@mortiseai/stem 0.0.16 → 0.0.18

package/README.md

@@ -674,6 +674,63 @@ mstem-storage/                     # 用户空间根(STEM_STORAGE_DIR)
 
 ---
 
+## Windows 使用说明
+
+macOS / Linux 用户可以跳过本节。以下是 Windows(尤其**中文系统 + 独立
+PowerShell / cmd 窗口**,即 conhost 而非 Windows Terminal)上遇到过的问题与开关。
+
+### 画面串行错乱(欢迎横幅 / 思考中 / 状态栏挤在同一行互相覆盖)
+
+原因是「东亚歧义宽度」字符 —— `● · ▁ │ ─ … → — ↑ ◇` 这些状态栏和横幅的主力符号,
+Unicode 规定"上下文不明时按 1 格算"(xterm / iTerm / Windows Terminal 都照办),
+但**中文 Windows 的 conhost 按控制台字体的全角字形画成 2 格**。渲染器是单元格模型,
+模型算的宽度和终端实际推进的列数一旦对不上,光标就逐列漂移。
+
+现在会自动判定(裸 conhost + CJK 代码页 → 按 2 格),启动后还会用 DECXCPR 实测一次
+校准。判定结果记在会话日志的 `[termProfile]` / `[termProfile:probe]` 里。
+
+判错了可以手动压:
+
+| 变量 | 作用 |
+| --- | --- |
+| `STEM_AMBIGUOUS_WIDTH=wide\|narrow` | 强制歧义宽度按 2 格 / 1 格算,优先级高于自动判定与探针 |
+| `STEM_CODE_PAGE=936` | 覆盖代码页探测(否则跑 `chcp` 取) |
+| `STEM_COLUMNS` / `STEM_ROWS` | 覆盖终端列/行数,见下 |
+
+### 画面右侧像被截断 / 窗口底部出现水平滚动条
+
+conhost 的**屏幕缓冲区**可以比可见**窗口**宽,而 Node 报告的列数取的是缓冲区宽度
+(libuv 用 `dwSize.X`),于是 UI 会往你看不见的列里画。两种解法:
+
+1. PowerShell 窗口 → 右键标题栏 → 属性 → 布局 → 把「屏幕缓冲区大小」的宽度改成与
+   「窗口大小」宽度一致(推荐,一劳永逸);
+2. 或用 `STEM_COLUMNS=<实际可见列数>` 压住。
+
+> 刻意**不认** `COLUMNS` / `LINES`:Git Bash / MSYS 导出的是启动时的静态值,窗口
+> 放大后不更新,拿它当真相源本身就是个 bug。
+
+### 中文变成 `���`
+
+工具输出(PowerShell / Bash)和 MCP server 的 stderr 现在都按正确编码处理:能控制的
+子进程强制它输出 UTF-8(PowerShell 注入 `[Console]::OutputEncoding`,cmd 前缀
+`chcp 65001`),控制不了的(MCP server)按 OEM 代码页解码。
+
+如果仍有乱码,把 `[termProfile]` 那行里的 `codePage` / `oemEncoding` 一并反馈。
+
+### MCP server 起不来
+
+Windows 上命令解析失败时**不会**报 ENOENT —— cross-spawn 会把它交给 `cmd.exe`,
+于是你只会看到一句本地化的 "不是内部或外部命令"(还是 OEM 编码的)。现在会在
+spawn 前先按 `PATHEXT` 沿 `PATH` 解析一遍,解析不到直接给 `command not found on
+PATH: "uvx"`。常见修法:装上对应工具,或把 `command` 写成 `npx.cmd` 这样带后缀的形式。
+
+### 报障时请带上
+
+- `logs/<sessionId>/*.txt`(含 `[termProfile]`,一眼能看出终端画像)
+- 复现时加 `STEM_DEBUG_REPAINTS=1`,日志里会多出全屏重画的归因
+- 画面问题可加 `STEM_TTY_RECORD=<路径>`,把原始终端字节流录下来一并发回 —— 我们能在
+  本地虚拟终端里按不同口径回放,把"猜"变成"量"
+
 ## 技术栈
 
 | 维度 | 选择 |

package/bin/stem-supervisor-lib.mjs

@@ -1,9 +1,9 @@
 // supervisor 逻辑库(2026-08-12 OOM 治理)— bin/stem.mjs 的看护实现。
 // 独立成库的唯一理由:入口脚本 import 即执行,smoke 无法直接测;这里的函数
 // 全部纯逻辑/可注入,scripts/smoke-supervisor.ts 逐项锁语义。
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
-import { tmpdir } from 'node:os'
+import { homedir, tmpdir } from 'node:os'
 import { spawn, spawnSync } from 'node:child_process'
 
 // 配置类错误的专用退出码(stem-entry-cli 侧同值):见 78 不重启。
