clauderipple 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 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

@@ -144,6 +144,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 +226,10 @@ ClaudeRipple은 Claude Code 프로세스만 신뢰하는 작은 HTTPS 프록시
   서버 측 스레드 처리, 도구 호출과 이미지 왕복, 모델이 받는 범위로 추론 강도 클램프, 호환 벤더에는 Anthropic 전용 필드 제거.
 - **제대로 된 요청 로그.** 누가 물었고 어떤 모델이 답했는지, 입력·캐시·출력 토큰, 지연, 상태를 요청마다. 한 시간 요약 포함.
 - **서브에이전트 이름표.** 백그라운드 작업 패널에 "Agent" 대신 `Terra·high · Review`가 보입니다.
+- **ChatGPT 구독으로 이미지 생성.** `clauderipple image "<프롬프트>"`. 참고 이미지와 투명 배경도 됩니다. 서브에이전트에도
+  방법이 적혀 있어, GPT나 DeepSeek 워커가 이미지 도구 없이 이미지를 만들고 직접 확인합니다.
+- **원하면 가벼운 워커.** 스위치 하나로, 생성된 서브에이전트에 세션의 MCP·플러그인 도구 전부 대신 워커가 쓰는 도구만
+  줍니다. 워커 첫 요청이 3.3만에서 0.9만 토큰으로 줄었습니다.
 - **터미널이 싫은 사람을 위해.** 원클릭 연결 확인과 모델 자동 검색이 붙은 프로바이더 프리셋, 드롭다운 모델 매핑, 자동 저장,
   한국어·영어 UI. 런타임을 품고 첫 실행에 스스로 설치하는 메뉴 막대 앱. 서명·공증 완료.
 
@@ -310,7 +321,7 @@ 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`.
+`codex on|off`, `update`, `image "<프롬프트>"`.
 </details>
 
 ## 클라이언트
@@ -355,6 +366,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 프로바이더를 검색 백엔드로 지정합니다:
 

package/README.md

@@ -165,6 +165,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
@@ -263,6 +272,12 @@ 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".
+- **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
@@ -360,7 +375,7 @@ 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`.
+`codex on|off`, `update`, `image "<prompt>"`.
 </details>
 
 ## Clients
