cron-up 26.10.30 → 26.10.32

package/src/registry.mjs

@@ -1,13 +1,14 @@
 // Claude Code 会话登记（~/.claude/sessions/*.json）的读取与消费者判定。
 // 登记是另一个程序未文档化的输出：一旦形状变化，所有会话都会被读成「不
-// 存在」，巡检就会在用户会话旁边反复重拉。scanSessions 因此内置四枚烟
-// 雾告警，分别盯住四种漂移形态。
+// 存在」，巡检就会反复重拉。scanSessions 因此内置三枚烟雾告警，分别盯住
+// 三种漂移形态。
 //
-// 除「某目录有没有消费者」外，它还回报每个消费者的进程祖先链：cron-up
-// 拉起的预热会话是三层结构 script(S) → zsh(Z) → claude(C)（claude 在交
-// 互 shell 里是函数，函数帧不做 tail-exec），state 只记得到 S，登记里
-// 却是 C，pgid 又被交互 shell 的作业控制改过——唯一稳定的认亲方式是沿
-// ppid 上溯。
+// 除「某目录有哪些活会话」外，它回报每个会话的进程祖先链：cron-up 拉起
+// 的预热会话是三层结构 script(S) → zsh(Z) → claude(C)（claude 在交互
+// shell 里是函数，函数帧不做 tail-exec），state 只记得到 S，登记里却是
+// C，pgid 又被交互 shell 的作业控制改过——唯一稳定的认亲方式是沿 ppid
+// 上溯。祖先链每轮恒拍（一次全机 ps，毫秒级）：任务级模型下每个预热都
+// 要靠它把 script pid 认成登记里的 sessionId，没有「不需要认亲」的轮次。
 
 import fs from 'node:fs';
 import path from 'node:path';
