@mortiseai/stem 0.0.27 → 0.0.28

package/README.md

@@ -2,11 +2,14 @@
 
 > **Stem** — MortiseAI 构建的 Self-Evolving AI Agent,基于 **MSCE**(MSC Engine)的自我进化智能体
 
-核心三种业务模式(详见[「业务模式」](#业务模式--agent----coding----fde)):
+四种启动模式(详见[「业务模式」](#业务模式)):
 
-- **Agent 模式** — 面向通用智能体形态,默认模式,当前唯一开放。启动:`stem` / `stem --agent`;核心能力:业务图谱记忆
-- **Coding 模式** — 面向编码工作流的形态(暂未开放)。启动:`stem --coding`;核心能力:业务图谱记忆,基于 MortiseAI Spec Code Engine 编码
-- **FDE 模式** — 面向企业交付场景的形态(暂未开放)。启动:`stem --fde`;核心能力:业务图谱记忆,私有图谱记忆,基于 MortiseAI Spec Code Engine 编码
+- **Agent 模式** — 面向通用智能体形态，默认模式。启动：`stem` / `stem --agent`；核心能力：业务图谱记忆
+- **Coding 模式** — 面向编码工作流。启动：`stem --coding`；核心能力：业务图谱记忆，基于 MortiseAI Spec Code Engine 编码
+- **FDE 模式** — 面向企业交付场景。启动：`stem --fde`；核心能力：业务图谱记忆、私有图谱记忆，基于 MortiseAI Spec Code Engine 编码
+- **EVO 模式** — 独立洞察 Session，固定简化 Welcome。启动或重连：`stem --evo`；显示 `Stem EVO.` 或 `Stem EVO. Code`
+
+**EVO 进化模式**：`/stem-evo on --stem` 生成自我进化方案，`/stem-evo on --stem code` 生成方案并执行源码进化；`/stem-evo on --biz <空间名>` 生成同名业务空间的方案，`/stem-evo on --biz --use <空间名>` 将方案转为可供场景应用的 Wiki/Case/Onto 资产。在来源 CLI 选择目标和策略，`stem --evo` 打开独立视图，窗口内用 `/evolve <新要求>` 更新当前方向并同步 `evo.directions.stem/biz`。方案写入 `.mstem/platform/evo/`，业务方案按空间隔离。详见 [EVO 运行说明](docs/evo-v2-runtime.md)。
 
 ---
 
@@ -22,6 +25,22 @@ stem
 ```
 macOS / Linux / Windows 均可,仅需 Node >= 22,无需 bun。
 
+通过 OSS 配置包初始化当前项目（将 `<密码>` 替换为发布方提供的 6～128 位字母或数字，去掉尖括号）：
+
+```text
+stem init --platform --<密码>
+stem init --p --<密码>          # 与 --platform 等效
+stem init --8ycwl8 --<密码>
+```
+
+`--platform` 是平台参数，可简写为 `--p`（例如 `/init --p --<密码>`）；其他作用域参数按租户码处理。下载版本与当前安装的 CLI 一致，分别备份并替换 `.mstem/platform/` 或 `.mstem/tenant/8ycwl8/`。客户端无需 `.env` 或 OSS 工具。密码按 MD5 → scrypt → AES-256-GCM 使用，命令行密码优先于环境密钥。密码可能留在终端历史和进程参数中；程序日志不记录密码。完整说明见 [初始化与升级](docs/stem-maintenance.md)。
+
+在交互界面中使用 `/init --platform --<密码>`（简写 `/init --p --<密码>`）安装平台配置，或 `/init --<租户号> --<密码>` 安装租户配置；安装成功后在仓库根目录生成基础 `STEM.md`，已有文件保留。安装和文件创建均在本地执行，不调用模型或上下文压缩。参数回显隐藏，安装成功后 CLI 自动重启并加载配置，保留当前会话，不触发模型续跑。无参数 `/init` 仅生成或完善项目指南 `STEM.md`；`/init --help` 查看两种用法。
+
+### 升级
+
+在交互界面执行 `/upgrade` 检查并升级 Stem。当前版本与最新版本相同或更高时不做变更。有新版时先升级 CLI，再询问是否更新当前平台和租户配置；选择更新后输入隐藏的配置密码。未发布的租户配置会在结果中列出并保留原配置，其余项目继续更新。完成后自动重启并恢复当前会话。详见 [初始化与升级](docs/stem-maintenance.md)。
+
 ### 退出
 在 Welcome 屏按 **q** · **Esc** · 或 **Ctrl+C**。
 
@@ -124,6 +143,7 @@ stem --telemetry-url ws://127.0.0.1:8123/ws/manual
 - **要改持久默认模型,就改 `llms.json` 的 `default`** —— 没有别的持久化入口
 - `/model current` 可查看当前模型与来源
 - `/fast [on|off]` 默认关闭，仅当前选中模型在 `llms.json` 声明有效 `fast_service_tier` 时可用；不带参数时切换。该字段只声明能力，不会自动开启 fast
+- `/effort` 和 `/fast` 只修改当前会话，并更新未来新建会话的默认值；其他已有会话保留自己的设置。`/resume`、`--resume` 和崩溃恢复读取该会话保存的值，`/clear`、`/branch` 新建会话时使用最新默认值。旧版本未保存独立偏好的会话在首次恢复时按当时默认值初始化。
 - 能力配置按模型级 > 平台级解析：模型未配置则继承平台，模型显式 `false` 禁用。未声明能力时，包括 OpenAI 官方端点，均不默认申请 `priority`；手动输入 `/fast` 会提示不可用且不修改开关
 - OpenAI 协议请求在 fast 生效后发送配置的 `service_tier`。如果配置了 `roles.fast`，只有选中模型和目标模型均声明能力时才切换；目标无能力时保持当前模型。`/fast off` 同时撤销服务档位和模型切换
 - Footer 仅在有能力时显示 `快速模式 : 关闭` / `快速模式 : 开启`；无能力时整个片段及分隔符隐藏，补全和 `/help` 也隐藏 `/fast`。额度与 fast 均不显示时，整行隐藏
@@ -150,6 +170,8 @@ stem --telemetry-url ws://127.0.0.1:8123/ws/manual
 | `reasoning_effort_levels` | 否 | 该模型支持的推理强度数组，可用值:`none` / `minimal` / `low` / `medium` / `high` / `xhigh` / `max` / `ultra`。`/effort` 只接受当前模型列出的档位；不写则保持原方案 `low` / `medium` / `high` / `max` |
 | `reasoning_effort` | 否 | 推理策略：`auto` 按任务和执行反馈自动分配；具体档位表示固定默认值；`provider` 关闭应用层分配、完全跟随供应商。**不写等同 `auto`** |
 
+Advisor 顾问复核统一默认使用 `max / 120秒`，普通和复杂复核仅在证据包容量上区分，可通过运行项目的 `advisor.effort`、`advisor.timeoutMs` 覆盖。可选复核失败保留主任务验证状态，必需复核失败标记未完成。详见 [Advisor 复核策略](docs/advisor-review.md)。
+
 > `auto` 是 Stem 策略状态，不会原样发给 API。主会话会把它解析成具体档位：严格的上一轮增量调整使用低档，普通任务使用中档，规划/跨模块复杂任务使用高档；工具失败或连续空搜索会升档，修改校验通过后的收尾会降档。用户显式 `/effort <档位>` 始终优先，`/effort auto` 清除会话覆写并恢复模型策略。
 >
 > 协议投递按能力降级：OpenAI 模型显式配置 `reasoning_effort` 或 `reasoning_effort_levels` 时发送具体原生档位；Anthropic/兼容网关已配置 `thinking` 时按档位调整开关和预算；能力未知时仅注入 system prompt，不盲发未知字段。即使完全未配置而默认进入 auto，也不会因此让兼容网关收到不支持的参数。
@@ -508,22 +530,29 @@ Chrome 回归测试默认关闭。要让当前工程每次启动 Stem 后都允
 >
 > 计费:前 2000 次调用免费,之后按次计。`/bailian tools` 只列工具不计费,是验证连通性最便宜的一步。
 
-### 业务模式 · `--agent` / `--coding` / `--fde`
+### 业务模式
 
-Stem 的三种核心业务模式:
+Stem 的四种启动模式：
 
 | 模式 | 启动命令 | 状态 | 说明 | 核心能力 |
 |---|---|---|---|---|
 | Agent | `stem` / `stem --agent` | ✅ 开放(默认) | 面向通用智能体形态 | 业务图谱记忆 |
-| Coding | `stem --coding` | ⬜ 暂未开放 | 面向编码工作流的形态 | 业务图谱记忆 · 基于 MortiseAI Spec Code Engine 编码 |
-| FDE | `stem --fde` | ⬜ 暂未开放 | 面向企业交付场景的形态 | 业务图谱记忆 · 私有图谱记忆 · 基于 MortiseAI Spec Code Engine 编码 |
+| Coding | `stem --coding` | ✅ 开放 | 面向编码工作流的形态 | 业务图谱记忆 · 基于 MortiseAI Spec Code Engine 编码 |
+| FDE | `stem --fde` | ✅ 开放 | 面向企业交付场景的形态 | 业务图谱记忆 · 私有图谱记忆 · 基于 MortiseAI Spec Code Engine 编码 |
+| EVO | `stem --evo` / `stem evo attach` | ✅ 开放 | 持续显示来源 Session 的进化任务 | Plan 方案；Code 源码；Use 业务资产应用 |
 
-三选一布尔开关,缺省回退 env `STEM_DEF_MODE`,默认 `agent`。显式请求 `--coding` / `--fde` 会拒绝启动并提示(不做静默回退)。
+缺省读取 env `STEM_DEF_MODE`，默认 `agent`。`--evo` 与其他启动模式互斥。EVO 是独立进化视图；来源 Session 使用 `/stem-evo on --stem [code]` 或 `/stem-evo on --biz [--use] <空间名>` 选择目标与策略。
 
 ### 会话 · `--resume`
 
 `--resume <id>` / `-r <id>` / `--resume=<id>`:恢复指定会话(退出提示里有 `--resume <id>` 可直接复制),复用原会话日志文件续写。
 
+底部耗时按会话累计各轮执行时间，手动恢复和 OOM 自动重启均接续原值；退出期间和轮次之间的空闲时间不计入。执行中每秒保存计时快照，轮次结束、切换会话及正常退出时立即保存；强制终止时恢复最近一次快照。旧会话首次恢复会从已有日志补回已记录的轮次耗时。`/clear` 新建会话从零计时，`/branch` 继承分叉时的累计值。
+
+恢复采用严格模式：历史不存在、为空、损坏或读取失败时停止启动并记录原因，不会降级为新会话。内存保护和异常崩溃的自动重启必须取得有效会话通告；会话历史或续接队列保存失败时停止自动重启，保留原会话供排查。
+
+内存告警在下一次模型请求或任务完成时执行回收，无需手动输入“继续”触发。回收后余量仍不足时自动重启：中断中的任务继续执行，已完成任务只恢复会话，不再注入续跑指令；原有待执行队列保持顺序。最终回复与会话记录在退出前保存。
+
 ### 多租户隔离 · `--tenant`
 
 `--tenant <code>`(或 `--tenant=<code>`)以租户模式启动:**全部落盘状态**按租户
@@ -609,7 +638,9 @@ Stem 的三种核心业务模式:
 - 依赖模型能力位:`llms.json` 模型条目的 `vision` 字段。`vision: false` 的模型粘贴时直接拦截提示;粘贴后切到不支持的模型,发送前自动剥离图片并提示「已省略 N 张图片」。
 - 剪贴板读取优先用 `pngpaste`(brew 可选安装,更快),否则走系统 `osascript` — 首次调用可能弹 macOS 自动化权限框,拒绝后图片粘贴不可用(等同剪贴板无图)。
 - 超限图片(>5MB 或长边 >8000px)自动用系统 `sips` 缩放到长边 1568px。
-- 已知限制:`--resume` 恢复的历史会话中图片不回灌,模型只见 `[Image #N]` 字面。
+- 图片在进入模型前保存到当前会话存储目录的 `<sessionId>/images/`，按 `1.png、2.jpg、3.webp…` 累计编号；重启后继续编号，相同内容复用缓存。用户附件与工具返回的图片都走这条路径。
+- 内存回收只卸载图片载荷，保留可读取的文件引用；`--resume` 后会提供图片索引，模型需要时通过 `Read` 指定缓存文件恢复看图能力，不会一次性把全部图片重新载入内存。`images/index.jsonl` 保存编号、来源和文件信息；升级前未缓存的历史图片仍需重新提供。
+- 图片索引元数据按会话与文件版本缓存，新增图片或索引变化时刷新；注入模型的最近图片目录限制为 4000 字符，较早图片仍可通过完整索引查找。
 
 ### 运行中继续输入：排队与直接插入
 
@@ -684,7 +715,12 @@ CLI 子进程的运行时开关统一放 settings 级联的 **`env` 段**(不再
 | `STEM_DEBUG` | `1` = 渲染 tool-use/tool-result 调试卡片 + Debug banner |
 | `STEM_ACTIVITY_MODE` | 任务过程密度:`normal`(默认,紧凑语义步骤、错误/小 diff/验证结果智能展开)\|`quiet`(只显示状态 spinner)\|`detailed`(同时预览全部工具结果);也可运行时使用 `/statusline activity quiet\|normal\|detailed`,`STEM_DEBUG=1` 仍使用原始调试卡 |
 | `STEM_API_RETRY_INTERVAL_MS` | LLM 网络错误重试间隔(默认 60000,最多 10 次) |
-| `STEM_API_TIMEOUT_MS` | LLM 请求全局超时(平台未配 `timeoutMs` 时生效,默认 600000) |
+| `STEM_API_TIMEOUT_MS` | JSON 请求总时限及 SSE 首次有效输出时限(平台未配 `timeoutMs` 时生效,默认 180000)；SSE 开始输出后由空闲时限和独立总时限管理 |
+| `STEM_API_HEADERS_TIMEOUT_MS` | 等待 HTTP 响应头的时限(默认 180000，且不超过请求时限) |
+| `STEM_API_FIRST_EVENT_TIMEOUT_MS` | 等待首个 SSE 数据事件的时限(默认 180000)；SSE 心跳不续期，首次有效输出仍受请求时限约束 |
+| `STREAM_IDLE_TIMEOUT_MS` | SSE 有效输出之间的空闲时限(默认 180000，且不超过请求时限)；正文、思考、工具参数增量续期，空帧及 SSE 心跳不续期 |
+| `STEM_API_RECOVERY_WINDOW_MS` | 首次可恢复失败后共享的重试恢复窗口(默认 180000)；退避和后续尝试共同消耗此窗口，设为 0 禁用扩展恢复 |
+| `STEM_API_STREAM_MAX_DURATION_MS` | 单次 SSE 请求的独立总时限(默认 1800000，即 30 分钟)，有效输出也不能延长 |
 | `STEM_AUTO_COMPACT_TIMEOUT_MS` | 自动压缩摘要的独立硬截止(默认 60000);到时中止辅助摘要并继续主任务,不继承 LLM 的全局 10 分钟超时 |
 | `STEM_ADAPTIVE_TASK_CONTRACT_MODE` | 复杂/批量改动任务的自适应执行合同:`enforce`(默认,深度理解后硬门控并逐条绑定用户明确约束)、`observe`(同样规划但只审计不阻断)、`off`(关闭);未完成时回复独立的“继续/continue/resume”会恢复 scope、约束、步骤和原任务预算，版本化快照可随同一 workspace/session 的 `--resume` 恢复；磁盘恢复始终要求重新验收，若目标文件指纹漂移则退回深度理解并重提合同。合同验收命令失败时会在原回合提供有上限的自动修复机会并把推理升到 `xhigh`/`max`，成功重跑后自动清账，连续失败达到上限才允许收口为阻塞。运行中的 Bash 会对合同目标做前后指纹检查：发生修改即清除旧验收并要求干净重跑，后台启动的命令不会直接形成验收证据；验收还绑定 workspace 根目录、拒绝未写进 verifier 的隐藏 `cwd`/`env` 覆写，并只接受与 verifier 完整一致的 Bash 命令，需要子目录、环境变量或复合步骤时须原样写为 `cd path && ...` / `VAR=value ...`。Bash、PowerShell 与未声明只读的 MCP 工具还会经过有界 Git mutation manifest：既有脏文件在调用期间再次变化也可识别；发现合同范围外路径时不自动回滚或归因，而是冻结旧合同、升到 `max` 重新理解并要求带 `revisionReason` 重提合同。普通新请求会丢弃旧快照；旧开关 `STEM_ADAPTIVE_TASK_CONTRACT=0` 仍等价于 `off`。可运行 `bun run smoke:task-contract` 做无网络状态机检查 |
 | `STEM_PERMISSION_MODE` | 工具权限模式 `default\|allow\|plan\|bypassPermissions\|...` |
@@ -695,7 +731,7 @@ CLI 子进程的运行时开关统一放 settings 级联的 **`env` 段**(不再
 | `STEM_HUD_SHOW_USAGE` / `STEM_HUD_SHOW_WEEK` | HUD 用量行 / 本周行显示开关 |
 | `STEM_TELEMETRY` | `1` = 无头模式开启 telemetry 观测帧(`--sdk-telemetry` 的 env 形式) |
 | `STEM_TELEMETRY_WS` | telemetry WS tap 地址 |
-| `STEM_STORAGE_DIR` | 存储根(缺省 `<cwd>/mstem-storage`;优先于 settings `storage.dir`)。用户空间自动追加 `platform/<user>` 或 `tenant/<code>/<user>`；项目级独立作用域 `wiki/`、`plans/` 直接位于根下。Group 数据(session/causal/distill/evolve)落 STEM_DIR 项目配置根 |
+| `STEM_STORAGE_DIR` | 存储根(缺省 `<cwd>/mstem-storage`;优先于 settings `storage.dir`)。用户空间自动追加 `platform/<user>` 或 `tenant/<code>/<user>`；项目级独立作用域 `wiki/`、`plans/` 直接位于根下。session 自动追加 `platform/<user或common>/session` 或 `tenant/<code>/<user或common>/session`；Group 洞察数据(causal/distill/evolve)落 STEM_DIR 项目配置根 |
 | `STEM_DIR` | 项目配置根(缺省 `<cwd>/.mstem`;取值形态与作用域追加规则同 `STEM_STORAGE_DIR`) |
 | `STEM_TENANT` | **内部通道,勿手工设置** — 只由 `--tenant` flag 写入,env 段里的值会被入口忽略 |
 | `STEM_USER` | **内部通道,勿手工设置** — 只由 `--user` flag 写入,env 段里的值会被入口忽略 |
@@ -708,10 +744,14 @@ CLI 子进程的运行时开关统一放 settings 级联的 **`env` 段**(不再
 `STEM_STORAGE_DIR` / `STEM_DIR` 的取值支持两种形态:绝对路径、相对路径
 (相对当前工程路径 cwd 解析)——**不做 `~` home 展开**,`~/...` 不会被特殊
 处理,直接按相对路径拼接。会话聊天文件默认落
-`<cwd>/.mstem/platform/session/<sessionId>.jsonl`(`--user` 时落用户空间
+`<cwd>/mstem-storage/platform/common/session/<sessionId>.jsonl`(`--user` 时落用户空间
 `<cwd>/mstem-storage/platform/<user>/session/`);升级前写在
-`~/.mstem/projects/<项目>/` 或 `mstem-storage/<scope>/common/` 的历史会话
-经惰性迁移仍可被 `/resume` 找到并续写原文件。
+`.mstem/<scope>/session/` 或 `~/.mstem/projects/<项目>/` 的历史会话
+仍可被 `/resume` 找到并续写原文件；新会话统一写入存储根。
+
+关闭文件日志时，工具调用跳过输入和结果预览；开启时对预览的层级、条数及字符数设限，图片载荷不进入预览。内存日志包含 `heapTotalMB`，流式采样使用正在执行的会话；`contextTextChars`、`imageBase64Chars` 和 `estimatedImageBytes` 分别表示文本长度、图片编码长度和估算的解码大小，不等同于实际 RSS。回收日志记录这些指标的前后变化。
+
+目录级 `Grep content` 最多返回 24 条、约 4000 字符的匹配记录（含路径）；指定单个文件时保留 80 条、16000 字符预算。截断结果会提示按已找到的文件和行号收窄或批量读取。最终回复中的校验成功声明会检查本轮已修改文件的版本：后续修改、外部改动或失败的命令会使旧证据失效，需要重跑相关检查或明确披露未重新校验；这一检查也适用于未激活 TaskContract 的轮次。
 
 ---
 
@@ -801,12 +841,11 @@ agent 侧配套工具(MCP 同样暴露为 `tool_ontology_*`):`OntologySchema`(tr
 /stem-case derive [--apply]                       # 待建清单 → 本体提案草案 + 页面待办;--apply 让 agent 经 OntologyPropose / WikiReview 落成正式项
 /stem-case run [--judge] [--kind k]               # agent 逐题用 WikiSearch / OntologyGraph 作答 → CaseScore score(确定性打分 + 归因)→ 全部打完自动收尾
 /stem-case report [runId] [--finish]              # 套件分 / 按 kind 通过率 / 归因分布 / 逐题明细 / 与上次 run 对比 / 是否已过期(页面或本体变了)
-/stem-case evolve <目标分> <最大轮数>              # run → 修根因(补页 / 提案 / 改标注)→ 再 run,直到达标(prompt 驱动循环;不改用例凑分)
 ```
 
 三种起步顺序都支持:用例先行(init/import → derive → `/stem-onto init` + merge → `/stem-wiki import` → run)、知识先行(基于类树 + 访谈生成 → run)、交替演化(evolve)。`/stem-onto status` 与 system prompt 会显示最近分数与最弱 kind,引导 import / classify 优先补短板。agent 工具:`CaseScore`(list / get / add / score / status;MCP `tool_case_score`)。prompt 指令块可用 `.mstem/skills/case-<init|import|add|run|derive|evolve>/SKILL.md` 覆盖。
 
-**独立面板**:`run` / `evolve` 发起后,输入框上方出现黄金用例面板(`src/stem-ui/CasePanel.tsx`,数据源 `stem-utils/casePanelStore`):逐题 ✓/✗/spinner、每题分数条与归因、套件分、按 kind 汇总、evolve 的轮次轨迹(R1 → R2 …);Agent 每次调 `CaseScore score` 即时刷新;Ctrl+C / Esc 标记中断并冻结为快照;`/stem-case hide` 关闭。它与洞察模式(`/stem-causal` / `/stem-distill` / `/stem-evolve` 的 InsightPanel)**零耦合**——自有 store、自有组件、自有生命周期,不新增 InsightMode。
+**独立面板**：`/stem-case run` 发起后显示逐题进度、分数与归因、套件分和分类汇总；`CaseScore score` 即时刷新，Ctrl+C / Esc 中断并保留快照，`/stem-case hide` 关闭。
 
 ---
 
@@ -814,8 +853,8 @@ agent 侧配套工具(MCP 同样暴露为 `tool_ontology_*`):`OntologySchema`(tr
 
 两个配置根均落在目标项目目录下,可用 env `STEM_DIR` / `STEM_STORAGE_DIR` 重定向(见「运行时开关」):
 
-- **`.mstem/`** — 项目配置根:配置文件 + Group 数据(session/causal/distill/evolve 等)
-- **`mstem-storage/`** — 存储根:承载 `--user` 用户隔离数据，以及独立作用域的 wiki/plan 项目产物；不放配置文件
+- **`.mstem/`** — 项目配置根:配置文件 + Group 洞察数据(causal/distill/evolve 等)
+- **`mstem-storage/`** — 存储根:承载所有作用域的 session、`--user` 用户隔离数据，以及独立作用域的 wiki/plan 项目产物；不放配置文件
 
 ```
 .mstem/                            # 项目配置根(STEM_DIR)
@@ -824,7 +863,7 @@ agent 侧配套工具(MCP 同样暴露为 `tool_ontology_*`):`OntologySchema`(tr
 │   ├── settings.local.json        #   个人项目级配置(应 gitignore;env 段放运行时开关)
 │   ├── llms.json                  #   多平台 LLM 目录(见「模型目录」节)
 │   ├── mcp.json                   #   MCP server 配置
-│   └── agents/ causal/ distill/ evolve/ memory/ plugins/ session/ skills/ workflows/
+│   └── agents/ causal/ distill/ evolve/ memory/ plugins/ skills/ workflows/
 └── tenant/<租户代码>/             # tenant 作用域:结构同 platform,首启自动建目录
     └── …                          #   但配置文件不播种,需手工放置
 
@@ -832,16 +871,16 @@ mstem-storage/                     # 存储根(STEM_STORAGE_DIR)
 ├── wiki/                          # 独立作用域的 Wiki（不插 platform/tenant/user）
 ├── plans/                         # plan file，与 wiki 同级
 ├── platform/
-│   ├── common/                    # 未指定 --user 时的公共用户空间
+│   ├── common/                    # 未指定 --user 时的公共用户空间，session/ 位于其下
 │   └── <用户ID>/                  # stem --user <用户ID> 的用户空间
-│       └── agents/ causal/ … workflows/(九个子目录同上)
+│       └── agents/ causal/ … workflows/ session/(含用户会话目录)
 └── tenant/<租户代码>/
-    ├── common/                    # 租户内公共用户空间
+    ├── common/                    # 租户内公共用户空间，session/ 位于其下
     └── <用户ID>/                  # stem --tenant <code> --user <id> 的用户空间
 ```
 
 - 四个作用域(platform / platform+user / tenant / tenant+user)两两绝对隔离,详见「多租户隔离」「用户隔离」两节
-- 会话聊天文件默认落 `.mstem/platform/session/<sessionId>.jsonl`;`--user` 时落 `mstem-storage/platform/<用户ID>/session/`
+- 会话聊天文件默认落 `mstem-storage/platform/common/session/<sessionId>.jsonl`;`--user` 时落 `mstem-storage/platform/<用户ID>/session/`
 - settings 级联：会话覆盖 > 当前 `.mstem/<scope>/settings.local.json` > `settings.json`；不读取家目录配置。
 - 新增设置写当前项目 `settings.local.json`，已有设置写回所属项目层；取消设置会清除项目两层中的该项。
 - 骨架补齐与配置播种统一走 `./update_pro.sh`(幂等,绝不覆盖已有文件,见「空间初始化」节)

package/bin/stem-env-lib.mjs

@@ -0,0 +1,20 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { parseEnv } from 'node:util'
+
+/** Load .env without executing shell code; shell values and earlier directories take precedence. */
+export function loadStemEnv(directories, env = process.env) {
+    if (env.STEM_SKIP_DOTENV === '1') return env
+    for (const directory of directories) {
+        const path = join(directory, '.env')
+        if (!existsSync(path)) continue
+        let values
+        try { values = parseEnv(readFileSync(path, 'utf8')) } catch {
+            throw new Error(`无法读取环境配置文件: ${path}`)
+        }
+        for (const [key, value] of Object.entries(values)) {
+            if (env[key] === undefined) env[key] = value
+        }
+    }
+    return env
+}

package/bin/stem-launcher-lib.mjs

@@ -52,6 +52,9 @@ export function shouldSupervise(argv, options = {}) {
   if (env[SUPERVISOR_OFF_ENV] === '1') return false
   if (env.STEM_SUPERVISED === '1') return false
   if (!stdoutIsTTY || !stdinIsTTY) return false
+  // EVO views reconnect to a durable coordinator and have no source conversation for supervisor recovery.
+  if (argv.includes('--evo') || argv[0] === 'evo'
+    || (env.STEM_DEF_MODE?.toLowerCase() === 'evo' && !argv.some(arg => ['--agent', '--coding', '--fde'].includes(arg)))) return false
   const nonInteractive = new Set(['--help', '-h', '--version', '-v', '--print'])
   return !argv.some(a => nonInteractive.has(a) || a === '--sdk-url' || a.startsWith('--sdk-url='))
 }

package/bin/stem-maintenance-launcher.mjs

@@ -0,0 +1,40 @@
+import { copyFileSync, existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { spawnSync } from 'node:child_process'
+import { loadStemEnv } from './stem-env-lib.mjs'
+
+export function isMaintenanceCommand(args) {
+    return ['init', 'upgrade', 'update', '--upgrade', '--update'].includes(args[0])
+}
+
+export function launchMaintenance(rootDir, args) {
+    const callerDir = process.env.CALLER_DIR || process.cwd()
+    const scratchRoot = tmpdir()
+    let scratch
+    try {
+        const help = isMaintenanceCommand(args) && args.length === 2 && ['--help', '-h'].includes(args[1])
+        const env = help ? { ...process.env } : loadStemEnv([callerDir, rootDir], { ...process.env })
+        const entry = join(rootDir, 'dist', 'maintenance.mjs')
+        if (!existsSync(entry)) throw new Error('缺少维护命令产物，请在源码仓库运行 bun run build:maintenance，或重新安装 CLI。')
+        scratch = mkdtempSync(join(scratchRoot, 'stem-maintenance-'))
+        const copied = join(scratch, 'maintenance.mjs')
+        copyFileSync(entry, copied)
+        const version = JSON.parse(readFileSync(join(rootDir, 'package.json'), 'utf8')).version
+        const result = spawnSync(process.execPath, [copied], {
+            cwd: scratch,
+            input: JSON.stringify({ args, cwd: callerDir, version }),
+            env,
+            stdio: ['pipe', 'inherit', 'inherit'], windowsHide: true,
+        })
+        if (result.error) console.error(`stem: 无法启动维护命令: ${result.error.message}`)
+        return result.status ?? 1
+    } catch (error) {
+        console.error(`stem: ${error instanceof Error ? error.message : String(error)}`)
+        return 1
+    } finally {
+        if (scratch && dirname(scratch) === scratchRoot && basename(scratch).startsWith('stem-maintenance-')) {
+            try { rmSync(scratch, { recursive: true, force: true }) } catch { /* OS may still hold a handle */ }
+        }
+    }
+}

package/bin/stem-supervisor-lib.mjs

@@ -2,21 +2,31 @@
 // 独立成库的唯一理由:入口脚本 import 即执行,smoke 无法直接测;这里的函数
 // 全部纯逻辑/可注入,scripts/smoke-supervisor.ts 逐项锁语义。
 import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path'
 import { homedir } from 'node:os'
 import { spawn, spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
 
 // 配置类错误的专用退出码(stem-entry-cli 侧同值):见 78 不重启。
 export const EXIT_CODE_CONFIG = 78
 // Child completed an in-process memory cleanup, persisted resumable state, and asks the
 // supervisor to replace the allocator/process without classifying the event as a crash.
 export const EXIT_CODE_MEMORY_RESTART = 75
+export const EXIT_CODE_CONFIGURATION_RESTART = 76
 export const CRASH_WINDOW_MS = 60_000
 export const CRASH_GIVE_UP_COUNT = 3
 export const RESTART_BACKOFF_MAX_MS = 10_000
 
 const pad2 = n => String(n).padStart(2, '0')
 
+function readSessionAnnouncement(file) {
+  try {
+    const value = JSON.parse(readFileSync(file, 'utf8'))
+    return value?.v === 1 && typeof value.sessionId === 'string' &&
+      /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(value.sessionId) ? value : null
+  } catch { return null }
+}
+
 /** 与子进程默认日志布局一致：日期分桶，桶内按本地时分秒 + sessionId 排序。 */
 export function buildSessionLogDir(cwd, sessionId, startedAt = new Date()) {
   const d = startedAt instanceof Date ? startedAt : new Date(startedAt)
@@ -42,10 +52,16 @@ export function stripResumeFlag(argv) {
     const a = argv[i]
     if (a === '--resume' || a === '-r') {
       const next = argv[i + 1]
-      if (next !== undefined && !next.startsWith('-')) { resumeId = next; i++ }
+      if (next !== undefined && !next.startsWith('-') && next.trim()) { resumeId = next; i++ }
+      else out.push(a) // Let the child reject a bare --resume; never start a fresh conversation.
+      continue
+    }
+    if (a.startsWith('--resume=')) {
+      const id = a.slice('--resume='.length)
+      if (id.trim()) resumeId = id
+      else out.push(a)
       continue
     }
-    if (a.startsWith('--resume=')) { resumeId = a.slice('--resume='.length); continue }
     out.push(a)
   }
   return { baseArgs: out, resumeId }
@@ -92,8 +108,8 @@ export function restartPrompt(isZh, crashInfo) {
 
 export function memoryRestartPrompt(isZh) {
   return isZh
-    ? '[系统] 内存保护已完成清理并受控重启。本会话对话、todo 与任务现场已从磁盘恢复。请先核对当前 todo 和实际文件状态，然后从未完成项继续执行；不要重复已完成的工作，也不要只回复确认性文字。'
-    : '[system] Memory protection completed cleanup and a controlled restart. The conversation, todo, and task state were restored from disk. Verify the current todo and actual files, then continue from the unfinished work. Do not redo completed work or reply with an acknowledgement only.'
+    ? '[系统] 内存保护已完成清理并受控重启。本会话对话、todo 与任务现场已从磁盘恢复。图片载荷已卸载，需要再次看图时请根据会话图片索引使用 Read 读取缓存文件。请先核对当前 todo 和实际文件状态，然后从未完成项继续执行；不要重复已完成的工作，也不要只回复确认性文字。'
+    : '[system] Memory protection completed cleanup and a controlled restart. The conversation, todo, and task state were restored from disk. Image payloads were unloaded; use the session image index and Read on a cached file when visual understanding is needed again. Verify the current todo and actual files, then continue from the unfinished work. Do not redo completed work or reply with an acknowledgement only.'
 }
 
 // 注入队列的去重前缀:文案带崩溃原因(逐次可变),不能再按全串相等去重。
@@ -136,6 +152,54 @@ export function injectMemoryRestartPrompt(queuePath, isZh) {
   return injectResumePrompt(queuePath, memoryRestartPrompt(isZh))
 }
 
+/** A completed task needs only a fresh process; preserve real queued prompts without adding work. */
+export function prepareIdleRestartQueue(queuePath) {
+  let parsed
+  try { parsed = JSON.parse(readFileSync(queuePath, 'utf8')) }
+  catch (error) { return error.code === 'ENOENT' }
+  if (!parsed || parsed.v !== 1 || !Array.isArray(parsed.queue) ||
+    parsed.queue.some(prompt => typeof prompt !== 'string')) return false
+  try {
+    writeFileSync(queuePath, JSON.stringify({ ...parsed, cleanExit: true }, null, 2) + '\n')
+    return true
+  } catch { return false }
+}
+
+export const prepareCompletedMemoryRestartQueue = prepareIdleRestartQueue
+
+export function crashRestartResumesTask(announce, pid) {
+  const state = announce.requestState
+  if (state === undefined) return true // Compatibility with children predating request-state announcements.
+  if (!state || state.version !== 1 || !Number.isSafeInteger(state.pid) || state.pid <= 0 ||
+    state.pid !== pid || typeof state.active !== 'boolean') {
+    throw new Error('invalid request state announcement')
+  }
+  return state.active
+}
+
+export function memoryRestartResumesTask(announce, pid) {
+  const intent = announce.memoryRestart
+  if (intent === undefined) return true // Legacy children always requested active-task recovery.
+  if (!intent || intent.version !== 1 || !Number.isSafeInteger(intent.pid) || intent.pid <= 0 ||
+    intent.pid !== pid || typeof intent.resumeTask !== 'boolean') {
+    throw new Error('invalid memory restart announcement')
+  }
+  return intent.resumeTask
+}
+
+export function evoResumeHandoffFor(announce, pid, isZh) {
+  const h = announce.evoHandoff
+  if (h === undefined) return '' // Older sources still recover conservatively as interrupted turns.
+  if (!h || h.version !== 1 || h.sourceSessionId !== announce.sessionId || h.pid !== pid ||
+    !Number.isSafeInteger(h.pid) || h.pid <= 0 || typeof h.logicalTurnId !== 'string' ||
+    !h.logicalTurnId.length || h.logicalTurnId.length > 300 ||
+    typeof h.handoffId !== 'string' || !/^[a-f0-9-]{36}$/.test(h.handoffId) ||
+    typeof h.artifactHash !== 'string' || !/^[a-f0-9]{64}$/.test(h.artifactHash)) {
+    throw new Error('invalid evo source handoff announcement')
+  }
+  return JSON.stringify({ handoff: h, requestHash: createHash('sha256').update(memoryRestartPrompt(isZh)).digest('hex') })
+}
+
 /** 崩溃标记(2026-08-13 事故:崩溃现场零证据,连退出信号都没记)。
  *  落日期/时间会话目录的 crash.json(与该会话的 supervisor.log /
  *  debug 日志 / 堆快照同目录归档;此前散在 queue sidecar 目录难找易丢)。
@@ -422,9 +486,11 @@ export async function runSupervisor(distEntry, argv, options = {}) {
     },
     installSignalHandlers = true,
   } = options
-  const launchPrefixArgs = Array.isArray(childPrefixArgs)
+  let launchPrefixArgs = Array.isArray(childPrefixArgs)
     ? [...childPrefixArgs]
     : [...nodeFlags, distEntry]
+  let launchCommand = childCommand
+  let launchCwd = childCwd
   const supervisorStartedAt = new Date(now())
 
   // log() 只写终端;logLine() 同时 append 到 supervisor.log(ISO 时间戳)—
@@ -458,6 +524,11 @@ export async function runSupervisor(distEntry, argv, options = {}) {
   let activeSessionLogDir = null
   let crashTimes = []
   let memoryRestartTimes = []
+  let configurationRestartTimes = []
+  let expectedResumePath = ''
+  let automaticResume = false
+  let evoResumeHandoff = ''
+  let configurationReload = false
   let childAlive = false
   // 崩溃前子进程通告的实时 permission mode(Shift+Tab 切换会更新通告)—
   // 重启时经 --permission-mode 复原,argv 中的启动值被剥离让位。
@@ -475,11 +546,7 @@ export async function runSupervisor(distEntry, argv, options = {}) {
   let announcedSid = null
   let currentPid = null
   const checkAnnounceForLifecycle = () => {
-    let parsed = null
-    try {
-      const p = JSON.parse(readFileSync(announceFile, 'utf8'))
-      if (p && p.v === 1 && typeof p.sessionId === 'string') parsed = p
-    } catch { return }
+    const parsed = readSessionAnnouncement(announceFile)
     if (!parsed) return
     // logDir 由子进程计算，包含精确到秒的会话起点；旧版通告没有该字段时
     // 才由 supervisor 以自身启动时间构造兼容落点。
@@ -513,11 +580,22 @@ export async function runSupervisor(distEntry, argv, options = {}) {
     if (permissionModeFromAnnounce) args.push('--permission-mode', permissionModeFromAnnounce)
     if (modelFromAnnounce) args.push('--model', modelFromAnnounce)
     if (resumeId) args.push('--resume', resumeId)
+    // Each child must publish its own identity; a previous child's file is not evidence.
+    try { rmSync(announceFile, { force: true }) } catch {
+      logLine('stem: cannot clear stale session announcement; automatic launch stopped.')
+      return EXIT_CODE_CONFIG
+    }
     const child = spawnChild(args, {
       ...process.env,
       STEM_SUPERVISED: '1',
       STEM_SESSION_ANNOUNCE_FILE: announceFile,
-    }, { command: childCommand, cwd: childCwd })
+      STEM_RESUME_EXPECTED_ID: automaticResume ? resumeId : '',
+      STEM_RESUME_EXPECTED_PATH: automaticResume ? expectedResumePath : '',
+      STEM_EVO_RESUME_HANDOFF: evoResumeHandoff,
+      STEM_CONFIGURATION_RELOAD: configurationReload ? '1' : '',
+    }, { command: launchCommand, cwd: launchCwd })
+    evoResumeHandoff = '' // Only the immediately following controlled restart receives the capability.
+    configurationReload = false
     childAlive = true
     currentPid = child.pid ?? null
     const lifecycleTimer = setInterval(checkAnnounceForLifecycle, 2000)
@@ -532,29 +610,79 @@ export async function runSupervisor(distEntry, argv, options = {}) {
       logFileOnly(isZh ? 'stem: 会话正常退出(code=0)' : 'stem: session exited normally (code=0)')
       return 0
     }
+    if (signal === 'SIGINT' || signal === 'SIGTERM' || code === 130 || code === 143) {
+      logFileOnly(isZh ? 'stem: 用户结束会话，看护不重启。' : 'stem: session terminated; supervisor will not restart.')
+      return signal === 'SIGINT' ? 130 : signal === 'SIGTERM' ? 143 : code
+    }
     if (code === EXIT_CODE_CONFIG) {
       logLine(isZh
         ? 'stem: 配置错误退出(code 78),看护不重启 — 请修正配置后重新运行。'
         : 'stem: exited with a configuration error (code 78); supervisor will not restart. Fix the configuration and run again.')
       return EXIT_CODE_CONFIG
     }
+    if (code === EXIT_CODE_CONFIGURATION_RESTART) {
+      const t = now()
+      configurationRestartTimes = configurationRestartTimes.filter(x => t - x < CRASH_WINDOW_MS)
+      configurationRestartTimes.push(t)
+      resetTerminalFn()
+      const announce = readSessionAnnouncement(announceFile)
+      if (!announce || announce.requestState?.pid !== child.pid || announce.requestState?.active !== false ||
+          typeof announce.queuePath !== 'string' || !announce.queuePath ||
+          configurationRestartTimes.length >= CRASH_GIVE_UP_COUNT) {
+        logLine(isZh ? 'stem: 无法安全自动重启，请重新启动 CLI 加载配置。'
+          : 'stem: automatic restart is unavailable; restart the CLI to load configuration.')
+        return EXIT_CODE_CONFIGURATION_RESTART
+      }
+      if (!prepareIdleRestartQueue(announce.queuePath)) {
+        logLine(isZh ? 'stem: 会话队列保存失败，请重新启动 CLI 加载配置。'
+          : 'stem: session queue could not be saved; restart the CLI to load configuration.')
+        return EXIT_CODE_CONFIG
+      }
+      if (announce.upgrade) {
+        try {
+          const entry = announce.upgrade.entry
+          if (typeof entry !== 'string' || !isAbsolute(entry) || basename(entry) !== 'cli.mjs' || !existsSync(entry)) throw new Error('invalid entry')
+          const pkg = JSON.parse(readFileSync(join(dirname(entry), '..', 'package.json'), 'utf8'))
+          if (pkg.name !== '@mortiseai/stem' || pkg.version !== announce.upgrade.version) throw new Error('invalid version')
+          launchPrefixArgs = [...nodeFlags, entry]
+          launchCommand = process.execPath
+          launchCwd = cwd
+        } catch {
+          logLine(isZh ? 'stem: 无法确认新版 CLI 入口，请重新运行 stem。' : 'stem: cannot verify the upgraded CLI entry; run stem again.')
+          return EXIT_CODE_CONFIG
+        }
+      }
+      resumeId = announce.sessionId
+      automaticResume = true
+      expectedResumePath = (Array.isArray(announce.jsonlPaths) ? announce.jsonlPaths : [])
+        .find(p => typeof p === 'string' && existsSync(p)) ?? ''
+      // Load model and permission defaults from the new configuration.
+      baseArgs = stripPermissionModeFlag(stripModelFlag(baseArgs))
+      permissionModeFromAnnounce = null
+      modelFromAnnounce = null
+      evoResumeHandoff = ''
+      configurationReload = true
+      onCrashCleanupPid(child.pid)
+      logFileOnly('stem: configuration installed; restarting CLI.')
+      await sleep(250)
+      continue
+    }
     if (code === EXIT_CODE_MEMORY_RESTART) {
       const t = now()
       memoryRestartTimes = memoryRestartTimes.filter(x => t - x < CRASH_WINDOW_MS)
       memoryRestartTimes.push(t)
       resetTerminalFn()
-      let announce = null
-      try {
-        const parsed = JSON.parse(readFileSync(announceFile, 'utf8'))
-        if (parsed && parsed.v === 1 && typeof parsed.sessionId === 'string') announce = parsed
-      } catch { /* ignore */ }
-      if (!announce || typeof announce.queuePath !== 'string') {
+      const announce = readSessionAnnouncement(announceFile)
+      if (!announce || typeof announce.queuePath !== 'string' || !announce.queuePath) {
         logLine(isZh
           ? 'stem: 子进程请求内存恢复重启，但没有有效会话通告；为避免丢失上下文，已停止自动重启。'
           : 'stem: child requested a memory recovery restart without a valid session announcement; automatic restart stopped to avoid losing context.')
         return EXIT_CODE_MEMORY_RESTART
       }
       resumeId = announce.sessionId
+      automaticResume = true
+      expectedResumePath = (Array.isArray(announce.jsonlPaths) ? announce.jsonlPaths : [])
+        .find(p => typeof p === 'string' && existsSync(p)) ?? ''
       if (typeof announce.permissionMode === 'string' && announce.permissionMode) {
         permissionModeFromAnnounce = announce.permissionMode
       }
@@ -571,11 +699,29 @@ export async function runSupervisor(distEntry, argv, options = {}) {
           : `stem: memory recovery restart requested ${memoryRestartTimes.length} times within 60s; giving up on auto-restart.`)
         return EXIT_CODE_MEMORY_RESTART
       }
-      injectMemoryRestartPrompt(announce.queuePath, isZh)
+      let resumeTask
+      try {
+        resumeTask = memoryRestartResumesTask(announce, child.pid)
+        evoResumeHandoff = resumeTask ? evoResumeHandoffFor(announce, child.pid, isZh) : ''
+      }
+      catch (error) {
+        logLine(`stem: ${error.message}; automatic restart stopped.`)
+        return EXIT_CODE_CONFIG
+      }
+      const queuePrepared = resumeTask
+        ? injectMemoryRestartPrompt(announce.queuePath, isZh)
+        : prepareIdleRestartQueue(announce.queuePath)
+      if (!queuePrepared) {
+        logLine(isZh ? `stem: 会话 ${resumeId} 的续接队列写入失败，已停止自动重启。`
+          : `stem: failed to persist the recovery queue for session ${resumeId}; restart stopped.`)
+        return EXIT_CODE_CONFIG
+      }
       onCrashCleanupPid(child.pid)
-      logLine(isZh
-        ? `stem: 内存清理后仍处于硬水位，已保存会话 ${resumeId}，正在受控重启并自动续接…`
-        : `stem: memory remained above the hard limit after cleanup; session ${resumeId} was saved and will resume after a controlled restart…`)
+      logLine(resumeTask
+        ? (isZh ? `stem: 内存清理后余量不足，已保存会话 ${resumeId}，正在重启并续接任务…`
+          : `stem: memory headroom remains insufficient; session ${resumeId} was saved and will resume after restart…`)
+        : (isZh ? `stem: 任务已完成，正在优化内存并恢复会话 ${resumeId}…`
+          : `stem: task completed; optimizing memory and restoring session ${resumeId}…`))
       await sleep(250)
       continue
     }
@@ -587,13 +733,12 @@ export async function runSupervisor(distEntry, argv, options = {}) {
     crashTimes = crashTimes.filter(x => t - x < CRASH_WINDOW_MS)
     crashTimes.push(t)
     resetTerminalFn()
-    let announce = null
-    try {
-      const parsed = JSON.parse(readFileSync(announceFile, 'utf8'))
-      if (parsed && parsed.v === 1 && typeof parsed.sessionId === 'string') announce = parsed
-    } catch { /* ignore */ }
+    const announce = readSessionAnnouncement(announceFile)
     if (announce) {
       resumeId = announce.sessionId
+      automaticResume = true
+      expectedResumePath = (Array.isArray(announce.jsonlPaths) ? announce.jsonlPaths : [])
+        .find(p => typeof p === 'string' && existsSync(p)) ?? ''
       if (typeof announce.permissionMode === 'string' && announce.permissionMode) {
         permissionModeFromAnnounce = announce.permissionMode
       }
@@ -656,12 +801,35 @@ export async function runSupervisor(distEntry, argv, options = {}) {
 
     // 续跑注入只在还会重启时做:放弃场景注入了反而让下次手动 resume 自动跑
     // 一条"已重启"文案,与事实不符。
-    if (announce && typeof announce.queuePath === 'string') {
-      injectRestartPrompt(announce.queuePath, isZh, { code, signal })
+    if (!announce || typeof announce.queuePath !== 'string' || !announce.queuePath) {
+      logLine(isZh
+        ? `stem: 进程异常退出(code=${code ?? '-'}, signal=${signal ?? '-'}),没有有效会话通告；严格恢复已停止，不会新建会话。`
+        : `stem: process exited (code=${code ?? '-'}, signal=${signal ?? '-'}), but no valid session announcement exists; strict recovery stopped without creating a new conversation.`)
+      onCrashCleanupPid(child.pid)
+      return EXIT_CODE_CONFIG
+    }
+    let resumeTask
+    try { resumeTask = crashRestartResumesTask(announce, child.pid) }
+    catch (error) {
+      logLine(`stem: ${error.message}; automatic restart stopped.`)
+      onCrashCleanupPid(child.pid)
+      return EXIT_CODE_CONFIG
+    }
+    const queuePrepared = resumeTask
+      ? injectRestartPrompt(announce.queuePath, isZh, { code, signal })
+      : prepareIdleRestartQueue(announce.queuePath)
+    if (!queuePrepared) {
+      logLine(isZh ? `stem: 会话 ${resumeId} 的续接队列写入失败，已停止自动重启。`
+        : `stem: failed to persist the recovery queue for session ${resumeId}; restart stopped.`)
+      return EXIT_CODE_CONFIG
     }
 
     onCrashCleanupPid(child.pid)
 
+    logFileOnly(resumeTask
+      ? (isZh ? 'stem: 恢复在途任务，已注入一条续接指令。' : 'stem: recovering interrupted task with one continuation prompt.')
+      : (isZh ? 'stem: 当前无在途任务，仅恢复会话与既有队列。' : 'stem: no active task; restoring the session and existing queue.'))
+
     const delayMs = Math.min(1000 * 2 ** (crashTimes.length - 1), RESTART_BACKOFF_MAX_MS)
     logLine(isZh
       ? `stem: 进程异常退出(code=${code ?? '-'}, signal=${signal ?? '-'}),${Math.round(delayMs / 1000)}s 后自动恢复会话${resumeId ? ` ${resumeId}` : ''}…(STEM_SUPERVISOR_OFF=1 可关闭看护)`