cron-up 26.10.32 → 26.10.34

package/src/service.mjs

@@ -22,34 +22,52 @@ import {
   validateConfig,
   normalizeRoots,
 } from './config.mjs';
-import { scriptProcLogPath } from './sessions.mjs';
+import { scriptProcLogPath, shellQuote } from './sessions.mjs';
 
 function guiTarget() {
   return `gui/${process.getuid()}`;
 }
 
 // launchctl 调用统一走不抛的 execFile，判成败看 status。与 ps 同款防御：
-// launchctl 卡住时命令挂死不如超时报「未加载」——总览页至少还能出来。
+// launchctl 卡住时命令挂死不如超时报「未加载」——总览页至少还能出来；卸载
+// 等破坏性操作另用下方三态 probe，状态未知时拒绝继续。
 export function launchctl(...args) {
   return deps.execFile('/bin/launchctl', args, { timeout: 10000 });
 }
 
-export function launchctlInfo() {
-  // 走 deps 而非同文件裸名：与 bootout/bootstrap 的打桩面保持一致，测试可
-  // 在 launchctl 一层整体模拟 launchd。
-  const r = deps.launchctl('print', `${guiTarget()}/${LABEL}`);
-  if (r.status !== 0) return null;
+function parseLaunchctlInfo(stdout = '') {
   const info = {};
   for (const key of ['state', 'last exit code']) {
-    const m = r.stdout.match(
+    const m = stdout.match(
       new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=\\s*(.+)$`, 'm'));
     if (m) info[key] = m[1].trim();
   }
-  const iv = r.stdout.match(/^\s*run interval\s*=\s*(\d+)\s*seconds/m);
+  const iv = stdout.match(/^\s*run interval\s*=\s*(\d+)\s*seconds/m);
   if (iv) info.interval = parseInt(iv[1], 10);
   return info;
 }
 
+// 卸载需要比 info/null 更细的结论：launchctl 对未加载与查询失败都返回非零，
+// 只有明确的「找不到服务」才能安全继续删除安装产物。
+function launchctlProbe() {
+  const r = deps.launchctl('print', `${guiTarget()}/${LABEL}`);
+  if (r.status === 0) {
+    return { kind: 'loaded', info: parseLaunchctlInfo(r.stdout ?? '') };
+  }
+  const stderr = (r.stderr ?? '').trim();
+  if (/could not find service/i.test(stderr)) return { kind: 'unloaded' };
+  return {
+    kind: 'unknown',
+    message: stderr || `launchctl print 退出码 ${r.status ?? '未知'}`,
+  };
+}
+
+export function launchctlInfo() {
+  // 总览页继续只看 info/null；详细三分状态仅供卸载等破坏性操作使用。
+  const probe = launchctlProbe();
+  return probe.kind === 'loaded' ? probe.info : null;
+}
+
 const LAUNCHD_STATES = new Map([
   ['running', '运行中'],
   ['not running', '空闲中（按间隔触发）'],
@@ -90,14 +108,17 @@ function isExecutable(p) {
 }
 
 // 返回 {pathDirs}：启动脚本要写进 PATH 的 bin 目录。注入 home/execPath/
-// systemPaths 仅为测试在临时 HOME 里伪造各安装形态。fnm 的
+// cronUpPath/systemPaths 仅为测试在临时 HOME 里伪造各安装形态。fnm 的
 // aliases/default/bin 是跟随 `fnm default` 切换的稳定 symlink（切勿
 // realpath 到版本化目录，fnm 升级后那里会失效）；volta 的 ~/.volta/bin、
 // Homebrew 与官网 pkg 的系统 bin 同理是版本无关的稳定入口。都不认识时退
-// 回当前安装进程自己的 bin 目录：nvm 等按版本目录安装的形态由此覆盖。
+// 回当前安装进程自己的 node bin 目录：nvm 等按版本目录安装的形态由此覆盖。
+// node 目录与当前实际 cron-up 的 bin 目录都必须保留：fnm 非默认版本、nvm
+// 或独立 npm prefix 下两者经常不同，找到稳定 node 后提前返回会丢掉 cron-up。
 export function resolveLauncher(opts = {}) {
   const home = opts.home ?? paths.home;
   const execPath = opts.execPath ?? process.execPath;
+  const cronUpPath = opts.cronUpPath ?? process.argv[1];
   const systemPaths = opts.systemPaths
     ?? ['/opt/homebrew/bin/node', '/usr/local/bin/node'];
 
@@ -111,14 +132,19 @@ export function resolveLauncher(opts = {}) {
     path.join(home, '.volta', 'bin'),
     ...systemPaths.map((p) => path.dirname(p)),
   ];
-  for (const dir of candidates) {
-    if (isExecutable(path.join(dir, 'node'))) return { pathDirs: [dir] };
+  const stableNodeDir = candidates.find((dir) => isExecutable(path.join(dir, 'node')));
+  const nodeDir = stableNodeDir ?? path.dirname(execPath);
+  // argv[1] 保留 npm 全局 bin symlink 的调用路径；不要 realpath 到包内
+  // bin/cron-up.mjs，否则独立 npm prefix 的 shim 目录会丢。无 argv[1] 时
+  // 退回 node 目录，至少覆盖 node 与全局 bin 同目录的常见安装。
+  const cronUpDir = cronUpPath
+    ? path.dirname(path.resolve(cronUpPath)) : path.dirname(execPath);
+  const result = { pathDirs: [...new Set([nodeDir, cronUpDir])] };
+  if (stableNodeDir === undefined) {
+    result.note = '未能定位版本无关的 node bin 目录，已使用当前 node 所在目录；'
+      + '该目录失效（如版本目录被删）时请重新运行 cron-up install';
   }
-  return {
-    pathDirs: [path.dirname(execPath)],
-    note: '未能定位版本无关的 node bin 目录，已使用当前 node 所在目录；'
-      + '该目录失效（如版本目录被删）时请重新运行 cron-up install',
-  };
+  return result;
 }
 
 // ---- plist ----
@@ -145,7 +171,9 @@ function xmlUnescape(s) {
 export function writeServiceScript(launcher) {
   const script = deps.paths.serviceScriptPath;
   fs.mkdirSync(path.dirname(script), { recursive: true });
-  const dirs = launcher.pathDirs.map((d) => `"${d}"`).join(':');
+  // 整个冒号前缀作为一个 shell word 引用：健康检查可无损解回同一串目录，
+  // 空格、单双引号、$ 等字符不会变成 shell 语法。
+  const dirs = shellQuote(launcher.pathDirs.join(':'));
   fs.writeFileSync(script,
     '#!/bin/bash\n'
     + '# 由 cron-up install 生成；重跑 cron-up install 覆盖重生成\n'
@@ -197,6 +225,51 @@ export function readPlistProgramArgs() {
   return parts.length > 0 ? parts : null;
 }
 
+// 解一个 POSIX shell word（不执行它）。覆盖 shellQuote 生成的单引号与
+// '"'"' 拼接，也兼容旧版脚本简单的双引号目录；含未引用空白、命令替换或
+// 变量展开的手改内容拒绝猜测。
+function parseShellWord(source) {
+  let value = '';
+  for (let i = 0; i < source.length;) {
+    const ch = source[i];
+    if (ch === "'") {
+      const end = source.indexOf("'", i + 1);
+      if (end < 0) return null;
+      value += source.slice(i + 1, end);
+      i = end + 1;
+      continue;
+    }
+    if (ch === '"') {
+      i += 1;
+      let closed = false;
+      while (i < source.length) {
+        if (source[i] === '"') {
+          closed = true;
+          i += 1;
+          break;
+        }
+        if (source[i] === '$' || source[i] === '`') return null;
+        if (source[i] === '\\') {
+          if (i + 1 >= source.length) return null;
+          i += 1;
+        }
+        value += source[i];
+        i += 1;
+      }
+      if (!closed) return null;
+      continue;
+    }
+    if (/\s/.test(ch) || /[$`;&|<>()]/.test(ch)) return null;
+    if (ch === '\\') {
+      if (i + 1 >= source.length) return null;
+      i += 1;
+    }
+    value += source[i];
+    i += 1;
+  }
+  return value;
+}
+
 // 从启动脚本内容里解出 PATH 目录；脚本是我们生成的固定格式，解不出（手改
 // 坏）返回 null。
 function scriptPathDirs(scriptPath) {
@@ -207,7 +280,11 @@ function scriptPathDirs(scriptPath) {
     return null;
   }
   const m = text.match(/^export PATH=(.+):"\$PATH"$/m);
-  return m ? m[1].split('":"').map((s) => s.replace(/"/g, '')) : null;
+  if (!m) return null;
+  const prefix = parseShellWord(m[1]);
+  if (!prefix) return null;
+  const dirs = prefix.split(':');
+  return dirs.every(Boolean) ? dirs : null;
 }
 
 // 总览页健康检查：launchd 每轮按启动脚本拉起巡检，脚本丢失、被手改或
@@ -283,27 +360,45 @@ export async function cmdInstall(args) {
   validateConfig(cfg, (m) => deps.print(m));
   if (JSON.stringify(cfg.roots)
       === JSON.stringify(normalizeRoots(DEFAULT_CONFIG.roots))) {
-    // 与 README 安全说明同一句话，在配置落定的这一刻当面再说一遍。
+    // 与 README「安全与自动修改」同一口径，在配置落定时再提示一次。
     deps.print(`提示：未指定 --roots，默认扫描 ${DEFAULT_CONFIG.roots.join('、')}`
       + '（不存在的目录跳过）；今后 clone 进这些容器的仓库也会进入巡检，'
-      + '其中的周期任务会被自动续期永久化。目录布局不同或需收窄时用 '
-      + '--roots 指定（见 README 安全说明）');
+      + '其中的周期任务会被自动续期永久化，任务、CLAUDE.md 与项目配置都会'
+      + '影响无人值守会话。目录布局不同或需收窄时用 --roots 指定'
+      + '（见 README「安全与自动修改」）');
   }
 
-  const launcher = resolveLauncher();
+  const launcher = deps.resolveLauncher();
   if (launcher.note) deps.print(`提示：${launcher.note}`);
 
   const script = writeServiceScript(launcher);
+  fs.mkdirSync(path.dirname(deps.paths.plistPath), { recursive: true });
   fs.writeFileSync(deps.paths.plistPath, renderPlist(script));
   deps.print(`已写入启动脚本与 LaunchAgent：${script}、${deps.paths.plistPath}`);
 
+  // bootstrap 成功只代表 launchd 收下 plist，不代表脚本真能解析 node 与
+  // cron-up。先自检启动链，避免随后的手动首轮巡检掩盖坏脚本。
+  const health = launcherHealth();
+  if (health) {
+    deps.printErr(`启动链自检失败：${health}`);
+    throw new ExitError(1);
+  }
+
   deps.launchctl('bootout', `${guiTarget()}/${LABEL}`);
   const r = deps.launchctl('bootstrap', guiTarget(), deps.paths.plistPath);
   if (r.status !== 0) {
     deps.printErr(`加载到 launchd 失败：\n${r.stderr.trim()}`);
     throw new ExitError(1);
   }
-  deps.launchctl('enable', `${guiTarget()}/${LABEL}`);
+  const enabled = deps.launchctl('enable', `${guiTarget()}/${LABEL}`);
+  if (enabled.status !== 0) {
+    deps.printErr(`启用 launchd 服务失败：\n${enabled.stderr.trim()}`);
+    throw new ExitError(1);
+  }
+  if (deps.launchctlInfo() === null) {
+    deps.printErr('加载后未能向 launchd 核实服务状态，请检查 cron-up 与 launchctl');
+    throw new ExitError(1);
+  }
   deps.print('已加载到 launchd');
 
   // install 与巡检撞车时首轮会被跳过，不能照常说「完成」。
@@ -353,34 +448,79 @@ export async function cmdUninstall(args) {
     throw new ExitError(2, 'uninstall 不支持 --config：卸载操作的是本机固定'
       + `的安装产物（${deps.paths.plistPath} 等）`);
   }
-  const r = deps.launchctl('bootout', `${guiTarget()}/${LABEL}`);
-  if (r.status === 0) deps.print('已从 launchd 卸载');
-
-  // 服务没了就没有回收者：默认结束全部预热会话，不留以 bypass 权限空转
-  // 的孤儿。各会话的停轮询（SIGTERM→等→SIGKILL）互不依赖，先逐个发信
-  // 号再并行等齐。
-  const stopping = [];
-  for (const { label, ent } of allTrackedWarmups()) {
-    deps.print(`正在结束预热会话 ${label}`);
-    stopping.push(deps.stopSession(ent));
+  const lock = deps.acquireRunLock();
+  if (lock === null) {
+    deps.printErr('已有一轮巡检在进行，为避免误删正在使用的产物，本次不卸载；'
+      + '请稍后重试');
+    throw new ExitError(1);
   }
-  await Promise.all(stopping);
+  try {
+    const target = `${guiTarget()}/${LABEL}`;
+    const before = deps.launchctlProbe();
+    if (before.kind === 'unknown') {
+      deps.printErr(`无法确认 launchd 服务状态：${before.message}\n`
+        + '状态未知时不能安全卸载，本次不删除 LaunchAgent、配置或日志');
+      throw new ExitError(1);
+    }
+    if (before.kind === 'unloaded') {
+      deps.print('launchd 服务未加载，无需重复卸载');
+    } else {
+      const r = deps.launchctl('bootout', target);
+      if (r.status !== 0) {
+        deps.printErr(`从 launchd 卸载失败：\n${r.stderr.trim()}\n`
+          + '为避免留下无人回收的预热会话，本次不删除 LaunchAgent、配置或日志');
+        throw new ExitError(1);
+      }
+      const after = deps.launchctlProbe();
+      if (after.kind === 'unknown') {
+        deps.printErr(`bootout 后无法确认 launchd 服务状态：${after.message}\n`
+          + '本次不继续删除 LaunchAgent、配置或日志');
+        throw new ExitError(1);
+      }
+      if (after.kind === 'loaded') {
+        deps.printErr('launchctl bootout 已返回，但服务仍能查到；本次不继续清理');
+        throw new ExitError(1);
+      }
+      deps.print('已从 launchd 卸载');
+    }
 
-  if (fs.existsSync(deps.paths.plistPath)) {
-    fs.rmSync(deps.paths.plistPath, { force: true });
-    deps.print(`已删除 ${deps.paths.plistPath}`);
-  }
+    // 服务没了就没有回收者：默认结束全部预热会话，不留以 bypass 权限空转
+    // 的孤儿。各会话的停轮询（SIGTERM→等→SIGKILL）互不依赖，先逐个发信
+    // 号再并行等齐。
+    const stopping = [];
+    for (const { label, ent } of allTrackedWarmups()) {
+      deps.print(`正在结束预热会话 ${label}`);
+      stopping.push(deps.stopSession(ent).then(
+        (stopped) => stopped ? null : label,
+      ));
+    }
+    const unsafe = (await Promise.all(stopping))
+      .filter((label) => label !== null);
+    if (unsafe.length > 0) {
+      deps.printErr('警告：以下预热会话仍活着，本次无法安全停止：'
+        + `${unsafe.join('、')}。已中止后续清理，`
+        + '不会继续删除 LaunchAgent、配置或日志；请人工核对后重试');
+      throw new ExitError(1);
+    }
 
-  if (args.purge) {
-    for (const p of [deps.paths.dataDir, deps.paths.logDir]) {
-      fs.rmSync(p, { recursive: true, force: true });
-      deps.print(`已删除 ${p}`);
+    if (fs.existsSync(deps.paths.plistPath)) {
+      fs.rmSync(deps.paths.plistPath, { force: true });
+      deps.print(`已删除 ${deps.paths.plistPath}`);
     }
-    // npm 管的文件不能手删：命令行本身交给 npm 卸载。
-    deps.print('命令行本身请运行 npm uninstall -g cron-up 卸载');
-  } else {
-    deps.print('配置与日志已保留（--purge 可删除全部产物）');
+
+    if (args.purge) {
+      for (const p of [deps.paths.dataDir, deps.paths.logDir]) {
+        fs.rmSync(p, { recursive: true, force: true });
+        deps.print(`已删除 ${p}`);
+      }
+      // npm 管的文件不能手删：命令行本身交给 npm 卸载。
+      deps.print('命令行本身请运行 npm uninstall -g cron-up 卸载');
+    } else {
+      deps.print('配置与日志已保留（--purge 可删除 cron-up 自有配置与日志）');
+    }
+  } finally {
+    deps.releaseRunLock(lock);
   }
 }
 
-Object.assign(deps, { launchctl, launchctlInfo });
+Object.assign(deps, { launchctl, launchctlInfo, launchctlProbe, resolveLauncher });

package/src/sessions.mjs

@@ -81,7 +81,8 @@ export function sessionArgv(ws, logPath) {
   // 里靠继承现成 PATH 一切正常，交给 launchd 就 fnm: command not found。
   return [
     '/usr/bin/script', '-q', logPath,
-    '/bin/zsh', '-lic', `cd ${shellQuote(ws)} && claude`,
+    '/bin/zsh', '-lic',
+    `cd ${shellQuote(ws)} && claude --permission-mode bypassPermissions`,
   ];
 }
 
@@ -109,14 +110,20 @@ export function rotateOnce(file) {
   fs.renameSync(file, old);
 }
 
+// 进程组信号只接受明确大于 1 的整数 pid：0/-1 等有广播含义，浮点、
+// 负数或非安全整数也都不能交给 process.kill。
+function canSignalProcessGroup(pid) {
+  return Number.isSafeInteger(pid) && pid > 1;
+}
+
 // 为一个任务拉起一个 detached 的 pty TUI，返回 {pid, procStart}。
 export function spawnSession(ws, taskId) {
   const logPath = sessionLogPath(ws, taskId);
-  // 会话日志目录 700（README 承诺）：每任务独立文件，目录只在此处创建。
+  // 会话日志目录 700（README 权限约定）：每任务独立文件，目录只在此处创建。
   ensurePrivateDir(path.dirname(logPath));
-  // 「一代会话 = 一次执行」：script(1) 打开即截断，不轮转的话上一代（上
-  // 一次执行）的界面记录会随本次拉起被抹掉。无条件保留一代（.1）——总
-  // 量上界两代，活着的一代增长再快也只影响自身，不会经轮转放大。
+  // script(1) 启动即截断：每次新拉起前无条件保留上一代（.1），避免上次
+  // 启动以来的界面记录被抹掉。总量上界两代，活着的一代增长再快也只影响
+  // 自身，不会经轮转放大。
   try {
     if (fs.existsSync(logPath)) rotateOnce(logPath);
   } catch {
@@ -149,34 +156,68 @@ export function spawnSession(ws, taskId) {
   // 拉不起来（spawn 当场失败，pid 是 undefined）时返回 null：没有进程可跟
   // 踪，调用方按启动失败计数，不把 pid=undefined 写进 state。
   if (child.pid === undefined) return null;
-  return { pid: child.pid, procStart: deps.procStartedAt(child.pid) };
+  let procStart = null;
+  let fingerprintError = null;
+  try {
+    procStart = deps.procStartedAt(child.pid);
+  } catch (e) {
+    fingerprintError = e;
+  }
+  if (procStart) return { pid: child.pid, procStart };
+
+  // 没有指纹的条目今后无法安全发信号，不能登记成正常会话。这里只清理
+  // 刚刚由本次 spawn 创建的进程组；pid 形状异常时宁可留下日志也不冒险。
+  const reason = fingerprintError
+    ? `读取进程身份指纹失败：${fingerprintError?.message ?? fingerprintError}`
+    : '未读到进程身份指纹';
+  let cleanup;
+  if (canSignalProcessGroup(child.pid)) {
+    try {
+      process.kill(-child.pid, 'SIGTERM');
+      cleanup = '已向刚拉起的进程组发送 SIGTERM';
+    } catch (e) {
+      cleanup = `清理刚拉起的进程组失败：${e?.code ? `${e.code}：` : ''}`
+        + `${e?.message ?? e}`;
+    }
+  } else {
+    cleanup = 'pid 不是大于 1 的整数，未发信号';
+  }
+  deps.log(`会话启动失败 ${ws} 任务 ${taskId} pid=${child.pid}：${reason}；`
+    + cleanup);
+  return null;
 }
 
 // 按进程组结束我们拉起的会话。发信号前先核身份：state 条目可能比它命名
 // 的进程活得久，给回收 pid 发组信号会杀掉无关进程组。detached（用户
-// resume 接管）时 trackedAlive 为 false：本函数直接返回，绝不碰用户的裸
-// claude。
+// resume 接管）时 trackedAlive 为 false：本函数返回 true，绝不碰用户的裸
+// claude。false 表示记录的进程仍活着，但因缺少指纹或信号失败而未能安全
+// 停止；调用方必须保留跟踪并告警，不能假装已经回收。
 export async function stopSession(ent) {
-  if (!deps.trackedAlive(ent)) return;
-  const pid = ent.pid;
+  const pid = ent?.pid;
+  if (!canSignalProcessGroup(pid)) return true;
+  if (!deps.trackedAlive(ent)) return true;
+  // trackedAlive 为兼容旧条目会在没有 procStart 时退回 kill -0；读取可以
+  // 沿用这个判断，停止却不行。死进程无需处理，活进程只能如实报告未停止。
+  if (!ent.procStart) return deps.alive(pid) ? false : true;
   try {
     process.kill(-pid, 'SIGTERM');
   } catch {
-    return;
+    return deps.alive(pid) ? false : true;
   }
   for (let i = 0; i < 20; i++) {
     await deps.sleep(100);
-    if (!deps.alive(pid)) return;
+    if (!deps.alive(pid)) return true;
   }
-  // 升级 SIGKILL 前再核一次指纹。
-  if (deps.trackedAlive(ent)) {
-    try {
-      process.kill(-pid, 'SIGKILL');
-    } catch {
-      // 组已消失。
-    }
-    await deps.sleep(100);
+  if (!deps.trackedAlive(ent)) return true;
+  // 升级 SIGKILL 前已再核一次指纹；信号失败或结束后仍是同一进程，都不能
+  // 向调用方报告停止成功。
+  try {
+    process.kill(-pid, 'SIGKILL');
+  } catch {
+    return deps.alive(pid) ? false : true;
   }
+  await deps.sleep(100);
+  return deps.trackedAlive(ent) ? false : true;
 }
 
 // typescript 多少秒没被写。文件缺失读作「没有任何活动证据」：Infinity 大

package/src/tasks.mjs

@@ -1,5 +1,5 @@
-// Claude Code 任务文件层：发现工作区、读任务、续期（permanent 标记）、id
-// 改小、归属盖印与原子写。任务文件是另一个程序写的外部输入，所有入口都
+// Claude Code 任务文件层：发现工作区、读任务、续期（permanent 标记）、
+// 归属盖印与原子写。任务文件是另一个程序写的外部输入，所有入口都
 // 校验形状，坏数据读作「没有任务」而不是抛进巡检循环。
 
 import fs from 'node:fs';
@@ -10,8 +10,6 @@ import { deps, isPlainObject } from './internals.mjs';
 import { TASK_REL } from './paths.mjs';
 import {
   PRUNE_DIRS,
-  CC_JITTER,
-  AUTO_MIN_ID_TARGET_DELAY_MS,
   MAX_SCAN_DEPTH,
 } from './constants.mjs';
 
@@ -140,9 +138,9 @@ export function taskKey(t) {
   return `anon:${createHash('sha1').update(taskSig(t)).digest('hex').slice(0, 16)}`;
 }
 
-// 任务的稳定内容签名：只含不会被我们与调度器改动的字段。minify 改 id、盖
-// 印改 createdBy*、执行改 lastFiredAt、续期加 permanent 都不改变签名——
-// 它是「id 改写前后 state 条目改键」与「一批多 target 盖印」的串联键。
+// 任务的稳定内容签名：只含不会被我们与调度器改动的字段。盖印改
+// createdBy*、执行改 lastFiredAt、续期加 permanent 都不改变签名；无 id
+// 任务的 taskKey 用它生成内容摘要键。
 export function taskSig(t) {
   return JSON.stringify([
     t?.cron ?? null,
@@ -152,9 +150,25 @@ export function taskSig(t) {
   ]);
 }
 
+// 按任务身份键分组的共享视图：重复键天然落在同一组，调用方不必各自
+// 维护重复计数与键集合。非对象条目不参与盖印或巡检，和 readTasks/
+// maintain 的既有口径一致。
+export function groupTasksByKey(tasks) {
+  const groups = new Map();
+  for (const t of tasks) {
+    if (!isPlainObject(t)) continue;
+    const key = taskKey(t);
+    const group = groups.get(key) ?? [];
+    group.push(t);
+    groups.set(key, group);
+  }
+  return groups;
+}
+
 // 任务文件在「读到」与「写回」之间被别的写者改了（Claude Code 更新
-// lastFiredAt 或删除已触发任务）：绝不覆盖，抛 TaskFileChanged 让下轮
-// 巡检基于更新的文档重试。
+// lastFiredAt 或删除已触发任务）：最终检查时能发现就抛 TaskFileChanged，
+// 让下轮巡检基于更新的文档重试。检查与 rename 之间仍有极小竞态，不能把
+// 这层检测当成与上游共用的互斥锁。
 export class TaskFileChanged extends Error {
   constructor(file) {
     super(`任务文件已被其他写者改动：${file}`);
@@ -184,8 +198,8 @@ function tmpSibling(file) {
 
 // 旁边写再 rename 的原子替换，保留原文件权限位与中文字面量。
 // tmp 以 0600 创建（绝不更宽），写完再放宽到原 mode。expectedMtimeNs 是
-// 乐观锁：路径 mtime 自调用方读后变了说明别的写者抢先，抛
-// TaskFileChanged 而不是覆盖它的更新。
+// 乐观检测：最终检查时路径 mtime 已变说明别的写者抢先，抛 TaskFileChanged
+// 而不是覆盖这次检查之前发生的更新。
 export function atomicWriteJson(file, doc, expectedMtimeNs) {
   let mode = 0o600;
   try {
@@ -221,72 +235,17 @@ export function atomicWriteJson(file, doc, expectedMtimeNs) {
   fs.renameSync(tmp, file);
 }
 
-// 严格 8 位十六进制的任务 id（Claude Code 自己生成的形状）转数值；其他
-// 形状（短串、UUID、缺失、非字符串）返回 null——它们算「未达标」，由
-// minifyIds 改写成合规小号。
-export function parseTaskIdN(id) {
-  if (typeof id !== 'string' || !/^[0-9a-fA-F]{8}$/.test(id)) return null;
-  return parseInt(id, 16);
-}
-
-// autoMinId 的 id 数值上界：每日任务延迟 ≤ AUTO_MIN_ID_TARGET_DELAY_MS。
-export function minTaskIdMaxN() {
-  return Math.floor(
-    AUTO_MIN_ID_TARGET_DELAY_MS
-      / (CC_JITTER.recurringFrac * 86400_000) * 2 ** 32);
-}
-
-// 把显式周期任务里 id 数值超过上界（或形状不合法）的，改写成文件内未占用
-// 的小号（00000001 起的 8 位十六进制），使其投递抖动降到目标延迟内。原地
-// 修改 tasks 元素，返回 {changed, idChanges}；idChanges 用 taskKey 口径
-// 记录改前/改后键，巡检同轮把 state 条目跟着改键（state 以任务 id 为
-// 键，不改键会把刚换 id 的任务误判为「旧任务删除 + 新任务」而错杀重
-// 拉）。关键纪律：
-//   - 只碰 t.recurring truthy 的显式周期任务，一次性与无标志手写条目不碰；
-//   - 已达标的小号（含 00000000）原样保留，永不重排——多次巡检结果稳定，
-//     第二轮起 0 改动、文件字节不动；
-//   - 空号在「文件内全部任务」（含一次性）已占用的 id 之外分配，保证同文
-//     件唯一；跨文件重复无妨（各工作区独立加载）。
-export function minifyIds(tasks) {
-  const maxN = minTaskIdMaxN();
-  const used = new Set();
-  for (const t of tasks) {
-    if (!isPlainObject(t)) continue;
-    const n = parseTaskIdN(t.id);
-    if (n !== null) used.add(n);
-  }
-  let next = 1;
-  const takeFree = () => {
-    while (used.has(next)) next += 1;
-    used.add(next);
-    return next;
-  };
-  let changed = 0;
-  const idChanges = [];
-  for (const t of tasks) {
-    if (!isPlainObject(t) || !t.recurring) continue;
-    const n = parseTaskIdN(t.id);
-    if (n !== null && n <= maxN) continue;
-    const from = taskKey(t);
-    const to = takeFree().toString(16).padStart(8, '0');
-    t.id = to;
-    changed += 1;
-    idChanges.push({ from, to });
-  }
-  return { changed, idChanges };
-}
-
-// 一轮巡检对一个任务文件做的维护：renew（补 permanent）、minify（id 改
-// 小）、reown（把任务归属盖给各自的预热会话）合并为同一次受 mtime 乐观
-// 锁保护的原子写。renew/minify 无条件执行，没有开关。先取 mtimeNs、清残
-// 留 .cron-up-tmp、loadTaskDoc round-trip 整文档；三项计数都为 0 时字节
-// 级不动。返回 {renewed,minified,reowned,idChanges}；null 表示文件缺失/
-// 损坏；读到写间被改抛 TaskFileChanged。
+// 一轮巡检对一个任务文件做的维护：renew（补 permanent）与 reown（把任务
+// 归属盖给各自的预热会话）合并为同一次带 mtime 乐观检测的原子写。先取
+// mtimeNs、清残留 .cron-up-tmp、loadTaskDoc round-trip 整文档；两项计数
+// 都为 0 时字节级不动。返回 {renewed,reowned}；null 表示文件缺失/损坏；
+// 读到写间被改抛 TaskFileChanged。
 //
-// reown 形状：Map<taskSig, {sessionId, pid, procStart}>。一轮内同一文件的
-// 不同任务可盖向不同预热（一任务一会话）；Map 以签名为键，minify 先改 id
-// 不影响随后的盖印查找。只盖 createdBySessionId 不等于目标的任务，第二轮
-// 起字节级不动；pid/procStart 是会话登记里 claude 进程的 pid 与 lstart。
+// reown 形状：Map<taskKey, {sessionId, pid, procStart}>。一轮内同一文件的
+// 不同任务可盖向不同预热（一任务一会话）；内容相同但 id 不同的任务互不
+// 影响。同一个 taskKey 对应多条任务是病态输入，无法把 state/会话唯一对应
+// 到条目，这些键全部跳过盖印。只盖 createdBySessionId 不等于目标的任务，
+// 第二轮起字节级不动；pid/procStart 是登记里 claude 进程的 pid 与 lstart。
 export function maintainWorkspace(taskfile, { reown = null } = {}) {
   let mtimeNs;
   try {
@@ -306,23 +265,25 @@ export function maintainWorkspace(taskfile, { reown = null } = {}) {
   if (doc === null) return null;
   let renewed = 0;
   for (const t of doc.tasks) {
+    if (!isPlainObject(t)) continue;
     // truthy 而非 === true：与 Claude Code 自己的加载器一致
     // （...o.permanent && {permanent:true}），它已认作永久的任何值都算，
     // 不再重写。只有显式周期任务有资格——绝不从 cron 形状推断周期性，
     // 一次性任务不碰。
-    if (isPlainObject(t) && t.recurring && !t.permanent) {
+    if (t.recurring && !t.permanent) {
       t.permanent = true;
       renewed += 1;
     }
   }
-  const { changed: minified, idChanges } = minifyIds(doc.tasks);
   let reowned = 0;
   if (reown instanceof Map && reown.size > 0) {
-    for (const t of doc.tasks) {
+    // 只有确实需要盖印时才计算任务键；纯续期与常见空操作不付摘要成本。
+    for (const [key, group] of groupTasksByKey(doc.tasks)) {
+      if (group.length !== 1) continue;
+      const t = group[0];
+      const target = reown.get(key);
       // 没有 owner 字段的外部条目同样盖——窗口内任务统一归各自预热，语义
       // 不因条目来源留例外。
-      if (!isPlainObject(t)) continue;
-      const target = reown.get(taskSig(t));
       if (target && t.createdBySessionId !== target.sessionId) {
         t.createdBySessionId = target.sessionId;
         t.createdByPid = target.pid;
@@ -332,11 +293,11 @@ export function maintainWorkspace(taskfile, { reown = null } = {}) {
       }
     }
   }
-  if (renewed === 0 && minified === 0 && reowned === 0) {
-    return { renewed: 0, minified: 0, reowned: 0, idChanges: [] };
+  if (renewed === 0 && reowned === 0) {
+    return { renewed: 0, reowned: 0 };
   }
   atomicWriteJson(taskfile, doc, mtimeNs);
-  return { renewed, minified, reowned, idChanges };
+  return { renewed, reowned };
 }
 
 Object.assign(deps, { discover, readTasks, loadTaskDoc });