codiedev 0.9.56 → 0.9.58

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/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
@@ -209,12 +188,26 @@ async function main() {
                     return null;
                 }
             },
+            isEngine: codieRuntimeInstall_1.isEngineOnDisk,
         }),
         install: (missing) => (0, codieRuntimeInstall_1.installCodieRuntimeOnDisk)(missing, stateDir),
+        repair: (unlinked) => {
+            // npm 12 skips dependency install scripts; codie runs opencode-ai's own
+            // link step instead (not when npm is explicitly set to ignore scripts).
+            console.error("codie: finishing the engine setup npm skipped (opencode-ai's postinstall)…");
+            const linked = (0, codieRuntimeInstall_1.linkEngineOnDisk)(unlinked.packageDir);
+            // npm set to ignore scripts: a reinstall would hit the same wall, so stop
+            // with the one clear step instead of downloading again every run.
+            if (!linked.ok && linked.detail === codieRuntimeInstall_1.IGNORE_SCRIPTS)
+                throw new Error((0, codieRuntimeInstall_1.linkFailure)(linked, unlinked.packageDir));
+            if (!linked.ok)
+                console.error(`codie: ${(0, codieRuntimeInstall_1.linkFailure)(linked, unlinked.packageDir)} Reinstalling the engine.`);
+            return linked.ok;
+        },
     });
     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 +225,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/codieRuntime.d.ts

@@ -8,12 +8,28 @@ export type CodieRuntime = {
     installDir: string;
     binary: string;
     spec: string;
+} | {
+    kind: "unlinked";
+    installDir: string;
+    binary: string;
+    spec: string;
+    packageDir: string;
 };
 export declare function codieRuntimeDir(stateDir: string): string;
-export declare function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }: {
+/**
+ * The real engine is a ~132MB native executable. opencode-ai ships
+ * bin/opencode.exe as a ~500-byte shell script that only prints "postinstall
+ * was not run" until its postinstall swaps the binary in; anything this small
+ * is that placeholder, not an engine. Pure.
+ */
+export declare const ENGINE_MIN_BYTES = 1000000;
+export declare function isEngineSize(bytes: number): boolean;
+export declare function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, isEngine, }: {
     env: Record<string, string | undefined>;
     stateDir: string;
     existsSync: (candidate: string) => boolean;
     resolveBundled: () => string | null;
+    /** Whether a candidate is a real engine, not opencode-ai's placeholder. */
+    isEngine?: (candidate: string) => boolean;
 }): CodieRuntime;
 export declare function assertCodieNodeVersion(version: string): void;

package/dist/codieRuntime.js

@@ -43,8 +43,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CODIE_MIN_NODE_MAJOR = exports.OPENCODE_RUNTIME_SPEC = void 0;
+exports.ENGINE_MIN_BYTES = exports.CODIE_MIN_NODE_MAJOR = exports.OPENCODE_RUNTIME_SPEC = void 0;
 exports.codieRuntimeDir = codieRuntimeDir;
+exports.isEngineSize = isEngineSize;
 exports.resolveCodieRuntime = resolveCodieRuntime;
 exports.assertCodieNodeVersion = assertCodieNodeVersion;
 const path = __importStar(require("path"));
