clauderipple 0.12.1 → 0.12.3

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.12.3 — 2026-10-22
+
+### Added
+
+- **Fast for GPT, separately for the main session and for subagents.** The ChatGPT provider's
+  settings have two switches, both off: "Fast for the main session" and "Fast for subagents".
+  When on, those GPT requests go out on Codex's fast tier, which answers sooner and uses the
+  subscription faster. Claude Code's own Fast toggle does not reach GPT models, so these are the
+  way to turn it on. Each request in the log now says whether a subagent made it.
+
+### Fixed
+
+- **The phone host says when Claude Code has no login of its own.** On a computer that only ever
+  used the Claude app, every phone turn failed at once with "Not logged in". `clauderipple doctor`
+  and `clauderipple remote install` now warn about it and say how to log in, and the phone shows
+  that instead of the raw error.
+
+## 0.12.2 — 2026-10-22
+
+### Fixed
+
+- **Back on Wi-Fi only when a known Wi-Fi is in range.** After a hotspot failover, the way back
+  no longer drops the hotspot for a Wi-Fi that is not there, which cut the connection on the move.
+
+### Changed
+
+- **Naming a model on a delegation is now explained to the main chat.** `ripple:auto`'s
+  description says that `[[ripple: opus@high]]` (or a worker's name) on the first line runs that
+  model past every ClaudeRipple rule and still shows in the agents panel, so a session no longer
+  starts models outside it to get one. It also says what a brief should state, to check that the
+  report did what was asked, and to resume a worker only within 5 minutes of its last reply.
+
 ## 0.12.1 — 2026-10-21
 
 ### Changed

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.12.1",
+  "version": "0.12.3",
   "type": "commonjs"
 }

package/dist/cli/src/claude-auth.js

@@ -1,6 +1,6 @@
 // `claude setup-token` invocation for a ClaudeRipple-owned, 0600 token file.
 // The token is never echoed, logged, or returned from this module.
-import { execFileSync } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -109,6 +109,97 @@ export function claudeBinary(pathValue = process.env.PATH) {
     }
     return latestDesktopClaude();
 }
