sidekick-shared 0.24.5 → 0.26.0

package/dist/stateFile.d.ts

@@ -0,0 +1,113 @@
+/**
+ * `state.json`: a small, versioned file for external consumers (tmux
+ * status bars, menu-bar apps, scripts) that want Sidekick's current account,
+ * quota windows with freshness, context usage, session cost, and the active
+ * billing block without running a Sidekick command.
+ *
+ * Written by the status line on every prompt and by both dashboards on their
+ * refresh ticks, but only when the content changed, so the hot path costs one
+ * small read in the common case. The schema is public: `schemaVersion` is 1,
+ * fields are only ever added, and the matching zod schema lives in
+ * `sidekick-shared/schemas` (`sidekickStateFileSchema`). This module does not
+ * import zod, so the status-line fast path stays small.
+ *
+ * @module stateFile
+ */
+import type { QuotaState } from './quota';
+import type { BillingBlock } from './usage/billingBlocks';
+export declare const STATE_FILE_SCHEMA_VERSION = 1;
+export declare const STATE_FILE_NAME = "state.json";
+export type StateFileWriter = 'statusline' | 'cli-dashboard' | 'vscode-dashboard';
+export interface StateFileQuotaWindow {
+    /** Utilization percentage (0–100). */
+    utilization: number;
+    /** ISO timestamp when the window resets; empty when unknown. */
+    resetsAt: string;
+}
+export interface StateFileQuota {
+    fiveHour: StateFileQuotaWindow;
+    sevenDay: StateFileQuotaWindow;
+    /** How the sample was obtained (`cache` when read back from the snapshot store). */
+    source: 'api' | 'session' | 'cache' | 'statusline' | null;
+    /** Original origin of a cached sample. */
+    capturedSource: 'api' | 'session' | 'statusline' | null;
+    capturedAt: string | null;
+    ageMs: number | null;
+    freshness: 'fresh' | 'aging' | 'stale' | null;
+}
+export interface StateFileAccount {
+    providerId: 'claude-code' | 'codex';
+    /** Sidekick registry id used to key quota snapshots and history. */
+    id: string | null;
+    label: string | null;
+}
+export interface StateFileContext {
+    usedPercentage: number | null;
+    contextWindowSize: number | null;
+    totalInputTokens: number | null;
+    totalOutputTokens: number | null;
+}
+export interface StateFileSession {
+    sessionId: string | null;
+    cwd: string | null;
+    model: string | null;
+    costUsd: number | null;
+    durationMs: number | null;
+    linesAdded: number | null;
+    linesRemoved: number | null;
+    /** Prompt-cache hit ratio (0–1) when the provider reports it. */
+    promptCacheHitRatio: number | null;
+}
+export interface StateFileBillingBlock {
+    start: string;
+    end: string;
+    isActive: boolean;
+    /** Cache-inclusive tokens so far. */
+    tokens: number;
+    costUsd: number;
+    costProvenance: 'reported' | 'estimated' | 'mixed' | 'unpriced' | 'none';
+    burnRatePerMinute: number;
+    projectedTokens: number;
+    projectedCostUsd: number;
+    remainingMs: number;
+}
+export interface SidekickStateFile {
+    schemaVersion: typeof STATE_FILE_SCHEMA_VERSION;
+    /** ISO timestamp of the write. Excluded from the unchanged comparison. */
+    writtenAt: string;
+    writer: StateFileWriter;
+    account: StateFileAccount | null;
+    quota: {
+        claude: StateFileQuota | null;
+        codex: StateFileQuota | null;
+    };
+    context: StateFileContext | null;
+    session: StateFileSession | null;
+    /** Active five-hour block (local estimate); null when unknown or not computed by the writer. */
+    billingBlock: StateFileBillingBlock | null;
+}
+/** Everything but the fields the writer stamps itself. */
+export type SidekickStateInput = Omit<SidekickStateFile, 'schemaVersion' | 'writtenAt'>;
+export interface WriteStateFileOptions {
+    /** Defaults to `<configDir>/state.json`. */
+    filePath?: string;
+    /** Clock for `writtenAt` (default `new Date()`). */
+    now?: Date;
+}
+export declare function getStateFilePath(): string;
+/** Read the current state file; null when absent or unreadable. */
+export declare function readStateFile(filePath?: string): SidekickStateFile | null;
+/**
+ * Write the state file atomically, but only when something other than
+ * `writtenAt` changed since the last write. Returns true when a write
+ * happened. Never throws: the state file is a convenience for other tools.
+ */
+export declare function writeStateFile(state: SidekickStateInput, options?: WriteStateFileOptions): boolean;
+/**
+ * Project a quota sample onto the state-file shape. A live sample (for
+ * example from the status-line payload) carries `capturedAt` but no age, so
+ * the age and freshness are derived from `now` when the sample omits them.
+ */
+export declare function quotaToStateFile(quota: QuotaState | null | undefined, now?: number): StateFileQuota | null;
+/** Project a billing block onto the state-file shape (totals only). */
+export declare function billingBlockToStateFile(block: BillingBlock | null | undefined): StateFileBillingBlock | null;

