cron-up 26.10.31 → 26.10.32

package/README.md

@@ -18,7 +18,7 @@ Claude Code 的任务归属是**任务级**的：任务文件里每条任务各
 3. 本进程是任务记录的创建者进程（resume 形态）→ 投；
 4. 其余情况 → 必须持锁、任务属于本项目、且创建者进程已死，才接管。
 
-cron-up 利用这套规则：为每个「归属会话已死、10 分钟内需要执行」的任务单独拉起一个后台会话，并把该任务的归属字段盖成这个新会话。于是同目录多个任务即使同一时刻触发，也各自投进各自的会话、互不插队；任一个预热中途死了，它的任务还会由另一个持锁活会话按规则 4 兜底接管。你本人的交互会话优先级最高：**只要任务的创建者会话还开着，cron-up 完全不碰它**。
+cron-up 利用这套规则：为每个「归属会话已死、6 分钟内需要执行」（一次性任务按最早可能投递时刻计，最多再提前 90 秒）的任务单独拉起一个后台会话，并把该任务的归属字段盖成这个新会话。于是同目录多个任务即使同一时刻触发，也各自投进各自的会话、互不插队；任一个预热中途死了，它的任务还会由另一个持锁活会话按规则 4 兜底接管。你本人的交互会话优先级最高：**只要任务的创建者会话还开着，cron-up 完全不碰它**。
 
 | 环节 | 由谁负责 |
 |---|---|
@@ -62,7 +62,7 @@ cron-up logs team-space--00000002 -f
 cron-up uninstall              # 停止全部预热会话并卸载（配置日志保留；--purge 连产物一起删）
 ```
 
-巡检固定每 5 分钟一轮、提前 10 分钟为任务备好会话；这些不是可配项。任何任务最迟在执行前一轮巡检被发现，而健康会话约 10 秒即可完成登记。
+巡检固定每 5 分钟一轮、提前 6 分钟为任务备好会话；这些不是可配项。任何任务最迟在执行前一轮巡检被发现；拉起会话后轮内每 3 秒重扫一次会话登记（先扫后睡、至多等 24 秒），健康会话约 10 秒即可完成登记，归属在**同一轮**盖印完成，不再跨一轮。24 秒只是盖印加速的等待上限，不是判死时限：等不到的会话原样留到下轮，仍按跨轮 3 分钟未登记判死，失败计数不因等待而增加。一次性任务在 :00/:30 落点最多提前 90 秒投递，其窗口前沿按最早投递时刻再前推 90 秒，保证任意巡检相位都有一轮在投递前把它发现。
 
 ### 自动维护（每轮无条件进行，没有开关）
 
@@ -84,7 +84,7 @@ cron-up uninstall              # 停止全部预热会话并卸载（配置日
 
 ## 窗口轮转与生命周期
 
-预热会话是缓存不是宠物：每个会话只活在「落点前 10 分钟 → 本任务执行完并静默 3 分钟 → 回收」这一段，任务之间上下文互不累积，内存也只在窗口内占用（每个会话数百 MB，窗口外为零）。回收还要求距该任务下次需要至少 7 分钟——回收后要经历「下轮重拉、再下轮盖印」两步，留足余量任务才不可能在空档到点。更近的触发直接复用现有会话。
+预热会话是缓存不是宠物：每个会话只活在「落点前 6 分钟（一次性网格任务至多 7.5 分钟）→ 本任务执行完并静默 3 分钟 → 回收」这一段，任务之间上下文互不累积，内存也只在窗口内占用（每个会话数百 MB，窗口外为零）。回收还要求距该任务下次需要至少 7 分钟——回收后下轮巡检（≤5 分钟）即重新拉起并在当轮完成认亲盖印，余量罩住一次性任务的 90 秒提前投递与唤醒抖动，任务不可能在空档到点。更近的触发直接复用现有会话。
 
 其它生命周期规则：
 
@@ -122,7 +122,7 @@ Claude Code 任务的实际投递不在 cron 落点，而是落点之后加一
 ## 已知限制
 
 - 仅支持 macOS。电脑休眠期间错过的周期任务不会补执行（launchd 醒来只补跑一轮巡检）；错过的**一次性**任务会在后台会话启动时补执行。
-- 每个窗口内的死主任务对应一个后台会话：同一分钟内有大量任务同时到期时，会同时存在相应数量的会话（每个数百 MB 内存）。时间错开的日常任务只在各自的 10 分钟窗口内占用。
+- 每个窗口内的死主任务对应一个后台会话：同一分钟内有大量任务同时到期时，会同时存在相应数量的会话（每个数百 MB 内存）。时间错开的日常任务只在各自的 6 分钟窗口内占用（一次性任务至多 7.5 分钟）。
 - 手工创建的任务若缺少 `createdAt`，错过补执行判定不生效。`cron-up list` 对缺字段的手写任务仍显示「已错过/设定时间」，但预热与补执行依赖 Claude Code 与 cron-up 的字段纪律。
 - 工作区从巡检视野里消失（`.claude/scheduled_tasks.json` 被整个删除或移出 roots）后，仍在运行的预热不会被回收，总览会列出这类会话，不需要时手动结束。
 - 预热依据的逐任务谓词、调度锁与三代进程结构是未公开内部实现：新版若调整归属/锁语义，任务级隔离的前提需要重新核对。cron-up 保留了会话登记格式的烟雾告警，格式漂移时在总览页明示。
@@ -155,7 +155,7 @@ Claude Code 任务的实际投递不在 cron 落点，而是落点之后加一
 { "roots": ["/Users/you/code", "/Users/you/work"] }
 ```
 
