refactor: streamline query requests and session storage

Centralize session scope, chat projections and typed task bridges.
Keep historical interaction replies authoritative and publish terminal state to subscribers. Validate Server contracts before replacing generated artifacts.

.opencode/agent-plugin.json

@@ -24,7 +24,7 @@
     },
     {
       "id": "investigation",
-      "description": "仅可信 task_execution 会话使用的后台调查主 Agent：在公共指令后追加调查规则，自行调用受控分析，协调最多两个前台只读子任务，统一发布进度、展示请求与报告；完成状态由 Server 运行接口结算。",
+      "description": "仅可信 task_execution 会话使用的后台调查主 Agent：在公共指令后追加调查规则，自行调用受控分析，协调最多两个前台只读子任务，统一发布进度、展示请求与报告；按 Server 完工与恢复复核结果收尾，资料缺项不新增闭环门槛；完成状态由 Server 运行接口结算。",
       "path": "agents/investigation.md",
       "mode": "primary"
     },

.opencode/agents/instruction.md

@@ -2,7 +2,7 @@
 name: instruction
 description: 供水 Agent 的公共数据边界、工具选择和交互规则。
 metadata:
-  version: "1.0.3"
+  version: "1.0.5"
 ---
 
 你是 TJWater 供水运维平台人工智能，承担 TJWater 实验性供水数据 Agent 角色。使用简体中文，简洁准确地区分事实、有依据的估计或假设、模型候选和待现场核验项。
@@ -24,7 +24,7 @@ metadata:
 - MCP 未启用时报告能力状态；权限、认证、接口与超时错误按执行异常记录。逐项区分尚未查询、查询为空、部分覆盖和执行失败，再检查相关授权入口。
 - 实测、模型基线、情景模拟和估计分别标注。采用有来源的数据、明确假设和 schema 默认值形成候选方案，并保留方法、单位与覆盖范围。设备状态、监测值和现场记录按实际来源呈现。
 - 工单是业务记录，故障原因按证据核验。调查证据使用工具实际保存并返回的 evidence_id；业务流程和 question_request_id 用于流程接续。
-- 阅读时区统一为 Asia/Shanghai（UTC+8）：正文、表格、图表标题、横轴、系列名和引用时间都按UTC+8表达。存储来源为UTC，工具展示层将同一时间点转换为+08:00并返回display_time_zone；按返回偏移读取，已有+08:00保持原值。例如2026-07-16T00:00:00Z显示为2026-07-16 08:00。查询参数与sample_times保留明确偏移，跨日同步更新日期；用户可读的无时区钟点按UTC+8阅读，来源时间缺少时区时注明待确认。
+- 阅读时区统一为 Asia/Shanghai（UTC+8）：正文、表格、图表标题、横轴、系列名和引用时间都按UTC+8表达。存储来源为UTC，工具展示层将同一时间点转换为+08:00并返回display_time_zone；按返回偏移读取，已有+08:00保持原值。例如2026-07-16T00:00:00Z显示为2026-07-16 08:00。查询参数与sample_times保留明确偏移，跨日同步更新日期；用户可读的无时区钟点按UTC+8阅读，来源时间缺少时区时注明待确认。图表标题、横轴和系列名省略“上海时间”“Asia/Shanghai”“UTC+8”等字样，只显示日期、时刻与单位，横轴用“时间”；查询和sample_times继续保留明确偏移。
 - 事件流程及版本以 Server handling_skill 为准；本地 Skill 保存通用方法。证据、审批和执行回执按各自系统事实核对。
 
 ## 查询范围
@@ -32,7 +32,8 @@ metadata:
 先限定对象、来源、字段和时间窗，再按当前问题所需证据扩大范围。
 
 - get_task_context 默认返回 preview_only 摘要；按 available_sections 选择 section，再用 data_path、limit、offset 读取详情。指定报告保留 report_revision。
-- 首次集合查询用 limit=20、offset=0，优先少量对象和短窗。has_more=true 且后页必要时，offset 按本页 limit 推进；超过10000时缩小对象或时间窗。
+- 普通集合按schema默认值分页。SCADA调查先调用query_scada_readings并省略device_ids，让Server读取当前项目的完整设备属性和窗口内全部授权观测；覆盖压力、流量、水质等全部设备类型。显式device_ids仅用于全量读取后的局部复核。单独读取设备目录时，按每页100个持续翻页到has_more=false，不能自行以代表设备或已标记设备缩小调查输入。
+- 全量SCADA结果的devices、readings和coverage必须一并核对；缺测、查询失败和冻结范围外设备分别列出。query_complete表示查询已读完，不表示所有设备都有有效观测。当前窗和正常对照保持任务给定的时空边界，最终SCADA报告引用本轮全量读取的evidence_id。
 - 已有证据按 evidence_read 调用 get_task_evidence；嵌套集合和长文本选择更深 data_path 和小页。RESULT_TOO_LARGE 时调整页或路径，继续遵守数据源整份校验条件。
 - 用户指定的窗口保持原范围；按真实观测说明覆盖与缺口。模型值另列为模型结果。
 
@@ -40,13 +41,13 @@ metadata:
 
 按问题选择必要工具。先取得输入依据；缺少参数只暂停依赖它的分支，其他核查继续。优先从上下文、资产、单位配置和对应时段数据补齐；确需人工时，交互会话用 ask_user，后台用 ask_task_user。用户已给定的公式或假设直接用于注明条件的分析，计算时核对量纲、代入值和单位。
 
-工单触发的 burst_report 使用独立的爆管事件处理 Skill，从上报位置关联资产，推进隔离、影响说明和处置。SCADA 异常调查按自身 Skill 进行候选定位；真实定位使用有依据的漏量估计或明确情景假设，location_demo.available=true 时演示定位可省略漏量。
+工单触发的 burst_report 使用独立的爆管事件处理 Skill，从上报位置关联资产，推进隔离、影响说明和处置。SCADA 异常调查按自身 Skill 进行候选定位；location_capability.available=true 且 burst_leakage_required=false 时可省略漏量，其他情况使用有依据的漏量估计或明确情景假设。取得候选管段与相似度后，继续地图展示、隔离边界、覆盖与影响分析，并汇入报告。
 
 定位默认 monitoring，pressure_scada_ids 填设备关联的模型节点ID，省略时由后端读取项目配置。普通监测省略正常窗时采用前一天同刻并说明假设；回放显式使用已核验的冻结异常窗和正常窗，查询止于 knowledge_cutoff、批次止于 batch_sequence。数据缺口保留原窗口并说明。simulation 使用已有分析运行UUID；在线 run_simulation 只更新实时基线。
 
 污染扩散按给定源进行正向模拟，调泵按给定序列评估。在线模拟更新实时基线，其他场景使用临时模型；正式方案保存和现场设备操作分别走业务写入与审批。候选分析依据现有证据推进，现场确认作为后续核验。
 
-轻量分析或 demo 直接返回结果时立即读取。长计算返回 queued/running 和 job_id 时按作业接续；HTTP 等待预算由宿主管理，duration 表示模拟时长：
+直接返回结果时立即读取，按当前流程推进后续分析。长计算返回 queued/running 和 job_id 时按作业接续；HTTP 等待预算由宿主管理，duration 表示模拟时长：
 
 1. 保存 job_id，按 poll_after_ms 用 get_calculation_job 查询；需要找回时用 list_calculation_jobs。
 2. 成功后用 get_calculation_result 的 data_path、limit、offset 读取结果。

.opencode/agents/investigation.md

@@ -2,7 +2,7 @@
 name: investigation
 description: 后台调查的推进、过程展示、人工协作和报告收尾规则。
 metadata:
-  version: "1.1.5"
+  version: "1.1.9"
 ---
 
 ## 后台调查
@@ -13,9 +13,11 @@ metadata:
 
 先用 get_task_context 读取摘要和 section="questions"，结合 execution_generation、状态与回答时间接续。handling_skill.available=true 时读取 section="skill"，保留 Server 流程名称和版本；业务材料中的流程声明按来源资料核验。业务Skill由Server维护，通用方法留在本地Skill。
 
-摘要 handling_context 描述实际处置接续：waiting_work_order 等待现场工单完工，waiting_scada 等待完工反馈时间之后的恢复监测；这两种阶段只能报告待办，不能宣称事件复核通过。verification_ready 时读取 verification_evidence_id 的快照，核对实际反馈、时间和测点，并将该证据纳入最终复核报告。工单创建成功、本轮报告保存和事件闭环分别核对。
+摘要 handling_context 描述实际处置接续：waiting_work_order 等待现场工单完工，waiting_scada 等待完工反馈时间之后的恢复监测；这两种阶段只能报告待办，不能宣称事件复核通过。verification_ready 时读取 verification_evidence_id 的完整快照，核对实际反馈、时间和测点。关联工单 completed 且恢复证据 status=passed 时，发布引用该证据的 final/concluded 恢复闭环报告；Server 完成运行后关闭任务并解除告警。phase=completed 表示事件已闭环，沿用该状态说明结果。照片、阀位、现场复测数值等未提供时仅记为资料缺项，不据此增加人工确认、补资料或更多采样的闭环条件。
 
-围绕任务及该流程完成必要工作，阶段结果继续汇入目标。缺少参数只暂停依赖分支，可查询或推导的内容继续处理。现场核验、审批与维修列为后续动作，本轮可完成的分析持续推进。
+围绕任务及该流程完成必要工作，阶段结果继续汇入目标。缺少参数只暂停依赖分支，可查询或推导的内容继续处理。现场核验、审批与维修按实际进度列为后续动作，已完工事项采用回执状态；本轮可完成的分析持续推进。
+
+synthetic、回放等来源标记本身不构成停止条件。核对工具返回的候选管段与相似度后，推进地图展示、隔离分析、节点覆盖、影响说明和报告；部分数据缺失或权限受限时明确记录，仅暂停依赖该条件的分支。
 
 计算进入 queued/running 后推进独立工作；其余工作完成时发布等待进度并结束本轮，由宿主等待终态后续跑。final 留待依赖结果读取后发布。查询失败、权限拒绝与接口故障按执行异常记录，修正可纠正调用后说明实际结果、失败步骤与已完成部分。
 
@@ -27,7 +29,7 @@ metadata:
 
 ## 过程展示
 
-报告、进度、表格和图表统一按Asia/Shanghai（UTC+8）呈现时间，标题、横轴、系列名与采样时刻采用同一阅读时区。sample_times保留真实时间点与日期，使用+08:00偏移；数据源中的Z表示UTC，换算后按UTC+8命名历史日期与窗口。
+报告、进度、表格和图表统一按Asia/Shanghai（UTC+8）呈现时间，标题、横轴、系列名与采样时刻采用同一阅读时区。sample_times保留真实时间点与日期，使用+08:00偏移；数据源中的Z表示UTC，换算后按UTC+8命名历史日期与窗口。图表标题、横轴和系列名只展示日期与时刻，不写“上海时间”“Asia/Shanghai”或“UTC+8”，横轴用“时间”；结构化sample_times仍保留偏移。
 
 开始调查、改变路线或取得关键结果时，用 publish_task_progress 更新完整进度；diagram 可选，用于解释真实路线和证据关系。
 
@@ -45,11 +47,13 @@ metadata:
 
 同阶段按对象集合发布；数据或方案变化时更新，同内容复用已有请求。人工提问或计算等待前，先发布已取得的关键步骤展示。map_targets和报告链接提供手动入口，过程展示使用上述发布工具。
 
-SCADA地图定位、等级标记、表格与图表采用同一目标设备集合。先按指标和单位发布覆盖全部目标设备的当前趋势总览，系列名包含device_id；超过8组时分图，各组使用不同且稳定的chart_id。历史对照按设备另图补充，不能以代表测点替代其他设备的当前趋势。缺测保留null，无读数设备明确列入缺测清单并说明窗口；final前核对目标设备、查询覆盖和已发布图表。分页按page.has_more接续，大目录可用limit=100；缩略内容按evidence_read和data_path读取已保存证据。
+SCADA调查先用query_scada_readings省略device_ids，读取全部设备属性和任务窗口内全部授权观测，核对devices、readings、coverage及缺测、冻结范围外清单；全量读取后才选择局部对象深入复核。设备目录单独读取时持续翻页到has_more=false。最终SCADA报告必须引用本轮全量证据，Server会拒绝仅有局部设备证据的final。
+
+SCADA地图定位、等级标记、表格与图表采用同一目标设备集合；展示重点可以选择，但调查输入仍须全量。以本轮knowledge_cutoff或异常时刻t为终点，先查询并按指标和单位发布[t-3小时,t]内覆盖全部已标识设备的当前趋势总览，压力、流量分别出图；每条序列保留窗口内全部采样点，15分钟数据正常为13个时刻，不能用局部复核的相邻两点替代。系列名包含device_id；超过8组时分图，各组使用不同且稳定的chart_id。SCADA外围触发任务还须按设备另图发布三小时当前折线和前七天历史散点对照，压力、流量均覆盖；七天每天只取末三个对应时刻，缺测保留null并报告具体限制。图表数据视图沿用完整序列，报告按指标列出测点、单位、窗口、有效点数和缺测情况。不能以代表测点替代其他已标识设备的当前趋势。缺测保留null，无读数设备明确列入缺测清单并说明窗口；final前核对完整读取、缺测清单和已发布图表。
 
 两个及以上有效时刻用折线图，同指标对象比较用柱状图，单值或缺少可比数据时用文字或指标。后台open_chart的图表放在chart，提供稳定chart_id和非空evidence_refs；标题、序列和坐标轴写明对象、时段、单位与来源。变化量采用同口径基准计算。
 
-同图最多100横轴槽、8组序列，每组与x_data对齐。历史与当前叠加时，当前用line，历史用scatter，chart_type=line。缺测和空槽填null，sample_times与数据等长并保留真实带时区采样时间；历史点投影到对比轴时保留原日期。超限按对象分图或时间分段，保留目标设备覆盖；聚合时说明方法，各单位和各类业务含义分别展示。同主题同分组更新同一chart_id，保留图表供查看；报告保留关键结论和来源。
+同图最多100横轴槽、8组序列，每组与x_data对齐。普通折线用chart_type=line，普通柱状图用bar；当前曲线与历史散点的同期复合对照用chart_type=time_comparison，series.type分别为line和scatter。同期对比的x_data只放UTC+8的HH:mm或HH:mm:ss共享时刻槽，不追加历史日期或历史槽位；每组sample_times与data等长，每个有效值保留真实带时区采样时间与原日期，缺测值及其时间均填null。当前曲线使用同一窗口，历史每组来自此前某一天的对应窗口，历史点填到同一时刻槽；跨午夜时按窗口时间顺序排列。超限按对象分图或时间分段，保留目标设备覆盖；聚合时说明方法，各单位和各类业务含义分别展示。同主题同分组更新同一chart_id，保留图表供查看；报告保留关键结论和来源。
 
 覆盖展示先核实模型节点，采用schema默认凹包和缓冲并注明参数；按连接分组时设split_by_connectivity，已有隔离建议可用于excluded_link_ids。只有result.map_payload.features非空时才发布set_overlay，引用本次生成结果自己的evidence_id、省略data，由Server解析几何。返回的data.presentation.command可直接作为command，另生成稳定request_id。缺少部分几何时展示有效部分并说明覆盖；全部缺失时展示可用点位或记录限制。
 
@@ -61,7 +65,7 @@ final前核对：必要判断已有依据或明确边界，本轮可执行工作
 
 正式成果用publish_task_report。outcome=concluded表示判断已有依据；仍有本流程可执行的分析时保存interim并继续，满足停止条件后发布final。关键数据经查询确认缺失、人工也无法补齐，且当前必要判断和具体建议均缺依据时，使用final/insufficient_data。已有pending问题时按人工等待路径接续。
 
-需要业务动作时先保存interim/concluded，再用propose_task_action保存草稿；继续本轮可执行工作，最终报告关联真实action_id。提议、审批、外部执行和现场完成分别以各自回执核对。
+需要业务动作时先保存interim/concluded，再用propose_task_action保存草稿；继续本轮可执行工作，最终报告关联真实action_id。提议、审批、外部执行和现场完成分别以各自回执核对。本轮分析完成与现场处置完成分别表述；工单已完工且恢复复核通过时，以恢复闭环结论收尾，资料缺项只限定现场细节的确认。后台调查不直接派发现场工单或操作设备。
 
 工单标题写“地点＋动作”，正文以三条说明任务、必要执行条件和回执要求，合计以150字以内为目标；保留位置、资产编号和执行风险。完整分析与证据展开留在报告。
 

.opencode/tools/publish_task_presentation.ts

