@keyou007/agent-bot 0.1.24-alpha.8 → 0.1.25-alpha.0

package/CHANGELOG.md

@@ -6,6 +6,34 @@ The project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.25-alpha.0] - 2026-10-30
+
+- 修复合并转发聊天记录中的图片、文件下载失败：改用外层消息 ID 读取资源，同时覆盖直接转发和引用聊天记录，保留用户正文为主 Prompt。
+- Fix image and file downloads in merged-forward chat records by using the container message ID, including quoted records, while keeping the user's instruction as the main Prompt.
+
+- 统一引用消息处理：不再按类型筛选待合并消息，普通文字和纯链接也可与同一用户、同一会话的显式引用附言合并；以当前正文作为主 Prompt 和卡片标题，保留引用资源、Reaction 和旧消息引用行为。
+- Unify quoted-message pairing across message types, including plain text and URLs: use the explicitly linked current instruction as the Prompt/card title, preserving reference resources, reactions, and older-quote behavior.
+
+- Add minimal delayed-Feishu-message diagnostics: retain source timestamps and event IDs in existing audits, with one content-free warning only for newly accepted messages delayed by at least one minute. Message handling remains unchanged.
+
+## [0.1.24] - 2026-10-24
+
+### 中文
+
+- 修复 Turn Preview 只有思考标题、没有正文时仍显示空折叠箭头的问题；后续收到正文才启用展开，保留实时局部更新及飞书思考卡片行为。
+- 修复飞书 SDK 展平事件 ID 后，新建目录按钮因固定名称被误去重而失效的问题；创建成功后原文件浏览卡片进入新目录，不改变任务工作目录。
+- 允许无轮次、分支历史或 Goal 的空会话切换 Provider：验证目标设置后更换底层线程，保留本地任务和群绑定，失败保留原会话。
+- Codex 遇到特定的 Responses 续接状态失效时，在原任务中自动尝试一次空输入续接，保留历史和已完成的工具结果，不重发 Prompt/图片；尊重取消、Reset、设置变化和任务接管。
+- 修复思考卡片及 Preview 重复显示同一运行警告与最终错误，实时更新移除重复项；提取结构化错误的可读信息并保留原始诊断记录。
+
+### English
+
+- Render title-only reasoning in Turn Preview without an empty disclosure or detail request; enable expansion when a body arrives, preserving live incremental updates and Feishu thinking cards.
+- Fix folder creation being silently deduplicated by the button's fixed name after the Feishu SDK flattens event IDs; open the created directory in the same browser card without changing the task's working directory.
+- Allow verified empty tasks without Turns, inherited history, or a Goal to switch Providers through a new remote thread, preserving local task/chat bindings and retaining the original on failure.
+- Recover a specific Codex Responses continuation-state rejection once with empty input on the same task, preserving history and completed tool outputs without replaying the Prompt/images; honor cancellation, Reset, settings changes, and newer work.
+- Deduplicate matching runtime warnings and final errors in thinking cards and Preview, including live updates; display readable structured error details while retaining original diagnostic records.
+
 ## [0.1.24-alpha.8] - 2026-10-19
 
 ### 中文

package/README.md

@@ -282,6 +282,8 @@ Renaming a Feishu group updates its currently bound task title, even when you re
 
 Private chats, group timelines, and topics keep separate current tasks. A new topic remains unbound while you use commands such as `/help`, `/status`, or `/sessions`; those commands do not create a hidden fork. Its first ordinary message forks from the mapped source turn, or starts a fresh task when no source turn can be identified. `/new` starts a fresh topic task, while `/sessions` can bind an existing task. Commands that require a current task explain how to bind one instead of operating on the parent conversation. Ordinary messages sent while a task is running add instructions to that turn; use `/queue` when the message should run afterward as a separate turn.
 
+For delayed-message diagnosis, existing incoming-message audits include the Feishu creation time, SDK callback time, and event ID when available. Only newly accepted messages delayed by at least one minute emit a warning, without message content; normal messages and duplicate deliveries add no log lines. These diagnostics do not reject or reorder messages, and SDK callback time does not identify when the WebSocket frame reached the host.
+
 `/release` sends a card for releasing the shared App Server used by the current task's Agent so its tasks can be opened in Codex Desktop. The card lists blocking task names and keeps them updated. Agent Bot never releases automatically: click **Release** when idle, or **Release Now** to interrupt active work and clear queued Prompts. **Cancel** cancels the pending release. Releasing does not archive or delete task history, but it affects every task loaded by that shared App Server.
 
 Topic replies check whether the root message is already in the task's history using lightweight Turn links, without loading the full history before sending the thinking card. Legacy parent links are repaired only when needed.
@@ -292,6 +294,8 @@ Only groups explicitly enabled with `/mute` or `/mute on` supplement ordinary @-
 
 `/new` and `/newgroup` use the conversation's default Agent unless `--agent <name>` selects another configured Agent for this task only; the source conversation's default is unchanged. For example, `/new Fix tests --agent codex` or `/newgroup Review --agent traex --dir ~/dev/project`. They inherit the current project; execution settings are inherited only when the selected Agent matches the current task's Agent, otherwise Provider, model, reasoning, and permission mode use the target Agent's saved defaults. Use `--dir` to choose another directory or `--nodir` to start without a project directory; `--nodir` requires the selected Agent to be App Server, and `~` represents your home directory.
 
+`/dir` opens the file browser. `NewFolder` creates a child directory and opens it in the same card at page one, without changing the task's working directory. `Back` cancels creation and restores the previous directory and page.
+
 `/file` accepts relative paths, absolute paths, and paths beginning with `~`; relative paths resolve from the current task directory.
 
 `/fork` and `/forkgroup` branch from completed work without interrupting a running turn. `/sessions` manages tasks across projects and Providers in pages of up to 10 tasks; switching Provider does not hide a task from the list or search. Use each project menu for `New` and `NewGroup`. Each task’s `SwitchGroup` action creates a new group bound to that same task, preserving its history, title, and execution settings without creating or forking an Agent task. The original conversation stays unchanged. An Agent Bot Turn already in progress keeps replying to its original conversation; new messages from the new group queue until it finishes. Tasks running in an external client cannot be switched until they finish. Expanding a task directly shows the first 50 characters of its latest user Prompt, its update time, and task-specific actions. Running tasks also show a direct `Stop` button, including the current task and tasks running in other conversations or external clients. It sends the normal Agent interrupt without switching tasks or killing processes. The list refresh preserves search and pagination and keeps Stop available until the Agent reports the task idle; Archive is available only when idle. Use `Turns` to view that task’s history without switching tasks, including tasks not yet bound to Agent Bot; non-current tasks are read-only until you switch to them. `/turns` restores conversation context without reverting local files.
