clauderipple 0.9.5 → 0.10.0

package/dist/router/src/admin.js

@@ -16,6 +16,7 @@
 //   POST /api/update    start `clauderipple update` in the background (it restarts this router)
 //   GET  /*           static files from packages/ui (the GUI itself)
 import crypto from "node:crypto";
+import { phoneRequest } from "./phone.js";
 import fs from "node:fs";
 import net from "node:net";
 import os from "node:os";
@@ -51,6 +52,8 @@ import { readClaudeAuthFile } from "./providers/anthropic-token-file.js";
 import { listClaudeAccounts, removeClaudeAccount, renameClaudeAccount, setPreferredClaudeAccount } from "./providers/anthropic-accounts.js";
 import { readChatGptAccounts, removeChatGptAccount, summarize as summarizeChatGptAccount, updateChatGptAccount } from "./providers/chatgpt/accounts.js";
 import { exhaustedForMs, IMAGE_ASPECTS, IMAGE_BACKGROUNDS, IMAGE_FORMATS } from "./providers/chatgpt/index.js";
+import { googleWindowsFromGroups } from "./providers/google/usage.js";
+import { isOpenCodeGo } from "./providers/opencode-usage.js";
 import { ANTIGRAVITY_WARNING, staticAntigravityModels } from "./providers/google/antigravity.js";
 import { readGoogleAccounts, removeGoogleAccount, summarize as summarizeGoogleAccount, updateGoogleAccount } from "./providers/google/accounts.js";
 import { GoogleOAuthSession } from "./providers/google/login.js";
@@ -100,6 +103,140 @@ async function claudeAccountUsage(deps) {
     }
     return rows;
 }