+// ---- does the Claude Code CLI itself have a login? -------------------------------------------
+//
+// The Ripple Remote host drives Claude Code through the Agent SDK and passes no credential of its
+// own, so every turn needs the CLI's own login. Where only the Claude desktop app is used, that
+// login never exists and the CLI answers "Not logged in · Please run /login" (issue #71).
+//
+// This asks whether the login is there. It never reads, returns or logs a secret: the keychain
+// item is looked up by name only (without -w, so the password is never fetched) and the
+// credential file is only parsed for the shape of its content.
+//
+// The router reads the same two stores for its own `claude-code` provider
+// (router/src/providers/anthropic.ts:41-74). That reader is not reused here: it returns the
+// secret, and it parses a login as present only when it is also unexpired — this asks for
+// presence, and for a home directory of the caller's choosing.
+/** The keychain service the CLI keeps its OAuth grant in (the router names it the same way). */
+const KEYCHAIN_SERVICE = "Claude Code-credentials";
+/** Where the CLI keeps its credential file. */
+export function claudeCredentialsFile(home = os.homedir()) {
+    return path.join(home, ".claude", ".credentials.json");
+}
+/**
+ * True when the file holds a `claudeAiOauth` block: a Claude Code login of its own. A file that
+ * only holds an `mcpOAuth` block is not one (that is what an MCP server's OAuth flow writes), and
+ * an empty access token is a login that was emptied rather than one that is there.
+ */
+export function hasClaudeAiOauth(raw) {
+    if (!raw)
+        return false;
+    try {
+        const parsed = JSON.parse(raw);
+        const oauth = parsed.claudeAiOauth;
+        if (oauth === null || typeof oauth !== "object" || Array.isArray(oauth))
+            return false;
+        const accessToken = oauth.accessToken;
+        return accessToken === undefined || (typeof accessToken === "string" && accessToken.length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+/** macOS: the CLI's keychain item, looked up by name. The secret itself is never read. */
+async function keychainHasCredentials() {
+    try {
+        // Without -w the password is never fetched, so what comes back is the item's attributes only.
+        await execFile("security", ["find-generic-password", "-s", KEYCHAIN_SERVICE], { timeout: 5_000, windowsHide: true });
+        return true;
+    }
+    catch {
+        // No item, or the keychain would not answer: there is no login to count.
+        return false;
+    }
+}
+/**
+ * Whether the Claude Code CLI has a login of its own, and where it is. Presence only: no secret
+ * is read, returned or logged. The environment is checked first because it costs nothing, and the
+ * keychain probe (a child process) runs only when nothing cheaper answered.
+ */
+export async function claudeCodeLogin(options = {}) {
+    const env = options.env ?? process.env;
+    const tokens = [
+        ["CLAUDE_CODE_OAUTH_TOKEN", "the CLAUDE_CODE_OAUTH_TOKEN environment variable"],
+        ["ANTHROPIC_API_KEY", "the ANTHROPIC_API_KEY environment variable"],
+        ["ANTHROPIC_AUTH_TOKEN", "the ANTHROPIC_AUTH_TOKEN environment variable"],
+    ];
+    for (const [key, where] of tokens)
+        if (env[key])
+            return { ok: true, where };
+    const platform = options.platform ?? process.platform;
+    if (platform === "darwin") {
+        const probe = options.keychain ?? keychainHasCredentials;
+        if (await probe())
+            return { ok: true, where: `the macOS keychain (${KEYCHAIN_SERVICE})` };
+    }
+    const home = options.home ?? os.homedir();
+    let raw = null;
+    try {
+        raw = fs.readFileSync(claudeCredentialsFile(home), "utf8");
+    }
+    catch {
+        raw = null;
+    }
+    if (hasClaudeAiOauth(raw))
+        return { ok: true, where: `${claudeCredentialsFile(home)} (claudeAiOauth)` };
+    return { ok: false, where: "no Claude Code login: no token in the environment, no keychain item, no credential file" };
+}
+/** What a person whose Claude Code CLI has no login is told to do. */
+export function claudeLoginHint(binary) {
+    return binary
+        ? `Run the Claude Code CLI once and log in with /login: ${binary}`
+        : "Run the Claude Code CLI once and log in with /login (install Claude Code if it is not on this computer)";
+}
 function needsTerminal() {
     return (`Claude sign-in needs a terminal: run \`clauderipple claude-login\` in ${isWindows ? "PowerShell" : "Terminal"}. ` +
         "If Claude Code is already signed in on this computer, its login is reused automatically and this step is not needed.");

package/dist/cli/src/doctor.js

@@ -6,9 +6,11 @@
 // Everything that reaches the machine is a dependency (`RecoveryDeps`), so tests run with a fake
 // supervisor and temp files and never touch launchd, the user's settings or the live router.
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { ConfigStore, adminPort } from "../../router/src/config.js";
 import { certPaths } from "./certs.js";
+import { claudeBinary, claudeCodeLogin, claudeLoginHint } from "./claude-auth.js";
 import { applyAppProxy, currentAppProxy } from "./picker.js";
 import { applyProxyEnv, settingsEnv } from "./settings.js";
 export async function fetchRouterStatus(adminUrl, timeoutMs) {
@@ -66,6 +68,21 @@ export function classifyMode(cli, desktop, pickerEnabled) {
 function configFile(home) {
     return path.join(home, "config.json");
 }
+/**
+ * Whether the phone host's own background service is installed here (a launchd agent, a scheduled
+ * task, a systemd user unit). The host package owns that path, so it is asked for it; a host that
+ * is not installed cannot need a CLI login of its own.
+ */
+async function remoteHostInstalled() {
+    try {
+        const { servicePaths } = await import("../../remote/src/host-service.js");
+        return fs.existsSync(servicePaths(process.platform, os.homedir()).definition);
+    }
+    catch {
+        // A host package that cannot be read is a host that is not installed here.
+        return false;
+    }
+}
 async function snapshot(deps) {
     const installed = fs.existsSync(configFile(deps.home));
     const cfg = new ConfigStore(configFile(deps.home)).get();
@@ -106,6 +123,13 @@ async function snapshot(deps) {
         add("desktop-foreign-proxy", `Claude Desktop goes through another proxy (${desktop.url}), not ClaudeRipple.`);
     if (mode === "mixed")
         add("mixed-mode", `Claude Code ${cli.proxy === "ripple" ? "goes" : "does not go"} through ClaudeRipple, Claude Desktop ${desktop.proxy === "ripple" ? "does" : "does not"}.`);
+    // The phone host starts Claude Code through the Agent SDK and passes no credential of its own, so
+    // without a login of the CLI's own every turn fails at once (issue #71).
+    if (await (deps.remoteHostInstalled ?? remoteHostInstalled)()) {
+        const login = await (deps.claudeLogin ?? (() => claudeCodeLogin()))();
+        if (!login.ok)
+            add("cli-not-logged-in", `Claude Code has no login on this computer, so the phone host's sessions fail at once. ${claudeLoginHint(claudeBinary())}`);
+    }
     return {
         report: {
             mode,

package/dist/mod/hooks/workers.ts

@@ -11,7 +11,11 @@ export const AUTO_DESCRIPTION = 'Delegate any task here; ClaudeRipple picks the
   'If you know how hard the task is, put [[ripple: light]], [[ripple: standard]], [[ripple: hard]] or [[ripple: max]] on the prompt\'s first line: ' +
   'light = lookups, mechanical edits, one small fix; standard = carry out a designed change (even across several files), research, summarize, read-only review; ' +
   'hard = subtle debugging, security review, or work where a wrong call is costly; max = planning, design or architecture where the deliverable is the decision itself. ' +
-  'Size, file count or the brief\'s warnings do not by themselves make a task hard. Leave the marker out when unsure, and ClaudeRipple judges it.'
+  'Size, file count or the brief\'s warnings do not by themselves make a task hard. Leave the marker out when unsure, and ClaudeRipple judges it. ' +
+  'To run one particular model instead (the user asked for it, or a comparison needs it), name it on the first line: [[ripple: opus@high]] for a Claude model (opus, sonnet, haiku), or [[ripple: <worker agent name>@<effort>]]. ' +
+  'It runs as named, past every ClaudeRipple rule, and still shows in the agents panel; never start a model another way, such as claude -p, to get around the rules. ' +
+  'A brief states the scope, what must not be touched, the done criteria and how to verify them. Read the report for whether it did what was asked before using it. ' +
+  'Continue a worker with SendMessage only within 5 minutes of its last reply; later its cache has lapsed, so start a new one with a summary of what is done and what is left.'
 
 /**
  * The tier markers the main chat may write on a ripple:auto prompt, as the judge's verdict they

package/dist/remote/src/bridge-client.js

@@ -8,6 +8,14 @@ import { setTimeout as delay } from "node:timers/promises";
 export const DESKTOP_BLOCKED = "Claude 앱에서 열려 있는 세션에 지금은 보낼 수 없습니다.";
 export const LOGIN_EXPIRED = "이 컴퓨터의 Claude 로그인이 만료되었습니다. Claude 앱을 한 번 열어 주십시오.";
 export const LOGIN_REFUSED = "이 컴퓨터의 Claude 로그인이 거절되었습니다 (401). Claude 앱을 한 번 열어 주십시오.";
+// The Claude Code CLI has no login of its own. The host starts the CLI through the Agent SDK and
+// passes no credential, so the CLI's own "Not logged in · Please run /login" is the whole error a
+// phone sees; this says it in the host's words (issue #71).
+export const CLI_NOT_LOGGED_IN = "이 컴퓨터의 Claude Code에 로그인되어 있지 않습니다. 터미널에서 Claude Code를 한 번 실행해 /login 해 주십시오.";
+/** The CLI's own words for the same thing, tolerant of the spacing around them. */
+export function isCliNotLoggedIn(text) {
+    return /^\s*not\s+logged\s+in\b/i.test(text);
+}
 class BridgeNetworkError extends Error {
 }
 /**

package/dist/remote/src/main.js

@@ -29,10 +29,11 @@ import { RelayHost, loadHostKey } from "./relay.js";
 import { RouterClient } from "./router.js";
 import { HostServer } from "./server.js";
 import { LocalControl } from "./local-control.js";
-import { findClaude, specFor } from "./service.js";
+import { findClaude, specFor, cliLoginWarning } from "./service.js";
 import { installService, uninstallService, serviceStatus, servicePaths, renderService, supervisorName, controlShutdown } from "./host-service.js";
 import { Sessions } from "./sessions.js";
 import { desktopHandoff } from "./handoff.js";
+import { claudeBinary, claudeCodeLogin } from "../../cli/src/claude-auth.js";
 const here = path.dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(fs.readFileSync(path.join(here, "..", "package.json"), "utf8")).version;
 const out = (s) => { process.stdout.write(s); };
@@ -231,7 +232,9 @@ async function installCmd() {
     if (process.platform === "win32" && !process.argv.includes("--print"))
         await controlShutdown(dir);
     const cfg = process.argv.includes("--print") ? loadConfig(dir, false) : configFromArgs(dir);
-    const spec = specFor({ script: fileURLToPath(import.meta.url), claudePath: findClaude(cfg.claudePath), ...(process.env.RIPPLE_REMOTE_HOME ? { remoteHome: process.env.RIPPLE_REMOTE_HOME } : {}) });
+    // The CLI the host will start; also what a person is told to run when it has no login.
+    const claudePath = findClaude(cfg.claudePath);
+    const spec = specFor({ script: fileURLToPath(import.meta.url), claudePath, ...(process.env.RIPPLE_REMOTE_HOME ? { remoteHome: process.env.RIPPLE_REMOTE_HOME } : {}) });
     if (process.argv.includes("--print")) {
         out(renderService(spec));
         return;
@@ -239,6 +242,12 @@ async function installCmd() {
     for (const line of await installService(spec))
         out(`${line}\n`);
     out(`Pair the phone: clauderipple remote pair\n`);
+    // The host starts Claude Code through the Agent SDK and passes no credential of its own, so a
+    // machine where the CLI was never logged in fails on every turn (issue #71). Say so now; the
+    // install itself is never held up by it.
+    const warning = cliLoginWarning(await claudeCodeLogin(), claudePath ?? claudeBinary() ?? null);
+    if (warning)
+        out(`⚠ ${warning}\n`);
 }
 async function main() {
     const sub = process.argv[2] && !process.argv[2].startsWith("--") ? process.argv[2] : null;

package/dist/remote/src/service.js

@@ -4,7 +4,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { claudeBinary } from "../../cli/src/claude-auth.js";
+import { claudeBinary, claudeLoginHint } from "../../cli/src/claude-auth.js";
 export const LABEL = "com.clauderipple.host";
 // ---- where things are --------------------------------------------------------------------------
 /** The user's own CLI when there is one: it is the version the router's measurements and the ripple mod are kept current with. */
@@ -26,6 +26,16 @@ export function findClaude(configured, exists = fs.existsSync, opts = {}) {
     // Shared discovery also covers both AppData roots and Desktop's version/hash cache layout.
     return platform === process.platform && exists === fs.existsSync ? claudeBinary() ?? undefined : undefined;
 }
+/**
+ * The one line `remote install` prints when the Claude Code CLI has no login of its own: the host
+ * starts Claude Code through the Agent SDK and passes no credential, so every phone turn would
+ * fail at once with the CLI's own "Not logged in" (issue #71). Null when there is a login.
+ */
+export function cliLoginWarning(login, binary) {
+    if (login.ok)
+        return null;
+    return `Claude Code has no login on this computer, so phone sessions will fail until it has one. ${claudeLoginHint(binary)}`;
+}
 const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 export function plist(spec) {
     const program = [spec.node, "--disable-warning=ExperimentalWarning", spec.script, ...spec.args];

package/dist/remote/src/sessions.js

@@ -11,7 +11,7 @@ import { attachmentContent, messageContent, sendUserFileImages } from "./images.
 import { ATTACHMENT_CAP, ATTACHMENT_COUNT } from "./protocol.js";
 import { DesktopSessions } from "./desktop.js";
 import { DesktopSidebar, PHONE_GROUP } from "./sidebar.js";
-import { BridgeAuthError, BridgeClient, DESKTOP_BLOCKED, object, slashCommands } from "./bridge-client.js";
+import { BridgeAuthError, BridgeClient, CLI_NOT_LOGGED_IN, DESKTOP_BLOCKED, isCliNotLoggedIn, object, slashCommands } from "./bridge-client.js";
 import { isDirectory } from "./folders.js";
 import { readJson, writeFileAtomic } from "./fsutil.js";
 import { createWorktree } from "./worktree.js";
@@ -1474,12 +1474,23 @@ export class Sessions {
         this.live.delete(r.id);
         this.opts.permissions.expireSession(r.id, "aborted");
         if (failure) {
-            this.append(r.id, { kind: "result", ok: false, error: failure, ms: this.now() - live.turnStart, turns: 0 });
-            this.setState(r, "error", failure.slice(0, 300));
+            const text = this.failureText(r.id, failure);
+            this.append(r.id, { kind: "result", ok: false, error: text, ms: this.now() - live.turnStart, turns: 0 });
+            this.setState(r, "error", text.slice(0, 300));
         }
         else if (r.state !== "idle" && r.state !== "error")
             this.setState(r, "stopped");
     }
+    /**
+     * The CLI's own words for "no login" become the host's, so a phone reads what to do about it.
+     * The raw text stays in the host's own log line, where the exact CLI wording belongs.
+     */
+    failureText(id, raw) {
+        if (!isCliNotLoggedIn(raw))
+            return raw;
+        (this.opts.log ?? console.error)(`[session ${id.slice(0, 8)}] Claude Code CLI: ${raw.trim()}`);
+        return CLI_NOT_LOGGED_IN;
+    }
     handle(r, live, msg) {
         const parent = msg.parent_tool_use_id ?? null;
         switch (msg.type) {
@@ -1638,7 +1649,7 @@ export class Sessions {
                 for (const [model, u] of Object.entries(usage ?? {}))
                     if (typeof u.contextWindow === "number")
                         this.learnWindow(model, u.contextWindow);
-                const error = ok ? undefined : String(msg.result ?? (Array.isArray(msg.errors) ? msg.errors.join("; ") : msg.subtype ?? "error")).slice(0, 500);
+                const error = ok ? undefined : this.failureText(r.id, String(msg.result ?? (Array.isArray(msg.errors) ? msg.errors.join("; ") : msg.subtype ?? "error"))).slice(0, 500);
                 this.append(r.id, { kind: "result", ok, ...(error ? { error } : {}), ms: typeof msg.duration_ms === "number" ? msg.duration_ms : this.now() - live.turnStart, turns: typeof msg.num_turns === "number" ? msg.num_turns : 0 });
                 this.setState(r, live.pendingTurns > 0 ? "running" : ok ? "idle" : "error");
                 if (live.pendingTurns === 0)

package/dist/router/src/config.js

@@ -8,6 +8,19 @@ import os from "node:os";
 import path from "node:path";
 import { PRESETS } from "./presets.js";
 import { hostProblem, portProblem } from "./remote-host.js";
+/**
+ * A provider's Fast switches as two plain booleans.
+ *
+ * Anything that is not exactly `true` is off: the switches are read from a file a person can edit
+ * by hand, and a value that is not a boolean ("yes", 1, null) must not be read as "on". A `fast`
+ * that is not an object at all is off the same way, rather than a crash on the first request.
+ */
+export function fastSwitches(provider) {
+    const fast = provider?.fast;
+    if (!fast || typeof fast !== "object")
+        return { main: false, subagent: false };
+    return { main: fast.main === true, subagent: fast.subagent === true };
+}
 /**
  * The provider's own key wherever its headers carry it, and every header that is not that one.
  *
@@ -502,6 +515,12 @@ export function validate(c) {
             }
             if (p.url && !/^https?:\/\//.test(p.url))
                 errors.push(`provider ${name}: url must start with http:// or https://`);
+            // Only the shape is refused here. A value inside that is not a boolean is not an error: it is
+            // read as off (fastSwitches), so a hand-edited file cannot put the router on a tier by
+            // accident, and one odd value does not keep the whole config from loading.
+            if (p.fast !== undefined && (!p.fast || typeof p.fast !== "object" || Array.isArray(p.fast))) {
+                errors.push(`provider ${name}: fast must be an object with main and subagent booleans`);
+            }
         }
         else if (p.type === "openai-compatible") {
             if (!/^https?:\/\//.test(p.url))

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

@@ -14,7 +14,7 @@ import { credentialHeaderValues, redactErrorText } from "../../redact.js";
 import { codexClientVersion, latestCodexVersion, parseCodexCatalog } from "./catalog.js";
 import fs from "node:fs";
 import path from "node:path";
-import { homeDir } from "../../config.js";
+import { homeDir, fastSwitches } from "../../config.js";
 export const DEFAULT_BASE = "https://chatgpt.com/backend-api";
 const PING_MS = 15_000;
 /** How long a stream may hold its headers waiting for upstream's first item (see `handle`). Tests shorten it. */
@@ -980,8 +980,11 @@ export class ChatGptAdapter {
      * to replay is read out of the request itself; `carried` is filled in as the input is built and the
      * outcome lands in the request log. `replay: false` is the retry after the backend refused that
      * carrier, and it puts back exactly the request this adapter sent before any of this existed.
+     *
+     * `subagent` is the one bit about the caller the tier needs: Claude Code names the agent in the
+     * `x-claude-code-agent-id` header, and only a subagent's request carries it.
      */
-    responsesOptions(carried, model, effort, replay = true) {
+    responsesOptions(carried, model, effort, replay = true, subagent = false) {
         return {
             model,
             effort: effort ?? this.cfg.defaultEffort ?? "high",
@@ -992,12 +995,20 @@ export class ChatGptAdapter {
             // else: reasoning outlives the turn that made it, and a conversation moved to another model
             // must not carry the old one's sealed state with it (reasoning.ts).
             env: { p: this.name, m: model },
+            // The Fast switches are the provider's own, so the tier is the same however the turn arrived.
+            fast: fastSwitches(this.cfg),
+            subagent,
             carried,
             log: (line) => this.log.info(`chatgpt ${this.name}: ${line} (${model})`),
         };
     }
-    /** Handle a fully-read Messages request. `model`/`effort` already resolved by routing. */
-    async handle(req, res, path, json, model, effort) {
+    /**
+     * Handle a fully-read Messages request. `model`/`effort` already resolved by routing.
+     *
+     * `options.subagent` says the turn was made inside a subagent, which is what the provider's
+     * `fast.subagent` switch is about.
+     */
+    async handle(req, res, path, json, model, effort, options) {
         if (path.startsWith("/v1/messages/count_tokens")) {
             const body = JSON.stringify({ input_tokens: estimateTokens(json) });
             res.writeHead(200, { "content-type": "application/json", "content-length": String(body.length) }).end(body);
@@ -1009,7 +1020,8 @@ export class ChatGptAdapter {
         if (serverTools.size > 0)
             this.log.warn(`chatgpt ${this.name}: dropped server tools for ${model}: ${[...serverTools].join(", ")} (Anthropic runs these; this provider cannot)`);
         const carried = { replayed: 0, undecodable: 0 };
-        let upstreamReq = toResponsesRequest(json, this.responsesOptions(carried, model, effort));
+        const subagent = options?.subagent === true;
+        let upstreamReq = toResponsesRequest(json, this.responsesOptions(carried, model, effort, true, subagent));
         let body = JSON.stringify(upstreamReq);
         const cacheKey = upstreamReq.prompt_cache_key;
         // Input estimate for message_start: a conversation only grows, so the last measured total is a floor.
@@ -1050,7 +1062,7 @@ export class ChatGptAdapter {
         // must never be the reason a user's turn fails (reasoning.ts).
         if (carried.replayed > 0 && sent.kind === "refused" && refusesReplayedReasoning(sent.status, sent.text)) {
             this.log.warn(`chatgpt ${this.name}: upstream ${sent.status} refused ${carried.replayed} replayed reasoning item(s) for ${model}; asking again without them: ${sent.text.slice(0, 200)}`);
-            upstreamReq = toResponsesRequest(json, this.responsesOptions({ replayed: 0, undecodable: 0 }, model, effort, false));
+            upstreamReq = toResponsesRequest(json, this.responsesOptions({ replayed: 0, undecodable: 0 }, model, effort, false, subagent));
             body = JSON.stringify(upstreamReq);
             carried.replayed = 0;
             sent = await ask();

package/dist/router/src/providers/chatgpt/translate.js

@@ -373,7 +373,11 @@ export function toResponsesRequest(req, opts) {
         out.tool_choice = tool_choice;
     // Claude Code's `/fast` arrives as `speed: "fast"` (Anthropic fast mode). The ChatGPT backend's
     // equivalent is the Codex CLI's Fast mode, which bills the plan at a higher rate (Codex docs, Speed).
-    if (req.speed === "fast")
+    // The CLI never sends `speed` for a GPT model, so the provider's own switches choose the tier:
+    // `fast.subagent` for a turn made inside a subagent, `fast.main` for the session's own turns.
+    const fast = opts.fast;
+    const fastOn = fast ? (opts.subagent === true ? fast.subagent === true : fast.main === true) : false;
+    if (req.speed === "fast" || fastOn)
         out.service_tier = "priority";
     return out;
 }

package/dist/router/src/proxy.js

@@ -692,6 +692,14 @@ export class Proxy {
         const session = req.headers["x-claude-code-session-id"];
         if (typeof session === "string" && /^[\w-]{1,128}$/.test(session))
             record.session = session;
+        // Claude Code names the agent a request was made inside, and only a subagent's request carries
+        // the name (CLI 2.1.304: `...Y?.agentId&&{"x-claude-code-agent-id":…}`). This one bit is what
+        // tells the main session from a subagent's turns, so it is recorded for every provider and read
+        // by the ChatGPT adapter to choose its tier.
+        const agentId = req.headers["x-claude-code-agent-id"];
+        const subagent = typeof agentId === "string" && agentId.length > 0;
+        if (subagent)
+            record.subagent = true;
         let observedUsage;
         let observedStopReason;
         // Set once a Google turn came back unwritten (a prompt refusal or no model capacity), which allows
@@ -980,7 +988,7 @@ export class Proxy {
                         try {
                             // The adapter reports each account's outcome to the shared pool itself, so a slot pointing
                             // here fails over once every account is out (chooseTarget asks the adapter).
-                            const o = await this.chatgpt(route.provider, provider).handle(req, res, path, json, route.model, effortOf(json));
+                            const o = await this.chatgpt(route.provider, provider).handle(req, res, path, json, route.model, effortOf(json), { subagent });
                             if (!path.startsWith("/v1/messages/count_tokens"))
                                 this.providerHealth.observe(route.provider, o.status, o.exhaustion);
                             finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...o, ...(searchAttempted ? { upstreamCalled: undefined } : {}) });

package/dist/router/src/tether-win.js

@@ -76,6 +76,13 @@ export function parseProfileNames(text) {
     }
     return names;
 }
+/** `netsh wlan show networks mode=ssid`: SSID is the protocol label, not the translated fields below it. */
+export function parseVisibleSsids(text) {
+    return [...new Set(text.split(/\r?\n/).flatMap((line) => {
+            const name = /^\s*SSID\s+\d+\s*:\s?(.*)$/.exec(line)?.[1]?.trim();
+            return name ? [name] : [];
+        }))];
+}
 function xmlText(s) {
     return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n))).replace(/&amp;/g, "&");
 }
@@ -103,6 +110,8 @@ export async function listWifiProfiles(run) {
         const r = await run(NETSH, ["wlan", "export", "profile", `folder="${dir}"`], { verbatim: true });
         if (needsLocation(r))
             return { profiles: [], location: true };
+        if (r.code !== 0)
+            return { profiles: [], error: (r.stderr || r.stdout).trim().slice(0, 200) || `profile export exited ${r.code}` };
         const parsed = [];
         for (const f of fs.readdirSync(dir)) {
             if (!f.toLowerCase().endsWith(".xml"))
@@ -191,8 +200,21 @@ export class WinTetherBackend {
         if (list.location)
             return "Windows needs Location on for Wi-Fi commands";
         if (list.error)
-            return null; // cannot tell: try anyway
-        return autoProfiles(list.profiles, ssid).length ? null : "no other Wi-Fi on this PC is set to connect automatically";
+            throw new Error(`saved Wi-Fi profiles failed: ${list.error}`);
+        const known = autoProfiles(list.profiles, ssid).filter((p) => p.ssid !== ssid);
+        if (!known.length)
+            return "no other Wi-Fi on this PC is set to connect automatically";
+        if (!this.adapter)
+            throw new Error("no Wi-Fi adapter for visibility scan");
+        const shown = await this.run(NETSH, ["wlan", "show", "networks", "mode=ssid", `interface="${this.adapter}"`], { verbatim: true, timeoutMs: 20_000 });
+        if (needsLocation(shown))
+            return "Windows needs Location on to scan for known Wi-Fi; visibility is unknown";
+        if (shown.code !== 0)
+            throw new Error(`netsh Wi-Fi scan failed: ${(shown.stderr || shown.stdout).trim().slice(0, 200) || `exit ${shown.code}`}`);
+        const visible = parseVisibleSsids(shown.stdout);
+        if (!visible.length)
+            return "no known Wi-Fi in range (netsh returned no usable SSIDs; empty, redacted or unsupported scan)";
+        return known.some((p) => visible.includes(p.ssid)) ? null : "no known Wi-Fi in range";
     }
     async leave() {
         if (!this.adapter)

package/dist/router/src/tether.js

@@ -11,13 +11,14 @@
 //   failover  on Wi-Fi (or none), 3 of the last 5 probe rounds failed → `sudo -n networksetup
 //             -setairportnetwork <dev> <hotspot>`; macOS takes the password from the System keychain.
 //   return    on the hotspot, at 5, 10, 20, 30, 40, 50 and 60 min after landing and every 10 min
-//             after that, while no model call runs → disassociate (CoreWLAN through JXA, as the
+//             after that, only if another known Wi-Fi is visible, while no model call runs →
+//             disassociate (CoreWLAN through JXA, as the
 //             console user — the router is a launchd agent in the user's session) so macOS
 //             auto-joins the best known network in range; probe it; if that does not give working
 //             Wi-Fi within 20s, rejoin the hotspot and wait for the next point. The times are fixed
 //             from landing rather than a doubling backoff (owner's decision, 2026-10-20): at most
-//             ~10 min on the hotspot after arriving at a known Wi-Fi, and a brief drop every 10 min
-//             on the move, instead of a cap of 15 min.
+//             ~10 min on the hotspot after arriving at a known Wi-Fi. On the move, a read-only scan
+//             replaces the old blind drop (2026-10-21): no known Wi-Fi in range → no leave, no hold.
 //   gap       a return still postponed RETURN_FORCE_AFTER_MS past due (calls back-to-back, so never
 //             a quiet moment — 2026-10-20) makes the gap itself: new model calls are held (hold.ts:
 //             they wait, they are not refused), the running ones get up to RETURN_DRAIN_WAIT_MS to
@@ -43,18 +44,36 @@ export const NETWORKSETUP = "/usr/sbin/networksetup";
 export const OSASCRIPT = "/usr/bin/osascript";
 /** wifihop's exact call (verified in its source, `mac_disassociate_js`): a zero-argument ObjC method is invoked by reading it. */
 export const DISASSOCIATE_JS = 'ObjC.import("CoreWLAN"); $.CWWiFiClient.sharedWiFiClient.interface.disassociate; "ok";';
+/** Read-only directed scans: a non-empty set proves visibility even if CWNetwork.ssid is redacted. */
+export const SCAN_KNOWN_JS = `function run(argv) {
+  ObjC.import("CoreWLAN");
+  var wifi = $.CWWiFiClient.sharedWiFiClient.interfaceWithName(argv[0]);
+  var names = JSON.parse(argv[1]);
+  for (var n = 0; n < names.length; n++) {
+    var error = Ref();
+    var found = wifi.scanForNetworksWithNameError(names[n], error);
+    var count = Number(found.count);
+    if (!isFinite(count) || count < 0) {
+      throw new Error("CoreWLAN scan unavailable: " + (ObjC.unwrap(error[0].localizedDescription) || "no result set"));
+    }
+    if (count > 0) return "visible";
+  }
+  return "none";
+}`;
 export const PROBE_URLS = {
     apple: "http://captive.apple.com/hotspot-detect.html",
     google: "http://connectivitycheck.gstatic.com/generate_204",
 };
 export const PROBE_TIMEOUT_MS = 4_000;
 export const MIN_SWITCH_INTERVAL_MS = 60_000;
+/** How long a scan that saw a known Wi-Fi stands for a return still waiting on busy calls. */
+export const KNOWN_VISIBLE_TRUST_MS = 60_000;
 export const RETURN_PROBE_MS = 20_000;
 /**
  * When to try the way back, counted from the moment the Mac landed on the hotspot: 5, 10, 20, 30,
  * 40, 50 and 60 min, then every 10 min for as long as it stays there (owner's decision, 2026-10-20 —
  * a fixed schedule rather than a doubling one: at most ~10 min on the hotspot after arriving at a
- * known Wi-Fi, and only a brief drop every 10 min on the move).
+ * known Wi-Fi). Each point scans first; without a visible known network it never drops the hotspot.
  */
 export const RETURN_SCHEDULE_MINUTES = [5, 10, 20, 30, 40, 50, 60];
 /** After the last scheduled point, every this long. */
@@ -90,6 +109,10 @@ export function parseWifiDevice(text) {
     }
     return null;
 }
+/** `networksetup -listpreferredwirelessnetworks`: preserve SSID spaces, discard only the indent. */
+export function parsePreferredNetworks(text) {
+    return [...new Set(text.split(/\r?\n/).filter((line) => line.startsWith("\t")).map((line) => line.slice(1)).filter(Boolean))];
+}
 /** The interface's IPv4 address, or null when it has none (not associated, or no DHCP yet). */
 export function wifiIPv4(ifaces, device) {
     return ifaces[device]?.find((a) => a.family === "IPv4" && !a.internal)?.address ?? null;
@@ -279,6 +302,22 @@ class MacTetherBackend {
             this.log.warn(`tether: networksetup said: ${(r.stdout + r.stderr).trim().slice(0, 200)}`);
         return failed;
     }
+    async returnBlocked(ssid) {
+        const preferred = await this.run(NETWORKSETUP, ["-listpreferredwirelessnetworks", this.device]);
+        if (preferred.code !== 0)
+            throw new Error(`preferred Wi-Fi list failed: ${(preferred.stderr || preferred.stdout).trim().slice(0, 200) || `exit ${preferred.code}`}`);
+        const names = parsePreferredNetworks(preferred.stdout).filter((name) => name !== ssid);
+        if (!names.length)
+            return "no known Wi-Fi in range";
+        const r = await this.run(OSASCRIPT, ["-l", "JavaScript", "-e", SCAN_KNOWN_JS, this.device, JSON.stringify(names)], { timeoutMs: 30_000 });
+        if (r.code !== 0)
+            throw new Error(`CoreWLAN scan failed: ${(r.stderr || r.stdout).trim().slice(0, 200) || `exit ${r.code}`}`);
+        if (r.stdout.trim() === "visible")
+            return null;
+        if (r.stdout.trim() === "none")
+            return "no known Wi-Fi in range";
+        throw new Error("CoreWLAN scan returned an unsupported result");
+    }
     async leave() {
         const r = await this.run(OSASCRIPT, ["-l", "JavaScript", "-e", DISASSOCIATE_JS], { timeoutMs: 15_000 });
         return r.code === 0 ? null : (r.stderr || r.stdout).trim().slice(0, 200);
@@ -297,6 +336,8 @@ export class TetherController {
     state = "off";
     pinned = false;
     lastSwitchAt = 0;
+    /** When a scan last saw a known Wi-Fi other than the hotspot. */
+    knownVisibleAt = -Infinity;
     lastSwitch = null;
     lastProbe = null;
     /** When the Mac landed on the hotspot (ours or by hand); null off the hotspot. The schedule counts from here. */
@@ -570,16 +611,31 @@ export class TetherController {
     async tryReturn(settings) {
         if (this.now() - this.lastSwitchAt < MIN_SWITCH_INTERVAL_MS)
             return;
+        // A return postponed for busy calls comes back every tick; one scan that saw a known Wi-Fi is
+        // trusted for a minute rather than repeated each time (a scan takes seconds on the radio).
+        if (this.now() - this.knownVisibleAt >= KNOWN_VISIBLE_TRUST_MS) {
+            let blocked;
+            try {
+                blocked = await this.backend.returnBlocked(settings.hotspotSsid);
+            }
+            catch (e) {
+                blocked = `known Wi-Fi scan failed: ${e instanceof Error ? e.message : String(e)}`;
+            }
+            if (blocked) {
+                this.backOff(blocked);
+                return;
+            }
+            this.knownVisibleAt = this.now();
+        }
+        // A scan is asynchronous: a pin/stop/settings change or an OS join meanwhile cancels the return.
+        const current = this.deps.settings();
+        if (this.stopped || this.pinned || !current.enabled || current.hotspotSsid !== settings.hotspotSsid || !this.onHotspot(this.currentIp()))
+            return;
         const idle = this.idle();
         if (!idle && (this.now() - this.nextReturnAt < RETURN_FORCE_AFTER_MS || this.hold.closed)) {
             this.decide(`Wi-Fi return postponed: a model call is running or just started (after ${RETURN_FORCE_AFTER_MS / 1000}s of this, new calls are held to make a gap)`);
             return;
         }
-        const blocked = (await this.backend.returnBlocked?.(settings.hotspotSsid)) ?? null;
-        if (blocked) {
-            this.backOff(blocked);
-            return;
-        }
         if (idle)
             await this.leaveHotspot(settings);
         else
@@ -704,7 +760,7 @@ export class TetherController {
         const landed = this.landedOnHotspotAt ?? this.now();
         this.nextReturnAt = nextReturnPoint(landed, this.now());
         this.lastLogged = "";
-        this.decide(`staying on the hotspot (${reason}); next try in ${Math.round((this.nextReturnAt - this.now()) / 1000)}s`);
+        this.decide(`staying on the hotspot: ${reason}; next try in ${Math.round((this.nextReturnAt - this.now()) / 1000)}s`);
     }
     recordSwitch(to, ok, reason) {
         this.lastSwitch = { at: new Date(this.now()).toISOString(), to, ok, reason };

package/dist/router/src/version.js

@@ -5,4 +5,4 @@
 // from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
 // still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
 // running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
-export const VERSION = "0.12.1";
+export const VERSION = "0.12.3";

package/dist/ui/app.js

@@ -3171,17 +3171,25 @@ function openProviderForm(options) {
     const identity = el("input", { type: "checkbox", checked: !(existing && existing.identity === false) });
     const limitsInput = el("input", { type: "checkbox", checked: !(existing && existing.limits === false) });
     const append = el("textarea", { rows: "2", value: (existing && existing.instructionsAppend) || "" });
+    // The Codex fast tier, one switch for the session's own turns and one for a subagent's.
+    const fastMain = el("input", { type: "checkbox", checked: Boolean(existing && existing.fast && existing.fast.main === true) });
+    const fastSubagent = el("input", { type: "checkbox", checked: Boolean(existing && existing.fast && existing.fast.subagent === true) });
     chatgptFields = [
       inputRow(t("providers.credentials"), auth, t("providers.credentialsHelp")),
       el("div", { class: "form-field" }, [el("span", { text: t("providers.login") }), login, loginHelp]),
       inputRow(t("providers.defaultEffort"), effort, t("providers.defaultEffortHelp")),
+      el("div", { class: "form-field" }, [
+        el("label", { class: "check" }, [fastMain, el("span", { text: t("providers.fastMain") })]),
+        el("label", { class: "check" }, [fastSubagent, el("span", { text: t("providers.fastSubagent") })]),
+        el("small", { text: t("providers.fastHelp") }),
+      ]),
     ];
     advancedContent.append(
       el("div", { class: "form-field" }, [el("label", { class: "check" }, [identity, el("span", { text: t("providers.identity") })]), el("small", { text: t("providers.identityHelp") })]),
       el("div", { class: "form-field" }, [el("label", { class: "check" }, [limitsInput, el("span", { text: t("providers.limits") })]), el("small", { text: t("providers.limitsHelp") })]),
       inputRow(t("providers.append"), append, t("providers.appendHelp")),
     );
-    advancedContent._chatgpt = { auth, effort, identity, limits: limitsInput, append };
+    advancedContent._chatgpt = { auth, effort, identity, limits: limitsInput, append, fastMain, fastSubagent };
   }
   advanced.appendChild(advancedContent);
   const customUrlRow = isCustom ? inputRow(t("providers.url"), urlInput, t("providers.urlHelp")) : null;
@@ -3223,7 +3231,7 @@ function openProviderForm(options) {
   function draftProvider() {
     if (isChatgpt) {
       const chat = advancedContent._chatgpt;
-      return { type: "chatgpt", auth: chat.auth.value, defaultEffort: chat.effort.value, identity: chat.identity.checked, limits: chat.limits.checked, ...(chat.append.value.trim() ? { instructionsAppend: chat.append.value.trim() } : {}) };
+      return { type: "chatgpt", auth: chat.auth.value, defaultEffort: chat.effort.value, identity: chat.identity.checked, limits: chat.limits.checked, fast: { main: chat.fastMain.checked, subagent: chat.fastSubagent.checked }, ...(chat.append.value.trim() ? { instructionsAppend: chat.append.value.trim() } : {}) };
     }
     const prompt = advancedContent._prompt;
     return {
@@ -3331,7 +3339,7 @@ function openProviderForm(options) {
     // (debugDump, a hand-written setting) is carried over from the saved one rather than dropped.
     // A field the form owns is left to the draft, so clearing it in the form still clears it.
     const formKeys = new Set(isChatgpt
-      ? ["type", "auth", "defaultEffort", "identity", "limits", "instructionsAppend", "models"]
+      ? ["type", "auth", "defaultEffort", "identity", "limits", "instructionsAppend", "fast", "models"]
       : ["type", "url", "identity", "limits", "instructionsAppend", "preset", "sessionHeader", "wire", "caps", "headers", "models"]);
     const kept = saved ? Object.fromEntries(Object.entries(saved).filter(([key]) => !formKeys.has(key))) : {};
     next.providers[providerName] = { ...kept, ...provider };

package/dist/ui/i18n.js

@@ -15,6 +15,9 @@ const I18N = {
     "slots.webSearch": "웹 검색·페이지 읽기", "slots.webSearchFollow": "작고 빠른 모델을 따름", "slots.webSearchHelp": "WebSearch 검색과 WebFetch의 페이지 읽기를 이 모델이 답합니다. 저장 즉시 적용되며, 답변을 시작하기 전에 실패하면 원래 모델로 넘어갑니다.", "slots.webSearchSaved": "웹 검색·페이지 읽기 모델을 저장했습니다. 바로 적용됩니다.",
     "slots.windowGlobal": "기본값", "slots.windowHelp": "모델이 한 번에 읽을 수 있는 컨텍스트 크기를 토큰 단위로 정합니다. 모델마다 지원하는 크기가 달라 따로 정합니다. 비워 두면 프로바이더가 알려 준 값을 쓰고, 그 값도 없으면 시스템 기본값을 씁니다. 대화를 압축할 시점이 아니라 모델이 실제로 읽을 수 있는 최대 크기를 입력하세요.",
     "providers.title": "프로바이더", "providers.subtitle": "연결한 서비스와 계정을 한곳에서 관리합니다. 프로바이더를 고르면 오른쪽에 세부 설정과 계정 목록이 나옵니다.", "providers.search": "프로바이더 검색…", "providers.overview": "개요", "providers.accounts": "계정","providers.modelsTab": "모델", "providers.selectedModels": "선택한 모델", "providers.modelsCountShort": "모델 {count}개", "providers.noSelection": "왼쪽에서 프로바이더를 고르세요.", "providers.rotationOn": "자동 전환 켜짐", "providers.rotationOff": "자동 전환 꺼짐", "providers.rotationSaving": "자동 전환 설정 저장 중…", "providers.rotationSaved": "자동 전환 설정을 저장했습니다.", "providers.accountCount": "연결된 계정 {count}개", "providers.accountCountHelp": "현재 Claude에 로그인한 계정과 리플에 추가한 계정을 모두 합한 수입니다.", "providers.accountPoolTitle": "Claude 계정", "providers.accountPoolSubtitle": "한 대화는 같은 계정으로 이어갑니다. 답변을 시작하기 전에 사용 한도에 걸리거나 인증 오류가 날 때만 다음 계정으로 넘어갑니다.", "providers.addClaudeAccount": "+ Claude 계정 추가", "providers.currentAccountHelp": "지금 Claude Code나 Claude Desktop에 로그인한 계정입니다. 리플에서는 삭제할 수 없습니다.", "providers.addedAccountHelp": "리플이 이 컴퓨터의 현재 사용자만 읽을 수 있는 파일에 OAuth 로그인 정보를 안전하게 저장하고 자동으로 갱신합니다.", "providers.reauthAction": "다시 로그인", "providers.preferBadge": "1순위", "providers.preferAction": "1순위로 지정", "providers.preferHelp": "새 대화는 목록 맨 위의 1순위 계정부터 씁니다. 한도에 닿으면 다음 계정으로 넘어가고, 한도가 초기화되면 새 대화부터 다시 1순위 계정을 씁니다. 진행 중인 대화는 프롬프트 캐시를 지키려고 같은 계정으로 이어갑니다.","providers.dangerZone": "추가 계정 관리","providers.connection": "연결 상태","providers.rotationRequired": "계정을 여러 개 추가해도 자동 전환을 켜야 Claude 앱과 Claude Code에서 쓸 수 있습니다.", "providers.anthropic": "Claude (Anthropic)", "providers.anthropicHelp": "Claude 구독 계정을 자동으로 돌려 쓰거나, Codex 같은 OpenAI 호환 도구에서 Claude 모델을 쓰게 연결합니다.", "providers.anthropicIngressOnly": "자동 전환을 끄면 고른 모델은 Codex 같은 OpenAI 호환 도구에서만 쓸 수 있고, Claude 앱의 모델 매핑에는 나오지 않습니다.", "providers.anthropicPoolRouting": "자동 전환을 켜면 Claude 앱과 Claude Code의 대화마다 같은 계정을 써서 프롬프트 캐시를 지킵니다. 답변을 만들기 전에 429 한도 초과나 인증 거부 오류가 오면 다음 계정으로 넘어갑니다. 구독 계정을 여러 개 쓰는 것은 Anthropic 이용약관에 따라 제한될 수 있습니다. 본인 계정만 허용된 용도로 쓰세요.","providers.anthropicPool": "Claude 계정 자동 전환","providers.anthropicCurrent": "현재 로그인 계정", "providers.anthropicReauth": "다시 로그인 필요", "providers.anthropicNoAccounts": "리플에 추가한 계정이 없습니다.", "providers.anthropicRenamePrompt": "이 계정을 표시할 이름", "providers.anthropicRemoveConfirm": "리플에서 Claude 계정 {name}을(를) 삭제할까요?", "providers.anthropicLogoutAll": "추가 계정 모두 삭제", "providers.anthropicLogoutAllConfirm": "리플에 추가한 Claude 계정을 모두 삭제할까요? Claude Code와 Claude Desktop의 현재 로그인은 그대로 둡니다.", "providers.anthropicAuthClaudeCode": "Claude Code 로그인 사용 (자동)", "providers.anthropicAuthApiKey": "API 키", "providers.anthropicCredentialsHelp": "Claude Code 로그인을 그대로 쓸지, Anthropic API 키로 연결할지 고르세요.", "providers.anthropicSourceObserved": "Claude Desktop 대화에서 확인됨", "providers.anthropicSourceClaudeCode": "터미널 claude 로그인", "providers.anthropicSourceTokenFile": "리플 토큰", "providers.anthropicSourceMissing": "없음 — 아래 버튼으로 연결","providers.anthropicOAuthTitle": "Claude 계정 추가", "providers.anthropicOAuthWarning": "Claude 구독의 OAuth 로그인을 리플 같은 다른 회사 프로그램에서 쓰는 것은 Anthropic이 공식 지원하지 않습니다. 약관을 어겨 계정 이용이 제한될 수 있습니다. 반드시 본인 계정만 허용된 용도로 쓰세요.", "providers.anthropicOAuthAccept": "위험을 확인했고 OAuth로 계속합니다.", "providers.anthropicOAuthContinue": "OAuth로 계속","providers.anthropicLoginDone": "Claude 구독을 연결했습니다.", "providers.anthropicSignInBrowser": "브라우저에서 Claude에 로그인하세요. 창이 열리지 않으면 아래 링크를 여세요.", "providers.anthropicSignInLink": "로그인 페이지 열기", "providers.anthropicSignInPaste": "브라우저에서 로그인한 뒤 나오는 코드를 여기에 붙여넣으세요.", "providers.anthropicSignInSubmit": "코드 입력 완료", "providers.anthropicSignInManual": "코드 붙여넣기로 다시 시도", "providers.anthropicSignInWaiting": "브라우저에서 승인 대기 중… (최대 5분)", "providers.anthropicSignInFailed": "로그인하지 못했습니다.","providers.add": "+ 프로바이더 추가", "providers.refresh": "전체 연결 확인", "providers.check": "연결 확인", "providers.checking": "확인 중", "providers.empty": "아직 연결된 프로바이더가 없습니다. 위쪽 버튼으로 추가하세요.","providers.noModels": "고른 모델이 없습니다. 수정 메뉴에서 모델을 고르세요.", "providers.removeConfirm": "프로바이더 {name}을(를) 삭제할까요? 이 프로바이더를 쓰는 모델 매핑도 함께 삭제됩니다.", "providers.choose": "프로바이더 추가", "providers.chooseHelp": "연결할 서비스를 고르세요.", "providers.chatgpt": "ChatGPT 구독", "providers.chatgptHelp": "Codex가 포함된 ChatGPT 요금제(Plus, Pro, Business 등)로 GPT 모델을 씁니다. API 키 없이 로그인만 하면 연결됩니다.", "providers.presetHelp": "API 키만 입력하면 바로 연결됩니다.", "providers.openaiGroup": "OpenAI 호환", "providers.openaiGroupHelp": "리플이 요청을 OpenAI API 규격에 맞게 바꿔 보냅니다.","providers.custom": "직접 입력", "providers.customName": "새 프로바이더", "providers.customHelp": "목록에 없는 Anthropic 호환 또는 OpenAI 호환 API를 연결합니다. API 주소(엔드포인트 URL)와 키를 직접 입력하세요.", "providers.formatHelp": "서비스 문서에 나온 규격을 고르세요. API 주소가 /chat/completions로 끝나면 OpenAI Chat Completions 규격입니다.", "providers.addTitle": "프로바이더 추가", "providers.edit": "프로바이더 수정", "providers.name": "이름", "providers.nameHelp": "목록과 모델 매핑에 표시할 프로바이더 이름입니다.", "providers.nameRequired": "이름을 입력하세요.", "providers.apiKey": "API 키", "providers.keyHelp": "프로바이더에서 발급받은 API 키입니다. 이 컴퓨터의 설정 파일에만 저장합니다.", "providers.keyPlaceholder": "API 키를 붙여넣으세요", "providers.keySaved": "저장한 키를 쓰고 있습니다. 바꾸려면 새 키를 입력하세요.", "providers.url": "API 기본 주소 (URL)", "providers.urlHelp": "Anthropic 호환 API의 기본 주소입니다. 서비스 문서의 주소와 다를 때만 바꾸세요.", "providers.openaiUrlHelp": "OpenAI 호환 API의 기본 주소입니다. 요청은 Chat Completions 또는 Responses API에 맞게 바꿔 보냅니다.", "providers.wire": "API 규격", "providers.wireHelp": "대부분 Chat Completions를 씁니다. 프로바이더가 이전 대화를 서버에 저장하지 않는 Responses API를 지원할 때만 Responses를 고르세요.", "providers.urlRequired": "올바른 URL을 입력하세요.", "providers.keyType": "인증 헤더", "providers.keyTypeHelp": "보통 x-api-key를 씁니다. 서비스 문서에 Authorization: Bearer 방식이 나와 있으면 그 항목을 고르세요.", "providers.extraHeaders": "추가 HTTP 헤더", "providers.extraHeadersHelp": "서비스에서 요구하는 추가 헤더를 '이름: 값' 형식으로 한 줄에 하나씩 입력하세요.", "providers.models": "사용할 모델", "providers.modelsHelp": "고른 모델이 모델 매핑에서 고를 수 있는 목록에 나옵니다.", "providers.modelsFound": "프로바이더에서 받아 온 모델 목록입니다.", "providers.modelsFallback": "모델 목록을 받아 오지 못해 기본으로 알려진 모델을 보여 줍니다.", "measure.running": "모델 기능 확인 중… ({done}/{total})", "measure.help": "모델마다 어떤 API 규격과 추론 강도를 지원하는지 확인합니다. 공개 모델 목록(models.dev)에 정보가 있으면 그 정보를 쓰고, 없으면 모델에 직접 요청을 보냅니다.", "measure.done": "모델 기능 확인 완료: {summary}", "measure.nothing": "모델이 응답하지 않아 기능을 확인하지 못했습니다.", "measure.notEntitled": "{models}: 이 프로바이더의 자체 앱에서만 쓸 수 있는 모델입니다. 여기서 골라도 쓸 수 없습니다.", "measure.failed": "모델 기능을 확인하지 못했습니다.", "measure.authFailed": "API 키 인증이 거부되어 모델 기능을 확인하지 못했습니다.", "providers.probeNotEntitled": "API 키는 정상이지만 요금제 제한으로 요청이 거부되었습니다.", "providerStatus.notEntitled": "요금제 제한", "providers.probeOk": "연결했습니다.", "providers.probeFailed": "연결하지 못했습니다.", "providers.apiSoon": "잠시 후 다시 시도하세요.", "providers.showInPicker": "Claude 앱 피커에 실제 모델 이름 표시", "providers.pickerOffHint": "피커 모드가 꺼져 있어 골라도 피커에 나오지 않습니다. 저장할 때 피커를 켤지 묻습니다.", "providers.pickerOffPrompt": "피커 모드가 꺼져 있어 이 모델이 Claude Desktop 피커에 나오지 않습니다. 지금 켤까요? 인증서를 신뢰하도록 설정할 때 운영체제의 확인 창이 열립니다.", "providers.credentials": "로그인 방식", "providers.credentialsHelp": "어디에 저장된 ChatGPT 로그인 정보(토큰)를 쓸지 정합니다.", "providers.authAuto": "자동 (리플 로그인 우선, 없으면 Codex CLI 로그인 사용)", "providers.authOwn": "리플에서 직접 로그인", "providers.authBorrow": "Codex CLI 로그인 사용 (~/.codex/auth.json)", "providers.login": "ChatGPT 로그인 안내", "providers.loginHelp": "메뉴 막대 앱에서 'ChatGPT 로그인…'을 누르거나 터미널에서 clauderipple login을 실행하면 브라우저 로그인 창이 열립니다. 토큰은 이 컴퓨터에만 저장합니다.","providers.chatgptLogin": "ChatGPT 로그인", "providers.chatgptLoginWaiting": "브라우저에서 로그인을 마치면 이 화면이 자동으로 새로고침됩니다.", "providers.chatgptLoginDone": "ChatGPT에 로그인했습니다.", "providers.chatgptAccountsTitle": "ChatGPT 계정", "providers.chatgptAccountsSubtitle": "계정을 여러 개 추가하면 한 계정이 한도에 닿았을 때 다음 계정이 같은 요청을 이어받습니다. 답한 뒤에는 같은 계정으로 대화를 이어가 프롬프트 캐시를 지킵니다. 계정은 목록 순서대로 씁니다.", "providers.addChatgptAccount": "+ ChatGPT 계정 추가", "providers.chatgptAddWaiting": "브라우저에서 추가할 계정으로 로그인하세요. 이미 로그인한 계정이 나오면 다른 계정을 고르세요.", "providers.chatgptAdded": "ChatGPT 계정을 추가했습니다.", "providers.chatgptNoAccounts": "로그인한 ChatGPT 계정이 없습니다.", "providers.chatgptAccountCount": "계정 {count}개", "providers.chatgptCodexHelp": "Codex CLI에 로그인한 계정입니다. 리플은 로그인 정보를 읽기만 하고 자동으로 갱신하지 않습니다. 다른 계정을 모두 쓴 뒤 마지막에 씁니다.", "providers.chatgptOwnHelp": "리플이 이 컴퓨터의 현재 사용자만 읽을 수 있는 파일에 계정 정보를 저장하고 자동으로 갱신합니다.", "providers.chatgptInUse": "현재 사용 중", "providers.chatgptStandby": "대기", "providers.chatgptPause": "일시 중지", "providers.chatgptResume": "다시 사용", "providers.chatgptPaused": "일시 중지됨", "providers.chatgptClearCooldown": "대기 해제", "providers.chatgptRemoveConfirm": "리플에서 ChatGPT 계정 {name}을(를) 삭제할까요?", "providers.chatgptReauthHelp": "로그인이 만료되었거나 거부되었습니다. 같은 계정으로 다시 로그인하면 사용할 수 있습니다.", "pool.coolingFor": "{duration} 후 다시 사용", "time.hoursMinutes": "{h}시간 {m}분", "time.minutes": "{m}분", "time.seconds": "{s}초", "quota.window5h": "5시간", "quota.windowWeek": "주간", "quota.windowHours": "{hours}시간", "quota.line": "{window} {percent}%", "quota.resetAt": "{time} 초기화", "providers.effortLevels": "추론 강도: {levels}", "providers.effortNone": "지원 안 함", "providers.modelEffort": "추론 강도 설정", "providers.modelNoEffort": "추론 강도 지원 안 함", "providers.defaultEffort": "기본 추론 강도 (effort)", "providers.defaultEffortHelp": "모델 매핑이나 앱에서 추론 강도를 따로 정하지 않았을 때 쓸 값입니다.", "providers.identity": "모델에 자기 이름 알려 주기 (identity)", "providers.append": "시스템 프롬프트 추가 문구", "providers.appendHelp": "모든 요청의 시스템 프롬프트 끝에 덧붙이는 고정 문구입니다. 자주 바꾸면 프롬프트 캐시를 쓸 수 없어 비용이 늘 수 있습니다.",
+    "providers.fastMain": "메인 세션 Fast",
+    "providers.fastSubagent": "서브에이전트 Fast",
+    "providers.fastHelp": "켜면 GPT 요청을 Codex 빠른 등급으로 보냅니다. 응답이 빨라지는 대신 구독 사용량이 더 빨리 줄어듭니다.",
     "providerStatus.connected": "연결됨", "providerStatus.keyNeeded": "API 키 확인 필요", "providerStatus.loginNeeded": "로그인 필요", "providerStatus.disconnected": "연결 안 됨", "providerStatus.checking": "확인 중",
     "clients.title": "클라이언트", "clients.subtitle": "리플에 연결해서 쓸 앱을 설정합니다.", "clients.desktop.title": "Claude Desktop", "clients.desktop.help": "프로바이더의 모델을 피커에 실제 이름으로 표시할지 정합니다.", "clients.codex.title": "Codex (앱과 CLI)", "clients.codex.help": "Codex 설정(~/.codex/config.toml)에 리플 프로바이더를 추가합니다. 터미널에서는 `codex --profile clauderipple -m <모델>`을 실행하고, Codex 앱에서는 설정에서 clauderipple 프로바이더를 기본값으로 고르세요.", "clients.codex.note": "켜면 Codex의 GPT 요청도 리플이 처리합니다. Codex 로그인은 그대로입니다. ChatGPT 계정을 여러 개 추가해 두면 한 계정이 한도에 걸려도 로그아웃할 필요 없이 다음 계정이 이어받습니다. 아래는 Codex에서 더 쓸 수 있는 Claude 모델과 Anthropic 호환 모델입니다.", "clients.codex.turnOn": "Codex에서 리플 사용","clients.claudeCode.title": "터미널 Claude Code", "clients.claudeCode.help": "터미널의 `claude`도 같은 리플에 연결됩니다. `/model <이름>` 명령어로 모델을 고르세요.",
     "logs.title": "로그", "logs.requests": "요청", "logs.raw": "원본 로그", "logs.lastHour": "최근 1시간", "logs.autoscroll": "자동 스크롤", "logs.polling": "3초마다 새로고침", "logs.rawPolling": "3초마다 새로고침 · 최근 200줄", "logs.provider": "프로바이더", "logs.all": "전체","logs.empty": "아직 요청이 없습니다.", "logs.summary.requests": "요청 수", "logs.summary.success": "성공 / 실패", "logs.summary.input": "입력 토큰", "logs.summary.output": "출력 토큰", "logs.summary.duration": "평균 응답 시간", "logs.cacheHit": "캐시 {percent}%", "logs.th.time": "시간", "logs.th.models": "모델", "logs.th.effort": "추론 강도", "logs.th.input": "입력", "logs.th.output": "출력", "logs.th.duration": "소요 시간", "logs.th.status": "상태", "logs.status.ok": "성공", "logs.status.error": "오류", "logs.status.resent": "재전송", "logs.status.resentHelp": "오류가 아닙니다. 클라이언트가 같은 요청을 다시 보냈습니다.", "logs.detail.id": "요청 ID", "logs.detail.kind": "종류", "logs.detail.stop": "종료 이유", "logs.detail.uncached": "캐시를 쓰지 않은 입력", "logs.detail.cacheRead": "캐시 읽기", "logs.detail.cacheWrite": "캐시 저장", "logs.detail.note": "메모", "logs.none": "없음", "logs.seconds": "{value}초",
@@ -232,6 +235,9 @@ const I18N = {
     "slots.webSearch": "Web search & page reading", "slots.webSearchFollow": "Follow the small, fast model", "slots.webSearchHelp": "This model answers WebSearch and WebFetch page reading. Applies immediately; failure before the response starts falls back to the original model.", "slots.webSearchSaved": "Web search & page reading model saved. Applies immediately.",
     "slots.windowGlobal": "default", "slots.windowHelp": "This model's context window, in tokens. Routed models do not share one, so each carries its own. Left blank it takes what the provider reported, and otherwise the global default. Enter the model's real window, not a compaction point.",
     "providers.title": "Providers", "providers.subtitle": "Manage connected services and accounts in one place. Pick a provider to open its settings and accounts.", "providers.search": "Search providers…", "providers.overview": "Overview", "providers.accounts": "Accounts","providers.modelsTab": "Models", "providers.selectedModels": "Selected models", "providers.modelsCountShort": "{count} models", "providers.noSelection": "Select a provider on the left.", "providers.rotationOn": "Rotation on", "providers.rotationOff": "Rotation off", "providers.rotationSaving": "Saving rotation…", "providers.rotationSaved": "Account rotation saved.", "providers.accountCount": "{count} connected accounts", "providers.accountCountHelp": "Includes the current Claude login and accounts added to ClaudeRipple.", "providers.accountPoolTitle": "Claude accounts", "providers.accountPoolSubtitle": "A conversation stays on one account. ClaudeRipple switches only when quota or authentication fails before output starts.", "providers.addClaudeAccount": "+ Add Claude account", "providers.currentAccountHelp": "The external sign-in currently used by Claude Code or Claude Desktop. ClaudeRipple cannot remove it.", "providers.addedAccountHelp": "ClaudeRipple stores this OAuth grant on this computer and refreshes it automatically.", "providers.reauthAction": "Sign in again", "providers.preferBadge": "First", "providers.preferAction": "Use first", "providers.preferHelp": "New conversations start on the account at the top. When it hits its limit they move to the next one, and once it resets new conversations go back to it. A conversation already running stays on its account to keep its cache.","providers.dangerZone": "Added account management","providers.connection": "Connection","providers.rotationRequired": "Added accounts are used for Claude app and Claude Code requests only when account rotation is on.", "providers.anthropic": "Claude (Anthropic)", "providers.anthropicHelp": "Rotate Claude subscription accounts, or serve Claude models to OpenAI-style tools such as Codex.", "providers.anthropicIngressOnly": "With account rotation off, the models chosen here are served only to OpenAI-style tools such as Codex and do not appear in Claude app mappings.", "providers.anthropicPoolRouting": "With account rotation on, Claude app and Claude Code requests stay on one account per conversation to preserve the prompt cache. A 429 or authentication refusal before the response starts moves the request to the next account. Using multiple subscriptions may be subject to Anthropic's terms and account restrictions; use only your own authorized accounts.","providers.anthropicPool": "Rotate Claude accounts automatically","providers.anthropicCurrent": "Current login", "providers.anthropicReauth": "Sign in again", "providers.anthropicNoAccounts": "No accounts have been added to ClaudeRipple.", "providers.anthropicRenamePrompt": "Display name for this account", "providers.anthropicRemoveConfirm": "Remove Claude account {name} from ClaudeRipple?", "providers.anthropicLogoutAll": "Remove all added accounts", "providers.anthropicLogoutAllConfirm": "Remove every Claude account added to ClaudeRipple? The current Claude Code and Claude Desktop login is not changed.", "providers.anthropicAuthClaudeCode": "Reuse Claude Code sign-in (automatic)", "providers.anthropicAuthApiKey": "API key", "providers.anthropicCredentialsHelp": "Choose your Claude Code sign-in or an Anthropic API key.", "providers.anthropicSourceObserved": "Detected from a Claude Desktop session", "providers.anthropicSourceClaudeCode": "Terminal Claude sign-in", "providers.anthropicSourceTokenFile": "ClaudeRipple token", "providers.anthropicSourceMissing": "None — connect below","providers.anthropicOAuthTitle": "Add Claude account", "providers.anthropicOAuthWarning": "Using Claude subscription OAuth through a third-party proxy is not an Anthropic-supported integration and may be subject to terms or account restrictions. Use only your own accounts for authorized purposes.", "providers.anthropicOAuthAccept": "I understand the risk and want to continue with OAuth.", "providers.anthropicOAuthContinue": "Continue with OAuth","providers.anthropicLoginDone": "Claude subscription connected.", "providers.anthropicSignInBrowser": "Sign in to Claude in your browser. If no window opened, use the link below.", "providers.anthropicSignInLink": "Open the sign-in page", "providers.anthropicSignInPaste": "After signing in, paste the code the page shows here.", "providers.anthropicSignInSubmit": "Submit code", "providers.anthropicSignInManual": "Try again by pasting a code", "providers.anthropicSignInWaiting": "Waiting for the browser… (up to 5 minutes)", "providers.anthropicSignInFailed": "Sign-in failed","providers.add": "+ Add provider", "providers.refresh": "Test all", "providers.check": "Test connection", "providers.checking": "Checking", "providers.empty": "No providers connected yet. Add one with the button above.","providers.noModels": "No models chosen. Pick some under Edit.", "providers.removeConfirm": "Remove provider {name}? Model mappings that use it are removed too.", "providers.choose": "Add provider", "providers.chooseHelp": "Pick the service to connect.", "providers.chatgpt": "ChatGPT subscription", "providers.chatgptHelp": "Use GPT models through any ChatGPT plan that includes Codex (Plus, Pro, Business…). Sign-in only, no API key.", "providers.presetHelp": "Paste an API key and you are done.", "providers.openaiGroup": "OpenAI-compatible", "providers.openaiGroupHelp": "ClaudeRipple translates requests into the OpenAI API format.","providers.custom": "Enter manually", "providers.customName": "New provider", "providers.customHelp": "Connect any Anthropic- or OpenAI-compatible API by URL and key.", "providers.formatHelp": "Pick the format the service docs name. A service whose endpoint ends in /chat/completions is OpenAI Chat Completions.", "providers.addTitle": "Add provider", "providers.edit": "Edit provider", "providers.name": "Name", "providers.nameHelp": "How this provider is called in lists and mappings.", "providers.nameRequired": "Enter a name.", "providers.apiKey": "API key", "providers.keyHelp": "The API key issued on the provider's site. Stored only in this computer's config file.", "providers.keyPlaceholder": "Paste your API key", "providers.keySaved": "The saved key stays in use. Paste a new key to replace it.", "providers.url": "API base URL", "providers.urlHelp": "Base URL of the Anthropic-compatible endpoint. Change only if the service docs differ.", "providers.openaiUrlHelp": "Base URL of the OpenAI-compatible API. Requests are translated to its Chat Completions or Responses endpoint.", "providers.wire": "API format", "providers.wireHelp": "Use Chat Completions for most providers. Select Responses only when the provider supports the stateless Responses API.", "providers.urlRequired": "Enter a valid URL.", "providers.keyType": "Auth header", "providers.keyTypeHelp": "Usually x-api-key. Pick Authorization: Bearer only if the service docs say so.", "providers.extraHeaders": "Extra HTTP headers", "providers.extraHeadersHelp": "Only headers the service requires, one 'name: value' per line.", "providers.models": "Models to use", "providers.modelsHelp": "Checked models appear in the Model mapping list.", "providers.modelsFound": "Model list reported by the provider.", "providers.modelsFallback": "Could not fetch the list; showing known default models.", "measure.running": "Measuring model capabilities… ({done}/{total})", "measure.help": "Checks which API format each model answers in and which reasoning efforts it takes — from the public model catalogue (models.dev) when it lists the model, otherwise by asking the model.", "measure.done": "Measured: {summary}", "measure.nothing": "Nothing was measured: no model answered.", "measure.notEntitled": "{models}: usable only from the provider\u2019s own app. Ticking it here will not make it work.", "measure.failed": "Could not measure model capabilities.", "measure.authFailed": "The API key was refused, so nothing could be measured.", "providers.probeNotEntitled": "The key was accepted; the plan refused.", "providerStatus.notEntitled": "Plan refused", "providers.probeOk": "Connected.", "providers.probeFailed": "Could not connect.", "providers.apiSoon": "Please try again shortly.", "providers.showInPicker": "Also show by real name in the Claude app picker", "providers.pickerOffHint": "Picker mode is off right now, so ticking this does not show them yet. You will be asked to turn it on when you save.", "providers.pickerOffPrompt": "Picker mode is off, so these models will not appear in the Claude Desktop picker yet. Turn it on now? Your operating system will ask you to confirm trusting the certificate.", "providers.credentials": "Sign-in source", "providers.credentialsHelp": "Where the ChatGPT account token comes from.", "providers.authAuto": "Auto (own sign-in if present, else Codex CLI's)", "providers.authOwn": "Sign in with ClaudeRipple", "providers.authBorrow": "Reuse Codex CLI sign-in (~/.codex/auth.json)", "providers.login": "How to sign in", "providers.loginHelp": "'Sign in to ChatGPT…' in the menu-bar app or clauderipple login in a terminal opens the browser sign-in. Tokens stay on this computer.","providers.chatgptLogin": "Sign in to ChatGPT", "providers.chatgptLoginWaiting": "Finish signing in in your browser. This will update when it is done.", "providers.chatgptLoginDone": "ChatGPT sign-in complete.", "providers.chatgptAccountsTitle": "ChatGPT accounts", "providers.chatgptAccountsSubtitle": "With several accounts, when one hits its limit the next one takes over the same request. A conversation stays on the account that answered, to keep its cache. Accounts are used in list order.", "providers.addChatgptAccount": "+ Add ChatGPT account", "providers.chatgptAddWaiting": "Sign in with the account to add in your browser. If it shows an account you already added, pick another.", "providers.chatgptAdded": "ChatGPT account added.", "providers.chatgptNoAccounts": "No ChatGPT account is signed in.", "providers.chatgptAccountCount": "{count} accounts", "providers.chatgptCodexHelp": "The Codex CLI's own login. ClaudeRipple only reads it, never refreshes it, and uses it last.", "providers.chatgptOwnHelp": "ClaudeRipple stores this login in a file only your user can read and refreshes it automatically.", "providers.chatgptInUse": "in use now", "providers.chatgptStandby": "standby", "providers.chatgptPause": "Pause", "providers.chatgptResume": "Resume", "providers.chatgptPaused": "paused", "providers.chatgptClearCooldown": "Use now", "providers.chatgptRemoveConfirm": "Remove ChatGPT account {name} from ClaudeRipple?", "providers.chatgptReauthHelp": "This login expired or was refused. Signing in again with the same account restores it in place.", "pool.coolingFor": "back in {duration}", "time.hoursMinutes": "{h}h {m}m", "time.minutes": "{m}m", "time.seconds": "{s}s", "quota.window5h": "5h", "quota.windowWeek": "weekly", "quota.windowHours": "{hours}h", "quota.line": "{window} {percent}%", "quota.resetAt": "resets {time}", "providers.effortLevels": "Reasoning effort: {levels}", "providers.effortNone": "Does not take reasoning effort", "providers.modelEffort": "effort", "providers.modelNoEffort": "no effort", "providers.defaultEffort": "Default reasoning effort", "providers.defaultEffortHelp": "Used when neither the mapping nor the app sets an effort.", "providers.identity": "Tell the model what it is (identity)", "providers.append": "System prompt addendum", "providers.appendHelp": "Fixed text appended to every request's system prompt. Changing it often breaks the prompt cache and raises cost.",
+    "providers.fastMain": "Fast for the main session",
+    "providers.fastSubagent": "Fast for subagents",
+    "providers.fastHelp": "When on, GPT requests go out on Codex's fast tier. Answers come back quicker, but your subscription's usage runs down faster.",
     "providerStatus.connected": "Connected", "providerStatus.keyNeeded": "Key needed", "providerStatus.loginNeeded": "Sign-in needed", "providerStatus.disconnected": "Not connected", "providerStatus.checking": "Checking",
     "clients.title": "Clients", "clients.subtitle": "Set up the apps that use ClaudeRipple.", "clients.desktop.title": "Claude Desktop", "clients.desktop.help": "Choose whether provider models appear by real name in the model picker.", "clients.codex.title": "Codex (app and CLI)", "clients.codex.help": "Adds ClaudeRipple as a provider to Codex's config (~/.codex/config.toml). Terminal: `codex --profile clauderipple -m <model>`; Codex app: make clauderipple the default provider in that config.", "clients.codex.note": "When on, Codex's GPT requests go through ClaudeRipple too. Codex keeps its own sign-in, and with several ChatGPT accounts added, the next one takes over when one hits its limit — no sign-out. The list below is the Claude and Anthropic-compatible models Codex gains.", "clients.codex.turnOn": "Use ClaudeRipple in Codex","clients.claudeCode.title": "Terminal Claude Code", "clients.claudeCode.help": "Terminal `claude` uses the same router. Choose with `/model <name>`.",
     "logs.title": "Logs", "logs.requests": "Requests", "logs.raw": "Raw logs", "logs.lastHour": "Last hour", "logs.autoscroll": "Auto-scroll", "logs.polling": "Updates every 3s", "logs.rawPolling": "Updates every 3s · last 200 lines", "logs.provider": "Provider", "logs.all": "All","logs.empty": "No requests yet.", "logs.summary.requests": "Requests", "logs.summary.success": "Succeeded / failed", "logs.summary.input": "Input tokens", "logs.summary.output": "Output tokens", "logs.summary.duration": "Average response", "logs.cacheHit": "Cache {percent}%", "logs.th.time": "Time", "logs.th.models": "Model", "logs.th.effort": "effort", "logs.th.input": "Input", "logs.th.output": "Output", "logs.th.duration": "Duration", "logs.th.status": "Status", "logs.status.ok": "ok", "logs.status.error": "error", "logs.status.resent": "resent", "logs.status.resentHelp": "Not a failure: the client sent this request again on its own.", "logs.detail.id": "Request ID", "logs.detail.kind": "Kind", "logs.detail.stop": "Stop reason", "logs.detail.uncached": "Uncached input", "logs.detail.cacheRead": "Cache read", "logs.detail.cacheWrite": "Cache write", "logs.detail.note": "Note", "logs.none": "None", "logs.seconds": "{value}s",
@@ -679,6 +685,9 @@ const I18N = {
     "providers.modelNoEffort": "不支持强度设置",
     "providers.defaultEffort": "默认推理强度",
     "providers.defaultEffortHelp": "映射和应用都未设置推理强度时使用。",
+    "providers.fastMain": "主会话 Fast",
+    "providers.fastSubagent": "子智能体 Fast",
+    "providers.fastHelp": "开启后，GPT 请求会以 Codex 的快速档位发送。回答更快，但订阅用量消耗得也更快。",
     "providers.identity": "告知模型身份",
     "providers.append": "系统提示词附加内容",
     "providers.appendHelp": "固定追加到每个请求系统提示词末尾的文本。修改此内容往往会破坏提示缓存，增加费用。",
@@ -1196,6 +1205,9 @@ const I18N = {
     "providers.modelNoEffort": "強度なし",
     "providers.defaultEffort": "デフォルトの推論強度",
     "providers.defaultEffortHelp": "マッピングでもアプリでも推論強度が指定されていないときに使います。",
+    "providers.fastMain": "メインセッション Fast",
+    "providers.fastSubagent": "サブエージェント Fast",
+    "providers.fastHelp": "オンにすると GPT リクエストを Codex の高速ティアで送ります。応答は速くなりますが、サブスクリプションの使用量も速く減ります。",
     "providers.identity": "モデルに自身の情報を伝える（アイデンティティ）",
     "providers.append": "システムプロンプトへの追記",
     "providers.appendHelp": "すべてのリクエストのシステムプロンプトに追加される固定テキストです。頻繁に変えるとプロンプトキャッシュが効かなくなり、コストが上がります。",
@@ -1713,6 +1725,9 @@ const I18N = {
     "providers.modelNoEffort": "sin esfuerzo",
     "providers.defaultEffort": "Esfuerzo de razonamiento predeterminado",
     "providers.defaultEffortHelp": "Se usa cuando ni la asignación ni la app indican un esfuerzo.",
+    "providers.fastMain": "Fast para la sesión principal",
+    "providers.fastSubagent": "Fast para subagentes",
+    "providers.fastHelp": "Al activarlo, las peticiones de GPT salen en el nivel rápido de Codex. Las respuestas llegan antes, pero el uso de la suscripción se consume más rápido.",
     "providers.identity": "Decirle al modelo quién es (identidad)",
     "providers.append": "Añadido al prompt del sistema",
     "providers.appendHelp": "Texto fijo que se añade al final del prompt del sistema en cada solicitud. Cambiarlo a menudo rompe la caché de prompts y encarece el uso.",
@@ -2230,6 +2245,9 @@ const I18N = {
     "providers.modelNoEffort": "sem esforço",
     "providers.defaultEffort": "Esforço de raciocínio padrão",
     "providers.defaultEffortHelp": "Usado quando nem o mapeamento nem o app definem um esforço.",
+    "providers.fastMain": "Fast para a sessão principal",
+    "providers.fastSubagent": "Fast para subagentes",
+    "providers.fastHelp": "Ao ativar, as requisições de GPT saem no nível rápido do Codex. As respostas chegam antes, mas o uso da assinatura acaba mais depressa.",
     "providers.identity": "Dizer ao modelo quem ele é (identidade)",
     "providers.append": "Adendo ao prompt de sistema",
     "providers.appendHelp": "Texto fixo acrescentado ao prompt de sistema de toda requisição. Alterá-lo com frequência quebra o cache de prompt e aumenta o custo.",

package/docs/ARCHITECTURE.md

@@ -856,7 +856,8 @@ text is added. Source: `requestlog.ts`, `proxy.ts`, provider adapter outcomes.
 - `upstreamCalled`: `false` only for a known pre-model-API exit; omitted when a search backend was attempted or the call state is unknown.
 - `refusal`: `thread-continue`, `drain`, `unroutable`, `no-account`, `unknown-provider`, `web-search-unsupported` or `prompt-incompatible`, from the actual exit branch. `prompt-incompatible` follows an upstream request; it does not set `upstreamCalled: false`.
 - `purpose`: `auto-mode-classifier` from the security-monitor request shape regardless of routing settings, or `web-search` for router-served searches.
-- `requestedTier`: the service tier actually sent upstream, including ChatGPT's `speed: "fast"` → `priority`; omitted when no tier was sent.
+- `requestedTier`: the service tier actually sent upstream, including ChatGPT's `speed: "fast"` → `priority`; omitted when no tier was sent. Claude Code never puts `speed` on a GPT request (its client gate allows fast only for model ids it knows, CLI 2.1.304), so a ChatGPT provider's `fast: {main, subagent}` switches (both off by default; issue #69, 2026-10-22) send `priority` themselves: `subagent` for requests carrying `x-claude-code-agent-id`, which the CLI adds only inside a subagent, `main` for the rest.
+- `subagent`: `true` when the request carried `x-claude-code-agent-id`, for every provider; omitted on a main session's own turns.
 - `servedTier`: the response-reported tier (Responses/Chat `service_tier` or Anthropic `usage.service_tier`); never inferred from the request.
 
 **Hourly usage history (`usage-hourly.jsonl`, 2026-10-20).** `requests.jsonl` is
@@ -1643,6 +1644,7 @@ plan unless marked otherwise.
 | ChatGPT accounts that had bought Codex credits were rested by the router the moment a window read 100%, though OpenAI serves them from credits past the window | `exhaustedForMs` ignores a full window while `credits.has_credits` or `unlimited` holds (and `overage_limit_reached` does not); an actual 429 still rests the account until the window resets. |
 | After ~120 host↔relay reconnects no phone could connect for minutes — web and native sat at "connecting" while the host's control socket was open and answering pings, and a host restart did not help (the simulator's own log: every attempt 19:10–19:17 timed out waiting for the relay's `open`, then the next one worked with no change on the phone; 2026-10-15). Measured on the deployed relay with throwaway server ids: a replaced host control socket whose other end never answers the close stays in `getWebSockets("host")`, in acceptance order, for 8+ minutes, and the room sent every phone's `connect` to `sockets("host")[0]` — that dead socket — through any number of reconnects and a restart | The room routes a phone only to the **newest** host socket (each is tagged `at:<accepted ms>`), and only while it pinged within `HOST_SILENT_MS` (the runtime's auto-response timestamp); a silent newest socket is closed `4408` and the phone hears `4404 host offline` at once. The host walks the phone's path itself after every hello and every 5 min (a client socket to its own room must come back `open` within 10 s) and reconnects when it does not; a ping timer that ran late (sleep, blocked event loop) is not taken for a dead socket. Close codes, reasons and ISO timestamps are in `host.log`. In-process tests reproduce the sequence over a network that keeps dead sockets listed (`relay-reconnect.test.ts`). |
 | Return to Wi-Fi postponed forever while subagents keep working (2026-10-20): on the iPhone hotspot, the way back ran only with no model call in flight and none started in the last 20s; with Claude and subagents working back-to-back it logged "Wi-Fi return postponed" at 19:22:54 and never went back to the home Wi-Fi | A return still postponed `RETURN_FORCE_AFTER_MS` (120s) past due makes the gap itself (§8 "Making the gap"): new model calls are **held** at a gate in the proxy and the OpenAI ingress (`hold.ts`) — they wait unread, nothing is written, nothing refused or 503'd, each at most 120s — the running ones get up to 60s to finish, then the usual leave → probe runs and the gate is released whatever the outcome; calls that do not finish in time → release, next scheduled point (the fixed 5/10/20/30/40/50/60-minute return schedule of §8, 2026-10-20). The release is in a `finally` (a thrown error releases it), `stop()` releases it, the gate has its own failsafe timer, and a draining router closes it so a held call meets the retryable 503 instead of being cut. Tests: `tether.test.ts`, `hold.test.ts`. |
+| Blind returns repeatedly cut the only connection while travelling with the lid closed (2026-10-21 18:40–19:08 KST, owner-reported router.log): at each point, "trying to go back to Wi-Fi: leaving the hotspot so macOS joins the best known network", then "no network was joined", "networksetup said: Failed to join network PBJ" → `join-failed`. No known Wi-Fi was in range, and an idle iPhone stops advertising; with the lid closed macOS did not reliably rejoin it. The owner pinned the network as a stopgap. | Never leave the hotspot speculatively. Before either quiet return or the hold gate, a read-only backend check must prove another saved Wi-Fi is visible (on Windows, also an automatic profile). No match → "staying on the hotspot: no known Wi-Fi in range", once per point, then the next point on the unchanged schedule. Scan/list failure, unsupported response or Location refusal → stay and log why; never hold calls or disconnect on unknown visibility. macOS: preferred SSIDs + directed CoreWLAN JXA scans, Windows: saved profile SSIDs intersected with `netsh wlan show networks` (§8, measurements 2026-10-21). |
 | Android hotspot never recognised (2026-10-20, found by reading the code for an owner with Windows laptops and Android phones in mind): "on the hotspot" was the iPhone range 172.20.10.0/28 alone, on macOS and Windows. An Android hotspot hands out 192.168.43.x (≤ Android 10) or a random /24 (Android 11+; 192.168/16, 172.16/12, 10/8 by Android 14), so after our own failover `join()` saw no hotspot address and reported `join-failed`/`hotspot-not-visible`, while on the phone the controller read Wi-Fi and never planned the way back, and a by-hand join was never recognised | The product does not assume an iPhone. After our own join of the configured SSID is accepted by the OS, a new, non-link-local address within the settle time is the join, and its subnet (address + netmask from `os.networkInterfaces()`: no Location, no elevation) is kept in `<home>/tether.json` for that hotspot name; "on the hotspot" = iPhone range OR that network (§8). Only our own join replaces it, and a subnet equal to the Wi-Fi watched before is not remembered (logged as ambiguous) so home Wi-Fi is never read as the hotspot. Hints name both phones where the step differs. Not yet run with a real Android phone. |
 | An expired Claude login on the Mac wrote `[desktop state] …로그인이 만료되었습니다…` every few seconds per Claude app session and read the keychain (a synchronous child process) for every request, while phones learned of it only by a failed send (2026-10-15) | A login problem is one host state: logged when it starts and ends, sent to phones as `HostInfo.desktopProblem` (a banner), and the keychain is reread at most every 30 s while expired or after a 401. Per-session Remote Control errors log once per change. The host never refreshes the login itself. |
 
@@ -1796,9 +1798,9 @@ join) is **not** remembered — the two could not be told apart — and is logge
 as Wi-Fi before; not remembering it"); that join reads as Wi-Fi and no way back is planned. The
 default gateway was not used: it needs a process per OS (`route -n get default`, `Get-NetRoute`) and
 says nothing the subnet does not. Limits: a by-hand join is recognised only on a network learned
-before; a Wi-Fi elsewhere that happens to use the learned /24 reads as the hotspot, so the way back
-drops it for a few seconds at each scheduled point and the OS rejoins it (no harm beyond those drops;
-`tether.pin` stops them). Failover (on Wi-Fi or no
+before; a Wi-Fi elsewhere that happens to use the learned /24 reads as the hotspot. The way back
+can drop it only when another saved SSID is visible (visibility guard, 2026-10-21, below);
+`tether.pin` stops switching entirely. Failover (on Wi-Fi or no
 address, outage): wait at most 30s for an in-flight call, then `sudo -n networksetup
 -setairportnetwork <dev> <NAME>` (macOS takes the password from the System keychain). The probe window
 lives in the process, so it only works if the router is not restarted every few seconds while the
@@ -1811,8 +1813,9 @@ to it for the timeout duration" unless auto shutdown is off — AOSP `SoftApConf
 android-11.0.0_r1, `isAutoShutdownEnabled`). Return (on the hotspot):
 on a fixed schedule counted from landing there — 5, 10, 20, 30, 40, 50 and 60 minutes, then every
 10 minutes for as long as it stays (owner's decision, 2026-10-20: at most ~10 minutes on the hotspot
-after reaching a known Wi-Fi, and only a brief drop every 10 minutes on the move — a doubling
-backoff held it for up to 15 minutes) — and only with no call in flight and none started in the
+after reaching a known Wi-Fi — a doubling backoff held it for up to 15 minutes). **Since
+2026-10-21 each point first checks whether another saved Wi-Fi is actually in range, without
+leaving the hotspot** (below). Only with a positive check, no call in flight and none started in the
 last 20s, disassociate via JXA as the console user (wifihop's exact call: `ObjC.import("CoreWLAN");
 $.CWWiFiClient.sharedWiFiClient.interface.disassociate`) so macOS auto-joins the best known network;
 two good probes within 20s keep it; otherwise stay on (or rejoin) the hotspot and move to the next
@@ -1823,11 +1826,57 @@ switching. Every decision is logged once, with its reason. "Ask to join hotspots
 (macOS 26+, Apple 109321) covers the no-Wi-Fi-at-all case by itself; its setting lives in a root-only
 file (`com.apple.airport.preferences.plist`: permission denied, measured), so it is only hinted at.
 
+**Visibility before return (2026-10-21).** The blind drop was not brief: while travelling with
+the lid closed and no known Wi-Fi, the owner reported this sequence in router.log, 18:40–19:08 KST:
+"trying to go back to Wi-Fi: leaving the hotspot so macOS joins the best known network" → "no
+network was joined" → "networksetup said: Failed to join network PBJ" → `join-failed`. An idle iPhone
+stops advertising (above), and closed-lid macOS did not reliably rejoin; the owner pinned the
+network via the API as a stopgap. Both return paths now share a read-only check **before any hold
+is engaged or network is left** (`TetherBackend.returnBlocked`). No other known SSID visible →
+"staying on the hotspot: no known Wi-Fi in range", once per scheduled point, then the next fixed
+point; no disconnect, join or hold. Failed/unsupported scans (including Location refusal) are
+unknown visibility, never permission to disconnect: the reason is logged and the point is skipped.
+The schedule and `MIN_SWITCH_INTERVAL_MS` are unchanged. Activity, pin, stop, current network and
+settings are checked after the asynchronous scan, so a new call or a cancellation is not overlooked.
+
+Read-only measurements on the owner's Mac (2026-10-21, `sw_vers`: macOS **27.0.1**, build **26A434**;
+`stat /dev/console` and `id`: console and executing user **pbj, uid 501**; Wi-Fi **en0**, IPv4
+**172.20.10.10** before/after scanning, no join/disassociate/permission change):
+- `networksetup -listpreferredwirelessnetworks en0` returned "Preferred networks on en0:" followed
+  by **48** tab-indented SSIDs, including the configured hotspot **PBJ**. **47** remain after excluding it.
+- CoreWLAN through `/usr/bin/osascript -l JavaScript`, the same user/session path as disassociate:
+  `scanForNetworksWithNameError($(), null)` returned **12** CWNetworks with **unredacted SSIDs**,
+  including PBJ; none of the other preferred SSIDs matched. JXA's ObjC nil is `$()`: passing plain
+  JavaScript `null` as the name gave no usable count (`undefined`), not an empty scan. An early
+  diagnostic attempting to serialize the ObjC error/result also exited **139**; nonzero exit or
+  missing/invalid output must therefore stay safe, not mean visibility.
+- Directed `scanForNetworksWithNameError(name, null)` for all **48** preferred names returned
+  **PBJ: count 1, SSIDs ["PBJ"]** and **each other name: count 0, SSIDs []**. The absent control
+  `__ClaudeRipple_absent_20261021__` also returned **0**. No SSID was redacted in these successful
+  scans; **redacted directed results have not been measured**. The implementation uses directed
+  set counts, not the returned SSID, so a non-empty set can prove the named SSID's visibility even
+  if a different OS/permission context redacts that field. The returned set's `count` bridges to a JXA string
+  here (`"1"`/`"0"`), so it is converted to Number; unavailable/non-finite results fail closed.
+- The actual `SCAN_KNOWN_JS` implementation was executed read-only with those lists: **47 preferred
+  SSIDs except PBJ → `none`; [PBJ] → `visible`; [absent control] → `none`**. It passes names as a JSON
+  argv value, never interpolated code, selects en0 explicitly, and has a 30s runner timeout.
+- `system_profiler SPAirPortDataType -json` returned **24** entries in
+  `spairport_airport_other_local_wireless_networks`; **every `_name` was `<redacted>`**, as was the
+  current network. These were successive snapshots while travelling, not simultaneous counts.
+  This path cannot identify a saved SSID here and is not used.
+
+Windows uses `netsh wlan show networks mode=ssid interface="<adapter>"` and saved profiles from
+`show profiles` plus exported XML (SSID and auto/manual mode), excluding the hotspot. Only a visible
+SSID with an automatic profile permits return; names of profiles alone are not SSID evidence.
+Location denial, command errors and an empty/redacted/unsupported listing all stay on the hotspot,
+with a reason. Unit tests use injected runners only. **Unverified:** Windows live behaviour and
+an actual return with another known Wi-Fi in range; no real switch was made for this change.
+
 **Making the gap (2026-10-20).** "No call in flight and none in the last 20s" never came while Claude
 and subagents worked back-to-back: the return was postponed from 19:22:54 on and the Mac stayed on
 the hotspot (§5). So a return still postponed `RETURN_FORCE_AFTER_MS` (120s) past due stops waiting
 for a quiet moment and makes one (`returnWithGap`, tether.ts), after the same `MIN_SWITCH_INTERVAL`
-and `returnBlocked` checks: (1) engage the hold gate (`hold.ts`), shared by the proxy (`/v1/messages*`)
+and positive visibility/`returnBlocked` checks (2026-10-21): (1) engage the hold gate (`hold.ts`), shared by the proxy (`/v1/messages*`)
 and the OpenAI ingress (Responses/Chat calls). A new model call that arrives while it is engaged
 waits before its body is read and before it is counted in `messagesInFlight` — no bytes written, not
 refused, not 503 — until the gate is released or `HOLD_MAX_MS` (120s) has passed for that call, then
@@ -1941,7 +1990,9 @@ anyway netsh says so ("…need location permission… ms-settings:privacy-locati
 interface="<adapter>"` (Windows keeps the password in the profile; no profile → `no-hotspot-profile`,
 "join it once from the Wi-Fi menu"). netsh returns once the request is queued, so the address decides:
 none within 15s → `hotspot-not-visible`. Return: only if some other profile has
-`connectionMode=auto` (else no attempt, a hint, the same return schedule); `netsh wlan disconnect` lets
+`connectionMode=auto` **and its SSID is visible in `netsh wlan show networks`** (2026-10-21, visibility
+check above; unknown visibility never disconnects or holds calls). Otherwise no attempt, a logged
+reason, the same return schedule; `netsh wlan disconnect` lets
 auto-config join the best automatic network; whether a netsh disconnect suppresses that on Vista+ is
 undocumented (WlanDisconnect's "on-demand profile" note is for XP), so with no address after 8s the
 first automatic profile is joined by name. Profile names come from `show profiles` (the text after

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "Use GPT (any ChatGPT plan with Codex), DeepSeek and 400+ other models in the Claude Desktop Code tab and Claude Code while staying signed in to your Claude subscription — no third-party gateway mode. Several ChatGPT accounts that take over when one runs out, in Codex too.",
   "license": "GPL-3.0-only",
   "workspaces": [