codiedev 0.10.0-beta.2 → 0.10.0-beta.4

package/assets/tui-brand-plugin.tsx

@@ -4,11 +4,16 @@
 // over the product name, with a "powered by opencode" credit line beneath.
 // Installed and kept current by `codie`; deleting this file and its tui.json
 // entry restores the stock logo.
+// Also paints the governed status line beside the prompt: who is spending,
+// how much of which budget, and what is in flight. The numbers and the
+// wording come from the codiedev package's tested usage module, whose
+// absolute path `codie` bakes in when it stages this file.
 // Mark ported from the retired Grok-fork TUI (assets/logo/logo07.txt), itself
 // derived from vm-demo/public/codiedev-icon.png — keep aligned to that
 // intertwined c/d silhouette when refreshing brand assets.
 import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui"
 import { TextAttributes } from "@opentui/core"
+import { createSignal } from "solid-js"
 
 const MARK = [
   "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿",
@@ -20,6 +25,56 @@ const MARK = [
   "⠀⠈⠻⢿⣿⣿⣿⠿⠋⠀⠀⠙⠿⣿⣿⣿⡿⠟⠁",
 ]
 
+// One poller per TUI process, shared by every slot that shows the line. A
+// failure anywhere here costs the status line and nothing else: the home
+// screen still brands, and the developer still codes.
+const REFRESH_MS = 30_000
+
+const [usageLine, setUsageLine] = createSignal("")
+
+async function startUsagePolling() {
+  let usage: any
+  try {
+    // Imported here, not at the top of the file. This plugin is copied
+    // outside the package, so its resolution is the engine loader's business:
+    // a top-level import that fails takes the whole module with it, and the
+    // developer silently loses the brand mark that worked before. solid-js
+    // stays a static import because @opentui/solid is already this file's JSX
+    // runtime — if Solid were missing the logo would be gone regardless.
+    const { createRequire } = await import("module")
+    usage = createRequire(import.meta.url)(__CODIEDEV_USAGE_MODULE__)
+  } catch {
+    return
+  }
+  const key = process.env.CODIEDEV_GATEWAY_KEY
+  if (!key || typeof usage?.fetchCodieUsage !== "function") return
+  const poll = async () => {
+    try {
+      const snapshot = await usage.fetchCodieUsage({
+        baseUrl: process.env.CODIEDEV_GATEWAY_URL,
+        key,
+      })
+      // A failed poll leaves the last good line up rather than blanking it:
+      // a number that stopped updating beats a number that vanished.
+      if (snapshot) setUsageLine(usage.formatUsageLine(snapshot))
+    } catch {}
+  }
+  void poll()
+  const timer = setInterval(poll, REFRESH_MS)
+  // Never hold the process open for a status poll.
+  ;(timer as any).unref?.()
+}
+
+void startUsagePolling().catch(() => {})
+
+function StatusLine(props: { theme: any }) {
+  return (
+    <text fg={props.theme.textMuted} selectable={false}>
+      {usageLine()}
+    </text>
+  )
+}
+
 const tui: TuiPlugin = async (api) => {
   api.slots.register({
     slots: {
@@ -51,6 +106,12 @@ const tui: TuiPlugin = async (api) => {
           </box>
         )
       },
+      home_prompt_right(ctx) {
+        return <StatusLine theme={ctx.theme.current} />
+      },
+      session_prompt_right(ctx) {
+        return <StatusLine theme={ctx.theme.current} />
+      },
     },
   })
 }

package/dist/codexLimitScan.d.ts