@@ -400,17 +404,19 @@ For App Server tasks, permission changes apply both approval and sandbox policie
 
 The execution settings card ends with a one-sentence Markdown blockquote for the selected tab's scope and timing. Agent selection changes only the default for new tasks in that conversation, without migrating the current task. Model, reasoning, and permission changes apply from the next turn. Agent and Provider options show their identifiers without duplicate display names, while retaining current/default indicators. `/provider` opens this card even when only one Provider is available, keeping the Model, Thinking, and Permission tabs accessible.
 
-Provider changes requested during an Agent Bot turn are saved as pending without interrupting it. The settings card immediately shows the target Provider and the model that will be used; the Model tab lists that Provider’s models, and later selections replace the pending choice. Thinking and permission changes made while a Provider switch is pending are staged with it. The switch is applied after the current turn ends, before a queued, retried, or new turn starts; idle tasks switch immediately. Pending settings survive restarts and do not overwrite active settings or Agent defaults until applied. If a deferred switch fails, Agent Bot restores the previous Provider and model. After verified rollback, the card returns to the original settings with an error notice, clears the pending choice, and queued/new turns continue using the original settings. Only failed or unverified rollback pauses further turns and keeps queued prompts for manual recovery. For a custom Provider, Agent Bot uses its OpenAI-compatible `/models` endpoint when available and shows only that Provider's models. A switch keeps the previous model when the target supports it, otherwise selects the target's default model or its first returned model. Providers without a model-list endpoint remain usable: Agent Bot keeps the current or configured model as the single fallback candidate and lets Codex apply it. Agent Bot verifies the task ID, Provider, and model before saving or reporting success. Settings changes always preserve the remote thread ID and all history, including failed and interrupted Turns. They never start, fork, truncate, or replace a thread. A pristine thread without a saved rollout is refused before detaching rather than silently replaced. If a switch fails, the previous settings are retained and remote recovery is attempted. If recovery also fails, further turns are blocked until a Provider switch succeeds.
+Provider changes requested during an Agent Bot turn are saved as pending without interrupting it. The settings card immediately shows the target Provider and the model that will be used; the Model tab lists that Provider’s models, and later selections replace the pending choice. Thinking and permission changes made while a Provider switch is pending are staged with it. The switch is applied after the current turn ends, before a queued, retried, or new turn starts; idle tasks switch immediately. Pending settings survive restarts and do not overwrite active settings or Agent defaults until applied. If a deferred switch fails, Agent Bot restores the previous Provider and model. After verified rollback, the card returns to the original settings with an error notice, clears the pending choice, and queued/new turns continue using the original settings. Only failed or unverified rollback pauses further turns and keeps queued prompts for manual recovery. For a custom Provider, Agent Bot uses its OpenAI-compatible `/models` endpoint when available and shows only that Provider's models. A switch keeps the previous model when the target supports it, otherwise selects the target's default model or its first returned model. Providers without a model-list endpoint remain usable: Agent Bot keeps the current or configured model as the single fallback candidate and lets Codex apply it. Agent Bot verifies the task ID, Provider, and model before saving or reporting success. Tasks with history always preserve their remote thread ID and all history, including failed and interrupted Turns. Before the first message, a verified empty task without inherited history or a Goal may switch through a new remote thread, keeping the same local task, conversation, directory, and title. The old thread remains attached until the new Provider/model and persistence succeed; failure keeps the original task. No synthetic Prompt or history rewrite is used. If a switch fails, the previous settings are retained and remote recovery is attempted. If recovery also fails, further turns are blocked until a Provider switch succeeds.
 
 For TraeX's built-in `trae` Provider, Agent Bot uses the complete native `model/list` catalog, including model names and reasoning options, without requiring a custom Provider `base_url`. Other custom Providers keep their own model discovery and fallback behavior.
 
