march-cli 0.1.35 → 0.1.37

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/command.mjs

@@ -6,11 +6,11 @@ import { createWebSessionManager, resolveWorkspace } from "./session-manager.mjs
 const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_PORT = 4174;
 
-export async function runWebUiCommand(args, { config, cwd, stateRoot, useRuntimeProcess = true } = {}) {
+export async function runWebUiCommand(args, { config, cwd, stateRoot } = {}) {
   const host = args.host ?? DEFAULT_HOST;
   assertLoopbackHost(host);
   const port = Number.parseInt(args.port ?? "", 10) || DEFAULT_PORT;
-  const runtime = createWebSessionManager({ args, config, launchCwd: cwd, stateRoot, useRuntimeProcess });
+  const runtime = createWebSessionManager({ args, config, launchCwd: cwd, stateRoot });
   const initialWorkspace = resolveInitialWorkspace(args, cwd);
   if (initialWorkspace) await runtime.createSession(initialWorkspace);
 

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

@@ -3,17 +3,12 @@ import { basename, join, resolve } from "node:path";
 import { existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
 import { createMarchAuthStorage } from "../auth/storage.mjs";
 import { createRuntimeRunner } from "../cli/startup/create-runtime-runner.mjs";
-import { createPermissionController, MODE } from "../cli/permissions.mjs";
 import { createCliShellRuntime } from "../shell/cli-runtime.mjs";
 import { MarkdownMemoryStore } from "../memory/markdown-store.mjs";
-import { createMarkdownMemoryTools } from "../memory/markdown-tools.mjs";
 import { resolveMemoryRoot } from "../memory/root.mjs";
 import { defaultProfilePaths, ensureProfileFiles } from "../context/profiles.mjs";
 import { loadOrCreateProjectId } from "../cli/startup/startup-session.mjs";
-import { createWebToolsFromConfig } from "../web/tools.mjs";
 import { createLogger, installProcessLogHandlers } from "../debug/logger.mjs";
-import { createModelContextDumper } from "../debug/model-context-dumper.mjs";
-import { createDesktopTurnNotifier } from "../notification/desktop-notifier.mjs";
 import { discoverProjectExtensionPaths } from "../extensions/discovery.mjs";
 import { loadProjectLifecycleHookManifests } from "../extensions/lifecycle-manifest.mjs";
 import { normalizeRemoteMemorySources } from "../memory/remote/config.mjs";
@@ -22,7 +17,7 @@ import { prepareTurnInput } from "../cli/turn/turn-input-preparer.mjs";
 const MAX_WORKSPACE_DEPTH = 3;
 const MAX_WORKSPACE_ENTRIES = 200;
 
-export async function createWebRuntimeHost({ args, config, cwd, stateRoot, useRuntimeProcess = true } = {}) {
+export async function createWebRuntimeHost({ args, config, cwd, stateRoot } = {}) {
   stateRoot ??= join(homedir(), ".march");
   if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
   const logger = createLogger({ logDir: join(stateRoot, "logs") });
@@ -40,14 +35,10 @@ export async function createWebRuntimeHost({ args, config, cwd, stateRoot, useRu
 
   const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
   const remoteMemorySources = normalizeRemoteMemorySources(config);
-  const memoryTools = createMarkdownMemoryTools(memoryStore, { remoteSources: remoteMemorySources });
   const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
   const extensionPaths = discoverProjectExtensionPaths(cwd);
   const lifecycleManifests = loadProjectLifecycleHookManifests(cwd);
   const contextDumpRoot = resolve(projectMarchDir, "context-dumps", Date.now().toString(36));
-  const modelContextDumper = createModelContextDumper({ enabled: args.dumpContext, rootDir: contextDumpRoot });
-  const permissionController = createPermissionController({ mode: args.permissionMode ?? MODE.BYPASS });
-  const turnNotifier = createDesktopTurnNotifier({ enabled: Boolean(config.notifications?.turnEnd), config: config.notifications });
   const ui = createHeadlessWebUi();
   const currentProject = basename(cwd);
   const namespace = loadOrCreateProjectId(projectMarchDir);
@@ -72,20 +63,9 @@ export async function createWebRuntimeHost({ args, config, cwd, stateRoot, useRu
     remoteMemorySources,
   };
   const runner = await createRuntimeRunner({
-    useRuntimeProcess,
     runnerOptions,
     ui,
-    memoryStore,
-    memoryTools,
     shellRuntime,
-    webTools: createWebToolsFromConfig(config),
-    usePiSessions: true,
-    usePiRuntimeHost: true,
-    authStorage: authConfig.authStorage,
-    permissionController,
-    modelContextDumper,
-    turnNotifier,
-    logger,
   });
   let turnRunning = false;
 
@@ -96,12 +76,14 @@ 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;
-      const input = prepareTurnInput({ prompt, runner, memoryStore, currentProject });
-      runner.runtimeUiEvents.emit({ type: "web_user_message", text: input.userMessage });
+      memoryStore.beginTurn();
       try {
+        const input = prepareTurnInput({ prompt, runner, memoryStore, currentProject });
+        runner.runtimeUiEvents.emit({ type: "web_user_message", text: input.userMessage });
         return await runner.runTurn(input.fullPrompt, input.userMessage, input.runOptions);
       } finally {
         turnRunning = false;
@@ -123,6 +105,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 +121,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

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { basename, resolve } from "node:path";
 import { createWebRuntimeHost } from "./runtime-host.mjs";
 
-export function createWebSessionManager({ args, config, launchCwd, stateRoot, useRuntimeProcess = true } = {}) {
+export function createWebSessionManager({ args, config, launchCwd, stateRoot } = {}) {
   const sessions = new Map();
   const activities = [];
   let activeSessionId = null;
@@ -12,7 +12,7 @@ export function createWebSessionManager({ args, config, launchCwd, stateRoot, us
   async function createSession(workspacePath) {
     const workspace = resolveWorkspace(workspacePath, launchCwd);
     const id = `session-${Date.now().toString(36)}-${nextSessionNumber++}`;
-    const runtime = await createWebRuntimeHost({ args, config, cwd: workspace, stateRoot, useRuntimeProcess });
+    const runtime = await createWebRuntimeHost({ args, config, cwd: workspace, stateRoot });
     const session = { id, workspace, title: basename(workspace) || workspace, runtime, createdAt: Date.now() };
     sessions.set(id, session);
     activeSessionId = id;
@@ -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}

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

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import type { ActivityEvent, SessionSummary } from "../model";
+import type { ActivityEvent, ProviderQuotaSnapshot, SessionSummary } from "../model";
 import type { FsEntry } from "../runtime/client";
 
 type RightSidebarProps = {
@@ -7,6 +7,7 @@ type RightSidebarProps = {
   activity: ActivityEvent[];
   fsEntries: FsEntry[];
   fsPath: string | null;
+  providerQuota?: ProviderQuotaSnapshot | null;
   running: boolean;
   onOpenSession: (sessionId: string) => Promise<void>;
   onCreateSession: (workspacePath: string) => Promise<void>;
@@ -14,7 +15,9 @@ type RightSidebarProps = {
   onBrowsePath: (path: string) => Promise<void>;
 };
 
-export function RightSidebar({ sessions, activity, fsEntries, fsPath, running, onOpenSession, onCreateSession, onBrowseRoots, onBrowsePath }: RightSidebarProps) {
+export function RightSidebar(props: RightSidebarProps) {
+  const { sessions, activity, fsEntries, fsPath, providerQuota, running } = props;
+  const { onOpenSession, onCreateSession, onBrowseRoots, onBrowsePath } = props;
   const [workspacePath, setWorkspacePath] = useState("");
   const canCreate = workspacePath.trim().length > 0 && !running;
 
@@ -50,6 +53,8 @@ export function RightSidebar({ sessions, activity, fsEntries, fsPath, running, o
           ))}
         </div>
 
+        {providerQuota ? <ProviderQuotaCard quota={providerQuota} /> : null}
+
         <div className="right-divider">Sessions</div>
         {sessions.map((session) => (
           <button key={session.id} className={session.active ? "session-row active" : "session-row"} type="button" onClick={() => onOpenSession(session.id)}>
@@ -68,3 +73,43 @@ export function RightSidebar({ sessions, activity, fsEntries, fsPath, running, o
     </aside>
   );
 }
+
+function ProviderQuotaCard({ quota }: { quota: ProviderQuotaSnapshot }) {
+  return (
+    <div className="provider-quota" aria-label="Provider quota">
+      <div className="provider-quota-header">
+        <span>{quota.label}</span>
+        <time>{quota.providerId}</time>
+      </div>
+      {quota.limits.flatMap((limit) => limit.windows.map((window) => {
+        const left = Math.round(window.remainingPercent);
+        return (
+          <div key={`${limit.id}:${window.id}`} className="quota-row">
+            <div className="quota-row-main">
+              <span>{formatQuotaLabel(window.label)}</span>
+              <strong>{left}% left</strong>
+            </div>
+            <div className="quota-bar" aria-label={`${left}% quota left`}>
+              <span style={{ width: `${Math.max(0, Math.min(100, left))}%` }} />
+            </div>
+            <em>{formatReset(window.resetsAt)}</em>
+          </div>
+        );
+      }))}
+    </div>
+  );
+}
+
+function formatQuotaLabel(label: string) {
+  return label === "weekly" ? "Weekly limit:" : `${label} limit:`;
+}
+
+function formatReset(resetsAt?: string | null) {
+  if (!resetsAt) return "reset unknown";
+  const date = new Date(resetsAt);
+  if (Number.isNaN(date.getTime())) return "reset unknown";
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const month = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][date.getMonth()];
+  return `resets ${hours}:${minutes} on ${date.getDate()} ${month}`;
+}