march-cli 0.1.35 → 0.1.36

package/src/cli/commands/registry/slash-command-registry.mjs

@@ -97,13 +97,16 @@ export const SLASH_COMMANDS = [
   exactCommand({
     name: "status",
     description: "Show runtime status",
-    run: async ({ ui, runner, sessionState, sessionSource }) => writeLines(ui, statusCommand({
-      runner,
-      sessionState,
-      sessionSource,
-      extensionDiagnostics: runner.getExtensionDiagnostics?.() ?? [],
-      lifecycleState: runner.getExtensionLifecycleState?.() ?? null,
-    })),
+    run: async ({ ui, runner, sessionState, sessionSource }) => {
+      await runner.getProviderQuotaSnapshot?.({ emit: true }).catch(() => null);
+      return writeLines(ui, statusCommand({
+        runner,
+        sessionState,
+        sessionSource,
+        extensionDiagnostics: runner.getExtensionDiagnostics?.() ?? [],
+        lifecycleState: runner.getExtensionLifecycleState?.() ?? null,
+      }));
+    },
   }),
   exactCommand({
     name: "notify",

package/src/cli/commands/status-command.mjs

@@ -10,15 +10,20 @@ export function statusCommand({
   lifecycleState = null,
   gitBranch = getGitBranch(runner.engine.cwd),
 }) {
-  return [formatStatusLine({
-    engine: runner.engine,
-    sessionState,
-    sessionStats: runner.getSessionStats?.() ?? null,
-    sessionSource,
-    extensionDiagnostics,
-    lifecycleState,
-    gitBranch,
-  })];
+  const providerQuota = runner.getCachedProviderQuotaSnapshot?.() ?? null;
+  const lines = [
+    ...formatStatusLines({
+      engine: runner.engine,
+      sessionState,
+      sessionStats: runner.getSessionStats?.() ?? null,
+      sessionSource,
+      extensionDiagnostics,
+      lifecycleState,
+      gitBranch,
+    }),
+    ...formatProviderQuotaLines(providerQuota),
+  ];
+  return lines.length > 0 ? lines : ["No provider quota available."];
 }
 
 export function statusBarLine({
@@ -37,35 +42,48 @@ export function statusBarLine({
   });
 }
 
-export function formatStatusLine({
-  engine,
-  sessionState,
-  sessionStats = null,
-  sessionSource = "pi",
+export function formatStatusLine(options) {
+  return formatStatusLines(options).join("  ");
+}
+
+export function formatStatusLines({
   extensionDiagnostics = [],
   lifecycleState = null,
-  gitBranch = null,
 }) {
-  const statsSessionId = sessionStats?.sessionId ?? sessionState?.sessionId ?? "unknown";
-  const tokens = sessionStats?.tokens
-    ? `${sessionStats.tokens.input ?? 0}in/${sessionStats.tokens.output ?? 0}out`
-    : "n/a";
-  const parts = [
-    `git:${gitBranch || "none"}`,
-    `session:${statsSessionId}`,
-    `source:${sessionSource}`,
-  ];
-  if (engine.sessionName) parts.push(`name:${engine.sessionName}`);
-  const remoteMemories = engine.remoteMemorySources ?? [];
-  if (remoteMemories.length > 0) parts.push(`remote-memory:${remoteMemories.map((source) => source.name).join(",")}`);
-  parts.push(
-    `model:${engine.modelId}`,
-    `provider:${engine.provider}`,
-    `thinking:${engine.thinkingLevel ?? "unknown"}`,
-    `tokens:${tokens}`,
-    `ext:${formatExtensionDiagnosticSummary(extensionDiagnostics, lifecycleState)}`,
-  );
-  return parts.join("  ");
+  const diagnosticSummary = formatExtensionDiagnosticSummary(extensionDiagnostics, lifecycleState);
+  return shouldShowDiagnostics(diagnosticSummary) ? [`Extensions: ${diagnosticSummary}`] : [];
+}
+
+export function formatProviderQuotaLines(providerQuota, { width = 20 } = {}) {
+  const windows = providerQuota?.limits?.flatMap((limit) => limit.windows ?? []) ?? [];
+  return windows.slice(0, 2).map((window) => formatProviderQuotaLine(window, { width }));
+}
+
+export function formatProviderQuotaLine(window, { width = 20 } = {}) {
+  const label = window.label === "weekly" ? "Weekly limit:" : `${window.label} limit:`;
+  const left = formatPercent(window.remainingPercent);
+  return `${label.padEnd(28)} ${formatQuotaBar(window.remainingPercent, width)} ${left}% left (${formatQuotaReset(window.resetsAt)})`;
+}
+
+export function formatQuotaBar(percent, width = 20) {
+  const value = Math.max(0, Math.min(100, Number(percent) || 0));
+  const filled = Math.round((value / 100) * width);
+  return `[${"█".repeat(filled)}${"░".repeat(width - filled)}]`;
+}
+
+export function formatQuotaReset(resetsAt) {
+  if (!resetsAt) return "reset unknown";
+  const date = new Date(resetsAt);
+  if (Number.isNaN(date.getTime())) return "reset unknown";
+  return `resets ${formatResetDate(date)}`;
+}
+
+function formatResetDate(date) {
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const day = date.getDate();
+  const month = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][date.getMonth()];
+  return `${hours}:${minutes} on ${day} ${month}`;
 }
 
 export function formatStatusBarLine({
@@ -154,6 +172,10 @@ export function formatCompactTokenCount(tokens) {
   return `${formatOneDecimal(value / 1000000)}M`;
 }
 
+function shouldShowDiagnostics(summary) {
+  return summary !== "ok" && summary.split(",").some((part) => !part.endsWith("info"));
+}
+
 export function formatExtensionDiagnosticSummary(extensionDiagnostics = [], lifecycleState = null) {
   const diagnostics = [...extensionDiagnostics, ...(lifecycleState?.diagnostics ?? [])];
   if (diagnostics.length === 0) return "ok";
@@ -194,3 +216,7 @@ function formatOneDecimal(value) {
   const rounded = Math.round(value * 10) / 10;
   return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
 }
+
+function formatPercent(value) {
+  return Math.round(Math.max(0, Math.min(100, Number(value) || 0)));
+}

package/src/context/system-core/base.md

@@ -103,6 +103,11 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 - Use memory_save() to create memories or update whole metadata fields on an existing memory. Before creating a new memory, first search/open related memories and merge updates into an existing memory when they share the same topic, project, or decision thread; prefer modifying the existing memory file over creating a scattered new one. Tags are the primary retrieval key for future recall. Prefer lowercase-kebab-case tags like 'march-cli', 'tooling', 'permissions'.
 - When learning multiple related external workflows or skills, maintain memory as an evolving domain library: start with the specific source name when only one item exists, then rename and rewrite the memory title/description as the scope grows; merge new related learnings into the same memory, preserving each source's unique traits while distilling reusable principles.
 - Distinguish "migrating a Skill to memory" from "learning a Skill": migration preserves the complete Skill folder under memory_root/skills/ and creates a memory entry as its index; that memory should describe what the Skill is for and reference the copied Skill folder path so future recall knows how to use it. Learning only reads and internalizes the Skill's methods, scenarios, and principles into ordinary memory without copying source files. Infer the action from the user's wording, and ask when ambiguous.
+- Do not proactively modify the agent profile. Update `agent.md` only when the user explicitly asks to change persistent agent behavior.
+- Proactively maintain the user profile when stable, reusable user preferences, working style, goals, or identity signals appear in conversation.
+- For user profile updates, distinguish explicit facts from inferred preferences. Write explicit facts directly; write inferred items as preferences or tendencies, and avoid overstating confidence.
+- Do not store transient task details, sensitive information, or one-off opinions in the user profile. Use memory for project-specific reusable knowledge and current conversation for short-lived context.
+- When a user profile update is non-obvious or potentially sensitive, ask before writing; otherwise update it as part of normal task completion and mention it briefly in the final summary.
 - Unlike recall blocks, this system-core center is always visible in every model call. Only update the center for instructions that must always be followed; use memory for contextual, project-specific, or recall-dependent knowledge.
 - If execution takes a meaningful detour, create or update a memory after the task. A detour means the initial plan or assumption failed, multiple approaches were tried, and the final successful path contains reusable project knowledge. Record the failed assumption, what was tried, and the successful approach. Prefer updating an existing related memory over creating a new one.
 </memory_system>

package/src/provider/quota/codex.mjs

@@ -0,0 +1,278 @@
+import { getOAuthProvider } from "@earendil-works/pi-ai/oauth";
+
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+
+export async function fetchOpenAICodexQuota({ authStorage, model, fetchImpl = fetch, now = new Date() } = {}) {
+  const token = await resolveCodexAccessToken(authStorage);
+  const accountId = resolveCodexAccountId(authStorage, token);
+  const response = await fetchImpl(CODEX_USAGE_URL, {
+    method: "GET",
+    headers: buildCodexUsageHeaders(token, accountId),
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Codex quota request failed (${response.status}): ${text || response.statusText}`);
+  }
+  const payload = await response.json();
+  return normalizeCodexQuotaPayload(payload, { model, capturedAt: now.toISOString() });
+}
+
+export function normalizeCodexQuotaPayload(payload, { model = null, capturedAt = new Date().toISOString() } = {}) {
+  const snapshots = Array.isArray(payload) ? payload : snapshotsFromCodexUsagePayload(payload);
+  return normalizeCodexQuotaSnapshots(snapshots, { model, capturedAt });
+}
+
+export function normalizeCodexQuotaSnapshots(snapshots, { model = null, capturedAt = new Date().toISOString() } = {}) {
+  const limits = snapshots.map(normalizeSnapshot).filter((limit) => limit.windows.length > 0);
+  if (limits.length === 0) return null;
+  return {
+    providerId: "openai-codex",
+    modelId: model?.id ?? null,
+    label: "GPT usage",
+    planType: firstNonEmpty(snapshots.map((snapshot) => readField(snapshot, "planType", "plan_type"))),
+    capturedAt,
+    limits,
+  };
+}
+
+export function parseOpenAICodexQuotaHeaders(headers, { model = null, capturedAt = new Date().toISOString() } = {}) {
+  const normalized = normalizeHeaders(headers);
+  const limitIds = new Set(["codex"]);
+  for (const name of Object.keys(normalized)) {
+    const prefix = name.endsWith("-primary-used-percent") ? name.slice(2, -"-primary-used-percent".length) : null;
+    if (prefix) limitIds.add(prefix.replaceAll("-", "_"));
+  }
+  const snapshots = [...limitIds]
+    .map((limitId) => snapshotFromHeaders(normalized, limitId))
+    .filter((snapshot) => snapshot.primary || snapshot.secondary || snapshot.credits);
+  return normalizeCodexQuotaSnapshots(snapshots, { model, capturedAt });
+}
+
+export function parseOpenAICodexQuotaEvent(payload, { model = null, capturedAt = new Date().toISOString() } = {}) {
+  const event = typeof payload === "string" ? parseJson(payload) : payload;
+  if (!event || event.type !== "codex.rate_limits") return null;
+  const snapshot = {
+    limitId: readField(event, "metered_limit_name", "limit_name") ?? "codex",
+    limitName: null,
+    primary: mapWindow(readField(readField(event, "rate_limits", "rateLimits"), "primary")),
+    secondary: mapWindow(readField(readField(event, "rate_limits", "rateLimits"), "secondary")),
+    credits: readField(event, "credits") ?? null,
+    planType: readField(event, "plan_type", "planType") ?? null,
+    rateLimitReachedType: null,
+  };
+  return normalizeCodexQuotaSnapshots([snapshot], { model, capturedAt });
+}
+
+async function resolveCodexAccessToken(authStorage) {
+  const token = await authStorage?.getApiKey?.("openai-codex", { includeFallback: false });
+  if (token) return token;
+  const credentials = authStorage?.get?.("openai-codex");
+  if (!credentials) throw new Error("OpenAI Codex not authenticated. Run: march login openai-codex");
+  const provider = getOAuthProvider("openai-codex");
+  if (!provider) throw new Error("OpenAI Codex OAuth provider is not available");
+  return provider.getApiKey(credentials);
+}
+
+function resolveCodexAccountId(authStorage, token) {
+  const credentials = authStorage?.get?.("openai-codex");
+  return credentials?.accountId ?? credentials?.chatgpt_account_id ?? extractAccountId(token);
+}
+
+function extractAccountId(token) {
+  try {
+    const [, payload] = String(token).split(".");
+    const parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    const accountId = parsed?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
+    if (typeof accountId === "string" && accountId) return accountId;
+  } catch {}
+  throw new Error("Failed to extract Codex account ID from token");
+}
+
+function buildCodexUsageHeaders(token, accountId) {
+  return {
+    authorization: `Bearer ${token}`,
+    "chatgpt-account-id": accountId,
+    originator: "march",
+    "user-agent": "march-cli",
+    accept: "application/json",
+  };
+}
+
+function snapshotsFromCodexUsagePayload(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const planType = readField(payload, "planType", "plan_type") ?? null;
+  const reached = readField(payload, "rateLimitReachedType", "rate_limit_reached_type") ?? null;
+  const snapshots = [makeSnapshot({
+    limitId: "codex",
+    limitName: null,
+    rateLimit: unwrap(readField(payload, "rateLimit", "rate_limit")),
+    credits: unwrap(readField(payload, "credits")),
+    planType,
+    rateLimitReachedType: unwrap(reached)?.kind ?? reached,
+  })];
+  const additional = readField(payload, "additionalRateLimits", "additional_rate_limits");
+  if (Array.isArray(additional)) {
+    for (const item of additional) {
+      snapshots.push(makeSnapshot({
+        limitId: readField(item, "meteredFeature", "metered_feature"),
+        limitName: readField(item, "limitName", "limit_name"),
+        rateLimit: unwrap(readField(item, "rateLimit", "rate_limit")),
+        credits: null,
+        planType,
+        rateLimitReachedType: null,
+      }));
+    }
+  }
+  return snapshots;
+}
+
+function makeSnapshot({ limitId, limitName, rateLimit, credits, planType, rateLimitReachedType }) {
+  return {
+    limitId: limitId ?? null,
+    limitName: limitName ?? null,
+    primary: mapWindow(readField(rateLimit, "primary", "primaryWindow", "primary_window")),
+    secondary: mapWindow(readField(rateLimit, "secondary", "secondaryWindow", "secondary_window")),
+    credits: credits ?? null,
+    planType,
+    rateLimitReachedType,
+  };
+}
+
+function snapshotFromHeaders(headers, limitId) {
+  const headerPrefix = `x-${limitId.replaceAll("_", "-")}`;
+  return {
+    limitId,
+    limitName: readHeader(headers, `${headerPrefix}-limit-name`),
+    primary: windowFromHeaders(headers, headerPrefix, "primary"),
+    secondary: windowFromHeaders(headers, headerPrefix, "secondary"),
+    credits: limitId === "codex" ? creditsFromHeaders(headers) : null,
+    planType: null,
+    rateLimitReachedType: null,
+  };
+}
+
+function windowFromHeaders(headers, prefix, windowId) {
+  const usedPercent = readHeader(headers, `${prefix}-${windowId}-used-percent`);
+  if (usedPercent === undefined) return null;
+  return {
+    usedPercent,
+    windowDurationMins: readHeader(headers, `${prefix}-${windowId}-window-minutes`),
+    resetsAt: readHeader(headers, `${prefix}-${windowId}-reset-at`),
+  };
+}
+
+function creditsFromHeaders(headers) {
+  const hasCredits = parseHeaderBool(readHeader(headers, "x-codex-credits-has-credits"));
+  const unlimited = parseHeaderBool(readHeader(headers, "x-codex-credits-unlimited"));
+  if (hasCredits === null || unlimited === null) return null;
+  return { hasCredits, unlimited, balance: readHeader(headers, "x-codex-credits-balance") ?? null };
+}
+
+function normalizeSnapshot(snapshot) {
+  const id = readField(snapshot, "limitId", "limit_id") ?? "quota";
+  return {
+    id,
+    name: readField(snapshot, "limitName", "limit_name") ?? id,
+    windows: [
+      normalizeWindow("primary", readField(snapshot, "primary")),
+      normalizeWindow("secondary", readField(snapshot, "secondary")),
+    ].filter(Boolean),
+    rateLimitReachedType: readField(snapshot, "rateLimitReachedType", "rate_limit_reached_type") ?? null,
+  };
+}
+
+function normalizeWindow(id, window) {
+  const normalized = mapWindow(window);
+  if (!normalized) return null;
+  const label = formatWindowLabel(normalized.windowDurationMins, id);
+  return {
+    id,
+    label,
+    usedPercent: normalized.usedPercent,
+    remainingPercent: Math.max(0, 100 - normalized.usedPercent),
+    windowDurationMins: normalized.windowDurationMins,
+    resetsAt: normalized.resetsAt,
+  };
+}
+
+function mapWindow(window) {
+  const unwrapped = unwrap(window);
+  if (!unwrapped || typeof unwrapped !== "object") return null;
+  const rawUsed = readField(unwrapped, "usedPercent", "used_percent");
+  const usedPercent = Number(rawUsed);
+  if (!Number.isFinite(usedPercent)) return null;
+  const rawMinutes = readField(unwrapped, "windowDurationMins", "window_minutes", "windowDurationMinutes");
+  const rawSeconds = readField(unwrapped, "limitWindowSeconds", "limit_window_seconds");
+  return {
+    usedPercent,
+    windowDurationMins: normalizeWindowMinutes(rawMinutes, rawSeconds),
+    resetsAt: normalizeResetTime(readField(unwrapped, "resetsAt", "resets_at", "resetAt", "reset_at")),
+  };
+}
+
+function normalizeWindowMinutes(minutes, seconds) {
+  const minuteValue = Number(minutes);
+  if (Number.isFinite(minuteValue) && minuteValue > 0) return minuteValue;
+  const secondValue = Number(seconds);
+  return Number.isFinite(secondValue) && secondValue > 0 ? Math.round(secondValue / 60) : null;
+}
+
+function normalizeResetTime(value) {
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    const millis = numeric < 10_000_000_000 ? numeric * 1000 : numeric;
+    return new Date(millis).toISOString();
+  }
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+
+function formatWindowLabel(minutes, fallback) {
+  if (!Number.isFinite(minutes) || minutes <= 0) return fallback;
+  if (minutes % (60 * 24 * 7) === 0) return "weekly";
+  if (minutes % 60 === 0) return `${minutes / 60}h`;
+  return `${minutes}m`;
+}
+
+function unwrap(value) {
+  return Array.isArray(value) && value.length === 1 ? value[0] : value;
+}
+
+function readField(object, ...keys) {
+  if (!object || typeof object !== "object") return undefined;
+  for (const key of keys) if (Object.hasOwn(object, key)) return object[key];
+  return undefined;
+}
+
+function normalizeHeaders(headers) {
+  if (!headers) return {};
+  if (typeof headers.entries === "function") {
+    return Object.fromEntries([...headers.entries()].map(([key, value]) => [key.toLowerCase(), String(value)]));
+  }
+  return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), String(value)]));
+}
+
+function readHeader(headers, name) {
+  const value = headers[name.toLowerCase()];
+  return value === undefined || value === "" ? undefined : value;
+}
+
+function parseHeaderBool(value) {
+  if (value === undefined) return null;
+  if (value === "1" || value.toLowerCase() === "true") return true;
+  if (value === "0" || value.toLowerCase() === "false") return false;
+  return null;
+}
+
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function firstNonEmpty(values) {
+  return values.find((value) => value !== null && value !== undefined && value !== "") ?? null;
+}

package/src/provider/quota/index.mjs

@@ -0,0 +1,46 @@
+import { fetchOpenAICodexQuota, parseOpenAICodexQuotaEvent, parseOpenAICodexQuotaHeaders } from "./codex.mjs";
+
+const quotaAdapters = new Map([
+  ["openai-codex", {
+    refresh: fetchOpenAICodexQuota,
+    observeHeaders: parseOpenAICodexQuotaHeaders,
+    observeEvent: parseOpenAICodexQuotaEvent,
+  }],
+]);
+
+export function supportsProviderQuota(providerId) {
+  return quotaAdapters.has(providerId);
+}
+
+export async function getProviderQuotaSnapshot({ providerId, model, authStorage, fetchImpl, now } = {}) {
+  const adapter = quotaAdapters.get(providerId);
+  if (!adapter) return null;
+  return adapter.refresh({ authStorage, model, fetchImpl, now });
+}
+
+export function observeProviderQuotaHeaders({ providerId, headers, model, capturedAt } = {}) {
+  const adapter = quotaAdapters.get(providerId);
+  return adapter?.observeHeaders?.(headers, { model, capturedAt }) ?? null;
+}
+
+export function observeProviderQuotaEvent({ providerId, payload, model, capturedAt } = {}) {
+  const adapter = quotaAdapters.get(providerId);
+  return adapter?.observeEvent?.(payload, { model, capturedAt }) ?? null;
+}
+
+export function createProviderQuotaService({ authStorage, fetchImpl = fetch, now = () => new Date() } = {}) {
+  return {
+    supports(providerId) {
+      return supportsProviderQuota(providerId);
+    },
+    refresh(model) {
+      return getProviderQuotaSnapshot({ providerId: model?.provider, model, authStorage, fetchImpl, now: now() });
+    },
+    observeHeaders(headers, model) {
+      return observeProviderQuotaHeaders({ providerId: model?.provider, headers, model, capturedAt: now().toISOString() });
+    },
+    observeEvent(payload, model) {
+      return observeProviderQuotaEvent({ providerId: model?.provider, payload, model, capturedAt: now().toISOString() });
+    },
+  };
+}

package/src/provider/quota/transport-observer.mjs

@@ -0,0 +1,99 @@
+const FETCH_INSTALLED = Symbol.for("march.providerQuota.fetchObserverInstalled");
+const WEBSOCKET_INSTALLED = Symbol.for("march.providerQuota.websocketObserverInstalled");
+const LISTENERS = Symbol.for("march.providerQuota.transportListeners");
+
+export function installProviderQuotaTransportObserver() {
+  installFetchObserver();
+  installWebSocketObserver();
+}
+
+export function subscribeProviderQuotaTransport(listener) {
+  const listeners = ensureListeners();
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+function installFetchObserver() {
+  if (globalThis[FETCH_INSTALLED]) return;
+  const originalFetch = globalThis.fetch;
+  if (typeof originalFetch !== "function") return;
+  globalThis.fetch = async function marchProviderQuotaFetch(input, init = {}) {
+    const response = await originalFetch.call(this, input, init);
+    if (isCodexResponsesHttpRequest(input, init)) {
+      notifyTransportListeners({ providerId: "openai-codex", source: "headers", headers: response.headers });
+    }
+    return response;
+  };
+  globalThis[FETCH_INSTALLED] = true;
+}
+
+function installWebSocketObserver() {
+  if (globalThis[WEBSOCKET_INSTALLED]) return;
+  const OriginalWebSocket = globalThis.WebSocket;
+  if (typeof OriginalWebSocket !== "function") return;
+
+  class MarchProviderQuotaWebSocket extends OriginalWebSocket {
+    constructor(url, protocolsOrOptions, maybeOptions) {
+      if (!isCodexResponsesWebSocketUrl(url)) {
+        return new OriginalWebSocket(url, protocolsOrOptions, maybeOptions);
+      }
+      super(url, protocolsOrOptions, maybeOptions);
+      this.addEventListener?.("message", async (event) => {
+        const payload = await decodeWebSocketData(event?.data).catch(() => null);
+        if (payload?.includes?.('"codex.rate_limits"')) {
+          notifyTransportListeners({ providerId: "openai-codex", source: "event", payload });
+        }
+      });
+    }
+  }
+  copyReadyStateConstants(MarchProviderQuotaWebSocket, OriginalWebSocket);
+  globalThis.WebSocket = MarchProviderQuotaWebSocket;
+  globalThis[WEBSOCKET_INSTALLED] = true;
+}
+
+function ensureListeners() {
+  globalThis[LISTENERS] = globalThis[LISTENERS] ?? new Set();
+  return globalThis[LISTENERS];
+}
+
+function notifyTransportListeners(event) {
+  for (const listener of [...ensureListeners()]) {
+    try {
+      listener(event);
+    } catch {}
+  }
+}
+
+function isCodexResponsesHttpRequest(input, init) {
+  const url = getRequestUrl(input);
+  if (!url || !url.includes("/codex/responses")) return false;
+  const method = init?.method ?? input?.method ?? "GET";
+  return String(method).toUpperCase() === "POST";
+}
+
+function isCodexResponsesWebSocketUrl(url) {
+  const raw = getRequestUrl(url);
+  return Boolean(raw?.includes("/codex/responses") && (raw.startsWith("ws://") || raw.startsWith("wss://")));
+}
+
+function getRequestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  if (input && typeof input.url === "string") return input.url;
+  return "";
+}
+
+async function decodeWebSocketData(data) {
+  if (typeof data === "string") return data;
+  if (data instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(data));
+  if (ArrayBuffer.isView(data)) return new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  if (data && typeof data.arrayBuffer === "function") return new TextDecoder().decode(new Uint8Array(await data.arrayBuffer()));
+  return null;
+}
+
+function copyReadyStateConstants(Target, OriginalWebSocket) {
+  for (const key of ["CONNECTING", "OPEN", "CLOSING", "CLOSED"]) {
+    const value = OriginalWebSocket[key];
+    if (typeof value === "number") Object.defineProperty(Target, key, { value, enumerable: true });
+  }
+}

package/src/web-ui/runtime-host.mjs

@@ -96,6 +96,7 @@ export async function createWebRuntimeHost({ args, config, cwd, stateRoot, useRu
     currentProject,
     snapshot: () => createWebSnapshot({ cwd, runner, currentProject }),
     subscribe: (listener) => runner.runtimeUiEvents.on(listener),
+    refreshProviderQuota: () => runner.getProviderQuotaSnapshot?.({ emit: true }) ?? null,
     async runTurn(prompt) {
       if (turnRunning) throw new Error("A turn is already running");
       turnRunning = true;
@@ -123,6 +124,7 @@ export function createHeadlessWebUi() {
     thinkingBlock: () => {}, toggleLastThinking: () => false,
     toolStart: () => {}, toolEnd: () => {}, textDelta: () => {},
     assistantReplyEnd: () => {}, status: () => {}, recall: () => {},
+    providerQuotaSnapshot: () => {},
     clearOutput: () => {}, restoreTranscript: () => {}, setStatusBar: () => {},
     turnStart: () => {}, turnEnd: () => {}, retryStart: () => {}, retryEnd: () => {},
     editDiff: () => {}, requestPermission: async () => true,
@@ -138,6 +140,7 @@ export function createWebSnapshot({ cwd, runner, currentProject = basename(cwd)
   return {
     workspace: readWorkspaceTree(cwd),
     timeline: { title: currentProject, meta: runtimeMeta(model), events: [] },
+    providerQuota: runner.getCachedProviderQuotaSnapshot?.() ?? null,
     sessions: [{ id: "current", title: runner.engine?.sessionName ?? currentProject, time: "now", active: true }],
     activity: [{ id: "runtime", action: "runner connected", time: "now" }],
     composer: { mode: "Chat", placeholder: "Message March…" },

package/src/web-ui/server.mjs

@@ -34,6 +34,7 @@ export async function handleApiRequest(req, res, runtime) {
     if (req.method === "POST" && pathname === "/api/sessions") return sendJson(res, await createRuntimeSession(req, runtime));
     if (req.method === "GET" && pathname === "/api/fs/roots") return sendJson(res, { roots: runtime.fsRoots() });
     if (req.method === "GET" && pathname === "/api/fs/list") return sendJson(res, { entries: runtime.fsList(getPathParam(req)) });
+    if (req.method === "GET" && pathname === "/api/provider-quota") return sendJson(res, { snapshot: await runtime.refreshProviderQuota(getSessionId(req)) });
     if (req.method === "POST" && pathname === "/api/turn") return sendJson(res, await runRuntimeTurn(req, runtime));
     if (req.method === "POST" && pathname === "/api/abort") return sendJson(res, { ok: true, result: runtime.abort(getSessionId(req)) });
     sendJson(res, { error: "Not found" }, 404);

package/src/web-ui/session-manager.mjs

@@ -33,6 +33,7 @@ export function createWebSessionManager({ args, config, launchCwd, stateRoot, us
     },
     subscribe(sessionId, listener) { return getSession(sessions, sessionId).runtime.subscribe(listener); },
     runTurn(sessionId, prompt) { return getSession(sessions, sessionId).runtime.runTurn(prompt); },
+    refreshProviderQuota(sessionId) { return getSession(sessions, sessionId).runtime.refreshProviderQuota?.() ?? null; },
     abort(sessionId) { return getSession(sessions, sessionId).runtime.abort?.(); },
     fsRoots() { return listFsRoots(launchCwd); },
     fsList(path) { return listFsDirectory(path); },
@@ -70,6 +71,7 @@ function createEmptySnapshot({ sessions, activeSessionId, activities }) {
     workspace: { id: "no-workspace", name: "Choose workspace", kind: "folder", selected: true },
     timeline: { title: "No session selected", meta: "Create a session and bind a workspace", events: [] },
     sessions: Array.from(sessions.values()).map((session) => toSessionSummary(session, session.id === activeSessionId)),
+    providerQuota: null,
     activity: activities,
     activeSessionId: null,
     composer: { mode: "No session", placeholder: "Choose a workspace to start…" },

package/src/web-ui/src/components/AppShell.tsx

@@ -28,6 +28,7 @@ export function AppShell({ runtime }: AppShellProps) {
         activity={model.activity}
         fsEntries={runtime.fsEntries}
         fsPath={runtime.fsPath}
+        providerQuota={model.providerQuota}
         running={runtime.running}
         onOpenSession={runtime.openSession}
         onCreateSession={runtime.createSession}