sidekick-shared 0.28.2 → 0.29.0

package/dist/esm/quotaSnapshots.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { getConfigDir } from './paths';
 import { atomicWriteJsonSync, withFileLockSync } from './writers/atomic';
-import { classifyQuotaFreshness } from './quota';
+import { classifyQuotaFreshness, extraQuotaRows } from './quota';
 import { isAggregateCodexLimit } from './types/codex';
 function getQuotaSnapshotPath() {
     return path.join(getConfigDir(), 'quota-snapshots.json');
@@ -46,6 +46,27 @@ function windowResetMs(value) {
     const ms = Date.parse(value);
     return Number.isFinite(ms) ? ms : 0;
 }
+/**
+ * Rank two samples by one window's reset time. A later reset means a newer
+ * window, so it wins — except that an existing window which had already reset
+ * by the time the newer sample was captured is obsolete and always yields.
+ * Without that exception a pre-reset sample outranks every later sample whose
+ * window has not started yet (empty reset), and the snapshot freezes.
+ * Returns `undefined` when the reset times tie.
+ */
+function compareWindowResets(existing, next, asOfMs) {
+    const existingReset = windowResetMs(existing.resetsAt);
+    const nextReset = windowResetMs(next.resetsAt);
+    if (existingReset === nextReset)
+        return undefined;
+    if (existingReset > 0 && asOfMs > 0 && existingReset <= asOfMs)
+        return false;
+    return existingReset > nextReset;
+}
+function windowPresenceChanged(existing, next) {
+    return (Boolean(existing.fiveHour.absent) !== Boolean(next.fiveHour.absent) ||
+        Boolean(existing.sevenDay.absent) !== Boolean(next.sevenDay.absent));
+}
 // Preserve the best-known same-window snapshot while still allowing lower
 // utilization after Codex advances to a newer reset window.
 function shouldKeepExistingSnapshot(existing, next) {
@@ -58,20 +79,50 @@ function shouldKeepExistingSnapshot(existing, next) {
     const nextAggregate = isAggregateCodexLimit(next.limitId);
     if (existingAggregate !== nextAggregate)
         return existingAggregate;
-    const existingPrimaryReset = windowResetMs(existing.fiveHour.resetsAt);
-    const nextPrimaryReset = windowResetMs(next.fiveHour.resetsAt);
-    if (existingPrimaryReset !== nextPrimaryReset)
-        return existingPrimaryReset > nextPrimaryReset;
-    const existingSecondaryReset = windowResetMs(existing.sevenDay.resetsAt);
-    const nextSecondaryReset = windowResetMs(next.sevenDay.resetsAt);
-    if (existingSecondaryReset !== nextSecondaryReset)
-        return existingSecondaryReset > nextSecondaryReset;
+    // The plan's window layout changed (a window appeared or disappeared): the
+    // reset times are not comparable, so the newer capture wins.
+    if (windowPresenceChanged(existing, next)) {
+        return snapshotTimeMs(existing) > snapshotTimeMs(next);
+    }
+    const asOfMs = snapshotTimeMs(next);
+    const primary = compareWindowResets(existing.fiveHour, next.fiveHour, asOfMs);
+    if (primary !== undefined)
+        return primary;
+    const secondary = compareWindowResets(existing.sevenDay, next.sevenDay, asOfMs);
+    if (secondary !== undefined)
+        return secondary;
     const existingUtilization = existing.fiveHour.utilization + existing.sevenDay.utilization;
     const nextUtilization = next.fiveHour.utilization + next.sevenDay.utilization;
     if (existingUtilization !== nextUtilization)
         return existingUtilization > nextUtilization;
     return snapshotTimeMs(existing) > snapshotTimeMs(next);
 }
+/**
+ * Status-line and history samples only know the two headline windows. Keep
+ * the plan label, extra usage, and still-running extra meters (e.g. a Fable
+ * weekly cap) an earlier API sample recorded, so a fresh status-line write
+ * does not erase them from every snapshot reader.
+ */
+function carryApiOnlyFields(existing, next) {
+    const merged = { ...next };
+    if (merged.planLabel === undefined && existing.planLabel !== undefined) {
+        merged.planLabel = existing.planLabel;
+    }
+    if (merged.planType === undefined && existing.planType !== undefined) {
+        merged.planType = existing.planType;
+    }
+    if (merged.extraUsage === undefined && existing.extraUsage !== undefined) {
+        merged.extraUsage = existing.extraUsage;
+    }
+    if (merged.limits === undefined && existing.limits !== undefined) {
+        const asOfMs = snapshotTimeMs(next);
+        // Headline meters duplicate the fresher windows on `next`; carry only the extras.
+        const running = extraQuotaRows(existing).filter((row) => windowResetMs(row.resetsAt) > asOfMs);
+        if (running.length > 0)
+            merged.limits = running;
+    }
+    return merged;
+}
 export function writeQuotaSnapshot(providerId, accountId, quota) {
     withSnapshotStoreLock(() => {
         const store = readStore();
@@ -93,7 +144,11 @@ export function writeQuotaSnapshot(providerId, accountId, quota) {
         };
         if (index >= 0 && shouldKeepExistingSnapshot(store.snapshots[index].quota, snapshot))
             return;
-        const record = { providerId, accountId, quota: snapshot };
+        const record = {
+            providerId,
+            accountId,
+            quota: existingQuota ? carryApiOnlyFields(existingQuota, snapshot) : snapshot,
+        };
         if (index >= 0)
             store.snapshots[index] = record;
         else

package/dist/esm/quotaThresholds.js

@@ -50,8 +50,13 @@ function evaluateWindow(window, quota, thresholds, previous) {
 export function evaluateQuotaThresholds(quota, config = DEFAULT_QUOTA_THRESHOLDS, memory = {}) {
     if (!quota.available)
         return { alerts: [], memory };
-    const fiveHour = evaluateWindow('fiveHour', quota.fiveHour, config.fiveHour, memory.fiveHour);
-    const sevenDay = evaluateWindow('sevenDay', quota.sevenDay, config.sevenDay, memory.sevenDay);
+    // A window the plan does not have (Ultra's missing five-hour limit) never alerts.
+    const fiveHour = quota.fiveHour.absent
+        ? { alert: null, memory: memory.fiveHour ?? { resetsAt: '', level: 0 } }
+        : evaluateWindow('fiveHour', quota.fiveHour, config.fiveHour, memory.fiveHour);
+    const sevenDay = quota.sevenDay.absent
+        ? { alert: null, memory: memory.sevenDay ?? { resetsAt: '', level: 0 } }
+        : evaluateWindow('sevenDay', quota.sevenDay, config.sevenDay, memory.sevenDay);
     return {
         alerts: [fiveHour.alert, sevenDay.alert].filter((alert) => alert !== null),
         memory: { fiveHour: fiveHour.memory, sevenDay: sevenDay.memory },

package/dist/esm/report/htmlReportGenerator.js

@@ -596,14 +596,51 @@ function renderContentBlock(block, includeThinking, includeToolDetail) {
             return '';
     }
 }
-function renderToolUse(block, includeDetail) {
+/** Prefix of the bookkeeping keys session parsers stash inside tool inputs. */
+const SIDEKICK_INPUT_KEY_PREFIX = '_sidekick';
+/**
+ * The tool's display identity and user-facing input. Entries built outside
+ * the canonical projection may still carry the parsers' `_sidekick*` keys in
+ * `toolInput`; those are hidden here and read as the raw identity.
+ */
+function toolDisplay(block) {
     const name = block.toolName || 'unknown';
+    const raw = block.toolInput;
+    let input = raw;
+    let rawToolName = block.rawToolName;
+    let mcpServerName = block.mcpServerName;
+    if (raw && Object.keys(raw).some((key) => key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))) {
+        const clean = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (!key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))
+                clean[key] = value;
+        }
+        input = clean;
+        if (!rawToolName && typeof raw._sidekickRawToolName === 'string') {
+            rawToolName = raw._sidekickRawToolName;
+        }
+        if (!mcpServerName && typeof raw._sidekickMcpServerName === 'string') {
+            mcpServerName = raw._sidekickMcpServerName;
+        }
+    }
+    const parts = [];
+    if (rawToolName && rawToolName.trim() && rawToolName !== name)
+        parts.push(rawToolName);
+    if (mcpServerName && mcpServerName.trim())
+        parts.push(`MCP: ${mcpServerName}`);
+    const hint = parts.length
+        ? ` <span class="tool-raw-name" style="color:var(--text-muted);font-size:11px">${escapeHtml(parts.join(' · '))}</span>`
+        : '';
+    return { name, hint, input };
+}
+function renderToolUse(block, includeDetail) {
+    const { name, hint, input } = toolDisplay(block);
     if (!includeDetail) {
-        return `<div class="tool-block" data-block-type="tool"><div style="padding:8px 12px;background:rgba(245,166,35,0.08);color:var(--accent-orange);font-family:monospace;font-size:13px;">${escapeHtml(name)}</div></div>`;
+        return `<div class="tool-block" data-block-type="tool"><div style="padding:8px 12px;background:rgba(245,166,35,0.08);color:var(--accent-orange);font-family:monospace;font-size:13px;">${escapeHtml(name)}${hint}</div></div>`;
     }
     let inputHtml = '';
-    if (block.toolInput && Object.keys(block.toolInput).length > 0) {
-        const inputJson = JSON.stringify(block.toolInput, null, 2);
+    if (input && Object.keys(input).length > 0) {
+        const inputJson = JSON.stringify(input, null, 2);
         const highlighted = highlightCodeBlock(inputJson, 'json');
         inputHtml = `<div class="tool-io">
     <div class="tool-label">Input</div>
@@ -611,7 +648,7 @@ function renderToolUse(block, includeDetail) {
   </div>`;
     }
     return `<details class="tool-block" data-block-type="tool">
-  <summary>${escapeHtml(name)}${block.toolUseId ? ` <span style="color:var(--text-muted);font-size:11px">${escapeHtml(block.toolUseId)}</span>` : ''}</summary>
+  <summary>${escapeHtml(name)}${hint}${block.toolUseId ? ` <span style="color:var(--text-muted);font-size:11px">${escapeHtml(block.toolUseId)}</span>` : ''}</summary>
   <div class="tool-content">
     ${inputHtml}
   </div>

package/dist/esm/report/transcriptParser.js

@@ -42,17 +42,19 @@ function toReportBlock(block) {
             return block.text ? [{ type: 'text', text: block.text }] : [];
         case 'thinking':
             return block.text ? [{ type: 'thinking', text: block.text }] : [];
-        case 'tool_use':
-            return [
-                {
-                    type: 'tool_use',
-                    toolName: block.toolName ?? 'unknown',
-                    toolInput: block.input && typeof block.input === 'object'
-                        ? block.input
-                        : {},
-                    toolUseId: block.toolUseId,
-                },
-            ];
+        case 'tool_use': {
+            const toolBlock = {
+                type: 'tool_use',
+                toolName: block.toolName ?? 'unknown',
+                toolInput: block.input && typeof block.input === 'object'
+                    ? block.input
+                    : {},
+                toolUseId: block.toolUseId,
+                ...(block.rawToolName ? { rawToolName: block.rawToolName } : {}),
+                ...(block.mcpServerName ? { mcpServerName: block.mcpServerName } : {}),
+            };
+            return [toolBlock];
+        }
         case 'tool_result':
             return [
                 {

package/dist/esm/schemas/index.js

@@ -17,9 +17,9 @@ export { tokenEstimateSchema } from './tokenEstimation';
 export { providerAuthenticationEvidenceSchema, providerFailureEvidenceSchema, providerRetryAfterSchema, providerFailureDiagnosisSchema, } from './providerFailure';
 export { transcriptSourceProvenanceSchema, canonicalTranscriptBlockSchema, canonicalToolCallSchema, canonicalTranscriptMessageSchema, canonicalSessionTranscriptSchema, } from './transcript';
 export { observationProvenanceV1Schema, observedAgentSessionV1Schema, observedValueV1Schema, pendingUserRequestV1Schema, providerCapabilitiesV1Schema, providerSessionAdapterV1Schema, sessionEvidenceRefV1Schema, } from './observedSessionV1';
-export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, codexResetCreditSchema, codexResetCreditsSnapshotSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './quota';
+export { quotaWindowSchema, quotaStateSchema, quotaLimitRowSchema, quotaExtraUsageSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, codexResetCreditSchema, codexResetCreditsSnapshotSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './quota';
 export { quotaHistoryRuntimeProviderSchema, quotaHistorySampleSchema, quotaHistoryDailyBucketSchema, } from './quotaHistory';
 export { activeProviderAccountStatusSchema, activeAccountStatusSchema } from './accountStatus';
 export { accountProviderIdSchema, accountManagerResultSchema, beginAccountLoginResultSchema, accountLoginStatusSchema, accountEntrySchema, savedAccountProfileSchema, listAllAccountsResultSchema, accountHealthStateSchema, accountHealthSourceSchema, accountHealthSidecarSchema, accountHealthSchema, accountViewSchema, runningProcessSchema, accountConsumerKindSchema, runningAccountConsumerSchema, switchAccountResultSchema, lastSwitchRecordSchema, providerSyncReportSchema, syncReportSchema, accountLaunchEnvSchema, } from './accountManager';
 export { assistantTurnEventSchema, assistantTurnEventTypeSchema, assistantTurnNarrationStepSchema, assistantTurnProcessSchema, assistantTurnProcessStepSchema, assistantTurnProjectionSchema, assistantTurnReasoningTimelineItemSchema, assistantTurnSubagentSchema, assistantTurnSubagentStatusSchema, assistantTurnTimelineItemSchema, assistantTurnToolGroupStepSchema, assistantTurnToolRefSchema, } from './assistantTurn';
-export { sidekickStateFileSchema, stateFileAccountSchema, stateFileBillingBlockSchema, stateFileContextSchema, stateFileQuotaSchema, stateFileQuotaWindowSchema, stateFileSessionSchema, stateFileWriterSchema, } from './stateFile';
+export { sidekickStateFileSchema, stateFileAccountSchema, stateFileBillingBlockSchema, stateFileContextSchema, stateFileQuotaSchema, stateFileQuotaWindowSchema, stateFileQuotaLimitSchema, stateFileSessionSchema, stateFileWriterSchema, } from './stateFile';

package/dist/esm/schemas/providerFailure.js

@@ -9,7 +9,7 @@
  */
 import { z } from 'zod';
 import { ACCOUNT_PROVIDER_IDS } from '../providerIds';
-import { PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, } from '../providerFailure';
+import { CODEX_ERROR_INFO_KINDS, PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, } from '../providerFailure';
 export const providerAuthenticationEvidenceSchema = z.object({
     credentialKind: z.enum(PROVIDER_CREDENTIAL_KINDS),
     state: z.enum(PROVIDER_AUTHENTICATION_STATES),
@@ -20,6 +20,7 @@ export const providerFailureEvidenceSchema = z.object({
     source: z.enum(PROVIDER_FAILURE_EVIDENCE_SOURCES),
     rule: z.enum(PROVIDER_FAILURE_CODES),
     checkedAt: z.string().optional(),
+    codexErrorInfo: z.enum(CODEX_ERROR_INFO_KINDS).optional(),
 });
 export const providerRetryAfterSchema = z.discriminatedUnion('kind', [
     z.object({ kind: z.literal('delay'), delayMs: z.number() }),
@@ -30,6 +31,7 @@ export const providerFailureDiagnosisSchema = z.object({
     credentialKind: z.enum(PROVIDER_CREDENTIAL_KINDS),
     diagnosis: z.enum(PROVIDER_FAILURE_CODES),
     recovery: z.enum(PROVIDER_RECOVERY_ACTIONS),
+    retryable: z.boolean().optional(),
     evidence: z.array(providerFailureEvidenceSchema),
     authentication: providerAuthenticationEvidenceSchema.optional(),
     httpStatus: z.number().optional(),

package/dist/esm/schemas/quota.js

@@ -14,6 +14,33 @@ import { QUOTA_PROVIDER_IDS, RUNTIME_QUOTA_PROVIDER_IDS } from '../providerIds';
 export const quotaWindowSchema = z.object({
     utilization: z.number(),
     resetsAt: z.string(),
+    absent: z.boolean().optional(),
+    windowMs: z.number().optional(),
+});
+// ── QuotaLimitRow / QuotaExtraUsage ──
+export const quotaLimitRowSchema = z.object({
+    kind: z.string(),
+    group: z.string(),
+    label: z.string(),
+    utilization: z.number(),
+    resetsAt: z.string(),
+    windowMs: z.number().optional(),
+    projected: z.number().optional(),
+    scopeModel: z.string().optional(),
+    scopeSurface: z.string().optional(),
+    severity: z.string().optional(),
+    isActive: z.boolean().optional(),
+    allowancePercentOfWeekly: z.number().optional(),
+    usedPercentOfWeekly: z.number().optional(),
+});
+export const quotaExtraUsageSchema = z.object({
+    enabled: z.boolean(),
+    monthlyLimit: z.number().nullable(),
+    usedCredits: z.number().nullable(),
+    utilization: z.number().nullable(),
+    currency: z.string().optional(),
+    decimalPlaces: z.number().optional(),
+    disabledReason: z.string().optional(),
 });
 // ── QuotaState ──
 export const quotaFailureKindSchema = z.enum([
@@ -74,7 +101,10 @@ export const quotaStateSchema = z.object({
     credits: z.unknown().optional(),
     resetCredits: codexResetCreditsSnapshotSchema.optional(),
     planType: z.string().optional(),
+    planLabel: z.string().optional(),
     rateLimitReachedType: z.string().optional(),
+    limits: z.array(quotaLimitRowSchema).optional(),
+    extraUsage: quotaExtraUsageSchema.optional(),
 });
 // ── PeakHoursState ──
 export const peakHoursStateSchema = z.object({

package/dist/esm/schemas/quotaHistory.js

@@ -21,8 +21,16 @@ export const quotaHistorySampleSchema = z.object({
     runtimeProvider: quotaHistoryRuntimeProviderSchema,
     providerId: z.string(),
     workspaceId: z.string(),
-    fiveHour: z.object({ utilization: z.number(), resetsAt: z.string() }),
-    sevenDay: z.object({ utilization: z.number(), resetsAt: z.string() }),
+    fiveHour: z.object({
+        utilization: z.number(),
+        resetsAt: z.string(),
+        absent: z.boolean().optional(),
+    }),
+    sevenDay: z.object({
+        utilization: z.number(),
+        resetsAt: z.string(),
+        absent: z.boolean().optional(),
+    }),
     available: z.boolean(),
     error: z.string().optional(),
     source: z.enum(['session', 'cache', 'api', 'statusline']).optional(),

package/dist/esm/schemas/stateFile.js

@@ -16,6 +16,13 @@ export const stateFileWriterSchema = z.enum([
 export const stateFileQuotaWindowSchema = z.object({
     utilization: z.number(),
     resetsAt: z.string(),
+    absent: z.boolean().optional(),
+});
+export const stateFileQuotaLimitSchema = z.object({
+    kind: z.string(),
+    label: z.string(),
+    utilization: z.number(),
+    resetsAt: z.string(),
 });
 export const stateFileQuotaSchema = z.object({
     fiveHour: stateFileQuotaWindowSchema,
@@ -25,6 +32,8 @@ export const stateFileQuotaSchema = z.object({
     capturedAt: z.string().nullable(),
     ageMs: z.number().nullable(),
     freshness: z.enum(['fresh', 'aging', 'stale']).nullable(),
+    planLabel: z.string().optional(),
+    extraLimits: z.array(stateFileQuotaLimitSchema).optional(),
 });
 export const stateFileAccountSchema = z.object({
     providerId: z.enum(['claude-code', 'codex']),

package/dist/esm/schemas/transcript.js

@@ -17,6 +17,8 @@ export const canonicalTranscriptBlockSchema = z.object({
     type: z.enum(['text', 'thinking', 'tool_use', 'tool_result', 'image', 'unknown']),
     text: z.string().optional(),
     toolName: z.string().optional(),
+    rawToolName: z.string().optional(),
+    mcpServerName: z.string().optional(),
     toolUseId: z.string().optional(),
     input: z.unknown().optional(),
     output: z.unknown().optional(),
@@ -28,6 +30,8 @@ export const canonicalTranscriptBlockSchema = z.object({
 export const canonicalToolCallSchema = z.object({
     id: z.string().optional(),
     name: z.string(),
+    rawToolName: z.string().optional(),
+    mcpServerName: z.string().optional(),
     timestamp: z.string(),
     input: z.unknown().optional(),
     output: z.unknown().optional(),

package/dist/esm/sessionPromptHistory.js

@@ -14,13 +14,13 @@
  * and replies or signals that belong to an out-of-scope prompt are dropped.
  */
 import * as fs from 'fs';
-import { DEFAULT_BOUNDS, compareStrings, emptyStats, listCandidates, resolveRoots, scanFile, } from './promptHistory';
+import { DEFAULT_BOUNDS, PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES, compareStrings, emptyStats, listCandidates, resolveRoots, scanFile, } from './promptHistory';
 import { createSessionRecordExtractor, } from './sessionPromptSignals';
 const DEFAULT_SESSION_BOUNDS = {
     maxSessions: 1000,
     maxSessionBytes: 256 * 1024 * 1024,
     maxTotalBytes: 256 * 1024 * 1024,
-    maxRecordBytes: DEFAULT_BOUNDS.maxRecordBytes,
+    maxRecordBytes: PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES,
     deadlineMs: 60_000,
 };
 const MAX_EXCLUSIONS = 1000;

package/dist/esm/stateFile.js

@@ -15,7 +15,7 @@
  */
 import * as fs from 'fs';
 import { getGlobalDataPath } from './paths';
-import { classifyQuotaFreshness } from './quota';
+import { classifyQuotaFreshness, extraQuotaRows } from './quota';
 import { atomicWriteJsonSync } from './writers/atomic';
 export const STATE_FILE_SCHEMA_VERSION = 1;
 export const STATE_FILE_NAME = 'state.json';
@@ -90,14 +90,29 @@ export function quotaToStateFile(quota, now = Date.now()) {
             freshness ??= classifyQuotaFreshness(ageMs);
         }
     }
+    const extraLimits = extraQuotaRows(quota).map((row) => ({
+        kind: row.kind,
+        label: row.label,
+        utilization: row.utilization,
+        resetsAt: row.resetsAt,
+    }));
     return {
-        fiveHour: { utilization: quota.fiveHour.utilization, resetsAt: quota.fiveHour.resetsAt },
-        sevenDay: { utilization: quota.sevenDay.utilization, resetsAt: quota.sevenDay.resetsAt },
+        fiveHour: stateFileWindow(quota.fiveHour),
+        sevenDay: stateFileWindow(quota.sevenDay),
         source: quota.source ?? null,
         capturedSource: quota.capturedSource ?? null,
         capturedAt: quota.capturedAt ?? null,
         ageMs,
         freshness,
+        ...(quota.planLabel ? { planLabel: quota.planLabel } : {}),
+        ...(extraLimits.length > 0 ? { extraLimits } : {}),
+    };
+}
+function stateFileWindow(window) {
+    return {
+        utilization: window.utilization,
+        resetsAt: window.resetsAt,
+        ...(window.absent ? { absent: true } : {}),
     };
 }
 /** Project a billing block onto the state-file shape (totals only). */

package/dist/esm/statusline/claudeStatuslinePayload.js

@@ -115,14 +115,26 @@ export function parseClaudeStatuslinePayload(text) {
         raw,
     };
 }
-function toWindow(live, fallback) {
+/**
+ * Claude Code leaves a window out of the document once its reset has passed,
+ * and always for a window the plan does not have (Ultra has no five-hour
+ * limit). A fallback is carried over only while it can still be current: an
+ * `absent` marker from an earlier API read, or a window that has not reset yet.
+ * An expired fallback would otherwise be re-saved as a fresh sample forever.
+ */
+function toWindow(live, fallback, nowMs) {
     if (live) {
         return {
             utilization: Math.max(0, live.usedPercentage),
             resetsAt: new Date(live.resetsAt * 1000).toISOString(),
         };
     }
-    return fallback ?? { utilization: 0, resetsAt: '' };
+    if (fallback?.absent)
+        return { utilization: 0, resetsAt: '', absent: true };
+    const fallbackResetMs = fallback ? Date.parse(fallback.resetsAt) : NaN;
+    if (fallback && Number.isFinite(fallbackResetMs) && fallbackResetMs > nowMs)
+        return fallback;
+    return { utilization: 0, resetsAt: '' };
 }
 /**
  * Build a `QuotaState` from the official rate-limit block. Returns `null`
@@ -137,8 +149,8 @@ export function quotaFromStatuslinePayload(payload, options = {}) {
     const now = options.now ?? new Date();
     const fallback = options.fallback ?? undefined;
     return {
-        fiveHour: toWindow(limits.fiveHour, fallback?.fiveHour),
-        sevenDay: toWindow(limits.sevenDay, fallback?.sevenDay),
+        fiveHour: toWindow(limits.fiveHour, fallback?.fiveHour, now.getTime()),
+        sevenDay: toWindow(limits.sevenDay, fallback?.sevenDay, now.getTime()),
         available: true,
         providerId: 'claude-code',
         source: 'statusline',

package/dist/esm/statusline/formatter.js

@@ -1,4 +1,4 @@
-import { FIVE_HOUR_WINDOW_MS, formatQuotaAge } from '../quota';
+import { FIVE_HOUR_WINDOW_MS, SEVEN_DAY_WINDOW_MS, formatQuotaAge, quotaWindowApplies, quotaWindowHasData, quotaWindowShortLabel, } from '../quota';
 import { estimateTimeToQuota } from './BurnRateCalculator';
 export function selectStatuslineAccount(input) {
     if (input.accounts.claude.present) {
@@ -23,6 +23,11 @@ export function selectStatuslineAccount(input) {
  * One-line status. Segments, in order, each omitted when unknown:
  * `acct:<label> · 5h 42% resets 14:00 · ~1h20m left · 7d 61% · (2h ago) · ctx 37% · $0.42 · cache 92%`
  *
+ * Plans without a five-hour window (Claude Ultra) lead with the weekly window
+ * instead: `acct:<label> · 7d 17% resets Fri 01:00 · ~2d3h left · …`. Window
+ * labels follow the reported window length, so a Codex weekly primary window
+ * reads `7d`, not `5h`.
+ *
  * The age segment appears only for cached quota older than five minutes, so
  * a snapshot from yesterday can no longer read like a live figure.
  */
@@ -37,20 +42,35 @@ export function formatStatusline(input) {
     if (!quota?.available) {
         return joinSegments([`acct:${account}`, 'quota unavailable', ...liveSegments]);
     }
-    const utilization = clampPercent(quota.fiveHour.utilization);
-    const reset = formatReset(quota.fiveHour.resetsAt, now);
-    const eta = estimateWindowEta(quota, now);
-    const segments = [`acct:${account}`, `5h ${Math.round(utilization)}% resets ${reset}`];
+    const first = describeWindow(quota.fiveHour, '5h', FIVE_HOUR_WINDOW_MS);
+    const second = describeWindow(quota.sevenDay, '7d', SEVEN_DAY_WINDOW_MS);
+    // Lead with the first window whenever the plan has it (even idle); fall back
+    // to the second window when the first does not exist for this plan.
+    const leadWithFirst = quotaWindowApplies(quota.fiveHour) || !quotaWindowHasData(quota.sevenDay);
+    const lead = leadWithFirst ? first : second;
+    const segments = [`acct:${account}`, formatLeadSegment(lead, now)];
+    const eta = estimateWindowEta(lead, quota.capturedAt, now);
     if (eta != null)
         segments.push(`~${formatMinutes(eta)} left`);
-    if (quota.sevenDay.resetsAt && quota.sevenDay.utilization > 0) {
-        segments.push(`7d ${Math.round(clampPercent(quota.sevenDay.utilization))}%`);
+    if (leadWithFirst && quotaWindowHasData(quota.sevenDay) && quota.sevenDay.utilization > 0) {
+        segments.push(`${second.label} ${Math.round(clampPercent(quota.sevenDay.utilization))}%`);
     }
     if (quota.freshness && quota.freshness !== 'fresh') {
         segments.push(`(${formatQuotaAge(quota.ageMs)})`);
     }
     return joinSegments([...segments, ...liveSegments]);
 }
+function describeWindow(window, label, defaultMs) {
+    const windowMs = typeof window.windowMs === 'number' && Number.isFinite(window.windowMs) && window.windowMs > 0
+        ? window.windowMs
+        : defaultMs;
+    return { label: quotaWindowShortLabel(window.windowMs, label), window, windowMs };
+}
+function formatLeadSegment(lead, now) {
+    const percent = `${lead.label} ${Math.round(clampPercent(lead.window.utilization))}%`;
+    const reset = formatReset(lead.window.resetsAt, now);
+    return reset ? `${percent} resets ${reset}` : percent;
+}
 function formatLiveSegments(live) {
     if (!live)
         return [];
@@ -76,22 +96,25 @@ function formatCost(value) {
         return value.toFixed(1);
     return value.toFixed(2);
 }
-function estimateWindowEta(quota, now) {
-    const resetAt = Date.parse(quota.fiveHour.resetsAt);
+function estimateWindowEta(lead, capturedAtIso, now) {
+    const { window, windowMs } = lead;
+    if (window.absent)
+        return null;
+    const resetAt = Date.parse(window.resetsAt);
     if (!Number.isFinite(resetAt))
         return null;
     const nowMs = now.getTime();
     if (resetAt <= nowMs)
         return null;
-    const capturedAt = quota.capturedAt ? Date.parse(quota.capturedAt) : now.getTime();
+    const capturedAt = capturedAtIso ? Date.parse(capturedAtIso) : now.getTime();
     const sampleAt = Number.isFinite(capturedAt) ? capturedAt : now.getTime();
     if (sampleAt >= resetAt)
         return null;
-    const elapsedMinutes = (sampleAt - (resetAt - FIVE_HOUR_WINDOW_MS)) / 60_000;
-    if (elapsedMinutes <= 0 || quota.fiveHour.utilization <= 0)
+    const elapsedMinutes = (sampleAt - (resetAt - windowMs)) / 60_000;
+    if (elapsedMinutes <= 0 || window.utilization <= 0)
         return null;
-    const burnRate = quota.fiveHour.utilization / elapsedMinutes;
-    const eta = estimateTimeToQuota(quota.fiveHour.utilization, 100, burnRate);
+    const burnRate = window.utilization / elapsedMinutes;
+    const eta = estimateTimeToQuota(window.utilization, 100, burnRate);
     const minutesUntilReset = (resetAt - nowMs) / 60_000;
     return eta !== null && eta < minutesUntilReset ? eta : null;
 }
@@ -103,20 +126,36 @@ function compactLabel(value) {
 function clampPercent(value) {
     return Number.isFinite(value) ? Math.min(100, Math.max(0, value)) : 0;
 }
-function formatReset(value, fallback) {
+/**
+ * Reset time as `HH:MM`, or `Fri 01:00` when it is more than a day away.
+ * Returns '' for an empty or unparseable value — never the current time.
+ */
+function formatReset(value, now) {
+    if (!value)
+        return '';
     const reset = new Date(value);
-    const date = Number.isNaN(reset.getTime()) ? fallback : reset;
-    return new Intl.DateTimeFormat(undefined, {
+    if (Number.isNaN(reset.getTime()))
+        return '';
+    const time = new Intl.DateTimeFormat(undefined, {
         hour: '2-digit',
         minute: '2-digit',
         hour12: false,
-    }).format(date);
+    }).format(reset);
+    if (reset.getTime() - now.getTime() <= 86_400_000)
+        return time;
+    const weekday = new Intl.DateTimeFormat(undefined, { weekday: 'short' }).format(reset);
+    return `${weekday} ${time}`;
 }
 function formatMinutes(value) {
     const minutes = Math.max(0, Math.round(value));
     if (minutes < 60)
         return `${minutes}min`;
     const hours = Math.floor(minutes / 60);
+    if (hours >= 48) {
+        const days = Math.floor(hours / 24);
+        const remainderHours = hours % 24;
+        return remainderHours ? `${days}d${remainderHours}h` : `${days}d`;
+    }
     const remainder = minutes % 60;
     return remainder ? `${hours}h${remainder}m` : `${hours}h`;
 }

package/dist/esm/statusline/index.js

@@ -1,7 +1,7 @@
 export { getActiveAccountStatus } from '../accountStatus';
 export { readQuotaSnapshot, writeQuotaSnapshot } from '../quotaSnapshots';
-export { appendQuotaHistorySample, getWorkspaceIdFromPath } from '../quotaHistory';
-export { classifyQuotaFreshness, formatQuotaAge } from '../quota';
+export { appendQuotaHistorySample, getWorkspaceIdFromPath, quotaHistoryWindow, } from '../quotaHistory';
+export { classifyQuotaFreshness, formatQuotaAge, quotaWindowApplies, quotaWindowHasData, quotaWindowShortLabel, } from '../quota';
 export { BurnRateCalculator, estimateTimeToQuota } from './BurnRateCalculator';
 export { formatStatusline, selectStatuslineAccount } from './formatter';
 export { parseClaudeStatuslinePayload, quotaFromStatuslinePayload, } from './claudeStatuslinePayload';

package/dist/esm/statusline/payload.js

@@ -0,0 +1,9 @@
+/**
+ * `sidekick-shared/statusline/payload` — the pure Claude Code status-line
+ * stdin parser on its own, for hosts with a tight bundle budget that render
+ * their own line. Loads no account, credential, quota-snapshot, or network
+ * code (the full `sidekick-shared/statusline` entry does).
+ *
+ * @module statusline/payload
+ */
+export { parseClaudeStatuslinePayload, quotaFromStatuslinePayload, } from './claudeStatuslinePayload';