clauderipple 0.6.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## 0.8.0 — 2026-10-05
+
+### Added
+
+- **The route, where you type** (Claude Code mods; a switch on the Clients screen, or
+  `clauderipple mod on`). A line above the Claude Code prompt says where your last request
+  went: model, provider, effort, cache hit and time, colored by provider and result. `Log` or
+  `/ripple-log` opens the request log in a side pane, all sessions or just this one; `×` or
+  `/ripple-bar` puts the line away. The router now records which Claude Code session sent each
+  request (`X-Claude-Code-Session-Id`), and `/api/requests?session=` filters by it.
+- **Workers stay on their own model.** The same mod catches a `model` argument on an Agent call
+  that would have put a ClaudeRipple worker on a Claude alias (its output cut to 64 tokens) and
+  runs it on its own model, and reads a `[[ripple: name@level]]` marker wherever it sits in the
+  prompt, not only on the first line.
+- **Google Gemini**, on its own wire: an AI Studio key, or a Google account through the
+  Antigravity backend with several accounts in rotation. Google's terms name the account route
+  as a breach and accounts were suspended for it; the sign-in says so before it starts.
+- **Each routed model gets its own effort menu in the Claude app.** DeepSeek and GLM show
+  low/high/max instead of Claude's whole ladder; a model that takes no effort shows none.
+- **Fast mode on GPT.** `/fast` in Claude Code asks the ChatGPT backend for the Codex fast tier.
+- **Updates from the dashboard**: the version row checks and starts an update.
+- **A typed model ID** for a provider that lists no models (#42).
+- **An explicit Auto mode classifier target** (`autoModeClassifier`, JSON only; #43 by
+  @Sociopacific). The README says what pointing it at a weaker model gives up.
+
+### Changed
+
+- **Measuring an OpenCode provider takes one request per model**, its effort ladder read from
+  models.dev, four models at a time, instead of about ten sequential requests each (three
+  OpenCode Go models had taken 2m33s). The ladders are the catalogue's: glm-5.3-flash is
+  low/high/max, where requests had accepted seven levels.
+- **Generated workers run at `@high`** unless a marker says otherwise.
+- **A clamping tie goes up**: medium on a low/high/max model is high, not low.
+
+### Fixed
+
+- **A settings save no longer undoes what the router wrote.** The dashboard saved the whole
+  config from the copy it loaded when it opened, so measured ladders and hand edits came back
+  with the next unrelated save. Every save now starts from the router's current config.
+- **Routed workers are no longer told to call `advisor`** after the tool was dropped (#47, #48
+  by @115dkk).
+- **`claude-login` finds the Desktop-cached CLI** in its new `<version>/<hash>/` folder (#45,
+  #46 by @115dkk). macOS had the same layout.
+- **Codex context overflow** is answered as "prompt is too long", so Claude Code compacts
+  instead of retrying the same request (#44 by @Sociopacific); a stream held for that opens
+  after five seconds regardless.
+- The Codex app sees a GPT model released after the router started; subagent titles keep the
+  model and effort under Desktop's new task panel; a provider's connection test reads a
+  model-not-found 404 as an accepted key; a Gemini provider waiting on Google's verification
+  is not shown as connected, and the page to open is passed on.
+
+## 0.7.0 — 2026-09-29
+
+### Added
+
+- **Worker tools** (`cli.limitWorkerTools`, off by default; a toggle in the dashboard). Generated
+  workers get only the read, edit, run, search and skill tools instead of inheriting every MCP
+  server and plugin tool of the session. One worker's first request fell from 32,942 to 8,823
+  tokens. Such a worker cannot use a browser or the iOS Simulator; keep those in an agent file of
+  your own.
+- **Images from the ChatGPT subscription.** `clauderipple image "<prompt>" -o file.png`, with
+  `--aspect square|landscape|portrait`, `--transparent`, `--format` and `--ref FILE` for reference
+  images. Underneath is `POST /api/image` on the admin port, which answers with the image itself.
+  Generated workers are told the `curl` form, so a worker with only Bash can make one. The backend
+  chooses resolution and quality; about 30 seconds an image.
+
 ## 0.6.0 — 2026-09-28
 
 Both suggested in #8 by @artisthanbohee-del.

package/README.ko.md

@@ -132,6 +132,15 @@ ClaudeRipple이 Claude에 하는 일은 작고 확인할 수 있습니다. Claud
 돌려 쓰는 것도 같은 약관 아래 각자 판단할 일입니다. 계정을 어떻게 다룰지는 Anthropic만 정할 수 있으니, 여기 적은
 내용은 보장이 아닙니다.
 
+### Gemini를 Google 계정으로 쓰면요?
+
+AI Studio API 키는 Google이 공식 지원하는 방식이고 안전합니다. Google 계정 로그인(Antigravity)은 다릅니다.
+Google [Antigravity 약관](https://antigravity.google/terms) 6조와 [Gemini CLI FAQ](https://geminicli.com/docs/resources/faq/)는
+그 로그인 정보를 다른 프로그램에서 쓰는 것을 위반으로 명시합니다. Google은 2026년 2월 이렇게 쓰인 계정을 정지했고(정지되면
+Gemini CLI와 Code Assist도 막혔습니다), [2차 위반은 영구 정지](https://github.com/google-gemini/gemini-cli/discussions/20632)라고
+밝혔습니다. ClaudeRipple은 다른 도구들도 제공하고 요청이 있어 이 로그인을 넣었으며, 시작 전에 이 경고를 보여 주고 트래픽을
+숨기는 일은 하지 않습니다. 쓰신다면 주 계정이 아닌 계정을 쓰세요.
+
 ### ChatGPT 계정을 여러 개 쓸 수 있나요?
 
 됩니다. `clauderipple login`을 할 때마다(또는 대시보드의 **+ ChatGPT 계정 추가**) 계정이 하나씩 늘어납니다.
@@ -144,6 +153,13 @@ ClaudeRipple이 Claude에 하는 일은 작고 확인할 수 있습니다. Claud
 Claude 모델이 이름 그대로 뜹니다. Claude Code 로그인이나 Anthropic API 키로 답합니다.
 [Codex 앱과 Codex CLI](#codex-앱과-codex-cli) 절을 보세요.
 
+### 이미지도 만들 수 있나요?
+
+됩니다. API 키 없이 ChatGPT 구독으로 만듭니다: `clauderipple image "빨간 종이배" -o boat.png --aspect square`.
+`--ref 파일`로 참고 이미지를, `--transparent`로 투명 배경을 줄 수 있습니다. 한 장에 30초쯤 걸리고, 해상도와 품질은
+구독 쪽이 정합니다. ClaudeRipple이 만든 서브에이전트에도 같은 방법이 적혀 있어 워커도 이미지를 만듭니다.
+[Claude Code](#claude-code-터미널-remote-control-서브에이전트) 절을 보세요.
+
 ### Claude Code 안에서는 GPT 성능이 떨어지지 않나요?
 
 Claude Code의 시스템 프롬프트와 도구 설명은 Claude에 맞춰 쓰여 있어서, 다른 모델은 남에게 맞춘 지시를 읽는 셈이고
@@ -219,6 +235,14 @@ ClaudeRipple은 Claude Code 프로세스만 신뢰하는 작은 HTTPS 프록시
   서버 측 스레드 처리, 도구 호출과 이미지 왕복, 모델이 받는 범위로 추론 강도 클램프, 호환 벤더에는 Anthropic 전용 필드 제거.
 - **제대로 된 요청 로그.** 누가 물었고 어떤 모델이 답했는지, 입력·캐시·출력 토큰, 지연, 상태를 요청마다. 한 시간 요약 포함.
 - **서브에이전트 이름표.** 백그라운드 작업 패널에 "Agent" 대신 `Terra·high · Review`가 보입니다.
+- **입력창에서 보이는 경로.** Claude Code mod가 입력창 위에 한 줄을 띄웁니다. 마지막 요청이 어디로 갔는지, 추론 강도·캐시
+  적중률·시간까지. `Log`(또는 `/ripple-log`)로 요청 로그를 옆 패널에 프로바이더·결과별 색으로 띄우고, `×`(또는
+  `/ripple-bar`)로 줄을 숨깁니다. 같은 mod가 Agent 호출에 다른 모델이 붙어도 워커를 제 모델로 돌리고,
+  `[[ripple: 이름@강도]]` 표식을 프롬프트 어디에 두든 읽습니다. 클라이언트 화면의 스위치 하나, 또는 `clauderipple mod on`.
+- **ChatGPT 구독으로 이미지 생성.** `clauderipple image "<프롬프트>"`. 참고 이미지와 투명 배경도 됩니다. 서브에이전트에도
+  방법이 적혀 있어, GPT나 DeepSeek 워커가 이미지 도구 없이 이미지를 만들고 직접 확인합니다.
+- **원하면 가벼운 워커.** 스위치 하나로, 생성된 서브에이전트에 세션의 MCP·플러그인 도구 전부 대신 워커가 쓰는 도구만
+  줍니다. 워커 첫 요청이 3.3만에서 0.9만 토큰으로 줄었습니다.
 - **터미널이 싫은 사람을 위해.** 원클릭 연결 확인과 모델 자동 검색이 붙은 프로바이더 프리셋, 드롭다운 모델 매핑, 자동 저장,
   한국어·영어 UI. 런타임을 품고 첫 실행에 스스로 설치하는 메뉴 막대 앱. 서명·공증 완료.
 
@@ -309,8 +333,8 @@ node packages/cli/src/index.ts ui        # 브라우저에서 로컬 GUI 열기
 ```
 
 `uninstall`은 전부 되돌리고 `~/.claude/settings.json`을 백업에서 복원합니다. 그 밖의 명령: `status`, `start`, `stop`,
-`restart`, `logs -f`, `login`, `logout`, `claude-login`, `claude-logout`, `picker on|off`, `agent-title on|off`,
-`codex on|off`.
+`restart`, `logs -f`, `login`, `logout`, `claude-login`, `claude-logout`, `picker on|off`, `agent-title on|off`, `mod on|off`,
+`codex on|off`, `update`, `image "<프롬프트>"`.
 </details>
 
 ## 클라이언트
@@ -355,6 +379,22 @@ model: gpt-5.6-sol@medium
 알 수 없는 에러로 죽게 두지 않고 이름을 대고 거부합니다(`400 ClaudeRipple: no provider declares "…"`).
 Claude 모델은 언제나 그대로 통과합니다. 생성을 끄려면 `"cli": { "agentFiles": false }`.
 
+생성된 워커는 기본적으로 세션의 도구를 전부 물려받아, MCP 서버·플러그인 도구가 워커 요청마다 실립니다.
+`"cli": { "limitWorkerTools": true }`(대시보드의 **워커 도구 제한**)를 켜면 읽기·편집·실행·검색·스킬 도구만
+주어 워커 첫 요청이 약 3.3만에서 0.9만 토큰으로 줄었습니다. 대신 그 워커는 브라우저·시뮬레이터 도구를 못 씁니다.
+그런 도구가 필요한 워커는 직접 만든 에이전트 파일로 두면 되고, 그 파일은 건드리지 않습니다.
+
+ChatGPT 프로바이더가 있으면 같은 구독으로 이미지를 만들 수 있습니다.
+
+```bash
+clauderipple image "빨간 종이배, 플랫 일러스트" -o boat.png --aspect square
+```
+
+`--transparent`, `--format png|jpeg|webp`, `--ref 파일`(참고 이미지, 여러 번 가능)은 선택입니다. 한 장에 30초쯤 걸립니다.
+구독 백엔드가 해상도와 품질을 직접 정하므로, 모양은 `--aspect`로 말로 요청합니다. 이 명령은 관리 포트의
+`POST /api/image`(응답이 이미지 바이트)를 부르는 클라이언트입니다. 생성된 워커에는 그 `curl` 형태가 적혀 있어,
+Bash만 있는 워커도 이미지를 만들고 Read로 확인할 수 있습니다.
+
 Claude Code의 `WebSearch`는 작은 모델에 별도 요청을 보냅니다. ChatGPT로 라우팅한 구성에서 그 요청만
 Anthropic 한도를 쓰지 않게 하려면 `config.json`에서 같은 ChatGPT 프로바이더를 검색 백엔드로 지정합니다:
 
@@ -392,6 +432,7 @@ Anthropic API 키로 갑니다. 구독 로그인 재사용은 Anthropic 약관
 | 프로바이더 | 종류 | 인증 | 모델 목록 | 비고 |
 |---|---|---|---|---|
 | ChatGPT 구독 | Codex 백엔드 | 로그인 여러 개, 한도 차면 자동 전환(Codex 로그인도 재사용) | 구독에서 자동으로 읽음(GPT-6 Sol·Luna·Astra, GPT-5.6 …) | 추론 강도 low…max(Luna는 ultra), 프롬프트 캐시 94~99 % |
+| Google Gemini | Gemini API | AI Studio API 키, 또는 Google 계정 로그인(Antigravity, 위 FAQ 참고) | 자동 검색 | 번역(Messages ⇄ generateContent), 턴 사이 thought signature 유지 |
 | OpenRouter | Anthropic 호환 | API 키 | 400+, 자동 검색 | 모델별 추론 강도 지원을 API에서 읽음 |
 | DeepSeek, Kimi, Z.ai GLM, MiniMax, Qwen(국제/중국) | Anthropic 호환 | API 키 | 프리셋 | 벤더 공식 문서로 확인 |
 | xAI Grok, Mistral, Groq, Together, Fireworks | OpenAI 호환 | API 키 | 자동 검색 | 번역(Chat Completions / Responses) |

package/README.md

@@ -151,6 +151,18 @@ subscription login. That use is subject to Anthropic's terms; an Anthropic API k
 the question. Rotating several Claude subscriptions is likewise your call under those
 terms. Only Anthropic can say how an account is treated, so nothing here is a promise.
 
+### What about Gemini through a Google account?
+
+An AI Studio API key is the way Google supports, and the safe one. The Google account
+sign-in (Antigravity) is different: Google's [Antigravity terms](https://antigravity.google/terms)
+(section 6) and the [Gemini CLI FAQ](https://geminicli.com/docs/resources/faq/) name using
+those credentials from another program as a breach. In February 2026 Google suspended
+accounts used this way — the suspension also cut off Gemini CLI and Code Assist — and
+[said](https://github.com/google-gemini/gemini-cli/discussions/20632) a second violation
+is permanent. ClaudeRipple offers the sign-in because others do and people asked, shows
+this warning before it starts, and does nothing to hide the traffic. Use a secondary
+account if you use it at all.
+
 ### Can I use several ChatGPT accounts?
 
 Yes. Each `clauderipple login` (or **+ Add ChatGPT account** in the dashboard) adds one.
@@ -165,6 +177,15 @@ Yes. `clauderipple codex on` adds ClaudeRipple as a provider, and Claude models
 the Codex app's and CLI's model list under their own names. They answer through your
 Claude Code login or an Anthropic API key. See [Codex app and Codex CLI](#codex-app-and-codex-cli).
 
+### Can it generate images?
+
+Yes, with a ChatGPT subscription and no API key:
+`clauderipple image "a red paper boat" -o boat.png --aspect square`. `--ref FILE` adds
+a reference image and `--transparent` a transparent background. One image takes about
+30 seconds, and the subscription chooses the resolution and quality. Subagents
+ClaudeRipple generates are told the same call, so they can make images too. See
+[Claude Code](#claude-code-terminal-remote-control-subagents).
+
 ### Does GPT do worse inside Claude Code?
 
 Claude Code's system prompt and tool descriptions are written for Claude, so another model
@@ -234,7 +255,7 @@ you map go to your provider, everything else goes to Anthropic byte for byte.
 
 - **Any model in Claude Desktop and Claude Code.** GPT-6 Sol / Luna / Astra and
   GPT-5.6 Terra / Sol / Luna through your ChatGPT Plus/Pro subscription (new models
-  appear the day OpenAI serves them), or DeepSeek, Kimi, GLM,
+  appear the day OpenAI serves them), Google Gemini, or DeepSeek, Kimi, GLM,
   MiniMax, Qwen, Grok, Mistral, Groq, Together, Fireworks, OpenRouter (400+ models)
   and local Ollama / LM Studio. Under their real names in the picker, or mapped onto
   a Claude name.
@@ -263,6 +284,18 @@ you map go to your provider, everything else goes to Anthropic byte for byte.
   latency, status, per request, with a one-hour summary.
 - **Subagent name tags.** The background-task panel shows `Terra·high · Review`
   instead of a generic "Agent".
+- **The route, where you type.** A Claude Code mod puts one line above the prompt:
+  where your last request went, its effort, cache hit and time. `Log` (or `/ripple-log`)
+  opens the request log in a side pane, color-coded by provider and result; `×` (or
+  `/ripple-bar`) hides the line. The same mod keeps a worker on its own model when the
+  Agent call names another, and reads its `[[ripple: name@level]]` marker wherever it sits
+  in the prompt. One switch on the Clients screen, or `clauderipple mod on`.
+- **Images from your ChatGPT subscription.** `clauderipple image "<prompt>"`, with
+  reference images and transparent backgrounds. Subagents are told how, so a GPT or
+  DeepSeek worker can make an image and look at it without an image tool.
+- **Lean workers, if you want them.** One switch gives generated subagents only the
+  tools a worker uses instead of every MCP server and plugin of the session: one
+  worker's first request fell from 33k to 9k tokens.
 - **Made for people who don't want a terminal.** Provider presets with one-click
   connection tests and model discovery, drop-down model mapping, auto-save, Korean
   and English UI. A menu-bar app that carries its own runtime and sets itself up on
@@ -359,8 +392,8 @@ node packages/cli/src/index.ts ui        # open the local GUI in your browser
 
 `uninstall` reverses everything and restores `~/.claude/settings.json` from a backup.
 Other commands: `status`, `start`, `stop`, `restart`, `logs -f`, `login`, `logout`,
-`claude-login`, `claude-logout`, `picker on|off`, `agent-title on|off`,
-`codex on|off`.
+`claude-login`, `claude-logout`, `picker on|off`, `agent-title on|off`, `mod on|off`,
+`codex on|off`, `update`, `image "<prompt>"`.
 </details>
 
 ## Clients
@@ -413,6 +446,27 @@ by name (`400 ClaudeRipple: no provider declares "…"`) instead of being sent o
 to fail somewhere less legible; native Claude models always pass through.
 Set `"cli": { "agentFiles": false }` to turn generation off.
 
+By default a generated worker inherits every tool of the session, so each MCP
+server and plugin rides along on every worker request. `"cli": {
+"limitWorkerTools": true }` (or **Worker tools** in the dashboard) gives it only
+the read, edit, run, search and skill tools, which cut one worker's first
+request from about 33k to 9k tokens. Such a worker has no browser or simulator
+tools. A worker that needs them belongs in an agent file of your own, which is
+never touched.
+
+With a ChatGPT provider configured, images come from the same subscription:
+
+```bash
+clauderipple image "a red paper boat, flat illustration" -o boat.png --aspect square
+```
+
+`--transparent`, `--format png|jpeg|webp` and `--ref FILE` (a reference image,
+repeatable) are optional. One image takes about 30 seconds. The subscription
+backend picks the resolution and quality itself, so the shape is asked for in
+words (`--aspect`). The command is a client of `POST /api/image` on the admin
+port, which answers with the image bytes. Generated workers are told the `curl`
+form of it, so a worker with only Bash can make an image and read it back.
+
 Claude Code runs `WebSearch` as a separate small-model request. To keep a
 ChatGPT-routed setup from spending Anthropic quota for that request, select the
 same ChatGPT provider as the search backend in `config.json`:
@@ -455,6 +509,7 @@ provider you configured is available the same way.
 | Provider | Kind | Auth | Model list | Notes |
 |---|---|---|---|---|
 | ChatGPT subscription | Codex backend | several sign-ins, switching when one runs out (Codex login reused too) | read from your subscription (GPT-6 Sol, Luna, Astra, GPT-5.6 …) | effort low…max (Luna: ultra), prompt cache 94–99 % |
+| Google Gemini | Gemini API | AI Studio API key, or Google account sign-in (Antigravity, see below) | discovered | translated (Messages ⇄ generateContent), thought signatures kept across turns |
 | OpenRouter | Anthropic-compatible | API key | 400+, discovered | per-model effort support read from the API |
 | DeepSeek, Kimi, Z.ai GLM, MiniMax, Qwen (intl / cn) | Anthropic-compatible | API key | preset | verified against vendor docs |
 | xAI Grok, Mistral, Groq, Together, Fireworks | OpenAI-compatible | API key | discovered | translated (Chat Completions / Responses) |
@@ -473,7 +528,8 @@ Claude Desktop / claude CLI ──HTTPS_PROXY──▶ ClaudeRipple ──▶ ap
                                                │
                         mapped model ──────────┼──▶ chatgpt.com/backend-api (Responses ⇄ Messages)
                                                ├──▶ Anthropic-compatible vendors (+ compat layer)
-                                               └──▶ OpenAI-compatible vendors (Messages ⇄ Chat/Responses)
+                                               ├──▶ OpenAI-compatible vendors (Messages ⇄ Chat/Responses)
+                                               └──▶ Google Gemini (Messages ⇄ generateContent)
 Codex app / CLI ──/v1/responses──▶ ClaudeRipple ingress ──▶ Claude (your login or API key) / vendors
 ```
 

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.6.0",
+  "version": "0.8.0",
   "type": "commonjs"
 }

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

@@ -39,6 +39,40 @@ function versionBinaries(versionDir) {
         ? BINARY_NAMES.map((name) => path.join(versionDir, name))
         : [path.join(versionDir, "claude.app", "Contents", "MacOS", "claude")];
 }
+/**
+ * The launcher of one cached version: in the version directory itself, else one directory below it,
+ * newest first. Claude Desktop 2.19675 on Windows caches CLI 2.1.286 as <version>\<12 hex>\claude.exe
+ * beside .payload and .verified files, and moved the 2.1.284 it already had into the same shape, so
+ * no version directory held a launcher directly any more (2026-10-02).
+ */
+function cachedBinary(versionDir) {
+    const flat = versionBinaries(versionDir).find((candidate) => fs.existsSync(candidate));
+    if (flat)
+        return flat;
+    try {
+        const subdirectories = fs.readdirSync(versionDir)
+            .flatMap((entry) => {
+            const directory = path.join(versionDir, entry);
+            try {
+                const stat = fs.statSync(directory);
+                return stat.isDirectory() ? [{ directory, mtimeMs: stat.mtimeMs }] : [];
+            }
+            catch {
+                return [];
+            }
+        })
+            .sort((left, right) => right.mtimeMs - left.mtimeMs);
+        for (const { directory } of subdirectories) {
+            const binary = versionBinaries(directory).find((candidate) => fs.existsSync(candidate));
+            if (binary)
+                return binary;
+        }
+    }
+    catch {
+        // A missing or unreadable version directory has no usable binary.
+    }
+    return null;
+}
 export function latestDesktopClaude() {
     for (const directory of desktopClaudeCodeDirs()) {
         try {
@@ -46,7 +80,7 @@ export function latestDesktopClaude() {
                 .filter((entry) => /^\d+\.\d+\.\d+$/.test(entry))
                 .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }));
             for (const version of versions.reverse()) {
-                const binary = versionBinaries(path.join(directory, version)).find((candidate) => fs.existsSync(candidate));
+                const binary = cachedBinary(path.join(directory, version));
                 if (binary)
                     return binary;
             }

package/dist/cli/src/codex.js

@@ -104,6 +104,29 @@ export function writeCodexCatalog(models, home = codexHome()) {
     fs.writeFileSync(file, JSON.stringify({ models: [...theirs, ...ours] }, null, 1), { mode: 0o600 });
     return file;
 }
+/**
+ * Our catalog is a copy of Codex's cache, so it goes stale when Codex refreshes that cache: a model
+ * OpenAI released after the router started stayed missing from the app (gpt-6.1-sol, 2026-09-30 —
+ * the copy was written at router start, Codex's cache gained the model half an hour later). Rewrite
+ * the copy whenever the cache changes, while `codex on` is in effect. Polls, as Codex replaces the
+ * file rather than editing it; once a minute is plenty, since the app reads the catalog only when it
+ * starts. Returns a stop function.
+ */
+export function followCodexCache(models, home = codexHome(), intervalMs = 60_000, onError = () => { }) {
+    const cache = path.join(home, "models_cache.json");
+    const listener = (now, before) => {
+        if (now.mtimeMs === before.mtimeMs || !codexEnabled(home))
+            return;
+        try {
+            writeCodexCatalog(models(), home);
+        }
+        catch (e) {
+            onError(e);
+        }
+    };
+    fs.watchFile(cache, { interval: intervalMs, persistent: false }, listener);
+    return () => fs.unwatchFile(cache, listener);
+}
 function catalogBlock(file) {
     return `${CATALOG_START}
 model_catalog_json = ${JSON.stringify(file)}

package/dist/cli/src/hooks/agent-title.js

@@ -1,12 +1,19 @@
 // Claude Code PreToolUse hook (matcher: Agent|Task): put the real model and thinking depth into the
 // subagent's title, e.g. "Terra·high · Provider presets", so the Claude Desktop background-task
-// panel shows which model a subagent runs on. The app's own second line is a fixed "Agent" label
-// (verified in the app renderer), so the description is the only text we can influence.
+// panel shows which model a subagent runs on. The app's model line names Claude models only (its
+// display table is a fixed list of Claude families, app web bundle 2026-09-30), so for a routed
+// model the title is the only text we can influence.
 //
-// Model resolution mirrors the router (packages/router/src/routing.ts): a `[[gpt: sol@xhigh]]`
-// marker in the prompt's first 5 lines, else the agent definition's frontmatter `model:`, else the
-// explicit `model` argument, else the parent session's model from the transcript tail.
-// Depth = the hook input's effort.level. Runs in <50ms, never fails the tool call (empty output = no-op).
+// The panel shows this title only while it follows the session live: rebuilt from the transcript
+// (another session opened and back, app restart) it takes the description the parent model wrote,
+// which a hook cannot change. So the generated agent files also ask the parent to write the same
+// prefix itself (packages/router/src/agents.ts); here it is corrected to what the router will do.
+//
+// Model resolution mirrors the router (packages/router/src/routing.ts): a `[[ripple: sol@xhigh]]`
+// marker at the very top of the prompt, else the agent definition's frontmatter `model:`, else the
+// explicit `model` argument, else the parent session's model from the transcript tail. Depth = the
+// marker's level, else the agent file's `@level`, else the hook input's effort.level, after the
+// router's `effortClamp`. Runs in <50ms, never fails the tool call (empty output = no-op).
 //
 // Installed by `clauderipple agent-title on` into ~/.claude/settings.json; the router ships no
 // Python, so this is TypeScript run by the Node recorded in <home>/paths.json.
@@ -14,36 +21,42 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-const MARKER = /\[\[\s*gpt\s*:\s*([a-z0-9.\-]+)\s*(?:@\s*([a-z]+))?\s*\]\]/i;
+// The router's marker (routing.ts MARKER): honoured only at the very top of the prompt.
+const MARKER = /^\s*\[\[\s*(?:ripple|gpt)\s*:\s*([A-Za-z0-9.\-]+)\s*(?:@\s*([A-Za-z]+))?\s*\]\]/;
+const REMINDER = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
 const OUR_PREFIX = /^[^\s·]+(?:·[a-z]+)? · /;
 const CLAUDE_ID = /^claude-(opus|sonnet|haiku|fable)-(\d+(?:-\d+)*?)(?:-\d{8})?$/;
-/** Display names: config's picker names (e.g. "GPT-5.6 Terra" → "Terra"), then a built-in table. */
-function prettyNames() {
-    const out = { "gpt-5.6-terra": "Terra", "gpt-5.6-sol": "Sol", "gpt-5.6-luna": "Luna", "gpt-6-astra": "Astra", "gpt-6-sol": "Sol", "gpt-6-luna": "Luna" };
+/** The router's default `effortClamp` (config.ts), for when config.json cannot be read. */
+const DEFAULT_CLAMP = { ultra: "max" };
+/** A model's name in a title: the last word of its display name ("GPT-6.1 Sol" → "Sol"). */
+export function shortName(name) {
+    const words = name.trim().split(/\s+/);
+    return words[words.length - 1];
+}
+function titleConfig() {
+    const names = { "gpt-5.6-terra": "Terra", "gpt-5.6-sol": "Sol", "gpt-5.6-luna": "Luna", "gpt-6-astra": "Astra", "gpt-6-sol": "Sol", "gpt-6-luna": "Luna" };
     const home = process.env.CLAUDERIPPLE_HOME ?? path.join(os.homedir(), ".clauderipple");
     try {
         const cfg = JSON.parse(fs.readFileSync(path.join(home, "config.json"), "utf8"));
         const add = (id, name) => {
-            if (!id || !name)
-                return;
-            const words = name.trim().split(/\s+/);
-            out[id.toLowerCase()] = words.length > 1 ? words[words.length - 1] : name.trim();
+            if (id && name)
+                names[id.toLowerCase()] = shortName(name);
         };
         for (const m of cfg.cli?.extraModels ?? [])
             add(m.model, m.name);
         for (const p of Object.values(cfg.providers ?? {}))
             for (const m of p.models ?? [])
                 add(m.id, m.name);
+        return { names, aliases: cfg.aliases ?? {}, effortClamp: { ...DEFAULT_CLAMP, ...(cfg.effortClamp ?? {}) } };
     }
     catch {
-        /* no config: built-ins only */
+        return { names, aliases: {}, effortClamp: DEFAULT_CLAMP };
     }
-    return out;
 }
+/** The `[[ripple: <name>@<effort>]]` a prompt starts with, name lowercased. Not resolved. */
 export function fromMarker(prompt) {
-    const head = prompt.split("\n").slice(0, 5).join("\n");
-    const m = MARKER.exec(head);
-    return m ? { model: m[1].toLowerCase(), effort: (m[2] ?? "").toLowerCase() } : null;
+    const m = MARKER.exec(prompt.replace(REMINDER, ""));
+    return m ? { name: m[1].toLowerCase(), effort: (m[2] ?? "").toLowerCase() } : null;
 }
 export function fromAgentFile(subagentType, dirs) {
     if (!subagentType || subagentType.includes("/") || subagentType.startsWith("."))
@@ -106,28 +119,44 @@ function parentModel(transcriptPath) {
     }
     return null;
 }
-export function retitle(input, agentDirs, names) {
+/**
+ * The model and effort the router will use for this call. The marker's name resolves as the router's
+ * aliases do (agents.ts withAgentAliases): an explicit alias, else an agent file's model, else the
+ * name itself; its effort, when absent, is the one the subagent's own `model:` asks for.
+ */
+function routed(inp, agentDirs, aliases) {
+    const own = fromAgentFile(typeof inp.subagent_type === "string" ? inp.subagent_type : "", agentDirs);
+    const marker = fromMarker(typeof inp.prompt === "string" ? inp.prompt : "");
+    if (!marker)
+        return own;
+    const model = aliases[marker.name]?.toLowerCase() ?? fromAgentFile(marker.name, agentDirs)?.model ?? marker.name;
+    return { model, effort: marker.effort || (own?.effort ?? "") };
+}
+export function retitle(input, agentDirs, cfg) {
     if (input.tool_name !== "Agent" && input.tool_name !== "Task")
         return null;
     const inp = input.tool_input ?? {};
     const desc = inp.description;
     if (typeof desc !== "string" || desc.trim() === "")
         return null;
-    const effort = (typeof input.effort === "object" && input.effort ? input.effort.level : typeof input.effort === "string" ? input.effort : "") ?? "";
-    const got = fromMarker(typeof inp.prompt === "string" ? inp.prompt : "") ?? fromAgentFile(typeof inp.subagent_type === "string" ? inp.subagent_type : "", agentDirs);
+    const clamp = cfg.effortClamp ?? DEFAULT_CLAMP;
+    const level = (e) => clamp[e] ?? e;
+    const effort = level((typeof input.effort === "object" && input.effort ? input.effort.level : typeof input.effort === "string" ? input.effort : "") ?? "");
+    const got = routed(inp, agentDirs, cfg.aliases ?? {});
+    const names = cfg.names;
     let tag = null;
-    if (got) {
-        // Marker short forms ("sol") resolve against full ids ("gpt-5.6-sol"), as the router's aliases do.
+    if (got && !claudePretty(got.model)) {
+        // Legacy short forms ("sol") resolve against full ids ("gpt-5.6-sol").
         const key = names[got.model] !== undefined ? got.model : Object.keys(names).find((k) => k.endsWith(`-${got.model}`));
-        const name = (key ? names[key] : undefined) ?? (got.model.startsWith("gpt") || got.model.includes("/") ? got.model : null);
-        if (name)
-            tag = got.effort ? `${name}·${got.effort}` : name;
+        const name = (key ? names[key] : undefined) ?? got.model;
+        tag = got.effort ? `${name}·${level(got.effort)}` : name;
     }
     if (tag === null) {
         const name = claudePretty(typeof inp.model === "string" ? inp.model : undefined) ?? (got ? claudePretty(got.model) : null) ?? claudePretty(parentModel(input.transcript_path) ?? undefined);
         if (!name)
             return null;
-        tag = effort ? `${name}·${effort}` : name;
+        const e = got?.effort ? level(got.effort) : effort;
+        tag = e ? `${name}·${e}` : name;
     }
     const prefix = `${tag} · `;
     if (desc.startsWith(prefix))
@@ -150,7 +179,7 @@ if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToP
     try {
         const raw = fs.readFileSync(0, "utf8");
         const data = JSON.parse(raw || "{}");
-        const updated = retitle(data, defaultAgentDirs(), prettyNames());
+        const updated = retitle(data, defaultAgentDirs(), titleConfig());
         if (updated)
             process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", updatedInput: updated } }) + "\n");
     }