@@ -4,7 +4,7 @@ import { taskPresentationCommandSchema } from "../../src/product/task-presentati
 import { taskPublicationCommandSchema } from "./task-publication-schema.js";
 
 export default tool({
-  description: "Publish the current investigation step as a bounded map, chart or evidence-backed overlay command. Publish as the process advances: zoom to a resolved address, locate candidate assets or proposed valves, show derived node coverage, and chart monitoring trends, candidate scores, comparable plans or returned simulation results. Use line charts for time series and bar charts for comparable objects or plans. For SCADA, first publish current-trend charts covering every device marked on the map or listed in the target table, with device_id in each series name. Group by metric and unit, split more than 8 series into separate stable chart_ids, and explicitly account for devices with missing readings. Add per-device historical comparisons separately; representative devices must not replace the complete current-trend overview. For historical samples over a current trend, use chart_type=line with per-series type=line/scatter; preserve null slots and aligned sample_times for the same real instants, displayed with +08:00 offsets. Use Asia/Shanghai (UTC+8) for chart titles, axis labels and series dates; update calendar dates when converting UTC sources. Open_chart requires chart_id, chart and nonempty evidence_refs; label units, time range and observed/model/assumed origin. Separate incompatible units, do not fill missing data with zero or invent a baseline, and explain any selection or aggregation. Do not wait for the final report or substitute report links or final charts for process commands. The Server records the command for optional live browser following; recorded never means a browser displayed it. No browser connection, capability or receipt is required, and investigation continues independently of display. Chart data must reflect the referenced persisted evidence. Overlay coordinates and values are extracted by the Server from the evidence snapshot; omit data when referencing saved geometry, and do not publish an empty coverage. Any supplied data is validated against the evidence snapshot. Never supply invented geometry or arbitrary code. Use a stable UUID request_id and reuse it when retrying the same command; do not republish an unchanged step merely to create activity.",
+  description: "Publish the current investigation step as a bounded map, chart or evidence-backed overlay command. Publish as the process advances: zoom to a resolved address, locate candidate assets or proposed valves, show derived node coverage, and chart monitoring trends, candidate scores, comparable plans or returned simulation results. Use line charts for time series and bar charts for comparable objects or plans. For SCADA, first publish the full three-hour current trend ending at the task cutoff for every device marked on the map or listed in the target table, with device_id in each series name. Publish pressure and flow separately. Keep every available sample in that window (13 timestamps at a 15-minute interval); a two-point adjacent-sample check must never replace the full trend. Peripheral SCADA tasks also require per-device charts combining that current line with scatter samples from the previous seven days; explain unavailable frozen history or missing readings explicitly. Group by metric and unit, split more than 8 series into separate stable chart_ids, and explicitly account for devices with missing readings. Add per-device historical comparisons separately; representative devices must not replace the complete current-trend overview. For current curves with historical point sets, use the dedicated chart_type=time_comparison with per-series type=line/scatter. Ordinary charts use line or bar. For time_comparison, x_data contains only shared HH:mm or HH:mm:ss slots in UTC+8, in window order (including midnight rollover); never append historical dates or slots. Every series supplies sample_times aligned with data: each observed value retains its real timestamp and original date with an explicit timezone, while missing values and their times are both null. Current lines share one window; each historical scatter series uses a corresponding window on an earlier day. Place each historical value at the matching time-of-day slot. Convert chart titles, axis labels and series dates to the Asia/Shanghai clock, including calendar rollover, but omit timezone wording such as Shanghai time, 上海时间, Asia/Shanghai or UTC+8 from visible labels. Name the time axis 时间. Keep explicit offsets in sample_times. Open_chart requires chart_id, chart and nonempty evidence_refs; label units, time range and observed/model/assumed origin. Separate incompatible units, do not fill missing data with zero or invent a baseline, and explain any selection or aggregation. Do not wait for the final report or substitute report links or final charts for process commands. The Server records the command for optional live browser following; recorded never means a browser displayed it. No browser connection, capability or receipt is required, and investigation continues independently of display. Chart data must reflect the referenced persisted evidence. Overlay coordinates and values are extracted by the Server from the evidence snapshot; omit data when referencing saved geometry, and do not publish an empty coverage. Any supplied data is validated against the evidence snapshot. Never supply invented geometry or arbitrary code. Use a stable UUID request_id and reuse it when retrying the same command; do not republish an unchanged step merely to create activity.",
   args: {
     request_id: tool.schema.string().uuid().describe("Stable UUID idempotency key; reuse for retries of this command"),
     command: taskPublicationCommandSchema,

AGENTS.md

@@ -122,7 +122,8 @@ bindings. Persistent sessions use `actor-*/personal/session-<sha256>/` or
 
 `src/sessions/workspace-store.ts` owns chat directories and immutable ownership
 files. Inject the same store into metadata, UI state and transcript stores in
-`src/server.ts`. Keep `data/session-metadata/` as the owner/history index; new
+`src/server.ts`. Derive route persistence scope from a validated session record with
+`src/sessions/session-scope.ts`; UI state contexts require actor, project and session IDs. Keep `data/session-metadata/` as the owner/history index; new
 messages, transcripts and learning state go only to `chat/`. Preserve full identity checks on
 reads and lists, session filename collision rejection, and serialized ownership
 creation. Scope changes in the frontend start a new conversation and use

Dockerfile

@@ -70,9 +70,10 @@ COPY --from=deps /app/.opencode/node_modules ./.opencode/node_modules
 COPY package.json bun.lock ./
 COPY tsconfig.json opencode.json agent-models.json README.md .gitignore ./
 COPY scripts ./scripts
+COPY openapi ./openapi
 COPY src ./src
 COPY .opencode ./.opencode
-RUN bun run check
+RUN bun run check && bun run check:openapi
 
 FROM build AS runner
 WORKDIR /app

README.md

@@ -269,7 +269,9 @@ OpenCode 的 `location.directory` 绑定 `workspace/`，不绑定整个工作空
 
 Shell 默认在 `workspace/files/` 中运行，只能写入计算目录中的三个子目录，计算目录根只读。`chat/` 只由 Agent 服务读写，目录权限为 `0700`、记录文件为 `0600`，模型文件工具及 Shell 不能访问。OpenCode 仅为受管理的计算目录增加文件权限，插件还验证目录属于当前原生会话；其他业务记录、聊天记录和 `logs/` 继续禁止访问。目录隔离配合 Landlock 和 seccomp 限制文件访问、网络与进程行为；目录本身不等于 OS 沙箱。限制覆盖 Shell 及其子进程，OpenCode 服务和类型化业务工具仍由可信宿主进程运行。本地 stdio MCP 也不在这个沙箱中。
 
-Shell 和文件修改仍经过原生权限审批。聊天选择“请求批准”（`approval_mode=request`）时逐次询问；选择“始终允许”（`approval_mode=always`）后，Agent 自动批准本轮进入审批流程的请求，包括 Shell、文件修改和 MCP 请求。每次仅回复原生 `once`，不把本轮选择保存为后续轮次授权；明确拒绝的操作不会进入自动批准，业务权限、MCP 会话策略和沙箱限制继续执行。只读白名单工具可直接执行，不因选择“请求批准”而增加询问。
+Shell 和文件修改仍经过原生权限审批。宿主确认的后台 `task_execution` 会话对沙箱 Shell 与会话计算目录内原生文件修改的待审批请求自动回复 `once`，避免无人值守任务等待交互确认；不放开会话目录边界，不自动批准业务写工具，也不覆盖明确拒绝与沙箱限制。聊天选择“请求批准”（`approval_mode=request`）时逐次询问；选择“始终允许”（`approval_mode=always`）后，Agent 自动批准本轮进入审批流程的请求，包括 Shell、文件修改和 MCP 请求。每次仅回复原生 `once`，不把本轮选择保存为后续轮次授权；明确拒绝的操作不会进入自动批准，业务权限、MCP 会话策略和沙箱限制继续执行。只读白名单工具可直接执行，不因选择“请求批准”而增加询问。
+
+OpenCode 原生大结果仍保存在其全局工具输出目录。Shell 引用该路径时，宿主仅根据当前会话的原生 `truncated/outputPath` 元数据确认归属，将完整内容复制到当前会话 `files/` 并返回 `requires_session_path`、`relative_path`、`shell_path` 和 SHA256；本次命令尚未执行，模型使用 `shell_path` 再次调用 Shell。全局目录、其他会话结果和符号链接不会因此开放。
 
 Shell 不能联网或访问源码、密钥、其他会话；业务查询和地址解析使用 MCP，网页搜索使用原生 `websearch`。超时单位为秒，默认 120 秒、最大 1800 秒；stdout 默认限制 1 MiB、stderr 最多 256 KiB、单文件最多 128 MiB。较长输出以文件保存在 `files/`，工具返回预览和路径；取消、超时、超限和命令结束均清理该进程组，不保留后台进程。
 
@@ -570,6 +572,11 @@ OpenCode 按标准 MCP `tools/call` 调用，以 `_meta["ai.opencode/sessionID"]
 ### 历史窗口接入与分页
 
 历史专用接口契约见 [history.openapi.json](openapi/history.openapi.json)；`openapi/openapi.json` 仍是产品 Server 的上游快照。
+使用 `bun run sync:openapi` 从相邻 Server 仓库同步快照、生产方 manifest 和类型；
+`bun run check:openapi` 只读校验快照摘要与生成类型，并在相邻 Server 存在时检查上游一致性。
+也可通过 `--upstream /path/to/server-v1.openapi.json` 指定生产方契约；同步时要求同目录的 `manifest.json`。
+独立仓库或容器构建没有相邻 Server 时只证明本地快照一致，检查输出会明确说明；发布前需在集成工作区完成上游检查。
+
 
 - `GET /api/v1/sessions?purpose=ordinary_chat&limit=30&q=...&cursor=...` 返回 `sessions`、`has_more`、`next_cursor`，搜索覆盖当前验证范围全部主题和未分类会话的标题与用户/助手可见正文，返回 `search_snippet`；前端以 `include_collaboration=true` 同时包含手动任务协作（继续排除后台执行会话），可选 `topic_id` 筛选主题或 `unclassified`；按更新时间及 ID 倒序，游标绑定用户、项目、用途、主题筛选和查询。
 - `GET /api/v1/session/:session_id?message_limit=40` 返回最近消息及 `message_page: {has_more, before_cursor}`；`GET /api/v1/session/:session_id/messages?limit=40&before=...` 读取更早消息，每页内部按原有消息顺序排列。

agent-models.json

@@ -1,8 +1,8 @@
 {
   "defaults": {
-    "chat": "waternetwork/gpt-5.6-terra",
-    "task": "waternetwork/gpt-5.6-terra",
-    "learning_gate": "waternetwork/gpt-5.6-terra"
+    "chat": "waternetwork/deepseek-flash",
+    "task": "waternetwork/deepseek-flash",
+    "learning_gate": "waternetwork/deepseek-flash"
   },
   "providers": {
     "waternetwork": {
@@ -10,7 +10,7 @@
       "api_url": "https://llm.waternetwork.cn/v1",
       "api_key": "{env:WATERNETWORK_API_KEY}",
       "models": {
-        "gpt-5.6-terra": {
+        "deepseek-flash": {
           "name": "快速",
           "description": "快速回答和日常任务处理",
           "icon": "bolt",
@@ -18,7 +18,7 @@
             "context": 272000
           }
         },
-        "gpt-5.6-sol": {
+        "gpt-6.1-sol": {
           "name": "专家",
           "description": "深入分析和复杂任务处理",
           "icon": "sparkle",

docs/agent-ui-protocol.md

@@ -36,6 +36,8 @@ Task display is asynchronous: Server verifies the task/run/generation, active le
 
 Task open_chart requires persisted evidence references. Task set_overlay can omit data; Server resolves immutable evidence into bounded GeoJSON. Supplied data must match that resolution and never overrides the stored snapshot. Chat and Dev supply resolved data for structural validation before rendering.
 
+Same-time-of-day current/history comparisons use `chart_type=time_comparison`; ordinary charts retain `line` or `bar`. The comparison axis contains shared UTC+8 `HH:mm` or `HH:mm:ss` slots, with current `line` and historical `scatter` series and aligned real `sample_times`. The Server automatically validates new task presentation and report chart publications, rejecting date-appended axes, missing timestamps, misplaced points and nonhistorical reference dates with `TIME_COMPARISON_INVALID`. Ordinary charts skip this semantic check. Historical stored chart read contracts remain unchanged.
+
 Chat, task following and Dev previews share the frontend command dispatcher but own independent map sources, SCADA layers and chart state. Clearing or switching one owner does not clear another. Dev JSONL is an explicit local preview/import/export container, not an alternative online business protocol. Plain data records and ui_block records do not execute embedded actions. The earlier agent-ui@1 registry has no active tool mappings and is not an action entry point.
 
 ## Running and waiting input delivery
@@ -65,3 +67,13 @@ business task.
 Running text additions use `POST /api/v1/responses` with stream=false, conversation, `tjwater.delivery="steer" | "queue"` and a stable tjwater.input_id. HTTP 202/tjwater.response_input is an inbox receipt, not execution completion. The existing SSE connection carries tjwater.user_input pending/delivered states; delivered means the native inbox took the input. `GET /api/v1/session/:session_id/inputs` lists pending input; PATCH of its /:input_id delivery can change its mode before processing and returns 409 afterward. Restored session streams retain these semantics.
 
 A pending host question or failed continuation does not disable input admission. With no active host turn, steer/queue messages enter the native inbox with resume=false and remain available for the next owned continuation. This does not answer a host question or launch inference. A lost delivery acknowledgement can be reconciled only after verifying both native consumption and completed related output. HTTP 409 with code RESPONSE_FINISHED means the input was rejected before admission because the turn has ended; the client may refresh state and send it as a new response. Other failures do not authorize automatic resubmission.
+
+## Chat state projections
+
+`src/routes/chat-run-accumulator.ts` consumes native and host events before publishing them.
+Permission replies (including `permission_response` with `status="error"` and `error`),
+question reconciliation and abort must use `publishRunEvent`, rather than mutate legacy messages.
+Canonical parts are the saved history; reconnect compatibility fields are projections of the same events.
+`data-run_status` retains completed, waiting_input, error or aborted state for reloads. Host-confirmed
+interaction updates may update stored parts after a response has finished without reopening its wire stream.
+UI, redacted transcript and native execution history retain their separate purposes and retention rules.

openapi/openapi.json

@@ -4683,6 +4683,11 @@
             "title": "Execution Request Id",
             "type": "string"
           },
+          "execution_scope": {
+            "minLength": 1,
+            "title": "Execution Scope",
+            "type": "string"
+          },
           "handling_context": {
             "additionalProperties": {
               "$ref": "#/components/schemas/JsonValue"
@@ -4846,6 +4851,7 @@
           }
         },
         "required": [
+          "execution_scope",
           "project_id",
           "task_id",
           "task_type",
@@ -5660,6 +5666,11 @@
             "title": "Execution Request Id",
             "type": "string"
           },
+          "execution_scope": {
+            "minLength": 1,
+            "title": "Execution Scope",
+            "type": "string"
+          },
           "handling_context": {
             "additionalProperties": {
               "$ref": "#/components/schemas/JsonValue"
@@ -5773,6 +5784,7 @@
           }
         },
         "required": [
+          "execution_scope",
           "project_id",
           "task_id",
           "task_type",
@@ -10211,7 +10223,8 @@
           "chart_type": {
             "enum": [
               "line",
-              "bar"
+              "bar",
+              "time_comparison"
             ],
             "title": "Chart Type",
             "type": "string"

openapi/server-manifest.json

@@ -0,0 +1,9 @@
+{
+  "contract_version": "1.0.0",
+  "contracts": {
+    "server": {
+      "file": "server-v1.openapi.json",
+      "sha256": "426b8d9170f253aa7132e9376031a7da8c04ac6f6e693948890d6f343420af1b"
+    }
+  }
+}

package.json

@@ -11,7 +11,8 @@
     "dev": "bun --watch src/server.ts",
     "build": "bun run check",
     "generate:openapi": "openapi-typescript openapi/openapi.json -o src/generated/server-api.d.ts",
-    "check:openapi": "bun run generate:openapi && git diff --exit-code -- openapi/openapi.json src/generated/server-api.d.ts",
+    "check:openapi": "bun scripts/server-contract.ts",
+    "sync:openapi": "bun scripts/server-contract.ts --sync",
     "check": "bun run typecheck && bun run typecheck:opencode",
     "check:models": "bun scripts/check-models.ts",
     "check:websearch": "bun scripts/check-websearch.ts",

scripts/server-contract.ts

@@ -0,0 +1,57 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFile, writeFile, rename, rm } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import openapiTS, { astToString, COMMENT_HEADER } from "openapi-typescript";
+
+const local = new URL("../openapi/openapi.json", import.meta.url);
+const manifest = new URL("../openapi/server-manifest.json", import.meta.url);
+const generated = new URL("../src/generated/server-api.d.ts", import.meta.url);
+const defaultUpstream = new URL("../../next-tjwater-server/contracts/server-v1.openapi.json", import.meta.url);
+
+export function assertContractDigest(raw: string, expected: string) {
+  if (createHash("sha256").update(raw).digest("hex") !== expected) throw new Error("Server contract digest differs; run bun run sync:openapi");
+}
+
+async function main() {
+  const sync = process.argv.includes("--sync");
+  const upstreamIndex = process.argv.indexOf("--upstream");
+  if (upstreamIndex >= 0 && !process.argv[upstreamIndex + 1]) throw new Error("--upstream requires an OpenAPI file");
+  const upstream = upstreamIndex >= 0 ? resolve(process.argv[upstreamIndex + 1]) : defaultUpstream;
+  let upstreamRaw: string | undefined;
+  try { upstreamRaw = await readFile(upstream, "utf8"); }
+  catch (error) {
+    if (sync || upstreamIndex >= 0 || (error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+  if (sync) {
+    const producerManifest = JSON.parse(await readFile(resolve(
+      dirname(upstream instanceof URL ? fileURLToPath(upstream) : upstream), "manifest.json"
+    ), "utf8"));
+    assertContractDigest(upstreamRaw!, producerManifest.contracts.server.sha256);
+    // Complete validation and generation before replacing any checked-in artifact.
+    const types = COMMENT_HEADER + astToString(await openapiTS(JSON.parse(upstreamRaw!)));
+    const artifacts = [
+      { target: local, content: upstreamRaw! },
+      { target: manifest, content: JSON.stringify(producerManifest, null, 2) + "\n" },
+      { target: generated, content: types },
+    ].map((artifact) => ({ ...artifact, temporary: new URL(`${artifact.target.href}.${randomUUID()}.tmp`) }));
+    try {
+      for (const artifact of artifacts) await writeFile(artifact.temporary, artifact.content);
+      for (const artifact of artifacts) await rename(artifact.temporary, artifact.target);
+    } finally {
+      await Promise.all(artifacts.map((artifact) => rm(artifact.temporary, { force: true })));
+    }
+    console.log("Server OpenAPI snapshot, producer digest and types synchronized.");
+    return;
+  }
+  const raw = await readFile(local, "utf8");
+  const receipt = JSON.parse(await readFile(manifest, "utf8"));
+  assertContractDigest(raw, receipt.contracts.server.sha256);
+  if (upstreamRaw !== undefined && upstreamRaw !== raw) throw new Error("Upstream Server contract changed; run bun run sync:openapi");
+  if (await readFile(generated, "utf8") !== COMMENT_HEADER + astToString(await openapiTS(JSON.parse(raw)))) throw new Error("Generated Server types differ; run bun run generate:openapi");
+  console.log(upstreamRaw === undefined
+    ? "Local Server contract digest and types checked; upstream unavailable in this checkout."
+    : "Upstream Server contract, digest and generated types checked.");
+}
+
+if (import.meta.main) await main();

src/chat/answer-stream-projection.ts

@@ -33,8 +33,8 @@ export function createAnswerStreamProjection(options: {
     } } as UIMessageChunk);
     options.onChange();
   };
-  const appendData = (event: string, data: Record<string, unknown>) => {
-    if (finished) return;
+  const updateData = (event: string, data: Record<string, unknown>, hostState = false) => {
+    if (finished && !hostState) return;
     if (event === "answer_ui") endText();
     const type = `data-${event}`;
     const id = [data.id, data.request_id, data.envelope_id, data.block_id].find((value): value is string => typeof value === "string");
@@ -42,9 +42,11 @@ export function createAnswerStreamProjection(options: {
     const part = id ? { type, id, data } : { type, data };
     if (existing >= 0) parts[existing] = part;
     else parts.push(part);
-    options.write(part as UIMessageChunk);
+    if (!finished) options.write(part as UIMessageChunk);
     options.onChange();
   };
+  const appendData = (event: string, data: Record<string, unknown>) => updateData(event, data);
+  const recordData = (event: string, data: Record<string, unknown>) => updateData(event, data, true);
   const finish = (finishReason: "stop" | "error" = "stop") => {
     if (finished) return;
     if (!parts.length) appendText("Agent 已完成处理。");
@@ -53,5 +55,5 @@ export function createAnswerStreamProjection(options: {
     options.onChange();
     options.write({ type: "finish", finishReason });
   };
-  return { parts, appendText, appendData, finish, get finished() { return finished; } };
+  return { parts, appendText, appendData, recordData, finish, get finished() { return finished; } };
 }

src/chat/answer-ui-catalog.json

@@ -310,7 +310,8 @@
           "type": "string",
           "enum": [
             "line",
-            "bar"
+            "bar",
+            "time_comparison"
           ]
         },
         "x_axis_name": {

src/frontendAction/command.ts

@@ -16,7 +16,7 @@ export function createViewSchemas(zod: typeof z = z, publication = false) {
   const chartSchema = z
     .object({
       title: z.string().max(200),
-      chart_type: z.enum(["line", "bar"]),
+      chart_type: z.enum(["line", "bar", "time_comparison"]),
       x_axis_name: z.string().max(128).optional(),
       y_axis_name: z.string().max(128).optional(),
       x_data: z.array(z.string().max(128)).min(1).max(100),

src/frontendAction/view-command.schema.json

@@ -211,7 +211,8 @@
               "type": "string",
               "enum": [
                 "line",
-                "bar"
+                "bar",
+                "time_comparison"
               ]
             },
             "x_axis_name": {

src/generated/server-api.d.ts

@@ -7507,6 +7507,8 @@ export interface components {
              * Format: uuid
              */
             execution_request_id: string;
+            /** Execution Scope */
+            execution_scope: string;
             /** Handling Context */
             handling_context?: {
                 [key: string]: components["schemas"]["JsonValue"];
@@ -7863,6 +7865,8 @@ export interface components {
              * Format: uuid
              */
             execution_request_id: string;
+            /** Execution Scope */
+            execution_scope: string;
             /** Handling Context */
             handling_context?: {
                 [key: string]: components["schemas"]["JsonValue"];
@@ -9600,7 +9604,7 @@ export interface components {
              * Chart Type
              * @enum {string}
              */
-            chart_type: "line" | "bar";
+            chart_type: "line" | "bar" | "time_comparison";
             /** Series */
             series: components["schemas"]["TaskSafeChartSeries"][];
             /** Title */

src/product/mcp-query-client.ts

@@ -203,7 +203,8 @@ export class McpQueryClient {
     if (!owner.context.projectId || owner.context.projectKey.startsWith("personal-") || !owner.context.purpose || !["ordinary_chat", "task_execution", "task_collaboration"].includes(owner.context.purpose)) throw error(403, "Project query context required");
     // No model-supplied identity, scope, bearer or Server URL can pass this boundary.
     const schema = this.catalog().find((tool) => tool.name === name)!.inputSchema;
-    const budget = queryTimeouts(this.tools.find((tool) => tool.name === name)!, args);
+    const definition = this.tools.find((tool) => tool.name === name)!;
+    const budget = queryTimeouts(definition, args);
     const reserved = new Set(["context_handle", "authorization", "headers", "project_id", "projectId", "network", "url", "server_url", "user_id", "subject", "client_id", "purpose", "native_session_id", "parent_session_id", "task_id", "scope", "scopes"]);
     if (Object.keys(args).some((key) => reserved.has(key) || !Object.hasOwn(schema.properties ?? {}, key))) throw error(400, "Unknown query parameter");
     const token = await this.userToken(owner.runtimeSessionId, owner.context.projectId, signal);
@@ -223,8 +224,7 @@ export class McpQueryClient {
     const handle = body.context_handle;
     try {
       return await this.withClient(token.token, project, signal, async (client) => {
-        await client.listTools(undefined, { signal, timeout: 5000 });
-        return client.callTool({ name, arguments: { ...args, ...(this.tools.find((tool) => tool.name === name)!.inputSchema.properties?.timeout_seconds ? { timeout_seconds: budget.serverMs / 1000 } : {}), context_handle: handle }, _meta: { "io.tjwater/callId": callId } }, { signal, timeout: budget.callMs });
+        return client.callTool({ name, arguments: { ...args, ...(definition.inputSchema.properties?.timeout_seconds ? { timeout_seconds: budget.serverMs / 1000 } : {}), context_handle: handle }, _meta: { "io.tjwater/callId": callId } }, { signal, timeout: budget.callMs, toolDefinition: definition });
       }, budget.callMs);
     } finally {
       // Expiry remains authoritative if transport cancellation prevents revocation.

src/routes/chat-run-accumulator.ts

@@ -0,0 +1,221 @@
+import type { UIMessage, UIMessageChunk } from "ai";
+import { createAnswerStreamProjection } from "../chat/answer-stream-projection.js";
+import type { UIEnvelopePayload } from "../uiEnvelope/types.js";
+import type { PermissionRequestPayload, QuestionRequestPayload, TodoUpdatePayload } from "./chatStream.js";
+import {
+  type ActiveRun, type RunStatus, updateLastAssistantMessage, applyInteractionResponse,
+  completeBackendProgress, cancelBackendTodos, upsertBackendProgress,
+  toFrontendPermission, upsertBackendQuestion, upsertBackendTodoUpdate,
+  appendBackendToolArtifact, appendBackendUiEnvelope,
+} from "./chatUiState.js";
+
+/** Compatibility fields are a projection of the same accepted event as canonical parts. */
+function reduceRunEvent(activeRun: ActiveRun, event: string, data: Record<string, unknown>, onStatus: (status: RunStatus) => void) {
+    if (event === "token") {
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message,
+        content: `${typeof message.content === "string" ? message.content : ""}${typeof data.content === "string" ? data.content : ""}`,
+        isError: false,
+      }));
+    } else if (event === "final_answer") {
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message, content: typeof data.content === "string" ? data.content : message.content,
+      }));
+    } else if (event === "progress") {
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message,
+        progress: upsertBackendProgress(message.progress, data),
+      }));
+    } else if (event === "done") {
+      activeRun.status = data.reason === "waiting_input" ? "waiting_input" : "completed";
+      onStatus(activeRun.status);
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message,
+        content:
+          typeof message.content === "string" && message.content.trim()
+            ? message.content
+            : data.reason === "waiting_input" ? "等待你的回答。" : "Agent 已完成处理，但没有生成文本回答。请查看过程记录，或换个更具体的问题重试。",
+        progress: completeBackendProgress(message.progress),
+      }));
+    } else if (event === "error" || event === "aborted") {
+      activeRun.status = event === "aborted" || activeRun.status === "aborted" ? "aborted" : "error";
+      onStatus(activeRun.status);
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message,
+        content:
+          typeof message.content === "string" && message.content.trim()
+            ? message.content
+            : `⚠️ **错误：** ${typeof data.message === "string" ? data.message : "unknown error"}`,
+        isError: true,
+        progress: completeBackendProgress(message.progress),
+        todos: cancelBackendTodos(message.todos),
+      }));
+    } else if (event === "permission_request") {
+      const payload = data as PermissionRequestPayload;
+      activeRun.pendingPermissions.set(payload.request_id, payload);
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message,
+        permissions: [
+          ...(Array.isArray(message.permissions) ? message.permissions : []),
+          toFrontendPermission(payload),
+        ],
+      }));
+    } else if (event === "permission_response") {
+      const requestId =
+        typeof data.request_id === "string" ? data.request_id : undefined;
+      const reply =
+        data.reply === "once" || data.reply === "always" || data.reply === "reject"
+          ? data.reply
+          : undefined;
+      if (requestId && (reply || data.status === "error")) {
+        if (reply) activeRun.pendingPermissions.delete(requestId);
+        activeRun.messages = applyInteractionResponse(activeRun.messages, "permission_response", data);
+      }
+    } else if (event === "question_request") {
+      const payload = data as QuestionRequestPayload;
+      let shouldTrackQuestion = true;
+      if (payload.tool?.callID) {
+        if (payload.request_id !== payload.tool.callID) {
+          activeRun.pendingQuestions.delete(payload.tool.callID);
+        } else {
+          const hasActionableQuestion = [...activeRun.pendingQuestions.values()].some(
+            (question) =>
+              question.tool?.callID === payload.tool?.callID &&
+              question.request_id !== payload.tool?.callID,
+          );
+          if (hasActionableQuestion) {
+            activeRun.messages = updateLastAssistantMessage(
+              activeRun.messages,
+              (message) => ({
+                ...message,
+                questions: upsertBackendQuestion(message.questions, payload),
+              }),
+            );
+            shouldTrackQuestion = false;
+          }
+        }
+      }
+      if (shouldTrackQuestion) {
+        activeRun.pendingQuestions.set(payload.request_id, payload);
+        activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+          ...message,
+          questions: upsertBackendQuestion(message.questions, payload),
+        }));
+      }
+    } else if (event === "question_response") {
+      const requestId =
+        typeof data.request_id === "string" ? data.request_id : undefined;
+      if (requestId) {
+        activeRun.pendingQuestions.delete(requestId);
+        activeRun.messages = applyInteractionResponse(activeRun.messages, "question_response", data);
+      }
+    } else if (event === "execution_plan") {
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message, executionPlans: [...(Array.isArray(message.executionPlans) ? message.executionPlans : []), data],
+      }));
+    } else if (event === "todo_update") {
+      const payload = data as TodoUpdatePayload;
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message,
+        todos: upsertBackendTodoUpdate(message.todos, payload),
+      }));
+    } else if (event === "tool_call") {
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message,
+        artifacts: appendBackendToolArtifact(message.artifacts, data),
+      }));
+    } else if (event === "ui_envelope") {
+      const payload = data as UIEnvelopePayload;
+      activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+        ...message,
+        uiEnvelopes: appendBackendUiEnvelope(message.uiEnvelopes, payload),
+      }));
+    }
+
+}
+
+/** All host mutations go through the accumulator before subscribers or persistence. */
+export function publishRunEvent(run: ActiveRun, event: string, data: Record<string, unknown>, notify = true) {
+  if (run.applyEvent) run.applyEvent(event, data);
+  else reduceRunEvent(run, event, data, () => {});
+  if (notify) for (const subscriber of run.subscribers) {
+    if (event === "done" || event === "error" || event === "aborted") {
+      subscriber.write("run_status", { ...data, id: "run-status", status: run.status });
+    }
+    subscriber.write(event, data);
+  }
+}
+
+/** One event owner updates the reconnect view and canonical wire/storage projections. */
+export function createChatRunAccumulator(options: {
+  run: ActiveRun;
+  messages: UIMessage[];
+  messageId: string;
+  sessionId: string;
+  collaboration: boolean;
+  write: (chunk: UIMessageChunk) => void;
+  onStatus: (status: RunStatus) => void;
+}) {
+  const activeRun = options.run;
+  let history = [...options.messages];
+  const syncParts = () => {
+    activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
+      ...message, id: options.messageId, parts: projection.parts.map((part) => ({ ...part })),
+    }));
+  };
+  const projection = createAnswerStreamProjection({
+    messageId: options.messageId, sessionId: options.sessionId,
+    write: options.write, onChange: syncParts,
+  });
+  const apply = (event: string, data: Record<string, unknown>) => {
+    reduceRunEvent(activeRun, event, data, options.onStatus);
+    let historicalResponse = false;
+    if (event === "permission_response" || event === "question_response") {
+      const updated = applyInteractionResponse(history, event, data);
+      historicalResponse = updated !== history;
+      history = updated;
+      if (historicalResponse) {
+        const byId = new Map(history.map((message) => [message.id, message]));
+        activeRun.messages = activeRun.messages.map((message) => {
+          if (!message || typeof message !== "object" || !("id" in message)) return message;
+          const canonical = byId.get(String(message.id));
+          return canonical ? { ...message, parts: canonical.parts } : message;
+        });
+      }
+    }
+
+    const hidden = options.collaboration && ["progress", "todo_update", "tool_call", "ui_envelope", "execution_plan"].includes(event);
+    if (!hidden && !historicalResponse) {
+      if (event === "token") projection.appendText(typeof data.content === "string" ? data.content : "");
+      else if (event === "done" || event === "error" || event === "aborted") {
+        const message = typeof data.message === "string" ? data.message : event === "aborted" ? "请求已中断" : "Agent stream failed";
+        if (!projection.parts.some((part) => ["text", "data-final_answer", "data-answer_ui"].includes(String(part.type)))) {
+          const assistant = activeRun.messages.at(-1) as { content?: string } | undefined;
+          projection.appendText(assistant?.content || message);
+        }
+        projection.recordData("run_status", { id: "run-status", status: activeRun.status, ...(event === "done" ? {} : { message }) });
+        if (event !== "done" && !projection.finished) options.write({ type: "error", errorText: message });
+        projection.finish(event === "done" ? "stop" : "error");
+      } else if (["permission_response", "question_response"].includes(event)) projection.recordData(event, data);
+      else projection.appendData(event, data);
+    }
+    syncParts();
+  };
+  const uiMessages = (): UIMessage[] => [...history, {
+    id: options.messageId, role: "assistant", parts: projection.parts.map((part) => ({ ...part })),
+  } as UIMessage];
+  activeRun.applyEvent = apply;
+  activeRun.uiMessages = uiMessages;
+  return {
+    apply,
+    finish: projection.finish,
+    get finished() { return projection.finished; },
+    uiMessages,
+    appendInput(message: UIMessage, text: string) {
+      if (history.some((item) => item.id === message.id)) return;
+      history.push(message);
+      const tail = activeRun.messages.at(-1);
+      activeRun.messages = [...activeRun.messages.slice(0, -1), { id: message.id, role: "user", content: text }, ...(tail ? [tail] : [])];
+    },
+  };
+}

src/routes/chatAuxiliaryRoutes.ts

@@ -1,3 +1,5 @@
+import { publishRunEvent } from "./chat-run-accumulator.js";
+import { toSessionScope } from "../sessions/session-scope.js";
 import { type Router } from "express";
 import { z } from "zod";
 import type { InteractionRequestStore } from "../sessions/interaction-request-store.js";
@@ -13,9 +15,6 @@ import { type FrontendActionCoordinator } from "../frontendAction/coordinator.js
 import {
   type ActiveRun,
   type RunStatus,
-  cancelBackendTodos,
-  completeBackendProgress,
-  updateLastAssistantMessage,
 } from "./chatUiState.js";
 
 const abortPayloadSchema = z.object({
@@ -33,11 +32,6 @@ type RegisterAuxiliaryRoutesOptions = {
   frontendActionCoordinator: FrontendActionCoordinator;
 };
 
-const toSessionUiStateContext = (record: { sessionId: string; actorKey: string; projectKey: string }) => ({
-  sessionId: record.sessionId,
-  actorKey: record.actorKey,
-  projectKey: record.projectKey,
-});
 
 export const registerChatAuxiliaryRoutes = (
   chatRouter: Router,
@@ -80,12 +74,12 @@ export const registerChatAuxiliaryRoutes = (
       const runtimeContext = getRuntimeSessionContext(sessionRecord.sessionId);
       if (runtimeContext) setRuntimeSessionContext({ ...runtimeContext, hostQuestionClosed: true });
       activeRuns.get(sessionRecord.sessionId)?.controller.abort();
-      await interactionRequestStore?.cancelPending(toSessionUiStateContext(sessionRecord));
-      const pendingInteraction = await interactionRequestStore?.getBlocking(toSessionUiStateContext(sessionRecord));
+      await interactionRequestStore?.cancelPending(toSessionScope(sessionRecord));
+      const pendingInteraction = await interactionRequestStore?.getBlocking(toSessionScope(sessionRecord));
       if (pendingInteraction?.delivery && runtime && interactionRequestStore) {
         const status = await runtime.stopInteractionInput(sessionRecord.sessionId, pendingInteraction.delivery.native_message_id);
-        const latest = await interactionRequestStore.get(toSessionUiStateContext(sessionRecord), pendingInteraction.interaction_id);
-        if (latest?.delivery && !["delivered", "cancelled"].includes(latest.delivery.status)) await interactionRequestStore.updateDelivery(toSessionUiStateContext(sessionRecord), latest.interaction_id, {
+        const latest = await interactionRequestStore.get(toSessionScope(sessionRecord), pendingInteraction.interaction_id);
+        if (latest?.delivery && !["delivered", "cancelled"].includes(latest.delivery.status)) await interactionRequestStore.updateDelivery(toSessionScope(sessionRecord), latest.interaction_id, {
           expected_revision: latest.delivery.revision, status,
         });
       }
@@ -99,28 +93,21 @@ export const registerChatAuxiliaryRoutes = (
         run.status = "aborted";
         lastRunStatuses.set(parsed.data.session_id, "aborted");
         run.controller.abort();
-        run.messages = updateLastAssistantMessage(run.messages, (message) => ({
-          ...message,
-          content:
-            typeof message.content === "string" && message.content.trim()
-              ? message.content
-              : "⚠️ **请求已中断**",
-          isError: true,
-          progress: completeBackendProgress(message.progress),
-          todos: cancelBackendTodos(message.todos),
-        }));
+        publishRunEvent(run, "aborted", { session_id: parsed.data.session_id, message: "请求已中断" }, false);
         const currentState = await sessionUiStateStore.read(
-          toSessionUiStateContext(sessionRecord),
+          toSessionScope(sessionRecord),
         );
-        await sessionUiStateStore.write(toSessionUiStateContext(sessionRecord), {
+        await sessionUiStateStore.write(toSessionScope(sessionRecord), {
           sessionId: sessionRecord.sessionId,
           isTitleManuallyEdited: currentState?.isTitleManuallyEdited ?? false,
-          messages: run.messages,
+          ...currentState,
+          messages: run.uiMessages?.() ?? run.messages,
         });
         for (const subscriber of run.subscribers) {
           subscriber.write("error", {
             session_id: parsed.data.session_id,
             message: "请求已中断",
+            status: "aborted",
           });
         }
         // The generation route emits its terminal Response after cleanup and

src/routes/chatInteractionRoutes.ts

@@ -1,3 +1,5 @@
+import { publishRunEvent } from "./chat-run-accumulator.js";
+import { toSessionScope } from "../sessions/session-scope.js";
 import { refreshSessionCredential } from "../product/credential-refresh.js";
 import { type Router } from "express";
 import { z } from "zod";
@@ -8,9 +10,7 @@ import { type OpencodeRuntimeAdapter } from "../runtime/opencode.js";
 import { SessionContextMismatchError, type SessionMetadataStore } from "../sessions/metadataStore.js";
 import { type SessionUiStateStore } from "../sessions/uiStateStore.js";
 import {
-  type ActiveRun,
-  toPermissionStatus,
-  updateLastAssistantPermission,
+  type ActiveRun, applyInteractionResponse,
 } from "./chatUiState.js";
 
 const permissionReplyPayloadSchema = z.object({
@@ -35,7 +35,6 @@ type RegisterInteractionRoutesOptions = {
   sessionUiStateStore: SessionUiStateStore;
 };
 
-const toSessionUiStateContext = (sessionId: string) => ({ sessionId });
 
 export const registerChatInteractionRoutes = (
   chatRouter: Router,
@@ -104,12 +103,13 @@ export const registerChatInteractionRoutes = (
       }
       const persistPermissionState = async () => {
         const currentState = await sessionUiStateStore.read(
-          toSessionUiStateContext(sessionRecord.sessionId),
+          toSessionScope(sessionRecord),
         );
-        await sessionUiStateStore.write(toSessionUiStateContext(sessionRecord.sessionId), {
+        await sessionUiStateStore.write(toSessionScope(sessionRecord), {
           sessionId: sessionRecord.sessionId,
           isTitleManuallyEdited: currentState?.isTitleManuallyEdited ?? false,
-          messages: run.messages,
+          ...currentState,
+          messages: run.uiMessages?.() ?? run.messages,
         });
       };
 
@@ -121,18 +121,10 @@ export const registerChatInteractionRoutes = (
           message: parsed.data.message,
         });
       } catch (error) {
-        run.messages = updateLastAssistantPermission(
-          run.messages,
-          requestId,
-          (permission) => ({
-            ...permission,
-            status: "error",
-            error:
-              error instanceof Error
-                ? error.message
-                : "failed to reply permission",
-          }),
-        );
+        publishRunEvent(run, "permission_response", {
+          session_id: sessionRecord.sessionId, request_id: requestId, status: "error",
+          error: error instanceof Error ? error.message : "failed to reply permission",
+        });
         await persistPermissionState().catch((persistError) => {
           logger.warn(
             { err: persistError, sessionId: sessionRecord.sessionId },
@@ -146,30 +138,15 @@ export const registerChatInteractionRoutes = (
         return;
       }
 
-      run.pendingPermissions.delete(requestId);
-      const status = toPermissionStatus(parsed.data.reply);
-      run.messages = updateLastAssistantPermission(
-        run.messages,
-        requestId,
-        (permission) => ({
-          ...permission,
-          status,
-          repliedAt: Date.now(),
-        }),
-      );
+      publishRunEvent(run, "permission_response", {
+        session_id: sessionRecord.sessionId, request_id: requestId, reply: parsed.data.reply,
+      });
       await persistPermissionState().catch((persistError) => {
         logger.warn(
           { err: persistError, sessionId: sessionRecord.sessionId },
           "failed to persist permission reply state",
         );
       });
-      for (const subscriber of run.subscribers) {
-        subscriber.write("permission_response", {
-          session_id: sessionRecord.sessionId,
-          request_id: requestId,
-          reply: parsed.data.reply,
-        });
-      }
 
       res.status(202).json({
         session_id: sessionRecord.sessionId,
@@ -219,23 +196,19 @@ export const registerChatInteractionRoutes = (
         }
       }
       // A host-confirmed reply remains authoritative after native forms are pruned.
-      const nativeStatus = confirmedStatus ? undefined : await runtime.getQuestionStatus({ sessionId: session.sessionId, requestId: canonicalId });
+      const form = confirmedStatus ? undefined : await runtime.getQuestion({ sessionId: session.sessionId, requestId: canonicalId });
+      const nativeStatus = form?.state.status ?? "missing";
       const status = confirmedStatus ?? (nativeStatus === "cancelled" ? "rejected" : nativeStatus === "missing" ? "invalidated" : nativeStatus!);
       const persist = async (nextStatus: string, answers?: string[][]) => {
-        const update = (messages: unknown[]) => messages.map((message) => {
-          if (!isRecord(message)) return message;
-          const questions = Array.isArray(message.questions) ? message.questions.map((q: unknown) => isRecord(q) && q.requestId === canonicalId ? { ...q, status: nextStatus, ...(answers ? { answers } : {}), error: undefined } : q) : undefined;
-          const parts = Array.isArray(message.parts) ? [...message.parts] : undefined;
-          if (parts && nextStatus !== "pending" && parts.some((part: unknown) => isRecord(part) && part.type === "data-question_request" && isRecord(part.data) && part.data.request_id === canonicalId)) {
-            const response = { type: "data-question_response", data: { session_id: session.sessionId, request_id: canonicalId, status: nextStatus, rejected: nextStatus === "rejected" || nextStatus === "invalidated", ...(answers ? { answers } : {}) } };
-            const index = parts.findIndex((part: unknown) => isRecord(part) && part.type === "data-question_response" && isRecord(part.data) && part.data.request_id === canonicalId);
-            if (index >= 0) parts[index] = { ...parts[index], data: { ...(isRecord(parts[index]) && isRecord(parts[index].data) ? parts[index].data : {}), ...response.data } }; else parts.push(response);
-          }
-          return { ...message, ...(questions ? { questions } : {}), ...(parts ? { parts } : {}) };
-        });
+        const response = {
+          session_id: session.sessionId, request_id: canonicalId, status: nextStatus,
+          rejected: nextStatus === "rejected" || nextStatus === "invalidated", ...(answers ? { answers } : {}),
+        };
         // Update the live projection before entering the same atomic persistence queue.
-        if (run) { run.messages = update(run.messages); if (nextStatus !== "pending") run.pendingQuestions.delete(canonicalId); }
-        await sessionUiStateStore.update(context, (latest) => ({ ...latest, messages: update(latest.messages) }));
+        if (run && nextStatus !== "pending") publishRunEvent(run, "question_response", response);
+        await sessionUiStateStore.update(context, (latest) => ({
+          ...latest, messages: applyInteractionResponse(latest.messages, "question_response", response),
+        }));
       };
       if (action === "status" || status !== "pending") {
         await persist(status);
@@ -243,10 +216,9 @@ export const registerChatInteractionRoutes = (
         return;
       }
       const answers = action === "reply" ? questionReplyPayloadSchema.parse(req.body).answers : undefined;
-      if (action === "reply") await runtime.replyQuestion({ sessionId: session.sessionId, requestId: canonicalId, answers: answers ?? [] });
+      if (action === "reply") await runtime.replyQuestion({ sessionId: session.sessionId, requestId: canonicalId, answers: answers ?? [], form: form! });
       else await runtime.rejectQuestion({ sessionId: session.sessionId, requestId: canonicalId });
       await persist(action === "reply" ? "answered" : "rejected", answers);
-      for (const subscriber of run?.subscribers ?? []) subscriber.write("question_response", { session_id: session.sessionId, request_id: canonicalId, ...(action === "reply" ? { answers } : { rejected: true }) });
       if (run && run.status !== "running" && !run.pendingPermissions.size && !run.pendingQuestions.size) activeRuns.delete(session.sessionId);
       res.status(202).json({ session_id: session.sessionId, request_id: canonicalId, ...(action === "reply" ? { answers } : { rejected: true }) });
     } catch (error) {

src/routes/chatPermissionPolicy.ts

@@ -1,5 +1,5 @@
 // Called only for native "asked" events. Explicit denials and host isolation
 // still run before this point; the selected round mode answers pending requests.
-export function canAutomaticallyApprove(mode: string, _action: string) {
-  return mode === "always";
+export function canAutomaticallyApprove(mode: string, action: string, backgroundSandboxPermissions = false) {
+  return mode === "always" || (backgroundSandboxPermissions && (action === "shell" || action === "edit"));
 }

src/routes/chatSession.ts

@@ -174,27 +174,6 @@ export const generateSessionTitle = async (
   }
 };
 
-export const getConversationTurnStats = async (
-  runtime: OpencodeRuntimeAdapter,
-  sessionId: string,
-) => {
-  const messages = await runtime.messages(sessionId, 12);
-  return messages.reduce(
-    (stats, message) => {
-      if (message.info.role === "user") {
-        stats.userMessageCount += 1;
-      } else if (message.info.role === "assistant") {
-        stats.assistantMessageCount += 1;
-      }
-      return stats;
-    },
-    {
-      userMessageCount: 0,
-      assistantMessageCount: 0,
-    },
-  );
-};
-
 export const buildPromptWithLearningContext = async (
   memoryStore: MemoryStore,
   actorKey: string,

src/routes/chatSessionRoutes.ts

@@ -1,3 +1,4 @@
+import { toSessionScope } from "../sessions/session-scope.js";
 import { registerChatTopicRoutes } from "./chat-topic-routes.js";
 import { matchHistoryText } from "../sessions/history-search.js";
 import { credentialRefreshCoordinator } from "../product/credential-refresh.js";
@@ -107,15 +108,51 @@ type RegisterChatSessionRoutesOptions = {
   sessionUiStateStore: SessionUiStateStore;
 };
 
-const toSessionUiStateContext = (sessionRecord: SessionRecord) => ({
-  sessionId: sessionRecord.sessionId,
-  actorKey: sessionRecord.actorKey,
-  projectKey: sessionRecord.projectKey,
-});
 
 const toSse = (event: string, data: Record<string, unknown>) =>
   `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
 
+export async function runBackgroundTaskExecution(input: {
+  sessionId: string;
+  credential: ProductCredential;
+  model: string;
+  workflow?: string;
+  isRunning: () => boolean;
+}) {
+  const { sessionId, credential, model, workflow } = input;
+  const baseUrl = process.env.TJWATER_AGENT_INTERNAL_BASE_URL ?? `http://127.0.0.1:${config.PORT}`;
+  await fetch(new URL("/api/v1/responses", baseUrl), {
+    method: "POST",
+    headers: {
+      Authorization: credential.authorization,
+      "Content-Type": "application/json",
+      "X-Project-Id": credential.projectId,
+    },
+    body: JSON.stringify({
+      conversation: sessionId,
+      model,
+      stream: true,
+      input: buildTaskExecutionPrompt(workflow),
+    }),
+  }).then(async (response) => {
+    const reader = response.body?.getReader();
+    if (reader) {
+      while (!(await reader.read()).done) {
+        // Drain the stream without retaining the model response in memory.
+      }
+    }
+    if (!response.ok) {
+      if (!input.isRunning()) clearOperationalTaskLease(sessionId);
+      logger.error({ sessionId, status: response.status, executionContinues: input.isRunning() }, "background task execution failed");
+    }
+  }).catch((error) => {
+    // A lost response stream does not end the host-owned execution. Its route
+    // still renews/finalizes the lease and owns cleanup of the cached revision.
+    if (!input.isRunning()) clearOperationalTaskLease(sessionId);
+    logger.warn({ err: error, sessionId, executionContinues: input.isRunning() }, "background task response stream failed");
+  });
+}
+
 export const registerChatSessionRoutes = (
   chatRouter: Router,
   options: RegisterChatSessionRoutesOptions,
@@ -135,6 +172,12 @@ export const registerChatSessionRoutes = (
   const { activeRuns, lastRunStatuses } = runState;
   const getSessionRunStatus = runState.getStatus;
 
+  const readMessages = (record: SessionRecord, state: { messages: unknown[] } | null) => {
+    if (readPurpose(record) === "task_collaboration") return state?.messages ?? [];
+    const run = activeRuns.get(record.sessionId);
+    return run?.uiMessages?.() ?? run?.messages ?? state?.messages ?? [];
+  };
+
   const withInteractionReplies = async (record: SessionRecord, messages: unknown[]) => {
     if (!interactionRequestStore) return messages;
     const ids = new Set(messages.flatMap((message) => {
@@ -142,7 +185,7 @@ export const registerChatSessionRoutes = (
       const value = message as Record<string, unknown>;
       return value.role === "user" && typeof value.id === "string" ? [value.id] : [];
     }));
-    const replies = await interactionRequestStore.forMessages(toSessionUiStateContext(record), ids);
+    const replies = await interactionRequestStore.forMessages(toSessionScope(record), ids);
     return projectInteractionReplyMessages(messages, replies);
   };
 
@@ -151,7 +194,7 @@ export const registerChatSessionRoutes = (
       || !isGenericTaskCollaborationTitle(record.title)) return record;
     if ((!credential && !knownTaskTitle) || signal?.aborted) return record;
     try {
-      const state = await sessionUiStateStore.read(toSessionUiStateContext(record));
+      const state = await sessionUiStateStore.read(toSessionScope(record));
       if (state?.isTitleManuallyEdited) return record;
       let taskTitle = knownTaskTitle;
       if (!taskTitle && credential) {
@@ -165,7 +208,7 @@ export const registerChatSessionRoutes = (
         }
       }
       if (!taskTitle?.trim()) return record;
-      const latestState = await sessionUiStateStore.read(toSessionUiStateContext(record));
+      const latestState = await sessionUiStateStore.read(toSessionScope(record));
       if (latestState?.isTitleManuallyEdited) return record;
       return await sessionMetadataStore.touch(record, { title: taskTitle }, {
         preserveUpdatedAt: true, expectedTitle: record.title ?? "",
@@ -183,35 +226,8 @@ export const registerChatSessionRoutes = (
     workflow?: string,
   ) => {
     queueMicrotask(() => {
-      const baseUrl = process.env.TJWATER_AGENT_INTERNAL_BASE_URL ?? `http://127.0.0.1:${config.PORT}`;
-      void fetch(new URL("/api/v1/responses", baseUrl), {
-        method: "POST",
-        headers: {
-          Authorization: credential.authorization,
-          "Content-Type": "application/json",
-          "X-Project-Id": credential.projectId,
-        },
-        body: JSON.stringify({
-          conversation: record.sessionId,
-          model,
-          stream: true,
-          input: buildTaskExecutionPrompt(workflow),
-        }),
-      }).then(async (response) => {
-        const reader = response.body?.getReader();
-        if (reader) {
-          while (!(await reader.read()).done) {
-            // Drain the stream without retaining the model response in memory.
-          }
-        }
-        if (!response.ok) {
-          clearOperationalTaskLease(record.sessionId);
-          logger.error({ sessionId: record.sessionId, status: response.status }, "background task execution failed");
-        }
-      }).catch((error) => {
-        clearOperationalTaskLease(record.sessionId);
-        logger.error({ err: error, sessionId: record.sessionId }, "background task execution request failed");
-      });
+      void runBackgroundTaskExecution({ sessionId: record.sessionId, credential, model, workflow,
+        isRunning: () => activeRuns.get(record.sessionId)?.status === "running" });
     });
   };
 
@@ -283,7 +299,7 @@ export const registerChatSessionRoutes = (
       sessionId,
     );
     if (!record) return null;
-    const state = await sessionUiStateStore.read(toSessionUiStateContext(record));
+    const state = await sessionUiStateStore.read(toSessionScope(record));
     if (!state) return null;
     return { record, state, taskTitle };
   };
@@ -589,7 +605,7 @@ export const registerChatSessionRoutes = (
     const titled = await sessionMetadataStore.touch(record, { title: `${history.taskTitle} · 调试` });
     const messages = await withInteractionReplies(history.record, history.state.messages ?? []);
     await sessionUiStateStore.write(
-      toSessionUiStateContext(titled),
+      toSessionScope(titled),
       buildForkedSessionUiState({ messages }, {
         keepMessageCount: messages.length,
         targetSessionId: titled.sessionId,
@@ -757,8 +773,8 @@ export const registerChatSessionRoutes = (
     const searchable: Array<SessionRecord & { searchSnippet?: string }> = [];
     for (const record of records) {
       const titleMatches = (record.title ?? "新对话").toLocaleLowerCase().includes((query.data.q ?? "").toLocaleLowerCase());
-      const state = query.data.q && !titleMatches ? await sessionUiStateStore.read(toSessionUiStateContext(record)) : null;
-      const messages = activeRuns.get(record.sessionId)?.messages ?? state?.messages ?? [];
+      const state = query.data.q && !titleMatches ? await sessionUiStateStore.read(toSessionScope(record)) : null;
+      const messages = readMessages(record, state);
       searchable.push({ ...record, searchSnippet: query.data.q && !titleMatches ? matchHistoryText(messages, query.data.q) : undefined });
     }
     let page;
@@ -814,9 +830,8 @@ export const registerChatSessionRoutes = (
     const context = getLocalAgentContext(req);
     const record = await sessionMetadataStore.get(context, req.params.session_id);
     if (!record) { res.status(404).json({ message: "session not found" }); return; }
-    const state = await sessionUiStateStore.read(toSessionUiStateContext(record));
-    const messages = readPurpose(record) === "task_collaboration" ? state?.messages ?? []
-      : activeRuns.get(record.sessionId)?.messages ?? state?.messages ?? [];
+    const state = await sessionUiStateStore.read(toSessionScope(record));
+    const messages = readMessages(record, state);
     try {
       const page = sessionMessagePage(messages, { scope: historyScope([record.actorKey, record.projectKey, record.sessionId]), ...query.data });
       res.json({ ...page, messages: await withInteractionReplies(record, page.messages) });
@@ -857,10 +872,9 @@ export const registerChatSessionRoutes = (
     sessionRecord = await refreshCollaborationTitle(sessionRecord, getTrustedProductCredential(req));
 
     const state = await sessionUiStateStore.read(
-      toSessionUiStateContext(sessionRecord),
+      toSessionScope(sessionRecord),
     );
-    const messages = readPurpose(sessionRecord) === "task_collaboration" ? state?.messages ?? []
-      : activeRuns.get(sessionRecord.sessionId)?.messages ?? state?.messages ?? [];
+    const messages = readMessages(sessionRecord, state);
     const messagePayload = query.data.message_limit ? sessionMessagePage(messages, {
       scope: historyScope([sessionRecord.actorKey, sessionRecord.projectKey, sessionId]), limit: query.data.message_limit,
     }) : { messages };
@@ -915,9 +929,8 @@ export const registerChatSessionRoutes = (
     res.flushHeaders?.();
 
     const run = activeRuns.get(sessionRecord.sessionId);
-    const state = await sessionUiStateStore.read(toSessionUiStateContext(sessionRecord));
-    const messages = readPurpose(sessionRecord) === "task_collaboration" ? state?.messages ?? []
-      : run?.messages ?? state?.messages ?? [];
+    const state = await sessionUiStateStore.read(toSessionScope(sessionRecord));
+    const messages = readMessages(sessionRecord, state);
     const messagePayload = query.data.message_limit ? sessionMessagePage(messages, {
       scope: historyScope([sessionRecord.actorKey, sessionRecord.projectKey, sessionId]), limit: query.data.message_limit,
     }) : { messages };
@@ -991,11 +1004,11 @@ export const registerChatSessionRoutes = (
       title,
     });
     const state = await sessionUiStateStore.read(
-      toSessionUiStateContext(nextSessionRecord),
+      toSessionScope(nextSessionRecord),
     );
     if (state) {
       await sessionUiStateStore.write(
-        toSessionUiStateContext(nextSessionRecord),
+        toSessionScope(nextSessionRecord),
         {
           ...state,
           isTitleManuallyEdited:
@@ -1120,7 +1133,7 @@ export const registerChatSessionRoutes = (
       }
       const sourceState = sourceSessionRecord
         ? await sessionUiStateStore.read(
-            toSessionUiStateContext(sourceSessionRecord),
+            toSessionScope(sourceSessionRecord),
           )
         : null;
       const forkTitle = sourceSessionRecord?.title
@@ -1131,7 +1144,7 @@ export const registerChatSessionRoutes = (
         { title: forkTitle },
       );
       await sessionUiStateStore.write(
-        toSessionUiStateContext(titledTargetSessionRecord),
+        toSessionScope(titledTargetSessionRecord),
         buildForkedSessionUiState(sourceState, {
           keepMessageCount: parsed.data.keep_message_count,
           targetSessionId: nextSessionId,

src/routes/chatStream.ts

@@ -84,6 +84,7 @@ type StreamPromptOptions = {
   message: string;
   model?: SupportedModel;
   approvalMode?: ApprovalMode;
+  backgroundSandboxPermissions?: boolean;
   traceId?: string;
   projectId?: string;
   signal?: AbortSignal;
@@ -148,6 +149,7 @@ export const streamPromptResponse = async ({
   message,
   model,
   approvalMode = "request",
+  backgroundSandboxPermissions = false,
   traceId,
   projectId,
   signal,
@@ -481,7 +483,7 @@ export const streamPromptResponse = async ({
           patterns: event.properties.patterns,
           elapsedMs: Math.max(0, Date.now() - requestStartedAt),
         });
-        const autoApprove = canAutomaticallyApprove(approvalMode, event.properties.permission);
+        const autoApprove = canAutomaticallyApprove(approvalMode, event.properties.permission, backgroundSandboxPermissions);
         emitProgress({
           id: `permission-${event.properties.id}`,
           phase: "permission",
@@ -489,7 +491,9 @@ export const streamPromptResponse = async ({
           title: autoApprove ? "已自动允许权限请求" : "等待权限确认",
           detail:
             autoApprove
-              ? "当前模式为本轮自动批准，已允许本次请求，不保存后续轮次授权。"
+              ? approvalMode === "always"
+                ? "当前模式为本轮自动批准，已允许本次请求，不保存后续轮次授权。"
+                : "后台任务的会话内 Shell / 文件修改已自动批准；目录边界与明确拒绝规则仍生效。"
               : buildPermissionDetail(event),
         });
         if (autoApprove) {
@@ -529,7 +533,7 @@ export const streamPromptResponse = async ({
           resources: event.properties.resources,
           elapsedMs: Math.max(0, Date.now() - requestStartedAt),
         });
-        const autoApprove = canAutomaticallyApprove(approvalMode, event.properties.action);
+        const autoApprove = canAutomaticallyApprove(approvalMode, event.properties.action, backgroundSandboxPermissions);
         emitProgress({
           id: `permission-${event.properties.id}`,
           phase: "permission",
@@ -537,7 +541,9 @@ export const streamPromptResponse = async ({
           title: autoApprove ? "已自动允许权限请求" : "等待权限确认",
           detail:
             autoApprove
-              ? "当前模式为本轮自动批准，已允许本次请求，不保存后续轮次授权。"
+              ? approvalMode === "always"
+                ? "当前模式为本轮自动批准，已允许本次请求，不保存后续轮次授权。"
+                : "后台任务的会话内 Shell / 文件修改已自动批准；目录边界与明确拒绝规则仍生效。"
               : buildPermissionV2Detail(event),
         });
         if (autoApprove) {

src/routes/chatStreamRoute.ts

@@ -1,3 +1,4 @@
+import { toSessionScope } from "../sessions/session-scope.js";
 import type { TaskCalculationWaiter } from "../mcp/task-calculation-waiter.js";
 import { createResponsesProjection, responseRequestSchema, responsePrompt } from "../chat/responses-protocol.js";
 import { ResponseInputTracker, WaitingResponseInputQueue } from "../chat/response-inputs.js";
@@ -5,7 +6,7 @@ import { reconcileInteractionDelivery } from "../sessions/interaction-delivery-r
 import type { InteractionRequestStore } from "../sessions/interaction-request-store.js";
 import { renderInteractionAnswer, type InteractionRequest } from "../chat/interaction-request-contract.js";
 import { createInteractionReplyMessage } from "../chat/interaction-message-presentation.js";
-import { createAnswerStreamProjection } from "../chat/answer-stream-projection.js";
+import { createChatRunAccumulator, publishRunEvent } from "./chat-run-accumulator.js";
 import type { AgentMessageCoordinator } from "../chat/agent-message-coordinator.js";
 import { credentialRefreshCoordinator } from "../product/credential-refresh.js";
 import { type Router } from "express";
@@ -47,7 +48,6 @@ import {
 } from "../product/operational-task-client.js";
 import { type SessionTranscriptStore } from "../sessions/transcriptStore.js";
 import { type SessionUiStateStore } from "../sessions/uiStateStore.js";
-import type { UIEnvelopePayload } from "../uiEnvelope/types.js";
 import { toActorKey, toProjectKey } from "../utils/fileStore.js";
 import {
   buildPromptWithLearningContext,
@@ -59,29 +59,14 @@ import {
 } from "./chatSession.js";
 import {
   collectTextContent,
-  type PermissionRequestPayload,
-  type QuestionRequestPayload,
   streamPromptResponse,
-  type TodoUpdatePayload,
 } from "./chatStream.js";
 import { type ChatRunState } from "./chatRunState.js";
 import {
   type ActiveRun,
-  type StreamSubscriber,
-  appendBackendToolArtifact,
-  appendBackendUiEnvelope,
-  cancelBackendTodos,
-  completeBackendProgress,
   createInitialStreamingMessages,
   isObjectRecord,
-  toFrontendPermission,
-  toPermissionStatus,
   updateLastAssistantMessage,
-  updateLastAssistantPermission,
-  updateLastAssistantQuestion,
-  upsertBackendProgress,
-  upsertBackendQuestion,
-  upsertBackendTodoUpdate,
 } from "./chatUiState.js";
 import {
   agentTriggerContextSchema,
@@ -106,11 +91,6 @@ const payloadSchema = z.object({
   }).strict().optional(),
 });
 
-const toSessionUiStateContext = (sessionRecord: SessionRecord) => ({
-  sessionId: sessionRecord.sessionId,
-  actorKey: sessionRecord.actorKey,
-  projectKey: sessionRecord.projectKey,
-});
 
 const runtimeHasConversation = async (
   runtime: OpencodeRuntimeAdapter,
@@ -311,7 +291,7 @@ export const registerChatStreamRoute = (
     let boundOperationalSessionId: string | undefined;
     let startingSessionId: string | undefined;
     let continuation: InteractionRequest | null = null;
-    let continuationScope: ReturnType<typeof toSessionUiStateContext> | undefined;
+    let continuationScope: ReturnType<typeof toSessionScope> | undefined;
     let waitingInteraction: InteractionRequest | null = null;
     try {
       const authContext = getLocalAgentContext(req);
@@ -365,7 +345,7 @@ export const registerChatStreamRoute = (
         res.status(400).json({ message: "Interaction continuation requires an existing conversation" }); return;
       }
       if (existingSessionRecord && interactionRequestStore) {
-        continuationScope = toSessionUiStateContext(existingSessionRecord);
+        continuationScope = toSessionScope(existingSessionRecord);
         if (input.tjwater.interaction_id) {
           continuation = await interactionRequestStore.get(continuationScope, input.tjwater.interaction_id);
           if (!continuation?.delivery || !["answered", "skipped"].includes(continuation.status) || continuation.delivery.status === "cancelled") {
@@ -523,7 +503,7 @@ export const registerChatStreamRoute = (
         sessionId: requestContext.clientSessionId,
       };
       const initialSessionState = await sessionUiStateStore.read(
-        toSessionUiStateContext(activeSessionRecord),
+        toSessionScope(activeSessionRecord),
       );
       const persistedUiMessages = toUiMessages(initialSessionState?.messages);
       if (!continuation && input.tjwater.client_message_id && persistedUiMessages.some((message) => message.id === input.tjwater.client_message_id)) {
@@ -551,7 +531,6 @@ export const registerChatStreamRoute = (
               ...visiblePersistedMessages,
               createFallbackUserUiMessage(promptText, input.tjwater.client_message_id),
             ];
-      let latestUiMessages = requestMessages;
       const baseMessages = toLegacyMessages(requestMessages);
       const recentTurns = await sessionTranscriptStore.getRecentTurns(historyContext, 8);
 
@@ -605,44 +584,28 @@ export const registerChatStreamRoute = (
       startingSessions.delete(activeSessionRecord.sessionId);
       startingSessionId = undefined;
       lastRunStatuses.set(clientSessionId, "running");
-      const sessionUiStateContext = toSessionUiStateContext(activeSessionRecord);
+      const sessionUiStateContext = toSessionScope(activeSessionRecord);
       const assistantUiMessageId = continuationAssistantId ?? `msg_${randomUUID().replaceAll("-", "")}`;
       setRuntimeSessionContext({ ...getRuntimeSessionContext(binding.sessionId)!, hostTurnId: wire.response.id, hostMessageId: assistantUiMessageId });
-      const syncLatestUiMessages = () => {
-        latestUiMessages = [
-          ...requestMessages,
-          {
-            id: assistantUiMessageId,
-            role: "assistant",
-            parts: assistantParts.map((part) => ({ ...part })),
-          } as UIMessage,
-        ];
-      };
-      const writeUiChunk = (chunk: UIMessageChunk) => {
-        // Persist canonical parts after disconnect; the wire emitter checks the socket.
-        wire!.write(chunk);
-      };
-      const projection = createAnswerStreamProjection({
-        messageId: assistantUiMessageId, sessionId: clientSessionId,
-        write: writeUiChunk, onChange: syncLatestUiMessages,
+      const accumulator = createChatRunAccumulator({
+        run: activeRun, messages: requestMessages, messageId: assistantUiMessageId, sessionId: clientSessionId,
+        collaboration: sessionPurpose === "task_collaboration", write: (chunk) => wire!.write(chunk),
+        onStatus: (status) => lastRunStatuses.set(clientSessionId, status),
       });
-      const assistantParts = projection.parts;
-      const writeTextDelta = projection.appendText;
-      const writeDataPart = projection.appendData;
-      const finishUiMessage = projection.finish;
+      const writeUiChunk = (chunk: UIMessageChunk) => wire!.write(chunk);
       writeUiChunk({ type: "start", messageId: assistantUiMessageId });
       let persistQueue = sessionUiStateStore.write(sessionUiStateContext, {
         executionPlans: executionPlanHistory,
         sessionId: activeSessionRecord.sessionId,
         isTitleManuallyEdited: initialSessionState?.isTitleManuallyEdited ?? false,
-        messages: sessionPurpose === "task_collaboration" ? toCollaborationMessages(latestUiMessages) : latestUiMessages,
+        messages: sessionPurpose === "task_collaboration" ? toCollaborationMessages(accumulator.uiMessages()) : accumulator.uiMessages(),
       });
       const queueSessionUiStatePersist = () => {
         const snapshot = {
           executionPlans: executionPlanHistory,
           sessionId: activeSessionRecord.sessionId,
           isTitleManuallyEdited: initialSessionState?.isTitleManuallyEdited ?? false,
-          messages: sessionPurpose === "task_collaboration" ? toCollaborationMessages(latestUiMessages) : latestUiMessages,
+          messages: sessionPurpose === "task_collaboration" ? toCollaborationMessages(accumulator.uiMessages()) : accumulator.uiMessages(),
         };
         persistQueue = persistQueue
           .catch((error) => {
@@ -654,36 +617,6 @@ export const registerChatStreamRoute = (
           .then(() => sessionUiStateStore.write(sessionUiStateContext, snapshot));
         return persistQueue;
       };
-      const primarySubscriber: StreamSubscriber = {
-        write: (event, data) => {
-          if (event === "token") {
-            writeTextDelta(typeof data.content === "string" ? data.content : "");
-            return;
-          }
-          if (event === "done") {
-            finishUiMessage("stop");
-            return;
-          }
-          if (event === "error") {
-            writeUiChunk({
-              type: "error",
-              errorText:
-                typeof data.message === "string"
-                  ? data.message
-                  : "Agent stream failed",
-            });
-            finishUiMessage("error");
-            return;
-          }
-          writeDataPart(event, data);
-        },
-        close: () => {
-          if (!res.writableEnded && !res.destroyed) {
-            res.end();
-          }
-        },
-      };
-      activeRun.subscribers.add(primarySubscriber);
       let taskArtifactPublishQueue: Promise<unknown> = Promise.resolve();
 
       const publish = (event: string, data: Record<string, unknown>) => {
@@ -697,131 +630,11 @@ export const registerChatStreamRoute = (
                     : assistantUiMessageId,
               }
             : data;
-        if (event === "token") {
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            content: `${typeof message.content === "string" ? message.content : ""}${typeof data.content === "string" ? data.content : ""}`,
-            isError: false,
-          }));
-        } else if (event === "final_answer") {
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message, content: typeof data.content === "string" ? data.content : message.content,
-          }));
-        } else if (event === "progress") {
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            progress: upsertBackendProgress(message.progress, data),
-          }));
-        } else if (event === "done") {
-          activeRun.status = data.reason === "waiting_input" ? "waiting_input" : "completed";
-          lastRunStatuses.set(clientSessionId, activeRun.status);
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            content:
-              typeof message.content === "string" && message.content.trim()
-                ? message.content
-                : data.reason === "waiting_input" ? "等待你的回答。" : "Agent 已完成处理，但没有生成文本回答。请查看过程记录，或换个更具体的问题重试。",
-            progress: completeBackendProgress(message.progress),
-          }));
-        } else if (event === "error") {
-          activeRun.status = activeRun.status === "aborted" ? "aborted" : "error";
-          lastRunStatuses.set(clientSessionId, activeRun.status);
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            content:
-              typeof message.content === "string" && message.content.trim()
-                ? message.content
-                : `⚠️ **错误：** ${typeof data.message === "string" ? data.message : "unknown error"}`,
-            isError: true,
-            progress: completeBackendProgress(message.progress),
-            todos: cancelBackendTodos(message.todos),
-          }));
-        } else if (event === "permission_request") {
-          const payload = data as PermissionRequestPayload;
-          activeRun.pendingPermissions.set(payload.request_id, payload);
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            permissions: [
-              ...(Array.isArray(message.permissions) ? message.permissions : []),
-              toFrontendPermission(payload),
-            ],
-          }));
-        } else if (event === "permission_response") {
-          const requestId =
-            typeof data.request_id === "string" ? data.request_id : undefined;
-          const reply =
-            data.reply === "once" || data.reply === "always" || data.reply === "reject"
-              ? data.reply
-              : undefined;
-          if (requestId && reply) {
-            activeRun.pendingPermissions.delete(requestId);
-            activeRun.messages = updateLastAssistantPermission(
-              activeRun.messages,
-              requestId,
-              (permission) => ({
-                ...permission,
-                status: toPermissionStatus(reply),
-                repliedAt: Date.now(),
-              }),
-            );
-          }
-        } else if (event === "question_request") {
-          const payload = data as QuestionRequestPayload;
-          let shouldTrackQuestion = true;
-          if (payload.tool?.callID) {
-            if (payload.request_id !== payload.tool.callID) {
-              activeRun.pendingQuestions.delete(payload.tool.callID);
-            } else {
-              const hasActionableQuestion = [...activeRun.pendingQuestions.values()].some(
-                (question) =>
-                  question.tool?.callID === payload.tool?.callID &&
-                  question.request_id !== payload.tool?.callID,
-              );
-              if (hasActionableQuestion) {
-                activeRun.messages = updateLastAssistantMessage(
-                  activeRun.messages,
-                  (message) => ({
-                    ...message,
-                    questions: upsertBackendQuestion(message.questions, payload),
-                  }),
-                );
-                shouldTrackQuestion = false;
-              }
-            }
-          }
-          if (shouldTrackQuestion) {
-            activeRun.pendingQuestions.set(payload.request_id, payload);
-            activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-              ...message,
-              questions: upsertBackendQuestion(message.questions, payload),
-            }));
-          }
-        } else if (event === "question_response") {
-          const requestId =
-            typeof data.request_id === "string" ? data.request_id : undefined;
-          if (requestId) {
-            activeRun.pendingQuestions.delete(requestId);
-            activeRun.messages = updateLastAssistantQuestion(
-              activeRun.messages,
-              requestId,
-              (question) => ({
-                ...question,
-                status: data.rejected === true ? "rejected" : "answered",
-                repliedAt: Date.now(),
-                answers: Array.isArray(data.answers) ? data.answers : question.answers,
-                error: undefined,
-              }),
-            );
-          }
-        } else if (event === "execution_plan") {
+        if (event === "execution_plan") {
           try {
             const snapshot = createExecutionPlanSnapshot(data, [{ executionPlans: executionPlanHistory }], clientSessionId);
             executionPlanHistory = [...executionPlanHistory, snapshot];
             subscriberData = snapshot;
-            activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-              ...message,
-              executionPlans: [...(Array.isArray(message.executionPlans) ? message.executionPlans : []), snapshot],
-            }));
             if (activeSessionRecord.taskId && executionPlanNeedsTaskPublish(data)) {
               taskArtifactPublishQueue = taskArtifactPublishQueue
                 .catch(() => undefined)
@@ -843,23 +656,6 @@ export const registerChatStreamRoute = (
             });
             return;
           }
-        } else if (event === "todo_update") {
-          const payload = data as TodoUpdatePayload;
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            todos: upsertBackendTodoUpdate(message.todos, payload),
-          }));
-        } else if (event === "tool_call") {
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            artifacts: appendBackendToolArtifact(message.artifacts, data),
-          }));
-        } else if (event === "ui_envelope") {
-          const payload = data as UIEnvelopePayload;
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            uiEnvelopes: appendBackendUiEnvelope(message.uiEnvelopes, payload),
-          }));
         }
 
         const hiddenCollaborationEvent = sessionPurpose === "task_collaboration" && [
@@ -869,12 +665,7 @@ export const registerChatStreamRoute = (
           "ui_envelope",
           "execution_plan",
         ].includes(event);
-        if (!hiddenCollaborationEvent) {
-          for (const subscriber of activeRun.subscribers) {
-            subscriber.write(event, subscriberData);
-          }
-        }
-        activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({ ...message, id: assistantUiMessageId, parts: assistantParts.map((part) => ({ ...part })) }));
+        publishRunEvent(activeRun, event, subscriberData, !hiddenCollaborationEvent);
         void queueSessionUiStatePersist().catch((error) => {
           logger.warn({ err: error, sessionId: clientSessionId }, "failed to persist chat stream state");
         });
@@ -944,10 +735,7 @@ export const registerChatStreamRoute = (
               : typeof generation === "number" && generation > 0 ? generation : null,
             report_revision: reportRef.success ? reportRef.data.revision : null,
           };
-          const part = { type: "data-task_context" as const, data: reference };
-          assistantParts.push(part);
-          writeUiChunk(part);
-          syncLatestUiMessages();
+          accumulator.apply("task_context", reference);
         }
         const preparedMessage = taskContext
           ? [
@@ -970,11 +758,8 @@ export const registerChatStreamRoute = (
         const messaging = getTrustedProductCredential(req) ? agentMessages : undefined;
         messaging?.start(activeSessionRecord);
         const inputTracker = new ResponseInputTracker(runtime, binding.sessionId, (receipt) => {
-          if (receipt.status === "delivered" && !requestMessages.some((message) => message.id === receipt.id)) {
-            requestMessages.push({ id: receipt.id, role: "user", parts: [{ type: "text", text: receipt.text }] } as UIMessage);
-            const tail = activeRun.messages.at(-1);
-            activeRun.messages = [...activeRun.messages.slice(0, -1), { id: receipt.id, role: "user", content: receipt.text }, ...(tail ? [tail] : [])];
-            syncLatestUiMessages();
+          if (receipt.status === "delivered") {
+            accumulator.appendInput({ id: receipt.id, role: "user", parts: [{ type: "text", text: receipt.text }] } as UIMessage, receipt.text);
           }
           publish("user_input", { session_id: clientSessionId, ...receipt });
         });
@@ -997,6 +782,7 @@ export const registerChatStreamRoute = (
           message: preparedMessage,
           model: parsed.data.model,
           approvalMode: parsed.data.approval_mode,
+          backgroundSandboxPermissions: sessionPurpose === "task_execution",
           traceId: requestContext.traceId,
           projectId: requestContext.projectId,
           signal: abortController.signal,
@@ -1124,14 +910,14 @@ export const registerChatStreamRoute = (
           const assistantMessage = [...messages]
             .reverse()
             .find((message) => message.info.role === "assistant");
-          const assistantText = readUiMessageText(latestUiMessages.at(-1)) || collectTextContent(assistantMessage?.parts ?? []);
+          const assistantText = readUiMessageText(accumulator.uiMessages().at(-1)) || collectTextContent(assistantMessage?.parts ?? []);
           const latestSessionRecord =
             (await sessionMetadataStore.get(
               { actorKey, projectId, projectKey, userId },
               activeSessionRecord.sessionId,
             )) ?? activeSessionRecord;
           const latestSessionState = await sessionUiStateStore.read(
-            toSessionUiStateContext(latestSessionRecord),
+            toSessionScope(latestSessionRecord),
           );
           const existingSessionTitle = latestSessionRecord.title;
           let sessionTitle = existingSessionTitle;
@@ -1228,29 +1014,13 @@ export const registerChatStreamRoute = (
         await taskArtifactPublishQueue.catch(() => undefined);
         unregisterFrontendActionSink?.();
         if (abortController.signal.aborted && !taskLeaseFailure) {
-          activeRun.messages = updateLastAssistantMessage(activeRun.messages, (message) => ({
-            ...message,
-            content:
-              typeof message.content === "string" && message.content.trim()
-                ? message.content
-                : "⚠️ **请求已中断**",
-            isError: true,
-            progress: completeBackendProgress(message.progress),
-            todos: cancelBackendTodos(message.todos),
-          }));
-          if (!projection.finished) {
-            writeUiChunk({
-              type: "error",
-              errorText: "请求已中断",
-            });
-            finishUiMessage("error");
-          }
+          publishRunEvent(activeRun, "aborted", { session_id: clientSessionId, message: "请求已中断" });
           void queueSessionUiStatePersist().catch((error) => {
             logger.warn({ err: error, sessionId: clientSessionId }, "failed to persist aborted chat stream state");
           });
         }
-        if (!projection.finished) {
-          finishUiMessage(activeRun.status === "error" ? "error" : "stop");
+        if (!accumulator.finished) {
+          publishRunEvent(activeRun, activeRun.status === "error" ? "error" : "done", { session_id: clientSessionId });
         }
         await queueSessionUiStatePersist().catch((error) => {
           logger.warn({ err: error, sessionId: clientSessionId }, "failed to persist chat stream state");

src/routes/chatUiState.ts

@@ -15,6 +15,8 @@ export type StreamSubscriber = {
 };
 
 export type ActiveRun = {
+  applyEvent?: (event: string, data: Record<string, unknown>) => void;
+  uiMessages?: () => unknown[];
   inputs?: ResponseInputTracker;
   clientSessionId: string;
   controller: AbortController;
@@ -175,43 +177,50 @@ export const updateLastAssistantMessage = (
   return messages;
 };
 
-export const updateLastAssistantPermission = (
-  messages: unknown[],
-  requestId: string,
-  updater: (permission: Record<string, unknown>) => Record<string, unknown>,
-) =>
-  updateLastAssistantMessage(messages, (message) => {
-    const permissions = Array.isArray(message.permissions)
-      ? message.permissions
-      : [];
-    return {
-      ...message,
-      permissions: permissions.map((permission) =>
-        isObjectRecord(permission) && permission.requestId === requestId
-          ? updater(permission)
-          : permission,
-      ),
-    };
-  });
-
-export const updateLastAssistantQuestion = (
-  messages: unknown[],
-  requestId: string,
-  updater: (question: Record<string, unknown>) => Record<string, unknown>,
-) =>
-  updateLastAssistantMessage(messages, (message) => {
-    const questions = Array.isArray(message.questions)
-      ? message.questions
-      : [];
-    return {
-      ...message,
-      questions: questions.map((question) =>
-        isObjectRecord(question) && question.requestId === requestId
-          ? updater(question)
-          : question,
-      ),
-    };
+/** Replies belong to the assistant that requested input, including earlier turns. */
+export function applyInteractionResponse<T>(
+  messages: T[],
+  event: "permission_response" | "question_response",
+  data: Record<string, unknown>,
+): T[] {
+  const requestId = data.request_id;
+  if (typeof requestId !== "string") return messages;
+  const permission = event === "permission_response";
+  const field = permission ? "permissions" : "questions";
+  const requestType = permission ? "data-permission_request" : "data-question_request";
+  let changed = false;
+  const next = messages.map((message) => {
+    if (!isObjectRecord(message) || message.role !== "assistant") return message;
+    const entries = Array.isArray(message[field]) ? message[field] as unknown[] : undefined;
+    const parts = Array.isArray(message.parts) ? [...message.parts] : undefined;
+    const ownsRequest = entries?.some((entry) => isObjectRecord(entry) && entry.requestId === requestId)
+      || parts?.some((part) => isObjectRecord(part) && part.type === requestType
+        && isObjectRecord(part.data) && part.data.request_id === requestId);
+    if (!ownsRequest) return message;
+    changed = true;
+    const updated = entries?.map((entry) => {
+      if (!isObjectRecord(entry) || entry.requestId !== requestId) return entry;
+      return permission ? {
+        ...entry, status: data.status === "error" ? "error" : toPermissionStatus(data.reply as PermissionReply),
+        error: data.status === "error" ? data.error : undefined, repliedAt: Date.now(),
+      } : {
+        ...entry, status: typeof data.status === "string" ? data.status : data.rejected === true ? "rejected" : "answered",
+        ...(Array.isArray(data.answers) ? { answers: data.answers } : {}), error: undefined, repliedAt: Date.now(),
+      };
+    });
+    if (parts && data.status !== "pending") {
+      const type = `data-${event}`;
+      const index = parts.findIndex((part) => isObjectRecord(part) && part.type === type
+        && isObjectRecord(part.data) && part.data.request_id === requestId);
+      const previous = index >= 0 && isObjectRecord(parts[index]) ? parts[index] : undefined;
+      const part = { ...previous, type, data: { ...(isObjectRecord(previous?.data) ? previous.data : {}), ...data } };
+      if (index >= 0) parts[index] = part;
+      else parts.push(part);
+    }
+    return { ...message, ...(updated ? { [field]: updated } : {}), ...(parts ? { parts } : {}) };
   });
+  return changed ? next : messages;
+}
 
 const getToolArtifactKind = (tool: string): ToolArtifactKind => {
   if (tool === "present_view") {

src/routes/sandboxToolBridge.ts

@@ -8,6 +8,8 @@ import { isTrustedInternalBridgeRequest } from "../product/internal-bridge-auth.
 import { getRuntimeSessionContext } from "../runtime/sessionContext.js";
 import { executeSandboxCommand } from "../sandbox/landlockSandbox.js";
 import { setSandboxOwnership } from "../runtime/conversationWorkspace.js";
+import type { OpencodeRuntimeAdapter } from "../runtime/opencode.js";
+import { nativeToolOutputDirectory, stageSessionToolOutputs } from "../sandbox/tool-output.js";
 
 export const sandboxInput = z.object({
   session_id: z.string().min(1).max(128),
@@ -37,6 +39,7 @@ export function isShellCommandDenied(command: string): boolean {
 export function registerSandboxToolBridge(app: Express, options: {
   internalToken: string;
   runtime: {
+    messages: OpencodeRuntimeAdapter["messages"];
     ensureSessionWorkspace(sessionId: string): Promise<string>;
     approveSandboxShell(input: { sessionId: string; command: string; description?: string; callId: string; messageId: string }, signal: AbortSignal): Promise<void>;
   };
@@ -61,6 +64,15 @@ export function registerSandboxToolBridge(app: Express, options: {
         sessionId: context.sessionId, command: parsed.data.command, description: parsed.data.description,
         callId: parsed.data.call_id, messageId: parsed.data.message_id,
       }, controller.signal);
+      if (parsed.data.command.includes(`${nativeToolOutputDirectory()}/`)) {
+        const files = await stageSessionToolOutputs(parsed.data.command, workspace, context.sessionId,
+          await options.runtime.messages(context.sessionId, 100));
+        if (files.length) {
+          res.json({ outcome: "requires_session_path", files,
+            detail: "命令尚未执行。当前会话的完整工具结果已复制到会话目录。请用返回的 shell_path 重新调用 Shell；relative_path 相对于会话 workspace，shell_path 相对于 Shell 的 files/ 工作目录。" });
+          return;
+        }
+      }
       const result = await executeSandboxCommand(workspace, parsed.data.command, parsed.data.timeout, controller.signal);
       const files: Partial<Record<"stdout_file" | "stderr_file", string>> = {};
       for (const stream of ["stdout", "stderr"] as const) {

src/routes/task-bridge-context.ts

@@ -0,0 +1,16 @@
+import type { Request, Response } from "express";
+import { isTrustedInternalBridgeRequest } from "../product/internal-bridge-auth.js";
+import { getRuntimeSessionContext } from "../runtime/sessionContext.js";
+
+export function readTaskBridgeContext(req: Request, token: string, allowQuery = false) {
+  if (!isTrustedInternalBridgeRequest(req, token)) return null;
+  const runtimeSessionId = typeof req.body?.session_id === "string" ? req.body.session_id.trim()
+    : allowQuery && typeof req.query.session_id === "string" ? req.query.session_id.trim() : "";
+  const context = runtimeSessionId ? getRuntimeSessionContext(runtimeSessionId) : null;
+  return context?.taskId ? { context, runtimeSessionId, taskId: context.taskId } : null;
+}
+
+export function replyTaskBridgeError(res: Response, error: unknown, fallback: string) {
+  const status = error && typeof error === "object" && "status" in error && typeof error.status === "number" ? error.status : 502;
+  res.status(status).json({ message: error instanceof Error ? error.message : fallback });
+}

src/routes/task-command-bridge.ts

@@ -0,0 +1,65 @@
+import type { Express } from "express";
+import { operationalTaskClient, expressAccessRequestSchema, proposedTaskActionSchema, humanTaskEvidenceCommandSchema, type OperationalTaskClient } from "../product/operational-task-client.js";
+import { readTaskBridgeContext, replyTaskBridgeError } from "./task-bridge-context.js";
+
+export function registerTaskCommandBridge(app: Express, options: {
+  internalToken: string;
+  client?: Pick<OperationalTaskClient, "requestDataAccess" | "proposeAction" | "addHumanEvidence">;
+}) {
+  const client = options.client ?? operationalTaskClient;
+  app.post("/internal/operational-task/access-requests", async (req, res) => {
+    const bridge = readTaskBridgeContext(req, options.internalToken, true);
+    if (!bridge || bridge.context.purpose !== "task_execution") {
+      res.status(403).json({ message: "task execution context required" });
+      return;
+    }
+    const parsed = expressAccessRequestSchema.safeParse(req.body?.request);
+    if (!parsed.success) {
+      res.status(400).json({ message: "invalid access request" });
+      return;
+    }
+    try {
+      res.json(await client.requestDataAccess(bridge.runtimeSessionId, bridge.taskId, {
+        ...parsed.data, sourceSessionId: bridge.context.clientSessionId,
+      }));
+    } catch (error) {
+      replyTaskBridgeError(res, error, "access request failed");
+    }
+  });
+
+  app.post("/internal/operational-task/actions", async (req, res) => {
+    const bridge = readTaskBridgeContext(req, options.internalToken, true);
+    if (!bridge) {
+      res.status(403).json({ message: "operational task context unavailable" });
+      return;
+    }
+    const parsed = proposedTaskActionSchema.safeParse(req.body?.action);
+    if (!parsed.success) {
+      res.status(400).json({ message: "invalid proposed action", detail: parsed.error.flatten() });
+      return;
+    }
+    try {
+      res.json(await client.proposeAction(bridge.runtimeSessionId, bridge.taskId, parsed.data));
+    } catch (error) {
+      replyTaskBridgeError(res, error, "task action proposal failed");
+    }
+  });
+
+  app.post("/internal/operational-task/human-evidence", async (req, res) => {
+    const bridge = readTaskBridgeContext(req, options.internalToken, true);
+    if (!bridge || bridge.context.purpose !== "task_collaboration") {
+      res.status(403).json({ message: "human evidence requires a task collaboration session" });
+      return;
+    }
+    const parsed = humanTaskEvidenceCommandSchema.safeParse(req.body?.command);
+    if (!parsed.success) {
+      res.status(400).json({ message: "invalid human evidence", detail: parsed.error.flatten() });
+      return;
+    }
+    try {
+      res.json(await client.addHumanEvidence(bridge.runtimeSessionId, bridge.taskId, parsed.data));
+    } catch (error) {
+      replyTaskBridgeError(res, error, "human evidence publish failed");
+    }
+  });
+}

src/routes/task-publication-bridge.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { isTrustedInternalBridgeRequest } from "../product/internal-bridge-auth.js";
 import { operationalTaskClient, type OperationalTaskClient, taskArtifactBridgeSchema } from "../product/operational-task-client.js";
 import { taskPresentationBridgeSchema } from "../product/task-presentation.js";
-import { getRuntimeSessionContext } from "../runtime/sessionContext.js";
+import { readTaskBridgeContext, replyTaskBridgeError } from "./task-bridge-context.js";
 
 const artifactsInputSchema = taskArtifactBridgeSchema.and(z.object({ session_id: z.string().trim().min(1).max(128) }));
 
@@ -19,12 +19,12 @@ export function registerTaskPublicationBridge(app: Express, options: {
         res.status(403).json({ message: "forbidden" });
         return;
       }
-      const sessionId = typeof req.body?.session_id === "string" ? req.body.session_id.trim() : "";
-      const context = sessionId ? getRuntimeSessionContext(sessionId) : null;
-      if (!context?.taskId) {
+      const bridge = readTaskBridgeContext(req, options.internalToken);
+      if (!bridge) {
         res.status(403).json({ message: "operational task context unavailable" });
         return;
       }
+      const { context, runtimeSessionId: sessionId, taskId } = bridge;
       if ((kind === "presentation" || req.body?.progress !== undefined) && context.purpose !== "task_execution") {
         res.status(403).json({ message: "task execution context required" });
         return;
@@ -36,7 +36,7 @@ export function registerTaskPublicationBridge(app: Express, options: {
             res.status(400).json({ message: "invalid task presentation", detail: parsed.error.flatten() });
             return;
           }
-          res.json(await client.publishPresentation(sessionId, context.taskId, {
+          res.json(await client.publishPresentation(sessionId, taskId, {
             requestId: parsed.data.request_id,
             sourceSessionId: context.clientSessionId,
             command: parsed.data.command,
@@ -47,7 +47,7 @@ export function registerTaskPublicationBridge(app: Express, options: {
             res.status(400).json({ message: "invalid task artifacts", detail: parsed.error.flatten() });
             return;
           }
-          res.json(await client.publishArtifacts(sessionId, context.taskId, {
+          res.json(await client.publishArtifacts(sessionId, taskId, {
             requestId: parsed.data.request_id,
             sourceSessionId: context.clientSessionId,
             evidence: parsed.data.evidence,
@@ -57,8 +57,7 @@ export function registerTaskPublicationBridge(app: Express, options: {
           }));
         }
       } catch (error) {
-        const status = error && typeof error === "object" && "status" in error && typeof error.status === "number" ? error.status : 502;
-        res.status(status).json({ message: error instanceof Error ? error.message : `task ${kind} publish failed` });
+        replyTaskBridgeError(res, error, `task ${kind} publish failed`);
       }
     });
   }

src/runtime/opencode.ts

@@ -2,7 +2,7 @@ import { LOCAL_QUERY_TOOL_IDS, PRODUCT_MCP_TOOL_IDS, PRODUCT_MCP_WRITE_TOOL_IDS,
 import { assertWebSearchReady } from "./web-search-check.js";
 import { allowedQueryTools } from "./query-mcp-policy.js";
 import { setTimeout as delayAbortable } from "node:timers/promises";
-import { isMessageNotFoundError, isSessionNotFoundError, type OpenCodeClient as OpencodeClient } from "@opencode/client";
+import { isMessageNotFoundError, isSessionNotFoundError, type FormDetail, type OpenCodeClient as OpencodeClient } from "@opencode/client";
 import { createRuntimeClient, startOpencode2 } from "./opencode2-server.js";
 import { formAnswers, normalizeRuntimeMessage, Opencode2EventNormalizer } from "./opencode2-events.js";
 import { existsSync, readFileSync } from "node:fs";
@@ -381,13 +381,6 @@ export class OpencodeRuntimeAdapter {
     await rm(directory, { recursive: true, force: true });
   }
 
-  async sendPrompt(sessionId: string, text: string) {
-    await this.prompt(sessionId, text);
-    // 当前 SDK 响应风格下，prompt() 本身不会直接返回完整 assistant parts，
-    // 所以这里紧跟一次 messages() 回读，给上层路由统一消费。
-    return this.messages(sessionId);
-  }
-
   async generateText(prompt: string, model?: RuntimeModelOverride, signal?: AbortSignal) {
     const client = await this.ensureClient();
     const selected = model ?? parseModelReference(config.OPENCODE_MODEL);
@@ -733,19 +726,18 @@ export class OpencodeRuntimeAdapter {
     return client.permission.reply({ sessionID: options.sessionId, requestID: options.requestId, decision: options.reply, message: options.message });
   }
 
-  async replyQuestion(options: { requestId: string; sessionId?: string; answers: QuestionAnswers }) {
+  async replyQuestion(options: { requestId: string; sessionId: string; answers: QuestionAnswers; form: FormDetail }) {
     if (!options.sessionId) throw new Error("OpenCode 2 form replies require sessionId");
     const client = await this.ensureClient();
-    const form = await client.session.form.get({ sessionID: options.sessionId, formID: options.requestId });
-    return client.session.form.reply({ sessionID: options.sessionId, formID: options.requestId, answer: formAnswers(form, options.answers) });
+    return client.session.form.reply({ sessionID: options.sessionId, formID: options.requestId, answer: formAnswers(options.form, options.answers) });
   }
 
-  async getQuestionStatus(options: { requestId: string; sessionId: string }): Promise<"pending" | "answered" | "cancelled" | "missing"> {
+  async getQuestion(options: { requestId: string; sessionId: string }): Promise<FormDetail | null> {
     const client = await this.ensureClient();
-    try { return (await client.session.form.get({ sessionID: options.sessionId, formID: options.requestId })).state.status; }
+    try { return await client.session.form.get({ sessionID: options.sessionId, formID: options.requestId }); }
     catch (error) {
       const tag = error && typeof error === "object" && "_tag" in error ? error._tag : undefined;
-      if (tag === "FormNotFoundError") return "missing";
+      if (tag === "FormNotFoundError") return null;
       throw error;
     }
   }

src/sandbox/tool-output.ts

@@ -0,0 +1,58 @@
+import { constants } from "node:fs";
+import { open, realpath } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import type { OpencodeRuntimeAdapter } from "../runtime/opencode.js";
+import { SANDBOX_GID, SANDBOX_UID } from "../runtime/conversationWorkspace.js";
+import { openArtifactDirectory } from "../mcp/artifact-files.js";
+
+export const nativeToolOutputDirectory = () => resolve(
+  process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "opencode", "tool-output",
+);
+
+// Only native truncation metadata from this session authorizes a source file.
+// Text supplied by the model or a tool response is never an ownership proof.
+export async function stageSessionToolOutputs(
+  command: string, workspace: string, sessionId: string,
+  messages: Awaited<ReturnType<OpencodeRuntimeAdapter["messages"]>>,
+) {
+  const sources = new Set<string>();
+  const root = nativeToolOutputDirectory();
+  for (const message of messages) for (const part of message.parts) {
+    if (part.type !== "tool" || part.state.status !== "completed") continue;
+    const metadata = part.state.metadata;
+    const path = metadata?.outputPath;
+    if (metadata?.truncated === true && typeof path === "string" && command.includes(path)
+        && dirname(path) === root && /^tool_[a-zA-Z0-9]+$/.test(basename(path))) sources.add(path);
+  }
+  if (!sources.size) return [];
+  const canonicalRoot = await realpath(root);
+  const directory = await openArtifactDirectory(workspace, sessionId);
+  const files: Array<{ source_path: string; relative_path: string; shell_path: string; size: number; sha256: string }> = [];
+  let remaining = 128 * 1024 * 1024;
+  try {
+    for (const path of sources) {
+      if (await realpath(path) !== join(canonicalRoot, basename(path))) throw new Error("Unsafe tool output path");
+      const source = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+      let bytes: Buffer;
+      try {
+        const stat = await source.stat();
+        if (!stat.isFile() || stat.size > remaining) throw new Error("Tool output staging budget exceeded");
+        bytes = await source.readFile();
+        if (bytes.length > remaining) throw new Error("Tool output staging budget exceeded");
+        remaining -= bytes.length;
+      } finally { await source.close(); }
+      const filename = `tool-output-${randomUUID()}.txt`;
+      const destination = await open(`/proc/self/fd/${directory.fd}/${filename}`,
+        constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+      try {
+        await destination.writeFile(bytes);
+        if (typeof process.getuid === "function" && process.getuid() === 0) await destination.chown(SANDBOX_UID, SANDBOX_GID);
+      } finally { await destination.close(); }
+      files.push({ source_path: path, relative_path: `files/${filename}`, shell_path: filename, size: bytes.length,
+        sha256: createHash("sha256").update(bytes).digest("hex") });
+    }
+  } finally { await directory.close(); }
+  return files;
+}

src/server.ts

@@ -37,12 +37,7 @@ import { createAgentMessageQuery, registerAgentMessageBridge } from "./routes/ag
 import { FrontendActionCoordinator, FrontendActionError } from "./frontendAction/coordinator.js";
 import { opencodeRuntime } from "./runtime/opencode.js";
 import { getRuntimeSessionContext } from "./runtime/sessionContext.js";
-import {
-  operationalTaskClient,
-  expressAccessRequestSchema,
-  humanTaskEvidenceCommandSchema,
-  proposedTaskActionSchema,
-} from "./product/operational-task-client.js";
+import { registerTaskCommandBridge } from "./routes/task-command-bridge.js";
 import { isTrustedInternalBridgeRequest } from "./product/internal-bridge-auth.js";
 
 const app = express();
@@ -53,9 +48,9 @@ const sessionWorkspaces = new SessionWorkspaceStore(config.CONVERSATION_WORKSPAC
 const sessionMetadataStore = new SessionMetadataStore(undefined, sessionWorkspaces);
 const answerViewStateStore = new AnswerViewStateStore(sessionWorkspaces);
 const interactionRequestStore = new InteractionRequestStore(sessionWorkspaces);
-const sessionUiStateStore = new SessionUiStateStore(undefined, sessionWorkspaces);
+const sessionUiStateStore = new SessionUiStateStore(sessionWorkspaces);
 const memoryStore = new MemoryStore();
-const sessionTranscriptStore = new SessionTranscriptStore(undefined, sessionWorkspaces);
+const sessionTranscriptStore = new SessionTranscriptStore(sessionWorkspaces);
 const learningOrchestrator = new LearningOrchestrator(
   opencodeRuntime,
   memoryStore,
@@ -112,80 +107,7 @@ app.post("/internal/frontend-actions/request", async (req, res) => {
   }
 });
 
-const readOperationalTaskBridgeContext = (req: express.Request) => {
-  if (!isTrustedInternalBridgeRequest(req, internalToken)) return null;
-  const runtimeSessionId = typeof req.body?.session_id === "string"
-    ? req.body.session_id.trim()
-    : typeof req.query.session_id === "string"
-      ? req.query.session_id.trim()
-      : "";
-  const context = runtimeSessionId ? getRuntimeSessionContext(runtimeSessionId) : null;
-  return context?.taskId ? { context, runtimeSessionId, taskId: context.taskId } : null;
-};
-
-app.post("/internal/operational-task/access-requests", async (req, res) => {
-  const bridge = readOperationalTaskBridgeContext(req);
-  if (!bridge || bridge.context.purpose !== "task_execution") {
-    res.status(403).json({ message: "task execution context required" });
-    return;
-  }
-  const parsed = expressAccessRequestSchema.safeParse(req.body?.request);
-  if (!parsed.success) {
-    res.status(400).json({ message: "invalid access request" });
-    return;
-  }
-  try {
-    res.json(await operationalTaskClient.requestDataAccess(bridge.runtimeSessionId, bridge.taskId, {
-      ...parsed.data, sourceSessionId: bridge.context.clientSessionId,
-    }));
-  } catch (error) {
-    const status = error && typeof error === "object" && "status" in error && typeof error.status === "number"
-      ? error.status : 502;
-    res.status(status).json({ message: error instanceof Error ? error.message : "access request failed" });
-  }
-});
-
-app.post("/internal/operational-task/actions", async (req, res) => {
-  const bridge = readOperationalTaskBridgeContext(req);
-  if (!bridge) {
-    res.status(403).json({ message: "operational task context unavailable" });
-    return;
-  }
-  const parsed = proposedTaskActionSchema.safeParse(req.body?.action);
-  if (!parsed.success) {
-    res.status(400).json({ message: "invalid proposed action", detail: parsed.error.flatten() });
-    return;
-  }
-  try {
-    res.json(await operationalTaskClient.proposeAction(bridge.runtimeSessionId, bridge.taskId, parsed.data));
-  } catch (error) {
-    const status = error && typeof error === "object" && "status" in error && typeof error.status === "number"
-      ? error.status
-      : 502;
-    res.status(status).json({ message: error instanceof Error ? error.message : "task action proposal failed" });
-  }
-});
-
-app.post("/internal/operational-task/human-evidence", async (req, res) => {
-  const bridge = readOperationalTaskBridgeContext(req);
-  if (!bridge || bridge.context.purpose !== "task_collaboration") {
-    res.status(403).json({ message: "human evidence requires a task collaboration session" });
-    return;
-  }
-  const parsed = humanTaskEvidenceCommandSchema.safeParse(req.body?.command);
-  if (!parsed.success) {
-    res.status(400).json({ message: "invalid human evidence", detail: parsed.error.flatten() });
-    return;
-  }
-  try {
-    res.json(await operationalTaskClient.addHumanEvidence(bridge.runtimeSessionId, bridge.taskId, parsed.data));
-  } catch (error) {
-    const status = error && typeof error === "object" && "status" in error && typeof error.status === "number"
-      ? error.status
-      : 502;
-    res.status(status).json({ message: error instanceof Error ? error.message : "human evidence publish failed" });
-  }
-});
+registerTaskCommandBridge(app, { internalToken });
 
 app.get("/health", async (_req, res) => {
   try {
@@ -247,10 +169,8 @@ const bootstrap = async () => {
     logger.info(migrated, "session records migrated to owned workspaces; legacy sources archived");
   }
   await Promise.all([
-    sessionUiStateStore.initialize(),
     learningOrchestrator.initialize(),
     memoryStore.initialize(),
-    sessionTranscriptStore.initialize(),
   ]);
 };
 

src/sessions/session-scope.ts

@@ -0,0 +1,8 @@
+import type { SessionWorkspaceContext } from "../runtime/conversationWorkspace.js";
+
+/** Always derive persistence scope from a host-validated session record. */
+export const toSessionScope = (record: SessionWorkspaceContext): SessionWorkspaceContext => ({
+  sessionId: record.sessionId,
+  actorKey: record.actorKey,
+  projectKey: record.projectKey,
+});

src/sessions/transcriptStore.ts

@@ -1,10 +1,5 @@
-import { join } from "node:path";
-
 import { config } from "../config.js";
 import {
-  atomicWriteJson,
-  ensureDirectory,
-  listJsonFiles,
   readJsonFile,
   toStableId,
 } from "../utils/fileStore.js";
@@ -50,11 +45,7 @@ const DEFAULT_SEARCH_MAX_QUERY_CHARS = 240;
 export class SessionTranscriptStore {
   private readonly writeQueues = new Map<string, Promise<void>>();
 
-  constructor(private readonly baseDir = config.SESSION_TRANSCRIPT_STORAGE_DIR, private readonly workspaces?: SessionWorkspaceStore) {}
-
-  async initialize() {
-    if (!this.workspaces) await ensureDirectory(this.baseDir);
-  }
+  constructor(private readonly workspaces: SessionWorkspaceStore) {}
 
   async appendTurn(
     context: SessionTranscriptContext,
@@ -66,7 +57,7 @@ export class SessionTranscriptStore {
   ) {
     const key = this.filePath(context);
     return this.serializeWrite(key, async () => {
-      if (this.workspaces) await this.workspaces.ensure(this.workspaceContext(context));
+      await this.workspaces.ensure(this.workspaceContext(context));
       // 同一会话的多次写入串行化，防止流式结束和 UI 同步同时写同一个 transcript。
       const transcript = (await this.readTranscript(context)) ?? {
         actorKey: context.actorKey,
@@ -148,10 +139,8 @@ export class SessionTranscriptStore {
       turns: projectTurnsForFork(sourceTranscript?.turns ?? [], keepMessageCount),
       updatedAt: timestamp,
     };
-    if (this.workspaces) {
-      await this.workspaces.ensure(this.workspaceContext(targetContext));
-      await this.workspaces.validate(this.workspaceContext(targetContext), "transcript.json");
-    }
+    await this.workspaces.ensure(this.workspaceContext(targetContext));
+    await this.workspaces.validate(this.workspaceContext(targetContext), "transcript.json");
     await this.persist(targetContext, nextTranscript);
     return nextTranscript;
   }
@@ -168,7 +157,7 @@ export class SessionTranscriptStore {
     }
     const queryTokens = normalizedQuery.split(/\s+/).filter(Boolean);
     const hits: SessionSearchHit[] = [];
-    const files = this.workspaces ? await this.workspaces.list(context, "transcript.json") : await listJsonFiles(this.baseDir);
+    const files = await this.workspaces.list(context, "transcript.json");
     for (const file of files) {
       const transcript = await readJsonFile<SessionTranscriptRecord>(file);
       if (!transcript) {
@@ -205,7 +194,7 @@ export class SessionTranscriptStore {
   }
 
   private async readTranscript(context: SessionTranscriptContext) {
-    if (this.workspaces && !await this.workspaces.validate(this.workspaceContext(context), "transcript.json")) return null;
+    if (!await this.workspaces.validate(this.workspaceContext(context), "transcript.json")) return null;
     const record = await readJsonFile<SessionTranscriptRecord>(this.filePath(context));
     if (record && (record.actorKey !== context.actorKey || record.projectKey !== context.projectKey ||
       (record.clientSessionId || record.sessionId) !== (context.clientSessionId || context.sessionId))) throw new Error("chat transcript ownership mismatch");
@@ -213,16 +202,11 @@ export class SessionTranscriptStore {
   }
 
   private filePath(context: SessionTranscriptContext) {
-    if (this.workspaces) return this.workspaces.path(this.workspaceContext(context), "transcript.json");
-    return join(
-      this.baseDir,
-      `${context.actorKey}__${context.projectKey}__${context.sessionId}.json`,
-    );
+    return this.workspaces.path(this.workspaceContext(context), "transcript.json");
   }
 
   private async persist(context: SessionTranscriptContext, transcript: SessionTranscriptRecord) {
-    if (this.workspaces) await this.workspaces.writeRecord(this.workspaceContext(context), "transcript.json", transcript);
-    else await atomicWriteJson(this.filePath(context), transcript);
+    await this.workspaces.writeRecord(this.workspaceContext(context), "transcript.json", transcript);
   }
 
   private workspaceContext(context: SessionTranscriptContext) {

src/sessions/uiStateStore.ts

@@ -1,13 +1,9 @@
-import { join } from "node:path";
+import type { SessionWorkspaceContext } from "../runtime/conversationWorkspace.js";
 
-import { config } from "../config.js";
 import { type SessionWorkspaceStore } from "./workspace-store.js";
 import {
-  atomicWriteJson,
-  ensureDirectory,
   readJsonFile,
   removeFileIfExists,
-  slugify,
 } from "../utils/fileStore.js";
 
 export type SessionUiStateRecord = {
@@ -17,56 +13,39 @@ export type SessionUiStateRecord = {
   executionPlans?: Record<string, unknown>[];
 };
 
-type SessionUiStateContext = {
-  sessionId: string;
-  actorKey?: string;
-  projectKey?: string;
-};
+type SessionUiStateContext = SessionWorkspaceContext;
 
 export class SessionUiStateStore {
-  constructor(private readonly baseDir = config.SESSION_UI_STATE_STORAGE_DIR, private readonly workspaces?: SessionWorkspaceStore) {}
-
-  async initialize() {
-    if (!this.workspaces) await ensureDirectory(this.baseDir);
-  }
+  constructor(private readonly workspaces: SessionWorkspaceStore) {}
 
   async read(context: SessionUiStateContext) {
-    if (this.workspaces && !await this.workspaces.validate(this.workspaceContext(context), "messages.json")) return null;
+    if (!await this.workspaces.validate(this.workspaceContext(context), "messages.json")) return null;
     return await readJsonFile<SessionUiStateRecord>(this.filePath(context));
   }
 
   async write(context: SessionUiStateContext, state: SessionUiStateRecord) {
     if (state.sessionId !== context.sessionId) throw new Error("chat state session mismatch");
-    if (this.workspaces) {
-      await this.workspaces.ensure(this.workspaceContext(context));
-      await this.workspaces.validate(this.workspaceContext(context), "messages.json");
-    }
-    if (this.workspaces) await this.workspaces.writeRecord(this.workspaceContext(context), "messages.json", state);
-    else await atomicWriteJson(this.filePath(context), state);
+    await this.workspaces.writeRecord(this.workspaceContext(context), "messages.json", state);
     return state;
   }
 
   async update(context: SessionUiStateContext, change: (state: SessionUiStateRecord) => SessionUiStateRecord) {
-    if (this.workspaces) return this.workspaces.updateRecord(this.workspaceContext(context), "messages.json", async ({ current }) => {
+    return this.workspaces.updateRecord(this.workspaceContext(context), "messages.json", async ({ current }) => {
       const state = current as SessionUiStateRecord | null;
       if (!state || state.sessionId !== context.sessionId || !Array.isArray(state.messages)) throw new Error("chat state unavailable");
       const next = change(state);
       if (next.sessionId !== context.sessionId) throw new Error("chat state session mismatch");
       return { result: next, value: next };
     });
-    const state = await this.read(context);
-    if (!state) throw new Error("chat state unavailable");
-    return this.write(context, change(state));
   }
 
   async remove(context: SessionUiStateContext) {
-    if (this.workspaces && !await this.workspaces.validate(this.workspaceContext(context), "messages.json")) return;
+    if (!await this.workspaces.validate(this.workspaceContext(context), "messages.json")) return;
     await removeFileIfExists(this.filePath(context));
   }
 
   private filePath(context: SessionUiStateContext) {
-    if (this.workspaces) return this.workspaces.path(this.workspaceContext(context), "messages.json");
-    return join(this.baseDir, `${slugify(context.sessionId)}.json`);
+    return this.workspaces.path(this.workspaceContext(context), "messages.json");
   }
 
   private workspaceContext(context: SessionUiStateContext) {

tests/chat/answer-ui.test.ts

@@ -99,11 +99,11 @@ describe("locally rendered answers", () => {
     try {
       const owner = { actorKey: "actor-answer", projectKey: "project-answer", sessionId: "answer-session" };
       const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
-      const store = new SessionUiStateStore(join(root, "legacy"), workspaces);
+      const store = new SessionUiStateStore(workspaces);
       const parts: UIMessage["parts"] = [{ type: "text", text: "演练：" }, { type: "data-answer_ui", id: "pressure", data: parseAnswerUiInput(input) }, { type: "text", text: "仍待核验。" }];
       const messages = [{ id: "a", role: "assistant", parts }];
       await store.write(owner, { sessionId: owner.sessionId, messages });
-      const restored = new SessionUiStateStore(join(root, "legacy"), new SessionWorkspaceStore(workspaces.root));
+      const restored = new SessionUiStateStore(new SessionWorkspaceStore(workspaces.root));
       expect((await restored.read(owner))?.messages).toEqual(messages);
       expect(await restored.read({ ...owner, actorKey: "actor-other" })).toBeNull();
       expect(await restored.read({ ...owner, projectKey: "project-other" })).toBeNull();

tests/chat/models.test.ts

@@ -156,19 +156,21 @@ describe("agent model config", () => {
   });
 
   it("exposes only the two configured gateway models with their roles, icons and context limits", () => {
-    expect(supportedModels).toEqual(["waternetwork/gpt-5.6-terra", "waternetwork/gpt-5.6-sol"]);
+    expect(supportedModels).toEqual(["waternetwork/deepseek-flash", "waternetwork/gpt-6.1-sol"]);
     expect(agentModelOptions.map(({ id, label, icon }) => ({ id, label, icon }))).toEqual([
-      { id: "waternetwork/gpt-5.6-terra", label: "快速", icon: "bolt" },
-      { id: "waternetwork/gpt-5.6-sol", label: "专家", icon: "sparkle" },
+      { id: "waternetwork/deepseek-flash", label: "快速", icon: "bolt" },
+      { id: "waternetwork/gpt-6.1-sol", label: "专家", icon: "sparkle" },
     ]);
     expect(isSupportedModel("deepseek/deepseek-flash")).toBe(false);
-    expect(isSupportedModel("waternetwork/deepseek-flash")).toBe(false);
+    expect(isSupportedModel("waternetwork/deepseek-flash")).toBe(true);
+    expect(isSupportedModel("waternetwork/gpt-5.6-terra")).toBe(false);
+    expect(isSupportedModel("waternetwork/gpt-5.6-sol")).toBe(false);
     expect(isSupportedModel("waternetwork/gpt-image-2.5")).toBe(false);
     expect(isSupportedModel("waternetwork/codex-auto-review")).toBe(false);
     const native = serviceOpencodeConfig({});
     expect(Object.keys(native.providers)).toEqual(["waternetwork"]);
-    expect(native.model).toBe("waternetwork/gpt-5.6-terra");
-    expect(native.providers.waternetwork.models["gpt-5.6-terra"].limit?.context).toBe(272000);
-    expect(native.providers.waternetwork.models["gpt-5.6-sol"].limit?.context).toBe(475000);
+    expect(native.model).toBe("waternetwork/deepseek-flash");
+    expect(native.providers.waternetwork.models["deepseek-flash"].limit?.context).toBe(272000);
+    expect(native.providers.waternetwork.models["gpt-6.1-sol"].limit?.context).toBe(475000);
   });
 });

tests/frontendAction/command.test.ts

@@ -35,9 +35,10 @@ describe("unified view commands", () => {
   });
   it("passes aligned historical scatter points through native and publication contracts", () => {
     const command = { action: "open_chart", chart_id: "pressure-comparison", evidence_refs: ["E1"], chart: {
-      title: "压力七天对比", chart_type: "line", y_axis_name: "压力（m）",
+      title: "压力七天对比", chart_type: "time_comparison", y_axis_name: "压力（m）",
       x_data: ["19:30", "19:45", "20:00"], series: [
-        { name: "当前", type: "line", data: [32, null, 31] },
+        { name: "当前", type: "line", data: [32, null, 31],
+          sample_times: ["2026-06-14T19:30:00+08:00", null, "2026-06-14T20:00:00+08:00"] },
         { name: "前一天", type: "scatter", data: [null, 32, 33],
           sample_times: [null, "2026-06-13T19:45:00+08:00", "2026-06-13T20:00:00+08:00"] },
       ],

tests/integration/mcp-query-smoke.ts

@@ -68,6 +68,7 @@ try {
     if (response.isError) throw new Error(`Extended tool failed through merged MCP: ${name}`);
   }
   if (!requests.includes("server/discover") || !requests.includes("tools/call") || requests.includes("initialize") || requests.includes("GET")) throw new Error("Transport used unexpected protocol requests");
+  if (requests.filter((method) => method === "tools/list").length !== 1) throw new Error("Business queries fetched the catalog again after startup");
   if (grants.join(",") !== "client_credentials,urn:ietf:params:oauth:grant-type:token-exchange") throw new Error("OAuth grants were not validated");
   console.log(`PASS: local MCP ${QUERY_MCP_TOOL_IDS.length}-tool discovery, real Server schemas, OAuth discovery, resource-bound grants, host binding, extended query and revocation over MCP HTTP`);
 } finally {

tests/mcp/queryServer.test.ts

@@ -17,6 +17,30 @@ afterEach(async () => {
 });
 const productTool: Tool = { name: "get_task_context", description: "Bound task", inputSchema: { type: "object", properties: { report_revision: { type: "integer", minimum: 1 } }, additionalProperties: false } };
 
+it("delivers complete SCADA metadata and observations through native MCP without narrowing device scope", async () => {
+  const data = {
+    devices: Array.from({ length: 168 }, (_, index) => ({ device_id: `D${index}`, node_id: `J${index}`, description: "x".repeat(100) })),
+    readings: Array.from({ length: 2184 }, (_, index) => ({ device_id: `D${index % 168}`, monitored_value: index, cleaned_value: null })),
+    coverage: { mode: "all_scada", query_complete: true, queried_device_count: 168, reading_count: 2184 },
+  };
+  const upstream = { content: [{ type: "text" as const, text: JSON.stringify(data) }], structuredContent: {
+    source: "query_scada_readings", evidence_id: "mcp:all-scada", data, truncated: false,
+  } };
+  const query = mock(async () => upstream);
+  const tool: Tool = { name: "query_scada_readings", inputSchema: { type: "object", properties: {
+    start: { type: "string" }, end: { type: "string" },
+    device_ids: { type: "array", items: { type: "string" }, maxItems: 20 },
+  }, required: ["start", "end"], additionalProperties: false } };
+  const { call } = await setup({ productTools: [tool], productClient: { query } });
+  setRuntimeSessionContext({ ...owner, purpose: "task_execution", taskId: "scada-task" });
+  const args = { start: "2026-07-16T05:00:00+08:00", end: "2026-07-16T08:00:00+08:00" };
+  const result = await call("query_scada_readings", args);
+  expect(result.isError).not.toBeTrue();
+  expect((query.mock.calls[0] as unknown as unknown[])[3]).toEqual(args);
+  expect(result.structuredContent).toEqual(upstream.structuredContent);
+  expect(JSON.stringify(result.structuredContent).length).toBeGreaterThan(12000);
+});
+
 it("hides HTTP budgets from models and fixes the native connection ceiling", async () => {
   const simulation: Tool = { name: "run_simulation", inputSchema: { type: "object", properties: {
     timeout_seconds: { type: "integer", minimum: 1, maximum: 240, default: 120 },

tests/product/mcpQueryClient.test.ts

@@ -26,6 +26,24 @@ const resourceToken = jwt("resource");
 const token = () => Response.json({ access_token: resourceToken, token_type: "Bearer", expires_in: 300 });
 function credential(id: string) { sessions.push(id); bindSessionCredential(id, { authorization: `Bearer ${jwt(id)}`, projectId: "project" }); }
 
+it("uses cached tool definitions without fetching the catalog on each query", async () => {
+  const id = "cached-tool-definition"; credential(id);
+  const client = fixture((async (url, init) => {
+    if (String(url).includes("/token")) return token();
+    return init?.method === "POST"
+      ? Response.json({ context_handle: "x".repeat(43) })
+      : new Response(null, { status: 204 });
+  }) as McpHttpFetch);
+  const definition = { ...catalog[0], outputSchema: { type: "object", properties: { ok: { type: "boolean" } } } };
+  Object.assign(client, { tools: [definition], withClient: async (_token: string, _project: string, _signal: AbortSignal, run: (client: unknown) => Promise<unknown>) => run({
+    callTool: async (_params: unknown, options: { toolDefinition: unknown }) => {
+      expect(options.toolDefinition).toBe(definition);
+      return { content: [], structuredContent: { ok: true } };
+    },
+  }) });
+  expect((await client.query(id, owner(id), definition.name, {}, "call")).structuredContent).toEqual({ ok: true });
+});
+
 it("owns simulation HTTP budgets and rejects model overrides before OAuth", async () => {
   const id = "mcp-calculation-budget"; credential(id);
   let requests = 0, transportTimeout = 0, sdkTimeout = 0;

tests/product/operationalTaskClient.test.ts

@@ -3,11 +3,14 @@ import { afterEach, describe, expect, it } from "bun:test";
 import {
   bindOperationalTaskCredential,
   humanTaskEvidenceCommandSchema,
+  hasOperationalTaskRun,
   OperationalTaskClient,
   proposedTaskActionSchema,
   releaseOperationalTaskCredential,
 } from "../../src/product/operational-task-client.js";
 
+import { runBackgroundTaskExecution } from "../../src/routes/chatSessionRoutes.js";
+
 const originalFetch = globalThis.fetch;
 const taskId = "50000000-0000-4000-8000-000000000001";
 const runId = "55000000-0000-4000-8000-000000000001";
@@ -364,3 +367,28 @@ describe("OperationalTaskClient", () => {
     expect(requestBodies[2]).toMatchObject({ expected_revision: 3 });
   });
 });
+
+
+it.each([true, false])("retains lease state on background stream loss only while running=%s", async (running) => {
+  const credential = { authorization: "Bearer fixture", projectId: "project-1" };
+  bindOperationalTaskCredential("runtime-1", credential);
+  globalThis.fetch = (async () => Response.json(run)) as unknown as typeof fetch;
+  const client = new OperationalTaskClient("http://server.test");
+  await client.claimTask("runtime-1", taskId, runId, {
+    requestId: executionRequestId, expectedRevision: 1, sourceSessionId: "session-1",
+  });
+  expect(hasOperationalTaskRun("runtime-1")).toBe(true);
+  globalThis.fetch = (async () => new Response(new ReadableStream({
+    start(controller) { controller.error(new Error("fixture stream disconnected")); },
+  }))) as unknown as typeof fetch;
+  await runBackgroundTaskExecution({ sessionId: "runtime-1", credential, model: "fixture/model",
+    isRunning: () => running });
+  expect(hasOperationalTaskRun("runtime-1")).toBe(running);
+  if (running) {
+    globalThis.fetch = (async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+      expect(JSON.parse(String(init?.body)).expected_revision).toBe(2);
+      return Response.json({ ...run, revision: 3 });
+    }) as unknown as typeof fetch;
+    await client.heartbeatTask("runtime-1", taskId, runId, "session-1");
+  }
+});

tests/routes/answerViewStateRoutes.test.ts

@@ -31,7 +31,7 @@ it("authenticates state reads and writes against the persisted session owner and
   const context = getLocalAgentContext(ownerRequest);
   const sessionId = "state-session";
   await sessions.ensure({ ...context, sessionId });
-  await new SessionUiStateStore(join(root, "unused"), workspaces).write({ ...context, sessionId }, { sessionId, messages: [{ id: "assistant", role: "assistant", parts: [{ type: "data-answer_ui", data: { version: "answer-ui@1", block_id: "block", fallback_text: "fallback", spec: { root: "evidence", elements: { evidence: { type: "Evidence", props: { title: "Evidence", summary: "Summary", source: "source", evidence_id: null, observed_at: null, kind: "observed" }, children: [] } } } } }] }] });
+  await new SessionUiStateStore(workspaces).write({ ...context, sessionId }, { sessionId, messages: [{ id: "assistant", role: "assistant", parts: [{ type: "data-answer_ui", data: { version: "answer-ui@1", block_id: "block", fallback_text: "fallback", spec: { root: "evidence", elements: { evidence: { type: "Evidence", props: { title: "Evidence", summary: "Summary", source: "source", evidence_id: null, observed_at: null, kind: "observed" }, children: [] } } } } }] }] });
   const app = express();
   app.use(express.json({ limit: "2mb" }));
   app.use(async (req, res, next) => {

tests/routes/chat-run-accumulator.test.ts

@@ -0,0 +1,47 @@
+import { expect, it } from "bun:test";
+import type { UIMessageChunk } from "ai";
+import { createChatRunAccumulator, publishRunEvent } from "../../src/routes/chat-run-accumulator.js";
+import { createInitialStreamingMessages, type ActiveRun } from "../../src/routes/chatUiState.js";
+
+it.each([false, true])("projects one event stream into reconnect and persisted messages (collaboration=%s)", (collaboration) => {
+  const run: ActiveRun = {
+    clientSessionId: "s", controller: new AbortController(), status: "running",
+    messages: createInitialStreamingMessages([], "查询"), pendingPermissions: new Map(), pendingQuestions: new Map(), subscribers: new Set(),
+  };
+  const chunks: UIMessageChunk[] = [];
+  const stream = createChatRunAccumulator({ run, messages: [{ id: "user", role: "user", parts: [{ type: "text", text: "查询" }] }],
+    messageId: "answer", sessionId: "s", collaboration, write: (chunk) => chunks.push(chunk), onStatus() {} });
+  stream.apply("progress", { id: "query", status: "running", title: "查询资料" });
+  stream.apply("token", { content: "已有数据" });
+  stream.apply("permission_request", { request_id: "permission", session_id: "s", permission: "shell", patterns: [], always: [], created_at: 1 });
+  stream.apply("permission_response", { request_id: "permission", reply: "once" });
+  stream.appendInput({ id: "extra", role: "user", parts: [{ type: "text", text: "补充" }] }, "补充");
+  stream.appendInput({ id: "extra", role: "user", parts: [] }, "重复");
+  stream.apply("final_answer", { content: "结论" });
+  stream.apply("done", {});
+  expect(run.status).toBe("completed");
+  expect(run.pendingPermissions.size).toBe(0);
+  expect(run.messages.at(-1)).toMatchObject({ id: "answer", content: "结论", permissions: [{ status: "approved_once" }], progress: [{ status: "completed" }, { status: "completed" }] });
+  const saved = stream.uiMessages();
+  expect(saved.map((message) => message.id)).toEqual(["user", "extra", "answer"]);
+  expect(saved.at(-1)?.parts).toEqual((run.messages.at(-1) as { parts: typeof saved[number]["parts"] }).parts);
+  expect(saved.at(-1)?.parts.some((part) => part.type === "data-progress")).toBe(!collaboration);
+  expect(chunks.filter((chunk) => chunk.type === "finish")).toHaveLength(1);
+});
+
+it.each(["done", "error", "aborted"])("publishes the same %s terminal state to reconnect subscribers and storage", (event) => {
+  const run: ActiveRun = {
+    clientSessionId: "s", controller: new AbortController(), status: "running",
+    messages: createInitialStreamingMessages([], "查询"), pendingPermissions: new Map(), pendingQuestions: new Map(), subscribers: new Set(),
+  };
+  const received: Array<{ event: string; data: Record<string, unknown> }> = [];
+  run.subscribers.add({ write: (event, data) => received.push({ event, data }), close() {} });
+  const stream = createChatRunAccumulator({ run, messages: [], messageId: "answer", sessionId: "s",
+    collaboration: false, write() {}, onStatus() {} });
+  publishRunEvent(run, "progress", { id: "tool", title: "正在处理", status: "running", phase: "tool" });
+  publishRunEvent(run, "token", { content: "部分结果" });
+  publishRunEvent(run, event, { session_id: "s", message: "执行已停止" });
+  const canonical = stream.uiMessages().at(-1)?.parts.find((part) => part.type === "data-run_status");
+  expect(received.at(-2)).toMatchObject({ event: "run_status", data: { status: event === "done" ? "completed" : event } });
+  expect(canonical).toMatchObject({ data: { status: received.at(-2)?.data.status } });
+});

tests/routes/chat-topics.test.ts

@@ -22,7 +22,7 @@ it("persists owned topics, searches old text across themes and preserves chats w
   globalThis.fetch = (async (_input, init) => Response.json({ user_id: new Headers(init?.headers).get("authorization") === "Bearer owner" ? "owner" : "other", project_id: new Headers(init?.headers).get("x-project-id"), network: "supply" })) as typeof fetch;
   const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
   const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
-  const states = new SessionUiStateStore(join(root, "ui"), workspaces);
+  const states = new SessionUiStateStore(workspaces);
   for (const id of ["a", "b", "unclassified"]) {
     await sessions.ensure({ ...context, sessionId: id });
     await states.write({ ...context, sessionId: id }, { sessionId: id, messages: [

tests/routes/chatStream.test.ts

@@ -714,3 +714,40 @@ describe("streamPromptResponse", () => {
   });
 
 });
+
+
+describe("background sandbox permissions", () => {
+  it.each([["permission.asked", true], ["permission.v2.asked", true],
+    ["permission.asked", false], ["permission.v2.asked", false]] as const)("limits session Shell/edit approval for %s background=%s", async (type, background) => {
+    const replies: Array<Record<string, unknown>> = [];
+    const runtime = {
+      subscribeEvents: async () => createEventStream([
+        ...["shell", "edit", "mcp_fixture_write"].map((action) => ({
+          type,
+          properties: {
+            id: action, sessionID: "runtime-session-1",
+            ...(type === "permission.asked"
+              ? { permission: action, patterns: ["fixture"], always: [] }
+              : { action, resources: ["fixture"], save: [] }),
+          },
+        })),
+        { type: "session.idle", properties: { sessionID: "runtime-session-1" } },
+      ]),
+      prompt: async () => undefined,
+      messages: async () => [],
+      replyPermission: async (input: Record<string, unknown>) => { replies.push(input); },
+    } as unknown as OpencodeRuntimeAdapter;
+    const events: Array<{ event: string; data: Record<string, unknown> }> = [];
+    await streamPromptResponse({
+      runtime, sessionId: "runtime-session-1", clientSessionId: "client-session-1",
+      message: "后台调查", approvalMode: "request", backgroundSandboxPermissions: background,
+      write: (event, data) => events.push({ event, data }),
+    });
+    expect(replies).toEqual(background ? [
+      { requestId: "shell", sessionId: "runtime-session-1", reply: "once" },
+      { requestId: "edit", sessionId: "runtime-session-1", reply: "once" },
+    ] : []);
+    expect(events.filter(({ event }) => event === "permission_request")
+      .map(({ data }) => data.permission)).toEqual(background ? ["mcp_fixture_write"] : ["shell", "edit", "mcp_fixture_write"]);
+  });
+});

tests/routes/credentialRefreshRoute.test.ts

@@ -7,6 +7,7 @@ import { attachTrustedAgentContext } from "../../src/context/localContext.js";
 import { registerChatInteractionRoutes } from "../../src/routes/chatInteractionRoutes.js";
 import { bindSessionCredential, credentialRefreshCoordinator, releaseSessionCredential } from "../../src/product/credential-refresh.js";
 import { SessionMetadataStore } from "../../src/sessions/metadataStore.js";
+import { SessionWorkspaceStore } from "../../src/sessions/workspace-store.js";
 import { SessionUiStateStore } from "../../src/sessions/uiStateStore.js";
 import { toActorKey, toProjectKey } from "../../src/utils/fileStore.js";
 import type { ActiveRun } from "../../src/routes/chatUiState.js";
@@ -28,7 +29,7 @@ describe("credential refresh HTTP route", () => {
     const router = express.Router();
     router.use((req, res, next) => { void attachTrustedAgentContext(req).then(() => next()).catch(() => res.sendStatus(401)); });
     const activeRuns = new Map<string, ActiveRun>([["credential-route-session", { clientSessionId: "credential-route-session", controller: new AbortController(), messages: [], pendingPermissions: new Map(), pendingQuestions: new Map(), subscribers: new Set(), status: "running" }]]);
-    registerChatInteractionRoutes(router, { activeRuns, runtime: {} as OpencodeRuntimeAdapter, sessionMetadataStore: metadata, sessionUiStateStore: new SessionUiStateStore(join(directory, "ui")) });
+    registerChatInteractionRoutes(router, { activeRuns, runtime: {} as OpencodeRuntimeAdapter, sessionMetadataStore: metadata, sessionUiStateStore: new SessionUiStateStore(new SessionWorkspaceStore(join(directory, "workspaces"))) });
     app.use(router);
     const server = app.listen(0, "127.0.0.1");
     await new Promise<void>((resolve) => server.once("listening", resolve));

tests/routes/hostQuestionStream.test.ts

@@ -115,7 +115,7 @@ it("uses authenticated /responses for saved answers and rejects bypass and forei
   globalThis.fetch = (async (_input, init) => Response.json({ user_id: new Headers(init?.headers).get("Authorization") === "Bearer owner" ? "owner" : "other", project_id: project, network: "fixture" })) as typeof fetch;
   const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
   const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
-  const states = new SessionUiStateStore(join(root, "unused"), workspaces);
+  const states = new SessionUiStateStore(workspaces);
   const interactions = new InteractionRequestStore(workspaces);
   const context = { actorKey: toActorKey("product:owner"), projectKey: toProjectKey(`product:${project}`), projectId: project, userId: "owner", sessionId: "owned" };
   await sessions.ensure(context);

tests/routes/legacyQuestionRoutes.test.ts

@@ -5,16 +5,43 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { getLocalAgentContext } from "../../src/context/localContext.js";
 import { registerChatInteractionRoutes } from "../../src/routes/chatInteractionRoutes.js";
-import type { OpencodeRuntimeAdapter } from "../../src/runtime/opencode.js";
+import { OpencodeRuntimeAdapter } from "../../src/runtime/opencode.js";
 import { SessionMetadataStore } from "../../src/sessions/metadataStore.js";
 import { SessionUiStateStore } from "../../src/sessions/uiStateStore.js";
 import { SessionWorkspaceStore } from "../../src/sessions/workspace-store.js";
 
+it("reads a native form once when checking and answering a persisted question", async () => {
+  const root = await mkdtemp(join(tmpdir(), "question-single-read-"));
+  const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
+  const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
+  const states = new SessionUiStateStore(workspaces);
+  const context = { ...getLocalAgentContext(), sessionId: "session" };
+  await sessions.ensure(context);
+  await states.write(context, { sessionId: context.sessionId, messages: [{ role: "assistant", questions: [{ requestId: "form", status: "pending" }] }] });
+  const calls: string[] = [];
+  const runtime = Object.assign(Object.create(OpencodeRuntimeAdapter.prototype), {
+    ensureClient: async () => ({ session: { form: {
+      get: async () => { calls.push("get"); return { fields: [{ key: "answer", type: "text" }], state: { status: "pending" } }; },
+      reply: async (input: { answer: unknown }) => { calls.push("reply"); expect(input.answer).toEqual({ answer: "A" }); },
+    } } }),
+  });
+  const routes = new Map<string, (req: unknown, res: unknown) => Promise<void>>();
+  const router = { get() {}, post(path: string, handler: (req: unknown, res: unknown) => Promise<void>) { routes.set(path, handler); } };
+  registerChatInteractionRoutes(router as unknown as express.Router, { activeRuns: new Map(), runtime, sessionMetadataStore: sessions, sessionUiStateStore: states });
+  const req = { params: { request_id: "form" }, body: { session_id: "session", answers: [["A"]] }, header() { return undefined; } };
+  const response = { code: 200, setHeader() {}, status(code: number) { this.code = code; return this; }, json() { return this; } };
+  try {
+    await routes.get("/question/:request_id/reply")!(req, response);
+    expect(response.code).toBe(202);
+    expect(calls).toEqual(["get", "reply"]);
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
 it("reconciles persisted legacy forms and replies after the active run was lost", async () => {
   const root = await mkdtemp(join(tmpdir(), "legacy-question-routes-"));
   const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
   const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
-  const states = new SessionUiStateStore(join(root, "unused"), workspaces);
+  const states = new SessionUiStateStore(workspaces);
   const context = { ...getLocalAgentContext(), sessionId: "session" };
   await sessions.ensure(context);
   await states.write(context, { sessionId: "session", messages: [{ id: "old", role: "assistant", questions: [{ requestId: "form", status: "pending", tool: { callID: "call" } }] }, { id: "new", role: "assistant", text: "later message", parts: [{ type: "data-question_request", data: { request_id: "form2", session_id: "session", questions: [], tool: { callID: "call2" } } }, { type: "data-question_request", data: { request_id: "form3", session_id: "session", questions: [] } }, { type: "data-question_request", data: { request_id: "form4", session_id: "session", questions: [] } }] }] });
@@ -22,7 +49,7 @@ it("reconciles persisted legacy forms and replies after the active run was lost"
   let unavailable = false;
   let reads = 0;
   let replies = 0;
-  const runtime = { getQuestionStatus: async () => { reads++; if (unavailable) throw new Error("private-native-path"); return status; }, replyQuestion: async () => { replies++; status = "answered"; }, rejectQuestion: async () => { status = "cancelled"; } } as unknown as OpencodeRuntimeAdapter;
+  const runtime = { getQuestion: async () => { reads++; if (unavailable) throw new Error("private-native-path"); return status === "missing" ? null : { state: { status } }; }, replyQuestion: async () => { replies++; status = "answered"; }, rejectQuestion: async () => { status = "cancelled"; } } as unknown as OpencodeRuntimeAdapter;
   const app = express(); app.use(express.json());
   registerChatInteractionRoutes(app, { activeRuns: new Map(), runtime, sessionMetadataStore: sessions, sessionUiStateStore: states });
   const server = app.listen(0, "127.0.0.1");

tests/routes/permissionPersistence.test.ts

@@ -0,0 +1,58 @@
+import { createChatRunAccumulator } from "../../src/routes/chat-run-accumulator.js";
+import { expect, it } from "bun:test";
+import express from "express";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getLocalAgentContext } from "../../src/context/localContext.js";
+import { registerChatInteractionRoutes } from "../../src/routes/chatInteractionRoutes.js";
+import type { ActiveRun } from "../../src/routes/chatUiState.js";
+import type { OpencodeRuntimeAdapter } from "../../src/runtime/opencode.js";
+import { SessionMetadataStore } from "../../src/sessions/metadataStore.js";
+import { SessionUiStateStore } from "../../src/sessions/uiStateStore.js";
+import { SessionWorkspaceStore } from "../../src/sessions/workspace-store.js";
+
+it.each([false, true])("persists permission replies in the owner's workspace (native failure=%s)", async (nativeFailure) => {
+  const root = await mkdtemp(join(tmpdir(), "permission-persistence-"));
+  const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
+  const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
+  const states = new SessionUiStateStore(workspaces);
+  const context = { ...getLocalAgentContext(), sessionId: "permission-session" };
+  await sessions.ensure(context);
+  const messages = [{ id: "answer", role: "assistant", permissions: [] }];
+  await states.write(context, { sessionId: context.sessionId, isTitleManuallyEdited: true, messages });
+  let calls = 0;
+  const runtime = { replyPermission: async () => { calls++; if (nativeFailure) throw new Error("native unavailable"); } } as unknown as OpencodeRuntimeAdapter;
+  const run: ActiveRun = {
+    clientSessionId: context.sessionId, controller: new AbortController(), messages,
+    pendingPermissions: new Map([["permission", { request_id: "permission", session_id: context.sessionId, permission: "shell", patterns: [], always: [], created_at: Date.now() }]]),
+    pendingQuestions: new Map(), subscribers: new Set(), status: "running",
+  };
+  const accumulator = createChatRunAccumulator({ run, messages: [], messageId: "answer", sessionId: context.sessionId,
+    collaboration: false, write() {}, onStatus() {} });
+  accumulator.apply("permission_request", run.pendingPermissions.get("permission")! as unknown as Record<string, unknown>);
+  await states.write(context, { sessionId: context.sessionId, isTitleManuallyEdited: true, messages: run.messages });
+  const app = express(); app.use(express.json());
+  registerChatInteractionRoutes(app, { activeRuns: new Map([[context.sessionId, run]]), runtime, sessionMetadataStore: sessions, sessionUiStateStore: states });
+  const server = app.listen(0, "127.0.0.1");
+  await new Promise<void>((resolve) => server.once("listening", resolve));
+  const url = `http://127.0.0.1:${(server.address() as { port: number }).port}/permission/permission/reply`;
+  const reply = (headers = {}) => fetch(url, { method: "POST", headers: { "Content-Type": "application/json", ...headers }, body: JSON.stringify({ session_id: context.sessionId, reply: "once" }) });
+  try {
+    expect((await reply({ "X-Agent-Local-User": "other" })).status).toBe(404);
+    expect(calls).toBe(0);
+    expect((await reply()).status).toBe(nativeFailure ? 502 : 202);
+    expect(calls).toBe(1);
+    expect(run.pendingPermissions.has("permission")).toBe(nativeFailure);
+    const saved = await states.read(context);
+    expect(saved?.isTitleManuallyEdited).toBe(true);
+    const parts = (saved?.messages[0] as { parts: Array<{ type: string; data: Record<string, unknown> }> }).parts;
+    expect(parts.find((part) => part.type === "data-permission_response")?.data).toMatchObject(nativeFailure
+      ? { request_id: "permission", status: "error", error: "native unavailable" }
+      : { request_id: "permission", reply: "once" });
+    expect(run.messages[0]).toMatchObject({ permissions: [{ requestId: "permission", status: nativeFailure ? "error" : "approved_once" }] });
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    await rm(root, { recursive: true, force: true });
+  }
+});

tests/routes/question-persistence.test.ts

@@ -0,0 +1,71 @@
+import { expect, it } from "bun:test";
+import express from "express";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { UIMessage } from "ai";
+import { getLocalAgentContext } from "../../src/context/localContext.js";
+import { createChatRunAccumulator } from "../../src/routes/chat-run-accumulator.js";
+import { registerChatInteractionRoutes } from "../../src/routes/chatInteractionRoutes.js";
+import { createInitialStreamingMessages, type ActiveRun } from "../../src/routes/chatUiState.js";
+import type { OpencodeRuntimeAdapter } from "../../src/runtime/opencode.js";
+import { SessionMetadataStore } from "../../src/sessions/metadataStore.js";
+import { SessionUiStateStore } from "../../src/sessions/uiStateStore.js";
+import { SessionWorkspaceStore } from "../../src/sessions/workspace-store.js";
+
+it("keeps historical question invalidation across the next live snapshot", async () => {
+  const root = await mkdtemp(join(tmpdir(), "question-persistence-"));
+  const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
+  const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
+  const states = new SessionUiStateStore(workspaces);
+  const context = { ...getLocalAgentContext(), sessionId: "history-session" };
+  await sessions.ensure(context);
+  const history: UIMessage[] = [{ id: "old-answer", role: "assistant", parts: [
+    { type: "data-question_request", data: { request_id: "old-question", session_id: context.sessionId,
+      questions: [{ question: "继续吗？", options: [] }] } },
+    { type: "data-final_answer", data: { content: "此前的结果" } },
+  ] }, { id: "user", role: "user", parts: [{ type: "text", text: "新一轮" }] }];
+  const run: ActiveRun = {
+    clientSessionId: context.sessionId, controller: new AbortController(), status: "running",
+    messages: createInitialStreamingMessages(history, "新一轮"),
+    pendingPermissions: new Map(), pendingQuestions: new Map(), subscribers: new Set(),
+  };
+  const stream = createChatRunAccumulator({ run, messages: history, messageId: "current-answer",
+    sessionId: context.sessionId, collaboration: false, write() {}, onStatus() {} });
+  stream.apply("token", { content: "正在核查" });
+  await states.write(context, { sessionId: context.sessionId, isTitleManuallyEdited: true, messages: stream.uiMessages() });
+  let nativeReads = 0;
+  const runtime = { getQuestion: async () => { nativeReads++; return null; } } as unknown as OpencodeRuntimeAdapter;
+  const app = express();
+  registerChatInteractionRoutes(app, { activeRuns: new Map([[context.sessionId, run]]), runtime,
+    sessionMetadataStore: sessions, sessionUiStateStore: states });
+  const server = app.listen(0, "127.0.0.1");
+  await new Promise<void>((resolve) => server.once("listening", resolve));
+  const url = `http://127.0.0.1:${(server.address() as { port: number }).port}/session/${context.sessionId}/questions/old-question`;
+  const resolved = (messages: unknown[]) => {
+    const message = messages[0] as UIMessage;
+    expect(message.id).toBe("old-answer");
+    const part = message.parts.find((part) => part.type === "data-question_response");
+    expect(part).toMatchObject({ type: "data-question_response", data: { request_id: "old-question", status: "invalidated" } });
+  };
+  try {
+    expect((await fetch(url, { headers: { "X-Agent-Local-User": "other" } })).status).toBe(404);
+    expect(nativeReads).toBe(0);
+    const response = await fetch(url);
+    expect(response.status).toBe(200);
+    expect(await response.json()).toMatchObject({ status: "invalidated" });
+    resolved((await states.read(context))!.messages);
+    resolved(run.messages);
+    resolved(stream.uiMessages());
+    expect(stream.uiMessages().at(-1)?.parts.some((part) => part.type === "data-question_response")).toBe(false);
+    stream.apply("token", { content: "，继续查询" });
+    await states.write(context, { ...(await states.read(context))!, messages: stream.uiMessages() });
+    resolved((await states.read(context))!.messages);
+    expect((await states.read(context))?.isTitleManuallyEdited).toBe(true);
+    await fetch(url);
+    expect(nativeReads).toBe(1);
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    await rm(root, { recursive: true, force: true });
+  }
+});

tests/routes/responses.test.ts

@@ -44,7 +44,7 @@ beforeEach(async () => {
   })) as typeof fetch;
   const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
   const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
-  states = new SessionUiStateStore(join(root, "ui"), workspaces);
+  states = new SessionUiStateStore(workspaces);
   interactions = new InteractionRequestStore(workspaces);
   await sessions.initialize();
   const context = { actorKey: toActorKey("product:owner"), projectKey: toProjectKey(`product:${project}`), projectId: project, userId: "owner", sessionId: "owned" };
@@ -296,6 +296,11 @@ it("marks an explicitly aborted response incomplete and preserves scoped history
   const text = await response.text();
   expect(text).toContain("event: response.incomplete");
   expect(text).not.toContain("event: response.completed");
+  const context = { actorKey: toActorKey("product:owner"), projectKey: toProjectKey(`product:${project}`), sessionId: "owned" };
+  const saved = (await states.read(context))!.messages as Array<{ parts: Array<{ type: string; data?: { status?: string } }> }>;
+  expect(saved.at(-1)?.parts.find((part) => part.type === "data-run_status")?.data?.status).toBe("aborted");
+  const loaded = await http(`${base}/api/v1/session/owned`, { headers: { Authorization: "Bearer owner", "X-Project-Id": project } });
+  expect((await loaded.json()).messages).toEqual(saved);
 });
 
 it("continues a paged conversation from the complete saved history and preserves client message IDs", async () => {
@@ -316,3 +321,28 @@ it("continues a paged conversation from the complete saved history and preserves
   expect((await call({ input: "重复提交", conversation: "owned", tjwater: { client_message_id: "client-turn-a" } })).status).toBe(409);
   expect(prompted).toHaveLength(1);
 });
+
+it("uses the same canonical live messages for session reads and older pages", async () => {
+  gate = new Promise<void>((resolve) => { release = resolve; });
+  const context = { actorKey: toActorKey("product:owner"), projectKey: toProjectKey(`product:${project}`), sessionId: "owned" };
+  const history = Array.from({ length: 5 }, (_, index) => ({ id: `old-${index}`, role: index % 2 ? "assistant" : "user",
+    parts: [{ type: "text", text: `历史 ${index}` }] as unknown[] }));
+  history[1].parts.push({ type: "data-question_request", data: { request_id: "old-question", session_id: "owned", questions: [] } });
+  await states.write(context, { sessionId: "owned", messages: history });
+  const response = await call({ input: "新一轮", conversation: "owned", stream: true, tjwater: { client_message_id: "live-user" } });
+  const headers = { Authorization: "Bearer owner", "X-Project-Id": project };
+  const live = await http(`${base}/api/v1/session/owned`, { headers });
+  const snapshot = await live.json();
+  expect(snapshot.is_streaming).toBe(true);
+  expect(snapshot.messages).toHaveLength(7);
+  expect(snapshot.messages.slice(0, 5)).toEqual(history);
+  expect(snapshot.messages[5].id).toBe("live-user");
+  const recent = await http(`${base}/api/v1/session/owned?message_limit=2`, { headers });
+  const page = await recent.json();
+  expect(page.messages).toEqual(snapshot.messages.slice(-2));
+  const older = await http(`${base}/api/v1/session/owned/messages?limit=40&before=${encodeURIComponent(page.message_page.before_cursor)}`, { headers });
+  expect(older.status).toBe(200);
+  expect((await older.json()).messages).toEqual(history);
+  release();
+  await response.text();
+});

tests/routes/sandboxToolBridge.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, it } from "bun:test";
 import express from "express";
 import { type Server } from "node:http";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { mkdtemp, mkdir, readFile, rm, writeFile, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { config } from "../../src/config.js";
@@ -11,6 +11,7 @@ import { registerSandboxToolBridge } from "../../src/routes/sandboxToolBridge.js
 
 let server: Server | undefined;
 let root: string | undefined;
+const previousDataHome = process.env.XDG_DATA_HOME;
 const previousRoot = config.CONVERSATION_WORKSPACE_ROOT;
 const session = "sandbox-bridge-test";
 afterEach(async () => {
@@ -18,6 +19,8 @@ afterEach(async () => {
   if (root) await rm(root, { recursive: true, force: true });
   config.CONVERSATION_WORKSPACE_ROOT = previousRoot;
   removeRuntimeSessionContext(session);
+  if (previousDataHome === undefined) delete process.env.XDG_DATA_HOME;
+  else process.env.XDG_DATA_HOME = previousDataHome;
 });
 describe("sandbox execution bridge", () => {
   it("executes only after approval and cannot override the owning workspace", async () => {
@@ -31,6 +34,7 @@ describe("sandbox execution bridge", () => {
     const requested = new Promise<void>((resolve) => { ready = resolve; });
     const app = express(); app.use(express.json());
     registerSandboxToolBridge(app, { internalToken: "TEST_ONLY", runtime: {
+      messages: async () => [],
       ensureSessionWorkspace: async (id) => { expect(id).toBe(session); return directory; },
       approveSandboxShell: async (input) => { if (approved) return; expect(input.command).toContain("approved.txt"); ready(); await new Promise<void>((resolve) => { approve = resolve; }); approved = true; },
     } });
@@ -55,3 +59,50 @@ describe("sandbox execution bridge", () => {
     expect(await readFile(large.stdout_file, "utf8")).toBe(`${"x".repeat(10000)}\n`);
   });
 });
+
+
+it("stages only this session's native output and keeps the global directory sandboxed", async () => {
+  root = await mkdtemp(join(tmpdir(), "sandbox-output-test-"));
+  config.CONVERSATION_WORKSPACE_ROOT = root;
+  process.env.XDG_DATA_HOME = join(root, "native");
+  const output = join(process.env.XDG_DATA_HOME, "opencode", "tool-output");
+  await mkdir(output, { recursive: true });
+  const own = join(output, "tool_own"), other = join(output, "tool_other");
+  const content = JSON.stringify({ evidence_id: "fixture", readings: "完整结果".repeat(1000) });
+  await writeFile(own, content); await writeFile(other, "other session");
+  const directory = await createConversationWorkspace(root);
+  setRuntimeSessionContext({ sessionId: session, clientSessionId: session, actorKey: "owner", projectKey: "project", traceId: "test" });
+  const metadata = { truncated: true, outputPath: own };
+  const app = express(); app.use(express.json());
+  registerSandboxToolBridge(app, { internalToken: "TEST_ONLY", runtime: {
+    ensureSessionWorkspace: async () => directory,
+    approveSandboxShell: async () => {},
+    messages: async () => [{ info: { id: "native", role: "assistant" }, parts: [{
+      type: "tool", state: { status: "completed", metadata },
+    }] }] as never,
+  } });
+  server = app.listen(0, "127.0.0.1");
+  await new Promise<void>((resolve) => server!.once("listening", resolve));
+  const post = async (command: string) => {
+    const response = await fetch(`http://127.0.0.1:${(server!.address() as { port: number }).port}/internal/tools/sandbox-shell`, {
+      method: "POST", headers: { "Content-Type": "application/json", "x-agent-internal-token": "TEST_ONLY" },
+      body: JSON.stringify({ session_id: session, call_id: "fixture", message_id: "fixture", command }),
+    });
+    return { status: response.status, data: await response.json() as Record<string, any> };
+  };
+  const staged = await post(`cat '${own}'`);
+  expect(staged.status).toBe(200);
+  expect(staged.data.outcome).toBe("requires_session_path");
+  const file = staged.data.files[0];
+  expect(await readFile(join(directory, file.relative_path), "utf8")).toBe(content);
+  const result = await post(`python3 -c 'import hashlib; print(hashlib.sha256(open("${file.shell_path}","rb").read()).hexdigest())'`);
+  expect(result.data.exitCode).toBe(0);
+  expect(result.data.stdout.trim()).toBe(file.sha256);
+  const forbidden = await post(`cat '${other}'`);
+  expect(forbidden.data.exitCode).not.toBe(0);
+  expect(forbidden.data.stderr).toContain("Permission denied");
+  const link = join(output, "tool_link");
+  await symlink(other, link);
+  metadata.outputPath = link;
+  expect((await post(`cat '${link}'`)).status).toBe(503);
+});

tests/routes/server-contract-sync.test.ts

@@ -0,0 +1,39 @@
+import { expect, it } from "bun:test";
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { astToString, COMMENT_HEADER, default as openapiTS } from "openapi-typescript";
+
+it.each(["valid", "invalid-schema", "invalid-digest"])("synchronizes the complete artifact group or preserves it (%s)", async (scenario) => {
+  const root = await mkdtemp(join(tmpdir(), "server-contract-sync-"));
+  try {
+    for (const directory of ["scripts", "openapi", "src/generated", "upstream"]) await mkdir(join(root, directory), { recursive: true });
+    await copyFile(new URL("../../scripts/server-contract.ts", import.meta.url), join(root, "scripts/server-contract.ts"));
+    await symlink(new URL("../../node_modules", import.meta.url).pathname, join(root, "node_modules"), "dir");
+    const targets = ["openapi/openapi.json", "openapi/server-manifest.json", "src/generated/server-api.d.ts"];
+    for (const target of targets) await writeFile(join(root, target), `original:${target}`);
+    const schema = { openapi: scenario === "invalid-schema" ? "9.9.9" : "3.1.0", info: { title: "Fixture", version: "1" }, paths: {} };
+    const raw = JSON.stringify(schema);
+    const manifest = { contracts: { server: { sha256: scenario === "invalid-digest" ? "incorrect" : createHash("sha256").update(raw).digest("hex") } } };
+    await writeFile(join(root, "upstream/schema.json"), raw);
+    await writeFile(join(root, "upstream/manifest.json"), JSON.stringify(manifest));
+    const child = Bun.spawn([process.execPath, "scripts/server-contract.ts", "--sync", "--upstream", "upstream/schema.json"], {
+      cwd: root, stdout: "pipe", stderr: "pipe",
+    });
+    const [code, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+    if (scenario === "valid") {
+      expect(code).toBe(0);
+      expect(await readFile(join(root, targets[0]), "utf8")).toBe(raw);
+      expect(JSON.parse(await readFile(join(root, targets[1]), "utf8"))).toEqual(manifest);
+      expect(await readFile(join(root, targets[2]), "utf8")).toBe(COMMENT_HEADER + astToString(await openapiTS(schema)));
+    } else {
+      expect(code).not.toBe(0);
+      expect(stderr).toContain(scenario === "invalid-schema" ? "Unsupported OpenAPI version" : "contract digest differs");
+      for (const target of targets) expect(await readFile(join(root, target), "utf8")).toBe(`original:${target}`);
+    }
+    expect((await readdir(join(root, "openapi"))).sort()).toEqual(["openapi.json", "server-manifest.json"]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

tests/routes/sessionIsolation.test.ts

@@ -47,7 +47,7 @@ describe("chat session HTTP isolation", () => {
 
     const workspaces = new SessionWorkspaceStore(join(metadataDir, "workspaces"));
     const sessionMetadataStore = new SessionMetadataStore(metadataDir, workspaces);
-    const sessionUiStateStore = new SessionUiStateStore(join(metadataDir, "old-ui"), workspaces);
+    const sessionUiStateStore = new SessionUiStateStore(workspaces);
     await sessionMetadataStore.initialize();
     const ownerContext = {
       actorKey: toActorKey("product:user-a"),

tests/routes/task-collaboration-sessions.test.ts

@@ -33,7 +33,7 @@ async function fixture() {
   const context = { actorKey: toActorKey("product:owner"), projectKey: toProjectKey(`product:${projectId}`), projectId, userId: "owner" };
   const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
   const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
-  const states = new SessionUiStateStore(join(root, "states"), workspaces);
+  const states = new SessionUiStateStore(workspaces);
   const taskNames = new Map([[firstTask, "南桥管道爆管调查"], [secondTask, "城南供水压力复核"]]);
   const taskReads: string[] = [];
   let available = true;

tests/routes/task-command-bridge.test.ts

@@ -0,0 +1,45 @@
+import { expect, it } from "bun:test";
+import express from "express";
+import type { OperationalTaskClient } from "../../src/product/operational-task-client.js";
+import { registerTaskCommandBridge } from "../../src/routes/task-command-bridge.js";
+import { removeRuntimeSessionContext, setRuntimeSessionContext } from "../../src/runtime/sessionContext.js";
+
+it("preserves command-specific session purposes and trusted bridge authentication", async () => {
+  const calls: unknown[][] = [];
+  const client = {
+    requestDataAccess: async (...args: unknown[]) => { calls.push(args); return {}; },
+    proposeAction: async (...args: unknown[]) => { calls.push(args); throw Object.assign(new Error("conflict"), { status: 409 }); },
+    addHumanEvidence: async (...args: unknown[]) => { calls.push(args); return {}; },
+  } as unknown as Pick<OperationalTaskClient, "requestDataAccess" | "proposeAction" | "addHumanEvidence">;
+  for (const purpose of ["task_execution", "task_collaboration"] as const) setRuntimeSessionContext({
+    sessionId: purpose, clientSessionId: `client-${purpose}`, taskId: "task", purpose,
+    actorKey: "actor", projectKey: "project", traceId: "test",
+  });
+  const app = express(); app.use(express.json());
+  registerTaskCommandBridge(app, { internalToken: "test-token", client });
+  const server = app.listen(0, "127.0.0.1");
+  await new Promise<void>((resolve) => server.once("listening", resolve));
+  const post = (kind: string, session: string, data: object, headers = {}) => fetch(`http://127.0.0.1:${(server.address() as { port: number }).port}/internal/operational-task/${kind}`, {
+    method: "POST", headers: { "Content-Type": "application/json", "x-agent-internal-token": "test-token", ...headers }, body: JSON.stringify({ session_id: session, ...data }),
+  });
+  const requestId = "60000000-0000-4000-8000-000000000001";
+  const access = { request: { requestId, nodeId: "read", scopes: ["scada_devices"], reason: "查询" } };
+  const evidence = { command: { request_id: requestId, evidence: { evidence_id: "e1", kind: "human_input", summary: "已复核", source_label: "用户", observed_at: "2026-11-09T00:00:00Z" } } };
+  try {
+    expect((await post("access-requests", "task_execution", access, { Origin: "http://browser.test" })).status).toBe(403);
+    expect((await post("access-requests", "task_execution", access, { "x-agent-internal-token": "wrong" })).status).toBe(403);
+    expect((await post("access-requests", "task_collaboration", access)).status).toBe(403);
+    expect((await post("human-evidence", "task_execution", evidence)).status).toBe(403);
+    expect(calls).toHaveLength(0);
+    expect((await post("access-requests", "task_execution", access)).status).toBe(200);
+    expect(calls[0]).toEqual(["task_execution", "task", { ...access.request, sourceSessionId: "client-task_execution" }]);
+    expect((await post("human-evidence", "task_collaboration", evidence)).status).toBe(200);
+    const action = { action: { request_id: requestId, reason: "核验", kind: "create_work_order", payload: { title: "采样", description: "核验", work_order_type: "general" } } };
+    expect((await post("actions", "task_execution", action)).status).toBe(409);
+    expect((await post("actions", "task_collaboration", action)).status).toBe(409);
+    expect((await post("actions", "unknown", action)).status).toBe(403);
+  } finally {
+    removeRuntimeSessionContext("task_execution"); removeRuntimeSessionContext("task_collaboration");
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+});

tests/runtime/hostQuestion.test.ts

@@ -33,11 +33,11 @@ test("native question lookup distinguishes missing form from unavailable service
   const adapter = Object.assign(Object.create(OpencodeRuntimeAdapter.prototype), {
     ensureClient: async () => ({ session: { form: { get: async () => { if (failure) throw failure; return { state: { status: "answered" } }; } } } }),
   }) as OpencodeRuntimeAdapter;
-  expect(await adapter.getQuestionStatus({ sessionId: "s", requestId: "form" })).toBe("missing");
+  expect(await adapter.getQuestion({ sessionId: "s", requestId: "form" })).toBeNull();
   failure = new Error("network unavailable");
-  await expect(adapter.getQuestionStatus({ sessionId: "s", requestId: "form" })).rejects.toThrow("network unavailable");
+  await expect(adapter.getQuestion({ sessionId: "s", requestId: "form" })).rejects.toThrow("network unavailable");
   failure = undefined;
-  expect(await adapter.getQuestionStatus({ sessionId: "s", requestId: "form" })).toBe("answered");
+  expect(await adapter.getQuestion({ sessionId: "s", requestId: "form" })).toMatchObject({ state: { status: "answered" } });
 });
 test("message admission lookup fails closed on inbox and message transport errors", async () => {
   let inboxFailure = true;

tests/runtime/opencode.test.ts

@@ -313,9 +313,9 @@ describe("OpencodeRuntimeAdapter.warmup", () => {
     } finally { await cleanup(); }
   });
   it("rejects an invalid non-default model before readiness and cleans up the session", async () => {
-    const { runtime, calls, cleanup } = await createWarmupRuntime([], "waternetwork/gpt-5.6-sol");
+    const { runtime, calls, cleanup } = await createWarmupRuntime([], "waternetwork/gpt-6.1-sol");
     try {
-      await expect(runtime.warmup()).rejects.toThrow("waternetwork/gpt-5.6-sol: not_advertised");
+      await expect(runtime.warmup()).rejects.toThrow("waternetwork/gpt-6.1-sol: not_advertised");
       expect(calls).not.toContain("model.list");
       expect(calls.at(-1)).toBe("session.remove");
     } finally { await cleanup(); }

tests/runtime/task-agent-policy.test.ts

@@ -84,6 +84,22 @@ it("keeps burst event handling separate from SCADA candidate location", () => {
   expect(allowedQueryTools({ ...context, taskId: undefined, purpose: "ordinary_chat" })).toContain(queryMcpToolId("run_burst_location"));
 });
 
+it("continues candidate analysis through the declared capability and records provenance without stopping", () => {
+  const config = serviceOpencodeConfig({});
+  for (const system of [config.agents.instruction.system, config.agents[TASK_AGENT].system]) {
+    expect(system).toContain("location_capability.available=true");
+    expect(system).toContain("burst_leakage_required=false 时可省略漏量");
+    expect(system).toContain("取得候选管段与相似度后，继续地图展示、隔离边界、覆盖与影响分析，并汇入报告。");
+    expect(system).toContain("直接返回结果时立即读取");
+    expect(system).not.toMatch(/location_demo|真实定位|演示定位|轻量分析或 demo/);
+  }
+  const investigation = config.agents[TASK_AGENT].system;
+  expect(investigation).toContain("synthetic、回放等来源标记本身不构成停止条件");
+  expect(investigation).toContain("仅暂停依赖该条件的分支");
+  expect(investigation).toContain("本轮分析完成与现场处置完成分别表述");
+  expect(investigation).toContain("不直接派发现场工单或操作设备");
+});
+
 
 it("keeps administrator denials for product MCP queries in both primary and reader permissions", () => {
   const denied = serviceOpencodeConfig({ permissions: [{ action: "mcp_tjwater_*", resource: "*", effect: "deny" }] });

tests/sessions/answerViewState.test.ts

@@ -26,7 +26,7 @@ describe("answer view state", () => {
   beforeEach(async () => {
     base = await mkdtemp(join(tmpdir(), "answer-state-"));
     workspaces = new SessionWorkspaceStore(join(base, "workspaces"));
-    messages = new SessionUiStateStore(join(base, "unused"), workspaces);
+    messages = new SessionUiStateStore(workspaces);
     states = new AnswerViewStateStore(workspaces);
     currentSpec = spec();
     await saveMessages();

tests/sessions/learningLifecycle.test.ts

@@ -44,7 +44,7 @@ describe("learning session lifecycle", () => {
   });
   const orchestrator = (runtime: object) => new LearningOrchestrator(
     runtime as OpencodeRuntimeAdapter, new MemoryStore(join(base, "memory"), join(base, "memory-backup")),
-    new SessionTranscriptStore(join(base, "legacy-transcripts"), records), state,
+    new SessionTranscriptStore(records), state,
   );
 
   it("releases both native helper sessions after a completed review and persists progress in chat", async () => {

tests/sessions/transcriptStore.test.ts

@@ -3,6 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { SessionWorkspaceStore } from "../../src/sessions/workspace-store.js";
 import { SessionTranscriptStore } from "../../src/sessions/transcriptStore.js";
 
 describe("SessionTranscriptStore", () => {
@@ -11,8 +12,7 @@ describe("SessionTranscriptStore", () => {
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), "tjwater-transcript-"));
-    store = new SessionTranscriptStore(tempDir);
-    await store.initialize();
+    store = new SessionTranscriptStore(new SessionWorkspaceStore(tempDir));
   });
 
   afterEach(async () => {

tests/sessions/uiStateStore.test.ts

@@ -2,18 +2,18 @@ import { expect, it } from "bun:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { SessionWorkspaceStore } from "../../src/sessions/workspace-store.js";
 import { SessionUiStateStore } from "../../src/sessions/uiStateStore.js";
 
 it("restores plan history independently of chat messages after reconnecting", async () => {
   const directory = await mkdtemp(join(tmpdir(), "tjwater-plan-state-"));
   try {
-    const store = new SessionUiStateStore(directory);
-    await store.initialize();
+    const store = new SessionUiStateStore(new SessionWorkspaceStore(directory));
     const executionPlans = [{ revision: 1, nodes: [{ id: "sampling", status: "waiting" }] }];
-    await store.write({ sessionId: "session-1" }, { sessionId: "session-1", messages: [], executionPlans });
-    const reloaded = await new SessionUiStateStore(directory).read({ sessionId: "session-1" });
+    await store.write({ sessionId: "session-1", actorKey: "actor-test", projectKey: "project-test" }, { sessionId: "session-1", messages: [], executionPlans });
+    const reloaded = await new SessionUiStateStore(new SessionWorkspaceStore(directory)).read({ sessionId: "session-1", actorKey: "actor-test", projectKey: "project-test" });
     expect(reloaded?.executionPlans).toEqual(executionPlans);
-    expect(await store.read({ sessionId: "other-session" })).toBeNull();
+    expect(await store.read({ sessionId: "other-session", actorKey: "actor-test", projectKey: "project-test" })).toBeNull();
   } finally {
     await rm(directory, { recursive: true, force: true });
   }

tests/sessions/workspaceStore.test.ts

@@ -20,11 +20,11 @@ describe("owned session workspaces", () => {
   afterEach(async () => { await rm(base, { recursive: true, force: true }); });
 
   it("keeps messages and searchable transcripts private to their user and scope", async () => {
-    const ui = new SessionUiStateStore(join(base, "old-ui"), records);
-    const transcript = new SessionTranscriptStore(join(base, "old-transcripts"), records);
+    const ui = new SessionUiStateStore(records);
+    const transcript = new SessionTranscriptStore(records);
     await ui.write(owner, { sessionId: owner.sessionId, messages: [{ text: "private answer" }] });
     await transcript.appendTurn(owner, { userMessage: "private question", assistantMessage: "private answer", toolCallCount: 0 });
-    expect((await new SessionUiStateStore(join(base, "old-ui"), records).read(owner))?.messages).toHaveLength(1);
+    expect((await new SessionUiStateStore(records).read(owner))?.messages).toHaveLength(1);
     expect(await ui.read({ ...owner, actorKey: "actor-b" })).toBeNull();
     expect(await ui.read({ ...owner, projectKey: "project-b" })).toBeNull();
     expect(await transcript.search(owner, "private")).toHaveLength(2);
@@ -36,7 +36,7 @@ describe("owned session workspaces", () => {
   });
 
   it("has a separate personal namespace for each user and separates it from projects", async () => {
-    const ui = new SessionUiStateStore(join(base, "old-ui"), records);
+    const ui = new SessionUiStateStore(records);
     const personal = { ...owner, projectKey: "personal-actor-a" };
     await ui.write(personal, { sessionId: owner.sessionId, messages: [{ text: "personal answer" }] });
     expect(records.path(personal, "messages.json")).toContain("/actor-a/personal/");
@@ -60,13 +60,13 @@ describe("owned session workspaces", () => {
     expect(await records.migrateLegacyRecords(options)).toEqual({ uiStates: 1, transcripts: 1, learningStates: 0, retainedUnownedUiStates: 1 });
     expect(await readFile(records.path(owner, "messages.json"), "utf8")).toBe(messages);
     expect(await readFile(records.path(owner, "transcript.json"), "utf8")).toBe(turns);
-    await new SessionUiStateStore(uiStateDir, records).write(owner, { sessionId: owner.sessionId, messages: [{ text: "new answer" }] });
+    await new SessionUiStateStore(records).write(owner, { sessionId: owner.sessionId, messages: [{ text: "new answer" }] });
     expect((await records.migrateLegacyRecords(options)).uiStates).toBe(0);
     const archive = join(sessionWorkspaceDirectory(records.backupRoot, owner), "chat");
     const backup = (await readdir(archive)).find((name) => name.startsWith("messages-"))!;
     expect(await readFile(join(archive, backup), "utf8")).toBe(messages);
     expect(await readdir(uiStateDir)).toEqual(["orphan.json"]);
-    expect((await new SessionUiStateStore(uiStateDir, records).read(owner))?.messages).toEqual([{ text: "new answer" }]);
+    expect((await new SessionUiStateStore(records).read(owner))?.messages).toEqual([{ text: "new answer" }]);
   });
 
   it("rejects traversal, linked records and mismatched ownership", async () => {
@@ -75,7 +75,7 @@ describe("owned session workspaces", () => {
     const foreign = join(base, "foreign.json");
     await writeFile(foreign, "private");
     await symlink(foreign, records.path(owner, "messages.json"));
-    await expect(new SessionUiStateStore(join(base, "old-ui"), records).read(owner)).rejects.toThrow("symbolic link");
+    await expect(new SessionUiStateStore(records).read(owner)).rejects.toThrow("symbolic link");
     await writeFile(join(sessionWorkspaceDirectory(records.root, owner), "chat", "owner.json"), JSON.stringify({ ...owner, actorKey: "actor-b" }));
     await expect(records.ensure(owner)).rejects.toThrow("ownership mismatch");
   });
@@ -114,8 +114,8 @@ describe("owned session workspaces", () => {
     for (const path of [metadataDir, uiStateDir, transcriptDir, learningStateDir]) await mkdir(path);
     const metadata = new SessionMetadataStore(metadataDir, records);
     const { record } = await metadata.ensure(owner);
-    const ui = new SessionUiStateStore(uiStateDir, records);
-    const transcript = new SessionTranscriptStore(transcriptDir, records);
+    const ui = new SessionUiStateStore(records);
+    const transcript = new SessionTranscriptStore(records);
     const learning = new SessionLearningStateStore(learningStateDir, records);
     const legacyUi = JSON.stringify({ sessionId: owner.sessionId, messages: [{ text: "private content" }] });
     await writeFile(join(uiStateDir, "chat.json"), legacyUi);
@@ -153,7 +153,7 @@ describe("owned session workspaces", () => {
     const metadataDir = join(base, "metadata");
     const metadata = new SessionMetadataStore(metadataDir, records);
     const { record } = await metadata.ensure(owner);
-    const transcript = new SessionTranscriptStore(join(base, "legacy"), records);
+    const transcript = new SessionTranscriptStore(records);
     await transcript.appendTurn(owner, { userMessage: "private question", assistantMessage: "private answer", toolCallCount: 0 });
     const markDeleted = records.markDeleted.bind(records);
     records.markDeleted = async () => { throw new Error("disk write interrupted"); };
@@ -163,7 +163,7 @@ describe("owned session workspaces", () => {
     await expect(records.writeRecord(owner, "messages.json", { sessionId: owner.sessionId, messages: [] })).rejects.toThrow("session not found");
     records = new SessionWorkspaceStore(records.root, records.backupRoot);
     const restarted = new SessionMetadataStore(metadataDir, records);
-    expect(await new SessionTranscriptStore(join(base, "legacy"), records).search(owner, "private")).toEqual([]);
+    expect(await new SessionTranscriptStore(records).search(owner, "private")).toEqual([]);
     await expect(restarted.ensure(owner)).rejects.toThrow("session not found");
     await markDeleted(owner);
     await restarted.remove(record);