+/** A `{used_percent, window_minutes, reset_at}` snapshot window as `/api/limits` reads it, or null. */
+function limitWindowFrom(w) {
+    if (!w || typeof w !== "object" || Array.isArray(w))
+        return null;
+    const o = w;
+    const used = o.used_percent;
+    if (typeof used !== "number" || !Number.isFinite(used))
+        return null;
+    const minutes = typeof o.window_minutes === "number" && o.window_minutes > 0 ? o.window_minutes : undefined;
+    // A reset already in milliseconds would otherwise park a window for decades; the other readers
+    // normalise the same way (chatgpt windowResetMs).
+    const reset = typeof o.reset_at === "number" && Number.isFinite(o.reset_at) ? Math.round(o.reset_at > 1e12 ? o.reset_at / 1000 : o.reset_at) : undefined;
+    return { used_percent: used, ...(minutes !== undefined ? { window_minutes: minutes } : {}), ...(reset !== undefined ? { reset_at: reset } : {}) };
+}
+/** The kind a five-hour/weekly/other window takes, by its length in minutes. */
+function windowKind(minutes) {
+    return minutes === 300 ? "five_hour" : minutes === 10080 ? "seven_day" : "window";
+}
+/** One Claude subscription account's plan windows: the two main windows and the scoped weeklies. */
+function claudeLimitWindows(quota) {
+    const out = [];
+    const limits = quota.rate_limits;
+    for (const w of [limits?.primary, limits?.secondary]) {
+        const win = limitWindowFrom(w);
+        if (win)
+            out.push({ kind: windowKind(win.window_minutes), used_percent: win.used_percent, ...(win.window_minutes !== undefined ? { window_minutes: win.window_minutes } : {}), ...(win.reset_at !== undefined ? { reset_at: win.reset_at } : {}) });
+    }
+    const scoped = quota.scoped;
+    if (Array.isArray(scoped))
+        for (const s of scoped) {
+            if (!s || typeof s !== "object" || Array.isArray(s))
+                continue;
+            const entry = s;
+            const win = limitWindowFrom(entry);
+            if (!win || typeof entry.name !== "string" || !entry.name)
+                continue;
+            out.push({ kind: "scoped", label: entry.name, used_percent: win.used_percent, ...(win.window_minutes !== undefined ? { window_minutes: win.window_minutes } : {}), ...(win.reset_at !== undefined ? { reset_at: win.reset_at } : {}) });
+        }
+    return out;
+}
+/** The Claude Code login's plan windows as one account (the row shows Claude as a single group). */
+async function anthropicLimitAccounts(deps) {
+    let usage;
+    try {
+        usage = (await deps.claudeUsage?.()) ?? {};
+    }
+    catch {
+        return [];
+    }
+    const quota = usage.current ?? Object.values(usage)[0];
+    if (!quota)
+        return [];
+    const windows = claudeLimitWindows(quota);
+    if (!windows.length)
+        return [];
+    const at = typeof quota.at === "number" ? quota.at : Date.now();
+    return [{ account: 0, windows, at }];
+}
+/** Every ChatGPT account's windows, paused and needs-login accounts left out and unnumbered. */
+function chatgptLimitAccounts(accounts) {
+    const kept = accounts.filter((a) => a.state !== "paused" && a.state !== "needs-login");
+    const out = [];
+    kept.forEach((account, index) => {
+        const quota = account.quota;
+        if (!quota || typeof quota.at !== "number")
+            return;
+        const limits = quota.rate_limits;
+        const windows = [];
+        for (const w of [limits?.primary, limits?.secondary]) {
+            const win = limitWindowFrom(w);
+            if (win)
+                windows.push({ kind: windowKind(win.window_minutes), used_percent: win.used_percent, ...(win.window_minutes !== undefined ? { window_minutes: win.window_minutes } : {}), ...(win.reset_at !== undefined ? { reset_at: win.reset_at } : {}) });
+        }
+        if (windows.length)
+            out.push({ account: index, windows, at: quota.at });
+    });
+    return out;
+}
+/** Every Antigravity account's windows (Gemini's own plus the third-party ones), paused left out. */
+async function googleLimitAccounts(deps, name) {
+    const google = deps.google?.();
+    if (!google)
+        return [];
+    const statuses = google.accounts()[name] ?? [];
+    const groups = (await google.usage?.(name)) ?? {};
+    const kept = statuses.filter((a) => a.state !== "paused" && a.state !== "needs-login");
+    const at = Date.now();
+    const out = [];
+    kept.forEach((account, index) => {
+        const quotient = groups[account.id];
+        if (!quotient || !quotient.length)
+            return;
+        const windows = googleWindowsFromGroups(quotient);
+        if (windows.length)
+            out.push({ account: index, windows, at });
+    });
+    return out;
+}
+/** Every provider whose quota can be read, in one shape, for `GET /api/limits`. */
+async function buildLimits(deps) {
+    const providers = [];
+    const chatgpt = deps.chatgpt?.();
+    const accounts = chatgpt?.accounts?.() ?? {};
+    for (const [name, p] of Object.entries(deps.config().providers)) {
+        if (p.limits === false)
+            continue;
+        if (p.type === "anthropic" && p.auth === "claude-code") {
+            const rows = await anthropicLimitAccounts(deps);
+            if (rows.length)
+                providers.push({ provider: name, type: "anthropic", title: "Claude", accounts: rows });
+        }
+        else if (p.type === "chatgpt") {
+            const rows = chatgptLimitAccounts(accounts[name] ?? []);
+            if (rows.length)
+                providers.push({ provider: name, type: "chatgpt", title: "GPT", accounts: rows });
+        }
+        else if (p.type === "google" && p.auth === "antigravity") {
+            const rows = await googleLimitAccounts(deps, name);
+            if (rows.length)
+                providers.push({ provider: name, type: "google", title: "Gemini", accounts: rows });
+        }
+        else if (p.type === "openai-compatible" && isOpenCodeGo(p)) {
+            const windows = (await deps.opencodeUsage?.(name)) ?? [];
+            if (windows.length)
+                providers.push({ provider: name, type: "opencode-go", title: "Go", accounts: [{ account: 0, windows: windows.map((w) => ({ ...w })), at: Date.now() }] });
+        }
+        else if (p.type === "grok") {
+            const windows = (await deps.grokUsage?.(name)) ?? [];
+            if (windows.length)
+                providers.push({ provider: name, type: "grok", title: "Grok", accounts: [{ account: 0, windows: windows.map((w) => ({ ...w })), at: Date.now() }] });
+        }
+    }
+    return { providers };
+}
 // The CLI's `--effort` takes the same five; Opus, Sonnet and Haiku 5.5 answered `xhigh` (requests.jsonl, 2026-10-14, #56).
 const ANTHROPIC_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 const CHATGPT_DEFAULT_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
