cron-up 26.10.31 → 26.10.33

package/src/patrol.mjs

@@ -1,18 +1,23 @@
-// 一轮巡检：发现工作区 → 自动维护任务文件（续期/改 id/盖印）→ 保证每个
+// 一轮巡检：发现工作区 → 自动维护任务文件（续期/盖印）→ 保证每个
 // 「创建者会话已死且处于预热窗口」的任务都有一个只属于它的健康会话。
-// 这是 launchd 的入口（每 N 秒被拉起一次，跑完即退）。状态机覆盖：认亲、
-// 卡死退休、失败冷却、执行完回收、resume 接管脱离、孤儿认领、任务消失回
-// 收、旧版目录级 state 迁移。
+// 这是 launchd 的入口（每 N 秒被拉起一次，跑完即退）。本轮新拉起的会话
+// 在所有工作区决策完后轮内等待登记（至多 WARMUP_WAIT_MS），认亲同一轮
+// 补盖归属印；等不到的留给跨轮宽限，绝不当轮判死。状态机还覆盖：卡死
+// 退休、失败冷却、执行完回收、resume 接管脱离、孤儿认领、任务消失回收、
+// 旧版目录级 state 迁移。
 
 import fs from 'node:fs';
 import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 
-import { deps, packageVersion } from './internals.mjs';
+import { deps, packageVersion, isPlainObject } from './internals.mjs';
 import {
   FAIL_LIMIT,
   COOLDOWN_SECONDS,
   FAIL_TTL_SECONDS,
   WARMUP_GRACE_SECONDS,
+  WARMUP_WAIT_MS,
+  WARMUP_POLL_MS,
   SESSION_RECYCLE_IDLE_SECONDS,
   SESSION_RECYCLE_MARGIN_SECONDS,
   PATROL_LOG_ROTATE_BYTES,
@@ -29,15 +34,15 @@ import {
   saveHeartbeat,
   heartbeatStale,
   isCooling,
+  parsePid,
 } from './config.mjs';
 import {
   maintainWorkspace,
   TaskFileChanged,
   taskFileExists,
-  taskKey,
-  taskSig,
+  groupTasksByKey,
 } from './tasks.mjs';
-import { taskWanted, parseCronOrNone, wanted } from './cron.mjs';
+import { taskWanted, parseCronOrNone, wantedNow } from './cron.mjs';
 import {
   sessionLogPath,
   sessionLogIdleSeconds,
@@ -75,10 +80,11 @@ export function log(msg) {
 }
 
 // ---- 巡检互斥锁 ----
-// flock 的替代：O_EXCL 创建 + 持锁 pid。内核不会在持有者死亡时自动释放
-// 这种锁，所以抢锁失败要读 pid 判活，死锁/半成品文件按 stale 清理后有
-// 限重试。对 300 秒一轮的单机 launchd，残余的 pid 复用窗口最坏只跳过一
-// 轮，可接受。
+// flock 的替代：O_EXCL 创建 + 完整 JSON 锁记录。token 防止释放/清理时误删
+// 已被别人替换的文件，pid + 进程启动指纹区分 pid 复用。创建后写记录有极短
+// 空窗，所以无效/空文件要等初始化宽限过后才能按 stale 清理。
+
+const RUN_LOCK_INIT_GRACE_MS = 10_000;
 
 function tryCreateLock(lockPath) {
   try {
@@ -89,59 +95,137 @@ function tryCreateLock(lockPath) {
   }
 }
 
-function readLockPid(lockPath) {
-  let text;
+// 文本与 stat 一起作为删除前的比对快照：除了内容，inode/mtime 也能识别
+// 「删掉旧锁后又恰好建了同样内容的新锁」。
+function readLockSnapshot(lockPath) {
+  try {
+    return {
+      text: fs.readFileSync(lockPath, 'utf-8'),
+      stat: fs.statSync(lockPath, { bigint: true }),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function parseLockRecord(snapshot) {
+  let record;
   try {
-    text = fs.readFileSync(lockPath, 'utf-8').trim();
+    record = JSON.parse(snapshot.text);
   } catch {
     return null;
   }
-  return /^\d+$/.test(text) ? parseInt(text, 10) : null;
+  if (!isPlainObject(record)
+      || !Number.isSafeInteger(record.pid) || record.pid <= 0
+      || typeof record.token !== 'string' || record.token === '') {
+    return null;
+  }
+  return record;
+}
+
+function sameLockSnapshot(a, b) {
+  return a.text === b.text
+    && a.stat.ino === b.stat.ino
+    && a.stat.mtimeNs === b.stat.mtimeNs
+    && a.stat.size === b.stat.size;
+}
+
+// 只能删除读取时看到的那个文件。比对失败说明别人释放/重建过，宁可本轮不
+// 抢锁，也绝不能把新持有者的锁 unlink 掉。
+function removeLockSnapshot(lockPath, snapshot) {
+  const latest = readLockSnapshot(lockPath);
+  if (latest === null || !sameLockSnapshot(snapshot, latest)) return false;
+  try {
+    fs.unlinkSync(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function staleLock(snapshot) {
+  const record = parseLockRecord(snapshot);
+  if (record === null) {
+    // 旧版锁只有十进制 pid。升级交错时它可能仍属于活巡检；没有指纹可核，
+    // 因此活着就保守保留，明确死亡才允许清理。
+    const legacyPid = parsePid(snapshot.text);
+    if (legacyPid !== null) {
+      try {
+        return !deps.alive(legacyPid);
+      } catch {
+        return false;
+      }
+    }
+    // 包含 O_EXCL 成功后、JSON 写完前的空文件。mtime 新于宽限的一律保留。
+    return Date.now() - Number(snapshot.stat.mtimeMs) >= RUN_LOCK_INIT_GRACE_MS;
+  }
+  let living;
+  try {
+    living = deps.alive(record.pid);
+  } catch {
+    return false; // 活判读不出时保守保留。
+  }
+  if (!living) return true;
+  // 活 pid 但缺记录指纹，或当前指纹读不出：都无法排除锁主仍在，不能删。
+  if (typeof record.procStart !== 'string' || record.procStart === '') return false;
+  let currentStart;
+  try {
+    currentStart = deps.procStartedAt(record.pid);
+  } catch {
+    return false;
+  }
+  if (!currentStart) return false;
+  return currentStart !== record.procStart;
 }
 
 export function acquireRunLock() {
   fs.mkdirSync(deps.paths.dataDir, { recursive: true });
   const lockPath = path.join(deps.paths.dataDir, 'run.lock');
+  let procStart;
+  try {
+    procStart = deps.procStartedAt(process.pid);
+  } catch (e) {
+    throw new Error('读取当前进程启动指纹失败，不能安全创建巡检锁：'
+      + `${e?.message ?? e}`);
+  }
+  // 无指纹锁一旦被崩溃留下，pid 复用时永远无法安全清理；宁可本轮响亮
+  // 失败，也不制造这种永久自锁。
+  if (!procStart) {
+    throw new Error('未读到当前进程启动指纹，不能安全创建巡检锁；'
+      + '请检查 /bin/ps 后重试');
+  }
+  const token = randomUUID();
+  const text = `${JSON.stringify({
+    pid: process.pid,
+    procStart,
+    token,
+  })}\n`;
   for (let attempt = 0; attempt < 3; attempt++) {
     const fd = tryCreateLock(lockPath);
     if (fd !== null) {
       try {
-        fs.writeFileSync(fd, `${process.pid}\n`);
+        fs.writeFileSync(fd, text);
         fs.fsyncSync(fd);
       } finally {
         fs.closeSync(fd);
       }
-      return { lockPath };
-    }
-    const holder = readLockPid(lockPath);
-    if (holder !== null) {
-      let live = false;
-      try {
-        process.kill(holder, 0);
-        live = true;
-      } catch (e) {
-        // EPERM：进程存在但不是我们的——当作活锁，不删别人的锁。
-        live = e.code === 'EPERM';
-      }
-      if (live) return null;
-    }
-    // 持有者已死 / 空文件 / pid 损坏：当作 stale 清掉重试。
-    try {
-      fs.unlinkSync(lockPath);
-    } catch {
-      return null; // 别人抢先重建了锁
+      return { lockPath, token };
     }
+    const snapshot = readLockSnapshot(lockPath);
+    if (snapshot === null) continue; // 持有者恰好释放，直接重试创建。
+    if (!staleLock(snapshot)) return null;
+    if (!removeLockSnapshot(lockPath, snapshot)) return null;
   }
   return null;
 }
 
-function releaseLock(handle) {
-  if (!handle?.lockPath) return;
-  try {
-    fs.unlinkSync(handle.lockPath);
-  } catch {
-    // 锁文件已不在即达成目的。
-  }
+export function releaseRunLock(handle) {
+  if (!handle?.lockPath || typeof handle.token !== 'string') return;
+  const snapshot = readLockSnapshot(handle.lockPath);
+  if (snapshot === null) return;
+  const record = parseLockRecord(snapshot);
+  if (record?.token !== handle.token) return;
+  removeLockSnapshot(handle.lockPath, snapshot);
 }
 
 // ---- 日志轮转 ----
@@ -164,13 +248,14 @@ export function rotatePatrolLogs() {
 }
 
 // 该任务下次「需要会话在场」的时刻（ms）：现在已在窗口（落点尾窗、一次
-// 性错过待补）视为立刻需要；窗口外取 cron 裸落点（刻意不取抖动后投递时
-// 刻：落点更早，按落点算余量更小、回收更保守，是安全方向）。cron 无效
-// 返回 Infinity，永不回收。
+// 性错过待补）视为立刻需要；窗口外取 cron 裸落点（周期任务投递晚于落
+// 点，按落点算余量更小、回收更保守；一次性网格落点反而提前至多 90 秒投
+// 递，这段提前量由回收余量 SESSION_FIRE_MARGIN_SECONDS 罩住）。cron
+// 无效返回 Infinity，永不回收。
 function taskNeedMs(task, now) {
   const cron = parseCronOrNone(task?.cron);
   if (cron === null) return Infinity;
-  if (wanted(cron, task, now, 0)) return now.getTime();
+  if (wantedNow(cron, task, now)) return now.getTime();
   return cron.nextAfter(now)?.getTime() ?? Infinity;
 }
 
@@ -179,12 +264,53 @@ function entryClaimed(ent) {
   return Boolean(ent?.sessionId && ent.claudeProcStart);
 }
 
-// 保证一个工作区里每个死主窗口任务都有专属预热，并完成本文件的续期/改
-// id/盖印维护。bucket 是 state[ws]（原地修改）。scriptProcsRef 是全轮共
-// 享的进程表快照容器（{value: 数组|null}），只在孤儿认领时拍一次。
+// 沿登记快照把一个活 script pid 认成登记里的 claude 孙进程：认到则回填
+// 身份、清零失败计数并返回登记详情，否则返回 null。轮初认亲与轮内等待
+// 认亲共用这唯一一份回填。
+function claimEntry(ent, details, ws) {
+  const d = deps.claimWarm(details, ws, ent.pid);
+  if (!d) return null;
+  ent.fails = 0;
+  if (d.sessionId && d.procStart) {
+    ent.claudePid = d.pid;
+    ent.sessionId = d.sessionId;
+    ent.claudeProcStart = d.procStart;
+  }
+  return d;
+}
+
+// 盖印目标三字段（tasks.mjs maintainWorkspace reown 映射的值形状）。
+const reownTarget = (ent) => ({
+  sessionId: ent.sessionId,
+  pid: ent.claudePid,
+  procStart: ent.claudeProcStart,
+});
+
+// 过户后的统一计数与日志（巡逻第三步与等待期补盖共用）。
+function noteReowned(ws, count, stats) {
+  bump(stats, 'reown');
+  deps.log(`已过户 ${ws}：${count} 个窗口内任务的归属改到各自的`
+    + '预热会话，这些任务将只在对应会话触发');
+}
+
+// 失败顶限时的统一冷却迁移：置冷却截止、计数、日志。cooldownUntil 之外
+// 的条目形状由各调用点按自身语境构造。
+function enterCooldown(ent, ws, key, fails, cur, stats) {
+  ent.cooldownUntil = cur + COOLDOWN_SECONDS;
+  bump(stats, 'cool');
+  deps.log(`冷却 ${ws} 任务 ${key}：仍有任务需要会话，但预热连续失败 `
+    + `${fails} 次，暂停重试 ${COOLDOWN_SECONDS / 60} 分钟`);
+}
+
+// 保证一个工作区里每个死主窗口任务都有专属预热，并完成本文件的续期/盖印
+// 维护。bucket 是 state[ws]（原地修改）。scriptProcsRef 是全轮共享的进程表
+// 快照容器（{value: 数组|null}），只在孤儿认领时拍一次。
+// 返回 pending：本轮新纳入跟踪、尚未认亲的活 script（新 spawn 与孤儿认
+// 领）的 {ws,key,pid} 列表，cmdRun 据此轮内等待认亲并补盖印。
 export async function patrolWorkspace(
   ws, bucket, taskfile, now, leadMs, cur, details, scriptProcsRef, stats,
 ) {
+  const pending = [];
   const tasks = deps.readTasks(ws);
   const note = (kind, msg) => {
     bump(stats, kind);
@@ -200,12 +326,20 @@ export async function patrolWorkspace(
       note('warn', `任务文件读不出 ${ws}：格式损坏或不可读，本轮跳过该目录，`
         + `其中 ${TASK_REL} 里的定时任务都不会执行`);
     }
-    return;
+    return [];
   }
 
-  const stopEntry = async (ent, kind, msg) => {
-    await deps.stopSession(ent);
+  // false 是 stopSession 的「活进程未能安全停止」：不能记回收、删 state
+  // 或继续重拉。生产与测试桩都返回严格布尔值。
+  const stopEntry = async (ent, key, kind, msg) => {
+    const stopped = await deps.stopSession(ent);
+    if (!stopped) {
+      note('warn', `无法安全停止 ${ws} 任务 ${key} pid=${ent.pid}：`
+        + '记录的进程仍存活；保留跟踪，本轮不删除条目也不另拉会话');
+      return false;
+    }
     note(kind, msg);
+    return true;
   };
 
   if (tasks.length === 0) {
@@ -214,62 +348,39 @@ export async function patrolWorkspace(
     // 接管）的 stop 是 no-op，条目照删——sid 没了任务也没了，无需再管。
     for (const [key, ent] of Object.entries(bucket)) {
       if (deps.trackedAlive(ent)) {
-        await stopEntry(ent, 'recycle',
+        const stopped = await stopEntry(ent, key, 'recycle',
           `回收 ${ws} 任务 ${key} pid=${ent.pid}：任务已全部清空，结束预热会话`);
+        if (!stopped) continue;
       }
       delete bucket[key];
     }
-    return;
+    return [];
   }
 
-  // 第零步：id 改键的崩溃窗口治愈。任务文件里旧键已不存在（上轮 minify
-  // 改小了 id、state 却没来得及存盘），而内容签名唯一匹配某个当前任务、
-  // 目标键又无主：先把条目挪到新键，让下面的决策把它当作连续的一代——
-  // 否则会按「旧任务删除 + 新任务」错杀活会话再重拉一个。必须在逐任务
-  // 决策之前做，spawn 才不会抢先占掉目标键。
-  let sigToKeys = new Map();
-  let currentKeys = new Set();
-  for (const t of tasks) {
-    const k = taskKey(t);
-    currentKeys.add(k);
-    const list0 = sigToKeys.get(taskSig(t)) ?? [];
-    list0.push(k);
-    sigToKeys.set(taskSig(t), list0);
-  }
-  for (const [key, ent] of Object.entries({ ...bucket })) {
-    if (currentKeys.has(key) || !ent.sig) continue;
-    const candidates = sigToKeys.get(ent.sig) ?? [];
-    if (candidates.length === 1 && !bucket[candidates[0]]) {
-      bucket[candidates[0]] = { ...ent, taskId: candidates[0] };
-      delete bucket[key];
-    }
+  // 与任务文件层共用一份按键分组视图。重复键对应多条任务时，state 与
+  // 会话都无法唯一对应到条目：跳过这些组并告警，maintainWorkspace 也只
+  // 处理单元素组。组的键集合同时就是后面的 currentKeys。
+  const taskGroups = groupTasksByKey(tasks);
+  for (const [key, group] of taskGroups) {
+    if (group.length < 2) continue;
+    note('warn', `任务键重复 ${ws}：${key} 对应 ${group.length} 条任务，`
+      + '无法区分各自会话，本轮跳过这些条目的预热与盖印');
   }
 
-  // 第一步：认亲。spawn 只知道 script pid，登记里是 claude 孙进程；沿轮
-  // 初快照的祖先链找到我们这代的登记详情，回填 sessionId/claudePid/
-  // claudeProcStart。认到 = 最强健康证据，当场清零失败计数。认不到下轮
-  // 再认，不阻断任何决策。
+  // 第一步：认亲。认到 = 最强健康证据，当场回填身份、清零失败计数。本
+  // 轮新 spawn 的不在快照里，认亲由 cmdRun 的轮内等待补做；其余条目认
+  // 不到下轮再认，不阻断任何决策。
   for (const ent of Object.values(bucket)) {
-    if (!deps.trackedAlive(ent)) continue;
-    const d = deps.claimWarm(details, ws, ent.pid);
-    if (!d) continue;
-    ent.fails = 0;
-    if (d.sessionId && d.procStart) {
-      ent.claudePid = d.pid;
-      ent.sessionId = d.sessionId;
-      ent.claudeProcStart = d.procStart;
-    }
+    if (deps.trackedAlive(ent)) claimEntry(ent, details, ws);
   }
 
-  // 第二步：逐任务决策。stamps 收本轮要盖的归属印（sig → 预热身份），
-  // 第三步合并进同一次原子写。stampConflicts 记「同内容签名被多个预热
-  // 声称」的病态任务（同毫秒连建的重复任务）：一律不盖，交回调度锁原
-  // 生规则，避免错盖后没拿到任务的预热永不满足回收条件而空转泄漏。
+  // 第二步：逐任务决策。stamps 收本轮要盖的归属印（taskKey → 预热身份），
+  // 第三步合并进同一次原子写。内容相同但 id 不同的任务各有自己的键；重复
+  // 键组直接跳过，不在循环内另建一套重复键索引。
   const stamps = new Map();
-  const stampConflicts = new Set();
-  for (const t of tasks) {
-    const key = taskKey(t);
-    const sig = taskSig(t);
+  for (const [key, group] of taskGroups) {
+    if (group.length !== 1) continue;
+    const t = group[0];
     let ent = bucket[key] ?? null;
     const logPath = sessionLogPath(ws, key);
     const ownerIsOurs = entryClaimed(ent)
@@ -284,14 +395,16 @@ export async function patrolWorkspace(
       if (ent && deps.trackedAlive(ent)
           && cur - (ent.startedAt ?? cur) > WARMUP_GRACE_SECONDS
           && !entryClaimed(ent)) {
-        await stopEntry(ent, 'stuck', `卡死 ${ws} 任务 ${key} pid=${ent.pid}：`
+        const stopped = await stopEntry(ent, key, 'stuck',
+          `卡死 ${ws} 任务 ${key} pid=${ent.pid}：`
           + '进程已存活仍未登记会话，已终止；任务的创建者会话仍在场可承接，'
           + '不另拉预热');
-        delete bucket[key];
+        if (stopped) delete bucket[key];
       } else if (ent && deps.trackedAlive(ent) && entryClaimed(ent)) {
-        await stopEntry(ent, 'recycle', `回收 ${ws} 任务 ${key} pid=${ent.pid}：`
+        const stopped = await stopEntry(ent, key, 'recycle',
+          `回收 ${ws} 任务 ${key} pid=${ent.pid}：`
           + '任务创建者会话已在场，结束多余的预热会话');
-        delete bucket[key];
+        if (stopped) delete bucket[key];
       }
       continue;
     }
@@ -314,9 +427,9 @@ export async function patrolWorkspace(
     // (c) window 回收：不要求任务此刻在窗口内——恰恰是执行完、已离开窗
     // 口的会话要被收掉。三条件缺一不可：本任务在本代执行过（lastFiredAt
     // 晚于 startedAt——区分「执行完的空闲」与「等触发的空闲」，后者是预
-    // 热缓存在干活）、本任务日志静默超时、距本任务下次需要还有两步余量
-    // （下轮重拉、再下轮盖印；needMs 在窗口内返回 now，天然挡住「回收后
-    // 立刻又需要」）。
+    // 热缓存在干活）、本任务日志静默超时、距本任务下次需要还有一个巡检
+    // 间隔加余量（下轮发现并 spawn、当轮等待认亲盖印；needMs 在窗口内
+    // 返回 now，天然挡住「回收后立刻又需要」）。
     if (ent && deps.trackedAlive(ent) && entryClaimed(ent)
         && typeof t.lastFiredAt === 'number'
         && t.lastFiredAt > (ent.startedAt ?? 0) * 1000
@@ -324,10 +437,10 @@ export async function patrolWorkspace(
           > SESSION_RECYCLE_IDLE_SECONDS
         && taskNeedMs(t, now) - now.getTime()
           > SESSION_RECYCLE_MARGIN_SECONDS * 1000) {
-      await stopEntry(ent, 'recycle',
+      const stopped = await stopEntry(ent, key, 'recycle',
         `回收 ${ws} 任务 ${key} pid=${ent.pid}：本任务已执行完毕且界面静默，`
         + '结束会话，下次窗口重新预热');
-      delete bucket[key];
+      if (stopped) delete bucket[key];
       continue;
     }
 
@@ -338,9 +451,11 @@ export async function patrolWorkspace(
     // 问界面的垃圾进程。杀掉后继续走失败计数/冷却/重拉。
     if (ent && deps.trackedAlive(ent) && !entryClaimed(ent)
         && cur - (ent.startedAt ?? cur) > WARMUP_GRACE_SECONDS) {
-      await stopEntry(ent, 'stuck', `卡死 ${ws} 任务 ${key} pid=${ent.pid}：`
+      const stopped = await stopEntry(ent, key, 'stuck',
+        `卡死 ${ws} 任务 ${key} pid=${ent.pid}：`
         + '进程已存活仍未登记会话，已终止'
         + `（排查：cron-up logs ${path.basename(ws)}--${key}）`);
+      if (!stopped) continue;
     }
 
     // (e) resume 接管结束：sid 已从登记消失。整代身份作废（script 已
@@ -358,23 +473,12 @@ export async function patrolWorkspace(
       ent.fails = 0;
     }
 
-    // 盖印：已认亲且任务归属还没盖到本代预热（活创建者已在 (a) 排
-    // 除）。当轮新 spawn 的会话没认亲，下轮才盖——lead 覆盖两轮巡检。
+    // 盖印（跨轮老条目）：已认亲且任务归属还没盖到本代预热（活创建者
+    // 已在 (a) 排除）。当轮新 spawn 的会话在第三步之后的轮内等待里认
+    // 亲，由 cmdRun 的 stampClaimed 补盖，不走这里。
     if (entryClaimed(ent)
         && (!t.createdBySessionId || t.createdBySessionId !== ent.sessionId)) {
-      const target = {
-        sessionId: ent.sessionId,
-        pid: ent.claudePid,
-        procStart: ent.claudeProcStart,
-      };
-      if (stamps.has(sig)) {
-        if (stamps.get(sig).sessionId !== ent.sessionId) {
-          stampConflicts.add(sig);
-          stamps.delete(sig);
-        }
-      } else if (!stampConflicts.has(sig)) {
-        stamps.set(sig, target);
-      }
+      stamps.set(key, reownTarget(ent));
     }
 
     // warm 未到回收 / spawning 宽限内：本轮无事。
@@ -396,14 +500,11 @@ export async function patrolWorkspace(
         ...ent,
         ws,
         taskId: key,
-        sig,
         pid: null,
         fails,
-        cooldownUntil: cur + COOLDOWN_SECONDS,
         log: ent?.log ?? logPath,
       };
-      note('cool', `冷却 ${ws} 任务 ${key}：仍有任务需要会话，但预热连续失败 `
-        + `${fails} 次，暂停重试 ${COOLDOWN_SECONDS / 60} 分钟`);
+      enterCooldown(bucket[key], ws, key, fails, cur, stats);
       continue;
     }
 
@@ -422,7 +523,6 @@ export async function patrolWorkspace(
         bucket[key] = {
           ws,
           taskId: key,
-          sig,
           pid: procPid,
           startedAt: cur,
           procStart: deps.procStartedAt(procPid),
@@ -431,6 +531,7 @@ export async function patrolWorkspace(
         };
         note('adopt', `接管 ${ws} 任务 ${key} pid=${procPid}：state 记录缺失，`
           + '但进程表里仍有本该任务的预热会话，重新纳入跟踪');
+        pending.push({ ws, key, pid: procPid });
         continue;
       }
     }
@@ -442,17 +543,14 @@ export async function patrolWorkspace(
       const newFails = fails + 1;
       if (newFails >= FAIL_LIMIT) {
         bucket[key] = {
-          ws, taskId: key, sig, pid: null, fails: newFails,
-          cooldownUntil: cur + COOLDOWN_SECONDS, log: logPath,
+          ws, taskId: key, pid: null, fails: newFails, log: logPath,
         };
-        note('cool', `冷却 ${ws} 任务 ${key}：仍有任务需要会话，但预热连续失败 `
-          + `${newFails} 次，暂停重试 ${COOLDOWN_SECONDS / 60} 分钟`);
+        enterCooldown(bucket[key], ws, key, newFails, cur, stats);
         continue;
       }
       bucket[key] = {
         ws,
         taskId: key,
-        sig,
         pid: null,
         startedAt: cur,
         fails: newFails,
@@ -465,7 +563,6 @@ export async function patrolWorkspace(
     bucket[key] = {
       ws,
       taskId: key,
-      sig,
       pid: spawned.pid,
       startedAt: cur,
       procStart: spawned.procStart,
@@ -474,74 +571,124 @@ export async function patrolWorkspace(
     };
     note('spawn', `已启动 ${ws} 任务 ${key} pid=${spawned.pid}`
       + `（连续失败计数 ${fails}）`);
+    pending.push({ ws, key, pid: spawned.pid });
   }
 
-  // 第三步：任务文件维护（续期 + 改 id + 盖印）合并为一次带乐观锁的原子
-  // 写。撞车（Claude Code 刚写了 lastFiredAt/删了任务）整轮放弃写与
-  // reap，下轮基于新文件重算——已 spawn 的条目留下轮处理，不受影响。
+  // 第三步：任务文件维护（续期 + 盖印）合并为一次带 mtime 乐观检测的原子写。
+  // 撞车（Claude Code 刚写了 lastFiredAt/删了任务）放弃本轮老条目维护，但已
+  // spawn 的会话仍返回给 cmdRun 等待认亲，盖印收尾会再写一次。
   let result;
   try {
     result = maintainWorkspace(taskfile, { reown: stamps });
   } catch (e) {
     if (e instanceof TaskFileChanged) {
       note('warn', `维护暂缓 ${ws}：任务文件刚被 Claude Code 改动，本轮不覆盖，`
-        + '下轮再来');
-      return;
+        + '稍后重试');
+      return pending;
     }
     throw e;
   }
-  if (result === null) return; // 与 readTasks 不一致的极端竞态：保守不动
+  // 与 readTasks 不一致的极端竞态：保守不动，新 spawn 也全留跨轮路径。
+  if (result === null) return [];
   if (result.renewed) {
     deps.log(`已续期 ${ws}：${result.renewed} 个周期任务标记为 permanent，`
       + '不再受 7 天过期限制');
   }
-  if (result.minified) {
-    deps.log(`已改小 id ${ws}：${result.minified} 个周期任务的 id 改为小哈希`
-      + '值，投递延迟降到约 1 分钟内');
-  }
-  if (result.reowned) {
-    bump(stats, 'reown');
-    deps.log(`已过户 ${ws}：${result.reowned} 个窗口内任务的归属改到各自的`
-      + '预热会话，这些任务将只在对应会话触发');
-  }
-  // id 改小同轮把 state 条目跟着改键：不改的话下轮会把换 id 的任务误判
-  // 成「旧任务删除 + 新任务」，错杀刚拉起的会话再重拉一个。
-  for (const { from, to } of result.idChanges) {
-    if (bucket[from] && !bucket[to]) {
-      bucket[to] = { ...bucket[from], taskId: to };
-      delete bucket[from];
+  if (result.reowned) noteReowned(ws, result.reowned, stats);
+
+  // 第四步：任务消失的条目回收。续期与盖印都不改任务键，分组视图的键集合
+  // 仍是准确的 currentKeys。冷却中的条目也删——任务没了，冷却没有意义；
+  // 停止失败则保留可跟踪条目，下轮继续尝试，绝不错删后遗留活会话。
+  for (const [key, ent] of Object.entries({ ...bucket })) {
+    if (taskGroups.has(key)) continue;
+    if (deps.trackedAlive(ent)) {
+      const stopped = await stopEntry(ent, key, 'recycle',
+        `回收 ${ws} 任务 ${key} pid=${ent.pid}：对应任务已删除，结束预热会话`);
+      if (!stopped) continue;
     }
+    delete bucket[key];
   }
+  return pending;
+}
 
-  // 第四步：任务消失的条目回收。第零步已做过签名治愈；这里重建当前键索
-  // 引——注意内存里的 tasks 是维护前的快照，minify 改的是重新读盘的
-  // doc，所以键必须经 idChanges 修正，否则刚改到新键的条目会被旧 id 视
-  // 图误当成「签名可治愈的旧键」再改回去。剩下对不上的键就是真的被删
-  // 了。冷却中的条目也删——任务没了，冷却没有意义。
-  const renamed = new Map(result.idChanges.map((c) => [c.from, c.to]));
-  sigToKeys = new Map();
-  currentKeys = new Set();
-  for (const t of tasks) {
-    const k = renamed.get(taskKey(t)) ?? taskKey(t);
-    currentKeys.add(k);
-    const list = sigToKeys.get(taskSig(t)) ?? [];
-    list.push(k);
-    sigToKeys.set(taskSig(t), list);
+// 等待拍数是墙钟帽的派生：假时钟（测试）下墙钟不走，拍数帽单独兜底。
+const MAX_WARMUP_POLLS = WARMUP_WAIT_MS / WARMUP_POLL_MS;
+
+// 轮内等待本轮新 spawn/认领的会话完成登记，认亲走与轮初同一个
+// claimEntry。这是盖印加速，不是判死：等不到的活会话原样留下，判死只
+// 走跨轮 WARMUP_GRACE 路径。先扫后睡——进入时各工作区决策已串行花掉数
+// 秒，健康会话可能已登记；任一 pending 认亲或死亡都移出集合，全部移出
+// 即提前结束。返回最新登记快照、按 ws 分组的认亲条目（供补盖印）与等
+// 待期内死亡的 pending（供退出日志；其 bucket 条目已计失败）。
+async function awaitWarmups(pending, state, cur, stats) {
+  const claimedByWs = new Map();
+  const died = [];
+  let details;
+  const deadline = Date.now() + WARMUP_WAIT_MS;
+  const recognize = () => {
+    const rest = [];
+    for (const p of pending) {
+      const ent = state[p.ws]?.[p.key];
+      if (!ent || ent.pid !== p.pid) continue;
+      if (!deps.trackedAlive(ent)) {
+        // 启动即崩的典型窗口：真拉起过却死掉，计一次失败并置空 pid，条
+        // 目靠 fails 走 48 小时 TTL 保留、下轮重拉；满三次当轮进冷却。
+        // 只打日志丢弃会让 fails 永远从零起，坏掉的环境每轮重拉却永不
+        // 冷却。
+        ent.fails = (ent.fails ?? 0) + 1;
+        ent.pid = null;
+        delete ent.procStart;
+        if (ent.fails >= FAIL_LIMIT) {
+          enterCooldown(ent, p.ws, p.key, ent.fails, cur, stats);
+        }
+        died.push(p);
+        continue;
+      }
+      if (claimEntry(ent, details, p.ws)) {
+        if (!claimedByWs.has(p.ws)) claimedByWs.set(p.ws, []);
+        claimedByWs.get(p.ws).push(ent);
+      } else {
+        rest.push(p);
+      }
+    }
+    pending = rest;
+  };
+  // 轮初快照拍于决策之前、spawn 尚未发生，认亲必然落空；进入先重扫一
+  // 拍再开始睡。之后睡一拍、扫一拍。
+  [, , details] = await deps.scanSessions();
+  recognize();
+  for (let polls = 0;
+    pending.length > 0 && polls < MAX_WARMUP_POLLS && Date.now() < deadline;
+    polls += 1) {
+    await deps.sleep(WARMUP_POLL_MS);
+    [, , details] = await deps.scanSessions();
+    recognize();
   }
-  for (const [key, ent] of Object.entries({ ...bucket })) {
-    if (currentKeys.has(key)) continue;
-    const candidates = ent.sig ? (sigToKeys.get(ent.sig) ?? []) : [];
-    if (candidates.length === 1 && !bucket[candidates[0]]) {
-      const to = candidates[0];
-      bucket[to] = { ...ent, taskId: to };
-      delete bucket[key];
-      continue;
+  return { details, claimedByWs, died };
+}
+
+// 等待期认到亲的会话补盖归属印：claimedByWs 的每个 ent 已是 bucket 条
+// 目，taskId 与认亲身份都在上面。无认亲的 ws 不调用、不写盘；撞 mtime 乐
+// 观锁或极端竞态（result=null）跳过，下轮再来。
+function stampClaimed(claimedByWs, taskfiles, stats) {
+  for (const [ws, ents] of claimedByWs) {
+    const stamps = new Map();
+    for (const ent of ents) {
+      if (entryClaimed(ent)) stamps.set(ent.taskId, reownTarget(ent));
     }
-    if (deps.trackedAlive(ent)) {
-      await stopEntry(ent, 'recycle', `回收 ${ws} 任务 ${key} pid=${ent.pid}：`
-        + '对应任务已删除，结束预热会话');
+    if (stamps.size === 0) continue;
+    try {
+      const result = maintainWorkspace(taskfiles.get(ws), { reown: stamps });
+      if (result?.reowned) noteReowned(ws, result.reowned, stats);
+    } catch (e) {
+      if (e instanceof TaskFileChanged) {
+        bump(stats, 'warn');
+        deps.log(`盖印暂缓 ${ws}：任务文件刚被 Claude Code 改动，本轮不覆盖，`
+          + '下轮再来');
+        continue;
+      }
+      throw e;
     }
-    delete bucket[key];
   }
 }
 
@@ -551,10 +698,16 @@ export async function patrolWorkspace(
 async function retireLegacy(legacy, stats) {
   for (const ent of legacy) {
     if (deps.trackedAlive(ent)) {
-      await deps.stopSession(ent);
-      bump(stats, 'recycle');
-      deps.log(`旧版迁移 ${ent.ws} pid=${ent.pid}：结束目录级预热会话，`
-        + '升级后按任务重新预热');
+      const stopped = await deps.stopSession(ent);
+      if (!stopped) {
+        bump(stats, 'warn');
+        deps.log(`旧版迁移暂缓 ${ent.ws} pid=${ent.pid}：记录的进程仍存活，`
+          + '本次无法安全停止目录级预热会话；本次不记为已回收');
+      } else {
+        bump(stats, 'recycle');
+        deps.log(`旧版迁移 ${ent.ws} pid=${ent.pid}：结束目录级预热会话，`
+          + '升级后按任务重新预热');
+      }
     }
   }
   const handled = new Set(legacy.filter((e) => e.pid).map((e) => e.pid));
@@ -566,10 +719,16 @@ async function retireLegacy(legacy, stats) {
     if (isTaskSessionLogName(path.basename(file))) continue; // 新一代命名
     const ent = { pid, procStart: deps.procStartedAt(pid) };
     if (!deps.trackedAlive(ent)) continue;
-    await deps.stopSession(ent);
-    bump(stats, 'recycle');
-    deps.log(`旧版迁移 pid=${pid}：结束目录级预热孤儿会话（日志 ${file}），`
-      + '升级后按任务重新预热');
+    const stopped = await deps.stopSession(ent);
+    if (!stopped) {
+      bump(stats, 'warn');
+      deps.log(`旧版迁移暂缓 pid=${pid}：记录的进程仍存活，本次无法安全停止`
+        + `目录级预热孤儿会话（日志 ${file}）；本次不记为已回收`);
+    } else {
+      bump(stats, 'recycle');
+      deps.log(`旧版迁移 pid=${pid}：结束目录级预热孤儿会话（日志 ${file}），`
+        + '升级后按任务重新预热');
+    }
   }
 }
 
@@ -587,8 +746,9 @@ export async function cmdRun(args) {
   const prevStopSession = deps.stopSession;
   const stoppedPids = new Set();
   deps.stopSession = async (ent) => {
-    if (ent?.pid) stoppedPids.add(ent.pid);
-    return prevStopSession(ent);
+    const stopped = await prevStopSession(ent);
+    if (stopped && ent?.pid) stoppedPids.add(ent.pid);
+    return stopped;
   };
   const prevProcStartedAt = deps.procStartedAt;
   const lstartCache = new Map();
@@ -624,8 +784,10 @@ export async function cmdRun(args) {
         + '请检查配置文件或用 cron-up install --roots 指定');
     }
 
-    // 登记每轮只读一次（含祖先链快照）：认亲与活创建者判定都靠它。
-    const [consumers, registryAlert, details] = await deps.scanSessions();
+    // 登记轮初读一次（含祖先链快照）：认亲与活创建者判定都靠它。有新
+    // spawn 时等待期会重扫，details 随之刷新到最新快照（轮末 kept 判定
+    // 与消费者计数都用刷新后的版本）。
+    let [consumers, registryAlert, details] = await deps.scanSessions();
     if (registryAlert) {
       bump(stats, 'warn');
       deps.log(`告警：${registryAlert}`);
@@ -668,15 +830,18 @@ export async function cmdRun(args) {
 
     let found = 0;
     const scriptProcsRef = { value: null };
+    const pendingAll = [];
+    const taskfiles = new Map();
     for (const [ws, taskfile] of deps.discover(cfg.roots)) {
       found += 1;
       if (!state[ws]) state[ws] = {};
+      taskfiles.set(ws, taskfile);
       // 一个工作区读不动/写不动不能中断整轮：discover 是生成器，抛了会
       // 跳过后面所有工作区。
       try {
-        await patrolWorkspace(
+        pendingAll.push(...await patrolWorkspace(
           ws, state[ws], taskfile, now, leadMs, cur, details,
-          scriptProcsRef, stats);
+          scriptProcsRef, stats));
       } catch (e) {
         bump(stats, 'error');
         deps.log(`错误 ${ws}：${e.constructor.name}：${e.message}`);
@@ -684,6 +849,33 @@ export async function cmdRun(args) {
       if (Object.keys(state[ws]).length === 0) delete state[ws];
     }
 
+    // 本轮有新会话拉起才等待：绝大多数轮次 pending 为空，零额外 ps、零睡
+    // 眠。认亲后同一轮补盖归属印（否则要等下一轮，提前量就得兜两轮）。
+    // 等待只认亲、不判死；等不到的下轮按 WARMUP_GRACE 跨轮处理。
+    if (pendingAll.length > 0) {
+      try {
+        const { details: latest, claimedByWs, died } = await awaitWarmups(
+          pendingAll, state, cur, stats);
+        details = latest;
+        consumers = new Set(details.keys());
+        // 等待期内自然死亡的是本轮新 spawn 的会话，不在轮初 prevAlive 分
+        // 组里，单独补一条退出日志，否则启动即崩将完全静默。死亡条目
+        // fails≥1，轮末 kept 必保留，此刻仍在 bucket 里（pid 已置空，
+        // 用 pending 记的 pid 补回给日志）。
+        for (const d of died) {
+          bump(stats, 'exit');
+          deps.log(exitLine(d.ws, d.key,
+            { ...state[d.ws]?.[d.key], pid: d.pid }));
+        }
+        stampClaimed(claimedByWs, taskfiles, stats);
+      } catch (e) {
+        // 等待或补盖失败不能丢轮末落盘：最坏只是盖印晚一轮，会话进程已
+        // 在场，目录调度锁仍兜底。
+        bump(stats, 'error');
+        deps.log(`等待预热登记出错：${e.constructor.name}：${e.message}`);
+      }
+    }
+
     // 轮中死亡复核：轮初活、轮末没气、又不是本轮主动 stop 的。轮中刚被
     // --resume 接管（sid 换 pid 存活）的不报。
     for (const [ws, taskId, old] of prevAlive) {
@@ -745,7 +937,7 @@ export async function cmdRun(args) {
   } finally {
     deps.stopSession = prevStopSession;
     deps.procStartedAt = prevProcStartedAt;
-    releaseLock(lock);
+    deps.releaseRunLock(lock);
   }
 }
 
@@ -754,4 +946,5 @@ Object.assign(deps, {
   runPatrol: cmdRun,
   rotatePatrolLogs,
   acquireRunLock,
+  releaseRunLock,
 });