clauderipple 0.9.5 → 0.11.0

package/dist/router/src/hold.js

@@ -0,0 +1,107 @@
+// Hold new model calls for a moment, without refusing them.
+//
+// The way back from the iPhone hotspot to Wi-Fi (tether.ts) drops the link for a few seconds, so it
+// waits for a quiet moment. With Claude and subagents working back-to-back there is none, and on
+// 2026-10-20 the return was postponed from 19:22:54 until the hotspot itself went away. So after a
+// grace period the tether controller makes the gap instead: it engages this gate, waits for the
+// calls already running to finish, switches, and releases the gate.
+//
+// While the gate is engaged, a NEW model call (the proxy's /v1/messages, the OpenAI ingress's
+// Responses/Chat calls) waits before its body is read: nothing is written to it, it is not refused
+// and not answered 503 — zero vanished requests is an acceptance metric. It goes ahead when the gate
+// is released or after HOLD_MAX_MS, whichever comes first. Non-model traffic is never held.
+//
+// Release is guaranteed three ways: the owner releases in a `finally`, a failsafe timer set at
+// engage() releases on its own, and close() (the router's drain) releases and refuses to engage again.
+/**
+ * The longest any one call waits at the gate; then it proceeds as if there were none. Longer than the
+ * tether's drain wait plus its switch (tether.ts RETURN_DRAIN_WAIT_MS), shorter than the ~180s after
+ * which Claude Code gave up on a call with no answer yet (2026-10-20).
+ */
+export const HOLD_MAX_MS = 120_000;
+const realTimers = {
+    set: (fn, ms) => {
+        const t = setTimeout(fn, ms);
+        t.unref();
+        return t;
+    },
+    clear: (t) => clearTimeout(t),
+};
+export class HoldGate {
+    reasonText = null;
+    failsafe = null;
+    isClosed = false;
+    waiters = new Set();
+    maxHoldMs;
+    timers;
+    now;
+    constructor(opts = {}) {
+        this.maxHoldMs = opts.maxHoldMs ?? HOLD_MAX_MS;
+        this.timers = opts.timers ?? realTimers;
+        this.now = opts.now ?? Date.now;
+    }
+    get engaged() {
+        return this.reasonText !== null;
+    }
+    get reason() {
+        return this.reasonText;
+    }
+    /** Calls waiting at the gate right now. */
+    get waiting() {
+        return this.waiters.size;
+    }
+    get closed() {
+        return this.isClosed;
+    }
+    /**
+     * Start holding new calls. `failsafeMs` releases the gate by itself if its owner never does.
+     * False after close(): a draining router holds nothing.
+     */
+    engage(reason, failsafeMs) {
+        if (this.isClosed)
+            return false;
+        this.reasonText = reason;
+        if (this.failsafe !== null)
+            this.timers.clear(this.failsafe);
+        this.failsafe = this.timers.set(() => {
+            this.failsafe = null;
+            this.release();
+        }, failsafeMs);
+        return true;
+    }
+    /** Let every held call go ahead. Idempotent. Returns how many were waiting. */
+    release() {
+        if (this.failsafe !== null)
+            this.timers.clear(this.failsafe);
+        this.failsafe = null;
+        this.reasonText = null;
+        const all = [...this.waiters];
+        for (const wake of all)
+            wake();
+        return all.length;
+    }
+    /** Release, and never engage again (the router is draining or exiting). */
+    close() {
+        this.isClosed = true;
+        return this.release();
+    }
+    /** Resolves at once when the gate is open; else when it is released or after HOLD_MAX_MS. */
+    wait() {
+        if (this.reasonText === null)
+            return Promise.resolve({ ms: 0, timedOut: false });
+        const t0 = this.now();
+        return new Promise((resolve) => {
+            let timer = null;
+            const done = (timedOut) => {
+                if (!this.waiters.delete(wake))
+                    return;
+                if (timer !== null)
+                    this.timers.clear(timer);
+                resolve({ ms: this.now() - t0, timedOut });
+            };
+            const wake = () => done(false);
+            this.waiters.add(wake);
+            timer = this.timers.set(() => done(true), this.maxHoldMs);
+        });
+    }
+}