@@ -45,6 +45,8 @@ export interface SweepArgs {
     scanOptions?: ScanOptions;
     /** How many rollouts may actually be READ in one sweep. */
     maxScans?: number;
+    /** Stop starting new scans once this many ms have elapsed. */
+    deadlineMs?: number;
 }
 /**
  * Report every Codex block this machine has not reported yet. Returns how many

package/dist/codexLimitScan.js

@@ -382,8 +382,20 @@ function recordCodexLimitReported(filePath, at, statePath = exports.CODEX_LIMIT_
 // Candidates are listed generously and settled by one statSync each; only
 // files that actually changed cost a read. The budget therefore bounds work
 // without letting idle sessions bury an unreported block.
+//
+// The budget binds only on a COLD START, where nothing has been seen before,
+// so it must be big enough to finish that first pass. A budget of 8 silently
+// starved the older blocked rollouts on a real machine: 49 candidates in the
+// window, the newest 8 all unblocked, nothing reported. A full pass over
+// those 49 costs ~205ms — the backward scan stops at the marker rather than
+// reading each file to its cap — so the budget can afford to cover them.
 const DEFAULT_CANDIDATES = 200;
-const DEFAULT_MAX_SCANS = 8;
+const DEFAULT_MAX_SCANS = 64;
+// The budget bounds how MANY files are read; this bounds how LONG. A count is
+// not enough on a slow or network-mounted disk, and this runs on the user's
+// prompt clock. Whatever is not reached stays unrecorded, so the next prompt
+// picks it up rather than skipping it.
+const DEFAULT_DEADLINE_MS = 1_500;
 /**
  * Report every Codex block this machine has not reported yet. Returns how many
  * events were posted. Never throws — it runs inside a hook.
@@ -407,6 +419,7 @@ async function sweepCodexLimits(args) {
     const now = Date.now();
     const touched = {};
     let budget = args.maxScans ?? DEFAULT_MAX_SCANS;
+    const deadline = now + (args.deadlineMs ?? DEFAULT_DEADLINE_MS);
     const pending = [];
     for (const file of files) {
         const print = fingerprint(file);
@@ -417,7 +430,7 @@ async function sweepCodexLimits(args) {
         // it holds nothing new and does not spend the read budget.
         if (record && record.size === print.size && record.mtime === print.mtime)
             continue;
-        if (budget <= 0)
+        if (budget <= 0 || Date.now() >= deadline)
             break;
         budget -= 1;
         const hit = scanCodexRolloutForLimit(file, args.scanOptions);

package/dist/codie.js

@@ -51,10 +51,15 @@ 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 codieStartup_1 = require("./codieStartup");
 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() : "";
@@ -97,32 +102,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
@@ -352,7 +331,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(),
@@ -374,7 +353,26 @@ async function main() {
     if (nonInteractiveRun)
         env.CODIEDEV_SECURITY_BLOCK_OUTPUT = "marker";
     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);
+        }
         process.exitCode = (await runNonInteractive(runtime, runtimeArgs, env)) ?? 1;
+        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 });

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;
 export declare const CODIE_SECURITY_BLOCK_MARKER = "__CODIEDEV_SECURITY_BLOCK__";
 /** Extract the private adapter marker used to carry a local block reason
  * across OpenCode's generic 500 boundary. The marker never contains prompt or
@@ -22,6 +45,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,11 +42,14 @@ 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 = exports.CODIE_SECURITY_BLOCK_MARKER = void 0;
+exports.HIDDEN_WORDMARK = exports.CODIEDEV_WORDMARK = exports.LEGACY_CODIEDEV_WORDMARK = exports.STOCK_WORDMARK = exports.BRAND_PLUGIN_SPEC = exports.USAGE_MODULE_PLACEHOLDER = exports.CODIE_SECURITY_BLOCK_MARKER = void 0;
+exports.usableModelCost = usableModelCost;
+exports.usableModelLimit = usableModelLimit;
 exports.extractCodieSecurityBlock = extractCodieSecurityBlock;
 exports.withCodieWorkingDirectory = withCodieWorkingDirectory;
 exports.bareModel = bareModel;
 exports.buildCodieConfig = buildCodieConfig;
+exports.stageUsageModule = stageUsageModule;
 exports.withBrandPlugin = withBrandPlugin;
 exports.patchBrandWordmark = patchBrandWordmark;
 exports.resolveCapturePlugin = resolveCapturePlugin;
@@ -64,6 +67,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 };
+}
 exports.CODIE_SECURITY_BLOCK_MARKER = "__CODIEDEV_SECURITY_BLOCK__";
 /** Extract the private adapter marker used to carry a local block reason
  * across OpenCode's generic 500 boundary. The marker never contains prompt or
@@ -143,10 +177,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"),
@@ -174,6 +221,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.
@@ -332,10 +394,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);
+    }
+}

package/dist/hook.js

@@ -217,14 +217,10 @@ async function runCodexLimitSweep(sessionId) {
             // A shorter timeout than the default: this is on the user's prompt
             // clock, and the next prompt retries anything that does not land.
             post: (payload) => (0, limitEventReporter_1.postLimitEvent)(config, payload, PROMPT_LIMIT_POST_TIMEOUT_MS),
-            // This runs on the prompt path, so keep it bounded. Unchanged rollouts
-            // cost one statSync and do not spend the read budget, so a busy machine
-            // cannot bury an unreported block behind newer idle sessions. When a
-            // block is still unreported it sits at the END of its rollout, so a
-            // small scan window is enough; the Stop path keeps the larger default
-            // for a session that kept going after the window reset.
+            // Unchanged rollouts cost one statSync and do not spend the read
+            // budget, so in steady state this is nearly free. The module default
+            // covers a cold start; see DEFAULT_MAX_SCANS for why it is not small.
             findOptions: { withinMs: 24 * 3600_000 },
-            maxScans: 8,
             scanOptions: { maxScanBytes: 4 * 1024 * 1024 },
         });
         if (posted > 0) {

package/dist/limitEvent.js

@@ -51,11 +51,36 @@ function parseLimitEventFromTranscript(transcript) {
     }
     return found;
 }
+/**
+ * Codex's `rate_limit_reached_type` is exactly five values (read off the 0.154
+ * binary): `rate_limit_reached`, `workspace_{owner,member}_credits_depleted`
+ * and `workspace_{owner,member}_usage_limit_reached`.
+ *
+ * The split that matters to a reader of the dashboard is "someone must act on
+ * money" vs "this dev is throttled and it will reset" — so map on what the
+ * snapshot actually asserts, not on the word "credits":
+ *
+ * - A member out of their OWN allowance is a rate limit. Real snapshots carry
+ *   `spend_control_reached: null` and `individual_limit: null` — nobody
+ *   configured a budget, the window is simply used up. Calling that personal
+ *   spend tells a manager the dev overspent, which is not what happened.
+ *
+ *   Deliberately NOT gated on `individual_limit`: it has only ever been
+ *   observed null, so its populated shape and meaning are unknown, and a
+ *   wrong guess reinstates the mislabel this exists to remove. The reason
+ *   string is the causal signal; `individual_limit` is at best correlative.
+ * - A member whose ADMIN capped them (`usage_limit_reached`) is personal spend:
+ *   there really is a cap, and someone can raise it.
+ * - Anything owner-scoped is org spend — the org's allowance or credits are
+ *   gone and somebody has to act.
+ */
 function codexLimitKind(reason, spendControlReached) {
     if (spendControlReached || reason.startsWith("workspace_owner_"))
         return "org_spend";
-    if (reason.startsWith("workspace_member_"))
+    if (reason === "workspace_member_usage_limit_reached")
         return "user_spend";
+    if (reason === "workspace_member_credits_depleted")
+        return "session";
     return reason === "rate_limit_reached" ? "session" : "other";
 }
 function codexResetText(rateLimits) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.10.0-beta.2",
+  "version": "0.10.0-beta.4",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",
@@ -57,7 +57,7 @@
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.4.0",
-    "vitest": "^3.2.6"
+    "vitest": "^4.1.11"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0"