@codemieai/code 0.15.3 → 0.15.5

package/dist/agents/plugins/claude/plugin/statusline.bundle.mjs

@@ -0,0 +1,729 @@
+#!/usr/bin/env node
+
+// src/agents/plugins/claude/plugin/statusline.ts
+import fs from "fs/promises";
+import os3 from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/exec.ts
+import { spawn } from "child_process";
+import os from "os";
+async function exec(command, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const isWindows = os.platform() === "win32";
+    let useShell = false;
+    if (options.shell !== void 0) {
+      useShell = options.shell;
+    }
+    const stdio = options.interactive ? "inherit" : "pipe";
+    let finalCommand = command;
+    let finalArgs = args;
+    if (useShell && args.length > 0) {
+      const needsQuoting = (arg) => arg.includes(" ") || arg.includes('"') || isWindows && /[&|<>^%()[\]{}]/.test(arg);
+      const quotedArgs = args.map(
+        (arg) => needsQuoting(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg
+      );
+      finalCommand = `${command} ${quotedArgs.join(" ")}`;
+      finalArgs = [];
+    }
+    const child = spawn(finalCommand, finalArgs, {
+      cwd: options.cwd || process.cwd(),
+      env: { ...process.env, ...options.env },
+      shell: useShell,
+      windowsHide: isWindows,
+      // Hide console window on Windows
+      stdio
+    });
+    let stdout = "";
+    let stderr = "";
+    let timeoutId = null;
+    const cleanup = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+    if (!options.interactive) {
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+    child.on("error", (error) => {
+      cleanup();
+      reject(new Error(`Failed to execute ${command}: ${error.message}`));
+    });
+    child.on("close", (code, signal) => {
+      cleanup();
+      if (code === null) {
+        reject(new Error(`Command terminated by signal ${signal ?? "unknown"}`));
+        return;
+      }
+      const result = {
+        code,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        signal
+      };
+      if (options.interactive && code !== 0) {
+        reject(new Error(`Command exited with code ${code}`));
+      } else {
+        resolve(result);
+      }
+    });
+    if (options.timeout) {
+      timeoutId = setTimeout(() => {
+        child.kill();
+        reject(new Error(`Command timed out after ${options.timeout}ms`));
+      }, options.timeout);
+    }
+  });
+}
+
+// src/utils/routing-headers.mjs
+var CODEMIE_ROUTING_HEADERS = [
+  "x-codemie-routed-model",
+  "x-codemie-requested-model",
+  "x-codemie-routing-tier",
+  "x-codemie-routing-decision-source",
+  "x-codemie-routing-source",
+  "x-codemie-routing-router-type",
+  "x-codemie-routing-family",
+  "x-codemie-routing-classifier-model",
+  "x-codemie-routing-classifier-cost-usd",
+  "x-codemie-routing-counterfactual-model"
+];
+function hasAnyHeader(message, headerNames) {
+  return headerNames.some((name) => message?.[name] != null);
+}
+function parseRoutingHeaders(message) {
+  if (!hasAnyHeader(message, CODEMIE_ROUTING_HEADERS)) return null;
+  const routingTier = normalizeRoutingTier(message["x-codemie-routing-tier"]);
+  const classifierCostUSD = parseOptFloat(message["x-codemie-routing-classifier-cost-usd"]);
+  return {
+    ...message["x-codemie-requested-model"] != null && { requestedModel: message["x-codemie-requested-model"] },
+    ...routingTier != null && { routingTier },
+    ...message["x-codemie-routing-tier"] != null && { routingTierRaw: message["x-codemie-routing-tier"] },
+    ...message["x-codemie-routed-model"] != null && { routedModel: message["x-codemie-routed-model"] },
+    ...message["x-codemie-routing-classifier-model"] != null && { classifierModel: message["x-codemie-routing-classifier-model"] },
+    ...message["x-codemie-routing-router-type"] != null && { routerType: message["x-codemie-routing-router-type"] },
+    ...message["x-codemie-routing-source"] != null && { routingSource: message["x-codemie-routing-source"] },
+    ...message["x-codemie-routing-decision-source"] != null && { decisionSource: message["x-codemie-routing-decision-source"] },
+    // Opaque passthrough of whichever backend mechanism made the decision — informational only.
+    ...message["x-codemie-routing-family"] != null && { routingFamily: message["x-codemie-routing-family"] },
+    // Backend-computed counterfactual: the model this turn's usage should be repriced at to
+    // estimate "what this would have cost unrouted" — see cost-enricher.ts's `buildModelTimeline`.
+    ...message["x-codemie-routing-counterfactual-model"] != null && { counterfactualModel: message["x-codemie-routing-counterfactual-model"] },
+    // Known iff the proxy reported a classifier cost for this turn — absence means "no
+    // classifier ran / not measured", not "zero".
+    routingCostKnown: classifierCostUSD != null,
+    ...classifierCostUSD != null && { classifierCostUSD }
+  };
+}
+function parseOptFloat(s) {
+  if (s == null) return void 0;
+  const v = parseFloat(s);
+  return Number.isNaN(v) ? void 0 : v;
+}
+function normalizeRoutingTier(raw) {
+  if (raw == null) return void 0;
+  const key = String(raw).trim().toLowerCase();
+  const map = {
+    "simple": "simple",
+    "efficient": "middle",
+    "medium": "middle",
+    "capable": "complex",
+    "complex": "complex",
+    "reasoning": "reasoning"
+  };
+  return map[key] ?? key;
+}
+
+// src/utils/bedrock-pricing.mjs
+function parseBackendModelName(message) {
+  return message?.["x-litellm-model-name"] ?? null;
+}
+var BEDROCK_REGION_PATTERN = /(?:^|\/)([a-z0-9-]+)\.anthropic\./i;
+function bedrockEndpointRegion(rawModelId) {
+  if (!rawModelId) return null;
+  const match = BEDROCK_REGION_PATTERN.exec(String(rawModelId).toLowerCase());
+  return match ? match[1] : null;
+}
+function isBedrockRegionalPremium(rawModelId) {
+  const region = bedrockEndpointRegion(rawModelId);
+  return region != null && region !== "global";
+}
+function applyBedrockRegionalPremium(price, rawModelId) {
+  if (price == null || price.bedrockRegionalMultiplier == null || !isBedrockRegionalPremium(rawModelId)) {
+    return price;
+  }
+  const multiplier = price.bedrockRegionalMultiplier;
+  return {
+    ...price,
+    ...price.input != null && { input: price.input * multiplier },
+    ...price.output != null && { output: price.output * multiplier },
+    ...price.cacheRead != null && { cacheRead: price.cacheRead * multiplier },
+    ...price.cacheCreation != null && { cacheCreation: price.cacheCreation * multiplier },
+    ...price.cacheWrite != null && { cacheWrite: price.cacheWrite * multiplier },
+    ...price.cacheWrite1h != null && { cacheWrite1h: price.cacheWrite1h * multiplier }
+  };
+}
+
+// src/utils/credential-crypto.ts
+import * as crypto from "crypto";
+import * as os2 from "os";
+import { URL } from "url";
+function deriveMachineEncryptionKey() {
+  const machineId = os2.hostname() + os2.platform() + os2.arch();
+  const hex = crypto.createHash("sha256").update(machineId).digest("hex");
+  return crypto.createHash("sha256").update(hex).digest();
+}
+function decryptWithKey(text, key) {
+  const parts = text.split(":");
+  if (parts.length === 3) {
+    const iv2 = Buffer.from(parts[0], "hex");
+    const authTag = Buffer.from(parts[1], "hex");
+    const decipher2 = crypto.createDecipheriv("aes-256-gcm", key, iv2);
+    decipher2.setAuthTag(authTag);
+    return decipher2.update(parts[2], "hex", "utf8") + decipher2.final("utf8");
+  }
+  const iv = Buffer.from(parts[0], "hex");
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  return decipher.update(parts[1], "hex", "utf8") + decipher.final("utf8");
+}
+function normalizeUrlForKey(baseUrl) {
+  try {
+    const parsed = new URL(baseUrl);
+    if (parsed.host && (parsed.protocol === "http:" || parsed.protocol === "https:")) {
+      return `${parsed.protocol}//${parsed.host}`.toLowerCase();
+    }
+  } catch {
+  }
+  return baseUrl.replace(/\/$/, "").toLowerCase();
+}
+function hashStorageKey(normalized) {
+  return `sso-${crypto.createHash("sha256").update(normalized).digest("hex")}`;
+}
+function deriveUrlStorageKey(baseUrl) {
+  return hashStorageKey(normalizeUrlForKey(baseUrl));
+}
+function deriveLegacyUrlStorageKey(baseUrl) {
+  return hashStorageKey(baseUrl.replace(/\/$/, "").toLowerCase());
+}
+
+// src/utils/model-normalizer.ts
+var VENDOR_PREFIX_PATTERN = /^(?:openai[./]|azure\/|vertex_ai\/|anthropic\/|moonshotai\.|qwen\.)/i;
+function normalizeModelName(modelName) {
+  const bedrockMatch = modelName.match(/^(?:bedrock\/)?(?:converse\/)?[a-z0-9-]+\.anthropic\.(claude-[a-z0-9-]+?)(?:-v\d+:\d+)?$/);
+  if (bedrockMatch) {
+    return bedrockMatch[1];
+  }
+  if (modelName.startsWith("kimi-code/")) {
+    return modelName.slice("kimi-code/".length);
+  }
+  const vendorPrefixMatch = modelName.match(VENDOR_PREFIX_PATTERN);
+  if (vendorPrefixMatch) {
+    return modelName.slice(vendorPrefixMatch[0].length);
+  }
+  return modelName;
+}
+
+// src/utils/price-resolution.ts
+var SNAPSHOT_SUFFIX_PATTERN = /-(?:\d{8}|\d{4}-\d{2}-\d{2}|latest|preview)$/;
+var CLAUDE_VERSION_FIRST_PATTERN = /^claude-(\d+(?:-\d+)*)-(opus|sonnet|haiku)(-.+)?$/;
+function priceTableKey(rawKey) {
+  return rawKey.toLowerCase().replace(/\./g, "-");
+}
+function canonicalizeModelId(model) {
+  return priceTableKey(normalizeModelName(model)).replace(/@/g, "-").replace(/-vertex$/, "");
+}
+function reorderClaudeVersionFamily(id) {
+  const match = id.match(CLAUDE_VERSION_FIRST_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const [, version, family, rest = ""] = match;
+  return `claude-${family}-${version}${rest}`;
+}
+function withoutSnapshot(key) {
+  const stripped = key.replace(SNAPSHOT_SUFFIX_PATTERN, "");
+  return stripped === key ? null : stripped;
+}
+function priceKeyCandidates(model) {
+  const canonical = canonicalizeModelId(model);
+  const candidates = [{ key: canonical, match: "exact" }];
+  const snapshot = withoutSnapshot(canonical);
+  if (snapshot) {
+    candidates.push({ key: snapshot, match: "snapshot" });
+  }
+  const reordered = reorderClaudeVersionFamily(canonical);
+  if (reordered) {
+    candidates.push({ key: reordered, match: "reordered" });
+    const reorderedSnapshot = withoutSnapshot(reordered);
+    if (reorderedSnapshot) {
+      candidates.push({ key: reorderedSnapshot, match: "reordered" });
+    }
+  }
+  return candidates;
+}
+function resolvePriceKey(model, lookup) {
+  for (const { key, match } of priceKeyCandidates(model)) {
+    const value = key ? lookup(key) : void 0;
+    if (value !== void 0) {
+      return { key, match, value };
+    }
+  }
+  return null;
+}
+
+// src/agents/plugins/claude/plugin/statusline.ts
+var HOME = process.env.CODEMIE_HOME || path.join(os3.homedir(), ".codemie");
+var CACHE_FILE = path.join(HOME, "budget-cache.json");
+var CONFIG_FILE = path.join(HOME, "codemie-cli.config.json");
+var CREDS_DIR = path.join(HOME, "credentials");
+var CACHE_TTL_MS = 6e4;
+var CACHE_SCHEMA = 2;
+var ENCRYPTION_KEY = deriveMachineEncryptionKey();
+async function readCredsFile(filePath) {
+  try {
+    return JSON.parse(decryptWithKey(await fs.readFile(filePath, "utf8"), ENCRYPTION_KEY));
+  } catch {
+    return null;
+  }
+}
+async function readStoredCredsFile(jwtPrefix, codeMieUrl) {
+  const current = await readCredsFile(path.join(CREDS_DIR, `${jwtPrefix}${deriveUrlStorageKey(codeMieUrl)}.enc`));
+  if (current) return current;
+  return readCredsFile(path.join(CREDS_DIR, `${jwtPrefix}${deriveLegacyUrlStorageKey(codeMieUrl)}.enc`));
+}
+async function getAuthHeaders(codeMieUrl) {
+  const sso = await readStoredCredsFile("", codeMieUrl);
+  if (sso?.cookies) {
+    return { cookie: Object.entries(sso.cookies).map(([k, v]) => `${k}=${v}`).join(";") };
+  }
+  const jwt = await readStoredCredsFile("jwt-", codeMieUrl);
+  if (jwt?.token) {
+    return { authorization: `Bearer ${jwt.token}` };
+  }
+  return null;
+}
+function matchBudgetRow(rows, userEmail) {
+  if (!Array.isArray(rows) || !userEmail) return null;
+  const target = `${userEmail.trim().toLowerCase()} (cli)`;
+  return rows.find((r) => r.project_name?.trim().toLowerCase() === target) ?? null;
+}
+function formatBudgetSegment(row) {
+  if (!row) return null;
+  const pct = Math.round(row.total ?? 0);
+  const reset = row.budget_reset_at ? new Date(row.budget_reset_at).toLocaleDateString() : "?";
+  return {
+    text: `$${row.current_spending.toFixed(2)} (${pct}%) resets ${reset}`,
+    pct
+  };
+}
+function extractBasicInfo(ctx) {
+  const cwd = ctx?.workspace?.current_dir ?? ctx?.cwd ?? "";
+  return {
+    projectName: cwd ? path.basename(cwd) : "",
+    cwd,
+    transcriptPath: ctx?.transcript_path ?? "",
+    modelId: ctx?.model?.id ?? "",
+    model: ctx?.model?.display_name ?? "",
+    ctxPct: ctx?.context_window?.used_percentage ?? null,
+    tokIn: ctx?.context_window?.total_input_tokens ?? null,
+    tokOut: ctx?.context_window?.total_output_tokens ?? null,
+    cost: ctx?.cost?.total_cost_usd ?? null,
+    durationMs: ctx?.cost?.total_duration_ms ?? null
+  };
+}
+var ROUTED_MODEL_TAIL_BYTES = 65536;
+var ROUTED_MODEL_TAIL_MAX_BYTES = 8 * 1024 * 1024;
+function normalizeModelId(modelId) {
+  if (!modelId) return "";
+  return modelId.toLowerCase().replace(/^(?:bedrock\/)?(?:converse\/)?/, "").replace(/^[a-z0-9-]+\.anthropic\./, "").replace(/-v\d+:\d+$/, "");
+}
+function parseLastAssistantTurn(tailText) {
+  if (!tailText) return null;
+  const lines = tailText.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const message = parsed?.message;
+    if (parsed?.type === "assistant" && message?.model && message.model !== "<synthetic>") {
+      return { responseModel: message.model, headerRoutedModel: parseRoutingHeaders(message)?.routedModel ?? null };
+    }
+  }
+  return null;
+}
+async function defaultReadTail(filePath, maxBytes) {
+  const handle = await fs.open(filePath, "r");
+  try {
+    const { size } = await handle.stat();
+    const start = Math.max(0, size - maxBytes);
+    const length = size - start;
+    if (length <= 0) return "";
+    const { buffer, bytesRead } = await handle.read({ buffer: Buffer.alloc(length), position: start });
+    return buffer.toString("utf8", 0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+function parseRouterModelIds(env) {
+  if (!env.CODEMIE_ROUTER_MODEL_IDS) return /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(env.CODEMIE_ROUTER_MODEL_IDS);
+    return new Set(Array.isArray(parsed) ? parsed : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function isRoutingConfigured(env, modelId) {
+  return parseRouterModelIds(env).has(modelId);
+}
+function parseModelLabels(env) {
+  if (!env.CODEMIE_MODEL_LABELS) return {};
+  try {
+    const parsed = JSON.parse(env.CODEMIE_MODEL_LABELS);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function resolveActualModel(transcriptPath, { readTail = defaultReadTail, labels = {} } = {}) {
+  if (!transcriptPath) return null;
+  let turn = null;
+  let bytes = ROUTED_MODEL_TAIL_BYTES;
+  for (; ; ) {
+    let tail;
+    try {
+      tail = await readTail(transcriptPath, bytes);
+    } catch {
+      return null;
+    }
+    turn = parseLastAssistantTurn(tail);
+    if (turn || Buffer.byteLength(tail, "utf8") < bytes || bytes >= ROUTED_MODEL_TAIL_MAX_BYTES) break;
+    bytes = Math.min(bytes * 8, ROUTED_MODEL_TAIL_MAX_BYTES);
+  }
+  if (!turn) return null;
+  const candidate = turn.headerRoutedModel ?? turn.responseModel;
+  if (!candidate) return null;
+  const normalized = normalizeModelId(candidate);
+  return labels[candidate] ?? labels[normalized] ?? normalized;
+}
+var PRICING_FILENAME = "codemie-pricing.json";
+var COST_CACHE_FILE = path.join(HOME, "statusline-cost-cache.json");
+var COST_CACHE_SCHEMA = 1;
+async function sourceSignature(paths, stat) {
+  const parts = [];
+  for (const p of paths) {
+    try {
+      const { size, mtimeMs } = await stat(p);
+      parts.push(`${p}:${size}:${mtimeMs}`);
+    } catch {
+      parts.push(`${p}:absent`);
+    }
+  }
+  return parts.join("|");
+}
+async function defaultReadPrices() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return JSON.parse(await fs.readFile(path.join(here, PRICING_FILENAME), "utf8"));
+}
+var NORMALIZED_TABLES = /* @__PURE__ */ new WeakMap();
+function normalizedTable(table) {
+  const cached = NORMALIZED_TABLES.get(table);
+  if (cached) return cached;
+  const normalized = /* @__PURE__ */ new Map();
+  const ambiguous = /* @__PURE__ */ new Set();
+  for (const [rawKey, rate] of Object.entries(table)) {
+    if (rawKey.startsWith("_")) continue;
+    const key = priceTableKey(rawKey);
+    if (normalized.has(key) && JSON.stringify(normalized.get(key)) !== JSON.stringify(rate)) ambiguous.add(key);
+    normalized.set(key, rate);
+  }
+  for (const key of ambiguous) normalized.delete(key);
+  NORMALIZED_TABLES.set(table, normalized);
+  return normalized;
+}
+function lookupRate(table, modelId) {
+  if (!table || !modelId) return null;
+  const rates = normalizedTable(table);
+  const hit = resolvePriceKey(modelId, (key) => rates.get(key));
+  return hit ? applyBedrockRegionalPremium(hit.value, modelId) : null;
+}
+function messageCost(rate, usage) {
+  const cacheWriteRate = rate.cacheCreation ?? rate.cacheWrite ?? 0;
+  const split = usage.cache_creation;
+  const write5m = split?.ephemeral_5m_input_tokens ?? 0;
+  const write1h = split?.ephemeral_1h_input_tokens ?? 0;
+  const cacheWrite = write5m || write1h ? write5m * cacheWriteRate + write1h * (rate.cacheWrite1h ?? cacheWriteRate) : (usage.cache_creation_input_tokens ?? 0) * cacheWriteRate;
+  return ((usage.input_tokens ?? 0) * (rate.input ?? 0) + (usage.output_tokens ?? 0) * (rate.output ?? 0) + (usage.cache_read_input_tokens ?? 0) * (rate.cacheRead ?? 0) + cacheWrite) / 1e6;
+}
+async function computeSessionCost(transcriptPath, {
+  readFile = fs.readFile,
+  readDir = fs.readdir,
+  writeFile = fs.writeFile,
+  stat = fs.stat,
+  readPrices = defaultReadPrices
+} = {}) {
+  if (!transcriptPath) return null;
+  let table;
+  try {
+    table = await readPrices();
+  } catch {
+    return null;
+  }
+  const subagentDir = path.join(
+    path.dirname(transcriptPath),
+    path.basename(transcriptPath, ".jsonl"),
+    "subagents"
+  );
+  const sourcePaths = [transcriptPath];
+  try {
+    for (const name of await readDir(subagentDir)) {
+      if (name.endsWith(".jsonl")) sourcePaths.push(path.join(subagentDir, name));
+    }
+  } catch {
+  }
+  const signature = await sourceSignature(sourcePaths, stat);
+  try {
+    const cached = JSON.parse(await readFile(COST_CACHE_FILE, "utf8"));
+    if (cached.schema === COST_CACHE_SCHEMA && cached.signature === signature && typeof cached.cost === "number" && typeof cached.exact === "boolean") {
+      return { cost: cached.cost, exact: cached.exact };
+    }
+  } catch {
+  }
+  const sources = [];
+  for (const sourcePath of sourcePaths) {
+    try {
+      sources.push(await readFile(sourcePath, "utf8"));
+    } catch {
+    }
+  }
+  const byMessage = /* @__PURE__ */ new Map();
+  let anon = 0;
+  for (const raw of sources) {
+    for (const line of raw.split("\n")) {
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line)?.message;
+      } catch {
+        continue;
+      }
+      if (!message?.usage) continue;
+      const id = message.id ?? `anon:${anon++}`;
+      const model = parseBackendModelName(message) ?? parseRoutingHeaders(message)?.routedModel ?? message.model ?? "";
+      byMessage.set(id, { model, usage: message.usage });
+    }
+  }
+  let cost = 0;
+  let exact = true;
+  for (const { model, usage } of byMessage.values()) {
+    const rate = lookupRate(table, model);
+    if (!rate) {
+      exact = false;
+      continue;
+    }
+    cost += messageCost(rate, usage);
+  }
+  const result = { cost, exact };
+  try {
+    await writeFile(COST_CACHE_FILE, JSON.stringify({ schema: COST_CACHE_SCHEMA, signature, ...result }), "utf8");
+  } catch {
+  }
+  return result;
+}
+function formatDuration(ms) {
+  if (typeof ms !== "number" || Number.isNaN(ms) || ms < 0) return null;
+  const mins = Math.floor(ms / 6e4);
+  const secs = Math.floor(ms % 6e4 / 1e3);
+  return `${mins}m ${secs}s`;
+}
+function fmt(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+var C = {
+  reset: "\x1B[0m",
+  purple: "\x1B[38;2;177;185;249m",
+  green: "\x1B[0;32m",
+  yellow: "\x1B[0;33m",
+  red: "\x1B[0;31m",
+  cyan: "\x1B[0;36m",
+  blue: "\x1B[0;94m",
+  gray: "\x1B[0;37m"
+};
+var c = (color, text) => `${color}${text}${C.reset}`;
+function ctxBar(pct) {
+  if (typeof pct !== "number" || Number.isNaN(pct)) return null;
+  const clamped = Math.max(0, Math.min(100, pct));
+  const color = clamped >= 90 ? C.red : clamped >= 70 ? C.yellow : C.green;
+  const filled = Math.floor(clamped / 10);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+  return `${c(color, bar)} ${pct}%`;
+}
+function buildStatusLine({ projectName, branch, model, actualModel, ctxPct, tokIn, tokOut, cost, costExact, durationMs }) {
+  const parts = [];
+  if (projectName) parts.push(c(C.purple, `[${projectName}]`));
+  if (branch) parts.push(c(C.blue, `(${branch})`));
+  if (model) parts.push(c(C.cyan, `[${actualModel ? `${model} \u2192 ${actualModel}` : model}]`));
+  const bar = ctxBar(ctxPct);
+  if (bar) parts.push(bar);
+  const stats = [];
+  if (tokIn != null) stats.push(`in:${fmt(tokIn)}`);
+  if (tokOut != null) stats.push(`out:${fmt(tokOut)}`);
+  if (stats.length) parts.push(c(C.gray, stats.join(" ")));
+  if (typeof cost === "number" && !Number.isNaN(cost)) {
+    parts.push(c(C.yellow, `${costExact ? "" : "~"}$${cost.toFixed(4)}`));
+  }
+  const dur = formatDuration(durationMs);
+  if (dur) parts.push(c(C.gray, dur));
+  return parts.join(" | ");
+}
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", () => resolve(data));
+  });
+}
+async function gitBranch(cwd) {
+  try {
+    const { stdout } = await exec("git", ["--no-optional-locks", "symbolic-ref", "--short", "HEAD"], { cwd, timeout: 2e3 });
+    if (stdout.trim()) return stdout.trim();
+  } catch {
+  }
+  try {
+    const { stdout } = await exec("git", ["--no-optional-locks", "rev-parse", "--short", "HEAD"], { cwd, timeout: 2e3 });
+    return stdout.trim() || "";
+  } catch {
+    return "";
+  }
+}
+async function resolveBudget({
+  readFile = fs.readFile,
+  writeFile = fs.writeFile,
+  fetchImpl = fetch,
+  getAuthHeadersImpl = getAuthHeaders
+} = {}) {
+  let config;
+  try {
+    config = JSON.parse(await readFile(CONFIG_FILE, "utf8"));
+  } catch {
+    return { budget: null, budgetError: null };
+  }
+  const sessionProfile = process.env.CODEMIE_PROFILE_NAME;
+  const profileName = sessionProfile && config.profiles?.[sessionProfile] ? sessionProfile : config.activeProfile;
+  try {
+    const cache = JSON.parse(await readFile(CACHE_FILE, "utf8"));
+    const validShape = cache.schema === CACHE_SCHEMA && cache.profile === profileName && typeof cache.value === "object" && cache.value !== null && typeof cache.value.text === "string";
+    if (validShape && Date.now() - cache.ts < CACHE_TTL_MS) {
+      return { budget: cache.value, budgetError: null };
+    }
+  } catch {
+  }
+  const profile = config.profiles?.[profileName];
+  const { baseUrl } = profile ?? {};
+  const codeMieUrl = config.workspace?.codeMieUrl;
+  const userEmail = config.userEmail;
+  if (!profile || !codeMieUrl || !baseUrl || !userEmail) {
+    return { budget: null, budgetError: null };
+  }
+  let headers;
+  try {
+    headers = await getAuthHeadersImpl(codeMieUrl);
+  } catch (e) {
+    return { budget: null, budgetError: e instanceof Error ? e.message : String(e) };
+  }
+  if (!headers) {
+    return { budget: null, budgetError: "reauthenticate" };
+  }
+  try {
+    const res = await fetchImpl(`${baseUrl}/v1/analytics/budget_usage`, {
+      headers: { "Content-Type": "application/json", "X-CodeMie-Client": "codemie-cli", ...headers }
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const contentType = res.headers?.get?.("content-type") ?? "";
+    if (!contentType.includes("json")) return { budget: null, budgetError: null };
+    const json = await res.json();
+    const row = matchBudgetRow(json?.data?.rows, userEmail);
+    if (!row) throw new Error("budget row not found");
+    const budget = formatBudgetSegment(row);
+    await writeFile(CACHE_FILE, JSON.stringify({ schema: CACHE_SCHEMA, profile: profileName, ts: Date.now(), value: budget }), "utf8");
+    return { budget, budgetError: null };
+  } catch (e) {
+    const code = e instanceof Error && e.cause && typeof e.cause === "object" && "code" in e.cause ? e.cause.code : void 0;
+    const message = e instanceof Error ? e.message : String(e);
+    return { budget: null, budgetError: code ? `budget: ${code}` : message };
+  }
+}
+async function main() {
+  const stdinRaw = await readStdin();
+  let basic;
+  try {
+    basic = extractBasicInfo(JSON.parse(stdinRaw));
+  } catch {
+    basic = extractBasicInfo({});
+  }
+  const labels = parseModelLabels(process.env);
+  const nominalLabel = labels[basic.modelId];
+  if (nominalLabel) basic.model = nominalLabel;
+  const branchPromise = basic.cwd ? gitBranch(basic.cwd) : Promise.resolve("");
+  const [branch, actualModel, priced] = await Promise.all([
+    branchPromise,
+    isRoutingConfigured(process.env, basic.modelId) ? resolveActualModel(basic.transcriptPath, { labels }) : Promise.resolve(null),
+    computeSessionCost(basic.transcriptPath)
+  ]);
+  const cost = priced ? priced.cost : basic.cost;
+  const costExact = priced ? priced.exact : false;
+  process.stdout.write(buildStatusLine({ ...basic, branch, actualModel, cost, costExact }));
+}
+function isMainModule(argv1, metaUrl) {
+  if (!argv1) return false;
+  try {
+    return fileURLToPath(metaUrl) === argv1;
+  } catch {
+    return false;
+  }
+}
+if (isMainModule(process.argv[1], import.meta.url)) {
+  main().catch(() => {
+    process.stdout.write("");
+  });
+}
+export {
+  buildStatusLine,
+  computeSessionCost,
+  ctxBar,
+  extractBasicInfo,
+  fmt,
+  formatBudgetSegment,
+  formatDuration,
+  getAuthHeaders,
+  isMainModule,
+  isRoutingConfigured,
+  lookupRate,
+  main,
+  matchBudgetRow,
+  normalizeModelId,
+  parseLastAssistantTurn,
+  parseModelLabels,
+  parseRouterModelIds,
+  resolveActualModel,
+  resolveBudget
+};