cron-up 26.10.25 → 26.10.27

package/src/overview.mjs

@@ -5,16 +5,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { deps } from './internals.mjs';
+import { deps, packageVersion } from './internals.mjs';
 import {
   loadConfig,
   loadState,
   validateConfig,
   loadHeartbeat,
+  heartbeatStale,
+  isCooling,
+  cooldownEtaMinutes,
 } from './config.mjs';
-import { packageVersion, TASK_REL } from './paths.mjs';
+import { taskFileExists } from './tasks.mjs';
 import { serviceLine, launcherHealth } from './service.mjs';
-import { HEARTBEAT_STALE_FACTOR } from './constants.mjs';
 import {
   humanDelta,
   clip,
@@ -25,6 +27,7 @@ import {
   elapsedZh,
   fmtMDHM,
   fmtHM,
+  sameMinute,
 } from './display.mjs';
 
 // 总览页任务盘点。返回 [告警, 已在告警里说明冷却的工作区集合, 本轮发现
@@ -47,7 +50,7 @@ function overviewTasks(cfg, cols, consumers, state) {
     if (tasks === null) {
       // 与巡检同一条规则：文件还在却读不出，总览页要把它摆进「需要留
       // 意」，而不是装作这个工作区不存在。
-      if (fs.existsSync(path.join(ws, TASK_REL))) {
+      if (taskFileExists(ws)) {
         alerts.push(`${ws} 的任务文件读不出：其中的定时任务一个都不会执行`);
       }
       continue;
@@ -80,11 +83,10 @@ function overviewTasks(cfg, cols, consumers, state) {
     }
     if (wanted && !consumers.has(ws)) {
       const ent = state[ws] ?? {};
-      const cooldown = ent.cooldownUntil ?? 0;
-      if (cooldown > cur) {
+      if (isCooling(ent, cur)) {
         // 与「下轮会自动启动」互斥：冷却中就是不会启动，两条同现会自相
         // 矛盾，这里合并成一条。
-        const eta = Math.max(0, Math.floor((cooldown - cur) / 60));
+        const eta = cooldownEtaMinutes(ent, cur);
         alerts.push(
           `${ws} 有任务即将执行（或错过待补执行），但保活会话连续失败 `
           + `${ent.fails ?? '?'} 次正处冷却中，约 ${eta} 分钟后才会重试；`
@@ -94,7 +96,7 @@ function overviewTasks(cfg, cols, consumers, state) {
         // 失败计数放在句子中部：总览告警按终端宽度截尾，计数比尾部的
         // 「下轮会自动启动」更该活下来；满额后的去向由「冷却中」那条合并
         // 告警解释，这里不重复。
-        const fails = (state[ws] ?? {}).fails ?? 0;
+        const fails = ent.fails ?? 0;
         const streak = fails > 0 ? `，近期已失败 ${fails} 次` : '';
         alerts.push(`${ws} 有任务即将执行（或错过待补执行）${streak}，`
           + '但当前没有交互会话，下轮巡检会自动启动');
@@ -108,8 +110,7 @@ function overviewTasks(cfg, cols, consumers, state) {
   if (soonest) {
     const [fire, ws, summary, nxt] = soonest;
     // 预计与设定不在同一分钟时，附注 cron 落点，解释两个时间的差。
-    const setTag = (nxt && (fmtHM(fire) !== fmtHM(nxt)
-      || fire.getDate() !== nxt.getDate()))
+    const setTag = (nxt && !sameMinute(fire, nxt))
       ? `，设定 ${fmtHM(nxt)}` : '';
     const line = `最近：${fmtMDHM(fire)}（${humanDelta(fire.getTime() - now.getTime())}`
       + `${setTag}） ${path.basename(ws)} · ${summary}`;
@@ -124,15 +125,14 @@ function overviewTasks(cfg, cols, consumers, state) {
   return [alerts, coolingWarned, discovered];
 }
 
-function overviewSessions(cols, state, suppressCooling = new Set(),
-  discovered = null) {
+function overviewSessions(cols, state, suppressCooling, discovered) {
   const alerts = [];
   const cur = Math.floor(Date.now() / 1000);
   const live = [];
   const cooling = [];
   const dead = [];
   for (const [ws, ent] of Object.entries(state)) {
-    if ((ent.cooldownUntil ?? 0) > cur) cooling.push([ws, ent]);
+    if (isCooling(ent, cur)) cooling.push([ws, ent]);
     else if (deps.trackedAlive(ent)) live.push([ws, ent]);
     else dead.push(ws); // 记录还在、进程已没：带失败计数的保留至老化，其余下轮清理
   }
@@ -151,7 +151,7 @@ function overviewSessions(cols, state, suppressCooling = new Set(),
   }
   for (const [ws, ent] of cooling) {
     if (suppressCooling.has(ws)) continue; // 任务区已给过带上下文的合并告警
-    const eta = Math.max(0, Math.floor(((ent.cooldownUntil ?? 0) - cur) / 60));
+    const eta = cooldownEtaMinutes(ent, cur);
     alerts.push(`${ws} 保活连续失败 ${ent.fails ?? '?'} 次，冷却中，约 ${eta} `
       + '分钟后重试');
   }
@@ -205,7 +205,7 @@ export async function cmdOverview(args) {
   const state = loadState();
   const curOv = Math.floor(Date.now() / 1000);
   const heartbeat = loadHeartbeat();
-  const coolingWarned = new Set();
+  let coolingWarned = new Set();
   let discovered = null;
 
   if (cfgError !== null) {
@@ -221,7 +221,7 @@ export async function cmdOverview(args) {
     const minIdTag = cfg.autoMinId ? '，id 自动改小' : '，id 保持原样';
     const retainTag = cfg.sessionRetain === 'always'
       ? '，会话常驻' : '，会话按执行回收';
-    if (actualIv === null || actualIv === undefined) {
+    if (actualIv == null) {
       deps.print(`巡检：配置为每 ${cfg.intervalSeconds} 秒一轮（服务未加载），`
         + `提前 ${cfg.leadSeconds} 秒启动会话${renewTag}${minIdTag}${retainTag}`);
     } else {
@@ -243,20 +243,19 @@ export async function cmdOverview(args) {
     // 心跳能戳穿。服务未加载（info 为 null）时不告警，服务行已说明未安装。
     if (heartbeat) {
       deps.print(`上次巡检：${elapsedZh(curOv - heartbeat.ranAt)}前`);
-      if (info
-          && curOv - heartbeat.ranAt
-            > cfg.intervalSeconds * HEARTBEAT_STALE_FACTOR) {
+      if (info && heartbeatStale(heartbeat, cfg.intervalSeconds, curOv)) {
         alerts.push(`巡检已沉默 ${elapsedZh(curOv - heartbeat.ranAt)}：launchd `
           + `显示服务已加载（配置每 ${cfg.intervalSeconds} 秒一轮），但最近没有`
           + '成功跑完的轮次，启动链可能已失效；请运行 cron-up logs 查看巡检'
           + '日志，必要时重跑 cron-up install');
       }
     }
-    alerts.push(...validateConfig(cfg, () => {}));
+    alerts.push(...validateConfig(cfg));
     deps.print('');
-    const [taskAlerts, cooled, found] = overviewTasks(cfg, cols, consumers, state);
+    const [taskAlerts, coolingWarnedNow, found] = overviewTasks(
+      cfg, cols, consumers, state);
     alerts.push(...taskAlerts);
-    for (const w of cooled) coolingWarned.add(w);
+    coolingWarned = coolingWarnedNow;
     discovered = found;
   }
 

package/src/paths.mjs

@@ -3,8 +3,6 @@
 
 import os from 'node:os';
 import path from 'node:path';
-import fs from 'node:fs';
-import { fileURLToPath } from 'node:url';
 
 export const LABEL = 'local.cron-up';
 
@@ -12,9 +10,42 @@ const HOME = os.homedir();
 // 被预热的 agent 工作区里，定时任务文件的相对路径。
 export const TASK_REL = path.join('.claude', 'scheduled_tasks.json');
 
+// 派生 getter 只写这一份：生产 paths 与测试重定向用的 tmpPaths
+// （test-support/helpers.mjs）共用同一工厂，派生路径改布局不会出现两处各
+// 改一半。
+export function makePaths({ home, dataDir, logDir, plistPath, sessionDir }) {
+  return {
+    home,
+    dataDir,
+    logDir,
+    plistPath,
+    sessionDir,
+
+    get sessionLogDir() {
+      return path.join(this.logDir, 'sessions');
+    },
+    get configPath() {
+      return path.join(this.dataDir, 'config.json');
+    },
+    get statePath() {
+      return path.join(this.dataDir, 'state.json');
+    },
+    // 巡检心跳：每轮成功跑完写一次，总览页据此判断上次巡检多久前。
+    get heartbeatPath() {
+      return path.join(this.dataDir, 'heartbeat');
+    },
+    // launchd 拉起的启动脚本。ProgramArguments[0] 直接指向它而非 node：
+    // macOS 后台项目列表按可执行文件名显示条目，直连 node 会归到「Node.js
+    // Foundation」名下（node 的签名者），自有脚本则显示脚本自己的名字。
+    get serviceScriptPath() {
+      return path.join(this.dataDir, 'cron-up-service');
+    },
+  };
+}
+
 // 路径对象整体可替换（deps.paths）：测试把产物目录重定向到 tmp，不碰真实
 // HOME。getter 让 sessionLogDir/configPath/statePath 跟随替换后的前缀。
-export const paths = {
+export const paths = makePaths({
   home: HOME,
   // 数据目录用 XDG 风格的 ~/.local/share/cron-up：config、state 与启动脚本
   // 集中一处，purge 一删全清。
@@ -22,35 +53,4 @@ export const paths = {
   logDir: path.join(HOME, 'Library', 'Logs', 'cron-up'),
   plistPath: path.join(HOME, 'Library', 'LaunchAgents', `${LABEL}.plist`),
   sessionDir: path.join(HOME, '.claude', 'sessions'),
-
-  get sessionLogDir() {
-    return path.join(this.logDir, 'sessions');
-  },
-  get configPath() {
-    return path.join(this.dataDir, 'config.json');
-  },
-  get statePath() {
-    return path.join(this.dataDir, 'state.json');
-  },
-  // 巡检心跳：每轮成功跑完写一次，总览页据此判断上次巡检多久前。
-  get heartbeatPath() {
-    return path.join(this.dataDir, 'heartbeat');
-  },
-  // launchd 拉起的启动脚本。ProgramArguments[0] 直接指向它而非 node：
-  // macOS 后台项目列表按可执行文件名显示条目，直连 node 会归到「Node.js
-  // Foundation」名下（node 的签名者），自有脚本则显示脚本自己的名字。
-  get serviceScriptPath() {
-    return path.join(this.dataDir, 'cron-up-service');
-  },
-};
-
-// 版本号读 package.json（用 fs 读而非 JSON import attribute，避免对 Node
-// 版本实验特性的依赖）；读不到返回 null，总览页降级显示。
-export function packageVersion() {
-  try {
-    const pkg = fileURLToPath(new URL('../package.json', import.meta.url));
-    return JSON.parse(fs.readFileSync(pkg, 'utf-8')).version ?? null;
-  } catch {
-    return null;
-  }
-}
+});

package/src/patrol.mjs

@@ -5,7 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { deps } from './internals.mjs';
+import { deps, packageVersion } from './internals.mjs';
 import {
   FAIL_LIMIT,
   COOLDOWN_SECONDS,
@@ -24,16 +24,23 @@ import {
   saveState,
   loadHeartbeat,
   saveHeartbeat,
+  heartbeatStale,
+  isCooling,
 } from './config.mjs';
-import { maintainWorkspace, TaskFileChanged } from './tasks.mjs';
+import {
+  maintainWorkspace,
+  TaskFileChanged,
+  taskFileExists,
+} from './tasks.mjs';
 import { taskWanted, parseCronOrNone, wanted } from './cron.mjs';
 import {
   sessionLogPath,
   sessionLogIdleSeconds,
   scriptProcLogPath,
+  rotateOnce,
 } from './sessions.mjs';
-import { TASK_REL, packageVersion } from './paths.mjs';
-import { elapsedZh } from './display.mjs';
+import { TASK_REL } from './paths.mjs';
+import { elapsedZh, pad2 } from './display.mjs';
 
 // 事件类型 → 轮末汇总里的中文标签。patrolWorkspace 与 cmdRun 往同一个
 // stats 计数器里记账，平静轮也会打出「本轮无动作」。
@@ -56,10 +63,9 @@ function bump(stats, kind) {
 
 export function log(msg) {
   const d = new Date();
-  const p = (n) => String(n).padStart(2, '0');
   deps.print(
-    `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} `
-    + `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())} ${msg}`,
+    `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} `
+    + `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())} ${msg}`,
   );
 }
 
@@ -124,7 +130,7 @@ export function acquireRunLock() {
   return null;
 }
 
-export function releaseLock(handle) {
+function releaseLock(handle) {
   if (!handle?.lockPath) return;
   try {
     fs.unlinkSync(handle.lockPath);
@@ -137,15 +143,14 @@ export function releaseLock(handle) {
 
 export function rotatePatrolLogs() {
   // launchd 按路径每次重开文件，轮初改名是安全的：本轮 fd 继续写改名后
-  // 的 inode，下轮打开新文件。
+  // 的 inode，下轮打开新文件。超阈值才轮转，与会话日志的「无条件保留一
+  // 代」共用 rotateOnce 的 rm+rename 顺序。
   for (const name of ['launchd.out.log', 'launchd.err.log']) {
     const file = path.join(deps.paths.logDir, name);
     try {
       if (fs.existsSync(file)
           && fs.statSync(file).size > PATROL_LOG_ROTATE_BYTES) {
-        const old = `${file}.1`;
-        fs.rmSync(old, { force: true });
-        fs.renameSync(file, old);
+        rotateOnce(file);
       }
     } catch {
       // 轮转失败不阻断巡检。
@@ -154,7 +159,11 @@ export function rotatePatrolLogs() {
 }
 
 // 下次「需要会话在场」的时刻（ms）：各任务下次触发的最小值；有错过待补
-// 执行的一次性任务时视为立刻需要。窗口内无安排返回 Infinity。
+// 执行的一次性任务时视为立刻需要。窗口内无安排返回 Infinity。锚点刻意取
+// cron 裸落点而非 nextDelivery 的抖动后投递时刻：落点总不晚于投递时刻，
+// 按落点算余量更小、回收更保守，是安全方向；真正的重拉闸门是下面的
+// wanted(leadMs)，margin 只需保住新会话登记。若改用 fire，落点后、投递
+// 前的整段延迟窗内都不会回收，回收频率被悄悄改变。
 function needHorizonMs(tasks, now) {
   let horizon = Infinity;
   for (const t of tasks) {
@@ -168,9 +177,11 @@ function needHorizonMs(tasks, now) {
 }
 
 // 保证一个工作区里有一个健康的消费者会话。原地修改 state。retain 来自
-// cfg.sessionRetain，直接调用（测试）默认 'always' 保持旧语义。
+// cfg.sessionRetain，直接调用（测试）默认 'always' 保持旧语义。scriptProcs
+// 是进程表快照或 null：null 时仅在需要认领孤儿（state 丢失的兜底分支）当
+// 下才拍快照，平静轮不付全量 ps 的代价。
 export async function patrolWorkspace(
-  ws, state, now, leadMs, cur, consumers, scriptProcs = [],
+  ws, state, now, leadMs, cur, consumers, scriptProcs = null,
   retain = 'always', stats = null,
 ) {
   const tasks = deps.readTasks(ws);
@@ -186,7 +197,7 @@ export async function patrolWorkspace(
     // 任务文件读不出：证据太弱，绝不动会话；但不能不吭声——文件还在却读
     // 不出意味着这个目录的定时任务一个都不会执行。文件已消失则是正常竞
     // 态（一次性任务执行完被删），不报。
-    if (fs.existsSync(path.join(ws, TASK_REL))) {
+    if (taskFileExists(ws)) {
       note('warn', `任务文件读不出 ${ws}：格式损坏或不可读，本轮跳过该目录，`
         + `其中 ${TASK_REL} 里的定时任务都不会执行`);
     }
@@ -206,24 +217,28 @@ export async function patrolWorkspace(
     return;
   }
 
+  // 结束本代会话的完整收尾：停掉 → 摘 state → 重扫消费者。换代与 window
+  // 回收是同一个动作，差别只在触发条件与文案；消费者快照拍于轮初，刚结束
+  // 的这代可能正是快照里的消费者，不重扫会让陈旧登记挡住下面的重拉。
+  let mineAlive = deps.trackedAlive(ent);
+  const retire = async (kind, msg) => {
+    await deps.stopSession(ent);
+    note(kind, msg);
+    delete state[ws];
+    ent = null;
+    mineAlive = false;
+    consumers = (await deps.scanSessions())[0];
+  };
+
   // 换代：超龄且日志静默（无任务在执行的证据）的会话主动结束，需要时下
   // 文自然重拉。换代是维护，不计失败。
-  let mineAlive = deps.trackedAlive(ent);
   if (ent !== null && mineAlive) {
     const age = cur - (ent.startedAt ?? cur);
     if (age > SESSION_MAX_AGE_SECONDS
         && sessionLogIdleSeconds(
           ent.log || sessionLogPath(ws), cur) > SESSION_IDLE_SECONDS) {
-      await deps.stopSession(ent);
-      note('ageout', `换代 ${ws} pid=${ent.pid}：会话已连续运行 `
+      await retire('ageout', `换代 ${ws} pid=${ent.pid}：会话已连续运行 `
         + `${Math.floor(age / 86400)} 天且近期无输出，结束后按需重拉`);
-      delete state[ws];
-      ent = null;
-      mineAlive = false;
-      // 消费者快照拍于轮初，被换代的这代可能正是快照里的消费者：重扫一
-      // 次，别让陈旧登记挡住下面的重拉。
-      const [fresh] = await deps.scanSessions();
-      consumers = fresh;
     }
   }
 
@@ -243,17 +258,9 @@ export async function patrolWorkspace(
         > SESSION_RECYCLE_IDLE_SECONDS
       && needHorizonMs(tasks, now) - now.getTime()
         > SESSION_FIRE_MARGIN_SECONDS * 1000) {
-    const pid = ent.pid;
-    await deps.stopSession(ent);
-    note('recycle', `回收 ${ws} pid=${pid}：本代任务已执行完毕且界面静默，`
-      + '结束会话，下次需要时重拉');
-    delete state[ws];
-    ent = null;
-    mineAlive = false;
-    // 同上：快照里的消费者可能正是刚结束的这代。用户自己的会话若在场，
-    // 重扫依旧看见，不会在同目录双开。
-    const [fresh] = await deps.scanSessions();
-    consumers = fresh;
+    // 用户自己的会话若在场，retire 的重扫依旧看见，不会在同目录双开。
+    await retire('recycle', `回收 ${ws} pid=${ent.pid}：本代任务已执行完毕且`
+      + '界面静默，结束会话，下次需要时重拉');
   }
 
   // 登记成功即健康证据，当场清零失败计数，不等「有任务想要会话」的轮
@@ -263,17 +270,16 @@ export async function patrolWorkspace(
     ent.fails = 0;
   }
 
-  if (!tasks.some((t) => taskWanted(t, now, leadMs))) return;
+  // 任务正在被消费。可能是我们的预热会话（已登记——上面的健康清零已覆
+  // 盖），也可能是用户的交互会话——后者放手：不在这里删死条目，失败计数
+  // 要跨任务窗口存活（用户会话在场不证明 launchd 拉起的环境健康），由轮
+  // 末 kept 过滤统一处理。先于 wanted 判定返回：有消费者在场的平稳态不必
+  // 为整组任务跑一遍 cron 求值。
+  if (consumers.has(ws)) return;
 
-  const cooling = Boolean(ent && (ent.cooldownUntil ?? 0) > cur);
+  if (!tasks.some((t) => taskWanted(t, now, leadMs))) return;
 
-  if (consumers.has(ws)) {
-    // 任务正在被消费。可能是我们的预热会话（已登记——上面的健康清零已覆
-    // 盖），也可能是用户的交互会话——后者放手：不在这里删死条目，失败计数
-    // 要跨任务窗口存活（用户会话在场不证明 launchd 拉起的环境健康），由轮
-    // 末 kept 过滤统一处理。
-    return;
-  }
+  const cooling = isCooling(ent, cur);
 
   // 活着但没有消费。健康只在真实启动所需的时间内成立；超时就是卡在无人
   // 应答的提问界面，永不登记——退休它并推进失败计数。
@@ -316,7 +322,7 @@ export async function patrolWorkspace(
     // 不会出现在登记里，直接再拉就是同目录双开。认回孤儿，重新纳入正常
     // 生命周期（卡死的 3 分钟后照退休处理）。
     const logPath = sessionLogPath(ws);
-    for (const [procPid, procArgs] of scriptProcs) {
+    for (const [procPid, procArgs] of scriptProcs ?? deps.listScriptProcesses()) {
       // alive 复核：快照拍于本轮开头，可能含着刚被换代/回收杀掉的 pid——
       // 把死人认回来会白记一次失败。
       if (scriptProcLogPath(procArgs) === logPath && deps.alive(procPid)) {
@@ -367,13 +373,22 @@ export async function cmdRun(args) {
     return false;
   }
   // 包一层 stopSession 记下本轮主动结束的 pid：轮末凭它区分「我们回收的」
-  // 与「会话自行退出/被外部杀掉的」，后者以前是无声丢失。finally 还原。
+  // 与「会话自行退出/被外部杀掉的」，后者以前是无声丢失。同样包一层
+  // procStartedAt：同一 pid 的 lstart 一轮内不会变，而轮初分区、各工作区
+  // 的 trackedAlive、轮末复核与 kept 过滤都会查指纹，缓存后每个 pid 只
+  // spawn 一次 ps。finally 一并还原。
   const prevStopSession = deps.stopSession;
   const stoppedPids = new Set();
   deps.stopSession = async (ent) => {
     if (ent?.pid) stoppedPids.add(ent.pid);
     return prevStopSession(ent);
   };
+  const prevProcStartedAt = deps.procStartedAt;
+  const lstartCache = new Map();
+  deps.procStartedAt = (pid) => {
+    if (!lstartCache.has(pid)) lstartCache.set(pid, prevProcStartedAt(pid));
+    return lstartCache.get(pid);
+  };
   try {
     const startedAtMs = Date.now();
     const stats = {};
@@ -388,8 +403,7 @@ export async function cmdRun(args) {
     // 时日志会一片寂静，无法和「平安无事」区分。上轮心跳过老说明中间漏
     // 轮——休眠期间错过的 StartInterval，launchd 醒来只补跑一轮。
     const hb = loadHeartbeat();
-    if (hb !== null
-        && cur - hb.ranAt > cfg.intervalSeconds * HEARTBEAT_STALE_FACTOR) {
+    if (heartbeatStale(hb, cfg.intervalSeconds, cur)) {
       bump(stats, 'warn');
       deps.log(`距上次巡检已 ${elapsedZh(cur - hb.ranAt)}，超过 `
         + `${HEARTBEAT_STALE_FACTOR} 个轮次间隔（${cfg.intervalSeconds} 秒），`
@@ -404,27 +418,29 @@ export async function cmdRun(args) {
     }
 
     // 轮初拍一份「上轮末仍相信活着」的会话快照（entry 复制，本轮原地改写
-    // 不影响），分成「轮初已没气」与「轮初还活着」两组。不能只收此刻
+    // 不影响），一遍分成「轮初已没气」与「轮初还活着」两组。不能只收此刻
     // kill -0 成功的——两轮之间崩溃正是最典型的被动死亡，本轮开始时它早
     // 已没气；带 deadSince 的是上轮已报过死亡的旧条目，跳过以免每轮重复报。
-    const prevTracked = Object.entries(state)
-      .filter(([, ent]) => ent.pid && !ent.deadSince)
-      .map(([ws, ent]) => [ws, { ...ent }]);
-    const prevDead = prevTracked.filter(([, ent]) => !deps.trackedAlive(ent));
-    const prevAlive = prevTracked.filter(([, ent]) => deps.trackedAlive(ent));
+    const prevDead = [];
+    const prevAlive = [];
+    for (const [ws, ent] of Object.entries(state)) {
+      if (!ent.pid || ent.deadSince) continue;
+      const copy = [ws, { ...ent }];
+      (deps.trackedAlive(copy[1]) ? prevAlive : prevDead).push(copy);
+    }
     const exitLine = (ws, old) => `会话退出 ${ws} pid=${old.pid}：非巡检主动结束`
       + `（已存活 ${elapsedZh(cur - (old.startedAt ?? cur))}），可能自行退出或`
       + '被外部终止；若反复出现请用 cron-up logs '
       + `${path.basename(ws)} 排查启动过程`;
 
     // 登记每轮只读一次：否则每个工作区都要 readdir + ps 一遍，自检也归
-    // 属这里。
+    // 属这里。进程表快照不在这里拍：只有孤儿认领分支需要，按需现拍（见
+    // patrolWorkspace 的 scriptProcs 形参）。
     const [consumers, registryAlert] = await deps.scanSessions();
     if (registryAlert) {
       bump(stats, 'warn');
       deps.log(`告警：${registryAlert}`);
     }
-    const scriptProcs = deps.listScriptProcesses();
 
     // 轮间死亡在进入工作区循环前先报：随后该工作区若需要会话会打印重拉，
     // 日志时间线就是「退出 → 重拉」，而不是反过来。
@@ -444,7 +460,7 @@ export async function cmdRun(args) {
           const { renewed, minified } = maintainWorkspace(taskfile, {
             renew: cfg.autoRenew,
             minify: cfg.autoMinId,
-          }) ?? { renewed: null, minified: null };
+          }) ?? {};
           if (renewed) {
             deps.log(`已续期 ${ws}：${renewed} 个周期任务标记为 permanent，`
               + '不再受 7 天过期限制');
@@ -467,7 +483,7 @@ export async function cmdRun(args) {
       }
       try {
         await patrolWorkspace(
-          ws, state, now, leadMs, cur, consumers, scriptProcs,
+          ws, state, now, leadMs, cur, consumers, null,
           cfg.sessionRetain, stats);
       } catch (e) {
         bump(stats, 'error');
@@ -494,7 +510,7 @@ export async function cmdRun(args) {
     const kept = Object.fromEntries(
       Object.entries(state).filter(([, ent]) => {
         if (deps.trackedAlive(ent)) return true;
-        if ((ent.cooldownUntil ?? 0) > cur) return true;
+        if (isCooling(ent, cur)) return true;
         if ((ent.fails ?? 0) > 0) {
           ent.deadSince ??= cur;
           return cur - ent.deadSince < FAIL_TTL_SECONDS;
@@ -525,6 +541,7 @@ export async function cmdRun(args) {
     return true;
   } finally {
     deps.stopSession = prevStopSession;
+    deps.procStartedAt = prevProcStartedAt;
     releaseLock(lock);
   }
 }

package/src/registry.mjs

@@ -6,9 +6,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { deps } from './internals.mjs';
-import { lenientInt } from './config.mjs';
-import { PID_T_MAX } from './constants.mjs';
+import { deps, isPlainObject } from './internals.mjs';
+import { parsePid } from './config.mjs';
+import { lexReal } from './tasks.mjs';
 
 // npm/bun 形态的 claude 是解释器跑的脚本：进程 comm 是 node/bun/deno，
 // 只能从完整命令行认 claude 入口（bin/claude 符号链接或包目录 cli.js）。
@@ -41,7 +41,7 @@ export function pidIsClaude(pid) {
 // 读一个登记文件；读不出返回 null。Claude Code 会就地（非原子）重写登
 // 记，读写相撞读到半个 JSON 时睡一拍重读一次；文件消失不是竞态，不重
 // 试。
-export async function readSessionFile(file) {
+async function readSessionFile(file) {
   for (let attempt = 0; attempt < 2; attempt++) {
     let text;
     try {
@@ -60,16 +60,6 @@ export async function readSessionFile(file) {
   return null;
 }
 
-// 宽容版 realpath：fs.realpathSync 对不存在的路径抛 ENOENT，这里失败时退
-// 回词法绝对路径（调用方已保证输入是绝对路径）。
-function lexReal(p) {
-  try {
-    return fs.realpathSync(p);
-  } catch {
-    return path.resolve(p);
-  }
-}
-
 // 返回 [拥有活消费者会话的工作区集合, 告警字符串|null]。
 export async function scanSessions() {
   let files = [];
@@ -83,7 +73,7 @@ export async function scanSessions() {
   const interactive = [];
   for (const f of files) {
     const s = await readSessionFile(f);
-    if (s && typeof s === 'object' && s.kind === 'interactive') {
+    if (isPlainObject(s) && s.kind === 'interactive') {
       interactive.push(s);
     }
   }
@@ -99,17 +89,11 @@ export async function scanSessions() {
     // 数都读不出活进程。这段代码在 per-workspace 保护圈之外，一个畸形登
     // 记抛出去就是整轮巡检失败；缺失时兜底 -1 还会被 kill(-1,0)（对全
     // 部进程的权限探测，不是存在性检查）误读为存活。
-    let pid;
-    try {
-      pid = lenientInt(s.pid);
-    } catch {
+    const pid = parsePid(s.pid);
+    if (pid === null) {
       suspect += 1; // 正常登记必带可解析 pid：缺失/变质即字段漂移
       continue;
     }
-    if (!(pid > 0 && pid <= PID_T_MAX)) {
-      suspect += 1;
-      continue;
-    }
     if (!deps.alive(pid)) continue; // 陈旧登记（崩溃留下）：正常，不计
     if (!commCache.has(pid)) {
       commCache.set(pid, deps.pidIsClaude(pid)); // ps 调用按 pid 缓存
@@ -120,11 +104,8 @@ export async function scanSessions() {
       // 热被静默跳过。
       const cwd = s.cwd;
       if (typeof cwd === 'string' && path.isAbsolute(cwd)) {
-        const real = lexReal(cwd);
-        if (real) {
-          consumers.add(real);
-          continue;
-        }
+        consumers.add(lexReal(cwd));
+        continue;
       }
       suspect += 1; // 活着的 claude 却没有可用 cwd：cwd 字段漂移
     } else {