package/dist/router/src/index.js

@@ -8,11 +8,15 @@ import fs from "node:fs";
 import path from "node:path";
 import { codexEnabled, followCodexCache, writeCodexCatalog } from "../../cli/src/codex.js";
 import { ingressModels } from "./ingress/models.js";
-import { ConfigStore, configPath, homeDir, terminateHosts } from "./config.js";
+import { ConfigStore, awakeSettings, configPath, homeDir, terminateHosts, tetherSettings } from "./config.js";
+import { AwakeController, execRunner } from "./awake.js";
+import { TetherController } from "./tether.js";
+import { powerPlatform } from "./power.js";
 import { defaultAgentDir, syncAgentFiles } from "./agents.js";
 import { CertStore } from "./certs.js";
 import { Logger } from "./log.js";
-import { UpstreamHealth, EXIT_UPSTREAM_UNREACHABLE } from "./health.js";
+import { UpstreamHealth, EXIT_UPSTREAM_UNREACHABLE, checkConnectivity } from "./health.js";
+import { HoldGate } from "./hold.js";
 import { Proxy } from "./proxy.js";
 import { adoptNewClaudeModels, backfillContextWindows, measureUnsettledModels, startAdmin } from "./admin.js";
 import { loadModelCatalog } from "./catalog.js";
@@ -21,6 +25,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 +37,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 +59,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);
@@ -81,15 +92,56 @@ function premintLeaves() {
         }
     }
 }