@@ -62,7 +63,20 @@ function codieRuntimeDir(stateDir) {
 function installedBinary(stateDir) {
     return path.join(codieRuntimeDir(stateDir), "node_modules", "opencode-ai", "bin", "opencode.exe");
 }
-function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }) {
+/**
+ * The real engine is a ~132MB native executable. opencode-ai ships
+ * bin/opencode.exe as a ~500-byte shell script that only prints "postinstall
+ * was not run" until its postinstall swaps the binary in; anything this small
+ * is that placeholder, not an engine. Pure.
+ */
+exports.ENGINE_MIN_BYTES = 1_000_000;
+function isEngineSize(bytes) {
+    return bytes >= exports.ENGINE_MIN_BYTES;
+}
+function installedPackageDir(stateDir) {
+    return path.join(codieRuntimeDir(stateDir), "node_modules", "opencode-ai");
+}
+function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, isEngine = () => true, }) {
     // 1. Explicit override — the air-gapped / pre-provisioned escape hatch.
     const override = env.CODIEDEV_OPENCODE_BINARY?.trim();
     if (override) {
@@ -74,12 +88,16 @@ function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }) {
     // 2. A bundled engine, if this package was installed with one (dev checkout,
     //    or a future vendored distribution).
     const bundled = resolveBundled();
-    if (bundled)
+    if (bundled && isEngine(bundled))
         return { kind: "ready", binary: bundled };
     // 3. The lazily installed engine.
     const binary = installedBinary(stateDir);
-    if (existsSync(binary))
+    if (existsSync(binary)) {
+        if (!isEngine(binary)) {
+            return { kind: "unlinked", installDir: codieRuntimeDir(stateDir), binary, spec: exports.OPENCODE_RUNTIME_SPEC, packageDir: installedPackageDir(stateDir) };
+        }
         return { kind: "ready", binary };
+    }
     return { kind: "missing", installDir: codieRuntimeDir(stateDir), binary, spec: exports.OPENCODE_RUNTIME_SPEC };
 }
 function assertCodieNodeVersion(version) {

package/dist/codieRuntimeInstall.d.ts

@@ -1,9 +1,17 @@
 import { CodieRuntime } from "./codieRuntime";
+type InstallableCodieRuntime = Exclude<CodieRuntime, {
+    kind: "ready";
+}>;
+/** Outcome of running opencode-ai's own link step. `detail` is its error. */
+export type LinkResult = {
+    ok: boolean;
+    detail?: string;
+};
+/** linkEngine's detail when npm is explicitly set not to run install scripts. */
+export declare const IGNORE_SCRIPTS = "ignore-scripts";
 export declare function buildRuntimeInstallArgs(stagingDir: string, spec: string): string[];
 export interface InstallDeps {
-    runtime: Extract<CodieRuntime, {
-        kind: "missing";
-    }>;
+    runtime: InstallableCodieRuntime;
     makeStagingDir: () => string;
     run: (args: string[]) => {
         status: number | null;
@@ -13,15 +21,36 @@ export interface InstallDeps {
     rename: (from: string, to: string) => void;
     remove: (target: string) => void;
     log: (message: string) => void;
+    /** Whether a file is a real engine, not opencode-ai's placeholder script. */
+    isEngine?: (candidate: string) => boolean;
+    /** Run opencode-ai's postinstall in a package dir. */
+    linkEngine?: (packageDir: string) => LinkResult;
 }
 export declare function installCodieRuntime(deps: InstallDeps): void;
-export declare function ensureCodieRuntimeBinary({ resolve, install, }: {
+export declare function ensureCodieRuntimeBinary({ resolve, install, repair, }: {
     resolve: () => CodieRuntime;
-    install: (runtime: Extract<CodieRuntime, {
-        kind: "missing";
-    }>) => void;
+    install: (runtime: InstallableCodieRuntime) => void;
+    /** Link an unlinked install in place (runs its postinstall); true if it's now an engine. */
+    repair?: (runtime: Extract<CodieRuntime, {
+        kind: "unlinked";
+    }>) => boolean;
 }): string;
-export declare function installCodieRuntimeOnDisk(runtime: Extract<CodieRuntime, {
-    kind: "missing";
-}>, stateDir: string): void;
+/** Why an installed engine still isn't runnable, with opencode-ai's own error. Pure. */
+export declare function linkFailure(linked: LinkResult, packageDir?: string): string;
+/** A cmd.exe command line: each argument double-quoted when it has spaces or
+ *  shell metacharacters (paths like C:\Users\First Last\…). Pure. */
+export declare function windowsCommand(command: string, args: string[]): string;
+/** A real engine on disk (not opencode-ai's placeholder script). */
+export declare function isEngineOnDisk(candidate: string): boolean;
+/** Whether npm is explicitly configured not to run install scripts (an org
+ *  policy codie shouldn't bypass). npm 12's default script approval isn't this. */
+export declare function npmIgnoresScripts(env?: Record<string, string | undefined>): boolean;
+/** Run opencode-ai's own postinstall, which links the platform binary into
+ *  bin/opencode.exe (and picks the right build for this CPU/libc). The same
+ *  step npm would have run; skipped when npm is set to ignore scripts. */
+export declare function linkEngineOnDisk(packageDir: string, { ignoreScripts }?: {
+    ignoreScripts?: () => boolean;
+}): LinkResult;
+export declare function installCodieRuntimeOnDisk(runtime: InstallableCodieRuntime, stateDir: string): void;
 export declare function defaultStagingRoot(): string;
+export {};

package/dist/codieRuntimeInstall.js

@@ -39,9 +39,15 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGNORE_SCRIPTS = void 0;
 exports.buildRuntimeInstallArgs = buildRuntimeInstallArgs;
 exports.installCodieRuntime = installCodieRuntime;
 exports.ensureCodieRuntimeBinary = ensureCodieRuntimeBinary;
+exports.linkFailure = linkFailure;
+exports.windowsCommand = windowsCommand;
+exports.isEngineOnDisk = isEngineOnDisk;
+exports.npmIgnoresScripts = npmIgnoresScripts;
+exports.linkEngineOnDisk = linkEngineOnDisk;
 exports.installCodieRuntimeOnDisk = installCodieRuntimeOnDisk;
 exports.defaultStagingRoot = defaultStagingRoot;
 const fs = __importStar(require("fs"));
@@ -49,6 +55,8 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const codieRuntime_1 = require("./codieRuntime");
+/** linkEngine's detail when npm is explicitly set not to run install scripts. */
+exports.IGNORE_SCRIPTS = "ignore-scripts";
 function buildRuntimeInstallArgs(stagingDir, spec) {
     // No --registry / --proxy: inherit whatever npm config the developer's
     // machine already has so an internal mirror keeps working.
@@ -64,7 +72,7 @@ function buildRuntimeInstallArgs(stagingDir, spec) {
     ];
 }
 function installCodieRuntime(deps) {
-    const { runtime, makeStagingDir, run, exists, rename, remove, log } = deps;
+    const { runtime, makeStagingDir, run, exists, rename, remove, log, isEngine = () => true, linkEngine } = deps;
     const staging = makeStagingDir();
     log(`Installing the Codie engine (${runtime.spec}). This runs once, and only for \`codie\`.`);
     let result;
@@ -87,6 +95,35 @@ function installCodieRuntime(deps) {
         throw new Error(`The Codie engine install did not produce a runtime binary. ` +
             `Check that ${runtime.spec} is available from your npm registry.`);
     }
+    // The placeholder exists even when postinstall never ran (npm 12 skips
+    // dependency install scripts); link it here — what opencode-ai's own error
+    // tells you to do — before promoting.
+    if (!isEngine(stagedBinary)) {
+        let linked = { ok: false };
+        try {
+            linked = linkEngine?.(path.dirname(path.dirname(stagedBinary))) ?? { ok: false };
+        }
+        catch (error) {
+            linked = { ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+        if (!linked.ok || !isEngine(stagedBinary)) {
+            if (linked.detail === exports.IGNORE_SCRIPTS) {
+                // npm is set to ignore scripts: keep the install (promote it) so the
+                // printed postinstall path exists and the next run is a no-download
+                // "unlinked" that stops with the same step, not another download.
+                try {
+                    rename(staging, runtime.installDir);
+                }
+                finally {
+                    remove(staging);
+                }
+            }
+            else {
+                remove(staging);
+            }
+            throw new Error(linkFailure(linked, path.join(runtime.installDir, "node_modules", "opencode-ai")));
+        }
+    }
     try {
         rename(staging, runtime.installDir);
     }
@@ -98,13 +135,33 @@ function installCodieRuntime(deps) {
     }
 }
 // Resolve the engine, downloading it once if this is the first `codie` run.
-function ensureCodieRuntimeBinary({ resolve, install, }) {
+function ensureCodieRuntimeBinary({ resolve, install, repair, }) {
     const runtime = resolve();
     if (runtime.kind === "ready")
         return runtime.binary;
+    // An install whose postinstall never ran: link it in place (no download).
+    // Re-resolve after, so a concurrent repair or a partial link falls through
+    // to a reinstall rather than launching a missing file.
+    if (runtime.kind === "unlinked" && repair?.(runtime)) {
+        const after = resolve();
+        if (after.kind === "ready")
+            return after.binary;
+    }
     install(runtime);
     return runtime.binary;
 }
+/** Why an installed engine still isn't runnable, with opencode-ai's own error. Pure. */
+function linkFailure(linked, packageDir) {
+    if (linked.detail === exports.IGNORE_SCRIPTS) {
+        const script = packageDir ? `"${path.join(packageDir, "postinstall.mjs")}"` : "postinstall.mjs in the opencode-ai package";
+        return (`The Codie engine installed, but npm is set to ignore install scripts (ignore-scripts=true), ` +
+            `so codie won't run opencode-ai's setup step. Run \`node ${script}\` yourself, ` +
+            `or set CODIEDEV_OPENCODE_BINARY to an opencode binary.`);
+    }
+    return (`The Codie engine installed, but its setup step (opencode-ai's postinstall) failed, so there is no runnable engine` +
+        (linked.detail ? `: ${linked.detail}` : ".") +
+        ` Set CODIEDEV_OPENCODE_BINARY to an opencode binary to use a pre-provisioned engine.`);
+}
 function installFailure(detail) {
     return new Error(`Could not download the Codie engine: ${detail}\n` +
         `If you are behind a proxy or an internal registry, make sure npm can reach it. ` +
@@ -112,6 +169,62 @@ function installFailure(detail) {
 }
 // ── Real-world wiring ───────────────────────────────────────────────────
 // Kept separate from the pure logic above so tests never shell out to npm.
+/** A cmd.exe command line: each argument double-quoted when it has spaces or
+ *  shell metacharacters (paths like C:\Users\First Last\…). Pure. */
+function windowsCommand(command, args) {
+    const quote = (a) => (/[\s"&|<>^()%!]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a);
+    return [command, ...args.map(quote)].join(" ");
+}
+/** A real engine on disk (not opencode-ai's placeholder script). */
+function isEngineOnDisk(candidate) {
+    try {
+        return (0, codieRuntime_1.isEngineSize)(fs.statSync(candidate).size);
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether npm is explicitly configured not to run install scripts (an org
+ *  policy codie shouldn't bypass). npm 12's default script approval isn't this. */
+function npmIgnoresScripts(env = process.env) {
+    // npm reads either case and treats anything but a false-ish value as true.
+    const fromEnv = env.npm_config_ignore_scripts ?? env.NPM_CONFIG_IGNORE_SCRIPTS;
+    if (fromEnv !== undefined)
+        return !["", "false", "0", "null", "no"].includes(fromEnv.trim().toLowerCase());
+    const opts = { encoding: "utf8", timeout: 10_000, windowsHide: true };
+    // npm.cmd needs a shell on Windows (Node 20+ refuses to spawn .cmd without
+    // one). One constant command string — args plus shell:true is deprecated.
+    const result = process.platform === "win32"
+        ? (0, child_process_1.spawnSync)("npm.cmd config get ignore-scripts", { ...opts, shell: true })
+        : (0, child_process_1.spawnSync)("npm", ["config", "get", "ignore-scripts"], opts);
+    return result.status === 0 && (result.stdout || "").trim() === "true";
+}
+const LINK_TIMEOUT_MS = 120_000;
+/** Run opencode-ai's own postinstall, which links the platform binary into
+ *  bin/opencode.exe (and picks the right build for this CPU/libc). The same
+ *  step npm would have run; skipped when npm is set to ignore scripts. */
+function linkEngineOnDisk(packageDir, { ignoreScripts = npmIgnoresScripts } = {}) {
+    const script = path.join(packageDir, "postinstall.mjs");
+    if (!fs.existsSync(script))
+        return { ok: false, detail: "opencode-ai has no postinstall.mjs" };
+    if (ignoreScripts())
+        return { ok: false, detail: exports.IGNORE_SCRIPTS };
+    const result = (0, child_process_1.spawnSync)(process.execPath, [script], {
+        cwd: packageDir,
+        encoding: "utf8",
+        stdio: ["ignore", "ignore", "pipe"],
+        timeout: LINK_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    if (result.error || result.signal) {
+        return { ok: false, detail: result.error ? result.error.message : `timed out after ${LINK_TIMEOUT_MS / 1000}s` };
+    }
+    if (result.status !== 0)
+        return { ok: false, detail: (result.stderr || "").trim().split("\n").slice(-3).join(" ") || `exit ${result.status}` };
+    return isEngineOnDisk(path.join(packageDir, "bin", "opencode.exe"))
+        ? { ok: true }
+        : { ok: false, detail: "postinstall ran but left no engine" };
+}
 function installCodieRuntimeOnDisk(runtime, stateDir) {
     installCodieRuntime({
         runtime,
@@ -121,12 +234,16 @@ function installCodieRuntimeOnDisk(runtime, stateDir) {
             return fs.mkdtempSync(path.join(path.dirname((0, codieRuntime_1.codieRuntimeDir)(stateDir)), ".runtime-staging-"));
         },
         run: (args) => {
-            const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-            const result = (0, child_process_1.spawnSync)(npm, args, {
+            const opts = {
                 encoding: "utf8",
                 stdio: ["ignore", "inherit", "pipe"],
                 env: { ...process.env, npm_config_yes: "true" },
-            });
+            };
+            // Windows: Node 20+ refuses to spawn npm.cmd without a shell (EINVAL),
+            // which made the engine install fail outright there. One quoted string.
+            const result = process.platform === "win32"
+                ? (0, child_process_1.spawnSync)(windowsCommand("npm.cmd", args), { ...opts, shell: true, windowsHide: true })
+                : (0, child_process_1.spawnSync)("npm", args, opts);
             if (result.error)
                 throw result.error;
             return { status: result.status, stderr: result.stderr || "" };
@@ -138,6 +255,8 @@ function installCodieRuntimeOnDisk(runtime, stateDir) {
         },
         remove: (target) => fs.rmSync(target, { recursive: true, force: true }),
         log: (message) => console.error(message),
+        isEngine: isEngineOnDisk,
+        linkEngine: linkEngineOnDisk,
     });
 }
 function defaultStagingRoot() {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.56",
+  "version": "0.9.58",
   "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",