-间隔（300 秒）、提前量（600 秒）、扫描深度（3）都是固定常量；直接编辑文件改 roots 也可以，最多 5 分钟后的下轮巡检生效。字段损坏时巡检响亮失败（退出码 2），不静默回退。
+间隔（300 秒）、提前量（360 秒，一次性任务另加至多 90 秒）、扫描深度（3）、轮内等待认亲上限（24 秒）都是固定常量；直接编辑文件改 roots 也可以，最多 5 分钟后的下轮巡检生效。字段损坏时巡检响亮失败（退出码 2），不静默回退。
 
 | 产物 | 位置 |
 |---|---|

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cron-up",
-  "version": "26.10.31",
+  "version": "26.10.32",
   "description": "为命令行 AI agent 的 cron 定时任务提前预热并保活交互式会话",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -11,9 +11,12 @@ export const DEFAULT_CONFIG = {
 
 // launchd 两轮巡检之间的秒数（plist 的 StartInterval）。
 export const INTERVAL_SECONDS = 300;
-// 提前多少秒为窗口内任务备好会话：覆盖两轮巡检（本轮发现、下轮盖印），任
-// 何任务最迟在执行前一轮被发现；会话登记本身只需约 10 秒。
-export const LEAD_SECONDS = 600;
+// 提前多少秒为窗口内任务备好会话。任务相对巡检网格的相位任意：最迟在落
+// 点前一轮（≤INTERVAL）被发现并 spawn，spawn 后当轮等待认亲并盖印（见
+// WARMUP_WAIT_MS），故提前量只需「一轮间隔 + 等待与重扫开销」。一次性
+// 任务在 :00/:30 网格最多提前 90 秒投递，其窗口前沿在 cron.mjs 的 wanted
+// 里再前推 CC_JITTER.oneShotMaxMs，不占这里的周期任务余量。
+export const LEAD_SECONDS = 360;
 // 工作区发现的最大递归深度（相对 roots）：深度 3 覆盖
 // <容器>/<仓>/<子目录>/<孙目录> 里的任务文件。
 export const MAX_SCAN_DEPTH = 3;
@@ -33,14 +36,23 @@ export const FAIL_TTL_SECONDS = 48 * 3600;
 export const PID_T_MAX = 2 ** 31 - 1;
 // 健康会话约 10 秒内完成登记。超时仍存活却没登记，是卡在无人应答的提问
 // 界面（目录信任、工具授权）；只看存活会把它当健康，只有这个时限兜得住。
+// 这是唯一的判死阈值，且只在跨轮判定（轮龄为整数个巡检间隔）时生效。
 export const WARMUP_GRACE_SECONDS = 180;
+// spawn 当轮在轮内等待会话登记的上限：它是「盖印加速」预算，不是判死阈
+// 值——等不到的会话原样留到下轮，按 WARMUP_GRACE_SECONDS 跨轮判死，失
+// 败计数不因等待而累积（慢启动环境两轮就被冷却的回退就是这么来的）。
+// 健康会话约 10 秒登记，24 秒是 8 拍重扫（另加进入时的先扫一拍）；拍数
+// 帽与墙钟帽双出口，高负载拖慢 setTimeout 也不会把一轮撑过间隔。
+export const WARMUP_WAIT_MS = 24_000;
+export const WARMUP_POLL_MS = 3_000;
 // window 回收判据一：界面静默超过此时长视为「本任务已执行完」。TUI 工作
 // 时持续渲染（毫秒级刷新 typescript），静默 3 分钟不可能是在执行；取
 // WARMUP_GRACE 同值，结构上对齐「3 分钟定生死」的既有心智。
 export const SESSION_RECYCLE_IDLE_SECONDS = WARMUP_GRACE_SECONDS;
 // window 回收判据二：距该任务下次「需要会话在场」至少还有这么多秒。回收
-// 后要经「下轮重拉 → 新会话登记 → 再下轮盖印」两步，任务才重新铁定投到
-// 新预热：一个巡检间隔加登记抖动余量。更近的触发不回收，复用现有会话。
+// 后下轮（≤INTERVAL）发现并 spawn，进程即在场，盖印在该轮等待期内完成；
+// 一个巡检间隔之外的 120 秒余量罩一次性任务最多 90 秒的提前投递与唤醒
+// 抖动。更近的触发不回收，复用现有会话。
 export const SESSION_FIRE_MARGIN_SECONDS = 120;
 export const SESSION_RECYCLE_MARGIN_SECONDS =
   SESSION_FIRE_MARGIN_SECONDS + INTERVAL_SECONDS;

package/src/cron.mjs

@@ -196,10 +196,10 @@ function createdAtDate(task) {
   return Number.isFinite(d.getTime()) ? d : null;
 }
 
-// 在已解析的 cron 上判定：这个任务现在是否需要一个已预热的会话。
-function wanted(cron, task, now, leadMs) {
-  const nxt = cron.nextAfter(now);
-  if (nxt && nxt.getTime() <= now.getTime() + leadMs) return true;
+// 此刻是否已需要会话：一次性任务错过待补，或周期任务处在落点之后、抖动
+// 投递之前的尾窗。不带任何前瞻——display 的「已错过」判定与回收余量都
+// 按这个口径，未来落点子句不属于这里。
+function wantedNow(cron, task, now) {
   // 首次触发已过却仍在文件里：一次性任务意味着没有 REPL 运行时被错过
   // （重启/睡眠）。原生机制会在会话启动时补执行一次再删除它。
   if (taskIsOneshot(task)) {
@@ -223,15 +223,33 @@ function wanted(cron, task, now, leadMs) {
   return recurringTailWindow(cron, task.id, now) !== null;
 }
 
+// leadMs 前瞻窗口内（含此刻）是否需要会话。leadMs 必须为正的前瞻量；
+// 传 0 时等价 wantedNow（「此刻」没有窗口，网格提前量也不成立），问此
+// 刻口径请直接用 wantedNow。一次性任务在 :00/:30 网格落点最多提前
+// oneShotMaxMs 投递（见 nextDelivery 的 Wsn 复刻）：前瞻窗口的前沿罩到
+// 最早投递时刻，否则约一成相位带在提前量内没有任何巡检点；非网格落点
+// 本不提前，保守同口径只是多等 90 秒，无损。周期任务的抖动在落点之
+// 后，未来子句不前推，尾窗交给 wantedNow。
+function wantedWithin(cron, task, now, leadMs) {
+  if (leadMs > 0) {
+    const nxt = cron.nextAfter(now);
+    const lookahead = taskIsOneshot(task)
+      ? leadMs + CC_JITTER.oneShotMaxMs
+      : leadMs;
+    if (nxt && nxt.getTime() <= now.getTime() + lookahead) return true;
+  }
+  return wantedNow(cron, task, now);
+}
+
 // 任务是否需要已预热的会话。任务字段全是别的程序写的，畸形条目读作「不
 // 需要」，绝不能让一个坏条目中断整轮巡检。
 export function taskWanted(task, now, leadMs) {
   const cron = parseCronOrNone(task?.cron);
-  return cron !== null && wanted(cron, task, now, leadMs);
+  return cron !== null && wantedWithin(cron, task, now, leadMs);
 }
 
-// wanted 供展示视图复用（同一个已解析 cron 顺带回答巡检问题）。
-export { wanted };
+// 两个口径供展示视图复用（同一个已解析 cron 顺带回答巡检问题）。
+export { wantedNow, wantedWithin };
 
 // ---- Claude Code 投递抖动（预计实际触发时间）----
 // 复刻 v2.1.285 内部的 M()：任务 id 前 8 位十六进制除以 2^32，得 [0,1) 的

package/src/display.mjs

@@ -3,7 +3,8 @@
 import {
   parseCronOrNone,
   taskIsOneshot,
-  wanted,
+  wantedNow,
+  wantedWithin,
   nextDelivery,
 } from './cron.mjs';
 
@@ -71,7 +72,7 @@ function taskSummary(task) {
 
 // 把一个任务整理成展示数据。字段来自别的程序写的文件，畸形也不抛。
 // 传 leadMs 时顺带在同一个已解析 cron 上回答「现在是否需要预热会话」
-// （wanted），总览页就不必为同一任务再解析一遍 cron。
+// （wantedWithin），总览页就不必为同一任务再解析一遍 cron。
 export function taskView(task, now, leadMs) {
   const expr = task?.cron;
   const cron = parseCronOrNone(expr);
@@ -90,8 +91,8 @@ export function taskView(task, now, leadMs) {
   }
   const oneshot = taskIsOneshot(task);
   // nxt 按定义不晚于展示语境里的下一次投递，「已错过」完全由补执行判定
-  // 回答：lead 传 0（不带前瞻），与巡检的补执行判定同一口径。
-  const missed = oneshot && wanted(cron, task, now, 0);
+  // 回答：只问此刻、不带前瞻，与巡检的错过/尾窗判定同一口径。
+  const missed = oneshot && wantedNow(cron, task, now);
   // 落点与投递由 nextDelivery 同源算出：尾窗内的周期任务即将到来的是上
   // 一落点的这次延迟投递，箭头才画得出「09:00 → 09:30」，而不是从明天
   // 的落点拐回来（2 月 29 日任务尾窗内 nextAfter 甚至找不到下一落点）。
@@ -108,7 +109,7 @@ export function taskView(task, now, leadMs) {
     summary: taskSummary(task),
     // wanted 恒为 null 或布尔：没传 leadMs（不问）与 cron 无效（问不了）
     // 都是 null，键的形状不随参数变化。
-    wanted: leadMs !== undefined ? wanted(cron, task, now, leadMs) : null,
+    wanted: leadMs !== undefined ? wantedWithin(cron, task, now, leadMs) : null,
     // 计入 Claude Code 投递抖动后的预计实际触发时刻；已错过的一次性任务
     // 没有未来触发，为 null；尾窗内的周期任务是即将到来的这次延迟投递。
     // 与 nxt 同为 Date 或 null。

package/src/patrol.mjs

@@ -1,8 +1,10 @@
 // 一轮巡检：发现工作区 → 自动维护任务文件（续期/改 id/盖印）→ 保证每个
 // 「创建者会话已死且处于预热窗口」的任务都有一个只属于它的健康会话。
-// 这是 launchd 的入口（每 N 秒被拉起一次，跑完即退）。状态机覆盖：认亲、
-// 卡死退休、失败冷却、执行完回收、resume 接管脱离、孤儿认领、任务消失回
-// 收、旧版目录级 state 迁移。
+// 这是 launchd 的入口（每 N 秒被拉起一次，跑完即退）。本轮新拉起的会话
+// 在所有工作区决策完后轮内等待登记（至多 WARMUP_WAIT_MS），认亲同一轮
+// 补盖归属印；等不到的留给跨轮宽限，绝不当轮判死。状态机还覆盖：卡死
+// 退休、失败冷却、执行完回收、resume 接管脱离、孤儿认领、任务消失回收、
+// 旧版目录级 state 迁移。
 
 import fs from 'node:fs';
 import path from 'node:path';
@@ -13,6 +15,8 @@ import {
   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,
@@ -37,7 +41,7 @@ import {
   taskKey,
   taskSig,
 } from './tasks.mjs';
-import { taskWanted, parseCronOrNone, wanted } from './cron.mjs';
+import { taskWanted, parseCronOrNone, wantedNow } from './cron.mjs';
 import {
   sessionLogPath,
   sessionLogIdleSeconds,
@@ -164,13 +168,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 +184,67 @@ function entryClaimed(ent) {
   return Boolean(ent?.sessionId && ent.claudeProcStart);
 }
 
+// 沿登记快照把一个活 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,
+});
+
+// 同 sig 的归属仲裁：先到先入；同 sig 被不同会话认亲（同毫秒连建的重复
+// 任务）则双双撤出、都不盖。
+function mergeStamp(stamps, conflicts, sig, target) {
+  const prev = stamps.get(sig);
+  if (prev) {
+    if (prev.sessionId !== target.sessionId) {
+      conflicts.add(sig);
+      stamps.delete(sig);
+    }
+  } else if (!conflicts.has(sig)) {
+    stamps.set(sig, target);
+  }
+}
+
+// 过户后的统一计数与日志（巡逻第三步与等待期补盖共用）。
+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} 分钟`);
+}
+
 // 保证一个工作区里每个死主窗口任务都有专属预热，并完成本文件的续期/改
 // id/盖印维护。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,7 +260,7 @@ export async function patrolWorkspace(
       note('warn', `任务文件读不出 ${ws}：格式损坏或不可读，本轮跳过该目录，`
         + `其中 ${TASK_REL} 里的定时任务都不会执行`);
     }
-    return;
+    return [];
   }
 
   const stopEntry = async (ent, kind, msg) => {
@@ -219,7 +279,7 @@ export async function patrolWorkspace(
       }
       delete bucket[key];
     }
-    return;
+    return [];
   }
 
   // 第零步：id 改键的崩溃窗口治愈。任务文件里旧键已不存在（上轮 minify
@@ -245,20 +305,11 @@ export async function patrolWorkspace(
     }
   }
 
-  // 第一步：认亲。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 → 预热身份），
@@ -314,9 +365,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
@@ -358,23 +409,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);
-      }
+      mergeStamp(stamps, stampConflicts, sig, reownTarget(ent));
     }
 
     // warm 未到回收 / spawning 宽限内：本轮无事。
@@ -399,11 +439,9 @@ export async function patrolWorkspace(
         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;
     }
 
@@ -431,6 +469,7 @@ export async function patrolWorkspace(
         };
         note('adopt', `接管 ${ws} 任务 ${key} pid=${procPid}：state 记录缺失，`
           + '但进程表里仍有本该任务的预热会话，重新纳入跟踪');
+        pending.push({ ws, key, pid: procPid });
         continue;
       }
     }
@@ -442,11 +481,9 @@ 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, sig, 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] = {
@@ -474,23 +511,25 @@ 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 的条目留下轮处理，不受影响。
+  // 写。撞车（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 天过期限制');
@@ -499,17 +538,19 @@ export async function patrolWorkspace(
     deps.log(`已改小 id ${ws}：${result.minified} 个周期任务的 id 改为小哈希`
       + '值，投递延迟降到约 1 分钟内');
   }
-  if (result.reowned) {
-    bump(stats, 'reown');
-    deps.log(`已过户 ${ws}：${result.reowned} 个窗口内任务的归属改到各自的`
-      + '预热会话，这些任务将只在对应会话触发');
-  }
+  if (result.reowned) noteReowned(ws, result.reowned, stats);
   // id 改小同轮把 state 条目跟着改键：不改的话下轮会把换 id 的任务误判
-  // 成「旧任务删除 + 新任务」，错杀刚拉起的会话再重拉一个。
+  // 成「旧任务删除 + 新任务」，错杀刚拉起的会话再重拉一个。pending 是本
+  // 轮 spawn 的返回快照，键也要跟着改，否则轮内等待按旧键找不到条目，新
+  // 任务的盖印被白白推到下轮。
   for (const { from, to } of result.idChanges) {
     if (bucket[from] && !bucket[to]) {
+      const movedPid = bucket[from].pid;
       bucket[to] = { ...bucket[from], taskId: to };
       delete bucket[from];
+      for (const p of pending) {
+        if (p.key === from && p.pid === movedPid) p.key = to;
+      }
     }
   }
 
@@ -543,6 +584,89 @@ export async function patrolWorkspace(
     }
     delete bucket[key];
   }
+  return pending;
+}
+
+// 等待拍数是墙钟帽的派生：假时钟（测试）下墙钟不走，拍数帽单独兜底。
+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();
+  }
+  return { details, claimedByWs, died };
+}
+
+// 等待期认到亲的会话补盖归属印：claimedByWs 的每个 ent 已是 bucket 条
+// 目，sig/认亲身份都在上面。无认亲的 ws 不调用、不写盘；撞 mtime 乐观
+// 锁或极端竞态（result=null）跳过，下轮再来。
+function stampClaimed(claimedByWs, taskfiles, stats) {
+  for (const [ws, ents] of claimedByWs) {
+    const stamps = new Map();
+    const conflicts = new Set();
+    for (const ent of ents) {
+      if (entryClaimed(ent)) mergeStamp(stamps, conflicts, ent.sig, reownTarget(ent));
+    }
+    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;
+    }
+  }
 }
 
 // 升级轮：旧版目录级 state 的预热逐个结束（不迁移归属，新流程按任务重
@@ -624,8 +748,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 +794,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 +813,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) {