@yanzc/claude-pro 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "claude-pro: a self-implemented coding agent for Anthropic-compatible APIs or local Claude Code subscription login. Full access with no permission prompts; file edits are checkpointed and can be rewound.",
   "type": "module",
   "repository": {

package/src/api.js

@@ -6,8 +6,9 @@ import { readClaudeCodeLogin, claudeCodeHeaders, CLAUDE_CODE_API_URL, CLAUDE_COD
 import { refreshClaudeCodeLogin, canRenewLogin } from './oauth.js';
 import { humanDuration, parseRateLimit, parseRetryAfter, planRetry, sleepUntil, timing } from './ratelimit.js';
 import { cacheControl, cachePlanOf, fingerprint } from './cache.js';
-import { readGatewayLogin } from './gateway.js';
+import { readGatewayLogin, fetchGatewayModels, cachedGatewayModel, gatewayEffort, gatewayDefaultEffort } from './gateway.js';
 import { createCodexFetch, codexModels } from './codex/client.js';
+import { SIGNATURE_PREFIX } from './codex/translate-request.js';
 
 let cached = null;
 
@@ -194,12 +195,18 @@ const noEffort = new Set();
 export const effortSupported = (modelId) => !noEffort.has(modelId);
 
 // The effort a model uses when none is sent (docs.claude.com, "Effort"): medium on Opus 5.5 and Haiku 5.5, high on
-// the other models that take one; for a GPT model, its default in the local Codex install's models cache. null for
+// the other models that take one; for a GPT model, the gateway's metadata or the local Codex models cache. null for
 // a model that takes none or is not known.
-export function defaultEffort(modelId) {
+export function defaultEffort(modelId, config = null) {
   const id = String(modelId || '');
   if (!effortSupported(id)) return null;
-  if (/^gpt-/i.test(id)) return codexModels().models.find((m) => m.slug === id)?.defaultEffort || null;
+  if (/^gpt-/i.test(id)) {
+    if (config?.usesGateway) {
+      const login = readGatewayLogin(config.gatewayUrl);
+      return gatewayDefaultEffort(cachedGatewayModel(login, id)) || codexModels(config.env).models.find((m) => m.slug === id)?.defaultEffort || null;
+    }
+    return codexModels(config?.env).models.find((m) => m.slug === id)?.defaultEffort || null;
+  }
   if (/^claude-(?:opus|haiku)-5-5(?:-|$)/i.test(id)) return 'medium';
   if (/^claude-(?:fable|mythos|opus-(?:5|4-[5-8])|sonnet-(?:5|4-6))(?:-|$)/i.test(id)) return 'high';
   return null;
@@ -218,6 +225,26 @@ export function parseMaxTokensLimit(message) {
   return n >= 256 ? n : null;
 }
 
+// Thinking blocks made from Codex reasoning (a GPT model's turns, signed "cgw1:...") replay that reasoning on the
+// Codex backend only: Anthropic refuses their signatures ("Invalid `signature` in `thinking` block"), so a
+// conversation that moves from a GPT model to Claude, or to another provider, sends them without those blocks.
+// The session keeps them, for a later switch back. `inTurn`: blocks were taken out of the turn in progress (the
+// tool loop since the last prompt), whose assistant messages Anthropic wants to start with thinking when thinking
+// is on; such a turn goes on without thinking until the next prompt.
+const isCodexThinking = (b) => b?.type === 'thinking' && typeof b.signature === 'string' && b.signature.startsWith(SIGNATURE_PREFIX);
+const isPrompt = (m) => m.role === 'user' && !(Array.isArray(m.content) && m.content.some((b) => b.type === 'tool_result'));
+function withoutCodexThinking(messages) {
+  const prompt = messages.findLastIndex(isPrompt);
+  let inTurn = false;
+  const out = messages.flatMap((m, i) => {
+    if (m.role !== 'assistant' || !Array.isArray(m.content) || !m.content.some(isCodexThinking)) return [m];
+    if (i > prompt) inTurn = true;
+    const content = m.content.filter((b) => !isCodexThinking(b));
+    return content.length ? [{ ...m, content }] : [];
+  });
+  return { messages: out, inTurn };
+}
+
 // `cacheBucket` says which prompt cache TTL applies: "main" for the conversation itself (the default), "other"
 // for sub-agents, compaction and side queries (see Config.cacheTtl). `cacheMessages: false` leaves the messages
 // unmarked: for a request whose messages are never sent twice, writing them to the cache only costs more.
@@ -229,6 +256,10 @@ export function buildParams(config, { model, system, messages, tools, maxTokens,
   const ttl = refused?.has('ttl') ? '5m' : config.cacheTtl(cacheBucket);
   const mark = (place) => (caching && !refused?.has(place) ? { ...cacheControl(ttl) } : null);
   const systemMark = mark('system');
+  // The codex provider, and the gateway for a GPT model, take the request to the Codex backend.
+  const toCodex = config.usesCodex || /^gpt-/i.test(model.id);
+  let turnLostThinking = false;
+  if (!toCodex) ({ messages, inTurn: turnLostThinking } = withoutCodexThinking(messages));
   const params = {
     model: model.id,
     max_tokens: outputCaps.has(model.id) ? Math.min(wanted, outputCaps.get(model.id)) : wanted,
@@ -244,13 +275,15 @@ export function buildParams(config, { model, system, messages, tools, maxTokens,
     const toolMark = mark('tools');
     params.tools = tools.map((t, i) => (i === tools.length - 1 && toolMark ? { ...t, cache_control: toolMark } : t));
   }
-  // A GPT model with no effort set gets its default from the local Codex models cache, sent explicitly, so that
-  // the gateway (whose own default is its Codex config) uses what the footer shows.
-  const eff = (effort === undefined ? config.effort : effort) || (/^gpt-/i.test(model.id) ? defaultEffort(model.id) : null);
+  // A GPT model with no effort set gets its default from the gateway's model metadata (or the local Codex cache
+  // when using the Codex provider), sent explicitly so that the footer and backend use the same level.
+  let eff = (effort === undefined ? config.effort : effort) || (/^gpt-/i.test(model.id) ? defaultEffort(model.id, config) : null);
+  if (config.usesGateway && /^gpt-/i.test(model.id)) eff = gatewayEffort(cachedGatewayModel(readGatewayLogin(config.gatewayUrl), model.id), eff);
   if (eff && !noEffort.has(model.id)) params.output_config = { effort: eff };
   const budget = config.thinkingBudget;
   if (budget === 0) params.thinking = { type: 'disabled' };
   else if (budget > 0) params.thinking = { type: 'enabled', budget_tokens: Math.min(budget, params.max_tokens - 1) };
+  if (turnLostThinking) params.thinking = { type: 'disabled' };
   return params;
 }
 
@@ -306,6 +339,14 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
   // A token that has expired (or is about to) is renewed first, as the official client does.
   if (config.usesClaudeCode) await renewLogin(config, signal);
   let login = config.usesClaudeCode ? readClaudeCodeLogin(config) : null;
+  // Load gateway model metadata before the synchronous parameter builder; the cache is keyed by gateway and key,
+  // so changing accounts or gateway URLs cannot leak a model's effort levels into another context.
+  if (config.usesGateway && /^gpt-/i.test(request.model?.id)) {
+    const gatewayLogin = readGatewayLogin(config.gatewayUrl);
+    if (gatewayLogin) {
+      try { await fetchGatewayModels(gatewayLogin, { signal }); } catch (e) { if (e.name === 'AbortError' || signal?.aborted) throw e; }
+    }
+  }
   let client = getClient(config, login);
   const params = buildParams(config, request, login);
   let authReloaded = false;

package/src/codex/client.js

@@ -174,6 +174,13 @@ function clampEffort(effort, supported) {
   return supported.reduce((best, s) => (Math.abs(EFFORTS.indexOf(s) - want) < Math.abs(EFFORTS.indexOf(best) - want) ? s : best), supported[0]);
 }
 
+// The effort levels a GPT model takes, from the local Codex models cache ([] when it is not listed there):
+// gpt-6.1-sol takes low … ultra, but not none or minimal.
+export const codexEfforts = (modelId, env = process.env) => codexModels(env).models.find((m) => m.slug === modelId)?.efforts || [];
+
+// The level the Codex backend gets for a chosen one: the nearest the model takes.
+export const codexEffort = (modelId, effort, env = process.env) => clampEffort(effort, codexEfforts(modelId, env));
+
 // An Anthropic-shaped error response, which the SDK turns into an APIError with this status.
 function errorResponse(status, type, message, headers = {}) {
   return new Response(JSON.stringify({ type: 'error', error: { type, message } }), { status, headers: { 'content-type': 'application/json', ...headers } });

package/src/commands.js

@@ -6,8 +6,8 @@ import { c, padEnd, truncate } from './ui/ansi.js';
 import { SelectDialog } from './ui/dialogs.js';
 import { renderTodos, resultLines, formatTokens, formatDuration } from './ui/render.js';
 import { loadConfig, settingsFiles, updateSettingsFile, rememberChoice, applyRememberedChoices, KNOWN_KEYS, VERSION, APP_NAME, CONFIG_DIR } from './config.js';
-import { loginWithBrowser, readGatewayLogin, clearGatewayLogin, fetchGatewayAccount, formatUsd } from './gateway.js';
-import { codexLoginSummary, codexModels } from './codex/client.js';
+import { loginWithBrowser, readGatewayLogin, clearGatewayLogin, fetchGatewayAccount, fetchGatewayModels, cachedGatewayModel, gatewayEfforts, gatewayEffort, formatUsd } from './gateway.js';
+import { codexLoginSummary, codexModels, codexEfforts, codexEffort } from './codex/client.js';
 import { readClaudeCodeLogin } from './claude-code.js';
 import { SessionStore } from './session.js';
 import { memoryFiles, listAutoMemories } from './context.js';
@@ -15,13 +15,20 @@ import { INIT_PROMPT } from './prompts.js';
 import { loadCustomCommands, renderSkill, expandCommandBody, expandShellEmbeds } from './agents.js';
 import { listBackgroundShells } from './tools/bash.js';
 import { estimateTokens } from './agent.js';
-import { quickQuery, cacheRefusals } from './api.js';
+import { quickQuery, cacheRefusals, defaultEffort } from './api.js';
 import { hasRipgrep } from './utils/shell.js';
 import { displayPath } from './utils/paths.js';
 import { rewind } from './checkpoints.js';
 import { canRestart, runSelfCheck } from './restart.js';
 
 const EFFORTS = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+const isGpt = (modelId) => /^gpt-/i.test(modelId);
+// The levels /effort offers for a model: gateway metadata first, then the local Codex cache, else EFFORTS.
+const effortLevels = (modelId, modelInfo = null) => {
+  const remote = gatewayEfforts(modelInfo);
+  if (remote.length) return remote;
+  return isGpt(modelId) && codexEfforts(modelId).length ? codexEfforts(modelId) : EFFORTS;
+};
 
 export function buildCommands(app) {
   const commands = new Map();
@@ -217,7 +224,18 @@ export function buildCommands(app) {
         } else {
           opts.push(...['opus', 'sonnet', 'haiku'].map((a) => ({ label: `${a} ${c.dim(`→ ${cfg.resolveModel(cfg.aliasTarget(a)).label}`)}`, value: a })));
         }
-        if (cfg.usesGateway) opts.push({ label: `gpt-6.1-sol ${c.dim('(OpenAI, through the gateway\'s Codex login)')}`, value: 'gpt-6.1-sol' });
+        if (cfg.usesGateway) {
+          // The other models the gateway serves (Fable, the GPT models, …); without an answer, gpt-6.1-sol.
+          const login = readGatewayLogin(cfg.gatewayUrl);
+          let served = null;
+          try { if (login) served = await fetchGatewayModels(login, { signal: AbortSignal.timeout(4000) }); } catch { /* offline: the fallback below */ }
+          const aliased = new Set(['opus', 'sonnet', 'haiku'].map((a) => cfg.resolveModel(cfg.aliasTarget(a)).id));
+          for (const m of served?.length ? served : [{ id: 'gpt-6.1-sol' }]) {
+            if (aliased.has(m.id)) continue;
+            const note = /^gpt-/i.test(m.id) ? 'OpenAI, through the gateway\'s Codex login' : m.display_name;
+            opts.push({ label: `${m.id}${note ? ` ${c.dim(`(${note})`)}` : ''}`, value: m.id });
+          }
+        }
         if (cfg.provider === 'api' && cfg.env.CLAUDE_CODE_SUBAGENT_MODEL) opts.push({ label: `${cfg.env.CLAUDE_CODE_SUBAGENT_MODEL} ${c.dim('(sub-agent model)')}`, value: cfg.env.CLAUDE_CODE_SUBAGENT_MODEL });
         choice = await app.showDialog(new SelectDialog({ title: 'Select model', question: `Current: ${c.bold(cfg.mainModel.label)}. Any name works too: /model <name>`, options: opts }));
         if (!choice) return;
@@ -235,25 +253,43 @@ export function buildCommands(app) {
 
   add({
     name: 'effort',
-    argHint: `[${EFFORTS.join('|')}|auto|default]`,
+    get argHint() {
+      const cfg = app.runtime.config;
+      const login = cfg.usesGateway ? readGatewayLogin(cfg.gatewayUrl) : null;
+      return `[${effortLevels(cfg.mainModel.id, cachedGatewayModel(login, cfg.mainModel.id)).join('|')}|auto|default]`;
+    },
     description: 'Set reasoning effort (output_config.effort; kept for later sessions)',
     async run(args) {
       const cfg = app.runtime.config;
+      const id = cfg.mainModel.id;
+      let modelInfo = null;
+      if (cfg.usesGateway && isGpt(id)) {
+        const login = readGatewayLogin(cfg.gatewayUrl);
+        try { if (login) modelInfo = (await fetchGatewayModels(login, { signal: AbortSignal.timeout(4000) })).find((m) => m.id === id) || null; } catch { /* use local cache or generic levels */ }
+      }
+      const levels = effortLevels(id, modelInfo);
       let choice = args.trim().toLowerCase();
       if (!choice) {
         const configured = (cfg.env.CLAUDE_CODE_EFFORT_LEVEL || '').trim().toLowerCase() || 'auto';
+        const fallback = defaultEffort(id, cfg);
+        // A level this GPT model does not take goes out as the nearest one it does.
+        const sent = cfg.effort && isGpt(id)
+          ? modelInfo ? gatewayEffort(modelInfo, cfg.effort) : codexEffort(id, cfg.effort)
+          : cfg.effort;
+        const current = !cfg.effort ? c.bold(`auto (${fallback ? `model default: ${fallback}` : 'not sent'})`)
+          : `${c.bold(cfg.effort)}${sent !== cfg.effort ? c.yellow(` (${id} does not take it: sent as ${sent})`) : ''}`;
         choice = await app.showDialog(new SelectDialog({
-          title: 'Reasoning effort',
-          question: `Current: ${c.bold(cfg.effort || 'auto (not sent)')}`,
+          title: `Reasoning effort · ${id}`,
+          question: `Current: ${current}`,
           options: [
-            ...EFFORTS.map((e) => ({ label: e, value: e })),
-            { label: 'auto (use API default)', value: 'auto' },
+            ...levels.map((e) => ({ label: e, value: e })),
+            { label: `auto ${c.dim(fallback ? `(model default: ${fallback})` : '(use API default)')}`, value: 'auto' },
             { label: `default ${c.dim(`(configured: ${configured})`)}`, value: 'default' },
           ],
         }));
         if (!choice) return;
       }
-      if (choice !== 'auto' && choice !== 'default' && !EFFORTS.includes(choice)) { out(c.red(`Unknown effort "${choice}". Use one of: ${EFFORTS.join(', ')}, auto, default`)); return; }
+      if (choice !== 'auto' && choice !== 'default' && !levels.includes(choice)) { out(c.red(`${id} does not take effort "${choice}". Use one of: ${levels.join(', ')}, auto, default`)); return; }
       const forget = choice === 'default';
       const wanted = (forget ? (cfg.env.CLAUDE_CODE_EFFORT_LEVEL || '') : choice).trim().toLowerCase();
       const next = wanted && wanted !== 'auto' && wanted !== 'default' ? wanted : null;

package/src/gateway.js

@@ -67,6 +67,39 @@ export async function fetchGatewayAccount({ url, apiKey }, { fetchImpl = globalT
   return body.account;
 }
 
+// The models the gateway serves (GET /v1/models), fetched once per gateway and key. The reasoning fields are
+// optional so older gateways still work; when present they are kept with the model for /effort and requests.
+const modelLists = new Map();
+export async function fetchGatewayModels({ url, apiKey }, { fetchImpl = globalThis.fetch, signal } = {}) {
+  const key = `${normalizeGatewayUrl(url)}\n${apiKey}`;
+  if (modelLists.has(key)) return modelLists.get(key);
+  const body = await gatewayJson(`${normalizeGatewayUrl(url)}/v1/models`, { headers: { authorization: `Bearer ${apiKey}` }, signal }, fetchImpl);
+  const list = (body.data || []).filter((m) => typeof m?.id === 'string').map((m) => ({
+    ...m,
+    supported_reasoning_levels: (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : Array.isArray(m.reasoning_levels) ? m.reasoning_levels : [])
+      .map((r) => typeof r === 'string' ? r : r?.effort || r?.name).filter(Boolean),
+    default_reasoning_level: typeof m.default_reasoning_level === 'string' ? m.default_reasoning_level
+      : m.default_reasoning_level?.effort || m.default_effort || null,
+  }));
+  modelLists.set(key, list);
+  return list;
+}
+
+export function cachedGatewayModel(login, modelId) {
+  if (!login?.url || !login?.apiKey) return null;
+  return modelLists.get(`${normalizeGatewayUrl(login.url)}\n${login.apiKey}`)?.find((m) => m.id === modelId) || null;
+}
+
+const EFFORT_ORDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+export function gatewayEfforts(model) { return model?.supported_reasoning_levels || []; }
+export function gatewayDefaultEffort(model) { return model?.default_reasoning_level || null; }
+export function gatewayEffort(model, effort) {
+  const supported = gatewayEfforts(model);
+  if (!effort || !supported.length || supported.includes(effort)) return effort;
+  const want = EFFORT_ORDER.indexOf(effort);
+  return supported.reduce((best, item) => (Math.abs(EFFORT_ORDER.indexOf(item) - want) < Math.abs(EFFORT_ORDER.indexOf(best) - want) ? item : best), supported[0]);
+}
+
 const PAGE = (title, text) => `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font-family:system-ui,sans-serif;max-width:32rem;margin:4rem auto;line-height:1.6"><h2>${title}</h2><p>${text}</p></body>`;
 
 // Log in through the browser. `onUrl(url)` is told the login page's address (to show it, for when the browser

package/src/peers.js

@@ -1,156 +1,157 @@
-// Peers: the other interactive claude-pro sessions on this machine. Each session registers itself in
-// CONFIG_DIR/peers/<id>.json (name, directory, pid, and a port and token of a small HTTP server on 127.0.0.1)
-// so that sessions can send each other tasks: the user with `@name task` in the input box, the model with the
-// MessagePeer tool. A task is answered automatically with the final text of the turn that handled it.
-
-import fs from 'node:fs';
-import path from 'node:path';
-import http from 'node:http';
-import crypto from 'node:crypto';
-import { CONFIG_DIR } from './config.js';
-
-export const PEERS_DIR = path.join(CONFIG_DIR, 'peers');
-const MAX_BODY = 2_000_000;
-
-export function peersEnabled(env = process.env) {
-  return !/^(0|false|no|off)$/i.test(env.CLAUDE_PRO_PEERS || '');
-}
-
-function alive(pid) {
-  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
-}
-
-export const cleanName = (s) => String(s || '').replace(/[^\w.-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').slice(0, 40) || 'agent';
-
-// The sessions that are running now (stale entries of sessions that died are removed).
-export function listPeers({ excludeId } = {}) {
-  let files = [];
-  try { files = fs.readdirSync(PEERS_DIR).filter((f) => f.endsWith('.json')); } catch { return []; }
-  const peers = [];
-  for (const f of files) {
-    const file = path.join(PEERS_DIR, f);
-    let p;
-    try { p = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { continue; }
-    if (!p?.id || !p.port || !alive(p.pid)) { try { fs.unlinkSync(file); } catch { /* ignore */ } continue; }
-    if (p.id !== excludeId) peers.push(p);
-  }
-  return peers.sort((a, b) => a.startedAt - b.startedAt);
-}
-
-export function findPeer(peers, ref) {
-  const q = String(ref || '').replace(/^@/, '').toLowerCase();
-  if (!q) return null;
-  return peers.find((p) => p.name.toLowerCase() === q) || peers.find((p) => p.id.startsWith(q)) || null;
-}
-
-export class PeerNode {
-  // onMessage(msg): msg = {id, kind: 'task'|'reply', text, inReplyTo, from: {id, name, cwd}}
-  constructor({ cwd, name, onMessage }) {
-    this.cwd = cwd;
-    this.wantedName = name || null;
-    this.onMessage = onMessage;
-    this.id = crypto.randomBytes(6).toString('hex');
-    this.token = crypto.randomBytes(16).toString('hex');
-    this.name = null;
-    this.server = null;
-    this.port = null;
-  }
-
-  get file() { return path.join(PEERS_DIR, `${this.id}.json`); }
-
-  async start() {
-    this.server = http.createServer((req, res) => this.handle(req, res));
-    await new Promise((resolve, reject) => {
-      this.server.once('error', reject);
-      this.server.listen(0, '127.0.0.1', resolve);
-    });
-    this.server.unref();
-    this.port = this.server.address().port;
-    this.setName(this.wantedName || path.basename(this.cwd) || 'agent');
-    return this;
-  }
-
-  // Take `name`, or name-2, name-3... when another live session has it. Returns the name taken.
-  setName(name) {
-    const base = cleanName(name);
-    const taken = new Set(listPeers({ excludeId: this.id }).map((p) => p.name.toLowerCase()));
-    let n = base;
-    for (let i = 2; taken.has(n.toLowerCase()); i++) n = `${base}-${i}`;
-    this.name = n;
-    this.write();
-    return n;
-  }
-
-  setCwd(cwd) {
-    if (cwd === this.cwd) return;
-    this.cwd = cwd;
-    this.write();
-  }
-
-  write() {
-    if (!this.port) return;
-    fs.mkdirSync(PEERS_DIR, { recursive: true });
-    const data = { id: this.id, name: this.name, cwd: this.cwd, pid: process.pid, port: this.port, token: this.token, startedAt: this.startedAt ??= Date.now() };
-    fs.writeFileSync(this.file, JSON.stringify(data));
-  }
-
-  peers() { return listPeers({ excludeId: this.id }); }
-
-  close() {
-    try { fs.unlinkSync(this.file); } catch { /* ignore */ }
-    try { this.server?.close(); } catch { /* ignore */ }
-    this.port = null;
-  }
-
-  handle(req, res) {
-    const reply = (code, body) => { res.writeHead(code, { 'content-type': 'application/json' }); res.end(JSON.stringify(body)); };
-    if (req.method !== 'POST' || req.url !== '/message') return reply(404, { error: 'not found' });
-    if (req.headers.authorization !== `Bearer ${this.token}`) return reply(401, { error: 'bad token' });
-    let body = '';
-    req.setEncoding('utf8');
-    req.on('data', (d) => { body += d; if (body.length > MAX_BODY) req.destroy(); });
-    req.on('end', () => {
-      let msg;
-      try { msg = JSON.parse(body); } catch { return reply(400, { error: 'bad json' }); }
-      if (typeof msg?.text !== 'string' || !msg.from?.name) return reply(400, { error: 'text and from are required' });
-      const id = crypto.randomBytes(4).toString('hex');
-      reply(200, { ok: true, id, name: this.name });
-      try { this.onMessage?.({ id, kind: msg.kind === 'reply' ? 'reply' : 'task', text: msg.text, inReplyTo: msg.inReplyTo || null, from: msg.from }); } catch { /* the receiver's problem */ }
-    });
-  }
-
-  // Send to a peer (an entry of peers(), or its name). Resolves with {id} (the id the receiver gave the message).
-  async send(target, { text, kind = 'task', inReplyTo = null }) {
-    const peer = typeof target === 'string' ? findPeer(this.peers(), target) : target;
-    if (!peer) throw new Error(`No running session called "${target}". /peers lists them.`);
-    const body = JSON.stringify({ kind, text, inReplyTo, from: { id: this.id, name: this.name, cwd: this.cwd } });
-    return await new Promise((resolve, reject) => {
-      const req = http.request({
-        host: '127.0.0.1', port: peer.port, path: '/message', method: 'POST', timeout: 10_000,
-        headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body), authorization: `Bearer ${peer.token}` },
-      }, (res) => {
-        let out = '';
-        res.setEncoding('utf8');
-        res.on('data', (d) => { out += d; });
-        res.on('end', () => {
-          let data = {};
-          try { data = JSON.parse(out); } catch { /* ignore */ }
-          if (res.statusCode !== 200) reject(new Error(`${peer.name} refused the message: ${data.error || res.statusCode}`));
-          else resolve({ id: data.id, peer });
-        });
-      });
-      req.on('timeout', () => req.destroy(new Error(`${peer.name} did not answer`)));
-      req.on('error', (e) => reject(new Error(`Could not reach ${peer.name}: ${e.message}`)));
-      req.end(body);
-    });
-  }
-}
-
-// What the model is given for a message from another session.
-export function peerMessagePrompt(msg) {
-  const from = `${msg.from.name}${msg.from.cwd ? ` (working in ${msg.from.cwd})` : ''}`;
-  if (msg.kind === 'reply') {
-    return `<peer-message from="${msg.from.name}" kind="reply">\n${msg.text}\n</peer-message>\n<system-reminder>This is the answer of another ${'claude-pro'} session, ${from}, to a message you sent it with MessagePeer. Carry on with your task using it.</system-reminder>`;
-  }
-  return `<peer-message from="${msg.from.name}" kind="task">\n${msg.text}\n</peer-message>\n<system-reminder>This task was sent to you by another claude-pro session, ${from}, not typed by your user. Do it as you would a request of the user. The final text of your answer is sent back to ${msg.from.name} automatically, so end with a self-contained report of what you did or found.</system-reminder>`;
-}
+// Peers: the other interactive claude-pro sessions on this machine. Each session registers itself in
+// CONFIG_DIR/peers/<id>.json (name, directory, pid, and a port and token of a small HTTP server on 127.0.0.1)
+// so that sessions can send each other tasks: the user with `@name task` in the input box, the model with the
+// MessagePeer tool. A task is answered automatically with the final text of the turn that handled it.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import http from 'node:http';
+import crypto from 'node:crypto';
+import { CONFIG_DIR } from './config.js';
+
+export const PEERS_DIR = path.join(CONFIG_DIR, 'peers');
+const MAX_BODY = 2_000_000;
+
+export function peersEnabled(env = process.env) {
+  return !/^(0|false|no|off)$/i.test(env.CLAUDE_PRO_PEERS || '');
+}
+
+function alive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
+}
+
+export const cleanName = (s) => String(s || '').replace(/[^\w.-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').slice(0, 40) || 'agent';
+
+// The sessions that are running now (stale entries of sessions that died are removed).
+export function listPeers({ excludeId } = {}) {
+  let files = [];
+  try { files = fs.readdirSync(PEERS_DIR).filter((f) => f.endsWith('.json')); } catch { return []; }
+  const peers = [];
+  for (const f of files) {
+    const file = path.join(PEERS_DIR, f);
+    let p;
+    try { p = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { continue; }
+    if (!p?.id || !p.port || !alive(p.pid)) { try { fs.unlinkSync(file); } catch { /* ignore */ } continue; }
+    if (p.id !== excludeId) peers.push(p);
+  }
+  return peers.sort((a, b) => a.startedAt - b.startedAt);
+}
+
+export function findPeer(peers, ref) {
+  const q = String(ref || '').replace(/^@/, '').toLowerCase();
+  if (!q) return null;
+  return peers.find((p) => p.name.toLowerCase() === q) || peers.find((p) => p.id.startsWith(q)) || null;
+}
+
+export class PeerNode {
+  // onMessage(msg): msg = {id, kind: 'task'|'reply', text, inReplyTo, from: {id, name, cwd}}
+  // `id`: the id this session had before a restart, so that answers on their way still find it.
+  constructor({ cwd, name, id, onMessage }) {
+    this.cwd = cwd;
+    this.wantedName = name || null;
+    this.onMessage = onMessage;
+    this.id = /^[0-9a-f]{12}$/.test(id || '') ? id : crypto.randomBytes(6).toString('hex');
+    this.token = crypto.randomBytes(16).toString('hex');
+    this.name = null;
+    this.server = null;
+    this.port = null;
+  }
+
+  get file() { return path.join(PEERS_DIR, `${this.id}.json`); }
+
+  async start() {
+    this.server = http.createServer((req, res) => this.handle(req, res));
+    await new Promise((resolve, reject) => {
+      this.server.once('error', reject);
+      this.server.listen(0, '127.0.0.1', resolve);
+    });
+    this.server.unref();
+    this.port = this.server.address().port;
+    this.setName(this.wantedName || path.basename(this.cwd) || 'agent');
+    return this;
+  }
+
+  // Take `name`, or name-2, name-3... when another live session has it. Returns the name taken.
+  setName(name) {
+    const base = cleanName(name);
+    const taken = new Set(listPeers({ excludeId: this.id }).map((p) => p.name.toLowerCase()));
+    let n = base;
+    for (let i = 2; taken.has(n.toLowerCase()); i++) n = `${base}-${i}`;
+    this.name = n;
+    this.write();
+    return n;
+  }
+
+  setCwd(cwd) {
+    if (cwd === this.cwd) return;
+    this.cwd = cwd;
+    this.write();
+  }
+
+  write() {
+    if (!this.port) return;
+    fs.mkdirSync(PEERS_DIR, { recursive: true });
+    const data = { id: this.id, name: this.name, cwd: this.cwd, pid: process.pid, port: this.port, token: this.token, startedAt: this.startedAt ??= Date.now() };
+    fs.writeFileSync(this.file, JSON.stringify(data));
+  }
+
+  peers() { return listPeers({ excludeId: this.id }); }
+
+  close() {
+    try { fs.unlinkSync(this.file); } catch { /* ignore */ }
+    try { this.server?.close(); } catch { /* ignore */ }
+    this.port = null;
+  }
+
+  handle(req, res) {
+    const reply = (code, body) => { res.writeHead(code, { 'content-type': 'application/json' }); res.end(JSON.stringify(body)); };
+    if (req.method !== 'POST' || req.url !== '/message') return reply(404, { error: 'not found' });
+    if (req.headers.authorization !== `Bearer ${this.token}`) return reply(401, { error: 'bad token' });
+    let body = '';
+    req.setEncoding('utf8');
+    req.on('data', (d) => { body += d; if (body.length > MAX_BODY) req.destroy(); });
+    req.on('end', () => {
+      let msg;
+      try { msg = JSON.parse(body); } catch { return reply(400, { error: 'bad json' }); }
+      if (typeof msg?.text !== 'string' || !msg.from?.name) return reply(400, { error: 'text and from are required' });
+      const id = crypto.randomBytes(4).toString('hex');
+      reply(200, { ok: true, id, name: this.name });
+      try { this.onMessage?.({ id, kind: msg.kind === 'reply' ? 'reply' : 'task', text: msg.text, inReplyTo: msg.inReplyTo || null, from: msg.from }); } catch { /* the receiver's problem */ }
+    });
+  }
+
+  // Send to a peer (an entry of peers(), or its name). Resolves with {id} (the id the receiver gave the message).
+  async send(target, { text, kind = 'task', inReplyTo = null }) {
+    const peer = typeof target === 'string' ? findPeer(this.peers(), target) : target;
+    if (!peer) throw new Error(`No running session called "${target}". /peers lists them.`);
+    const body = JSON.stringify({ kind, text, inReplyTo, from: { id: this.id, name: this.name, cwd: this.cwd } });
+    return await new Promise((resolve, reject) => {
+      const req = http.request({
+        host: '127.0.0.1', port: peer.port, path: '/message', method: 'POST', timeout: 10_000,
+        headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body), authorization: `Bearer ${peer.token}` },
+      }, (res) => {
+        let out = '';
+        res.setEncoding('utf8');
+        res.on('data', (d) => { out += d; });
+        res.on('end', () => {
+          let data = {};
+          try { data = JSON.parse(out); } catch { /* ignore */ }
+          if (res.statusCode !== 200) reject(new Error(`${peer.name} refused the message: ${data.error || res.statusCode}`));
+          else resolve({ id: data.id, peer });
+        });
+      });
+      req.on('timeout', () => req.destroy(new Error(`${peer.name} did not answer`)));
+      req.on('error', (e) => reject(new Error(`Could not reach ${peer.name}: ${e.message}`)));
+      req.end(body);
+    });
+  }
+}
+
+// What the model is given for a message from another session.
+export function peerMessagePrompt(msg) {
+  const from = `${msg.from.name}${msg.from.cwd ? ` (working in ${msg.from.cwd})` : ''}`;
+  if (msg.kind === 'reply') {
+    return `<peer-message from="${msg.from.name}" kind="reply">\n${msg.text}\n</peer-message>\n<system-reminder>This is the answer of another ${'claude-pro'} session, ${from}, to a message you sent it with MessagePeer. Carry on with your task using it.</system-reminder>`;
+  }
+  return `<peer-message from="${msg.from.name}" kind="task">\n${msg.text}\n</peer-message>\n<system-reminder>This task was sent to you by another claude-pro session, ${from}, not typed by your user. Do it as you would a request of the user. The final text of your answer is sent back to ${msg.from.name} automatically, so end with a self-contained report of what you did or found.</system-reminder>`;
+}

package/src/tools/effort.js

@@ -25,7 +25,7 @@ Do not raise it for routine work, and do not switch back and forth: the prompt c
     async call(input) {
       const level = String(input.level || '').trim().toLowerCase();
       if (!EFFORT_LEVELS.includes(level)) return { isError: true, content: `Unknown effort "${input.level}". Use one of: ${EFFORT_LEVELS.join(', ')}.` };
-      const shown = () => config.effort || defaultEffort(config.mainModel.id) || 'the model default';
+      const shown = () => config.effort || defaultEffort(config.mainModel.id, config) || 'the model default';
       const before = shown();
       if (level === before) return { content: `The effort is already ${level}.` };
       config.effortBoost = null;