@@ -95,25 +95,30 @@ export function injectRestartPrompt(queuePath, isZh, crashInfo) {
   } catch { return false }
 }
 
-/** 崩溃标记 sidecar(2026-08-13 事故:崩溃现场零证据,连退出信号都没记)。
- *  与 queue sidecar 同目录,`<sessionId>.crash.json`;crashes 数组保最近 20 条,
- *  下次排查直接看这里而不用翻 supervisor stderr。写失败静默(标记是诊断增强,
- *  不能反过来阻断重启)。 */
-export function writeCrashMarker(queuePath, sessionId, crashInfo, nowMs) {
-  if (typeof queuePath !== 'string' || !queuePath) return false
-  const markerPath = queuePath.endsWith('.queue.json')
-    ? queuePath.slice(0, -'.queue.json'.length) + '.crash.json'
-    : join(dirname(queuePath), `${sessionId || 'session'}.crash.json`)
+/** 崩溃标记(2026-08-13 事故:崩溃现场零证据,连退出信号都没记)。
+ *  落 `logs/<sessionId>/crash.json`(2026-08-18 起与该会话的 supervisor.log /
+ *  debug 日志 / 堆快照同目录归档;此前散在 queue sidecar 目录难找易丢)。
+ *  crashes 数组保最近 20 条,下次排查直接看这里而不用翻 supervisor stderr。
+ *  写失败静默(标记是诊断增强,不能反过来阻断重启)。 */
+export function writeCrashMarker(markerDir, sessionId, crashInfo, nowMs, extras = {}) {
+  if (typeof markerDir !== 'string' || !markerDir) return false
+  const markerPath = join(markerDir, 'crash.json')
   let crashes = []
   try {
     const parsed = JSON.parse(readFileSync(markerPath, 'utf8'))
     if (parsed && parsed.v === 1 && Array.isArray(parsed.crashes)) crashes = parsed.crashes
   } catch { /* 无文件/坏文件 → 全新标记 */ }
-  crashes.push({
+  const entry = {
     atMs: nowMs,
     exitCode: crashInfo && typeof crashInfo.code === 'number' ? crashInfo.code : null,
     signal: crashInfo && typeof crashInfo.signal === 'string' ? crashInfo.signal : null,
-  })
+  }
+  // 附加取证字段(2026-08-17 第五次崩溃:原生 SIGABRT 的 stderr 转储全部丢失,
+  // 只有 {exitCode, signal} 无法定因)— 全部可选、additive,v 保持 1,旧读方无感。
+  for (const [k, v] of Object.entries(extras)) {
+    if (v !== undefined && v !== null && v !== '') entry[k] = v
+  }
+  crashes.push(entry)
   if (crashes.length > 20) crashes = crashes.slice(-20)
   try {
     mkdirSync(dirname(markerPath), { recursive: true })
@@ -139,17 +144,97 @@ export function stripPermissionModeFlag(argv) {
   return out
 }
 
-/** 崩溃堆快照清理:只保留最新一份 Heap.*.heapsnapshot(防 24h 连跑占满磁盘)。 */
-export function cleanupHeapSnapshots(dir) {
+/** 从 argv 剥离 --model(重启时以通告里的实时会话模型为准 — 会话内 /model 切过的
+ *  模型不在启动 argv 里,原样透传会把模型打回启动值/llms.json default,2026-08-18
+ *  事故实证:/model 切到 gpt-5.6-sol 崩溃后自动续跑那一轮换回了兜底模型)。 */
+export function stripModelFlag(argv) {
+  const out = []
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === '--model') {
+      if (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-')) i++
+      continue
+    }
+    if (a.startsWith('--model=')) continue
+    out.push(a)
+  }
+  return out
+}
+
+/** 崩溃堆快照清理:跨给定目录扫描 Heap.*.heapsnapshot,按 mtime 只保最新
+ *  keep 份(快照 GB 级,防 24h 连跑占满磁盘)。2026-08-18 起快照按会话归档进
+ *  logs/<sessionId>/,清理从"cwd 内只留 1 份"改为"cwd + logs/ + 各会话目录
+ *  全局保最新 3 份"— 老会话的取证快照不再被下一次崩溃立即冲掉。 */
+export function cleanupHeapSnapshots(dirs, keep = 3) {
+  const found = []
+  for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
+    let entries
+    try { entries = readdirSync(dir).filter(f => /^Heap\..*\.heapsnapshot$/.test(f)) } catch { continue }
+    for (const f of entries) {
+      const p = join(dir, f)
+      try { found.push({ p, t: statSync(p).mtimeMs }) } catch { found.push({ p, t: 0 }) }
+    }
+  }
+  if (found.length <= keep) return
+  found.sort((a, b) => b.t - a.t)
+  for (const { p } of found.slice(keep)) {
+    try { rmSync(p, { force: true }) } catch { /* 占用中等失败静默 */ }
+  }
+}
+
+/** 遗留平铺会话日志归位:分会话目录改造(2026-08-18)前,debug 日志平铺在
+ *  logs/ 顶层(`<YYYY-MM-DD_HH-MM>_<sessionId>.txt`)。按文件名内嵌的会话 id
+ *  搬进 logs/<sessionId>/ —— 会话目录必须是该会话日志全集(提 bug 只拷一个
+ *  目录)。supervisor.log / 无关文件不动;搬失败(占用中)留待下次。 */
+export function relocateLegacySessionLogs(logsDir) {
   let entries
-  try { entries = readdirSync(dir).filter(f => /^Heap\..*\.heapsnapshot$/.test(f)) } catch { return }
-  if (entries.length <= 1) return
-  const withTime = entries.map(f => {
-    try { return { f, t: statSync(join(dir, f)).mtimeMs } } catch { return { f, t: 0 } }
-  }).sort((a, b) => b.t - a.t)
-  for (const { f } of withTime.slice(1)) {
-    try { rmSync(join(dir, f), { force: true }) } catch { /* 占用中等失败静默 */ }
+  try { entries = readdirSync(logsDir, { withFileTypes: true }) } catch { return [] }
+  const moved = []
+  for (const e of entries) {
+    if (!e.isFile()) continue
+    const m = /^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}_([A-Za-z0-9-]+)\.txt$/.exec(e.name)
+    if (!m) continue
+    try {
+      const dest = join(logsDir, m[1])
+      mkdirSync(dest, { recursive: true })
+      renameSync(join(logsDir, e.name), join(dest, e.name))
+      moved.push(join(dest, e.name))
+    } catch { /* 占用中/权限失败,下次启动再收 */ }
+  }
+  return moved
+}
+
+/** 堆快照可能出现的目录:cwd(V8 默认 / --diagnostic-dir 建目录失败回落)、
+ *  logs/(--diagnostic-dir 落点)、logs/ 下各会话归档目录。 */
+export function heapSnapshotDirs(cwd) {
+  const logsDir = join(cwd, 'logs')
+  const dirs = [cwd, logsDir]
+  try {
+    for (const e of readdirSync(logsDir, { withFileTypes: true })) {
+      if (e.isDirectory()) dirs.push(join(logsDir, e.name))
+    }
+  } catch { /* logs/ 不存在 */ }
+  return dirs
+}
+
+/** 崩溃堆快照按会话归档:把散落在 fromDirs(cwd / logs/ 顶层)的
+ *  Heap.*.heapsnapshot 搬进 logs/<sessionId>/,与该会话的 crash.json /
+ *  supervisor.log 放一起。搬失败(占用中/跨设备)留在原地由清理兜底。 */
+export function relocateHeapSnapshots(fromDirs, destDir) {
+  const moved = []
+  for (const dir of fromDirs) {
+    if (dir === destDir) continue
+    let entries
+    try { entries = readdirSync(dir).filter(f => /^Heap\..*\.heapsnapshot$/.test(f)) } catch { continue }
+    for (const f of entries) {
+      try {
+        mkdirSync(destDir, { recursive: true })
+        renameSync(join(dir, f), join(destDir, f))
+        moved.push(join(destDir, f))
+      } catch { /* 留在原地,cleanupHeapSnapshots 兜底 */ }
+    }
   }
+  return moved
 }
 
 /** 崩溃现场的终端复位:OOM abort 不走 ink 的退出钩子,raw mode / alt screen /
@@ -161,12 +246,79 @@ export function resetTerminal() {
   try { process.stdin.setRawMode?.(false) } catch { /* 非 TTY / 已复位 */ }
 }
 