@@ -35,7 +36,7 @@ function ps(pid, fmt) {
 
 // 一次 ps 同时拿进程名与父 pid：{isClaude, ppid}。ppid 按「末尾空白+
 // 数字」取——comm 可能是含空格的路径，但不会以「空白+数字」结尾；列缺
-// 失（ps 失败/输出漂移）时 ppid 为 null，调用方按歧义保守处理。
+// 失（ps 失败/输出漂移）时 ppid 为 null。
 export function processShape(pid) {
   const line = ps(pid, 'comm=,ppid=');
   const m = line.match(/^(.*\S)\s+(\d+)\s*$/);
@@ -49,7 +50,7 @@ export function processShape(pid) {
 }
 
 // 全机进程父子表：一次 ps -axo pid=,ppid= 拍快照，Map<pid, ppid>。任何
-// 异常都返回 null（调用方退化为「全部歧义」的保守行为，绝不抛出）。
+// 异常都返回 null（祖先链一律按空链处理：认亲下轮再试，不阻断 spawn）。
 export function processParentMap() {
   const r = deps.execFile('/bin/ps', ['-axo', 'pid=,ppid='], { timeout: 5000 });
   if (r.status !== 0) return null;
@@ -62,8 +63,7 @@ export function processParentMap() {
 }
 
 // 沿父子表上溯（不含 pid 自身），直到 launchd(1；其父记为 0)。中途父 pid
-// 在快照里缺失（ps 退化/进程刚好退出）或成环时 chainComplete=false——
-// 「没找到目标」与「证据链断了」必须由调用方区分：后者按歧义不双开。
+// 在快照里缺失（ps 退化/进程刚好退出）或成环时 chainComplete=false。
 export function ancestorChain(pid, parentMap) {
   const ancestors = [];
   const seen = new Set([pid]);
@@ -79,9 +79,9 @@ export function ancestorChain(pid, parentMap) {
   }
 }
 
-// 本目录活着的消费者会话 id 集合。窗口任务的 createdBySessionId 命中其中
-// 任一个，就说明创建它的会话还开着——stampOwner 的最高优先级是尊重活创
-// 建者，既不另拉也不过户。
+// 本目录活着的会话 id 集合。任务的 createdBySessionId 命中其中任一个，
+// 就说明创建它的会话还开着——活创建者享有最高优先级：任务铁定投进它，
+// 巡检不预热、不盖印。
 export function liveSessionIds(details, ws) {
   return new Set((details?.get(ws) ?? [])
     .map((d) => d.sessionId)
@@ -89,38 +89,51 @@ export function liveSessionIds(details, ws) {
 }
 
 // 逐任务本原谓词：这条任务的创建者会话还活着吗？liveSids 是同工作区的
-// liveSessionIds 快照。认亲分类（聚合布尔）与盖印（逐任务）都从它派生。
+// liveSessionIds 快照。
 export function creatorSessionAlive(task, liveSids) {
   return typeof task?.createdBySessionId === 'string'
     && liveSids.has(task.createdBySessionId);
 }
 
-// stampOwner 的认亲结论。details/ws 是 scanSessions 的第三元素；ownPid
-// 是调用方按指纹判活的本代 script pid（没有活条目时给 null，registry 不
-// 认识 state 条目的语义）；creatorAlive 表示「至少一个窗口内任务的创建
-// 者会话还在本目录活着」：
-//   own          祖先链里有 ownPid——在场消费者就是我们的预热；
-//                target 给出可盖印详情，身份字段缺失时为 null；
-//   creatorAlive 窗口任务的创建者会话还活着——任务按 Claude Code 规则必
-//                然投给它，不另拉、不盖印（用户显式要求的最高优先级）；
-//   ambiguous    没有认到自己的预热，但在场会话父链不完整——无法证明不
-//                是自己（如 state 丢失的孤儿预热），保守不双开；
-//   user         以上皆否——创建者已关闭/崩溃，在场的只是无关用户会话
-//                （或根本没有消费者），可以另拉独立预热承接。
-export function classifyWorkspace(details, ws, ownPid, creatorAlive) {
+// 认亲：我们 spawn 的 script pid 是不是本目录某个活登记会话的祖先。命中
+// 即该预热已完成登记、是健康会话，返回登记详情（claude 的 pid/sessionId/
+// procStart）；认不到返回 null（会话还在启动，或卡在提问界面）。
+export function claimWarm(details, ws, scriptPid) {
   const list = details?.get(ws) ?? [];
-  if (ownPid !== null) {
-    const own = list.find((d) => d.ancestors.includes(ownPid));
-    if (own) {
-      return {
-        kind: 'own',
-        target: own.sessionId && own.procStart ? own : null,
-      };
+  return list.find((d) => d.ancestors.includes(scriptPid)) ?? null;
+}
+
+// 轻量单会话存活检查：按 sessionId 找登记、pid 活、cwd 匹配。轮末死亡复
+// 核用——轮初还活的预热 script 轮中死去时，要区分「真的死了」与「用户在
+// 终端 --resume 接管成裸 claude」（同一 sessionId、新 pid），后者不算会
+// 话退出。不给 ws 时只看 sid 活不活。
+export function sessionAliveNow(sid, ws = null) {
+  if (typeof sid !== 'string') return false;
+  let files = [];
+  try {
+    files = fs.readdirSync(deps.paths.sessionDir)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => path.join(deps.paths.sessionDir, f));
+  } catch {
+    return false;
+  }
+  for (const f of files) {
+    let s;
+    try {
+      s = JSON.parse(fs.readFileSync(f, 'utf-8'));
+    } catch {
+      continue; // 可能正被 Claude Code 就地重写
     }
+    if (!isPlainObject(s) || s.sessionId !== sid) continue;
+    const pid = parsePid(s.pid);
+    if (pid === null || !deps.alive(pid)) continue;
+    if (ws !== null) {
+      if (typeof s.cwd !== 'string' || !path.isAbsolute(s.cwd)
+          || lexReal(s.cwd) !== ws) continue;
+    }
+    return true;
   }
-  if (creatorAlive) return { kind: 'creatorAlive', target: null };
-  if (list.some((d) => !d.chainComplete)) return { kind: 'ambiguous', target: null };
-  return { kind: 'user', target: null };
+  return false;
 }
 
 // 读一个登记文件；读不出返回 null。Claude Code 会就地（非原子）重写登
@@ -147,10 +160,9 @@ async function readSessionFile(file) {
 
 // 返回 [拥有活消费者会话的工作区集合, 告警字符串|null, 会话详情 Map]。
 // 第三个元素是 Map<cwd, Array<{pid, sessionId, procStart, ancestors,
-// chainComplete}>>；祖先链要付一次全机 ps，只有 stampOwner 需要，所以
-// lineage 默认关：关时恒为空 Map，总览/list/平静巡检不增加任何进程开销
-// （与本仓「全量 ps 按需现拍」的既有纪律一致）。
-export async function scanSessions({ lineage = false } = {}) {
+// chainComplete}>>。祖先链恒拍：快照失败给空链，相关预热本轮认不到亲、
+// 下轮自动重试；consumers 判定不受影响。
+export async function scanSessions() {
   let files = [];
   try {
     files = fs.readdirSync(deps.paths.sessionDir)
@@ -167,17 +179,13 @@ export async function scanSessions({ lineage = false } = {}) {
     }
   }
 
-  // 全轮一张父子表快照：所有会话的祖先链取自同一时刻，且只付一次全量
-  // ps。仅在 lineage 显式开启时拍——快照失败给 null，祖先链一律按断链
-  // 处理（stampOwner 退化为「全部歧义、绝不双开」），consumers 判定不受
-  // 影响。
+  // 全轮一张父子表快照：所有会话的祖先链取自同一时刻，且只付一次全机
+  // ps。失败给 null，祖先链一律按断链处理（本轮认不到亲）。
   let parentMap = null;
-  if (lineage) {
-    try {
-      parentMap = deps.processParentMap();
-    } catch {
-      parentMap = null;
-    }
+  try {
+    parentMap = deps.processParentMap();
+  } catch {
+    parentMap = null;
   }
 
   const consumers = new Set();
@@ -187,9 +195,6 @@ export async function scanSessions({ lineage = false } = {}) {
   // interactive 认得出来，却读不出有效 pid 或工作目录的条目数：pid/cwd
   // 字段改名就是这种形态，而下面两条自检只看 kind 与进程形态，兜不住。
   let suspect = 0;
-  // 已是消费者、但进程父 pid 或祖先链读不完整的条目数：stampOwner 会因
-  // 此无法认亲，只能保守不双开（过户暂停），需要一行告警让人看见退化。
-  let lineageMissing = 0;
   for (const s of interactive) {
     // pid 也是外部程序写的字段：null、非数值、非正数、超 pid_t 的巨大整
     // 数都读不出活进程。这段代码在 per-workspace 保护圈之外，一个畸形登
@@ -207,29 +212,25 @@ export async function scanSessions({ lineage = false } = {}) {
     const shape = shapeCache.get(pid);
     if (shape.isClaude) {
       // cwd 同样不可信：非字符串当定位不到工作区；空串与相对路径会被
-      // resolve 拼到巡检进程自己的 cwd 下，凭空造出消费者目录，可能令预
-      // 热被静默跳过。
+      // resolve 拼到巡检进程自己的 cwd 下，凭空造出消费者目录。
       const cwd = s.cwd;
       if (typeof cwd === 'string' && path.isAbsolute(cwd)) {
         const ws = lexReal(cwd);
         consumers.add(ws);
-        if (lineage) {
-          const chain = parentMap
-            ? ancestorChain(pid, parentMap)
-            : { ancestors: [], chainComplete: false };
-          if (shape.ppid === null || !chain.chainComplete) lineageMissing += 1;
-          const list = details.get(ws) ?? [];
-          list.push({
-            pid,
-            sessionId: typeof s.sessionId === 'string' ? s.sessionId : null,
-            // procStart 是 ps lstart 原文（单位数日期含双空格），只许原样
-            // 传递给任务文件，绝不能自己拼。
-            procStart: typeof s.procStart === 'string' ? s.procStart : null,
-            ancestors: chain.ancestors,
-            chainComplete: chain.chainComplete,
-          });
-          details.set(ws, list);
-        }
+        const chain = parentMap
+          ? ancestorChain(pid, parentMap)
+          : { ancestors: [], chainComplete: false };
+        const list = details.get(ws) ?? [];
+        list.push({
+          pid,
+          sessionId: typeof s.sessionId === 'string' ? s.sessionId : null,
+          // procStart 是 ps lstart 原文（单位数日期含双空格），只许原样
+          // 传递给任务文件，绝不能自己拼。
+          procStart: typeof s.procStart === 'string' ? s.procStart : null,
+          ancestors: chain.ancestors,
+          chainComplete: chain.chainComplete,
+        });
+        details.set(ws, list);
         continue;
       }
       suspect += 1; // 活着的 claude 却没有可用 cwd：cwd 字段漂移
@@ -249,11 +250,7 @@ export async function scanSessions({ lineage = false } = {}) {
   } else if (suspect > 0 && consumers.size === 0) {
     alert = '会话登记中的 interactive 会话都读不出有效的 pid 或工作目录；'
       + 'Claude Code 的会话登记字段可能已变更，cron-up 会把已有会话误判为'
-      + '不存在，在同目录重复拉起会话';
-  } else if (lineage && lineageMissing > 0) {
-    alert = `${lineageMissing} 个存活会话的进程父子关系读不完整（ps 输出异常或`
-      + '会话进程正在退出）；stampOwner 本轮按保守策略不另拉预热会话、暂停'
-      + '任务过户，下轮自动恢复';
+      + '不存在，重复拉起预热会话';
   }
   return [consumers, alert, details];
 }
@@ -264,6 +261,7 @@ Object.assign(deps, {
   ancestorChain,
   liveSessionIds,
   creatorSessionAlive,
-  classifyWorkspace,
+  claimWarm,
+  sessionAliveNow,
   scanSessions,
 });

package/src/service.mjs

@@ -7,26 +7,22 @@ import path from 'node:path';
 import {
   deps,
   ExitError,
-  isPlainObject,
   ensurePrivateDir,
 } from './internals.mjs';
 import { paths, LABEL } from './paths.mjs';
-import { SPECS, thisCamel } from './args.mjs';
-// paths.home 仅用于 resolveLauncher 的默认 HOME；其余产物路径一律走
-// deps.paths（测试要整体重定向）。
-import { scriptProcLogPath } from './sessions.mjs';
 import {
   DEFAULT_CONFIG,
+  INTERVAL_SECONDS,
 } from './constants.mjs';
 import {
   loadConfig,
   saveConfig,
   loadState,
+  loadLegacyEntries,
   validateConfig,
   normalizeRoots,
-  isInt,
-  configFieldErrors,
 } from './config.mjs';
+import { scriptProcLogPath } from './sessions.mjs';
 
 function guiTarget() {
   return `gui/${process.getuid()}`;
@@ -82,7 +78,7 @@ export function serviceLine(info, plistExists) {
 // npm 全局 bin 的 shebang 是 #!/usr/bin/env node，而 launchd 的最小 PATH
 // （/usr/bin:/bin:/usr/sbin:/sbin）里没有 node。安装时把「node 与 cron-up
 // 所在的 bin 目录」写进启动脚本的 PATH，之后每轮由脚本自己解析：npm 升
-// 级、切换默认版本都自动跟随，且 node 与包永远同版本。
+// 级、切换默认版本都自动跟随。
 
 function isExecutable(p) {
   try {
@@ -98,9 +94,7 @@ function isExecutable(p) {
 // aliases/default/bin 是跟随 `fnm default` 切换的稳定 symlink（切勿
 // realpath 到版本化目录，fnm 升级后那里会失效）；volta 的 ~/.volta/bin、
 // Homebrew 与官网 pkg 的系统 bin 同理是版本无关的稳定入口。都不认识时退
-// 回当前安装进程自己的 bin 目录：nvm 等按版本目录安装的形态由此覆盖（node
-// 与 cron-up 同目录，npm 升级自动跟随），代价是绑定装包时的版本目录——切
-// 换默认版本后要重跑 install 才切过去。
+// 回当前安装进程自己的 bin 目录：nvm 等按版本目录安装的形态由此覆盖。
 export function resolveLauncher(opts = {}) {
   const home = opts.home ?? paths.home;
   const execPath = opts.execPath ?? process.execPath;
@@ -144,27 +138,25 @@ function xmlUnescape(s) {
 }
 
 // 生成 launchd 拉起的启动脚本：ProgramArguments[0] 指向它而非 node。
-// macOS 的后台项目列表（系统设置 → 登录项与扩展 → 允许在后台）按
-// ProgramArguments[0] 的文件名归组条目：直连 node 会与所有 node 系后台服务
-// 合并显示在「Node.js Foundation」（node 的签名者）名下；指向自有脚本则
-// 显示 cron-up-service。脚本把 node 所在 bin 目录放进 PATH 后直接
-// exec cron-up run：npm 升级自动跟随，无需重跑 install（node 与 cron-up
-// 同目录，天然同版本）。
+// macOS 的后台项目列表按 ProgramArguments[0] 的文件名归组条目：直连
+// node 会归到「Node.js Foundation」（node 的签名者）名下；指向自有脚本
+// 则显示 cron-up-service。脚本把 node 所在 bin 目录放进 PATH 后直接
+// exec cron-up run：npm 升级自动跟随，无需重跑 install。
 export function writeServiceScript(launcher) {
   const script = deps.paths.serviceScriptPath;
   fs.mkdirSync(path.dirname(script), { recursive: true });
   const dirs = launcher.pathDirs.map((d) => `"${d}"`).join(':');
   fs.writeFileSync(script,
     '#!/bin/bash\n'
-    + '# 由 cron-up install 生成；重跑 cron-up install --force 覆盖重生成\n'
+    + '# 由 cron-up install 生成；重跑 cron-up install 覆盖重生成\n'
     + `export PATH=${dirs}:"$PATH"\n`
     + 'exec cron-up run\n');
   fs.chmodSync(script, 0o755);
   return script;
 }
 
-// ProgramArguments 单参数（启动脚本路径）。
-export function renderPlist(intervalSeconds, scriptPath) {
+// ProgramArguments 单参数（启动脚本路径）。间隔固定为 INTERVAL_SECONDS。
+export function renderPlist(scriptPath) {
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -182,7 +174,7 @@ export function renderPlist(intervalSeconds, scriptPath) {
 \t<key>StandardOutPath</key>
 \t<string>${xmlEscape(path.join(deps.paths.logDir, 'launchd.out.log'))}</string>
 \t<key>StartInterval</key>
-\t<integer>${intervalSeconds}</integer>
+\t<integer>${INTERVAL_SECONDS}</integer>
 </dict>
 </plist>
 `;
@@ -219,9 +211,7 @@ function scriptPathDirs(scriptPath) {
 }
 
 // 总览页健康检查：launchd 每轮按启动脚本拉起巡检，脚本丢失、被手改或
-// PATH 目录里解析不到 cron-up/node（典型断点：切换默认 Node 版本后忘了
-// 在新版本里装包、版本目录被删）时都会静默拉不起来，这是总览唯一能发现
-// 它的地方。
+// PATH 目录里解析不到 cron-up/node 时都会静默拉不起来。
 export function launcherHealth() {
   if (!fs.existsSync(deps.paths.plistPath)) return null;
   const args = readPlistProgramArgs();
@@ -251,138 +241,60 @@ export function launcherHealth() {
 
 // ---- install / uninstall ----
 
-// install 的可覆盖项（配置键 → 命令行旗标）：--force 缺席时逐项点名「未
-// 生效的参数」。名单直接从解析器的选项表派生——force 不落盘，其余选项都
-// 会写进配置；新加可持久化选项时这里自动跟进，不会静默漏报。
-const IGNORED_INSTALL_FLAGS = Object.keys(SPECS.install.options)
-  .filter((name) => name !== 'force')
-  .map((name) => [thisCamel(name), `--${name}`]);
+// roots 三选一：命令行显式值 > 现有配置 > 默认。现有配置损坏不阻断安
+// 装——install 本身就是最自然的修复动作，回退默认并当面说明。
+function resolveRoots(args) {
+  if (args.roots !== undefined) {
+    const roots = normalizeRoots(args.roots.split(','));
+    if (roots.length === 0) {
+      deps.printErr(`--roots 解析后没有有效目录：${JSON.stringify(args.roots)}`);
+      throw new ExitError(1);
+    }
+    return roots;
+  }
+  if (fs.existsSync(deps.paths.configPath)) {
+    try {
+      return loadConfig(deps.paths.configPath).roots;
+    } catch (e) {
+      deps.print(`提示：现有配置无法解读（${e.message}），本次按默认扫描目录`
+        + '重写；如需其他范围用 cron-up install --roots 指定');
+    }
+  }
+  return normalizeRoots(DEFAULT_CONFIG.roots);
+}
 
 export async function cmdInstall(args) {
-  // --config 在这里只会造成误解：install 写盘、launchd 每轮读取的都是固定
-  // 路径的配置，指定别的路径不改变任何行为——静默忽略等于让人以为装到了
-  // 别处。查询与巡检命令（run/renew/list/总览）才真正支持 --config。
+  // install 写盘、launchd 每轮读取的都是固定路径配置，--config 只会造成
+  // 误解。
   if (args.config !== undefined) {
     throw new ExitError(2, 'install 不支持 --config：配置与 LaunchAgent 固定'
-      + `使用 ${deps.paths.configPath}，如需临时改配置请直接编辑该文件`);
+      + `使用 ${deps.paths.configPath}`);
   }
   fs.mkdirSync(deps.paths.dataDir, { recursive: true });
-  // dataDir 只建不 chmod：本分支可能保留旧配置而不写盘，不搭车改权限。
   ensurePrivateDir(deps.paths.sessionLogDir);
 
-  let cfg;
-  if (fs.existsSync(deps.paths.configPath) && !args.force) {
-    try {
-      cfg = loadConfig(deps.paths.configPath);
-    } catch (e) {
-      // 损坏配置最自然的修复动作就是重跑 install——当面给出 --force 出口，
-      // 而不是只丢下一行解析错误。
-      if (e instanceof ExitError) {
-        throw new ExitError(e.code,
-          `${e.message}\n  丢弃损坏配置重新安装：cron-up install --force`);
-      }
-      throw e;
-    }
-    deps.print(`保留现有配置：${deps.paths.configPath}（需要更新时加 --force）`);
-    // 不带 --force 时配置原样保留，命令行显式给的参数一律不生效：点名说清
-    // 被忽略的是哪些，而不是让用户以为已经改了。
-    const ignored = IGNORED_INSTALL_FLAGS
-      .filter(([k]) => args[k] !== undefined).map(([, flag]) => flag);
-    if (ignored.length > 0) {
-      deps.print(`警告：参数 ${ignored.join('、')} 未生效（现有配置保留）；`
-        + '要更新这些字段请带 --force 重跑，--force 只覆盖显式给出的字段');
-    }
-  } else {
-    // 即使 --force 也从现有配置（全新安装则默认值）起步，只覆盖命令行给
-    // 的字段——否则 --force --interval 600 会悄悄把 roots 重置成默认。
-    cfg = { ...DEFAULT_CONFIG };
-    let inherited = false;
-    if (fs.existsSync(deps.paths.configPath)) {
-      let old = null;
-      try {
-        old = JSON.parse(fs.readFileSync(deps.paths.configPath, 'utf-8'));
-      } catch {
-        // 读不出（损坏 JSON）：没有可继承的旧值。
-      }
-      // 手改成非对象（123、["a"]）：同样没有可继承的旧值，静默按默认走。
-      if (isPlainObject(old)) {
-        // 类型坏的字段不继承（回到默认值）并当面说明，其余照旧——force 不
-        // 该把类型错误写进新配置，也不该因一个字段坏了丢掉其余设置。
-        const errs = configFieldErrors({ ...DEFAULT_CONFIG, ...old });
-        for (const [key, msg] of errs) {
-          delete old[key];
-          deps.print(`提示：旧配置的 ${msg}，未继承，采用默认值`);
-        }
-        cfg = { ...cfg, ...old };
-        inherited = true;
-      }
-    }
-    const overrides = {};
-    if (args.roots !== undefined) {
-      const roots = normalizeRoots(args.roots.split(','));
-      if (roots.length === 0) {
-        deps.printErr(`--roots 解析后没有有效目录：${JSON.stringify(args.roots)}`);
-        throw new ExitError(1);
-      }
-      overrides.roots = roots;
-    }
-    // is not undefined，而非 truthiness：--lead 0（「不要提前量」）是合法
-    // 选择，不能被悄悄丢掉。值域就地拦且必须在 saveConfig 之前：文件继承
-    // 的值已由 loadConfig / configFieldErrors 把关，命令行值只经过整数解
-    // 析——被拒的安装若把非法值写进配置，此后每轮巡检都会以退出码 2 死掉。
-    if (args.interval !== undefined) {
-      if (!isInt(args.interval) || args.interval <= 0) {
-        deps.printErr(`--interval 必须是正整数秒，当前为 ${JSON.stringify(args.interval)}`);
-        throw new ExitError(1);
-      }
-      overrides.intervalSeconds = args.interval;
-    }
-    if (args.lead !== undefined) {
-      if (!isInt(args.lead) || args.lead < 0) {
-        deps.printErr(`--lead 必须是非负整数秒，当前为 ${JSON.stringify(args.lead)}`);
-        throw new ExitError(1);
-      }
-      overrides.leadSeconds = args.lead;
-    }
-    if (args.autoRenew !== undefined) overrides.autoRenew = args.autoRenew;
-    if (args.autoMinId !== undefined) overrides.autoMinId = args.autoMinId;
-    if (args.stampOwner !== undefined) overrides.stampOwner = args.stampOwner;
-    if (args.sessionRetain !== undefined) {
-      if (args.sessionRetain !== 'window' && args.sessionRetain !== 'always') {
-        deps.printErr(`--session-retain 只接受 window 或 always，当前为 ${JSON.stringify(args.sessionRetain)}`);
-        throw new ExitError(1);
-      }
-      overrides.sessionRetain = args.sessionRetain;
-    }
-    cfg = { ...cfg, ...overrides };
-    cfg.roots = normalizeRoots(cfg.roots ?? []);
-    saveConfig(cfg);
-    const updated = Object.keys(overrides).join('、') || '无';
-    const rest = inherited ? '其余继承现有配置' : '全部默认值';
-    deps.print(`已写入配置：${deps.paths.configPath}（更新字段：${updated}，${rest}）`);
-  }
+  // 每次 install 都重写配置（纯化旧版本留下的已废弃键）、脚本与 plist：
+  // 这也是升级 Node、改扫描范围后的统一修复入口。
+  const cfg = { roots: resolveRoots(args) };
+  saveConfig(cfg);
+  deps.print(`已写入配置：${deps.paths.configPath}（扫描目录：${cfg.roots.join('、')}）`);
 
-  // 命令行值的硬校验已在落盘前完成；软问题（提前量过小、目录缺失）只警告。
+  // 软问题（目录不存在）只警告。
   validateConfig(cfg, (m) => deps.print(m));
   if (JSON.stringify(cfg.roots)
       === JSON.stringify(normalizeRoots(DEFAULT_CONFIG.roots))) {
-    // 与 README 安全说明同一句话，在配置落定的这一刻当面再说一遍。默认目
-    // 录清单从 DEFAULT_CONFIG 插值：改默认值时提示不会留在旧清单上。
+    // 与 README 安全说明同一句话，在配置落定的这一刻当面再说一遍。
     deps.print(`提示：未指定 --roots，默认扫描 ${DEFAULT_CONFIG.roots.join('、')}`
       + '（不存在的目录跳过）；今后 clone 进这些容器的仓库也会进入巡检，'
-      + '自动续期会把其中的周期任务永久化。目录布局不同或需收窄时用 '
+      + '其中的周期任务会被自动续期永久化。目录布局不同或需收窄时用 '
       + '--roots 指定（见 README 安全说明）');
   }
 
-  // npm 包没有「安装二进制」这一步：node 与入口文件已由 npm 就位，这里只
-  // 解析它们所在的 bin 目录，写进启动脚本（plist 只指向脚本，让后台项目
-  // 列表显示 cron-up-service 而非 node 的签名者）。
   const launcher = resolveLauncher();
   if (launcher.note) deps.print(`提示：${launcher.note}`);
 
   const script = writeServiceScript(launcher);
-  fs.writeFileSync(deps.paths.plistPath,
-    renderPlist(cfg.intervalSeconds, script));
+  fs.writeFileSync(deps.paths.plistPath, renderPlist(script));
   deps.print(`已写入启动脚本与 LaunchAgent：${script}、${deps.paths.plistPath}`);
 
   deps.launchctl('bootout', `${guiTarget()}/${LABEL}`);
@@ -403,9 +315,40 @@ export async function cmdInstall(args) {
   }
 }
 
+// 遍历全部 tracked 预热：新版嵌套 state、旧版扁平 state、state 丢失时的
+// ps 孤儿（日志位于会话日志目录即可，不区分两代命名）。
+function* allTrackedWarmups() {
+  const handled = new Set();
+  for (const bucket of Object.values(loadState())) {
+    for (const [taskId, ent] of Object.entries(bucket)) {
+      if (deps.trackedAlive(ent)) {
+        handled.add(ent.pid);
+        yield { label: `${ent.ws} 任务 ${taskId}`, ent, orphan: false };
+      }
+    }
+  }
+  for (const ent of loadLegacyEntries()) {
+    if (ent.pid) handled.add(ent.pid);
+    if (deps.trackedAlive(ent)) {
+      yield { label: ent.ws, ent, orphan: false };
+    }
+  }
+  // state 丢失的兜底：没进登记的孤儿从进程表按日志目录认。
+  for (const [pid, procArgs] of deps.listScriptProcesses()) {
+    if (handled.has(pid)) continue;
+    const log = scriptProcLogPath(procArgs);
+    if (log === null
+        || !log.startsWith(`${deps.paths.sessionLogDir}${path.sep}`)) continue;
+    const ent = { pid, procStart: deps.procStartedAt(pid) };
+    if (deps.trackedAlive(ent)) {
+      yield { label: `pid=${pid}（state 已丢失）`, ent, orphan: true };
+    }
+  }
+}
+
 export async function cmdUninstall(args) {
-  // 同 install：uninstall 动的是本机固定的安装产物，--config 只会让人以为
-  // 卸载的是另一套安装（--purge 删的也是真实目录）。
+  // uninstall 动的是本机固定的安装产物，--config 只会让人以为卸载的是
+  // 另一套安装。
   if (args.config !== undefined) {
     throw new ExitError(2, 'uninstall 不支持 --config：卸载操作的是本机固定'
       + `的安装产物（${deps.paths.plistPath} 等）`);
@@ -413,34 +356,15 @@ export async function cmdUninstall(args) {
   const r = deps.launchctl('bootout', `${guiTarget()}/${LABEL}`);
   if (r.status === 0) deps.print('已从 launchd 卸载');
 
-  // 服务没了就没有回收者：默认结束自己拉起的保活会话，不留以 bypass 权限
-  // 空转的孤儿。--keep-sessions 显式保留（例如马上重装）。各会话的停轮询
-  // （SIGTERM→等→SIGKILL）互不依赖，先逐个发信号再并行等齐，N 个会话不
-  // 用串行吃 N 轮等待。
-  if (!args.keepSessions) {
-    const stopping = [];
-    const handled = new Set();
-    for (const [ws, ent] of Object.entries(loadState())) {
-      if (deps.trackedAlive(ent)) {
-        handled.add(ent.pid);
-        deps.print(`正在结束保活会话 ${ws} pid=${ent.pid}`);
-        stopping.push(deps.stopSession(ent));
-      }
-    }
-    // state 丢失时的兜底：没进登记的孤儿会话（卡在提问界面就不会出现在
-    // state 里）从进程表按日志目录精确认领。
-    for (const [pid, procArgs] of deps.listScriptProcesses()) {
-      if (handled.has(pid)) continue; // state 循环已发起，别对同 pid 二次发信号
-      const log = scriptProcLogPath(procArgs);
-      if (log === null
-          || !log.startsWith(`${deps.paths.sessionLogDir}${path.sep}`)) continue;
-      const ent = { pid, procStart: deps.procStartedAt(pid) };
-      if (!deps.trackedAlive(ent)) continue;
-      deps.print(`正在结束保活会话（state 已丢失） pid=${pid}`);
-      stopping.push(deps.stopSession(ent));
-    }
-    await Promise.all(stopping);
+  // 服务没了就没有回收者：默认结束全部预热会话，不留以 bypass 权限空转
+  // 的孤儿。各会话的停轮询（SIGTERM→等→SIGKILL）互不依赖，先逐个发信
+  // 号再并行等齐。
+  const stopping = [];
+  for (const { label, ent } of allTrackedWarmups()) {
+    deps.print(`正在结束预热会话 ${label}`);
+    stopping.push(deps.stopSession(ent));
   }
+  await Promise.all(stopping);
 
   if (fs.existsSync(deps.paths.plistPath)) {
     fs.rmSync(deps.paths.plistPath, { force: true });
@@ -455,8 +379,7 @@ export async function cmdUninstall(args) {
     // npm 管的文件不能手删：命令行本身交给 npm 卸载。
     deps.print('命令行本身请运行 npm uninstall -g cron-up 卸载');
   } else {
-    deps.print('配置与日志已保留（--purge 删除全部产物，--keep-sessions 保留'
-      + '保活会话）');
+    deps.print('配置与日志已保留（--purge 可删除全部产物）');
   }
 }