package/dist/stateFile.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * `state.json`: a small, versioned file for external consumers (tmux
+ * status bars, menu-bar apps, scripts) that want Sidekick's current account,
+ * quota windows with freshness, context usage, session cost, and the active
+ * billing block without running a Sidekick command.
+ *
+ * Written by the status line on every prompt and by both dashboards on their
+ * refresh ticks, but only when the content changed, so the hot path costs one
+ * small read in the common case. The schema is public: `schemaVersion` is 1,
+ * fields are only ever added, and the matching zod schema lives in
+ * `sidekick-shared/schemas` (`sidekickStateFileSchema`). This module does not
+ * import zod, so the status-line fast path stays small.
+ *
+ * @module stateFile
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_FILE_NAME = exports.STATE_FILE_SCHEMA_VERSION = void 0;
+exports.getStateFilePath = getStateFilePath;
+exports.readStateFile = readStateFile;
+exports.writeStateFile = writeStateFile;
+exports.quotaToStateFile = quotaToStateFile;
+exports.billingBlockToStateFile = billingBlockToStateFile;
+const fs = __importStar(require("fs"));
+const paths_1 = require("./paths");
+const quota_1 = require("./quota");
+const atomic_1 = require("./writers/atomic");
+exports.STATE_FILE_SCHEMA_VERSION = 1;
+exports.STATE_FILE_NAME = 'state.json';
+function getStateFilePath() {
+    return (0, paths_1.getGlobalDataPath)(exports.STATE_FILE_NAME);
+}
+/** Read the current state file; null when absent or unreadable. */
+function readStateFile(filePath = getStateFilePath()) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return parsed && parsed.schemaVersion === exports.STATE_FILE_SCHEMA_VERSION ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Key-order-independent serialisation, dropping undefined values. */
+function stableStringify(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    if (value && typeof value === 'object') {
+        const record = value;
+        const entries = Object.keys(record)
+            .sort()
+            .filter((key) => record[key] !== undefined)
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`);
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}
+/** The content that decides whether a rewrite is needed: everything the writer does not stamp. */
+function comparable(state) {
+    return stableStringify({ ...state, schemaVersion: undefined, writtenAt: undefined });
+}
+/**
+ * Write the state file atomically, but only when something other than
+ * `writtenAt` changed since the last write. Returns true when a write
+ * happened. Never throws: the state file is a convenience for other tools.
+ */
+function writeStateFile(state, options = {}) {
+    const filePath = options.filePath ?? getStateFilePath();
+    try {
+        const existing = readStateFile(filePath);
+        if (existing && comparable(existing) === comparable(state))
+            return false;
+        const next = {
+            schemaVersion: exports.STATE_FILE_SCHEMA_VERSION,
+            writtenAt: (options.now ?? new Date()).toISOString(),
+            ...state,
+        };
+        (0, atomic_1.atomicWriteJsonSync)(filePath, next);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Project a quota sample onto the state-file shape. A live sample (for
+ * example from the status-line payload) carries `capturedAt` but no age, so
+ * the age and freshness are derived from `now` when the sample omits them.
+ */
+function quotaToStateFile(quota, now = Date.now()) {
+    if (!quota || !quota.available)
+        return null;
+    let ageMs = typeof quota.ageMs === 'number' ? quota.ageMs : null;
+    let freshness = quota.freshness ?? null;
+    if (ageMs === null && quota.capturedAt) {
+        const capturedMs = Date.parse(quota.capturedAt);
+        if (Number.isFinite(capturedMs)) {
+            ageMs = Math.max(0, now - capturedMs);
+            freshness ??= (0, quota_1.classifyQuotaFreshness)(ageMs);
+        }
+    }
+    return {
+        fiveHour: { utilization: quota.fiveHour.utilization, resetsAt: quota.fiveHour.resetsAt },
+        sevenDay: { utilization: quota.sevenDay.utilization, resetsAt: quota.sevenDay.resetsAt },
+        source: quota.source ?? null,
+        capturedSource: quota.capturedSource ?? null,
+        capturedAt: quota.capturedAt ?? null,
+        ageMs,
+        freshness,
+    };
+}
+/** Project a billing block onto the state-file shape (totals only). */
+function billingBlockToStateFile(block) {
+    if (!block)
+        return null;
+    return {
+        start: block.start,
+        end: block.end,
+        isActive: block.isActive,
+        tokens: block.tokens.total,
+        costUsd: block.costUsd,
+        costProvenance: block.costProvenance,
+        burnRatePerMinute: block.burnRatePerMinute,
+        projectedTokens: block.projectedTokens,
+        projectedCostUsd: block.projectedCostUsd,
+        remainingMs: block.remainingMs,
+    };
+}

package/dist/statusline/claudeStatuslinePayload.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Parser for the JSON Claude Code pipes to its status-line command.
+ *
+ * Claude Code runs the configured `statusLine.command` after every response
+ * (debounced at 300 ms) with a JSON document on stdin describing the session:
+ * model, workspace, context-window usage, estimated session cost, and — for
+ * Claude.ai Pro and Max subscribers — the *official* five-hour and seven-day
+ * rate-limit windows. That last block is the same data `/usage` shows and
+ * needs no network call, so Sidekick treats it as its most authoritative
+ * quota source whenever the status line is installed.
+ *
+ * Only the fields Sidekick reads are typed here; the raw document is kept on
+ * `raw` for callers that need more. Browser-safe: no Node imports.
+ *
+ * @module statusline/claudeStatuslinePayload
+ */
+import type { QuotaState } from '../quota';
+/** One official rate-limit window. */
+export interface ClaudeStatuslineRateLimitWindow {
+    /** Percentage of the window consumed, 0–100 (spend limits may exceed 100). */
+    usedPercentage: number;
+    /** Unix epoch seconds when the window resets. */
+    resetsAt: number;
+}
+export interface ClaudeStatuslinePayload {
+    sessionId?: string;
+    transcriptPath?: string;
+    cwd?: string;
+    model?: {
+        id?: string;
+        displayName?: string;
+    };
+    workspace?: {
+        currentDir?: string;
+        projectDir?: string;
+        gitWorktree?: string;
+    };
+    contextWindow?: {
+        usedPercentage?: number | null;
+        remainingPercentage?: number | null;
+        contextWindowSize?: number;
+        totalInputTokens?: number;
+        totalOutputTokens?: number;
+    };
+    cost?: {
+        totalCostUsd?: number;
+        totalDurationMs?: number;
+        totalApiDurationMs?: number;
+        totalLinesAdded?: number;
+        totalLinesRemoved?: number;
+    };
+    rateLimits?: {
+        fiveHour?: ClaudeStatuslineRateLimitWindow;
+        sevenDay?: ClaudeStatuslineRateLimitWindow;
+        spendLimit?: ClaudeStatuslineRateLimitWindow;
+    };
+    promptCache?: {
+        warm?: boolean;
+        cachingObserved?: boolean;
+        hitRatio?: number | null;
+        requests?: number;
+        misses?: number;
+        expectedRebuilds?: number;
+    };
+    /** The parsed document as received. */
+    raw: Record<string, unknown>;
+}
+/**
+ * Parse a status-line document. Returns `null` for empty input, non-JSON, or
+ * JSON that is not an object; never throws.
+ */
+export declare function parseClaudeStatuslinePayload(text: string): ClaudeStatuslinePayload | null;
+export interface QuotaFromStatuslineOptions {
+    /** Capture time; defaults to now. */
+    now?: Date;
+    /**
+     * A previously known quota (typically the persisted snapshot). Windows the
+     * payload omits are carried over from it, since Claude Code drops a window
+     * from the document once its reset time has passed.
+     */
+    fallback?: QuotaState | null;
+}
+/**
+ * Build a `QuotaState` from the official rate-limit block. Returns `null`
+ * when the payload carries no rate limits at all (API-key users, or before
+ * the first response of a session), so callers fall back to their other
+ * sources.
+ */
+export declare function quotaFromStatuslinePayload(payload: ClaudeStatuslinePayload, options?: QuotaFromStatuslineOptions): QuotaState | null;

package/dist/statusline/claudeStatuslinePayload.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Parser for the JSON Claude Code pipes to its status-line command.
+ *
+ * Claude Code runs the configured `statusLine.command` after every response
+ * (debounced at 300 ms) with a JSON document on stdin describing the session:
+ * model, workspace, context-window usage, estimated session cost, and — for
+ * Claude.ai Pro and Max subscribers — the *official* five-hour and seven-day
+ * rate-limit windows. That last block is the same data `/usage` shows and
+ * needs no network call, so Sidekick treats it as its most authoritative
+ * quota source whenever the status line is installed.
+ *
+ * Only the fields Sidekick reads are typed here; the raw document is kept on
+ * `raw` for callers that need more. Browser-safe: no Node imports.
+ *
+ * @module statusline/claudeStatuslinePayload
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClaudeStatuslinePayload = parseClaudeStatuslinePayload;
+exports.quotaFromStatuslinePayload = quotaFromStatuslinePayload;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function nullableNum(value) {
+    if (value === null)
+        return null;
+    return num(value);
+}
+function str(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function bool(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function window(value) {
+    if (!isRecord(value))
+        return undefined;
+    const usedPercentage = num(value.used_percentage);
+    const resetsAt = num(value.resets_at);
+    if (usedPercentage === undefined || resetsAt === undefined)
+        return undefined;
+    return { usedPercentage, resetsAt };
+}
+function defined(value) {
+    return Object.values(value).some((entry) => entry !== undefined) ? value : undefined;
+}
+/**
+ * Parse a status-line document. Returns `null` for empty input, non-JSON, or
+ * JSON that is not an object; never throws.
+ */
+function parseClaudeStatuslinePayload(text) {
+    if (typeof text !== 'string' || !text.trim())
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(raw))
+        return null;
+    const model = isRecord(raw.model) ? raw.model : undefined;
+    const workspace = isRecord(raw.workspace) ? raw.workspace : undefined;
+    const contextWindow = isRecord(raw.context_window) ? raw.context_window : undefined;
+    const cost = isRecord(raw.cost) ? raw.cost : undefined;
+    const rateLimits = isRecord(raw.rate_limits) ? raw.rate_limits : undefined;
+    const promptCache = isRecord(raw.prompt_cache) ? raw.prompt_cache : undefined;
+    return {
+        sessionId: str(raw.session_id),
+        transcriptPath: str(raw.transcript_path),
+        cwd: str(raw.cwd),
+        model: model ? defined({ id: str(model.id), displayName: str(model.display_name) }) : undefined,
+        workspace: workspace
+            ? defined({
+                currentDir: str(workspace.current_dir),
+                projectDir: str(workspace.project_dir),
+                gitWorktree: str(workspace.git_worktree),
+            })
+            : undefined,
+        contextWindow: contextWindow
+            ? defined({
+                usedPercentage: nullableNum(contextWindow.used_percentage),
+                remainingPercentage: nullableNum(contextWindow.remaining_percentage),
+                contextWindowSize: num(contextWindow.context_window_size),
+                totalInputTokens: num(contextWindow.total_input_tokens),
+                totalOutputTokens: num(contextWindow.total_output_tokens),
+            })
+            : undefined,
+        cost: cost
+            ? defined({
+                totalCostUsd: num(cost.total_cost_usd),
+                totalDurationMs: num(cost.total_duration_ms),
+                totalApiDurationMs: num(cost.total_api_duration_ms),
+                totalLinesAdded: num(cost.total_lines_added),
+                totalLinesRemoved: num(cost.total_lines_removed),
+            })
+            : undefined,
+        rateLimits: rateLimits
+            ? defined({
+                fiveHour: window(rateLimits.five_hour),
+                sevenDay: window(rateLimits.seven_day),
+                spendLimit: window(rateLimits.spend_limit),
+            })
+            : undefined,
+        promptCache: promptCache
+            ? defined({
+                warm: bool(promptCache.warm),
+                cachingObserved: bool(promptCache.caching_observed),
+                hitRatio: nullableNum(promptCache.hit_ratio),
+                requests: num(promptCache.requests),
+                misses: num(promptCache.misses),
+                expectedRebuilds: num(promptCache.expected_rebuilds),
+            })
+            : undefined,
+        raw,
+    };
+}
+function toWindow(live, fallback) {
+    if (live) {
+        return {
+            utilization: Math.max(0, live.usedPercentage),
+            resetsAt: new Date(live.resetsAt * 1000).toISOString(),
+        };
+    }
+    return fallback ?? { utilization: 0, resetsAt: '' };
+}
+/**
+ * Build a `QuotaState` from the official rate-limit block. Returns `null`
+ * when the payload carries no rate limits at all (API-key users, or before
+ * the first response of a session), so callers fall back to their other
+ * sources.
+ */
+function quotaFromStatuslinePayload(payload, options = {}) {
+    const limits = payload.rateLimits;
+    if (!limits?.fiveHour && !limits?.sevenDay)
+        return null;
+    const now = options.now ?? new Date();
+    const fallback = options.fallback ?? undefined;
+    return {
+        fiveHour: toWindow(limits.fiveHour, fallback?.fiveHour),
+        sevenDay: toWindow(limits.sevenDay, fallback?.sevenDay),
+        available: true,
+        providerId: 'claude-code',
+        source: 'statusline',
+        capturedAt: now.toISOString(),
+        stale: false,
+    };
+}

package/dist/statusline/formatter.d.ts

@@ -1,9 +1,15 @@
 import type { ActiveAccountStatus } from '../accountStatus';
 import type { QuotaState } from '../quota';
+import type { ClaudeStatuslinePayload } from './claudeStatuslinePayload';
 export interface StatuslineInput {
     accounts: ActiveAccountStatus;
     claudeQuota?: QuotaState | null;
     codexQuota?: QuotaState | null;
+    /**
+     * The document Claude Code piped to the status-line command, when running
+     * as one. Adds context usage, session cost, and prompt-cache hit rate.
+     */
+    live?: ClaudeStatuslinePayload | null;
     now?: Date;
 }
 export interface StatuslineSelection {
@@ -13,4 +19,11 @@ export interface StatuslineSelection {
     quota: QuotaState | null;
 }
 export declare function selectStatuslineAccount(input: StatuslineInput): StatuslineSelection | null;
+/**
+ * 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%`
+ *
+ * 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.
+ */
 export declare function formatStatusline(input: StatuslineInput): string;

package/dist/statusline/formatter.js

@@ -23,20 +23,62 @@ function selectStatuslineAccount(input) {
     }
     return null;
 }
+/**
+ * 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%`
+ *
+ * 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.
+ */
 function formatStatusline(input) {
     const selected = selectStatuslineAccount(input);
+    const now = input.now ?? new Date();
+    const liveSegments = formatLiveSegments(input.live);
     if (!selected)
-        return 'acct:none · quota unavailable';
+        return joinSegments(['acct:none', 'quota unavailable', ...liveSegments]);
     const account = compactLabel(selected.accountLabel);
     const quota = selected.quota;
-    if (!quota?.available)
-        return `acct:${account} · quota unavailable`;
-    const now = input.now ?? new Date();
+    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 etaText = eta == null ? '' : ` · ~${formatMinutes(eta)} left`;
-    return `acct:${account} · 5h ${Math.round(utilization)}% resets ${reset}${etaText}`;
+    const segments = [`acct:${account}`, `5h ${Math.round(utilization)}% resets ${reset}`];
+    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 (quota.freshness && quota.freshness !== 'fresh') {
+        segments.push(`(${(0, quota_1.formatQuotaAge)(quota.ageMs)})`);
+    }
+    return joinSegments([...segments, ...liveSegments]);
+}
+function formatLiveSegments(live) {
+    if (!live)
+        return [];
+    const segments = [];
+    const context = live.contextWindow?.usedPercentage;
+    if (typeof context === 'number')
+        segments.push(`ctx ${Math.round(clampPercent(context))}%`);
+    const cost = live.cost?.totalCostUsd;
+    if (typeof cost === 'number' && cost > 0)
+        segments.push(`$${formatCost(cost)}`);
+    const hitRatio = live.promptCache?.hitRatio;
+    if (typeof hitRatio === 'number')
+        segments.push(`cache ${Math.round(clampPercent(hitRatio * 100))}%`);
+    return segments;
+}
+function joinSegments(segments) {
+    return segments.join(' · ');
+}
+function formatCost(value) {
+    if (value >= 100)
+        return value.toFixed(0);
+    if (value >= 10)
+        return value.toFixed(1);
+    return value.toFixed(2);
 }
 function estimateWindowEta(quota, now) {
     const resetAt = Date.parse(quota.fiveHour.resetsAt);

package/dist/statusline/index.d.ts

@@ -1,7 +1,15 @@
 export { getActiveAccountStatus } from '../accountStatus';
-export type { ActiveAccountStatus, ActiveProviderAccountStatus } from '../accountStatus';
-export { readQuotaSnapshot } from '../quotaSnapshots';
+export type { ActiveAccountStatus, ActiveAccountStatusOptions, ActiveProviderAccountStatus, } from '../accountStatus';
+export { readQuotaSnapshot, writeQuotaSnapshot } from '../quotaSnapshots';
 export type { QuotaSnapshotProviderId } from '../quotaSnapshots';
+export { appendQuotaHistorySample, getWorkspaceIdFromPath } from '../quotaHistory';
+export type { QuotaHistorySample } from '../quotaHistory';
+export { classifyQuotaFreshness, formatQuotaAge } from '../quota';
+export type { QuotaFreshness, QuotaState } from '../quota';
 export { BurnRateCalculator, estimateTimeToQuota } from './BurnRateCalculator';
 export { formatStatusline, selectStatuslineAccount } from './formatter';
 export type { StatuslineInput, StatuslineSelection } from './formatter';
+export { parseClaudeStatuslinePayload, quotaFromStatuslinePayload, } from './claudeStatuslinePayload';
+export type { ClaudeStatuslinePayload, ClaudeStatuslineRateLimitWindow, QuotaFromStatuslineOptions, } from './claudeStatuslinePayload';
+export { STATE_FILE_NAME, STATE_FILE_SCHEMA_VERSION, billingBlockToStateFile, getStateFilePath, quotaToStateFile, readStateFile, writeStateFile, } from '../stateFile';
+export type { SidekickStateFile, SidekickStateInput, StateFileAccount, StateFileBillingBlock, StateFileContext, StateFileQuota, StateFileQuotaWindow, StateFileSession, StateFileWriter, WriteStateFileOptions, } from '../stateFile';

package/dist/statusline/index.js

@@ -1,13 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectStatuslineAccount = exports.formatStatusline = exports.estimateTimeToQuota = exports.BurnRateCalculator = exports.readQuotaSnapshot = exports.getActiveAccountStatus = void 0;
+exports.writeStateFile = exports.readStateFile = exports.quotaToStateFile = exports.getStateFilePath = exports.billingBlockToStateFile = exports.STATE_FILE_SCHEMA_VERSION = exports.STATE_FILE_NAME = exports.quotaFromStatuslinePayload = exports.parseClaudeStatuslinePayload = exports.selectStatuslineAccount = exports.formatStatusline = exports.estimateTimeToQuota = exports.BurnRateCalculator = exports.formatQuotaAge = exports.classifyQuotaFreshness = exports.getWorkspaceIdFromPath = exports.appendQuotaHistorySample = exports.writeQuotaSnapshot = exports.readQuotaSnapshot = exports.getActiveAccountStatus = void 0;
 var accountStatus_1 = require("../accountStatus");
 Object.defineProperty(exports, "getActiveAccountStatus", { enumerable: true, get: function () { return accountStatus_1.getActiveAccountStatus; } });
 var quotaSnapshots_1 = require("../quotaSnapshots");
 Object.defineProperty(exports, "readQuotaSnapshot", { enumerable: true, get: function () { return quotaSnapshots_1.readQuotaSnapshot; } });
+Object.defineProperty(exports, "writeQuotaSnapshot", { enumerable: true, get: function () { return quotaSnapshots_1.writeQuotaSnapshot; } });
+var quotaHistory_1 = require("../quotaHistory");
+Object.defineProperty(exports, "appendQuotaHistorySample", { enumerable: true, get: function () { return quotaHistory_1.appendQuotaHistorySample; } });
+Object.defineProperty(exports, "getWorkspaceIdFromPath", { enumerable: true, get: function () { return quotaHistory_1.getWorkspaceIdFromPath; } });
+var quota_1 = require("../quota");
+Object.defineProperty(exports, "classifyQuotaFreshness", { enumerable: true, get: function () { return quota_1.classifyQuotaFreshness; } });
+Object.defineProperty(exports, "formatQuotaAge", { enumerable: true, get: function () { return quota_1.formatQuotaAge; } });
 var BurnRateCalculator_1 = require("./BurnRateCalculator");
 Object.defineProperty(exports, "BurnRateCalculator", { enumerable: true, get: function () { return BurnRateCalculator_1.BurnRateCalculator; } });
 Object.defineProperty(exports, "estimateTimeToQuota", { enumerable: true, get: function () { return BurnRateCalculator_1.estimateTimeToQuota; } });
 var formatter_1 = require("./formatter");
 Object.defineProperty(exports, "formatStatusline", { enumerable: true, get: function () { return formatter_1.formatStatusline; } });
 Object.defineProperty(exports, "selectStatuslineAccount", { enumerable: true, get: function () { return formatter_1.selectStatuslineAccount; } });
+var claudeStatuslinePayload_1 = require("./claudeStatuslinePayload");
+Object.defineProperty(exports, "parseClaudeStatuslinePayload", { enumerable: true, get: function () { return claudeStatuslinePayload_1.parseClaudeStatuslinePayload; } });
+Object.defineProperty(exports, "quotaFromStatuslinePayload", { enumerable: true, get: function () { return claudeStatuslinePayload_1.quotaFromStatuslinePayload; } });
+var stateFile_1 = require("../stateFile");
+Object.defineProperty(exports, "STATE_FILE_NAME", { enumerable: true, get: function () { return stateFile_1.STATE_FILE_NAME; } });
+Object.defineProperty(exports, "STATE_FILE_SCHEMA_VERSION", { enumerable: true, get: function () { return stateFile_1.STATE_FILE_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "billingBlockToStateFile", { enumerable: true, get: function () { return stateFile_1.billingBlockToStateFile; } });
+Object.defineProperty(exports, "getStateFilePath", { enumerable: true, get: function () { return stateFile_1.getStateFilePath; } });
+Object.defineProperty(exports, "quotaToStateFile", { enumerable: true, get: function () { return stateFile_1.quotaToStateFile; } });
+Object.defineProperty(exports, "readStateFile", { enumerable: true, get: function () { return stateFile_1.readStateFile; } });
+Object.defineProperty(exports, "writeStateFile", { enumerable: true, get: function () { return stateFile_1.writeStateFile; } });