codiedev 0.9.55 → 0.9.57

package/dist/codie.js

@@ -51,9 +51,14 @@ const child_process_1 = require("child_process");
 const url_1 = require("url");
 const configDir_1 = require("./configDir");
 const codieLauncher_1 = require("./codieLauncher");
+const codieBrandInstall_1 = require("./codieBrandInstall");
+const codieUsage_1 = require("./codieUsage");
 const codieRuntime_1 = require("./codieRuntime");
 const codieRuntimeInstall_1 = require("./codieRuntimeInstall");
 const upgradeNudge_1 = require("./upgradeNudge");
+// How long to let the gateway finish booking the last request before asking
+// what the session cost.
+const USAGE_SETTLE_MS = 1200;
 function git(args) {
     const result = (0, child_process_1.spawnSync)("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     return result.status === 0 ? result.stdout.trim() : "";
@@ -96,32 +101,6 @@ function assetPath(name) {
     // dist/codie.js → ../assets/<name>; src/codie.ts → ../assets/<name>.
     return path.join(__dirname, "..", "assets", name);
 }
-// Stage the home-screen branding plugin. TUI plugins only load from tui.json
-// in the OpenCode config dir, so the packaged file is copied next to the
-// capture plugin and referenced with a relative spec. Best-effort: any
-// failure (e.g. a hand-edited tui.json with comments) leaves the stock logo.
-function installBrandPlugin() {
-    try {
-        // OpenCode resolves its config dir per the XDG spec, so a customized
-        // XDG_CONFIG_HOME must be honored or tui.json lands where it never reads.
-        const configDir = path.join(process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), ".config"), "opencode");
-        const pluginDir = path.join(configDir, "plugins");
-        fs.mkdirSync(pluginDir, { recursive: true });
-        const source = fs.readFileSync(assetPath("tui-brand-plugin.tsx"), "utf8");
-        const destination = path.join(pluginDir, "codiedev-brand.tsx");
-        if (!fs.existsSync(destination) || fs.readFileSync(destination, "utf8") !== source) {
-            fs.writeFileSync(destination, source);
-        }
-        const tuiConfigPath = path.join(configDir, "tui.json");
-        const existing = fs.existsSync(tuiConfigPath) ? JSON.parse(fs.readFileSync(tuiConfigPath, "utf8")) : {};
-        const { config, changed } = (0, codieLauncher_1.withBrandPlugin)(existing);
-        if (changed)
-            fs.writeFileSync(tuiConfigPath, `${JSON.stringify(config, null, 2)}\n`);
-    }
-    catch (error) {
-        console.error(`codie: continuing without Codiedev branding (${error instanceof Error ? error.message : error})`);
-    }
-}
 // Remove the engine's boot/exit banner wordmark in place (see
 // patchBrandWordmark). Best-effort like the TUI plugin: any failure rolls the
 // bytes back and the stock banner keeps working. Runs once per install; an
@@ -214,7 +193,7 @@ async function main() {
     });
     const metadataPlugin = (0, url_1.pathToFileURL)(assetPath("opencode-plugin.mjs")).href;
     const capturePlugin = (0, codieLauncher_1.resolveCapturePlugin)({ homeDir: os.homedir(), existsSync: fs.existsSync });