-If Provider model discovery fails, settings cards retain the fallback model but show the failure and warn that service availability is unconfirmed. A successful settings change verifies configuration, not a live inference request. App Server runtime errors and native retry notices show the message and any `additionalDetails` in the existing progress card and Preview, including upstream error codes and retry delays when supplied. Error text is displayed literally, duplicate details are omitted, and long reasons remain available in Preview and activity history. Missing details are not guessed, and previously saved snapshots are not backfilled. Retrying does not create another card or end the turn; the final turn notification still determines success, failure, or cancellation.
+If Provider model discovery fails, settings cards retain the fallback model but show the failure and warn that service availability is unconfirmed. A successful settings change verifies configuration, not a live inference request. App Server runtime errors and native retry notices show the message and any `additionalDetails` in the existing progress card and Preview, including upstream error codes and retry delays when supplied. Error text is displayed literally, duplicate details are omitted, and long reasons remain available in Preview and activity history. Missing details are not guessed. Native retries do not create another card or end the turn; the final turn notification still determines success, failure, or cancellation. If the final failure repeats the preceding runtime warning, cards and Preview display it only once; the original execution record is retained.
+
+For Codex's specific `unsupported_persisted_item_context` continuation failure, Agent Bot attempts one empty-input continuation in the same task, preserving history and completed tool results without resending your Prompt or images. This creates a new Turn and progress card, not a new task or Fork. If recovery fails, the error remains visible and you can send a message to continue. See the [technical reference](docs/technical-reference.md#responses-continuation-recovery) for recovery limits.
 
 Some Responses-compatible Providers omit assistant message phases. Their text stays in the progress timeline instead of being concatenated into a premature final answer. On successful completion, only the last unphased message not followed by a tool start becomes the final answer; explicit `commentary` and `final_answer` phases take precedence. Cards and Preview share this classification. Previously saved snapshots are not automatically rewritten.
 
 `feishu.groupNameFormat` defines separate name templates for new Project and Projectless groups, with variables for the operating system, Agent, project, task name, and date. See the [technical reference](docs/technical-reference.md#configuration-model) for the complete format.
 
-If App Server ignores the requested Provider/model, Agent Bot reports the requested and actual settings and verifies restoration on the same thread. It never forks to bypass an upstream limitation. Provider switching releases and resumes only the selected task, preserving its ID and history while other tasks keep running. It does not restart the shared App Server. If the selected task cannot unload, Agent Bot reports the failure and attempts to restore its previous settings. Settings pages can load saved task metadata without first resuming a broken old Provider; ordinary resume/reconnect verifies thread identity and known Provider before allowing a new Turn. Permanent authentication failures are not automatically retried by Agent Bot.
+If App Server ignores the requested Provider/model, Agent Bot reports the requested and actual settings and verifies restoration on the same thread. It never forks to bypass an upstream limitation. Provider switching releases and resumes only the selected task, preserving existing history while other tasks keep running; only verified empty tasks may receive a new remote thread ID. It does not restart the shared App Server. If the selected task cannot unload, Agent Bot reports the failure and attempts to restore its previous settings. Settings pages can load saved task metadata without first resuming a broken old Provider; ordinary resume/reconnect verifies thread identity and known Provider before allowing a new Turn. Permanent authentication failures are not automatically retried by Agent Bot.
 
 Agent processes inherit ordinary parent-process variables and their explicit `agents.<name>.env` settings. Before starting an Agent, Agent Bot removes inherited `FEISHU_*` credentials and internal `AGENT_BOT_*` state, then provides only namespaced, non-secret Profile and Lark identity context. `FEISHU_APP_SECRET` is never forwarded to an Agent process.
 
@@ -424,11 +430,11 @@ Thinking cards use the grouped layout by default: auxiliary Commentary and user
 
 Whitespace-only Commentary does not use a pinned message slot. Adjacent omission markers generated by the card are shown once, without removing literal message text or changing saved history.
 
-Turn Preview shows each saved reasoning item in a collapsed panel. A leading Markdown heading or standalone bold title appears directly in the header; expanding shows the remaining summary and content without extra Summary/Content labels or a repeated title. Items without an explicit title keep the Reasoning fallback and all original text. Collapsed panels load their full Markdown on expansion and retain expansion during live updates. Reasoning content and authoritative completed items are stored separately from card activities; this does not change thinking-card titles, grouping, or final replies. Existing saved summaries remain viewable, but previously unrecorded content is not backfilled from Agent history.
+Turn Preview shows saved reasoning with a body in a collapsed panel. A leading Markdown heading or standalone bold title appears directly in the header; expanding shows the remaining summary and content without extra Summary/Content labels or a repeated title. Title-only items remain visible as non-interactive rows without a disclosure arrow or detail request; live updates add a disclosure if a body arrives later. Items without an explicit title keep the Reasoning fallback and all original text. Collapsed panels load their full Markdown on expansion and retain expansion during live updates. Reasoning content and authoritative completed items are stored separately from card activities; this does not change thinking-card titles, grouping, or final replies. Existing saved summaries remain viewable, but previously unrecorded content is not backfilled from Agent history.
 
-Quoted cards and cards inside merged forwards include their available original text and images in the Agent's context.
+Quoted cards and cards inside merged forwards include their available original text and images in the Agent's context. Images and files in forwarded chat records are downloaded as reference attachments, including when you quote the chat record with your own instruction.
 
-When forwarding rich text, images, files, or chat records with an attached message, Agent Bot combines the associated messages into one request: your attached text is the main Prompt, and the forwarded content remains reference material.
+When you quote a message, your current message body is the main Prompt; the quoted content remains reference material regardless of its type. Ordinary Feishu messages, including plain text and links, briefly wait up to 1.5 seconds after acknowledgement for an explicitly linked follow-up from the same sender in the same conversation. A matching follow-up combines them into one request and supplies the card Prompt. Commands do not wait. Quotes of older or already-submitted messages use normal quoting/steering without replacing completed history.
 
 File-change summaries display paths as plain text, preserving Windows separators and literal underscores (including `\__init__.py`) instead of interpreting them as Markdown formatting.
 

package/README.zh.md

@@ -279,6 +279,8 @@ agentbot task dismiss [任务] --yes
 
 私聊、群正文和话题分别维护当前任务。新话题在执行 `/help`、`/status` 或 `/sessions` 等命令时保持未绑定状态，不会暗中创建分支；收到第一条普通消息后，才会从可识别的原始 turn 创建分支，无法识别来源时则创建全新任务。使用 `/new` 可以直接创建全新话题任务，使用 `/sessions` 可以绑定现有任务；依赖当前任务的命令会提示如何绑定，而不会操作父会话任务。任务运行时发送普通消息会向当前轮次追加指令；需要在本轮结束后独立执行时，使用 `/queue`。
 
+排查迟到消息时，复用现有接收审计记录，补充飞书创建时间、SDK 回调时间及事件 ID（上游提供时）。仅首次接收且延迟达到 1 分钟的消息额外记录一条告警，不含消息正文；正常消息和重复投递不增加日志条目。不改变接收、执行或消息顺序；SDK 回调时间不代表 WebSocket 帧抵达本机的时间。
+
 `/release` 会发送当前任务所属 Agent 共享 App Server 的释放卡片，以便在 Codex Desktop 中打开这些任务。卡片会列出并持续刷新阻塞释放的任务名。Agent Bot 不会自动释放：空闲时点击 **Release**，有活动任务时点击 **Release Now** 会中断执行并清除排队 Prompt；**Cancel** 会取消本次释放。释放不会归档或删除任务历史，但会影响该 App Server 已加载的所有任务。
 
 Fork 只记录来源任务和分支轮次，不同步完整历史。普通任务和分支任务的 `/turns` 都按需要读取摘要分页，翻页才继续读取较早轮次；分支历史不会越过分支轮次。本地卡片只读取关系索引和当前页 Prompt 摘要，不加载历史工具输出。任务列表只读最近一轮摘要，目录等元数据查询不读轮次；状态与恢复只读最近一轮的完整结果，并复用状态校准结果。活跃检测复用未变化的日志，只增量扫描追加内容。
@@ -293,6 +295,8 @@ Fork 只记录来源任务和分支轮次，不同步完整历史。普通任务
 
 `/new` 和 `/newgroup` 默认使用当前会话设置的默认 Agent，也可用 `--agent <名称>` 为本次任务指定已配置的 Agent，不改变源会话的默认值。例如：`/new 修复测试 --agent codex`、`/newgroup 代码审查 --agent traex --dir ~/dev/project`。项目目录仍继承当前任务；选中的 Agent 与当前任务相同时继承运行设置，不同时使用目标 Agent 已保存的 Provider、模型、思考强度和权限默认值。使用 `--dir` 指定其他目录，或使用 `--nodir` 创建无项目目录的任务；`--nodir` 要求选中的 Agent 为 App Server，`~` 表示用户主目录。
 
+`/dir` 打开文件浏览卡片。`NewFolder` 创建子目录后，原卡片直接进入新目录的第一页，不改变任务工作目录；`Back` 取消创建并回到原目录和页码。
+
 `/file` 支持相对路径、绝对路径和以 `~` 开头的用户目录路径；相对路径以当前任务目录为基准。
 
 `/fork` 和 `/forkgroup` 会从已完成的工作创建分支，不会中断正在执行的轮次。`/sessions` 用于跨项目、跨 Provider 管理任务，每页最多显示 10 个任务；切换 Provider 不会让任务从列表或搜索结果中消失。项目菜单提供 `New` 和 `NewGroup`。每个任务的 `SwitchGroup` 会创建新群并绑定同一个任务，保留历史、标题和运行设置，不创建新 Agent 任务，也不 fork，原会话绑定不变。若任务正在 Agent Bot 中执行，本轮回复仍留在原会话，新群发来的消息先排队；正在外部客户端执行的任务需要等待完成后再切换。展开任务后会直接显示最后一个用户 Prompt 的前 50 个字符、更新时间以及任务级操作。运行中任务还会显示独立的 `Stop` 按钮，包括当前任务、其他会话和外部客户端中的任务；点击发送正常的 Agent 中断信号，不切换任务、不结束进程。列表刷新保留搜索条件和页码，并根据 Agent 的实际状态保留或移除 Stop；空闲后才提供 Archive。点击 `Turns` 可查看对应任务的轮次，包括尚未绑定到 Agent Bot 的任务，不会切换当前任务；非当前任务仅供查看，需要先切换任务才能 Reset。`/turns` 用于恢复对话上下文，不会回退本地文件。
@@ -345,7 +349,7 @@ Agent Bot 将用户相关文件保存在仓库之外：
 
 `/status` 状态卡片底部也提供 **Preview**，与 Refresh、Stop/Switch 放在同一行。点击可查看正在执行的轮次，空闲时则查看最近一轮；刷新卡片后会更新目标。对于尚未被 Agent Bot 记录的外部任务，打开 Preview 时会从 Agent 按需读取所选轮次并缓存完整执行详情；读取失败可刷新页面重试。没有轮次、无法读取历史且无本地记录，或文件预览服务不可用时不显示按钮。查看其他任务的状态不会切换或接管任务。
 
-思考卡片底部操作区提供 `Preview` 按钮，可在浏览器中查看本轮已保存的执行时间线，采用紧凑布局并适配手机，思考块直接以内容标题作为折叠标题，展开后显示内容。工具块只有一级折叠，默认只显示有意义的单行命令摘要、简短耗时（如 `58s` 或 `2:32`）和完成状态。展开后先显示以 `$` 开头的完整命令，随后直接显示结果、图片和修改文件。相同的输出和错误日志只显示一次。执行中的 Turn 会通过局部更新实时显示变化，保留手动展开状态、滚动位置和未变化的图片节点，避免图片反复加载；Token 等元数据更新不会替换时间线。折叠工具块和文件变更汇总首屏只加载摘要，展开时才请求命令、日志、图片和文件列表；再次展开复用已加载内容，运行中只刷新已展开且内容变化的详情，加载失败可点击重试。已结束的 Turn 不再建立 SSE 实时连接。“正在等待 Agent 返回进度”只在尚无可显示进度时出现，已有回答、其他可见进展或 Turn 已结束时不再显示。点击文件变更列表或工具文件列表中的文件，可在新标签页预览其当前内容；已删除或不可用的文件保留为路径文字。Turn Preview 与本地文件链接共用相同的签名、访问地址和网络范围。“最终回答”旁提供下载、复制两个图标，导出原始 Markdown（保留格式、代码块和原始链接），而非渲染后的网页内容。下载为 UTF-8 `.md` 文件；复制支持 HTTP/局域网页面的回退方式，并显示成功或失败提示。已结束页面及实时到达的最终回答均可使用。
+思考卡片底部操作区提供 `Preview` 按钮，可在浏览器中查看本轮已保存的执行时间线，采用紧凑布局并适配手机，思考块直接以内容标题作为折叠标题，展开后显示内容。只有标题而没有正文时保留普通标题行，不显示折叠箭头、不请求详情；实时更新收到正文后才变为可展开项。工具块只有一级折叠，默认只显示有意义的单行命令摘要、简短耗时（如 `58s` 或 `2:32`）和完成状态。展开后先显示以 `$` 开头的完整命令，随后直接显示结果、图片和修改文件。相同的输出和错误日志只显示一次。执行中的 Turn 会通过局部更新实时显示变化，保留手动展开状态、滚动位置和未变化的图片节点，避免图片反复加载；Token 等元数据更新不会替换时间线。折叠工具块和文件变更汇总首屏只加载摘要，展开时才请求命令、日志、图片和文件列表；再次展开复用已加载内容，运行中只刷新已展开且内容变化的详情，加载失败可点击重试。已结束的 Turn 不再建立 SSE 实时连接。“正在等待 Agent 返回进度”只在尚无可显示进度时出现，已有回答、其他可见进展或 Turn 已结束时不再显示。点击文件变更列表或工具文件列表中的文件，可在新标签页预览其当前内容；已删除或不可用的文件保留为路径文字。Turn Preview 与本地文件链接共用相同的签名、访问地址和网络范围。“最终回答”旁提供下载、复制两个图标，导出原始 Markdown（保留格式、代码块和原始链接），而非渲染后的网页内容。下载为 UTF-8 `.md` 文件；复制支持 HTTP/局域网页面的回退方式，并显示成功或失败提示。已结束页面及实时到达的最终回答均可使用。
 
 Turn Preview 完整保留已记录的执行内容，不再反复把整轮内容写入数据库。页面按增量实时更新，折叠工具展开时加载完整详情。备份时请保留整个 Profile 数据目录，以同时保存执行记录和任务信息；已有历史仍可查看。
 
@@ -391,17 +395,19 @@ App Server 任务切换权限时，下一轮会同时应用审批与沙箱策略
 
 运行设置卡片末尾以 Markdown 引用块显示当前选项页的一句重点提示，标明作用范围和生效时机。Agent 只改变本聊天或话题中新任务的默认 Agent，不迁移当前任务；模型、思考强度和权限从下一轮生效。Agent 和 Provider 选项只显示标识，去掉重复的展示名称，保留当前与默认状态标记。只有一个 Provider 时，`/provider` 仍会打开运行设置卡片，可以继续切换到 Model、Thinking 和 Permission 页。
 
-任务正在 Agent Bot 中执行时，切换 Provider 会保存为待生效设置，不中断本轮。运行设置卡片立即显示目标 Provider 和将使用的模型，Model 页切换为该 Provider 的模型列表，可继续选择，以最后选择为准；此时修改思考强度和权限也一起暂存。本轮结束后、排队消息、重试或新轮次开始前实际应用，空闲任务则立即切换。待生效设置重启后保留，应用前不改动实际运行设置或 Agent 默认值。如果延迟切换失败，自动回退之前的 Provider 和模型；确认回退成功后，卡片恢复显示原设置并提示失败原因，清除待生效选择，排队消息和后续轮次继续使用原设置。只有回退也失败或无法确认时才暂停后续轮次、保留排队消息，等待重新选择恢复。对于自定义 Provider，Agent Bot 会在接口可用时读取其 OpenAI 兼容 `/models` 接口，并只展示该 Provider 返回的模型。切换时优先保留目标 Provider 也支持的原模型；否则选择目标 Provider 的默认模型，没有默认模型时选择返回列表中的第一个模型。未提供模型列表接口的 Provider 仍可使用：Agent Bot 会把当前或已配置模型作为唯一候选交给 Codex 应用。Agent Bot 校验任务 ID、Provider 和模型后才保存并提示成功。设置切换始终保留远端线程 ID 和全部历史，包括失败、中断的轮次；绝不新建、Fork、截断或替换线程。尚未保存 rollout 的全新空会话会在取消订阅前明确拒绝切换，不会偷偷替换。切换失败时保留原设置并尝试恢复远端；如果恢复也失败，将阻止后续执行，直到重新切换 Provider 成功。
+任务正在 Agent Bot 中执行时，切换 Provider 会保存为待生效设置，不中断本轮。运行设置卡片立即显示目标 Provider 和将使用的模型，Model 页切换为该 Provider 的模型列表，可继续选择，以最后选择为准；此时修改思考强度和权限也一起暂存。本轮结束后、排队消息、重试或新轮次开始前实际应用，空闲任务则立即切换。待生效设置重启后保留，应用前不改动实际运行设置或 Agent 默认值。如果延迟切换失败，自动回退之前的 Provider 和模型；确认回退成功后，卡片恢复显示原设置并提示失败原因，清除待生效选择，排队消息和后续轮次继续使用原设置。只有回退也失败或无法确认时才暂停后续轮次、保留排队消息，等待重新选择恢复。对于自定义 Provider，Agent Bot 会在接口可用时读取其 OpenAI 兼容 `/models` 接口，并只展示该 Provider 返回的模型。切换时优先保留目标 Provider 也支持的原模型；否则选择目标 Provider 的默认模型，没有默认模型时选择返回列表中的第一个模型。未提供模型列表接口的 Provider 仍可使用：Agent Bot 会把当前或已配置模型作为唯一候选交给 Codex 应用。Agent Bot 校验任务 ID、Provider 和模型后才保存并提示成功。已有历史的任务切换时保留远端线程 ID 和全部历史，包括失败、中断的轮次。首次发消息前，确认没有历史、分支来源或 Goal 的空会话可通过新建底层线程切换 Provider，本地任务、群聊/话题绑定、目录和标题保持不变；新 Provider/模型及持久化成功前保留原线程，失败仍使用原会话，不发送虚构 Prompt 或改写历史。切换失败时保留原设置并尝试恢复远端；如果恢复也失败，将阻止后续执行，直到重新切换 Provider 成功。
 
 `feishu.groupNameFormat` 可分别设置 Project 与 Projectless 新群的名称模板，支持系统、Agent、项目、任务名和日期变量。完整格式说明见[技术参考](docs/technical-reference.zh.md#配置模型)。
 
 TraeX 内置的 `trae` Provider 直接使用原生 `model/list` 返回的完整模型列表，保留模型名称和思考强度选项，不要求配置自定义 Provider 的 `base_url`。其他自定义 Provider 的模型发现和降级行为保持不变。
 
-Provider 模型列表读取失败时，设置卡片保留降级候选模型，同时显示失败原因并提示服务可用性未确认。切换成功只代表配置已通过校验，不代表实际模型请求可用。App Server 执行错误和原生重试通知会在同一张思考卡片和 Preview 中显示消息及 `additionalDetails`，包括 Agent 提供的上游错误码和重试等待时间。错误按纯文本展示，重复详情不重复显示，长原因可在 Preview 和思考活动历史中查看。缺少详情时不猜测原因，不自动回填此前保存的快照。重试不会新建卡片或提前结束任务，最终完成通知仍决定成功、失败或取消状态。
+Provider 模型列表读取失败时，设置卡片保留降级候选模型，同时显示失败原因并提示服务可用性未确认。切换成功只代表配置已通过校验，不代表实际模型请求可用。App Server 执行错误和原生重试通知会在同一张思考卡片和 Preview 中显示消息及 `additionalDetails`，包括 Agent 提供的上游错误码和重试等待时间。错误按纯文本展示，重复详情不重复显示，长原因可在 Preview 和思考活动历史中查看。缺少详情时不猜测原因。原生重试不会新建卡片或提前结束任务，最终完成通知仍决定成功、失败或取消状态。最终错误与此前的运行警告相同时，卡片和 Preview 只显示一次，原始执行记录仍然保留。
+
+Codex 出现特定的 `unsupported_persisted_item_context` 续接失败时，Agent Bot 会在同一任务中自动尝试一次空输入续接，保留历史和已完成的工具结果，不重发用户的 Prompt 或图片。它会新增一个轮次及思考卡片，不会新建任务或 Fork。恢复失败时仍显示错误，可以发送消息继续。恢复边界见[技术参考](docs/technical-reference.zh.md#responses-续接恢复)。
 
 部分 Responses 兼容 Provider 不返回助手消息阶段。这类文本先按顺序显示在进度时间线，不再提前拼接成最终回答；轮次成功结束时，只有最后一条且之后未开始工具调用的未标记消息会成为最终回答。明确的 `commentary` 和 `final_answer` 标记优先。思考卡片和 Preview 使用同一分类结果，不自动改写此前保存的快照。
 
-如果 App Server 忽略指定的 Provider 或模型，Agent Bot 会报告请求值和实际值，并在同一线程上验证恢复原设置，绝不通过 Fork 绕过上游限制。切换 Provider 只释放并恢复当前任务，保留其 ID 和历史，其他任务可以继续执行；不会因此重启共享 App Server。若目标任务无法卸载，会提示失败并尝试恢复原设置。设置入口可直接加载保存的任务元数据，无需先用故障的旧 Provider 恢复任务；普通恢复和断线重连会验证线程 ID 与已知 Provider，再允许发起新轮次。明确的认证失败不再触发 Agent Bot 自动重试。
+如果 App Server 忽略指定的 Provider 或模型，Agent Bot 会报告请求值和实际值，并在同一线程上验证恢复原设置，绝不通过 Fork 绕过上游限制。切换 Provider 只处理当前任务并保留已有历史，其他任务可以继续执行；只有确认无历史的空会话允许更换底层线程 ID；不会因此重启共享 App Server。若目标任务无法卸载，会提示失败并尝试恢复原设置。设置入口可直接加载保存的任务元数据，无需先用故障的旧 Provider 恢复任务；普通恢复和断线重连会验证线程 ID 与已知 Provider，再允许发起新轮次。明确的认证失败不再触发 Agent Bot 自动重试。
 
 Agent 进程会继承普通父进程变量及其显式配置的 `agents.<name>.env`。启动 Agent 前，Agent Bot 会移除继承的 `FEISHU_*` 凭据和内部 `AGENT_BOT_*` 状态，再仅提供带命名空间的非敏感 Profile 与 Lark 身份上下文；`FEISHU_APP_SECRET` 永远不会传入 Agent 进程。
 
@@ -417,9 +423,9 @@ Agent Bot 会响应机器人所在群内拥有者发送的普通消息。将 `fe
 
 Turn Preview 中每个已保存的思考项默认折叠，开头的 Markdown 标题或独立加粗标题直接显示在折叠栏；展开后显示剩余摘要和正文，不再添加“摘要 / 正文”标签或重复同一标题。没有明确标题时保留“思考”作为标题，原文完整保留。折叠时不加载全文，展开后按需加载 Markdown，实时更新保留展开状态。思考正文及完成事件中的权威内容单独保存，不改变思考卡片的标题、分组或最终回答。旧快照中已保存的摘要仍可查看，此前未记录的正文不会从 Agent 历史自动回填。
 
-引用卡片或合并转发中的卡片时，Agent 会收到可读取的原始文字和图片。
+引用卡片或合并转发中的卡片时，Agent 会收到可读取的原始文字和图片。转发聊天记录中的图片、文件会下载为参考附件，引用聊天记录并附上自己的指令时也同样适用。
 
-转发富文本、图片、文件或聊天记录并附言时，Agent Bot 会将关联消息合并为一次请求：你的附言作为主 Prompt，转发内容保留为参考材料。
+引用消息时，你当前发送的正文作为主 Prompt，被引用内容保留为参考材料，不按消息类型区分。普通飞书消息（包括文字和链接）在确认收到后，最多短暂等待 1.5 秒；同一用户在同一会话中紧接着显式引用它补充说明时，合并为一次请求，并以附言作为卡片 Prompt。命令不等待；引用旧消息或已提交的消息仍按正常引用和追加逻辑处理，不替换已完成的历史。
 
 文件变更摘要中的路径保持普通文本样式，完整保留 Windows 路径分隔符和下划线（包括 `\__init__.py`），不会将其解析为 Markdown 格式。
 

package/dist/codex/CodexRuntime.js

@@ -2,6 +2,7 @@ import { statSync } from "node:fs";
 import { setTimeout as delay } from "node:timers/promises";
 import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
+import { isResponseContinuationError } from "../runtime/responseErrors.js";
 import { AppServerRequestError } from "./AppServerConnection.js";
 import { workspaceSandboxFromConfig, workspaceSandboxFromResponse } from "./AppServerPermissions.js";
 import { formatCodexError, mapCodexNotification } from "./CodexEventMapper.js";
@@ -170,15 +171,49 @@ export class CodexRuntime {
         return session;
     }
     async startTurn(sessionId, prompt) {
-        return this.runSessionOperation(sessionId, () => this.startTurnNow(sessionId, prompt));
+        return this.runSessionOperation(sessionId, () => {
+            this.requireSession(sessionId).responseFailureTurnId = undefined;
+            return this.startTurnNow(sessionId, prompt);
+        });
+    }
+    get recoverResponseContinuation() {
+        return this.provider.getAgentFamily?.() === "codex"
+            ? (sessionId, failedTurnId, signal) => this.recoverResponseContinuationNow(sessionId, failedTurnId, signal)
+            : undefined;
     }
-    async startTurnNow(sessionId, prompt) {
+    async recoverResponseContinuationNow(sessionId, failedTurnId, signal) {
+        return this.runSessionOperation(sessionId, async () => {
+            signal?.throwIfAborted();
+            const session = this.requireSession(sessionId);
+            if (session.responseFailureTurnId !== failedTurnId || session.activeTurnId || session.needsResume) {
+                throw new Error("模型续接恢复已失效，请发送消息继续。");
+            }
+            // Consume before starting: a timeout must not create a second continuation.
+            session.responseFailureTurnId = undefined;
+            const client = await this.client();
+            const metadata = await client.request("thread/read", {
+                threadId: session.remoteSessionId, includeTurns: false,
+            }, SYNC_REQUEST_TIMEOUT_MS);
+            const latest = await this.readLatestThreadTurns(client, session.remoteSessionId, "summary");
+            signal?.throwIfAborted();
+            if (session.activeTurnId || session.needsResume || metadata.thread.id !== session.remoteSessionId || metadata.thread.status?.type === "active"
+                || latest.at(-1)?.id !== failedTurnId || latest.at(-1)?.status !== "failed") {
+                throw new Error("任务已发生变化，未自动恢复模型续接。请检查当前任务后继续。");
+            }
+            const turnId = await this.startTurnNow(sessionId, "", true);
+            if (signal?.aborted && session.activeTurnId === turnId)
+                await this.cancelTurn(sessionId, turnId);
+            signal?.throwIfAborted();
+            return turnId;
+        });
+    }
+    async startTurnNow(sessionId, prompt, responseContinuation = false) {
         const session = this.requireSession(sessionId);
         const client = await this.client();
         await this.ensureSessionResumed(session, client);
         const start = async () => client.request("turn/start", {
             threadId: session.remoteSessionId,
-            input: codexUserInput(prompt),
+            input: responseContinuation ? [] : codexUserInput(prompt),
             cwd: session.cwd,
             model: session.model,
             effort: session.reasoningEffort,
@@ -197,7 +232,7 @@ export class CodexRuntime {
             response = await start();
         }
         catch (error) {
-            if (!isInvalidWorkingDirectoryError(error))
+            if (responseContinuation || !isInvalidWorkingDirectoryError(error))
                 throw error;
             this.logger.warn({ error, sessionId: session.localSessionId, cwd: session.cwd }, "App Server rejected the task working directory; refreshing the current thread before retrying.");
             await this.resumeAppServerSession(session, client);
@@ -617,17 +652,30 @@ export class CodexRuntime {
         return response.cleared;
     }
     async setModel(sessionId, model) {
-        await this.runSessionOperation(sessionId, async () => { this.requireSession(sessionId).model = model; });
+        await this.runSessionOperation(sessionId, async () => {
+            const session = this.requireSession(sessionId);
+            session.model = model;
+            session.responseFailureTurnId = undefined;
+        });
     }
     async setReasoningEffort(sessionId, effort) {
-        await this.runSessionOperation(sessionId, async () => { this.requireSession(sessionId).reasoningEffort = effort; });
+        await this.runSessionOperation(sessionId, async () => {
+            const session = this.requireSession(sessionId);
+            session.reasoningEffort = effort;
+            session.responseFailureTurnId = undefined;
+        });
     }
     async setPermissionMode(sessionId, mode) {
-        await this.runSessionOperation(sessionId, async () => { this.requireSession(sessionId).permissionMode = mode; });
+        await this.runSessionOperation(sessionId, async () => {
+            const session = this.requireSession(sessionId);
+            session.permissionMode = mode;
+            session.responseFailureTurnId = undefined;
+        });
     }
     async setExecutionSettings(sessionId, settings, persist) {
         return this.runSessionOperation(sessionId, async () => {
             try {
+                this.requireSession(sessionId).responseFailureTurnId = undefined;
                 return await this.setExecutionSettingsNow(sessionId, settings, persist);
             }
             catch (error) {
@@ -647,22 +695,14 @@ export class CodexRuntime {
         const metadata = await client.request("thread/read", {
             threadId: session.remoteSessionId, includeTurns: false,
         }, SYNC_REQUEST_TIMEOUT_MS);
+        if (metadata.thread.id !== session.remoteSessionId)
+            throw new Error("App Server 返回了不同的任务 ID，未切换 Provider。");
         const localActive = await this.localActivityDetector?.activeThreads([session.remoteSessionId]);
         if (metadata.thread.status?.type === "active" || localActive?.has(session.remoteSessionId) || session.activeTurnId) {
             throw new Error(PROVIDER_SWITCH_BUSY);
         }
-        if (session.turnCount === 0 && !metadata.thread.forkedFromId && !metadata.thread.preview?.trim()) {
-            try {
-                const turns = await this.readLatestThreadTurns(client, session.remoteSessionId, "summary");
-                if (turns.length === 0)
-                    throw new Error(PROVIDER_SWITCH_EMPTY);
-            }
-            catch (error) {
-                if (!(error instanceof AppServerRequestError) || error.method !== "thread/turns/list"
-                    || !/missing source rollout|no rollout found/iu.test(error.serverMessage))
-                    throw error;
-                throw new Error(PROVIDER_SWITCH_EMPTY, { cause: error });
-            }
+        if (await this.isEmptySettingsSession(client, session, metadata.thread)) {
+            return this.replaceEmptySettingsSession(client, session, settings, persist);
         }
         const previous = { ...session };
         const restoreProvider = previous.modelProvider?.trim()
@@ -726,6 +766,78 @@ export class CodexRuntime {
         }
         return session;
     }
+    async isEmptySettingsSession(client, session, thread) {
+        if (thread.id !== session.remoteSessionId || thread.preview !== "" || thread.forkedFromId
+            || (session.turnCount === undefined && thread.forkedFromId !== null)
+            || session.activeTurnId || (session.turnCount ?? 0) > 0 || session.knownTurnIds.size > 0
+            || session.terminalTurnIds.size > 0 || (thread.turns?.length ?? 0) > 0)
+            return false;
+        try {
+            if ((await this.readLatestThreadTurns(client, session.remoteSessionId, "summary")).length > 0)
+                return false;
+        }
+        catch (error) {
+            if (!(error instanceof AppServerRequestError) || error.method !== "thread/turns/list"
+                || !/missing source rollout|no rollout found|not materialized yet/iu.test(error.serverMessage))
+                throw error;
+        }
+        if (!["idle", "notLoaded"].includes(thread.status?.type ?? ""))
+            throw new Error(PROVIDER_SWITCH_EMPTY);
+        const { goal } = await client.request("thread/goal/get", {
+            threadId: session.remoteSessionId,
+        }, CONTROL_REQUEST_TIMEOUT_MS);
+        if (goal !== null)
+            throw new Error(PROVIDER_SWITCH_EMPTY);
+        return true;
+    }
+    async replaceEmptySettingsSession(client, session, settings, persist) {
+        const oldId = session.remoteSessionId;
+        let replacementId;
+        try {
+            // Keep the original attachment until target verification and persistence both succeed.
+            const response = await client.request("thread/start", {
+                cwd: session.cwd, modelProvider: settings.modelProvider, model: settings.model, threadSource: "user",
+                ...threadLifecycleParams(session.cwd), ...permissionParams(settings.permissionMode),
+            }, SESSION_REQUEST_TIMEOUT_MS);
+            if (!response.thread.id || response.thread.id === oldId)
+                throw new Error("App Server 未创建独立的空任务，未保存设置。");
+            replacementId = response.thread.id;
+            assertProviderSettingsApplied(response, settings);
+            if (session.title)
+                await client.request("thread/name/set", { threadId: replacementId, name: session.title }, CONTROL_REQUEST_TIMEOUT_MS);
+            const { thread } = await client.request("thread/read", { threadId: oldId, includeTurns: false }, SYNC_REQUEST_TIMEOUT_MS);
+            const active = await this.localActivityDetector?.activeThreads([oldId]);
+            if (active?.has(oldId) || !await this.isEmptySettingsSession(client, session, thread))
+                throw new Error(PROVIDER_SWITCH_BUSY);
+            if (this.attachedClient !== client)
+                throw new Error("App Server 连接已变化，请重试 Provider 切换。");
+            const candidate = this.makeSession({
+                localSessionId: session.localSessionId, agentName: session.agentName, cwd: session.cwd, title: session.title, ...settings,
+            }, response, settings.reasoningEffort);
+            candidate.title = session.title;
+            await persist?.(candidate, { emptyRemoteSessionId: oldId });
+            Object.assign(session, candidate, {
+                needsResume: this.attachedClient !== client, settingsRecoveryError: undefined, remoteSummary: undefined,
+            });
+        }
+        catch (error) {
+            if (replacementId)
+                await this.releaseUnusedSettingsThread(client, replacementId);
+            throw new ProviderSwitchError(`Provider 切换失败：${providerSwitchFailure(error)} 原会话和设置已保留。`, !session.needsResume && !session.settingsRecoveryError, { cause: error });
+        }
+        if (![...this.sessions.values()].some(other => other.remoteSessionId === oldId)) {
+            await this.releaseUnusedSettingsThread(client, oldId);
+        }
+        return session;
+    }
+    async releaseUnusedSettingsThread(client, threadId) {
+        try {
+            await client.request("thread/unsubscribe", { threadId }, CONTROL_REQUEST_TIMEOUT_MS);
+        }
+        catch (error) {
+            this.logger.warn({ error, threadId }, "Could not release an unused empty settings thread.");
+        }
+    }
     async detachThreadForSettings(client, session, onDetach) {
         const current = await client.request("thread/read", {
             threadId: session.remoteSessionId, includeTurns: false,
@@ -1236,6 +1348,9 @@ export class CodexRuntime {
             session.activeTurnStartedAt = undefined;
             session.terminalTurnIds.add(mapped.turnId);
             session.messagePhases.clear();
+            session.responseFailureTurnId = mapped.status === "failed" && mapped.error
+                && this.provider.getAgentFamily?.() === "codex" && isResponseContinuationError(mapped.error)
+                ? mapped.turnId : undefined;
             if (mapped.status === "cancelled") {
                 this.emit({ type: "turn_cancelled", sessionId, turnId: mapped.turnId });
             }
@@ -1406,6 +1521,7 @@ export class CodexRuntime {
                 session.turnCount += 1;
         }
         session.activeTurnId = turnId;
+        session.responseFailureTurnId = undefined;
         session.activeTurnStartedAt = startedAt;
         session.planContinuationTurnId = undefined;
         session.modeChangeRequestIds.clear();
@@ -1440,6 +1556,9 @@ export class CodexRuntime {
         session.activeTurnStartedAt = undefined;
         session.terminalTurnIds.add(turn.id);
         session.messagePhases.clear();
+        const failure = formatCodexError(turn.error);
+        session.responseFailureTurnId = turn.status === "failed" && failure
+            && this.provider.getAgentFamily?.() === "codex" && isResponseContinuationError(failure) ? turn.id : undefined;
         if (turn.status === "interrupted") {
             this.emit({ type: "turn_cancelled", sessionId: session.localSessionId, turnId: turn.id });
             return;
@@ -1449,7 +1568,7 @@ export class CodexRuntime {
                 type: "turn_failed",
                 sessionId: session.localSessionId,
                 turnId: turn.id,
-                message: formatCodexError(turn.error) ?? "App Server turn failed.",
+                message: failure ?? "App Server turn failed.",
             });
             return;
         }
@@ -1499,7 +1618,7 @@ export class CodexRuntime {
             workspaceSandboxPolicy: workspaceSandboxFromResponse(response.sandbox),
             rolloutPath: stringValue(response.thread.path)?.trim() || undefined,
             turnCount: "remoteSessionId" in input ? undefined : 0,
-            knownTurnIds: new Set(),
+            knownTurnIds: new Set("lastTurnId" in input && input.lastTurnId ? [input.lastTurnId] : []),
         };
     }
     requireSession(sessionId) {
@@ -1572,6 +1691,7 @@ export class CodexRuntime {
         for (const session of this.sessions.values()) {
             session.needsResume = true;
             session.planContinuationTurnId = undefined;
+            session.responseFailureTurnId = undefined;
             const turnId = session.activeTurnId;
             if (!turnId)
                 continue;