+/** stderr 尾部环形缓冲(2026-08-17 第五次崩溃:V8 fatal error 的原生转储直写
+ *  fd 2 打上 TUI 后丢失,`FATAL ERROR:` 首行是定因的唯一证据)。Buffer 数组累积,
+ *  超限从头丢弃;read() 返回尾部 utf8 文本。 */
+export function createStderrTail(maxBytes = 64 * 1024) {
+  const chunks = []
+  let total = 0
+  return {
+    push(chunk) {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))
+      chunks.push(buf)
+      total += buf.length
+      while (total > maxBytes && chunks.length > 1) total -= chunks.shift().length
+    },
+    read() {
+      const text = Buffer.concat(chunks).toString('utf8')
+      return text.length > maxBytes ? text.slice(-maxBytes) : text
+    },
+  }
+}
+
+/** 崩溃时刻之后生成的 macOS 原生崩溃报告(ReportCrash 对 SIGABRT/SIGSEGV 必产出,
+ *  含完整原生栈与 abort 原因)。只找不搬:报告数百 KB 且含系统信息。 */
+export function findDiagnosticReport(sinceMs, dir) {
+  let entries
+  try { entries = readdirSync(dir).filter(f => f.endsWith('.ips')) } catch { return null }
+  let best = null
+  for (const f of entries) {
+    try {
+      const t = statSync(join(dir, f)).mtimeMs
+      if (t >= sinceMs && (!best || t > best.t)) best = { f, t }
+    } catch { /* 读取中/权限失败跳过 */ }
+  }
+  return best ? join(dir, best.f) : null
+}
+
+/** 把 .ips 报告路径回填到 crash.json 最新一条崩溃条目(报告由 ReportCrash 异步
+ *  生成,writeCrashMarker 时通常还不存在,退避 sleep 后二次回填)。失败静默。 */
+export function attachDiagnosticReport(markerDir, reportPath) {
+  if (typeof markerDir !== 'string' || !markerDir || !reportPath) return false
+  const markerPath = join(markerDir, 'crash.json')
+  try {
+    const parsed = JSON.parse(readFileSync(markerPath, 'utf8'))
+    if (!parsed || parsed.v !== 1 || !Array.isArray(parsed.crashes) || parsed.crashes.length === 0) return false
+    parsed.crashes[parsed.crashes.length - 1].diagnosticReport = reportPath
+    writeFileSync(markerPath, JSON.stringify(parsed, null, 2) + '\n')
+    return true
+  } catch { return false }
+}
+
 function defaultSpawnChild(args, env) {
-  const child = spawn(process.execPath, args, { stdio: 'inherit', env })
+  // stderr 走 pipe 而非 inherit:原生崩溃转储(V8 fatal / abort)绕过 JS 层拦截
+  // 直写 fd 2,inherit 时直接打上 TUI 且父进程零捕获(2026-08-17 事故)。pipe 后
+  // 实时透传回终端(行为不变)+ 环形缓冲留尾部作取证。TUI 渲染门只看 stdout/stdin
+  // 的 isTTY,stderr 非 TTY 的影响仅限着色(exitCleanup 的 hint 着色已改跟 stdout)。
+  const tail = createStderrTail()
+  const child = spawn(process.execPath, args, { stdio: ['inherit', 'inherit', 'pipe'], env })
+  child.stderr?.on('data', chunk => {
+    tail.push(chunk)
+    try { process.stderr.write(chunk) } catch { /* 终端已关闭等,透传失败无害 */ }
+  })
   return {
     pid: child.pid,
+    stderrTail: () => tail.read(),
     exited: new Promise(resolve => {
-      child.on('exit', (code, signal) => resolve({ code, signal }))
+      // 'close' 优先:exit 触发时 stderr pipe 可能还有未读完的崩溃转储,close 保证
+      // flush 完、stderrTail 不缺尾巴。但 close 会被继承了 stderr fd 的孙进程
+      // (MCP server 等)拖住 — 子进程死了管道还开着,close 迟迟不来(实测孙进程
+      // 活多久拖多久)→ 崩溃检测被无限延迟。所以 exit 后给 2s flush 宽限兜底,
+      // 两者先到先赢(resolve 幂等)。
+      child.on('close', (code, signal) => resolve({ code, signal }))
+      child.on('exit', (code, signal) => {
+        setTimeout(() => resolve({ code, signal }), 2000)
+      })
       child.on('error', () => resolve({ code: 1, signal: null }))
     }),
   }
@@ -188,6 +340,13 @@ export async function runSupervisor(distEntry, argv, options = {}) {
     now = Date.now,
     cwd = process.cwd(),
     announceFile = join(mkdtempSync(join(tmpdir(), 'stem-supervisor-')), 'session.json'),
+    // supervisor 自身诊断的持久化落点(2026-08-17 事故:崩溃信息只写终端,滚屏即丢)。
+    // 缺省 null = 动态解析:会话已知 → logs/<sessionId>/supervisor.log,
+    // 未知(死在首次通告前且无 --resume)→ logs/supervisor.log 顶层兜底。
+    // 显式传入(smoke 注入)则固定用该路径。
+    supervisorLogPath = null,
+    // macOS ReportCrash 报告目录(smoke 可注入假目录)。
+    diagnosticReportsDir = join(homedir(), 'Library', 'Logs', 'DiagnosticReports'),
     resetTerminalFn = resetTerminal,
     onCrashCleanupPid = pid => {
       // Windows 下 best-effort 清理子进程树残留(MCP npx/uvx 僵尸);根进程已死时
@@ -199,12 +358,61 @@ export async function runSupervisor(distEntry, argv, options = {}) {
     installSignalHandlers = true,
   } = options
 
+  // log() 只写终端;logLine() 同时 append 到 supervisor.log(ISO 时间戳)—
+  // 崩溃路径一律用 logLine,子进程日志闸门(STEM_DEBUG)关着时这里仍有据可查。
+  // 路径每次写时解析:resumeId 随通告更新,崩溃日志落到崩溃会话自己的目录。
+  const supervisorLogFile = () => {
+    if (supervisorLogPath) return supervisorLogPath
+    return resumeId
+      ? join(cwd, 'logs', resumeId, 'supervisor.log')
+      : join(cwd, 'logs', 'supervisor.log')
+  }
+  const logFileOnly = text => {
+    const logPath = supervisorLogFile()
+    try {
+      mkdirSync(dirname(logPath), { recursive: true })
+      appendFileSync(logPath, `${new Date(now()).toISOString()} ${text}\n`)
+    } catch { /* 诊断落盘失败不阻断看护 */ }
+  }
+  const logLine = text => {
+    log(text)
+    logFileOnly(text)
+  }
+  // stem 版本一次性读取(dist/cli.mjs → ../package.json),best-effort。
+  let stemVersion = null
+  try { stemVersion = JSON.parse(readFileSync(join(dirname(distEntry), '..', 'package.json'), 'utf8')).version ?? null } catch { /* smoke 假路径等 */ }
+
   let { baseArgs, resumeId } = stripResumeFlag(argv)
   let crashTimes = []
   let childAlive = false
   // 崩溃前子进程通告的实时 permission mode(Shift+Tab 切换会更新通告)—
   // 重启时经 --permission-mode 复原,argv 中的启动值被剥离让位。
   let permissionModeFromAnnounce = null
+  // 崩溃前子进程通告的实时会话模型(--model 启动参数 / 会话内 /model 同一个槽)—
+  // null = 子进程从未通告过(死在首次 announce 前)→ 启动 argv 原样透传;
+  // '' = 通告了"无覆盖"→ 剥掉启动 argv 里的 --model,回落 llms.json default。
+  let modelFromAnnounce = null
+
+  // 会话生命周期行(2026-08-18 用户要求:健康会话的目录里也要有 supervisor.log,
+  // 不能"没崩就空无一物")。会话身份来自通告文件:子进程在每个会话切换点写,
+  // supervisor 此前只在崩溃后读 → 这里加轻量轮询(2s,unref)+ 退出时兜底检查,
+  // 每个会话(含 /clear 切出的)首次现身即在自己目录写"已启动"行;只写文件
+  // 不写终端(TUI 占屏)。同 sid 重复通告/崩溃重启不重复写。
+  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 }
+    if (!parsed || parsed.sessionId === announcedSid) return
+    announcedSid = parsed.sessionId
+    resumeId = parsed.sessionId
+    logFileOnly(isZh
+      ? `stem: 会话已启动(pid ${currentPid ?? '-'})`
+      : `stem: session started (pid ${currentPid ?? '-'})`)
+  }
 
   if (installSignalHandlers) {
     // Windows CTRL_C_EVENT 广播父子都收:父进程吞掉,让子进程自己处理(单击中断 /
@@ -214,10 +422,16 @@ export async function runSupervisor(distEntry, argv, options = {}) {
   }
 
   for (;;) {
-    cleanupHeapSnapshots(cwd)
-    const effectiveBase = permissionModeFromAnnounce ? stripPermissionModeFlag(baseArgs) : baseArgs
+    // --diagnostic-dir=logs/ 的落点必须存在:目录缺失时 V8 写快照直接原生断言
+    // 崩溃(实测 node 25)。用户中途删掉 logs/ 也要能扛,每轮 spawn 前补建。
+    try { mkdirSync(join(cwd, 'logs'), { recursive: true }) } catch { /* 建不了则回落 cwd 默认 */ }
+    relocateLegacySessionLogs(join(cwd, 'logs'))
+    cleanupHeapSnapshots(heapSnapshotDirs(cwd))
+    let effectiveBase = permissionModeFromAnnounce ? stripPermissionModeFlag(baseArgs) : baseArgs
+    if (modelFromAnnounce !== null) effectiveBase = stripModelFlag(effectiveBase)
     const args = [...nodeFlags, distEntry, ...effectiveBase]
     if (permissionModeFromAnnounce) args.push('--permission-mode', permissionModeFromAnnounce)
+    if (modelFromAnnounce) args.push('--model', modelFromAnnounce)
     if (resumeId) args.push('--resume', resumeId)
     const child = spawnChild(args, {
       ...process.env,
@@ -225,31 +439,33 @@ export async function runSupervisor(distEntry, argv, options = {}) {
       STEM_SESSION_ANNOUNCE_FILE: announceFile,
     })
     childAlive = true
+    currentPid = child.pid ?? null
+    const lifecycleTimer = setInterval(checkAnnounceForLifecycle, 2000)
+    lifecycleTimer.unref?.()
     const { code, signal } = await child.exited
+    clearInterval(lifecycleTimer)
     childAlive = false
+    // 兜底:极快退出 / smoke 假子进程 / 轮询没赶上,也不漏启动行。
+    checkAnnounceForLifecycle()
 
-    if (code === 0) return 0
+    if (code === 0) {
+      logFileOnly(isZh ? 'stem: 会话正常退出(code=0)' : 'stem: session exited normally (code=0)')
+      return 0
+    }
     if (code === EXIT_CODE_CONFIG) {
-      log(isZh
+      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
     }
 
-    // 崩溃路径。60 秒窗口内连崩 3 次 → 放弃(配置外的持续性故障,重启无益)。
+    // 崩溃路径。先读会话通告拿会话身份 — 所有崩溃落盘(supervisor.log /
+    // crash.json / 堆快照)都按 logs/<sessionId>/ 分目录归档,身份必须先到手;
+    // 子进程死在通告前 → 沿用现有 resumeId(可能为 null → 落 logs/ 顶层兜底)。
     const t = now()
     crashTimes = crashTimes.filter(x => t - x < CRASH_WINDOW_MS)
     crashTimes.push(t)
     resetTerminalFn()
-    if (crashTimes.length >= CRASH_GIVE_UP_COUNT) {
-      log(isZh
-        ? `stem: 60 秒内连续崩溃 ${crashTimes.length} 次(code=${code ?? '-'}, signal=${signal ?? '-'}),停止自动重启。`
-        : `stem: crashed ${crashTimes.length} times within 60s (code=${code ?? '-'}, signal=${signal ?? '-'}); giving up on auto-restart.`)
-      return typeof code === 'number' && code !== 0 ? code : 1
-    }
-
-    // 会话通告(子进程在每个会话切换点写):拿到真实 sessionId 与 sidecar 路径,
-    // 修补崩溃截断的 JSONL 尾部 + 注入续跑队列。子进程死在通告前 → 沿用现有 resumeId。
     let announce = null
     try {
       const parsed = JSON.parse(readFileSync(announceFile, 'utf8'))
@@ -260,24 +476,87 @@ export async function runSupervisor(distEntry, argv, options = {}) {
       if (typeof announce.permissionMode === 'string' && announce.permissionMode) {
         permissionModeFromAnnounce = announce.permissionMode
       }
+      // 模型:空串是有效状态(无覆盖),所以只判类型不判真值 — 判真值会让
+      // /model default 之后的重启把启动 argv 的旧 --model 又带回来。
+      if (typeof announce.model === 'string') modelFromAnnounce = announce.model
+    }
+    // 本次崩溃的会话归档目录(crash.json / 堆快照 / supervisor.log 共用)。
+    const sessionDir = resumeId ? join(cwd, 'logs', resumeId) : null
+    // 堆快照按会话归档:V8 落在 --diagnostic-dir(logs/)或 cwd(旧默认 /
+    // 建目录失败回落),搬进崩溃会话自己的目录,免得被后续清理当无主快照收走。
+    if (sessionDir) relocateHeapSnapshots([cwd, join(cwd, 'logs')], sessionDir)
+
+    // stderr 尾部取证:pipe 捕获的原生崩溃转储(FATAL ERROR / abort 栈)。
+    // crash.json 里截 8KB;supervisor.log 无条件记一份 — 即便子进程死在首次
+    // announce 前(crash.json 写不了),这里也有据。
+    const stderrTail = typeof child.stderrTail === 'function' ? child.stderrTail() : ''
+    const stderrTail8k = stderrTail.length > 8 * 1024 ? stderrTail.slice(-8 * 1024) : stderrTail
+    if (stderrTail8k.trim()) {
+      logLine(isZh
+        ? `stem: 崩溃 stderr 尾部(code=${code ?? '-'}, signal=${signal ?? '-'}):\n${stderrTail8k}`
+        : `stem: crash stderr tail (code=${code ?? '-'}, signal=${signal ?? '-'}):\n${stderrTail8k}`)
+    }
+
+    // JSONL 修补 + 崩溃标记在放弃判定之前:第 3 崩(将放弃)恰是最需要取证的
+    // 一次;修补后用户手动 --resume 也不会被截断半行拒载(旧实现两者都缺)。
+    if (announce) {
       for (const p of Array.isArray(announce.jsonlPaths) ? announce.jsonlPaths : []) {
         if (typeof p === 'string' && existsSync(p) && repairJsonlTail(p)) {
-          log(isZh ? `stem: 已修补崩溃截断的会话记录 ${p}` : `stem: repaired crash-truncated session log ${p}`)
+          logLine(isZh ? `stem: 已修补崩溃截断的会话记录 ${p}` : `stem: repaired crash-truncated session log ${p}`)
           break
         }
       }
-      if (typeof announce.queuePath === 'string') {
-        writeCrashMarker(announce.queuePath, announce.sessionId, { code, signal }, t)
-        injectRestartPrompt(announce.queuePath, isZh, { code, signal })
+      // .tasks.json / .taskstate.json 的 mtime = 子进程最后一次任务落盘时刻,
+      // 用于回答"崩溃前它空闲了多久"(本次事故:空闲 8.5 分钟零遥测)。
+      const sidecarMtime = suffix => {
+        if (typeof announce.queuePath !== 'string') return undefined
+        try { return statSync(announce.queuePath.replace(/\.queue\.json$/, suffix)).mtimeMs } catch { return undefined }
       }
+      writeCrashMarker(sessionDir, announce.sessionId, { code, signal }, t, {
+        stderrTail: stderrTail8k,
+        args,
+        nodeVersion: process.version,
+        stemVersion,
+        announceUpdatedAtMs: typeof announce.updatedAtMs === 'number' ? announce.updatedAtMs : undefined,
+        tasksSnapshotMtimeMs: sidecarMtime('.tasks.json'),
+        taskStateMtimeMs: sidecarMtime('.taskstate.json'),
+      })
+    }
+
+    if (crashTimes.length >= CRASH_GIVE_UP_COUNT) {
+      logLine(isZh
+        ? `stem: 60 秒内连续崩溃 ${crashTimes.length} 次(code=${code ?? '-'}, signal=${signal ?? '-'}),停止自动重启。`
+        : `stem: crashed ${crashTimes.length} times within 60s (code=${code ?? '-'}, signal=${signal ?? '-'}); giving up on auto-restart.`)
+      return typeof code === 'number' && code !== 0 ? code : 1
+    }
+
+    // 续跑注入只在还会重启时做:放弃场景注入了反而让下次手动 resume 自动跑
+    // 一条"已重启"文案,与事实不符。
+    if (announce && typeof announce.queuePath === 'string') {
+      injectRestartPrompt(announce.queuePath, isZh, { code, signal })
     }
 
     onCrashCleanupPid(child.pid)
 
     const delayMs = Math.min(1000 * 2 ** (crashTimes.length - 1), RESTART_BACKOFF_MAX_MS)
-    log(isZh
+    logLine(isZh
       ? `stem: 进程异常退出(code=${code ?? '-'}, signal=${signal ?? '-'}),${Math.round(delayMs / 1000)}s 后自动恢复会话${resumeId ? ` ${resumeId}` : ''}…(STEM_NO_SUPERVISOR=1 可关闭看护)`
       : `stem: process crashed (code=${code ?? '-'}, signal=${signal ?? '-'}); resuming session${resumeId ? ` ${resumeId}` : ''} in ${Math.round(delayMs / 1000)}s… (set STEM_NO_SUPERVISOR=1 to disable)`)
     await sleep(delayMs)
+
+    // macOS 信号死亡 → ReportCrash 异步生成 .ips 报告(实测崩溃后 ~5s 才落盘,
+    // 退避窗口等不到):崩溃后 8s 延迟扫描,找到就回填 crash.json 最新条目 +
+    // 落 supervisor.log。只写文件不写终端(此时新子进程 TUI 已接管屏幕);
+    // unref 不阻退出;只记路径不搬内容。
+    if (process.platform === 'darwin' && signal) {
+      const markerDirForAttach = announce ? sessionDir : null
+      const scanTimer = setTimeout(() => {
+        const report = findDiagnosticReport(t, diagnosticReportsDir)
+        if (!report) return
+        logFileOnly(isZh ? `stem: 原生崩溃报告 ${report}` : `stem: native crash report ${report}`)
+        if (markerDirForAttach) attachDiagnosticReport(markerDirForAttach, report)
+      }, 8000)
+      scanTimer.unref?.()
+    }
   }
 }

package/bin/stem.mjs

@@ -9,9 +9,9 @@
 // 会话重启。正常退出(exit 0)与配置错误(exit 78)不重启;60 秒内连崩 3 次
 // 放弃。STEM_NO_SUPERVISOR=1 退回单次直跑;实现与语义锁定见
 // bin/stem-supervisor-lib.mjs 与 scripts/smoke-supervisor.ts。
-import { existsSync, realpathSync } from 'node:fs'
+import { existsSync, mkdirSync, realpathSync } from 'node:fs'
 import { dirname, join } from 'node:path'
-import { devNull } from 'node:os'
+import { devNull, totalmem } from 'node:os'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { spawnSync } from 'node:child_process'
 
@@ -38,18 +38,47 @@ function heapConfigured() {
   )
 }
 
+/**
+ * 堆上限按机器物理内存推导(2026-08-18 第六次事故)。
+ *
+ * 此前固定 8192 —— 在提交不上 8GB 的机器上 V8 永远够不到自己的上限:
+ * near-heap-limit 回调(含 --heapsnapshot-near-heap-limit)不会执行,一切
+ * "距上限还有多远"的判断全是空转,进程改由原生分配失败打死,而 V8 视角
+ * 直到最后一刻都"还健康"(事故日志:heap 1.5GB / RSS 1.8GB 时静默死亡,
+ * 所有守护零触发)。取物理内存 60%,夹在 [2048, 8192];读不到 totalmem
+ * 时退回 4096(比 8192 保守,宁可早撞 V8 上限也别让它够不着)。
+ */
+function heapLimitMB() {
+  let total = 0
+  try { total = totalmem() } catch { total = 0 }
+  if (!Number.isFinite(total) || total <= 0) return 4096
+  return Math.max(2048, Math.min(8192, Math.floor((total / (1024 * 1024)) * 0.6)))
+}
+
 /** 子进程 node flags:heap 上限(未显式配置时)+ OOM 前堆快照(可关)。 */
 function childNodeFlags() {
   const flags = []
-  if (!heapConfigured()) flags.push('--max-old-space-size=8192')
+  if (!heapConfigured()) flags.push(`--max-old-space-size=${heapLimitMB()}`)
   // OOM 前自动堆快照:定位"未知同步分配风暴"元凶的唯一现实手段(手动
   // /heapdump 在同步爆发下来不及)。代价是崩溃时写数 GB 快照;supervisor
-  // 每轮 spawn 前清理只留最新一份。STEM_HEAP_SNAPSHOT=0 关闭。
+  // 崩溃后按会话归档进 logs/<sessionId>/,每轮 spawn 前跨目录清理保最新
+  // 3 份。STEM_HEAP_SNAPSHOT=0 关闭。
   if (
     process.env.STEM_HEAP_SNAPSHOT !== '0' &&
     !(process.env.NODE_OPTIONS ?? '').includes('--heapsnapshot-near-heap-limit')
   ) {
     flags.push('--heapsnapshot-near-heap-limit=1')
+    // 快照定向到 <cwd>/logs/(V8 默认写 cwd,散落且被误当项目文件);supervisor
+    // 崩溃后再按会话归档进 logs/<sessionId>/。注意 --diagnostic-dir 指向的目录
+    // 必须已存在 —— 实测(node 25)目录缺失时 V8 写快照直接原生断言崩溃,
+    // 所以先建目录,建失败就不加 flag 回落 cwd 默认。
+    if (!(process.env.NODE_OPTIONS ?? '').includes('--diagnostic-dir')) {
+      try {
+        const diagDir = join(process.cwd(), 'logs')
+        mkdirSync(diagDir, { recursive: true })
+        flags.push(`--diagnostic-dir=${diagDir}`)
+      } catch { /* 建目录失败 → 维持 V8 默认(cwd),supervisor 归档兜底 */ }
+    }
   }
   return flags
 }
@@ -78,7 +107,7 @@ if (process.env.STEM_DEV !== '1' && existsSync(distEntry)) {
     // 把 --max-old-space-size 带给真正的 CLI 进程。
     const result = spawnSync(
       process.execPath,
-      ['--max-old-space-size=8192', distEntry, ...argv],
+      [`--max-old-space-size=${heapLimitMB()}`, distEntry, ...argv],
       { stdio: 'inherit' },
     )
     process.exit(result.status ?? 1)