@yanzc/claude-pro 0.4.3 → 0.4.4

package/README.md

@@ -64,7 +64,7 @@ claude-pro config set CLAUDE_PRO_PROVIDER claude-code
 
 调用方式是：本项目 → `https://api.anthropic.com/v1/messages?beta=true`。请求复用 `Authorization: Bearer <accessToken>`，带上 Claude Code 的 OAuth beta、`x-app: cli`、User-Agent、系统标识，以及来自 `.claude.json` 的设备和账号 metadata。流式响应、原生 `tool_use` / `tool_result`、工具执行、hooks、检查点、计划模式及会话功能都由本项目原有逻辑处理。
 
-此模式默认 `sonnet` → `claude-sonnet-5-5`，`opus` → `claude-opus-5-5`，`haiku` → `claude-haiku-4-5-20251001`；子 agent 默认用 `sonnet`（`CLAUDE_PRO_CLAUDE_CODE_SUBAGENT_MODEL` 可改）。使用 `--model`、`/model` 或 `CLAUDE_PRO_CLAUDE_CODE_MODEL` 指定模型。**`/model`、`/effort` 的选择会一直保留**：按后端记在 `~/.claude-pro/settings.json` 的 `remembered` 里，之后每次启动（交互式和 `-p`）都沿用，优先于 `.env`/settings/环境变量里的配置；命令行 `--model`/`--effort` 只覆盖当次启动；`/model default`、`/effort default` 删掉记住的选择，回到配置的值。`claude-pro config list` 会显示当前记住的选择。已有的 DeepSeek API URL、API key 和 API 模型别名不会参与订阅请求。OAuth 令牌始终只发往 Anthropic，原 API 配置可以通过 `--provider api` 继续使用。
+此模式默认 `sonnet` → `claude-sonnet-5-5`，`opus` → `claude-opus-5-5`，`haiku` → `claude-haiku-5-5`（与 Claude Code 2.1.293 起一样；话题标题、WebFetch 摘要等小请求用它）；子 agent 默认用 `sonnet`（`CLAUDE_PRO_CLAUDE_CODE_SUBAGENT_MODEL` 可改）。使用 `--model`、`/model` 或 `CLAUDE_PRO_CLAUDE_CODE_MODEL` 指定模型。**`/model`、`/effort` 的选择会一直保留**：按后端记在 `~/.claude-pro/settings.json` 的 `remembered` 里，之后每次启动（交互式和 `-p`）都沿用，优先于 `.env`/settings/环境变量里的配置；命令行 `--model`/`--effort` 只覆盖当次启动；`/model default`、`/effort default` 删掉记住的选择，回到配置的值。`claude-pro config list` 会显示当前记住的选择。已有的 DeepSeek API URL、API key 和 API 模型别名不会参与订阅请求。OAuth 令牌始终只发往 Anthropic，原 API 配置可以通过 `--provider api` 继续使用。
 
 每次请求重新读取现有凭据；如果本机 Claude Code 更新了令牌，下次请求自动使用新值。
 