-const health = new UpstreamHealth(() => store.get().health.maxConsecutiveUpstreamFailures, (n) => {
-    log.error(`${n} consecutive upstream connect failures; exiting ${EXIT_UPSTREAM_UNREACHABLE} for the supervisor to restart`);
+// One gate for the proxy and the ingress: the tether controller holds new model calls at it while
+// it switches the network back to Wi-Fi (hold.ts). Closed when the router drains or exits.
+const hold = new HoldGate();
+const powerRunner = execRunner();
+const health = new UpstreamHealth(() => store.get().health.maxConsecutiveUpstreamFailures, (n, c) => {
+    const why = !c ? "" : c.result === "online" ? ` while this machine is online (${c.detail}): this process is stuck` : ` and the connectivity check could not tell (${c.detail})`;
+    log.error(`${n} consecutive upstream connect failures${why}; exiting ${EXIT_UPSTREAM_UNREACHABLE} for the supervisor to restart`);
+    hold.close();
     setTimeout(() => process.exit(EXIT_UPSTREAM_UNREACHABLE), 100);
+}, {
+    // A fresh process (curl) asks first; a machine that is offline is not helped by a restart.
+    connectivity: () => checkConnectivity(powerRunner, process.platform),
+    onOffline: (n, c) => log.warn(`${n} consecutive upstream connect failures, but this machine is offline too (${c.detail}); not restarting`),
 });
 const observedClaudeCodeAuth = new ObservedClaudeCodeAuth(path.join(home, "claude-auth-observed.json"));
 // Before any provider fetches: a reasoning model may stay silent past fetch's 300s default.
 allowLongSilences();
-const proxy = new Proxy({ config: () => store.get(), log, certs, health, home, requests, observedClaudeCodeAuth });
-const ingress = new OpenAiIngress({ config: () => store.get(), log, requests, home, observedClaudeCodeAuth, chatgpt: (name) => proxy.chatgptForCodex(name) });
+const proxy = new Proxy({ config: () => store.get(), log, certs, health, home, requests, observedClaudeCodeAuth, hold });
+const ingress = new OpenAiIngress({ config: () => store.get(), log, requests, home, observedClaudeCodeAuth, chatgpt: (name) => proxy.chatgptForCodex(name), hold });
+// Lid-closed awake and hotspot failover (macOS and Windows; no-ops elsewhere, off until configured).
+// They read Claude's activity from the two servers' counters. Started after listen(), below.
+const activity = () => {
+    const p = proxy.stats;
+    const i = ingress.stats;
+    const latest = (a, b) => (a === undefined ? b : b === undefined ? a : Math.max(a, b));
+    const lastStartedAt = latest(p.lastMessageStartedAt, i.lastMessageStartedAt);
+    const lastEndedAt = latest(p.lastMessageEndedAt, i.lastMessageEndedAt);
+    return {
+        inFlight: p.messagesInFlight + i.messagesInFlight,
+        ...(lastStartedAt !== undefined ? { lastStartedAt } : {}),
+        ...(lastEndedAt !== undefined ? { lastEndedAt } : {}),
+    };
+};
+const awake = new AwakeController({
+    platform: process.platform,
+    run: powerRunner,
+    settings: () => awakeSettings(store.get()),
+    activity,
+    journalFile: path.join(home, "awake.json"),
+    log: { info: (m) => log.info(m), warn: (m) => log.warn(m) },
+});
+const tether = new TetherController({
+    platform: process.platform,
+    run: powerRunner,
+    settings: () => tetherSettings(store.get()),
+    activity,
+    log: { info: (m) => log.info(m), warn: (m) => log.warn(m) },
+    hold,
+    stateFile: path.join(home, "tether.json"),
+});
 process.on("uncaughtException", (e) => log.error(`uncaught ${e.stack ?? e}`));
 process.on("unhandledRejection", (e) => log.error(`unhandled ${e?.stack ?? e}`));
 const DRAIN_MS = 90_000; // new model calls are refused during drain, so this is the longest single call we wait for; `clauderipple restart` waits 120s
@@ -108,6 +160,8 @@ function beginDrain(reason) {
     draining = true;
     log.info(`${reason}: draining, proxy=${proxy.stats.messagesInFlight} ingress=${ingress.stats.messagesInFlight} model calls`);
     let lastReported = -1;
+    // Each drain() closes the shared hold gate first (hold.ts): a call held for a network switch is
+    // let go, refused with the retryable 503 like any new call, and waited for.
     void Promise.all([
         proxy.drain(DRAIN_MS, () => { }),
         ingress.drain(DRAIN_MS, () => { }),
@@ -116,11 +170,20 @@ function beginDrain(reason) {
         const left = proxy.stats.messagesInFlight + ingress.stats.messagesInFlight;
         if (left !== lastReported)
             log.info(`drain complete, exiting (model calls still open: ${left})`);
+        // The sleep bit is left as it is (awake.ts header): the successor reconciles it within one
+        // tick, and the journal carries the working window across the restart.
+        tether.stop();
+        awake.stop();
+        awake.beforeExit();
         setTimeout(() => process.exit(0), 200).unref();
     });
 }
 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 +201,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 +242,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,12 +251,32 @@ 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();
+            },
+        },
+        power: {
+            status: () => ({ platform: powerPlatform(process.platform), awake: awake.status(), tether: tether.status() }),
+            pin: (on) => tether.setPin(on),
+            poke: async () => {
+                tether.kick();
+                await awake.refresh();
+            },
+        },
     };
     const admin = await startAdmin(adminDeps);
     log.info(`clauderipple admin GUI on http://127.0.0.1:${admin.port}/`);
+    // The first awake tick is the reconcile: a bit a previous process set is kept or cleared now.
+    void awake.start().catch((e) => log.warn(`awake: ${e.message}`));
+    tether.start();
     setImmediate(premintLeaves);
     // A minute in, once start-up traffic has settled: first the catalogue's context windows are
     // written into models already saved without one (a one-shot pass), then a few one-token requests

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