-    installBrandPlugin();
+    (0, codieBrandInstall_1.installTuiPlugin)();
     installBrandWordmark(runtime);
     const config = (0, codieLauncher_1.buildCodieConfig)({
         existing: existingInlineConfig(),
@@ -232,6 +211,33 @@ async function main() {
         OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
     };
     const runtimeArgs = (0, codieLauncher_1.withCodieWorkingDirectory)(parsed.args, process.cwd());
+    const nonInteractiveRun = runtimeArgs[0] === "run";
+    if (nonInteractiveRun) {
+        // The TUI paints its own live status line from the same endpoint. A
+        // non-interactive run has no TUI, so the budget arrives as two printed
+        // lines instead — and only for a human at a terminal, so a scripted run
+        // is neither slowed nor polluted.
+        const reportCost = Boolean(process.stderr.isTTY);
+        const startedAt = Date.now();
+        if (reportCost) {
+            const line = (0, codieUsage_1.formatUsageLine)(await (0, codieUsage_1.fetchCodieUsage)({ baseUrl: gatewayUrl, key }));
+            if (line)
+                console.error(line);
+        }
+        const result = (0, child_process_1.spawnSync)(runtime, runtimeArgs, { stdio: "inherit", env });
+        if (result.error)
+            throw result.error;
+        process.exitCode = result.status === null ? 1 : result.status;
+        if (reportCost) {
+            // The gateway books a request's cost after it has answered, so a poll
+            // fired the instant the run closes can miss the last one.
+            await new Promise((resolve) => setTimeout(resolve, USAGE_SETTLE_MS));
+            const cost = (0, codieUsage_1.formatSessionCostLine)(await (0, codieUsage_1.fetchCodieUsage)({ baseUrl: gatewayUrl, key, sinceMs: startedAt }));
+            if (cost)
+                console.error(cost);
+        }
+        return;
+    }
     const result = (0, child_process_1.spawnSync)(runtime, runtimeArgs, { stdio: "inherit", env });
     if (result.error)
         throw result.error;

package/dist/codieBrandInstall.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The usage module this install should load. The shipped package has the
+ * compiled file; a source checkout (and the test run) has the TypeScript one.
+ * Naming a path that does not exist would cost the status line silently, so a
+ * miss raises instead and the caller falls back to the plain plugin.
+ */
+export declare function usageModulePath(): string;
+/** The engine resolves its config dir per the XDG spec, so a customized
+ * XDG_CONFIG_HOME must be honored or tui.json lands where it never reads. */
+export declare function openCodeConfigDir(): string;
+export declare function installTuiPlugin(): void;

package/dist/codieBrandInstall.js

@@ -0,0 +1,98 @@
+"use strict";
+// Stages the Codiedev TUI plugin into the engine's config directory.
+//
+// TUI plugins load only from tui.json in the OpenCode config dir, so the
+// packaged template is copied there and referenced by a relative spec. The
+// copy also carries the status line, which needs an absolute path back into
+// this package — the plugin sits outside it and cannot reach it any other way.
+//
+// Every step is best-effort: a developer who cannot write this directory still
+// gets a working harness, just the stock logo and no status line.
+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.usageModulePath = usageModulePath;
+exports.openCodeConfigDir = openCodeConfigDir;
+exports.installTuiPlugin = installTuiPlugin;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const codieLauncher_1 = require("./codieLauncher");
+function assetPath(name) {
+    // dist/codieBrandInstall.js → ../assets/<name>; src/… → ../assets/<name>.
+    return path.join(__dirname, "..", "assets", name);
+}
+/**
+ * The usage module this install should load. The shipped package has the
+ * compiled file; a source checkout (and the test run) has the TypeScript one.
+ * Naming a path that does not exist would cost the status line silently, so a
+ * miss raises instead and the caller falls back to the plain plugin.
+ */
+function usageModulePath() {
+    const candidates = [
+        path.join(__dirname, "codieUsage.js"),
+        path.join(__dirname, "codieUsage.ts"),
+    ];
+    const found = candidates.find((candidate) => fs.existsSync(candidate));
+    if (!found)
+        throw new Error("this install has no Codiedev usage module");
+    return found;
+}
+/** The engine resolves its config dir per the XDG spec, so a customized
+ * XDG_CONFIG_HOME must be honored or tui.json lands where it never reads. */
+function openCodeConfigDir() {
+    return path.join(process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), ".config"), "opencode");
+}
+function installTuiPlugin() {
+    try {
+        const configDir = openCodeConfigDir();
+        const pluginDir = path.join(configDir, "plugins");
+        fs.mkdirSync(pluginDir, { recursive: true });
+        const source = (0, codieLauncher_1.stageUsageModule)(fs.readFileSync(assetPath("tui-brand-plugin.tsx"), "utf8"), usageModulePath());
+        const destination = path.join(pluginDir, path.basename(codieLauncher_1.BRAND_PLUGIN_SPEC));
+        if (!fs.existsSync(destination) || fs.readFileSync(destination, "utf8") !== source) {
+            fs.writeFileSync(destination, source);
+        }
+        const tuiConfigPath = path.join(configDir, "tui.json");
+        const existing = fs.existsSync(tuiConfigPath)
+            ? JSON.parse(fs.readFileSync(tuiConfigPath, "utf8"))
+            : {};
+        const { config, changed } = (0, codieLauncher_1.withBrandPlugin)(existing);
+        if (changed)
+            fs.writeFileSync(tuiConfigPath, `${JSON.stringify(config, null, 2)}\n`);
+    }
+    catch (error) {
+        console.error(`codie: continuing without Codiedev branding (${error instanceof Error ? error.message : error})`);
+    }
+}

package/dist/codieLauncher.d.ts