@@ -116,13 +116,13 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 每次请求都会把整个对话重新发给模型，账单的大头是"重复读历史"。本项目按 [Claude Code 的做法](https://code.claude.com/docs/en/prompt-caching)使用 Anthropic 的提示词缓存：
 
 - **断点**：在工具列表末尾、系统提示词、最新一条消息的末尾各放一个 `cache_control`（共 3 个，上限 4 个）。系统提示词在一个会话里只构建一次，前缀稳定才能命中。
-- **开箱即用，不需要配置**：默认值和 Claude Code 一致。订阅登录（`--provider claude-code`）下**主对话用 1 小时**缓存（Claude Code 在订阅额度内就是这样请求的），API key / 其他端点用 5 分钟（API 默认值，不发送 `ttl` 字段）；子 agent、压缩等其他请求永远默认 5 分钟。effort 不设就用模型自己的默认值（Sonnet 5.5、Opus 5.5 是 medium），自动压缩窗口不设就是模型的整个窗口。
+- **开箱即用，不需要配置**：默认值和 Claude Code 一致。订阅登录（`--provider claude-code`）和网关（`gateway`）下**主对话用 1 小时**缓存（Claude Code 在订阅额度内就是这样请求的；网关按 2 倍价计费 1 小时写入，但按网关的用量记录算，533 次 Opus 请求里停顿 5–60 分钟让整段对话重写了 9 次、多花 $14.77，全部改用 1 小时只多花 $2.80），API key / 其他端点用 5 分钟（API 默认值，不发送 `ttl` 字段）；子 agent、压缩等其他请求永远默认 5 分钟。effort 不设就用模型自己的默认值（Sonnet 5.5、Opus 5.5 是 medium），自动压缩窗口不设就是模型的整个窗口。
 - **`.env` 只属于 API 提供方**：`--provider claude-code` 时，`.env` 里的 `CLAUDE_CODE_EFFORT_LEVEL`、`CLAUDE_CODE_AUTO_COMPACT_WINDOW`、`CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`、`CLAUDE_CODE_MAX_OUTPUT_TOKENS`、`MAX_THINKING_TOKENS` 不会被读取（它们是为 DeepSeek 之类的端点调的），订阅模式用上面的默认值；`/config` 会列出被忽略的键。想在订阅模式下调，用 `/config set`、`/effort`、设置文件、环境变量或 `--effort`，这些照常生效。
 - **TTL 分两个桶**（可以改），每次命中会重新计时：
   - **主对话**（你的每一轮）：`CLAUDE_CODE_PROMPT_CACHE_TTL=5m|1h`，或设置项 `promptCacheTtl`
   - **其他请求**（子 agent、压缩、小模型的辅助请求）：`CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL=5m|1h`，或设置项 `subagentPromptCacheTtl`
   - 变量优先于设置项（无论来自哪个文件）；无效的值被忽略，按下一条规则算。`ENABLE_PROMPT_CACHING_1H=1` 让两个桶都用 1 小时（上面两个变量和设置项优先）；`FORCE_PROMPT_CACHING_5M=1` 强制两个桶都用 5 分钟，优先级最高；其他取值被忽略。
-  - 1 小时档的缓存写入按 2 倍价格计费（5 分钟档是 1.25 倍），而且每一轮新增的内容都按这个价写：用 API key 按 token 付费时，只有上下文很大、而且常常停顿超过 5 分钟才划算，所以那里默认是 5 分钟。订阅额度内 Claude Code 默认用 1 小时；想在订阅模式下用 5 分钟，设 `FORCE_PROMPT_CACHING_5M=1`。
+  - 1 小时档的缓存写入按 2 倍价格计费（5 分钟档是 1.25 倍），而且每一轮新增的内容都按这个价写：用 API key 按 token 付费时，只有上下文很大、而且常常停顿超过 5 分钟才划算，所以那里默认是 5 分钟。订阅额度内 Claude Code 默认用 1 小时；想在订阅模式或网关下用 5 分钟，设 `FORCE_PROMPT_CACHING_5M=1`。
 - **关闭缓存**：`DISABLE_PROMPT_CACHING=1` 完全不发 `cache_control`；`DISABLE_PROMPT_CACHING_HAIKU` / `_SONNET` / `_OPUS` 只关 haiku/sonnet/opus 别名所指的模型，`_FABLE` 只关 Fable 模型。
 - **端点不认**：网关对 `cache_control`（或 `ttl`）返回 400 时，不会让请求失败：在被点名的位置去掉标记（报 `ttl` 则退回 5 分钟）后重发；没点名位置的报错一次去掉一处（先消息、再工具、再系统提示词），尽量多保留缓存。请求成功之后才记住这个端点拒绝了什么（之后不再发送），`/status` 会显示；报错本身只是提到 `cache_control` 而去掉标记也没用时，什么都不会记住。
 - **一次性的请求不加缓存标记**：WebFetch 摘要这类整页内容只发一次的小模型请求，缓存写入只会多收钱，所以不标记。
@@ -151,6 +151,7 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 - **压缩对话时**撞上限流同样会暂停，界面显示同样的倒计时（不会一直停在"Compacting conversation"上让人以为卡死了）。
 - **子 agent 和后台 agent** 同样会等待，暂停与恢复都以 `[agent 名]` 为前缀提示一次（倒计时那一行属于主 agent，因为后台 agent 暂停时主 agent 可能还在干活）。轮询（服务器没给重置时间）每隔几分钟重试一次，但只提示一次，不会刷屏。
 - `/doctor` 这类诊断请求不等，直接报告限流。
+- **API 过载（529 / `overloaded_error`）** 也不会让任务停下：先按 `CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS`（默认 1 秒）起、每次翻倍、最长 `CLAUDE_CODE_OVERLOADED_RETRY_MAX_DELAY_MS`（默认 32 秒）快速重试 `CLAUDE_PRO_MAX_RETRIES` 次；用完后转为暂停（界面显示 `API overloaded · checking again in …`，Esc 取消），每隔最长间隔再试一次，直到 API 恢复（提示 `The API is answering again; continuing.`），最多等 `CLAUDE_CODE_RETRY_WATCHDOG_MAX_WAIT_MS`（默认同 `CLAUDE_PRO_RATE_LIMIT_MAX_WAIT_MS`，6 小时；`0` = 重试用完就报错）。
 
 ## 终端标题、页脚与窗口缩放
 
@@ -186,7 +187,7 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 | Bash 默认 / 最长超时 | 2 分钟 / 10 分钟 | 10 分钟 / 1 小时 |
 | Bash 输出返回给模型的上限 | 30000 字符 | 60000 字符，超出部分的全文保存到文件 |
 | 单个工具结果上限（超出落盘） | 50000 字符 | 100000 字符 |
-| `Read` 一次最多 | 2000 行、每行 2000 字符、总共 12 万字符 | 10000 行、每行 20000 字符、总共 40 万字符 |
+| `Read` 一次最多 | 2000 行、每行 2000 字符、总共 12 万字符 | 10000 行、每行 20000 字符、总共 40 万字符；加 `allow_large: true`（与 Claude Code 2.1.296 相同）不限行数和长度，只要上下文在自动压缩之前还放得下（同一批并行读取共用这份余量），放不下就拒绝并写明差多少 |
 | `Glob` / `Grep` 默认返回条数 | 100 / 250 | 1000 / 1000 |
 | `WebFetch` | 只返回小模型的摘要（最多 4096 token），自动把 http 升成 https | `raw: true` 直接拿转换后的全文；摘要上限 16000 token、页面上限 40 万字符；按原样请求 URL，localhost 和内网也可以 |
 | 子 agent | 不能再派子 agent | 嵌套到 2 层（`CLAUDE_PRO_MAX_SUBAGENT_DEPTH`，0 = 不嵌套） |
@@ -197,12 +198,13 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 
 ## 功能
 
-**工具**（与 Claude Code 同名同语义）：`Bash`（持久 cwd、超时、后台运行、可喂 stdin）、`BashOutput`、`KillShell`、`Read`（行号、图片、ipynb）、`Write`、`Edit`（必须先读后改、检测外部修改、保留 CRLF/BOM）、`NotebookEdit`、`Glob`、`Grep`（有 ripgrep 用 rg，否则用内置 JS 搜索：异步不卡界面，遵循 `.gitignore`/`.ignore`、`!` 排除 glob、`^`/`$` 行锚点、多行匹配、上下文行；找不到 rg 时可用 `CLAUDE_PRO_RIPGREP_PATH` 指定；与 rg 不同的是它始终跳过 `node_modules` 等目录，除非 glob 里点名）、`WebFetch`、`WebSearch`（DuckDuckGo/Bing）、`TodoWrite`、`Task`（子 agent）、`TaskOutput`、`TaskStop`、`Skill`、`ExitPlanMode`、`AskUserQuestion`，以及 MCP 工具。
+**工具**（与 Claude Code 同名同语义）：`Bash`（持久 cwd、超时、后台运行、可喂 stdin）、`BashOutput`、`KillShell`、`Read`（行号、图片、ipynb）、`Write`、`Edit`（必须先读后改、检测外部修改、保留 CRLF/BOM）、`NotebookEdit`、`Glob`、`Grep`（有 ripgrep 用 rg，否则用内置 JS 搜索：异步不卡界面，遵循 `.gitignore`/`.ignore`、`!` 排除 glob、`^`/`$` 行锚点、多行匹配、上下文行；找不到 rg 时可用 `CLAUDE_PRO_RIPGREP_PATH` 指定；与 rg 不同的是它始终跳过 `node_modules` 等目录，除非 glob 里点名；模型误传的 `file_path` 当作 `path`，grep 的 `-l`/`-c` 当作输出模式）、`WebFetch`、`WebSearch`（DuckDuckGo/Bing）、`TodoWrite`、`Task`（子 agent）、`TaskOutput`、`TaskStop`、`Skill`、`ExitPlanMode`、`AskUserQuestion`，以及 MCP 工具。
 
 **交互**
 - 流式 Markdown 渲染（代码高亮、表格、中文宽度对齐），思考过程折叠显示（`ctrl+o` 展开）
 - `Esc` 中断；忙碌时输入的消息会排队并插入当前任务
 - `!` Bash 模式、`#` 写入记忆（CLAUDE.md）、`\`+回车 或 `ctrl+j` 换行、粘贴大段文本折叠为 `[Pasted text #1 +42 lines]`
+- `ctrl+c` 或连按两次 `Esc` 清掉的草稿不会丢：在空输入框按 `↑` 找回（连同粘贴的文本和图片），中间发过别的消息也可以
 - `@文件` 补全并附加内容：走的就是 `Read` 工具，等于模型自己读了这个文件。最多带前 2000 行（被截断时会明确告诉模型，并把该文件记为"只读了一部分"，之后 `Write` 不会去覆盖没给它看过的行）；图片作为图片附加；二进制文件和超过 512KB 的文本会被跳过并提示原因；`@目录` 列出目录内容
 - `alt+v` 粘贴剪贴板里的图片（截图用 `Win+Shift+S`），输入框里显示为 `[Image #1]`；超过 1568px 的图会自动缩小。把图片文件拖进终端（或粘贴图片路径）也会作为图片附加
 - 上下文用量接近阈值时自动压缩（`CLAUDE_CODE_AUTO_COMPACT_WINDOW`），也可手动 `/compact`
@@ -210,13 +212,13 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 
 **斜杠命令**：`/help` `/clear` `/compact` `/config` `/model` `/effort` `/status` `/cost` `/context` `/init` `/review` `/memory` `/verify` `/tasks` `/plan` `/rewind` `/skills` `/resume` `/todos` `/agents` `/mcp` `/bashes` `/verbose` `/export` `/doctor` `/exit`，以及 `.claude/commands/*.md`、`.claude-pro/commands/*.md`、`~/.claude-pro/commands/*.md` 中的自定义命令（支持 `$ARGUMENTS`、`$1`、`` !`cmd` ``）。
 
-**记忆**：自动读取 `~/.claude-pro/CLAUDE.md`、项目各级目录的 `CLAUDE.md` / `.claude/CLAUDE.md` / `AGENTS.md` / `CLAUDE.local.md`。
+**记忆**：自动读取 `~/.claude-pro/CLAUDE.md`、项目各级目录的 `CLAUDE.md` / `.claude/CLAUDE.md` / `CLAUDE.local.md`；某一级目录没有 `CLAUDE.md` 时读它的 `AGENTS.md` 代替（与 Claude Code 相同，两者都有时通常是同一份说明，不重复发送）。
 
 **自动记忆（跨会话）**：每个项目有一个由 agent 自己维护的记忆目录 `~/.claude-pro/projects/<项目>/memory/`。它会把你的偏好、纠正过的做法、项目约束等写成一条条小文件，并在 `MEMORY.md` 里建索引；每次新会话开始时索引自动载入。直接说"记住……"或"忘掉……"即可；`/memory` 查看；`CLAUDE_PRO_DISABLE_AUTO_MEMORY=1` 关闭。
 
 **Skills**：`<目录>/skills/<名字>/SKILL.md`，frontmatter 写 `name` 和 `description`，正文是指令，格式与 Claude Code 的 skills 相同。搜索 `~/.claude-pro/skills/`、`<项目>/.claude/skills/`、`<项目>/.claude-pro/skills/`（项目级覆盖用户级）。模型发现任务匹配某个 skill 的描述时会通过 `Skill` 工具自动加载它；你也可以直接用 `/<skill 名> [参数]` 调用，`/skills` 列出全部。
 
-**子 agent**：内置 `general-purpose`、`Explore`、`Plan`；自定义 agent 放在 `.claude/agents/*.md` 或 `~/.claude-pro/agents/*.md`（frontmatter：`name`、`description`、`tools`、`model`）。
+**子 agent**：内置 `general-purpose`、`Explore`、`Plan`；自定义 agent 放在 `.claude/agents/*.md` 或 `~/.claude-pro/agents/*.md`（frontmatter：`name`、`description`、`tools`、`model`、`effort`（low/medium/high/xhigh/max）、`autoCompactWindow`（这个 agent 自己的自动压缩窗口，token 数））。模型调用 `Task` 时也可以给单个子 agent 指定 `model`（sonnet/opus/haiku 或完整 id）和 `effort`，优先于 agent 定义里的，定义里的又优先于会话的。
 
 **后台子 agent**：模型可以用 `Task` 的 `run_in_background: true` 把子 agent 放到后台，自己继续干别的。子 agent 完成后，结果会作为 `<task-notification>` 自动送回；如果当时主 agent 空闲，会自动开启新的一轮来处理结果。`TaskOutput` 用于提前等待结果，`TaskStop` 用于取消；`/tasks` 列出所有后台 agent，`/tasks kill agent_1` 停止其中一个。`-p` 模式会等所有后台 agent 结束后再退出。
 
@@ -224,7 +226,7 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 
 **大输出落盘**：工具结果超过 `CLAUDE_PRO_MAX_TOOL_RESULT_CHARS`（默认 50000 字符）时，全文会保存到 `~/.claude-pro/projects/<项目>/tool-results/`，只把预览和文件路径发给模型，模型可以再用 `Read`/`Grep` 按需查看。Bash 输出被截断时同样会保存全文。超过 7 天的旧文件在启动时自动清理。
 
-**Hooks**：`settings.json` 里的 `hooks` 与 Claude Code 同形：`PreToolUse`、`PostToolUse`、`UserPromptSubmit`、`Stop`。事件内容以 JSON 从 **stdin** 传给脚本（同时放在环境变量 `CLAUDE_PRO_HOOK_INPUT`，另有 `CLAUDE_PROJECT_DIR`）；退出码 0 = 通过（stdout 作为附加上下文），2 = 拦截（stderr 反馈给模型；`Stop` 则让模型继续干活），其他 = 仅警告。
+**Hooks**：`settings.json` 里的 `hooks` 与 Claude Code 同形：`PreToolUse`、`PostToolUse`、`UserPromptSubmit`、`Stop`。事件内容以 JSON 从 **stdin** 传给脚本（同时放在环境变量 `CLAUDE_PRO_HOOK_INPUT`，另有 `CLAUDE_PROJECT_DIR`）；退出码 0 = 通过（stdout 作为附加上下文），2 = 拦截（stderr 反馈给模型；`Stop` 则让模型继续干活），其他 = 仅警告。当护栏用的 hook 加上 `"onFailure": "block"`：启动不了、超时或以其他退出码结束时按拦截处理，而不是放行（与 Claude Code 相同）。hook 输出里的 `<system-reminder>` 标签会被转义，冒充不了系统提示。
 
 ```json
 { "hooks": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "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/agent.js

@@ -168,8 +168,10 @@ function validateInput(schema, input) {
 }
 
 export class Agent {
-  constructor({ config, modes, tools, systemPrompt, io, model, isSubagent = false, cwd, name = 'main', spawnSubagent, hooks, tasks, checkpoints, depth = 0, refreshSystemPrompt, beforeTurn }) {
+  constructor({ config, modes, tools, systemPrompt, io, model, isSubagent = false, cwd, name = 'main', spawnSubagent, hooks, tasks, checkpoints, depth = 0, refreshSystemPrompt, beforeTurn, effort, compactWindow = 0 }) {
     this.config = config;
+    this.effort = effort || undefined; // a sub-agent's own effort level; undefined: the session's (config.effort)
+    this.compactWindow = compactWindow; // a sub-agent's own auto-compact window (tokens); 0: the session's
     this.depth = depth; // 0 for the main agent, +1 for every level of sub-agent
     this.hooks = hooks;
     this.tasks = tasks; // background tasks (sub-agents started with run_in_background)
@@ -191,6 +193,7 @@ export class Agent {
     this.cwd = cwd;
     this.lastContextTokens = 0;
     this.tokensSinceUsage = 0;
+    this.heldTokens = 0; // room taken by tool results not yet in the conversation (see takeContext)
     // What this agent's own requests used. `requests` counts the turns' requests; the summary requests of
     // compactions are counted apart (`compactions`) and their tokens are in the totals like any others.
     this.usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cacheWrite1h: 0, requests: 0, compactions: 0 };
@@ -216,9 +219,26 @@ export class Agent {
 
   get contextEstimate() { return this.lastContextTokens + this.tokensSinceUsage; }
 
+  // Tokens the context can still take before it reaches the auto-compaction threshold: what a Read with allow_large
+  // may use (a larger one would be compacted away right after it was read).
+  contextRoom() {
+    return this.config.autoCompactThreshold(this.model, this.compactWindow) - this.contextEstimate - this.heldTokens;
+  }
+
+  // Claim room for a tool result that is about to be added. Read-only tools run in parallel, so what each one
+  // took is held until their results are in the conversation. Returns {ok, tokens, room}.
+  takeContext(value) {
+    const tokens = estimateTokens(value);
+    const room = this.contextRoom();
+    if (tokens > room) return { ok: false, tokens, room };
+    this.heldTokens += tokens;
+    return { ok: true, tokens, room };
+  }
+
   pushMessage(msg) {
     this.messages.push(msg);
     this.lastActivityAt = Date.now();
+    if (msg.role === 'user') this.heldTokens = 0; // the results that held room are counted from here on
     if (msg.role === 'user') this.tokensSinceUsage += estimateTokens(msg.content);
     this.io.messageAdded?.(msg, this);
   }
@@ -473,7 +493,7 @@ export class Agent {
   shouldAutoCompact() {
     if (!this.config.autoCompactEnabled || this.messages.length <= 2) return false;
     if (this.compactFailures >= MAX_COMPACT_FAILURES) return false;
-    const threshold = this.config.autoCompactThreshold(this.model);
+    const threshold = this.config.autoCompactThreshold(this.model, this.compactWindow);
     if (this.contextEstimate < threshold) return false;
     // Right after a compaction the base context (system prompt, tools, summary) may itself be
     // near a very small window; require real growth so we don't compact on every step.
@@ -545,6 +565,7 @@ export class Agent {
       messages: normalizeMessages(this.messages),
       tools: this.toolSchemas(),
       cacheBucket: this.isSubagent ? 'other' : 'main',
+      ...(this.effort ? { effort: this.effort } : {}),
     }, { signal, onEvent: (ev) => this.io.streamEvent?.(ev, this) });
     this.lastContextTokens = contextTokens(res.usage);
     this.tokensSinceUsage = 0;
@@ -618,7 +639,7 @@ export class Agent {
     const fail = (content, extra = {}) => ({ block: { type: 'tool_result', tool_use_id: tu.id, is_error: true, content }, ...extra });
     const tool = map.get(tu.name);
     if (!tool) return fail(`Error: No such tool available: ${tu.name}`);
-    const input = tu.input || {};
+    const input = tool.normalizeInput && tu.input && typeof tu.input === 'object' ? tool.normalizeInput({ ...tu.input }) : (tu.input || {});
     if (input.__invalid_json !== undefined) {
       return fail('Error: the tool input was not valid JSON (it may have been truncated by the output token limit). Try again with a smaller input, e.g. write large files in several steps.');
     }
@@ -705,7 +726,7 @@ export class Agent {
   // the request is too long by the size of the instruction) the plainer request is made: a short system prompt
   // and no effort, which cannot share the cache, but is smaller and cannot be led astray by the main prompt.
   async requestSummary(messages, { signal, onEvent }) {
-    const call = (request) => streamMessage(this.config, { model: this.model, tools: this.toolSchemas(), messages, cacheBucket: 'other', ...request }, { signal, onEvent });
+    const call = (request) => streamMessage(this.config, { model: this.model, tools: this.toolSchemas(), messages, cacheBucket: 'other', ...(this.effort ? { effort: this.effort } : {}), ...request }, { signal, onEvent });
     try {
       const res = await call({ system: this.currentSystem() });
       this.recordUsage(res, 'summary');

package/src/agents.js

@@ -6,6 +6,8 @@ import path from 'node:path';
 import { CONFIG_DIR } from './config.js';
 
 const READ_ONLY_TOOLS = ['Glob', 'Grep', 'Read', 'Bash', 'WebFetch', 'WebSearch', 'BashOutput'];
+// The effort levels a Task call or an agent definition may ask for (as Claude Code's Agent tool takes them).
+export const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
 
 export const BUILTIN_AGENTS = [
   {
@@ -83,11 +85,14 @@ export function loadAgents(cwd) {
       try {
         const parsed = parseFrontmatter(fs.readFileSync(path.join(dir, f), 'utf8'));
         if (!parsed?.meta.name || !parsed.meta.description) continue;
+        const window = parseInt(parsed.meta.autoCompactWindow, 10);
         agents.set(parsed.meta.name, {
           name: parsed.meta.name,
           description: parsed.meta.description,
           tools: parsed.meta.tools ? toolList(parsed.meta.tools) : '*',
           model: parsed.meta.model && parsed.meta.model !== 'inherit' ? parsed.meta.model : null,
+          effort: EFFORTS.includes(parsed.meta.effort?.toLowerCase()) ? parsed.meta.effort.toLowerCase() : null,
+          autoCompactWindow: window > 0 ? window : 0,
           prompt: parsed.body,
           source: path.join(dir, f),
         });

package/src/api.js

@@ -301,11 +301,12 @@ export function buildParams(config, { model, system, messages, tools, maxTokens,
 }
 
 export class APIError extends Error {
-  constructor(message, { status, retryable, promptTooLong, retryAfterMs = null, rateLimit = null } = {}) {
+  constructor(message, { status, retryable, promptTooLong, retryAfterMs = null, rateLimit = null, overloaded = false } = {}) {
     super(message);
     this.status = status;
     this.retryable = retryable;
     this.promptTooLong = promptTooLong;
+    this.overloaded = overloaded; // 529 / overloaded_error: waited out with its own backoff (see planRetry)
     this.retryAfterMs = retryAfterMs; // what the server's Retry-After header asked for
     this.rateLimit = rateLimit; // what the rate limit headers say (see ratelimit.js)
   }
@@ -325,7 +326,8 @@ function describeError(err, config) {
   if (status === 402 && config?.usesGateway) msg = `The gateway account's balance is too low for this request. Top up at ${config.gatewayUrl}/user (or run /login to check the balance). ${msg}`;
   const retryable = !status || status === 408 || status === 409 || status === 429 || status >= 500;
   const header = typeof err?.headers?.get === 'function' ? err.headers.get('retry-after') : err?.headers?.['retry-after'];
-  return new APIError(msg, { status, retryable, promptTooLong, retryAfterMs: parseRetryAfter(header), rateLimit: parseRateLimit(err?.headers, timing.now()) });
+  const overloaded = status === 529 || (err?.error?.error?.type || err?.error?.type) === 'overloaded_error';
+  return new APIError(msg, { status, retryable, promptTooLong, retryAfterMs: parseRetryAfter(header), rateLimit: parseRateLimit(err?.headers, timing.now()), overloaded });
 }
 
 // Our own aborts are named AbortError and the SDK's is an APIUserAbortError. The message test only
@@ -365,16 +367,17 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
   const params = buildParams(config, request, login);
   let authReloaded = false;
   const refused = new Set(); // what the endpoint refused for this request: remembered once a request got through
-  const retryState = { attempt: 0, rateLimitHits: 0, waitedMs: 0 };
-  let paused = false;
+  const retryState = { attempt: 0, rateLimitHits: 0, waitedMs: 0, overloaded: 0, overloadedWaitMs: 0 };
+  let paused = null; // the plan of the pause in progress (see planRetry)
   for (;;) {
     let emitted = false;
     const startedAt = Date.now(); // the cache TTL counts from the start of the request, not from the end of the reply
     try {
       const stream = await client.messages.create(params, { signal });
       if (paused) {
-        paused = false;
-        onEvent({ type: 'rate_limit_resume', waitedMs: retryState.waitedMs });
+        const overloaded = paused.overloaded;
+        paused = null;
+        onEvent({ type: 'rate_limit_resume', waitedMs: overloaded ? retryState.overloadedWaitMs : retryState.waitedMs, ...(overloaded ? { overloaded } : {}) });
       }
       const blocks = [];
       const jsonBufs = [];
@@ -428,7 +431,7 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
             if (ev.usage) usage = { ...usage, ...Object.fromEntries(Object.entries(ev.usage).filter(([, v]) => v != null)) };
             break;
           case 'error':
-            throw Object.assign(new Error(ev.error?.message || 'stream error'), { status: ev.error?.type === 'rate_limit_error' ? 429 : 500 });
+            throw Object.assign(new Error(ev.error?.message || 'stream error'), { status: { rate_limit_error: 429, overloaded_error: 529 }[ev.error?.type] || 500 });
           default:
             break;
         }
@@ -498,10 +501,13 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
       }
       if (emitted) onEvent({ type: 'reset' });
       if (plan.kind === 'rate_limit') {
-        paused = true;
+        paused = plan;
         onEvent({
           type: 'rate_limit_wait', error: err, delayMs: plan.delayMs, resumeAt: plan.resumeAt, resetAt: plan.resetAt,
-          label: plan.label, polling: plan.polling, waitedMs: retryState.waitedMs, maxWaitMs: config.rateLimitMaxWait,
+          label: plan.label, polling: plan.polling,
+          ...(plan.overloaded
+            ? { overloaded: true, waitedMs: retryState.overloadedWaitMs, maxWaitMs: config.overloadedMaxWait }
+            : { waitedMs: retryState.waitedMs, maxWaitMs: config.rateLimitMaxWait }),
           loginExpiresAt: loginExpiryToWarnAbout(config, login),
         });
         await sleepUntil(plan.resumeAt, signal);

package/src/config.js

@@ -56,7 +56,7 @@ export const KNOWN_KEYS = {
   DISABLE_AUTOCOMPACT: 'Set to 1 to disable auto-compaction',
   CLAUDE_CODE_MAX_OUTPUT_TOKENS: 'max_tokens for each model response (default 128000; lowered automatically if the API allows less)',
   MAX_THINKING_TOKENS: 'Thinking budget: 0 disables thinking, N enables with budget N',
-  CLAUDE_CODE_PROMPT_CACHE_TTL: 'Prompt cache TTL of the conversation itself: 5m or 1h (default: 1h with the subscription login, as in Claude Code, else 5m; 1h writes cost more, they pay off when you pause for more than 5 minutes). Also the promptCacheTtl setting',
+  CLAUDE_CODE_PROMPT_CACHE_TTL: 'Prompt cache TTL of the conversation itself: 5m or 1h (default: 1h with the subscription login, as in Claude Code, and with the gateway, else 5m; 1h writes cost more, they pay off when you pause for more than 5 minutes). Also the promptCacheTtl setting',
   CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL: 'Prompt cache TTL of everything else (sub-agents, compaction, side queries): 5m (default) or 1h. Also the subagentPromptCacheTtl setting',
   ENABLE_PROMPT_CACHING_1H: 'Set to 1 to request the 1-hour TTL for both (the two TTL variables above win over it)',
   FORCE_PROMPT_CACHING_5M: 'Set to 1 to force the 5-minute TTL for both, over every other TTL setting',
@@ -69,6 +69,9 @@ export const KNOWN_KEYS = {
   CLAUDE_PRO_MAX_RETRIES: 'Retries for failed API requests (0 = no retries at all, which also turns off the rate limit wait)',
   CLAUDE_PRO_RATE_LIMIT_MAX_WAIT_MS: 'Longest total time to wait for a rate limit (e.g. the 5-hour window) to reset before continuing by itself (default 21600000 = 6 hours; 0 = report the error instead of waiting)',
   CLAUDE_PRO_RATE_LIMIT_POLL_MS: 'When a rate limit does not say when it resets, try again at most this far apart (default 300000 = 5 minutes)',
+  CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS: 'First wait before retrying a request refused as overloaded (529); doubled at each retry (default 1000)',
+  CLAUDE_CODE_OVERLOADED_RETRY_MAX_DELAY_MS: 'Longest wait between retries of an overloaded (529) request (default 32000)',
+  CLAUDE_CODE_RETRY_WATCHDOG_MAX_WAIT_MS: 'How long to keep retrying an overloaded (529) API once the usual retries are used up, before reporting the error (default: CLAUDE_PRO_RATE_LIMIT_MAX_WAIT_MS, 6 hours; 0 = give up after the retries)',
   BASH_DEFAULT_TIMEOUT_MS: 'Default timeout for Bash commands (default 600000 = 10 minutes)',
   BASH_MAX_TIMEOUT_MS: 'Maximum timeout the model may request for Bash commands (default 3600000 = 1 hour)',
   BASH_MAX_OUTPUT_LENGTH: 'Max characters of Bash output returned to the model; the full text is saved to a file (default 60000)',
@@ -254,10 +257,10 @@ export class Config {
 
   aliasTarget(alias) {
     if (this.usesClaudeCode) {
-      return { opus: 'claude-opus-5-5', sonnet: 'claude-sonnet-5-5', haiku: 'claude-haiku-4-5-20251001' }[alias] || null;
+      return { opus: 'claude-opus-5-5', sonnet: 'claude-sonnet-5-5', haiku: 'claude-haiku-5-5' }[alias] || null;
     }
     // The gateway prices models by their undated names.
-    if (this.usesGateway) return { opus: 'claude-opus-5-5', sonnet: 'claude-sonnet-5-5', haiku: 'claude-haiku-4-5' }[alias] || null;
+    if (this.usesGateway) return { opus: 'claude-opus-5-5', sonnet: 'claude-sonnet-5-5', haiku: 'claude-haiku-5-5' }[alias] || null;
     if (this.usesCodex) {
       // No Claude here: the big aliases mean the Codex model, haiku the small one when the Codex install has it.
       if (alias === 'haiku') return codexModels(this.env).models.some((m) => m.slug === 'gpt-6-luna') ? 'gpt-6-luna' : this.codexModelSpec;
@@ -281,7 +284,7 @@ export class Config {
       const inner = this.resolveModel(aliased);
       return { ...inner, contextWindow: oneM ? 1_000_000 : inner.contextWindow, label: `${name}${oneM ? '[1m]' : ''} (${inner.label})` };
     }
-    const nativeOneM = this.claudeIds && /^claude-(?:sonnet-5(?:-|$)|opus-(?:5(?:-|$)|4-[78](?:-|$)))/i.test(name);
+    const nativeOneM = this.claudeIds && /^claude-(?:(?:sonnet|haiku)-5(?:-|$)|opus-(?:5(?:-|$)|4-[78](?:-|$)))/i.test(name);
     // OpenAI models (the codex provider, gpt-6.1-sol on the gateway): the window the Codex install reports,
     // else the 272K of the current GPT models.
     if (/^gpt-/i.test(name)) {
@@ -337,7 +340,9 @@ export class Config {
       : normalizeTtl(this.env.CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL) || normalizeTtl(this.settings?.subagentPromptCacheTtl);
     if (own) return own;
     if (isOn(this.env.ENABLE_PROMPT_CACHING_1H)) return '1h';
-    return bucket === 'main' && this.usesClaudeCode ? '1h' : '5m';
+    // The gateway too: measured on its usage records (533 Opus requests), pauses of 5 to 60 minutes rewrote the whole
+    // conversation 9 times at 1.25x, $14.77; writing every turn at 2x instead costs $2.80 more.
+    return bucket === 'main' && (this.usesClaudeCode || this.usesGateway) ? '1h' : '5m';
   }
   // DISABLE_PROMPT_CACHING turns it off for everything; the per-model variables only for the model that
   // their alias resolves to (a different version pinned as the model keeps its caching), wherever it runs.
@@ -354,15 +359,20 @@ export class Config {
   get maxRetries() { return int(this.env.CLAUDE_PRO_MAX_RETRIES, 6); }
   get rateLimitMaxWait() { return Math.max(0, int(this.env.CLAUDE_PRO_RATE_LIMIT_MAX_WAIT_MS, 6 * 3_600_000)); }
   get rateLimitPoll() { return Math.max(1000, int(this.env.CLAUDE_PRO_RATE_LIMIT_POLL_MS, 300_000)); }
-
-  // Effective window for compaction: the configured auto-compact window capped by the model window.
-  compactWindow(model = this.mainModel) {
-    const configured = int(this.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW, 0);
+  // An overloaded API (529): the backoff, and how long to keep trying once the retries are used up (see planRetry).
+  get overloadedRetryBaseDelay() { return Math.max(100, int(this.env.CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS, 1000)); }
+  get overloadedRetryMaxDelay() { return Math.max(this.overloadedRetryBaseDelay, int(this.env.CLAUDE_CODE_OVERLOADED_RETRY_MAX_DELAY_MS, 32_000)); }
+  get overloadedMaxWait() { return Math.max(0, int(this.env.CLAUDE_CODE_RETRY_WATCHDOG_MAX_WAIT_MS, this.rateLimitMaxWait)); }
+
+  // Effective window for compaction: the configured auto-compact window capped by the model window. `own`: a
+  // sub-agent's autoCompactWindow, which takes the place of the configured one.
+  compactWindow(model = this.mainModel, own = 0) {
+    const configured = own > 0 ? own : int(this.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW, 0);
     return configured > 0 ? Math.min(configured, model.contextWindow) : model.contextWindow;
   }
   get autoCompactEnabled() { return !/^(1|true|yes)$/i.test(this.env.DISABLE_AUTOCOMPACT || ''); }
-  autoCompactThreshold(model = this.mainModel) {
-    const window = this.compactWindow(model);
+  autoCompactThreshold(model = this.mainModel, own = 0) {
+    const window = this.compactWindow(model, own);
     const pct = int(this.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE, 0);
     if (pct > 0 && pct <= 100) return Math.floor(window * pct / 100);
     // Leave room for the summary itself and the next response (replies rarely come close to the

package/src/context.js

@@ -43,9 +43,12 @@ export function memoryFiles(cwd) {
   }
   for (const d of dirs) {
     if (d === os.homedir()) continue; // home is covered by the user memory
+    const before = files.length;
     add(path.join(d, 'CLAUDE.md'), 'project');
     add(path.join(d, '.claude', 'CLAUDE.md'), 'project');
-    add(path.join(d, 'AGENTS.md'), 'project');
+    // As in Claude Code, AGENTS.md stands in for a missing CLAUDE.md: where both exist they are usually copies of
+    // each other (one for Claude, one for Codex), and loading both would send the instructions twice.
+    if (files.length === before) add(path.join(d, 'AGENTS.md'), 'project');
     add(path.join(d, 'CLAUDE.local.md'), 'local');
   }
   return files;

package/src/hooks.js

@@ -4,13 +4,17 @@
 //              "PostToolUse": [...], "UserPromptSubmit": [...], "Stop": [...] }
 // The event payload is passed as JSON on stdin (like Claude Code) and in $CLAUDE_PRO_HOOK_INPUT; $CLAUDE_PROJECT_DIR is set too.
 // Exit code 0: fine (stdout is kept as extra context). Exit code 2: block, stderr goes to the model.
-// Any other non-zero exit code is reported as a warning and ignored.
+// Any other non-zero exit code, a hook that cannot start and one that times out are reported as a warning and
+// let through, unless the hook says "onFailure": "block" (as in Claude Code): then they block like exit code 2.
+// <system-reminder> tags in a hook's output are escaped, so that it cannot pass itself off as the harness.
 
 import { spawnShell, killTree, findShell, watchShell } from './utils/shell.js';
 import { stripAnsi } from './ui/ansi.js';
 
 const DEFAULT_TIMEOUT_MS = 60_000;
 
+export const escapeReminders = (text) => String(text).replace(/<(\/?\s*system-reminder)/gi, '&lt;$1');
+
 function matches(matcher, name) {
   if (!matcher || matcher === '*') return true;
   try { return new RegExp(`^(?:${matcher})$`).test(name || ''); } catch { return matcher === name; }
@@ -69,11 +73,18 @@ export class HookRunner {
         const r = await runCommand(this.shell, h.command, { cwd, payload: full, timeout: h.timeout ? h.timeout * 1000 : DEFAULT_TIMEOUT_MS, signal });
         if (r.code === 2) {
           result.blocked = true;
-          result.message = r.err || r.out || `Blocked by ${event} hook: ${h.command}`;
+          result.message = escapeReminders(r.err || r.out || `Blocked by ${event} hook: ${h.command}`);
           return result;
         }
-        if (r.code !== 0) result.warnings.push(`${event} hook "${h.command}" exited with ${r.code}${r.err ? `: ${r.err.split('\n')[0]}` : ''}`);
-        else if (r.out) result.context.push(r.out);
+        if (r.code !== 0) {
+          const failure = `${event} hook "${h.command}" exited with ${r.code}${r.err ? `: ${r.err.split('\n')[0]}` : ''}`;
+          if (h.onFailure === 'block' && !signal?.aborted) {
+            result.blocked = true;
+            result.message = escapeReminders(`${failure}\n(The hook failed and is set to block on failure.)`);
+            return result;
+          }
+          result.warnings.push(failure);
+        } else if (r.out) result.context.push(escapeReminders(r.out));
       }
     }
     return result;

package/src/print.js

@@ -3,7 +3,7 @@
 
 import { createRuntime } from './runtime.js';
 import { SessionStore } from './session.js';
-import { describePause, shouldAnnounce } from './ratelimit.js';
+import { describePause, resumeText, shouldAnnounce } from './ratelimit.js';
 import { c } from './ui/ansi.js';
 
 export async function runPrint({ prompt, flags, cwd, stdout = process.stdout, stderr = process.stderr }) {
@@ -21,7 +21,7 @@ export async function runPrint({ prompt, flags, cwd, stdout = process.stdout, st
       }
       if (ev.type === 'rate_limit_resume') {
         paused = null;
-        err(c.yellow(`${who}The limit has cleared; continuing.`));
+        err(c.yellow(`${who}${resumeText(ev)}`));
       }
     };
   };

package/src/ratelimit.js

@@ -161,6 +161,11 @@ function limitMessage(err, rl, state, budget, now, why) {
 //    that reset, as long as it fits in the budget (rateLimitMaxWait, default 6 hours);
 //  - a short announced wait: a few quick retries, counted like any other;
 //  - nothing announced: back off 1s, 2s, 4s ... up to rateLimitPoll (5 minutes) between attempts, within the budget.
+//
+// An overloaded API (529, overloaded_error) backs off from CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS (1s) to
+// CLAUDE_CODE_OVERLOADED_RETRY_MAX_DELAY_MS (32s), as in Claude Code. When the usual retries are used up it does not
+// give up but pauses and tries again at the longest delay, like Claude Code's unattended retry mode, for at most
+// overloadedMaxWait (CLAUDE_CODE_RETRY_WATCHDOG_MAX_WAIT_MS, by default the rate limit budget) in all.
 export function planRetry(err, state, config, { now = Date.now(), rand = Math.random, allowWait = true } = {}) {
   if (!err.retryable) return { action: 'throw' };
   const maxRetries = config.maxRetries;
@@ -171,6 +176,22 @@ export function planRetry(err, state, config, { now = Date.now(), rand = Math.ra
     return { action: 'wait', kind: 'retry', delayMs, resumeAt: now + delayMs, attempt, maxRetries: max };
   };
 
+  if ((err.status === 529 || err.overloaded) && maxRetries > 0) {
+    // Its own count: a pause starts the quick retries over (see streamMessage), and this one must not.
+    const n = state.overloaded = (state.overloaded || 0) + 1;
+    const base = config.overloadedRetryBaseDelay ?? 1000;
+    const cap = Math.max(base, config.overloadedRetryMaxDelay ?? 32_000);
+    const delayMs = Math.max(Math.min(cap, base * 2 ** (n - 1)) + Math.floor(rand() * 500), Math.min(err.retryAfterMs ?? 0, MAX_RETRY_AFTER_MS));
+    if (n <= maxRetries) return { action: 'wait', kind: 'retry', delayMs, resumeAt: now + delayMs, attempt: n, maxRetries };
+    const allowed = allowWait ? (config.overloadedMaxWait ?? budget) : 0;
+    const waited = state.overloadedWaitMs || 0;
+    if (waited + delayMs > allowed) {
+      return { action: 'throw', message: `${err.message} (the API was still overloaded after ${n - 1} retries${waited ? ` and ${humanDuration(waited)} of waiting` : ''})` };
+    }
+    state.overloadedWaitMs = waited + delayMs;
+    return { action: 'wait', kind: 'rate_limit', overloaded: true, delayMs, resumeAt: now + delayMs, resetAt: null, label: 'API overloaded', polling: true, attempt: n, maxRetries: null };
+  }
+
   if (err.status === 429 && allowWait && maxRetries > 0 && budget > 0) {
     const known = rl?.waitMs ?? null;
     if (known !== null && known < LONG_WAIT_MS) {
@@ -223,6 +244,7 @@ export function describePause(ev, now = Date.now()) {
   }
   const label = capitalize(ev.label || 'rate limit');
   const left = humanDuration(Math.max(0, ev.resumeAt - now));
+  if (ev.overloaded) return `The API is overloaded and kept refusing the request. Trying again at ${formatClock(ev.resumeAt, now)} (in ${left}), and every so often after that, then continuing automatically.`;
   const text = ev.polling
     ? `${label} reached and the server gave no reset time. Checking again at ${formatClock(ev.resumeAt, now)} (in ${left}), and every few minutes after that, then continuing automatically.`
     : `${label} reached. Pausing until ${formatClock(ev.resumeAt, now)} (in ${left}), then continuing automatically.`;
@@ -237,6 +259,8 @@ export function describePause(ev, now = Date.now()) {
 // announced reset moves a little between waits: those only continue the pause already announced,
 // unless the reset moved by more than two minutes. Waiting for the login to be renewed is a different
 // kind of wait from waiting for the limit, and always worth saying when it begins.
+export const resumeText = (ev) => (ev?.overloaded ? 'The API is answering again; continuing.' : 'The limit has cleared; continuing.');
+
 export function shouldAnnounce(prev, ev) {
   if (!prev) return true;
   if (Boolean(prev.waitingForLogin) !== Boolean(ev.waitingForLogin)) return true;

package/src/runtime.js

@@ -101,8 +101,10 @@ export async function createRuntime({ cwd, flags = {}, io }) {
     return true;
   };
 
-  runtime.spawnSubagent = async ({ def, prompt, description, ctx }) => {
-    const model = def.model ? config.resolveModel(def.model) : config.subagentModel;
+  // `model` and `effort`: what the Task call asked for, over the agent definition's own, over the session's.
+  runtime.spawnSubagent = async ({ def, prompt, description, ctx, model: modelSpec, effort }) => {
+    const spec = modelSpec || def.model;
+    const model = spec ? config.resolveModel(spec) : config.subagentModel;
     const subIo = io.subagentIo ? io.subagentIo({ def, description, parentCtx: ctx }) : {};
     // The main agent is depth 0; an agent below the nesting limit may start sub-agents itself.
     const depth = (ctx.depth ?? ctx.agent?.depth ?? 0) + 1;
@@ -120,6 +122,8 @@ export async function createRuntime({ cwd, flags = {}, io }) {
       cwd: ctx.cwd,
       name: def.name,
       hooks,
+      effort: effort || def.effort,
+      compactWindow: def.autoCompactWindow,
     });
     let result;
     try {

package/src/tools/files.js

@@ -32,9 +32,9 @@ function readText(file, buf = fs.readFileSync(file)) {
   return { text, bom: text !== raw, crlf: crlfCount > 0 && crlfCount >= bareLfCount };
 }
 
-export function numberLines(lines, start) {
+export function numberLines(lines, start, maxLineChars = MAX_LINE_CHARS) {
   return lines.map((l, i) => {
-    const line = l.length > MAX_LINE_CHARS ? l.slice(0, MAX_LINE_CHARS) + '… [line truncated]' : l;
+    const line = l.length > maxLineChars ? l.slice(0, maxLineChars) + '… [line truncated]' : l;
     return `${String(start + i).padStart(6)}\t${line}`;
   }).join('\n');
 }
@@ -63,6 +63,7 @@ Usage:
 - By default, it reads up to ${MAX_LINES} lines starting from the beginning of the file
 - You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
 - Any lines longer than ${MAX_LINE_CHARS} characters will be truncated
+- A file whose numbered text is longer than ${MAX_OUTPUT_CHARS} characters is refused (or cut there with offset/limit). When you need a large file whole, in one call, pass allow_large: true: then there is no line, character or line length limit, only the room left in the context, and a read that does not fit is refused. Prefer offset/limit or Grep when part of the file will do.
 - Results are returned using cat -n format, with line numbers starting at 1
 - This tool can read images (PNG, JPG, GIF, WEBP) and Jupyter notebooks (.ipynb)
 - This tool can only read files, not directories. To list a directory, use ls via the Bash tool.
@@ -74,6 +75,7 @@ Usage:
       file_path: { type: 'string', description: 'The absolute path to the file to read' },
       offset: { type: 'number', description: 'The line number to start reading from. Only provide if the file is too large to read at once' },
       limit: { type: 'number', description: 'The number of lines to read. Only provide if the file is too large to read at once.' },
+      allow_large: { type: 'boolean', description: 'Read past the usual size limits in one call (the whole file, or the whole offset/limit range, with long lines kept whole), when you need all of it and the context has room. Refused if it would not fit in the context left.' },
     },
     required: ['file_path'],
   },
@@ -125,19 +127,27 @@ Usage:
       seen(true);
       return { content: `<system-reminder>Warning: the file exists but is shorter than the provided offset (${start}). The file has ${lines.length} lines.</system-reminder>`, display: { summary: 'Read 0 lines' } };
     }
-    const limit = Math.max(1, Math.floor(input.limit || MAX_LINES));
+    // allow_large: no line, character or line length limit, only the room left in the context (see Agent.takeContext).
+    const large = input.allow_large === true;
+    const limit = Math.max(1, Math.floor(input.limit || (large ? Infinity : MAX_LINES)));
     const slice = lines.slice(start - 1, start - 1 + limit);
-    let content = numberLines(slice, start);
-    if (content.length > MAX_OUTPUT_CHARS && !input.limit) {
-      return { isError: true, content: `File content (${Math.round(content.length / 1024)}KB) exceeds the maximum allowed size. Use the offset and limit parameters to read specific portions of the file, or use the Grep tool to search for specific content.` };
+    let content = numberLines(slice, start, large ? Infinity : MAX_LINE_CHARS);
+    if (large) {
+      const fit = ctx.agent?.takeContext?.(content);
+      if (fit && !fit.ok) {
+        const n = (t) => t.toLocaleString('en-US');
+        return { isError: true, content: `File content (about ${n(fit.tokens)} tokens) does not fit in the context left (about ${n(Math.max(0, fit.room))} tokens before auto-compaction). Read the parts you need with offset and limit, or use the Grep tool to search for specific content.` };
+      }
+    } else if (content.length > MAX_OUTPUT_CHARS && !input.limit) {
+      return { isError: true, content: `File content (${Math.round(content.length / 1024)}KB) exceeds the maximum allowed size. Use the offset and limit parameters to read specific portions of the file, or use the Grep tool to search for specific content. If you need the whole file at once, pass allow_large: true.` };
     }
     let cut = false;
     let end = start + slice.length - 1;
-    if (content.length > HARD_MAX_CHARS) {
+    if (!large && content.length > HARD_MAX_CHARS) {
       const kept = content.slice(0, HARD_MAX_CHARS);
       const whole = kept.endsWith('\n'); // the cut fell between two lines
       end = start + (kept.match(/\n/g) || []).length - (whole ? 1 : 0); // the last line shown
-      content = `${kept}${whole ? '' : '\n'}… [output cut at ${HARD_MAX_CHARS} characters: line ${end} is the last one shown${whole ? '' : ', and only in part'}; read on from there with offset/limit]`;
+      content = `${kept}${whole ? '' : '\n'}… [output cut at ${HARD_MAX_CHARS} characters: line ${end} is the last one shown${whole ? '' : ', and only in part'}; read on from there with offset/limit, or pass allow_large: true to read it all at once]`;
       cut = true;
     }
     seen(cut || start > 1 || end < lines.length);

package/src/tools/search.js

@@ -385,6 +385,14 @@ Usage:
     },
     required: ['pattern'],
   },
+  // What a model used to grep (or to the Read tool) sometimes sends, taken as meant, as Claude Code does, instead of
+  // searching the working directory when it named a file_path: -l and -c pick the output mode, -r is the default.
+  normalizeInput(input) {
+    if (input.path == null && typeof input.file_path === 'string') input.path = input.file_path;
+    if (input.output_mode == null && input['-c']) input.output_mode = 'count';
+    else if (input.output_mode == null && input['-l']) input.output_mode = 'files_with_matches';
+    return input;
+  },
   summarize(input, ctx) {
     let s = `pattern: "${input.pattern}"`;
     if (input.path) s += `, path: "${displayPath(resolvePath(input.path, ctx.cwd), ctx.cwd)}"`;

package/src/tools/task.js

@@ -3,6 +3,7 @@
 // background tasks.
 
 import { taskResultText } from '../tasks.js';
+import { EFFORTS } from '../agents.js';
 
 // Wait for `promise`, at most `ms`, or until `signal` aborts. The timer is always cleared so a
 // finished wait never keeps the process alive.
@@ -52,16 +53,24 @@ Usage notes:
         prompt: { type: 'string', description: 'The task for the agent to perform' },
         subagent_type: { type: 'string', description: 'The type of specialized agent to use for this task' },
         run_in_background: { type: 'boolean', description: 'Run the agent in the background and return immediately with a task id' },
+        model: { type: 'string', description: 'Optional model for this agent: sonnet, opus, haiku or a full model id. Defaults to the agent definition\'s model, else the sub-agent default. A smaller model is cheaper and faster for simple searches.' },
+        effort: { type: 'string', enum: EFFORTS, description: 'Optional effort level for this agent (default: the agent definition\'s, else the session\'s). Low suits quick lookups, high or above hard reasoning.' },
       },
       required: ['description', 'prompt', 'subagent_type'],
     },
-    summarize(input) { return `${input.description || ''}${input.run_in_background ? ' (background)' : ''}`; },
+    summarize(input) {
+      const on = [input.model, input.effort].filter(Boolean).join(' · ');
+      return `${input.description || ''}${on ? ` (${on})` : ''}${input.run_in_background ? ' (background)' : ''}`;
+    },
     label(input) { return input.subagent_type && input.subagent_type !== 'general-purpose' ? input.subagent_type : 'Task'; },
     async call(input, ctx) {
       const def = agents.get(input.subagent_type) || agents.get('general-purpose');
       if (!agents.has(input.subagent_type) && input.subagent_type) {
         return { isError: true, content: `Agent type '${input.subagent_type}' not found. Available agents: ${[...agents.keys()].join(', ')}` };
       }
+      const effort = input.effort ? String(input.effort).toLowerCase() : undefined;
+      if (effort && !EFFORTS.includes(effort)) return { isError: true, content: `Unknown effort '${input.effort}'. Use one of: ${EFFORTS.join(', ')}.` };
+      const choice = { model: input.model?.trim() || undefined, effort };
       if (input.run_in_background) {
         if (!ctx.tasks) return { isError: true, content: 'Background agents are not available here; run the task in the foreground.' };
         // The task outlives this turn, so it gets its own signal and no live progress display.
@@ -69,7 +78,7 @@ Usage notes:
         const task = ctx.tasks.start({
           description: input.description || def.name,
           subagentType: def.name,
-          run: (signal) => ctx.spawnSubagent({ def, prompt: input.prompt, description: input.description, ctx: { ...base, signal } }),
+          run: (signal) => ctx.spawnSubagent({ def, prompt: input.prompt, description: input.description, ctx: { ...base, signal }, ...choice }),
         });
         return {
           content: `Started background agent ${task.id} (${def.name}): ${input.description}. Its final report will arrive in a <task-notification> when it finishes. Continue with other work; use TaskOutput with task_id "${task.id}" only if you need to wait for it.`,
@@ -77,7 +86,7 @@ Usage notes:
         };
       }
       const started = Date.now();
-      const { text, toolUses, tokens } = await ctx.spawnSubagent({ def, prompt: input.prompt, description: input.description, ctx });
+      const { text, toolUses, tokens } = await ctx.spawnSubagent({ def, prompt: input.prompt, description: input.description, ctx, ...choice });
       const secs = Math.round((Date.now() - started) / 100) / 10;
       const kTok = tokens >= 1000 ? `${(tokens / 1000).toFixed(1)}k` : String(tokens);
       return {

package/src/ui/editor.js

@@ -99,12 +99,32 @@ export class Editor {
 
   clear() {
     this.set('');
-    this.pastes.clear();
-    this.images.clear();
+    this.pastes = new Map();
+    this.images = new Map();
     this.imageCounter = 0;
     this.historyIndex = null;
   }
 
+  // Clear a draft the user threw away (ctrl+c, esc esc), as Claude Code does: up on the empty prompt brings it back,
+  // with its pasted text and images, even after other messages were sent meanwhile.
+  discard() {
+    if (this.text.trim()) {
+      this.cleared = { text: this.text, cursor: this.cursor, pastes: this.pastes, images: this.images, imageCounter: this.imageCounter };
+    }
+    this.clear();
+  }
+
+  restoreCleared() {
+    const d = this.cleared;
+    if (!d || this.text || this.historyIndex !== null) return false;
+    this.cleared = null;
+    this.pastes = d.pastes;
+    this.images = d.images;
+    this.imageCounter = d.imageCounter;
+    this.set(d.text, d.cursor);
+    return true;
+  }
+
   insertImage(image) {
     const label = `[Image #${++this.imageCounter}]`;
     this.images.set(label, image);
@@ -213,9 +233,9 @@ export class Editor {
     }
     if (name === 'escape') {
       if (this.suggestions) { this.suggestionsDismissedFor = this.text; this.suggestions = null; return true; }
-      if (key.meta && this.text) { this.clear(); return true; } // ESC ESC arriving in one chunk
+      if (key.meta && this.text) { this.discard(); return true; } // ESC ESC arriving in one chunk
       const now = Date.now();
-      if (this.text && now - this.lastEscape < 800) { this.clear(); this.lastEscape = 0; return true; }
+      if (this.text && now - this.lastEscape < 800) { this.discard(); this.lastEscape = 0; return true; }
       this.lastEscape = now;
       return false;
     }
@@ -228,7 +248,7 @@ export class Editor {
         this.set(this.text, Math.min(prevStart + col, lineStart - 1));
         return true;
       }
-      return this.historyPrev();
+      return this.restoreCleared() || this.historyPrev();
     }
     if (name === 'down' || (key.ctrl && name === 'n')) {
       if (this.suggestions) { this.selected = (this.selected + 1) % this.suggestions.items.length; this.onChange?.(); return true; }

package/src/ui/repl.js

@@ -24,7 +24,7 @@ import { buildCommands } from '../commands.js';
 import { canRestart, writeRestartState, runSelfCheck, watchSource, restartNote, RESTART_EXIT_CODE, MAX_RESTARTS, RESTART_WINDOW_MS } from '../restart.js';
 import { resolvePath, displayPath } from '../utils/paths.js';
 import { ripgrepPath } from '../utils/shell.js';
-import { describePause, formatClock, humanDuration, shouldAnnounce } from '../ratelimit.js';
+import { describePause, formatClock, humanDuration, resumeText, shouldAnnounce } from '../ratelimit.js';
 import { shutdownBackgroundShells, listBackgroundShells } from '../tools/bash.js';
 import { estimateTokens } from '../agent.js';
 import { readClipboardImage, imageFromFile, watchClipboard } from '../utils/clipboard.js';
@@ -625,7 +625,7 @@ export class App {
       return;
     }
     if (this.busy) { this.interrupt(); return; }
-    if (this.editor.text) { this.editor.clear(); this.screen.schedule(); return; }
+    if (this.editor.text) { this.editor.discard(); this.screen.schedule(); return; }
     if (Date.now() - this.exitArmed < 1500) { this.exit(0); return; }
     this.exitArmed = Date.now();
     this.screen.schedule();
@@ -1149,12 +1149,12 @@ export class App {
   rateLimitEvent(ev) {
     if (ev.type === 'rate_limit_resume') {
       this.rateWait = null;
-      this.notice('The limit has cleared; continuing.');
+      this.notice(resumeText(ev));
       return;
     }
     // Say it once; later waits of the same pause only move the countdown (unless the reset moved a lot).
     const prev = this.rateWait;
-    this.rateWait = { resumeAt: ev.resumeAt, label: ev.label, polling: ev.polling, waitingForLogin: Boolean(ev.waitingForLogin) };
+    this.rateWait = { resumeAt: ev.resumeAt, label: ev.label, polling: ev.polling, waitingForLogin: Boolean(ev.waitingForLogin), overloaded: Boolean(ev.overloaded) };
     if (shouldAnnounce(prev, ev)) this.notice(`${describePause(ev)} Esc cancels.`, 'warn');
     this.screen.schedule();
   }
@@ -1238,7 +1238,7 @@ export class App {
       }
       if (ev.type === 'rate_limit_resume') {
         paused = null;
-        app.notice(`[${def.name}] The limit has cleared; continuing.`);
+        app.notice(`[${def.name}] ${resumeText(ev)}`);
       }
     };
     return {
@@ -1321,7 +1321,7 @@ export class App {
       if (w.waitingForLogin) return c.yellow(`${frame} Waiting for the Claude Code login to be renewed · checking again in ${left}`) + ' ' + esc;
       const label = w.label.charAt(0).toUpperCase() + w.label.slice(1);
       const when = w.polling ? `checking again in ${left}` : `resumes at ${formatClock(w.resumeAt)} (in ${left})`;
-      return c.yellow(`${frame} ${label} reached · ${when}`) + ' ' + esc;
+      return c.yellow(`${frame} ${w.overloaded ? label : `${label} reached`} · ${when}`) + ' ' + esc;
     }
     const secs = formatDuration(Date.now() - this.turnStart);
     const verb = this.status || (this.thinking ? 'Thinking' : this.verb);