@@ -131,6 +131,8 @@ export class OpenAiIngress {
     claudeAccounts;
     deps;
     draining = false;
+    /** Model calls waiting at the hold gate (not yet in `stats`): drain() waits for them too. */
+    held = 0;
     constructor(deps) {
         this.deps = deps;
         this.claudeAccounts = deps.claudeAccounts ?? new ClaudeAccountAuthPool({
@@ -166,9 +168,13 @@ export class OpenAiIngress {
     /** Stop new connections, reject new model work on keep-alive sockets, then close after model calls drain. */
     async drain(maxMs, onProgress) {
         this.draining = true;
+        // As in the proxy: a call held for a network switch goes on now, meets the 503, and is waited for.
+        const released = this.deps.hold?.close() ?? 0;
+        if (released)
+            this.deps.log.info(`OPENAI drain: released ${released} model call(s) held for a network switch`);
         this.server.close();
         const start = Date.now();
-        while (this.stats.messagesInFlight > 0 && Date.now() - start < maxMs) {
+        while ((this.stats.messagesInFlight > 0 || this.held > 0) && Date.now() - start < maxMs) {
             onProgress?.(this.stats.messagesInFlight);
             await new Promise((resolveP) => setTimeout(resolveP, 250));
         }
@@ -187,11 +193,25 @@ export class OpenAiIngress {
         const path = (req.url ?? "/").split("?")[0] ?? "/";
         const method = req.method ?? "GET";
         const isCall = method === "POST" && (path === "/v1/responses" || path === "/v1/responses/compact" || path === "/v1/chat/completions");
+        // As in the proxy (hold.ts): during a network switch a new model call waits here, unread and
+        // uncounted, then goes ahead. Draining refuses below instead.
+        const hold = this.deps.hold;
+        if (isCall && hold?.engaged && !this.draining) {
+            this.held++;
+            const held = await hold.wait().finally(() => this.held--);
+            this.deps.log.info(`OPENAI HOLD ${method} ${path} waited ${(held.ms / 1000).toFixed(1)}s${held.timedOut ? " (longest hold reached; going ahead)" : ""}`);
+            if (req.socket?.destroyed) {
+                this.deps.log.warn(`OPENAI HOLD ${method} ${path}: the client left while held`);
+                return;
+            }
+        }
         this.stats.started++;
         this.stats.inFlight++;
-        if (isCall)
-            this.stats.messagesInFlight++;
         const started = Date.now();
+        if (isCall) {
+            this.stats.messagesInFlight++;
+            this.stats.lastMessageStartedAt = started;
+        }
         let record = { kind: "messages", source: "-", target: "-", provider: "-", stream: false };
         let completed = false;
         const finish = (status, bytes, extra = {}) => {
@@ -199,8 +219,10 @@ export class OpenAiIngress {
                 return;
             completed = true;
             this.stats.inFlight--;
-            if (isCall)
+            if (isCall) {
                 this.stats.messagesInFlight--;
+                this.stats.lastMessageEndedAt = Date.now();
+            }
             if (status >= 200 && status < 400)
                 this.stats.completed++;
             else

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/power.js

@@ -0,0 +1,107 @@
+// The admin contract for lid-closed awake + hotspot failover (`GET|PUT /api/power`).
+//
+//   GET  → { platform: "darwin"|"win32"|"linux", awake: AwakeStatus, tether: TetherStatus }
+//        (`platform` lets a client word things per OS: "Mac" or "PC", the Windows hints. Anything
+//        that is neither macOS nor Windows reads "linux", where both features are `unsupported`.)
+//   PUT  { awake?: { mode?: "off"|"working"|"on", until?: ISO string | null },
+//          tether?: { enabled?: boolean, pin?: boolean } }
+//        mode/until/enabled are saved to config.json (the router picks the file up by mtime, like
+//        every other settings save); `pin` is in-memory only — it pauses switching until unpinned or
+//        until the router restarts.
+import fs from "node:fs";
+import path from "node:path";
+export function powerPlatform(p) {
+    return p === "darwin" || p === "win32" ? p : "linux";
+}
+/** Validates a PUT body. Returns the change, or what is wrong with it. */
+export function parsePowerChange(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return "expected an object";
+    const body = raw;
+    const out = {};
+    for (const key of Object.keys(body))
+        if (key !== "awake" && key !== "tether")
+            return `unknown field "${key}"`;
+    if (body.awake !== undefined) {
+        const a = body.awake;
+        if (!a || typeof a !== "object" || Array.isArray(a))
+            return "awake must be an object";
+        for (const key of Object.keys(a))
+            if (key !== "mode" && key !== "until")
+                return `unknown field "awake.${key}"`;
+        const awake = {};
+        if (a.mode !== undefined) {
+            if (a.mode !== "off" && a.mode !== "working" && a.mode !== "on")
+                return 'awake.mode must be "off", "working" or "on"';
+            awake.mode = a.mode;
+        }
+        if (a.until !== undefined) {
+            if (a.until !== null && (typeof a.until !== "string" || Number.isNaN(Date.parse(a.until))))
+                return "awake.until must be an ISO date-time or null";
+            awake.until = a.until === null ? null : new Date(Date.parse(a.until)).toISOString();
+        }
+        out.awake = awake;
+    }
+    if (body.tether !== undefined) {
+        const t = body.tether;
+        if (!t || typeof t !== "object" || Array.isArray(t))
+            return "tether must be an object";
+        // The hotspot name is set by `awake setup` only: the sudoers rule names it.
+        for (const key of Object.keys(t))
+            if (key !== "enabled" && key !== "pin")
+                return `unknown field "tether.${key}"${key === "hotspotSsid" ? " (set it with `clauderipple awake setup --ssid`)" : ""}`;
+        const tether = {};
+        if (t.enabled !== undefined) {
+            if (typeof t.enabled !== "boolean")
+                return "tether.enabled must be true or false";
+            tether.enabled = t.enabled;
+        }
+        if (t.pin !== undefined) {
+            if (typeof t.pin !== "boolean")
+                return "tether.pin must be true or false";
+            tether.pin = t.pin;
+        }
+        out.tether = tether;
+    }
+    return out;
+}
+/**
+ * Applies the persistent part of a change to the config file as it is on disk (re-read, so a save
+ * made elsewhere meanwhile is not reverted) and writes it atomically. Returns whether it wrote.
+ */
+export function persistPowerChange(configFile, change) {
+    const awake = change.awake ?? {};
+    const tether = change.tether ?? {};
+    if (awake.mode === undefined && awake.until === undefined && tether.enabled === undefined && tether.hotspotSsid === undefined)
+        return false;
+    let raw = {};
+    try {
+        raw = JSON.parse(fs.readFileSync(configFile, "utf8"));
+    }
+    catch (e) {
+        if (e.code !== "ENOENT")
+            throw e;
+    }
+    if (awake.mode !== undefined || awake.until !== undefined) {
+        const next = { ...(raw.awake ?? {}) };
+        if (awake.mode !== undefined)
+            next.mode = awake.mode;
+        if (awake.until === null)
+            delete next.until;
+        else if (awake.until !== undefined)
+            next.until = awake.until;
+        raw.awake = next;
+    }
+    if (tether.enabled !== undefined || tether.hotspotSsid !== undefined) {
+        raw.tether = {
+            ...(raw.tether ?? {}),
+            ...(tether.enabled !== undefined ? { enabled: tether.enabled } : {}),
+            ...(tether.hotspotSsid !== undefined ? { hotspotSsid: tether.hotspotSsid } : {}),
+        };
+    }
+    fs.mkdirSync(path.dirname(configFile), { recursive: true });
+    const tmp = `${configFile}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, JSON.stringify(raw, null, 2) + "\n");
+    fs.renameSync(tmp, configFile);
+    return true;
+}

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