@@ -1,7 +1,30 @@
+export interface ModelCost {
+    /** Dollars per million prompt tokens. */
+    input: number;
+    /** Dollars per million completion tokens. */
+    output: number;
+}
+export interface ModelLimit {
+    /** Maximum prompt tokens the model accepts. */
+    context: number;
+    /** Maximum completion tokens the model emits. */
+    output: number;
+}
 export interface CatalogModel {
     id: string;
     name?: string;
+    cost?: ModelCost;
+    limit?: ModelLimit;
 }
+/** A rate card is usable only when both sides are real, finite and not
+ * negative. Half a card prices a session wrong in a way nobody can see, so a
+ * partial one is dropped and the model stays unpriced. */
+export declare function usableModelCost(value: unknown): ModelCost | undefined;
+/** A context/output window is usable only when both sides are real, finite and
+ * positive. A partial window makes the engine's "% of context used" read wrong
+ * in a way nobody can see, so a partial one is dropped and the model keeps the
+ * engine's default. */
+export declare function usableModelLimit(value: unknown): ModelLimit | undefined;
 /**
  * Pin non-interactive runs to the directory where `codie` was launched.
  * OpenCode can reuse a previously-known project instance; without an explicit
@@ -17,6 +40,16 @@ export declare function buildCodieConfig({ existing, catalog, env, plugin, plugi
     plugin?: string;
     plugins?: string[];
 }): Record<string, any>;
+export declare const USAGE_MODULE_PLACEHOLDER = "__CODIEDEV_USAGE_MODULE__";
+/**
+ * Point the staged TUI plugin at this install's usage module.
+ *
+ * The plugin is copied into the engine's own config directory, so it cannot
+ * reach the package by a relative path — the absolute path is baked in at
+ * stage time. It goes in as a JSON literal so a Windows path keeps its
+ * backslashes instead of turning into escape sequences.
+ */
+export declare function stageUsageModule(source: string, modulePath: string): string;
 export declare const BRAND_PLUGIN_SPEC = "./plugins/codiedev-brand.tsx";
 export declare function withBrandPlugin(existing: Record<string, any> | undefined): {
     config: Record<string, any>;

package/dist/codieLauncher.js

@@ -42,10 +42,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HIDDEN_WORDMARK = exports.CODIEDEV_WORDMARK = exports.LEGACY_CODIEDEV_WORDMARK = exports.STOCK_WORDMARK = exports.BRAND_PLUGIN_SPEC = void 0;
+exports.HIDDEN_WORDMARK = exports.CODIEDEV_WORDMARK = exports.LEGACY_CODIEDEV_WORDMARK = exports.STOCK_WORDMARK = exports.BRAND_PLUGIN_SPEC = exports.USAGE_MODULE_PLACEHOLDER = void 0;
+exports.usableModelCost = usableModelCost;
+exports.usableModelLimit = usableModelLimit;
 exports.withCodieWorkingDirectory = withCodieWorkingDirectory;
 exports.bareModel = bareModel;
 exports.buildCodieConfig = buildCodieConfig;
+exports.stageUsageModule = stageUsageModule;
 exports.withBrandPlugin = withBrandPlugin;
 exports.patchBrandWordmark = patchBrandWordmark;
 exports.resolveCapturePlugin = resolveCapturePlugin;
@@ -62,6 +65,37 @@ const DEFAULT_NAMES = {
     "z-ai/glm-5.2": "GLM 5.2 · Fireworks ZDR",
     "moonshotai/kimi-k2.7-code": "Kimi K2.7 Code · Fireworks ZDR",
 };
+/** A rate card is usable only when both sides are real, finite and not
+ * negative. Half a card prices a session wrong in a way nobody can see, so a
+ * partial one is dropped and the model stays unpriced. */
+function usableModelCost(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const { input, output } = value;
+    if (typeof input !== "number" || typeof output !== "number")
+        return undefined;
+    if (!Number.isFinite(input) || !Number.isFinite(output))
+        return undefined;
+    if (input < 0 || output < 0)
+        return undefined;
+    return { input, output };
+}
+/** A context/output window is usable only when both sides are real, finite and
+ * positive. A partial window makes the engine's "% of context used" read wrong
+ * in a way nobody can see, so a partial one is dropped and the model keeps the
+ * engine's default. */
+function usableModelLimit(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const { context, output } = value;
+    if (typeof context !== "number" || typeof output !== "number")
+        return undefined;
+    if (!Number.isFinite(context) || !Number.isFinite(output))
+        return undefined;
+    if (context <= 0 || output <= 0)
+        return undefined;
+    return { context, output };
+}
 /**
  * Pin non-interactive runs to the directory where `codie` was launched.
  * OpenCode can reuse a previously-known project instance; without an explicit
@@ -121,10 +155,23 @@ function buildCodieConfig({ existing = {}, catalog, env = {}, plugin, plugins =
     const planModel = governedModel(requestedPlan, approved, fast, "Plan agent");
     const existingPlugins = Array.isArray(existing.plugin) ? existing.plugin : [];
     const requiredPlugins = [...plugins, plugin].filter(Boolean);
-    const models = Object.fromEntries(catalog.map((model) => [
-        bareModel(model.id),
-        { name: model.name || DEFAULT_NAMES[bareModel(model.id)] || bareModel(model.id) },
-    ]));
+    const models = Object.fromEntries(catalog.map((model) => {
+        // The engine prices a session from this rate card. Without it every
+        // model reads $0.00, which is how the harness came to show no spend at
+        // all. The gateway publishes prompt and completion prices only, so
+        // cached tokens are priced at zero here and the engine's session figure
+        // stays an estimate — the budget line from /me/usage is the true spend.
+        const cost = usableModelCost(model.cost);
+        const limit = usableModelLimit(model.limit);
+        return [
+            bareModel(model.id),
+            {
+                name: model.name || DEFAULT_NAMES[bareModel(model.id)] || bareModel(model.id),
+                ...(cost ? { cost: { ...cost, cache: { read: 0, write: 0 } } } : {}),
+                ...(limit ? { limit } : {}),
+            },
+        ];
+    }));
     return {
         ...existing,
         model: governedModel(primary, approved, first, "Primary agent"),
@@ -152,6 +199,21 @@ function buildCodieConfig({ existing = {}, catalog, env = {}, plugin, plugins =
         plugin: [...existingPlugins.filter((item) => !requiredPlugins.includes(item)), ...requiredPlugins],
     };
 }
+exports.USAGE_MODULE_PLACEHOLDER = "__CODIEDEV_USAGE_MODULE__";
+/**
+ * Point the staged TUI plugin at this install's usage module.
+ *
+ * The plugin is copied into the engine's own config directory, so it cannot
+ * reach the package by a relative path — the absolute path is baked in at
+ * stage time. It goes in as a JSON literal so a Windows path keeps its
+ * backslashes instead of turning into escape sequences.
+ */
+function stageUsageModule(source, modulePath) {
+    if (!source.includes(exports.USAGE_MODULE_PLACEHOLDER)) {
+        throw new Error(`plugin template is missing the ${exports.USAGE_MODULE_PLACEHOLDER} placeholder`);
+    }
+    return source.split(exports.USAGE_MODULE_PLACEHOLDER).join(JSON.stringify(modulePath));
+}
 exports.BRAND_PLUGIN_SPEC = "./plugins/codiedev-brand.tsx";
 // Pure merge for ~/.config/opencode/tui.json: TUI plugins load from tui.json,
 // not the opencode.json we inject via OPENCODE_CONFIG_CONTENT.
@@ -310,10 +372,16 @@ async function fetchApprovedCatalog({ baseUrl, key, fetchImpl = fetch, }) {
         if (!Array.isArray(payload?.data) || payload.data.length === 0) {
             throw new Error("model catalog is empty");
         }
-        return payload.data.map((model) => ({
-            id: bareModel(model.id),
-            name: typeof model.name === "string" && model.name ? model.name : DEFAULT_NAMES[bareModel(model.id)],
-        }));
+        return payload.data.map((model) => {
+            const cost = usableModelCost(model.cost);
+            const limit = usableModelLimit(model.limit);
+            return {
+                id: bareModel(model.id),
+                name: typeof model.name === "string" && model.name ? model.name : DEFAULT_NAMES[bareModel(model.id)],
+                ...(cost ? { cost } : {}),
+                ...(limit ? { limit } : {}),
+            };
+        });
     }
     finally {
         clearTimeout(timeout);

package/dist/codieUsage.d.ts

@@ -0,0 +1,57 @@
+export interface CodieUsageBudget {
+    companyBudgetUsd: number | null;
+    companySpentUsd: number;
+    companyHeldUsd: number;
+    userBudgetUsd: number | null;
+    userSpentUsd: number;
+    userHeldUsd: number;
+    keyBudgetUsd: number | null;
+    keySpentUsd: number;
+    keyHeldUsd: number | null;
+}
+export interface CodieUsageInFlight {
+    /** Reservations open inside the gateway's hold TTL: real work running now. */
+    requests: number;
+    heldUsd: number;
+    /** Reservations past the TTL, waiting for the sweep. They hold budget
+     * without doing work, so they are never counted as live work. */
+    staleRequests: number;
+    staleHeldUsd: number;
+}
+export interface CodieUsage {
+    enabled: boolean;
+    user: {
+        name: string;
+        email: string;
+        role: string;
+    } | null;
+    budget: CodieUsageBudget;
+    inFlight: CodieUsageInFlight;
+    since?: {
+        costUsd: number;
+        promptTokens: number;
+        completionTokens: number;
+        requests: number;
+    };
+}
+/**
+ * One line: who is spending, how much, against what, and what is running.
+ * Returns "" when there is nothing honest to say.
+ */
+export declare function formatUsageLine(usage: CodieUsage | null | undefined): string;
+/**
+ * What this session just cost. Returns "" when the session billed nothing,
+ * because a developer who spent nothing does not need to be told a number.
+ */
+export declare function formatSessionCostLine(usage: CodieUsage | null | undefined): string;
+/**
+ * Read the developer's budget snapshot. Returns null on any refusal, network
+ * failure, timeout, or malformed answer — a status poll is never worth an
+ * error in front of a developer who asked for none.
+ */
+export declare function fetchCodieUsage({ baseUrl, key, sinceMs, fetchImpl, }: {
+    baseUrl?: string;
+    key: string;
+    sinceMs?: number;
+    fetchImpl?: typeof fetch;
+}): Promise<CodieUsage | null>;

package/dist/codieUsage.js

@@ -0,0 +1,184 @@
+"use strict";
+// The Codie harness status line.
+//
+// The gateway already knows what a developer has spent, what caps them, and
+// what they have in flight. Nothing ever asked it. This module asks, and turns
+// the answer into one line the harness can paint next to the prompt.
+//
+// Every failure here is silent by design: a status poll must never interrupt,
+// delay, or break a coding session. No snapshot means no line.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatUsageLine = formatUsageLine;
+exports.formatSessionCostLine = formatSessionCostLine;
+exports.fetchCodieUsage = fetchCodieUsage;
+const USAGE_TIMEOUT_MS = 4000;
+function cleanBaseUrl(value) {
+    return String(value || "https://gateway.codiedev.com/api/v1").replace(/\/+$/, "");
+}
+function money(value) {
+    return `$${value.toFixed(2)}`;
+}
+/** Budgets are set in whole dollars far more often than not, so $150 reads
+ * better than $150.00 next to a spend figure that does need its cents. */
+function budgetMoney(value) {
+    return Number.isInteger(value) ? `$${value}` : money(value);
+}
+function percent(spent, budget) {
+    if (!(budget > 0))
+        return null;
+    const share = (spent / budget) * 100;
+    // A first request against a large budget rounds to 0%, which reads as
+    // "nothing spent". Say "under one percent" instead.
+    if (share > 0 && share < 1)
+        return "<1%";
+    return `${Math.round(share)}%`;
+}
+/**
+ * One line: who is spending, how much, against what, and what is running.
+ * Returns "" when there is nothing honest to say.
+ */
+function formatUsageLine(usage) {
+    if (!usage || !usage.enabled)
+        return "";
+    const { budget, inFlight } = usage;
+    const segments = [];
+    if (usage.user?.name)
+        segments.push(usage.user.name);
+    // The developer's own month-to-date spend is always the headline. Only the
+    // budget that actually caps them earns a percentage next to it.
+    if (typeof budget.userBudgetUsd === "number") {
+        segments.push(`${money(budget.userSpentUsd)} / ${budgetMoney(budget.userBudgetUsd)}`);
+        const share = percent(budget.userSpentUsd, budget.userBudgetUsd);
+        if (share)
+            segments.push(share);
+    }
+    else {
+        segments.push(money(budget.userSpentUsd));
+        if (typeof budget.companyBudgetUsd === "number") {
+            const share = percent(budget.companySpentUsd, budget.companyBudgetUsd);
+            // Labelled, because a team percentage beside a personal dollar figure
+            // otherwise reads as the developer's own share.
+            if (share)
+                segments.push(`team ${share}`);
+        }
+    }
+    if (inFlight.requests > 0)
+        segments.push(`${inFlight.requests} in flight`);
+    // Stale holds cap a budget while doing no work. Naming them is the
+    // difference between "I am blocked" and "I am blocked by nothing".
+    if (inFlight.staleHeldUsd > 0)
+        segments.push(`${money(inFlight.staleHeldUsd)} held stale`);
+    return segments.join(" · ");
+}
+function tokens(total) {
+    // Rounded by arithmetic, not toFixed: 2.55 is not exactly representable, so
+    // toFixed(1) rounds it down and the same count can read two ways.
+    if (total >= 1_000_000)
+        return `${Math.round(total / 100_000) / 10}M`;
+    if (total >= 1_000)
+        return `${Math.round(total / 1_000)}k`;
+    return String(total);
+}
+/**
+ * What this session just cost. Returns "" when the session billed nothing,
+ * because a developer who spent nothing does not need to be told a number.
+ */
+function formatSessionCostLine(usage) {
+    const since = readSince(usage?.since);
+    if (!since || since.requests <= 0)
+        return "";
+    // A real charge that rounds to $0.00 reads as free. Say it is under a cent
+    // instead — the month-to-date figure is where it really lands.
+    const cost = since.costUsd > 0 && since.costUsd < 0.005 ? "<$0.01" : money(since.costUsd);
+    const requests = `${since.requests} ${since.requests === 1 ? "request" : "requests"}`;
+    return `This session: ${cost} · ${requests} · ${tokens(since.promptTokens + since.completionTokens)} tokens`;
+}
+/**
+ * A usage window is reported only when every field of it is a real number.
+ * A partial block is worse than none: it reads as a cheap session, and the
+ * arithmetic on a missing field throws out of a call site whose whole
+ * contract is that it cannot break the run that just finished.
+ */
+function readSince(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const { costUsd, promptTokens, completionTokens, requests } = value;
+    const finite = (candidate) => typeof candidate === "number" && Number.isFinite(candidate);
+    if (!finite(costUsd) || !finite(promptTokens) || !finite(completionTokens) || !finite(requests)) {
+        return undefined;
+    }
+    return { costUsd, promptTokens, completionTokens, requests };
+}
+function readNumber(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function readBudgetCap(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readUser(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const { name, email, role } = value;
+    if (typeof name !== "string" || !name)
+        return null;
+    return {
+        name,
+        email: typeof email === "string" ? email : "",
+        role: typeof role === "string" ? role : "",
+    };
+}
+/**
+ * Read the developer's budget snapshot. Returns null on any refusal, network
+ * failure, timeout, or malformed answer — a status poll is never worth an
+ * error in front of a developer who asked for none.
+ */
+async function fetchCodieUsage({ baseUrl, key, sinceMs, fetchImpl = fetch, }) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), USAGE_TIMEOUT_MS);
+    try {
+        const query = typeof sinceMs === "number" && sinceMs > 0 ? `?since=${sinceMs}` : "";
+        const response = await fetchImpl(`${cleanBaseUrl(baseUrl)}/me/usage${query}`, {
+            headers: { Authorization: `Bearer ${key}` },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return null;
+        const payload = (await response.json());
+        const budget = payload?.budget;
+        if (!budget || typeof budget !== "object")
+            return null;
+        const raw = budget;
+        const flight = (payload?.inFlight ?? {});
+        return {
+            enabled: payload?.enabled === true,
+            user: readUser(payload?.user),
+            budget: {
+                companyBudgetUsd: readBudgetCap(raw.companyBudgetUsd),
+                companySpentUsd: readNumber(raw.companySpentUsd),
+                companyHeldUsd: readNumber(raw.companyHeldUsd),
+                userBudgetUsd: readBudgetCap(raw.userBudgetUsd),
+                userSpentUsd: readNumber(raw.userSpentUsd),
+                userHeldUsd: readNumber(raw.userHeldUsd),
+                keyBudgetUsd: readBudgetCap(raw.keyBudgetUsd),
+                keySpentUsd: readNumber(raw.keySpentUsd),
+                keyHeldUsd: typeof raw.keyHeldUsd === "number" ? raw.keyHeldUsd : null,
+            },
+            inFlight: {
+                requests: readNumber(flight.requests),
+                heldUsd: readNumber(flight.heldUsd),
+                staleRequests: readNumber(flight.staleRequests),
+                staleHeldUsd: readNumber(flight.staleHeldUsd),
+            },
+            ...(() => {
+                const since = readSince(payload?.since);
+                return since ? { since } : {};
+            })(),
+        };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}