@@ -1030,10 +1167,12 @@ async function probeProvider(body, probeFetch = fetchWithTimeout) {
     const checkModel = presetProbeModel(body.preset) ?? models[0]?.id ?? body.probeModel ?? "test";
     // 16 tokens, as on Responses: some vendors refuse a smaller cap outright (B.ai: "max_tokens must be
     // greater than 2", #57), which read as a failed connection though the key and URL were right.
+    // Streamed, as every translated turn is: the status arrives with the headers, while a reasoning
+    // model answering whole can take past the timeout (Hive: 0.3s streamed, 3–23s whole, 2026-10-18).
     const checkBody = responses
-        ? { model: checkModel, max_output_tokens: 16, stream: false, store: false, input: "hi" }
+        ? { model: checkModel, max_output_tokens: 16, stream: true, store: false, input: "hi" }
         : openai
-            ? { model: checkModel, max_tokens: 16, stream: false, messages: [{ role: "user", content: "hi" }] }
+            ? { model: checkModel, max_tokens: 16, stream: true, messages: [{ role: "user", content: "hi" }] }
             : { model: checkModel, max_tokens: 16, messages: [{ role: "user", content: "hi" }] };
     const label = responses ? "responses endpoint" : openai ? "chat completions endpoint" : "messages endpoint";
     try {
@@ -1051,8 +1190,10 @@ async function probeProvider(body, probeFetch = fetchWithTimeout) {
             const auth = response.status === 403 && refusedByPlan(refusal) ? "not-entitled" : "bad-key";
             return { ok: false, auth, models, error: `${label} returned ${response.status}: ${refusal}` };
         }
-        if (response.ok)
+        if (response.ok) {
+            await response.body?.cancel().catch(() => { });
             return { ok: true, auth: "ok", models, ...(modelsError ? { error: modelsError } : {}) };
+        }
         const detail = snippet(await response.text());
         // A model-validation refusal still demonstrates that the endpoint reached the provider and the key was accepted.
         if (refusedForModel(response.status, detail)) {
@@ -1441,6 +1582,28 @@ async function pickerModels(deps) {
     }
     return { models: await claudeModelList(deps), source: "fallback" };
 }
+/**
+ * Each model's context window, for a client that reads a session's context use without the CLI's own
+ * figure (the phone, for a Claude app session). Claude's from Anthropic's catalog, the CLI's injected
+ * models from their config (else `cli.autoCompactWindow`), providers' from theirs. Unknown is absent.
+ */
+async function contextWindows(deps) {
+    const cfg = deps.config();
+    const windows = {};
+    const put = (id, value) => {
+        if (typeof value === "number" && Number.isFinite(value) && value > 0 && windows[id] === undefined)
+            windows[id] = Math.floor(value);
+    };
+    for (const model of await claudeModelList(deps))
+        put(model.id, model.contextWindow);
+    for (const model of cfg.cli.extraModels)
+        put(model.model, model.contextWindow ?? cfg.cli.autoCompactWindow);
+    for (const provider of Object.values(cfg.providers)) {
+        for (const model of ("models" in provider && provider.models) || [])
+            put(model.id, model.contextWindow);
+    }
+    return { windows };
+}
 function tailLines(file, n) {
     if (!fs.existsSync(file))
         return "";
@@ -1535,6 +1698,28 @@ export function startAdmin(deps) {
                 sendJson(res, 403, { error: "cross-site request refused" });
                 return;
             }
+            if (pathname.startsWith("/api/phone/")) {
+                res.setHeader("cache-control", "no-store");
+                // Pairing is a credential read: guard GETs too, including DNS-rebinding Host values.
+                if (crossSitePost(req) || req.headers["sec-fetch-site"] === "cross-site" ||
+                    !new Set([`127.0.0.1:${boundPort}`, `localhost:${boundPort}`]).has(req.headers.host ?? "")) {
+                    sendJson(res, 403, { error: "same-origin phone control required" });
+                    return;
+                }
+                let body;
+                if (method === "POST" && pathname === "/api/phone/settings") {
+                    try {
+                        body = (await readBody(req, 4096, new Error("phone settings too large"))).toString("utf8");
+                    }
+                    catch {
+                        sendJson(res, 413, { error: "phone settings too large" });
+                        return;
+                    }
+                }
+                const result = await phoneRequest(pathname.slice("/api/phone/".length), method, body, deps.phone);
+                sendJson(res, result.status, result.body);
+                return;
+            }
             if (pathname === "/api/shutdown" && method === "POST") {
                 if (!deps.shutdown) {
                     sendJson(res, 501, { error: "shutdown not available" });
@@ -1546,6 +1731,22 @@ export function startAdmin(deps) {
                 deps.shutdown();
                 return;
             }
+            if (pathname === "/api/remote" && method === "GET") {
+                if (!deps.remote) {
+                    sendJson(res, 501, { error: "remote tunnels not available" });
+                    return;
+                }
+                sendJson(res, 200, { hosts: deps.remote.status() });
+                return;
+            }
+            if (pathname === "/api/remote/reload" && method === "POST") {
+                if (!deps.remote) {
+                    sendJson(res, 501, { error: "remote tunnels not available" });
+                    return;
+                }
+                sendJson(res, 200, { hosts: deps.remote.reload() });
+                return;
+            }
             // Liveness is answering at all; readiness is 200 only when a request can actually go through.
             if (pathname === "/readyz" && method === "GET") {
                 const readiness = (await buildStatus(deps)).readiness;
@@ -1559,6 +1760,11 @@ export function startAdmin(deps) {
                 sendJson(res, 200, await buildStatus(deps, { refresh }));
                 return;
             }
+            // One shape for every provider whose quota can be read, for the status bar's limits row.
+            if (pathname === "/api/limits" && method === "GET") {
+                sendJson(res, 200, await buildLimits(deps));
+                return;
+            }
             if (pathname === "/api/mod-settings" && method === "GET") {
                 const snapshot = readModSettings();
                 // Filled here as well as on save, so a ladder with empty rungs (Auto migrated, or never set) reads whole to every surface.
@@ -1597,6 +1803,10 @@ export function startAdmin(deps) {
                 sendJson(res, 200, await pickerModels(deps));
                 return;
             }
+            if (pathname === "/api/context-windows" && method === "GET") {
+                sendJson(res, 200, await contextWindows(deps));
+                return;
+            }
             if (pathname === "/api/effort-levels" && method === "GET") {
                 sendJson(res, 200, effortLevels(deps.config()));
                 return;
@@ -2294,7 +2504,20 @@ export function startAdmin(deps) {
                 return;
             }
             if (pathname === "/api/requests/summary" && method === "GET") {
-                const seconds = Number(new URL(url, "http://x").searchParams.get("since") ?? 3600);
+                const query = new URL(url, "http://x").searchParams;
+                const fromParam = query.get("from");
+                if (fromParam !== null) {
+                    const from = Number(fromParam);
+                    const toParam = query.get("to");
+                    const to = toParam === null ? Date.now() : Number(toParam);
+                    if (!Number.isFinite(from) || !Number.isFinite(to) || from > to) {
+                        sendJson(res, 400, { error: "from and to must be epoch milliseconds with from <= to" });
+                        return;
+                    }
+                    sendJson(res, 200, { ...deps.requests.usage(from, to), from, to });
+                    return;
+                }
+                const seconds = Number(query.get("since") ?? 3600);
                 const safeSeconds = Number.isFinite(seconds) ? Math.min(31_536_000, Math.max(0, seconds)) : 3600;
                 sendJson(res, 200, deps.requests.summary(Date.now() - safeSeconds * 1000));
                 return;

package/dist/router/src/config.js

@@ -7,6 +7,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { PRESETS } from "./presets.js";
+import { hostProblem, portProblem } from "./remote-host.js";
 /**
  * The provider's own key, re-sent under the header another wire on the same account expects.
  *
@@ -323,6 +324,8 @@ export function validate(c) {
             errors.push(`provider ${name}: identity must be true or false`);
         if (shared.instructionsAppend !== undefined && typeof shared.instructionsAppend !== "string")
             errors.push(`provider ${name}: instructionsAppend must be a string`);
+        if (shared.limits !== undefined && typeof shared.limits !== "boolean")
+            errors.push(`provider ${name}: limits must be true or false`);
         // Ids key the router's cooldown and quarantine state, so a duplicate would make two credentials
         // share one health record and take each other down.
         const pool = p.credentials;
@@ -465,6 +468,33 @@ export function validate(c) {
         errors.push("cli.limitWorkerTools must be true or false");
     if (c.listen.openaiPort !== undefined && !(c.listen.openaiPort >= 0 && c.listen.openaiPort < 65536))
         errors.push("listen.openaiPort out of range");
+    if (c.remote !== undefined) {
+        const hosts = c.remote?.hosts;
+        if (!Array.isArray(hosts))
+            errors.push("remote.hosts must be a list");
+        else {
+            const seen = new Set();
+            hosts.forEach((entry, i) => {
+                const h = entry;
+                if (!h || typeof h !== "object") {
+                    errors.push(`remote.hosts ${i} must be an object`);
+                    return;
+                }
+                // Handed to ssh as an argument: the same check `remote add` applies, so a hand edit cannot
+                // slip an option such as -oProxyCommand into the router's own ssh.
+                const hostError = hostProblem(h.host);
+                if (hostError)
+                    errors.push(`remote.hosts ${i}: ${hostError}`);
+                else if (seen.has(h.host))
+                    errors.push(`remote.hosts ${i}: "${String(h.host)}" is listed twice`);
+                else
+                    seen.add(h.host);
+                const portError = portProblem(h.port);
+                if (portError)
+                    errors.push(`remote.hosts ${i}: ${portError}`);
+            });
+        }
+    }
     return errors;
 }
 export class ConfigStore {

package/dist/router/src/index.js

@@ -21,6 +21,8 @@ import { OpenAiIngress } from "./ingress/server.js";
 import { ObservedClaudeCodeAuth } from "./providers/anthropic-observed.js";
 import { VERSION } from "./version.js";
 import { allowLongSilences } from "./providers/retry.js";
+import { assetsFingerprint, readLocalAssets, spawnSsh, syncRemoteAssets } from "./remote-host.js";
+import { RemoteTunnels, proxyConnectHost } from "./remote-tunnel.js";
 // Startup timing. Claude Desktop routes *all* its traffic through us in picker mode, so every
 // second before the socket is open is a second the app cannot reach anything (ERR_PROXY_-
 // CONNECTION_FAILED, observed 2026-09-14 after a reboot: 26s between exec and listening).
@@ -31,6 +33,8 @@ const since = (t) => Date.now() - t;
 const home = homeDir();
 const logFile = process.env.CLAUDERIPPLE_NO_LOGFILE ? null : path.join(home, "logs", "router.log");
 let log = null;
+// Created after listen(); the config callback below runs before that and finds it null.
+let tunnels = null;
 const store = new ConfigStore(undefined, (c, errors) => {
     for (const e of errors)
         (log ?? console).warn(`config: ${e}`);
@@ -51,6 +55,9 @@ const store = new ConfigStore(undefined, (c, errors) => {
     catch (e) {
         (log ?? console).warn(`agent files: ${e.message}`);
     }
+    // Remote hosts get the regenerated agent files too, and a hand edit of `remote.hosts` takes effect.
+    tunnels?.reconcile(c.remote?.hosts ?? []);
+    tunnels?.assetsChanged();
 });
 const cfg0 = store.get();
 log = new Logger(logFile, cfg0.log.maxBytes, cfg0.log.keep, !!process.env.CLAUDERIPPLE_ECHO || !logFile);
@@ -121,6 +128,10 @@ function beginDrain(reason) {
 }
 for (const sig of ["SIGINT", "SIGTERM"])
     process.on(sig, () => beginDrain(sig));
+// Tunnels go with the process, not with the start of a drain: a remote session's in-flight model
+// call travels through one, and the drain exists to let it finish. Every exit path ends here
+// (drain, the health self-exit, a fatal startup error); a SIGKILL is covered by the pid record.
+process.on("exit", () => tunnels?.stopAll());
 const statsEvery = 5 * 60 * 1000;
 setInterval(() => {
     const s = proxy.stats;
@@ -138,6 +149,24 @@ proxy
         ` (startup ${since(T_EXEC)}ms: node ${T_MODULE - T_EXEC}, config ${T_CONFIG - T_MODULE}, listen ${since(T_CONFIG)})`);
     const ingressPort = await ingress.listen();
     log.info(`clauderipple OpenAI ingress listening on 127.0.0.1:${ingressPort}`);
+    // Reverse tunnels to remote (SSH) hosts, after listen() so their far end has something to reach.
+    const assets = () => readLocalAssets({ home, agentDir: defaultAgentDir() });
+    tunnels = new RemoteTunnels({
+        log: log,
+        proxyTarget: () => ({ host: proxyConnectHost(store.get().listen.host), port: store.get().listen.port }),
+        pidFile: path.join(home, "remote-tunnels.json"),
+        sync: (host) => syncRemoteAssets(spawnSsh, host, assets()),
+        fingerprint: () => {
+            try {
+                return assetsFingerprint(assets());
+            }
+            catch {
+                return "";
+            }
+        },
+    });
+    tunnels.cleanupStale();
+    tunnels.reconcile(c.remote?.hosts ?? []);
     // Quota only arrives on GPT response headers, so a quiet day left the status 11 hours stale
     // (2026-09-20). Ask once now, after listen(), and never wait for the answer.
     proxy.chatgptRefreshAll();
@@ -161,6 +190,7 @@ proxy
         google: () => ({
             accounts: () => proxy.googleAccounts(),
             models: (name) => proxy.googleFetchModels(name),
+            usage: (name) => proxy.googleUsage(name),
             clearCooldown: (id) => proxy.googleClearCooldown(id),
             recheckVerification: (id) => proxy.googleRecheckVerification(id),
         }),
@@ -169,9 +199,18 @@ proxy
         observedClaudeCodeAuth,
         claudeUsage: () => proxy.claudeUsage.snapshot(),
         claudeModels: () => proxy.claudeModels.list(),
+        opencodeUsage: (name) => proxy.opencodeLimits(name),
+        grokUsage: (name) => proxy.grokLimits(name),
         image: (req, signal) => proxy.generateImage(req, signal),
         modelCatalog: () => loadModelCatalog(),
         shutdown: () => beginDrain("shutdown requested"),
+        remote: {
+            status: () => tunnels.status(),
+            reload: () => {
+                tunnels.reconcile(store.get().remote?.hosts ?? []);
+                return tunnels.status();
+            },
+        },
     };
     const admin = await startAdmin(adminDeps);
     log.info(`clauderipple admin GUI on http://127.0.0.1:${admin.port}/`);

package/dist/router/src/ingress/translate.js

@@ -170,9 +170,13 @@ export function effortFromRequest(value) {
     return effort ?? undefined;
 }
 /** Convert an OpenAI Responses request to a cache-friendly Anthropic Messages request. */
-/** Claude models that accept `output_config.effort` (measured 2026-09-13: Haiku 4.5 answers 400 "does not support the effort parameter"). */
+/**
+ * Claude models that accept `output_config.effort` (measured 2026-09-13: Haiku 4.5 answers 400 "does
+ * not support the effort parameter"). Mythos 5 and 5.1 list `effort` among their capabilities in
+ * Claude Code 2.1.295's model catalogue (read 2026-10-14).
+ */
 export function claudeSupportsEffort(model) {
-    return /^claude-(opus|sonnet|fable)-(4-[6-9]|5)(-|$)/.test(model);
+    return /^claude-(opus|sonnet|fable|mythos)-(4-[6-9]|5)(-|$)/.test(model);
 }
 /**
  * With a borrowed Claude Code login, Anthropic accepts the request only when the system prompt is

package/dist/router/src/phone.js

@@ -0,0 +1,82 @@
+// Admin → host control bridge. Never forwards arbitrary URLs, headers or redirects.
+import fs from "node:fs";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { DEFAULT_PORT, remoteHome } from "../../remote/src/config.js";
+import { fileURLToPath } from "node:url";
+const INSTALL_HINT = "clauderipple remote install";
+function target(dir) {
+    let port = DEFAULT_PORT;
+    try {
+        const config = JSON.parse(fs.readFileSync(path.join(dir, "host.json"), "utf8"));
+        if (config.port !== undefined) {
+            if (typeof config.port !== "number" || !Number.isInteger(config.port) || config.port < 1 || config.port > 65535)
+                throw new Error("invalid host port");
+            port = config.port;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const secret = fs.readFileSync(path.join(dir, "local.secret"), "utf8").trim();
+    if (secret.length < 32 || !/^[\w-]+$/.test(secret))
+        throw new Error("invalid local secret");
+    return { port, secret };
+}
+function execute(file, args) {
+    return new Promise((resolve, reject) => execFile(file, args, { timeout: 150_000, windowsHide: true }, error => error ? reject(error) : resolve()));
+}
+export async function phoneRequest(route, method, body, deps = {}) {
+    if (route === "restart" && method === "POST") {
+        const uid = deps.uid ?? process.getuid?.();
+        const command = uid === undefined ? "npm run remote -- install" : `launchctl kickstart -k gui/${uid}/com.clauderipple.host`;
+        if ((deps.platform ?? process.platform) !== "darwin") {
+            const script = fileURLToPath(new URL(`../../remote/src/main${path.extname(import.meta.url)}`, import.meta.url));
+            try {
+                await (deps.exec ?? execute)(process.execPath, [script, "install"]);
+                return { status: 200, body: { ok: true } };
+            }
+            catch {
+                return { status: 502, body: { error: "host service install/restart failed", command: INSTALL_HINT } };
+            }
+        }
+        if (uid === undefined)
+            return { status: 500, body: { error: "host restart unavailable" } };
+        try {
+            await (deps.exec ?? execute)("launchctl", ["kickstart", "-k", `gui/${uid}/com.clauderipple.host`]);
+            return { status: 200, body: { ok: true } };
+        }
+        catch {
+            return { status: 502, body: { error: "host restart failed", command } };
+        }
+    }
+    if (!((method === "GET" && (route === "status" || route === "pairing")) || (method === "POST" && (route === "settings" || route === "rotate")))) {
+        return { status: 404, body: { error: "unknown phone endpoint or method" } };
+    }
+    let response;
+    try {
+        const { port, secret } = target(deps.home ?? remoteHome());
+        response = await (deps.fetch ?? fetch)(`http://127.0.0.1:${port}/local/${route}`, {
+            method, headers: { "x-ripple-local": secret, "content-type": "application/json" },
+            ...(body !== undefined ? { body } : {}), redirect: "error", signal: AbortSignal.timeout(5000),
+        });
+    }
+    catch {
+        return route === "status"
+            ? { status: 200, body: { hostRunning: false, hint: INSTALL_HINT } }
+            : { status: 503, body: { error: "phone host unavailable", hint: INSTALL_HINT } };
+    }
+    // A live old host or rejected local secret is not a stopped host. Report the boundary failure.
+    if (!response.ok)
+        return { status: response.status === 400 ? 400 : 502, body: { error: `host control HTTP ${response.status}; update the host if its local API is unavailable` } };
+    try {
+        const data = await response.json();
+        if (!data || typeof data !== "object" || Array.isArray(data))
+            throw new Error("invalid host response");
+        return { status: 200, body: route === "status" ? { ...data, hostRunning: true } : data };
+    }
+    catch {
+        return { status: 502, body: { error: "invalid host control response" } };
+    }
+}

package/dist/router/src/providers/anthropic-usage.js

@@ -25,7 +25,39 @@ export function claudeUsageFromBody(body) {
     const secondary = win(b?.seven_day, WEEK);
     if (!primary && !secondary)
         return null;
-    return { type: "claude.usage", rate_limits: { primary: primary ?? secondary, secondary: primary ? secondary : null }, at: Date.now() };
+    const scoped = scopedFromLimits(b?.limits);
+    return {
+        type: "claude.usage",
+        rate_limits: { primary: primary ?? secondary, secondary: primary ? secondary : null },
+        ...(scoped.length ? { scoped } : {}),
+        at: Date.now(),
+    };
+}
+/**
+ * Per-model weekly windows from the same body: entries of `limits` with kind `weekly_scoped`
+ * carry the model in `scope.model.display_name` (measured 2026-10-15:
+ * `{"kind":"weekly_scoped","group":"weekly","percent":2,…,"scope":{"model":{"id":null,
+ * "display_name":"Fable"},"surface":null},"is_active":false}`). They ride beside
+ * `rate_limits` (which the GUI and the tray read) so those readers keep working unchanged.
+ */
+function scopedFromLimits(limits) {
+    if (!Array.isArray(limits))
+        return [];
+    const out = [];
+    for (const entry of limits) {
+        if (!entry || typeof entry !== "object" || entry.kind !== "weekly_scoped")
+            continue;
+        const name = entry.scope?.model?.display_name;
+        const percent = entry.percent;
+        if (typeof name !== "string" || !name || typeof percent !== "number" || !Number.isFinite(percent))
+            continue;
+        const w = { name, used_percent: percent, window_minutes: WEEK };
+        const at = typeof entry.resets_at === "string" ? Date.parse(entry.resets_at) : NaN;
+        if (Number.isFinite(at))
+            w.reset_at = Math.round(at / 1000);
+        out.push(w);
+    }
+    return out;
 }
 /**
  * Per-account snapshots, fetched at most once per `ttlMs` per account. The GUI polls the status

package/dist/router/src/providers/google/index.js

@@ -25,6 +25,8 @@ import { ThoughtSignatureStore } from "./thoughtSignatures.js";
 import { conversationKey, serverToolNames, toolNameRestoreMap } from "../chatgpt/translate.js";
 import { GoogleAccountPool } from "./accounts.js";
 import { fetchAvailableModels, staticAntigravityModels } from "./antigravity.js";
+import { GoogleUsage } from "./usage.js";
+import { ANTIGRAVITY_PROMPT_REFUSAL_MESSAGE, isAntigravityPromptRefusal } from "./prompt-refusal.js";
 const PING_MS = 15_000;
 /** How long the CCA model list is reused before asking again. */
 const MODELS_CACHE_MS = 60 * 60 * 1000;
@@ -113,6 +115,8 @@ export class GoogleAdapter {
     cfg;
     log;
     accounts;
+    /** Per-account quota, for the status bar's limits row (`GET /api/limits`). */
+    usage;
     /** Cooldowns and conversation stickiness, shared with the proxy's other credential pools. */
     pool;
     lastInputByKey = new Map();
@@ -130,6 +134,7 @@ export class GoogleAdapter {
         this.log = log;
         this.pool = pool;
         this.accounts = new GoogleAccountPool({ home, log, ...(fetchImpl ? { fetch: fetchImpl } : {}) });
+        this.usage = new GoogleUsage(this.accounts, { warn: (message) => log.warn(message), ...(fetchImpl ? { fetch: fetchImpl } : {}) });
     }
     describeAuth() {
         const all = this.accounts.summaries();
@@ -161,6 +166,13 @@ export class GoogleAdapter {
             };
         });
     }
+    /**
+     * Each account's quota groups by owner id, for the status bar's limits row. Never a token; a
+     * failed lookup keeps that account's last good groups.
+     */
+    usageSnapshot() {
+        return this.usage.snapshot();
+    }
     /**
      * Ask Google again whether an account still needs its verification page (dashboard action). The
      * mark otherwise clears only when the account next answers a turn, so a person who had just
@@ -338,6 +350,8 @@ export class GoogleAdapter {
         const sent = await this.sendToAnAccount({
             conversation: key,
             signal: controller.signal,
+            system: upstreamRequest.systemInstruction,
+            model,
             build: (credential) => {
                 const built = transport.build(upstreamRequest, {
                     model,
@@ -352,6 +366,11 @@ export class GoogleAdapter {
             res.off("close", onClose);
             if (sent.kind === "aborted")
                 return { status: 0, bytes: 0, note: "client closed" };
+            if (sent.kind === "prompt-refused") {
+                const err = anthropicError(400, "invalid_request_error", ANTIGRAVITY_PROMPT_REFUSAL_MESSAGE);
+                return { kind: "prompt-incompatible", status: 400, bytes: 0, errorBody: err.body,
+                    note: "upstream 429: suspected Antigravity SDK prompt refusal with remaining quota", refusal: "prompt-incompatible" };
+            }
             if (sent.kind === "unreachable") {
                 const err = anthropicError(502, "api_error", `Google provider unreachable: ${sent.error.message}`);
                 if (!res.headersSent)
@@ -557,6 +576,13 @@ export class GoogleAdapter {
             const safeText = redactErrorText(text, secrets);
             const status = upstream.status;
             this.log.warn(`google ${this.name}: account ${credential.ownerId.slice(0, 8)} answered ${status}: ${safeText.slice(0, 400)}`);
+            // The generic 429 is also real exhaustion. Only fresh quota evidence for this
+            // account/model permits a request-specific refusal; otherwise keep ordinary
+            // cooldown and account rotation. The proxy can still try a route fallback.
+            if (isAntigravityPromptRefusal(spec.system, status, text, upstream.headers.get("retry-after")) &&
+                this.usage.hasRemainingQuota(credential, spec.model)) {
+                return { kind: "prompt-refused" };
+            }
             // Not a rest and not a refresh: the account works again the moment its person finishes
             // Google's page, so it stays in rotation and the next turn finds out.
             const verifyUrl = status === 403 ? googleValidationUrl(text) : undefined;