@@ -413,6 +428,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`:

package/dist/app/package.json

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

package/dist/cli/src/index.js

@@ -120,6 +120,44 @@ function starterConfig(port) {
         log: DEFAULTS.log,
     }, null, 2) + "\n";
 }
+const IMAGE_USAGE = 'usage: clauderipple image "<prompt>" [-o FILE] [--aspect square|landscape|portrait] [--format png|jpeg|webp] [--transparent] [--ref FILE ...]';
+/**
+ * One image through the running router's ChatGPT subscription (`POST /api/image`), written to a
+ * file whose path is printed — so a worker with nothing but Bash can make and then look at one.
+ */
+async function image() {
+    const prompt = args[1];
+    if (!prompt || prompt.startsWith("-"))
+        throw new Error(IMAGE_USAGE);
+    const images = args.flatMap((a, i) => (a === "--ref" && args[i + 1] ? [args[i + 1]] : [])).map((file) => {
+        const ext = path.extname(file).slice(1).toLowerCase();
+        return `data:image/${ext === "jpg" ? "jpeg" : ext};base64,${fs.readFileSync(file).toString("base64")}`;
+    });
+    const format = opt("format") ?? "png";
+    const out = path.resolve(opt("o") ?? `image-${new Date().toISOString().replace(/[:.]/g, "-")}.${format === "jpeg" ? "jpg" : format}`);
+    const body = {
+        prompt,
+        format,
+        ...(opt("aspect") ? { aspect: opt("aspect") } : {}),
+        ...(flag("transparent") ? { background: "transparent" } : {}),
+        ...(images.length ? { images } : {}),
+    };
+    const port = adminPort(new ConfigStore(configPath()).get());
+    let res;
+    try {
+        res = await fetch(`http://127.0.0.1:${port}/api/image`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+    }
+    catch {
+        throw new Error(`the router is not answering on 127.0.0.1:${port}; start it with: clauderipple start`);
+    }
+    if (!res.ok) {
+        const answer = (await res.json().catch(() => ({})));
+        throw new Error(answer.error ?? `HTTP ${res.status}`);
+    }
+    fs.mkdirSync(path.dirname(out), { recursive: true });
+    fs.writeFileSync(out, Buffer.from(await res.arrayBuffer()));
+    console.log(out);
+}
 /** The version the router on this admin port reports, or null when it does not answer. */
 async function runningVersion(port) {
     try {
@@ -420,6 +458,8 @@ function help() {
   logout            forget every ChatGPT account added with "login" (the Codex CLI's own login is left alone)
   claude-login      connect a Claude subscription in the browser (--setup-token: via \`claude setup-token\`; --manual: paste the code)
   claude-logout     remove every Claude subscription added to ClaudeRipple
+  image "<prompt>" [-o FILE] [--aspect square|landscape|portrait] [--transparent] [--ref FILE ...]
+                    generate an image with your ChatGPT subscription and print the file's path
   picker on|off     show your mapped models by name in the Claude Desktop picker (trusts the CA in your login keychain, routes the app through ClaudeRipple)
   codex on|off      add/remove ClaudeRipple's local OpenAI provider and selection profile for Codex CLI
   agent-title on|off|status
@@ -552,6 +592,9 @@ try {
         case "claude-logout":
             console.log(claudeLogout(homeDir()) ? "✓ ClaudeRipple Claude accounts removed" : "no ClaudeRipple Claude accounts stored");
             break;
+        case "image":
+            await image();
+            break;
         case "ui":
             ui();
             break;

package/dist/router/src/admin.js

@@ -33,7 +33,10 @@ import { ClaudeOAuthSession } from "./providers/claude-oauth.js";
 import { readClaudeAuthFile } from "./providers/anthropic-token-file.js";
 import { listClaudeAccounts, removeClaudeAccount, renameClaudeAccount } from "./providers/anthropic-accounts.js";
 import { readChatGptAccounts, removeChatGptAccount, summarize as summarizeChatGptAccount, updateChatGptAccount } from "./providers/chatgpt/accounts.js";
+import { IMAGE_ASPECTS, IMAGE_BACKGROUNDS, IMAGE_FORMATS } from "./providers/chatgpt/index.js";
 const MAX_BODY = 1024 * 1024;
+/** `/api/image` carries reference images inline, so it gets more room than a config save. */
+const MAX_IMAGE_BODY = 32 * 1024 * 1024;
 const here = path.dirname(fileURLToPath(import.meta.url));
 const STARTED_AT = new Date().toISOString();
 // packages/router/src → packages/ui in a checkout; dist/router/src → dist/ui in an npm install,
@@ -444,13 +447,51 @@ function syncModelSlotsForGui(cfg) {
         return `model slots were not written to settings.json: ${message}`;
     }
 }
-function readBody(req) {
+/**
+ * The body of `POST /api/image`, checked: `{prompt, aspect?, format?, background?, images?}`,
+ * `images` being `data:image/...;base64,` URLs. A string is the reason it was refused.
+ */
+export function parseImageRequest(raw) {
+    if (!raw || typeof raw !== "object")
+        return "expected a JSON object";
+    const body = raw;
+    if (typeof body.prompt !== "string" || !body.prompt.trim())
+        return "prompt is required";
+    const out = { prompt: body.prompt };
+    const pick = (key, allowed) => {
+        const value = body[key];
+        if (value === undefined)
+            return null;
+        if (typeof value !== "string" || !allowed.includes(value))
+            return `${key} must be one of ${allowed.join(", ")}`;
+        out[key] = value;
+        return null;
+    };
+    const refused = pick("aspect", IMAGE_ASPECTS) ?? pick("format", IMAGE_FORMATS) ?? pick("background", IMAGE_BACKGROUNDS);
+    if (refused)
+        return refused;
+    if (body.images !== undefined) {
+        if (!Array.isArray(body.images))
+            return "images must be a list of data: URLs";
+        const images = [];
+        for (const url of body.images) {
+            const m = typeof url === "string" ? /^data:(image\/[a-z0-9.+-]+);base64,([A-Za-z0-9+/=\s]+)$/i.exec(url) : null;
+            if (!m)
+                return "each image must be a data:image/...;base64, URL";
+            images.push({ mediaType: m[1].toLowerCase(), data: m[2].replace(/\s/g, "") });
+        }
+        if (images.length)
+            out.images = images;
+    }
+    return out;
+}
+function readBody(req, limit = MAX_BODY) {
     return new Promise((resolveP, reject) => {
         const chunks = [];
         let n = 0;
         req.on("data", (c) => {
             n += c.length;
-            if (n > MAX_BODY) {
+            if (n > limit) {
                 reject(new Error("body too large"));
                 req.destroy();
                 return;
@@ -1409,6 +1450,49 @@ export function startAdmin(deps) {
                 sendJson(res, r.ok ? 200 : 500, { ok: r.ok, output: r.output });
                 return;
             }
+            if (pathname === "/api/image" && method === "POST") {
+                // The image itself is the response body, so `curl -o out.png` is the whole client. An error
+                // is JSON with a non-2xx status (`curl --fail-with-body` writes it to the same file).
+                if (!deps.image) {
+                    sendJson(res, 501, { error: "image generation not available" });
+                    return;
+                }
+                let parsed;
+                try {
+                    parsed = parseImageRequest(JSON.parse((await readBody(req, MAX_IMAGE_BODY)).toString("utf8")));
+                }
+                catch (e) {
+                    sendJson(res, 400, { error: /too large/.test(e.message) ? "body too large (reference images over 32 MB)" : "invalid JSON" });
+                    return;
+                }
+                if (typeof parsed === "string") {
+                    sendJson(res, 400, { error: parsed });
+                    return;
+                }
+                // A caller that gives up should not leave the generation running on the subscription.
+                const abort = new AbortController();
+                res.on("close", () => { if (!res.writableFinished)
+                    abort.abort(); });
+                const started = Date.now();
+                try {
+                    const image = await deps.image(parsed, abort.signal);
+                    deps.log.info(`admin: image ${image.size ?? "?"} ${image.quality ?? "?"} ${image.format}, ${parsed.images?.length ?? 0} reference(s), ${image.data.length} bytes in ${Date.now() - started} ms`);
+                    res.writeHead(200, {
+                        "content-type": `image/${image.format}`,
+                        "content-length": String(image.data.length),
+                        ...(image.size ? { "x-image-size": image.size } : {}),
+                        ...(image.quality ? { "x-image-quality": image.quality } : {}),
+                        ...(image.revisedPrompt ? { "x-revised-prompt": encodeURIComponent(image.revisedPrompt) } : {}),
+                    });
+                    res.end(image.data);
+                }
+                catch (e) {
+                    deps.log.warn(`admin: image failed after ${Date.now() - started} ms: ${e.message}`);
+                    if (!res.headersSent)
+                        sendJson(res, 502, { error: e.message });
+                }
+                return;
+            }
             if (pathname === "/api/agent-title" && method === "POST") {
                 // Registers/removes the PreToolUse hook that prefixes subagent titles with the real model.
                 let enabled;

package/dist/router/src/agents.js

@@ -14,6 +14,7 @@ import os from "node:os";
 import path from "node:path";
 import { homeDir } from "./config.js";
 import { declaredBy } from "./routing.js";
+import { adminPort } from "./admin.js";
 /** Where Claude Code's Agent tool reads its worker definitions. */
 export function defaultAgentDir() {
     return path.join(os.homedir(), ".claude", "agents");
@@ -34,6 +35,27 @@ const BODY = [
     "**작업 디렉터리(cwd)에 어떤 파일도 만들지 않는다.** 조사·감사처럼 \"읽기만\" 하는 일이어도 마찬가지다.",
     "임시 파일이 필요하면 `/tmp` 아래에만 만들고, 끝나면 지운다. 사본을 작업 폴더에 떨구지 마라.",
 ].join("\n");
+/**
+ * Added to the body when a ChatGPT provider is configured: how a worker makes an image. A worker has
+ * no image tool, and `clauderipple` is not on PATH for everyone (a checkout runs from source), so
+ * the instruction is the admin endpoint itself, which curl reaches on every platform.
+ */
+function imageLine(port) {
+    return [
+        "이미지가 필요하면 ChatGPT 구독으로 만든다(한 장 30초~수 분):",
+        `\`curl -sS --fail-with-body -o <절대경로>.png -H 'content-type: application/json' -d '{"prompt":"…"}' http://127.0.0.1:${port}/api/image\``,
+        "선택 키: aspect(square·landscape·portrait), background(transparent), format(png·jpeg·webp), images(참고 이미지 data: URL 목록). 해상도·품질은 지정할 수 없다. 실패하면 그 파일에 오류 JSON이 담긴다. 만든 뒤 Read로 확인한다.",
+    ].join("\n");
+}
+/**
+ * The tools a generated worker is given when `cli.limitWorkerTools` is on. Without a `tools:` line a
+ * subagent inherits every tool of the session — each MCP server, plugin agent and deferred-tool name —
+ * and a general worker's first request measured 43,598 tokens (2026-09-20), resent on every turn;
+ * limited, a deepseek worker's first request fell from 32,942 to 8,823 (2026-09-29). A worker reads,
+ * edits, searches, runs commands and uses skills; it does not drive browsers, simulators or mail.
+ * Off by default: a user whose workers do need those tools would otherwise lose them silently.
+ */
+const TOOLS = ["Read", "Write", "Edit", "Glob", "Grep", "Bash", "WebFetch", "WebSearch", "Skill"];
 /**
  * Parsed `*.md` frontmatter per directory, keyed by file mtime so a request never re-reads the whole
  * directory. Only the `---` block's own `key: value` lines are read: no YAML library, because the
@@ -134,10 +156,12 @@ function effortSuffix(provider, modelId) {
     const levels = modelLevels !== undefined ? modelLevels : capsEffortLevels(provider);
     return levels?.includes("medium") ? "@medium" : "";
 }
-function fileContent(name, modelId, provider, suffix) {
+function fileContent(name, modelId, provider, suffix, limitTools, imagePort) {
     const description = `${modelId} via ${provider}. Generated by ClaudeRipple from config.json — edits are overwritten; ` +
         `to customise, copy to another name. Set effort with [[ripple: ${name}@<level>]] on the first line.`;
-    return `---\nname: ${name}\ndescription: ${description}\nmodel: ${modelId}${suffix}\n---\n${BODY}\n`;
+    const tools = limitTools ? `tools: ${TOOLS.join(", ")}\n` : "";
+    const body = imagePort === null ? BODY : `${BODY}\n${imageLine(imagePort)}`;
+    return `---\nname: ${name}\ndescription: ${description}\nmodel: ${modelId}${suffix}\n${tools}---\n${body}\n`;
 }
 function readManifest(file) {
     try {
@@ -199,6 +223,7 @@ export function syncAgentFiles(cfg, dir, log, opts = {}) {
             targets.set(name, { modelId: model.id, provider: providerName, suffix: effortSuffix(provider, model.id) });
         }
     }
+    const imagePort = Object.values(cfg.providers).some((p) => p.type === "chatgpt") ? adminPort(cfg) : null;
     const nextOwned = [];
     for (const [name, t] of targets) {
         if (handNames.has(name)) {
@@ -206,7 +231,7 @@ export function syncAgentFiles(cfg, dir, log, opts = {}) {
             continue;
         }
         const file = path.join(dir, `${name}.md`);
-        const content = fileContent(name, t.modelId, t.provider, t.suffix);
+        const content = fileContent(name, t.modelId, t.provider, t.suffix, cfg.cli.limitWorkerTools === true, imagePort);
         const existing = scanned.get(`${name}.md`);
         if (existing) {
             let current = null;

package/dist/router/src/config.js

@@ -381,6 +381,8 @@ export function validate(c) {
         errors.push("listen.port out of range");
     if (c.cli.agentFiles !== undefined && typeof c.cli.agentFiles !== "boolean")
         errors.push("cli.agentFiles must be true or false");
+    if (c.cli.limitWorkerTools !== undefined && typeof c.cli.limitWorkerTools !== "boolean")
+        errors.push("cli.limitWorkerTools must be true or false");
     if (c.listen.openaiPort !== undefined && !(c.listen.openaiPort >= 0 && c.listen.openaiPort < 65536))
         errors.push("listen.openaiPort out of range");
     return errors;

package/dist/router/src/index.js

@@ -154,6 +154,7 @@ proxy
         picker: () => ({ enabled: !!store.get().picker?.enabled, hosts: terminateHosts(store.get()).slice(1), last: proxy.lastPickerInjection }),
         observedClaudeCodeAuth,
         claudeUsage: () => proxy.claudeUsage.snapshot(),
+        image: (req, signal) => proxy.generateImage(req, signal),
         shutdown: () => beginDrain("shutdown requested"),
     });
     log.info(`clauderipple admin GUI on http://127.0.0.1:${admin.port}/`);

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

@@ -24,6 +24,17 @@ const USAGE_TIMEOUT_MS = 10_000;
 const MODELS_PATH = "/codex/models";
 const MODELS_TIMEOUT_MS = 15_000;
 const MODELS_CACHE_MS = 60 * 60 * 1000;
+/** One image took about 30 s at low quality (2026-09-29); high quality and references take longer. */
+const IMAGE_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * The shape, asked for in words. The subscription backend accepts the tool's `size` and `quality`
+ * and ignores them — even "999x1" and "bogus" came back 200 as a 1536x1024 image (2026-09-29) —
+ * while the prompt steers it: "square composition" gave 1254x1254. So the shape is a prompt hint,
+ * and quality is the backend's to choose.
+ */
+export const IMAGE_ASPECTS = ["square", "landscape", "portrait"];
+export const IMAGE_FORMATS = ["png", "jpeg", "webp"];
+export const IMAGE_BACKGROUNDS = ["auto", "transparent", "opaque"];
 function anthropicError(status, type, message) {
     return { status, body: JSON.stringify({ type: "error", error: { type, message } }) };
 }
@@ -394,6 +405,107 @@ export class ChatGptAdapter {
         const prose = text.trim();
         return prose ? { hits: selected, text: prose } : { hits: selected };
     }
+    /**
+     * Hosted image generation, the same way `searchWeb` runs a hosted search: one Responses turn with
+     * the `image_generation` tool required. Wire measured 2026-09-29 against the live backend with a
+     * ChatGPT subscription: an `image_generation_call` output item whose `result` is the base64 image,
+     * beside the `size`, `quality` and `output_format` it chose and a `revised_prompt`; about 30 s.
+     */
+    async generateImage(model, req, signal) {
+        const tokens = await this.anyCredential();
+        if (tokens instanceof Error)
+            throw tokens;
+        const id = crypto.randomUUID();
+        const tool = {
+            type: "image_generation",
+            output_format: req.format ?? "png",
+            ...(req.background ? { background: req.background } : {}),
+        };
+        const prompt = req.aspect ? `${req.prompt}\n\nCompose it as a ${req.aspect} image.` : req.prompt;
+        const content = [{ type: "input_text", text: prompt }];
+        for (const image of req.images ?? [])
+            content.push({ type: "input_image", image_url: `data:${image.mediaType};base64,${image.data}` });
+        const body = {
+            model,
+            instructions: "Generate the requested image. Use any attached images as references.",
+            input: [{ type: "message", role: "user", content }],
+            tools: [tool],
+            tool_choice: "required",
+            reasoning: { effort: "low", summary: "auto" },
+            store: false,
+            stream: true,
+            prompt_cache_key: id,
+            client_metadata: { session_id: id, thread_id: id, turn_id: crypto.randomUUID(), "x-codex-window-id": `${id}:0` },
+        };
+        const timeout = AbortSignal.timeout(IMAGE_TIMEOUT_MS);
+        const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+        const res = await fetch(`${(this.cfg.url ?? DEFAULT_BASE).replace(/\/$/, "")}/codex/responses`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                accept: "text/event-stream",
+                authorization: `Bearer ${tokens.accessToken}`,
+                "chatgpt-account-id": tokens.accountId,
+                "OpenAI-Beta": "responses=experimental",
+                originator: "codex_cli_rs",
+                "session-id": id,
+                "thread-id": id,
+                "x-client-request-id": id,
+                "x-codex-window-id": `${id}:0`,
+            },
+            body: JSON.stringify(body),
+            signal: requestSignal,
+        });
+        this.noteRateLimits(tokens, rateLimitsFromHeaders(res.headers));
+        if (!res.ok || !res.body) {
+            const text = await res.text().catch(() => "");
+            if (res.status === 401)
+                void this.accounts.forceRefresh(tokens.ownerId);
+            throw new Error(`ChatGPT image generation: HTTP ${res.status}${text ? ` ${redactErrorText(text, [tokens.accessToken], 200)}` : ""}`);
+        }
+        const parser = new SseParser();
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let image;
+        let text = "";
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                for (const event of parser.feed(decoder.decode(value, { stream: true }))) {
+                    if (event.type === "response.output_text.delta")
+                        text += String(event.delta ?? "");
+                    if (event.type === "response.output_item.done") {
+                        const item = event.item;
+                        if (item?.type === "image_generation_call" && typeof item.result === "string" && item.result)
+                            image = item;
+                    }
+                    if (event.type === "error" || event.type === "response.failed") {
+                        const error = (event.error ?? event.response?.error);
+                        throw new Error(`ChatGPT image generation: ${String(error?.message ?? "backend error")}`);
+                    }
+                }
+            }
+        }
+        finally {
+            try {
+                await reader.cancel();
+            }
+            catch { /* already closed */ }
+        }
+        // A refusal comes back as prose and no image; that prose is the only explanation there is.
+        if (!image)
+            throw new Error(`ChatGPT image generation: no image returned${text.trim() ? `: ${text.trim().slice(0, 300)}` : ""}`);
+        const str = (v) => (typeof v === "string" && v ? v : undefined);
+        return {
+            data: Buffer.from(image.result, "base64"),
+            format: str(image.output_format) ?? req.format ?? "png",
+            ...(str(image.size) ? { size: str(image.size) } : {}),
+            ...(str(image.quality) ? { quality: str(image.quality) } : {}),
+            ...(str(image.revised_prompt) ? { revisedPrompt: str(image.revised_prompt) } : {}),
+        };
+    }
     /** One in-flight lookup shared by every caller (the status route and the startup refresh). */
     rateLimitsInFlight = null;
     /**

package/dist/router/src/proxy.js

@@ -253,6 +253,20 @@ export class Proxy {
             return this.chatgpt(first[0], first[1]);
         return this.chatgpt("codex-login", { type: "chatgpt", auth: "borrow-codex" });
     }
+    /**
+     * One image for `/api/image`, on the first chatgpt provider and the first model it declares. The
+     * model only runs the tool call — the image comes from the backend's own image model — so which
+     * one it is barely matters.
+     */
+    generateImage(req, signal) {
+        const first = Object.entries(this.deps.config().providers).find(([, p]) => p.type === "chatgpt");
+        if (!first || first[1].type !== "chatgpt")
+            return Promise.reject(new Error("image generation needs a ChatGPT provider; add one in the dashboard"));
+        const model = first[1].models?.[0]?.id;
+        if (!model)
+            return Promise.reject(new Error(`provider ${first[0]} declares no models`));
+        return this.chatgpt(first[0], first[1]).generateImage(model, req, signal);
+    }
     /** Dashboard action: put one resting ChatGPT account back into rotation now. */
     chatgptClearCooldown(ownerId) {
         for (const [name, p] of Object.entries(this.deps.config().providers)) {

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.6.0";
+export const VERSION = "0.7.0";

package/dist/ui/app.js

@@ -377,6 +377,12 @@ function renderClients() {
   agentButton.className = agentEnabled ? "btn secondary" : "btn";
   agentButton.disabled = agentTitleBusy;
   agentButton.onclick = () => toggleAgentTitle(!agentEnabled);
+  const toolsLimited = Boolean(currentConfig.cli && currentConfig.cli.limitWorkerTools);
+  $("#client-worker-tools-rows").replaceChildren(el("div", { class: "row" }, [el("span", { class: "k", text: t("picker.state") }), toolsLimited ? badge("ok", t("workerTools.on")) : el("span", { class: "small", text: t("workerTools.off") })]));
+  const toolsButton = $("#client-worker-tools-toggle");
+  toolsButton.textContent = toolsLimited ? t("workerTools.turnOff") : t("workerTools.turnOn");
+  toolsButton.className = toolsLimited ? "btn secondary" : "btn";
+  toolsButton.onclick = () => toggleWorkerTools(!toolsLimited);
   void renderCodexClient();
   const mapped = Object.entries(currentConfig.routes || {}).map(([source, route]) => `${labelOf(claudeModels.find((model) => model.id === source) || { id: source })} → ${labelOf((groupedModels(currentConfig).find((group) => group.name === route.provider) || { models: [] }).models.find((model) => model.id === route.model) || { id: route.model })}`);
   $("#client-claude-code-rows").replaceChildren(el("div", { class: "small", text: mapped.join(" · ") || t("slots.noChanges") }));
@@ -537,6 +543,17 @@ async function toggleAgentTitle(enabled) {
     void refreshHealth();
   }
 }
+async function toggleWorkerTools(enabled) {
+  if (!currentConfig) return;
+  const next = clone(currentConfig);
+  next.cli = { ...(next.cli || {}), limitWorkerTools: enabled };
+  try {
+    await configRequest(next);
+    currentConfig = next;
+    toast(t("common.saved"));
+  } catch (error) { toast(t("common.saveFailed"), true, error.message); }
+  renderClients();
+}
 async function renderCodexClient() {
   const rows = $("#client-codex-rows");
   const button = $("#client-codex-toggle");

package/dist/ui/i18n.js

@@ -24,6 +24,12 @@ const I18N = {
     "agentTitle.off": "꺼짐",
     "agentTitle.turnOn": "이름표 켜기",
     "agentTitle.turnOff": "이름표 끄기",
+    "workerTools.title": "워커 도구 제한",
+    "workerTools.help": "ClaudeRipple이 만든 워커에 읽기·편집·명령 실행·검색·스킬 도구만 줍니다. 세션의 MCP 서버·플러그인 도구가 워커 요청마다 실리지 않아 입력이 크게 줄지만, 브라우저·iOS 시뮬레이터 같은 도구는 쓸 수 없습니다. 그런 도구가 필요한 워커는 ~/.claude/agents에 직접 만든 에이전트 파일로 두세요(ClaudeRipple은 그 파일을 건드리지 않습니다). 새 세션부터 적용됩니다.",
+    "workerTools.on": "켜짐",
+    "workerTools.off": "꺼짐 (세션 도구 전부 상속)",
+    "workerTools.turnOn": "제한 켜기",
+    "workerTools.turnOff": "제한 끄기",
     "providers.probeNoCredits": "키는 맞습니다. 다만 이 계정에 크레딧(잔액)이 없어 응답은 받지 못합니다. 프로바이더 사이트에서 충전하세요.",
     "providers.probeBadKey": "API 키가 거부됐습니다. 키를 다시 확인하세요.",
     "providers.searchModels": "모델 검색 (이름 또는 id)",
@@ -57,6 +63,12 @@ const I18N = {
     "agentTitle.off": "Off",
     "agentTitle.turnOn": "Turn on",
     "agentTitle.turnOff": "Turn off",
+    "workerTools.title": "Worker tools",
+    "workerTools.help": "Gives the workers ClaudeRipple generates only the read, edit, run, search and skill tools. The session's MCP servers and plugin tools no longer ride along on every worker request, which cuts input sharply, but those workers cannot use a browser or the iOS Simulator. A worker that needs them belongs in an agent file of your own in ~/.claude/agents, which ClaudeRipple never touches. Applies to new sessions.",
+    "workerTools.on": "On",
+    "workerTools.off": "Off (inherits every session tool)",
+    "workerTools.turnOn": "Limit tools",
+    "workerTools.turnOff": "Stop limiting",
     "providers.probeNoCredits": "The key is valid, but this account has no credits, so no answer came back. Top up on the provider site.",
     "providers.probeBadKey": "The API key was rejected. Check the key.",
     "providers.searchModels": "Search models (name or id)",

package/dist/ui/index.html

@@ -67,6 +67,11 @@
       <p class="hint" data-i18n="agentTitle.help"></p>
       <div class="rows" id="client-agent-title-rows"></div>
       <div class="actions"><button class="btn" id="client-agent-title-toggle" type="button"></button></div>
+      <div class="client-divider"></div>
+      <h3 data-i18n="workerTools.title">Worker tools</h3>
+      <p class="hint" data-i18n="workerTools.help"></p>
+      <div class="rows" id="client-worker-tools-rows"></div>
+      <div class="actions"><button class="btn" id="client-worker-tools-toggle" type="button"></button></div>
     </div>
     <div class="card">
       <h2 data-i18n="clients.codex.title">Codex CLI</h2>

package/docs/ARCHITECTURE.md

@@ -166,7 +166,19 @@ chat is out of reach for every approach, ours included.
   records what it wrote in `<home>/generated-agents.json` and touches **only**
   those files: a hand-written agent of the same name wins and is left alone, an
   unticked model removes its generated file and nothing else, identical content is
-  not rewritten. `cli.agentFiles: false` turns generation off. The marker alias
+  not rewritten. `cli.agentFiles: false` turns generation off;
+  `cli.limitWorkerTools: true` adds a `tools:` line so a worker does not inherit
+  every MCP and plugin tool of the session (first request 32,942 → 8,823 tokens,
+  2026-09-29), at the cost of browser and simulator tools. It is opt-in for that
+  reason. With a chatgpt provider configured the body also tells a worker how to
+  make an image: `POST /api/image` on the admin port, which runs one Codex
+  Responses turn with the hosted `image_generation` tool required and answers
+  with the image bytes (`clauderipple image` is the same call). Measured
+  2026-09-29 on a subscription: the image is the `image_generation_call` output
+  item's base64 `result`, about 30 s; `output_format` and `background` are
+  honoured, `size` and `quality` are accepted and ignored (even "999x1" and
+  "bogus" returned 200), and the shape follows the prompt ("square composition"
+  → 1254x1254). So the API takes `aspect` and says it in words. The marker alias
   table is the union of `aliases` (explicit, wins) and every agent file's
   `name → model` — so `[[ripple: <agent>@<effort>]]` resolves for any agent that
   exists, generated or not, with no second registry to keep in step. Why: on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Use GPT (ChatGPT Plus/Pro), 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": [