cron-up 26.10.30 → 26.10.31

package/src/config.mjs

@@ -62,48 +62,21 @@ export function parsePid(v) {
   return pid > 0 && pid <= PID_T_MAX ? pid : null;
 }
 
-// 配置字段的类型规则，loadConfig 与 install --force 继承旧配置共用。返回
-// [字段名, 人话错误][]：手改把字段写坏时绝不静默回退——回退的两个可能方向
-// （roots 坏 → 回扫整个家目录、autoRenew 坏 → 回开续期）都比停机更危险。
+// 配置只有 roots 一个字段：手改写坏它时绝不静默回退——回退成空数组是
+// 「形同空转」，回退成默认家目录扫描则会动到用户没打算纳入的仓库，两个
+// 方向都比停机更危险。
 export function configFieldErrors(cfg) {
-  const errs = [];
   if (!Array.isArray(cfg.roots)) {
-    errs.push(['roots', `roots 应是字符串数组，当前为 ${JSON.stringify(cfg.roots)}`]);
+    return [['roots', `roots 应是字符串数组，当前为 ${JSON.stringify(cfg.roots)}`]];
   }
-  if (!isInt(cfg.maxDepth) || cfg.maxDepth < 0) {
-    errs.push(['maxDepth', `maxDepth 应是非负整数，当前为 ${JSON.stringify(cfg.maxDepth)}`]);
-  }
-  if (!isInt(cfg.intervalSeconds) || cfg.intervalSeconds <= 0) {
-    errs.push(['intervalSeconds',
-      `intervalSeconds 应是正整数秒，当前为 ${JSON.stringify(cfg.intervalSeconds)}`]);
-  }
-  if (!isInt(cfg.leadSeconds) || cfg.leadSeconds < 0) {
-    errs.push(['leadSeconds',
-      `leadSeconds 应是非负整数秒，当前为 ${JSON.stringify(cfg.leadSeconds)}`]);
-  }
-  if (typeof cfg.autoRenew !== 'boolean') {
-    errs.push(['autoRenew',
-      `autoRenew 应是布尔值（true/false），当前为 ${JSON.stringify(cfg.autoRenew)}`]);
-  }
-  if (typeof cfg.autoMinId !== 'boolean') {
-    errs.push(['autoMinId',
-      `autoMinId 应是布尔值（true/false），当前为 ${JSON.stringify(cfg.autoMinId)}`]);
-  }
-  if (cfg.sessionRetain !== 'window' && cfg.sessionRetain !== 'always') {
-    errs.push(['sessionRetain',
-      `sessionRetain 应是 "window" 或 "always"，当前为 ${JSON.stringify(cfg.sessionRetain)}`]);
-  }
-  if (typeof cfg.stampOwner !== 'boolean') {
-    errs.push(['stampOwner',
-      `stampOwner 应是布尔值（true/false），当前为 ${JSON.stringify(cfg.stampOwner)}`]);
-  }
-  return errs;
+  return [];
 }
 
 // opts.missingOk：缺失文件把异常抛给调用方（总览页把「缺失」当页面内容的
-// 一部分）；opts.corruptOk：损坏 JSON/顶层非对象/字段类型错抛普通错误而非
-// exit（总览页把它们当页面内容展示）。launchd 的 run 入口两个都不要——它
-// 该死成一行原因而不是 traceback。
+// 一部分）；opts.corruptOk：损坏 JSON/顶层不是对象/roots 类型错抛普通错
+// 误而非 exit（总览页把它们当页面内容展示）。launchd 的 run 入口两个都不
+// 要——它该死成一行原因而不是 traceback。配置里的其余键（旧版本留下的
+// intervalSeconds 等）一律忽略：行为已全部常量化，install 重写时纯化。
 export function loadConfig(file, opts = {}) {
   const fail = (message) => {
     if (opts.corruptOk) throw new Error(message);
@@ -123,26 +96,67 @@ export function loadConfig(file, opts = {}) {
     throw new ExitError(2, `配置文件不是合法 JSON：${file}\n  ${e.message}`);
   }
   if (!isPlainObject(cfg)) {
-    // 合法 JSON 但顶层不是对象（123、["a"]）：与「不是合法 JSON」同等对待。
-    // 单行消息：总览页按宽度截断展示，断行会失去告警前缀。
     fail(`配置文件顶层应是 JSON 对象而不是${Array.isArray(cfg) ? '数组' : typeof cfg}：`
       + `${file}；运行 cron-up install 生成，或用 --config 指定路径`);
   }
   const merged = { ...DEFAULT_CONFIG, ...cfg };
   const errs = configFieldErrors(merged);
   if (errs.length > 0) {
-    // 单行消息（字段在前、修复指引在后）：总览页按宽度截断展示，截尾只
-    // 伤修复指引，不伤字段清单。
     fail(`配置字段类型不对：${errs.map(([, m]) => m).join('；')}`
-      + `；修复 ${file} 或重跑 cron-up install --force`);
+      + `；修复 ${file} 或重跑 cron-up install`);
+  }
+  return { roots: normalizeRoots(merged.roots) };
+}
+
+// ---- state.json：两级嵌套 {ws: {taskId: entry}} ----
+//
+// entry 字段：pid/procStart（script 层指纹）、claudePid/sessionId/
+// claudeProcStart（认亲后回填）、startedAt、fails、cooldownUntil、
+// deadSince、log、notified。pid 为 null 的条目是「当场没拉起/冷却中」的
+// 合法形态；未认亲时 claude* 三字段缺省。
+
+// 旧版顶层标记字段：旧 state 是 {ws: entry}，新 state 是 {ws: {taskId:
+// entry}}。taskId 只可能是 8 位十六进制或 anon: 前缀，永不与这些名字冲
+// 突，因此「顶层值自身是否带 entry 标记」就是两代形状的区分判据。
+const LEGACY_MARKERS = ['pid', 'startedAt', 'cooldownUntil', 'fails'];
+
+function cleanEntry(raw, ws, taskId) {
+  if (!isPlainObject(raw)) return null;
+  const ent = { ...raw };
+  ent.pid = parsePid(ent.pid);
+  if (ent.claudePid !== undefined) {
+    const claudePid = parsePid(ent.claudePid);
+    if (claudePid === null) delete ent.claudePid;
+    else ent.claudePid = claudePid;
+  }
+  for (const k of ['startedAt', 'cooldownUntil', 'fails', 'deadSince']) {
+    if (ent[k] !== null && ent[k] !== undefined) {
+      try {
+        ent[k] = lenientInt(ent[k]);
+      } catch {
+        delete ent[k];
+      }
+    }
+  }
+  // 身份字符串：存在就必须是非空字符串，否则删掉（ws/taskId 随即用键补
+  // 回）。
+  for (const k of ['ws', 'taskId', 'sessionId', 'log', 'procStart',
+    'claudeProcStart']) {
+    if (ent[k] !== undefined
+        && (typeof ent[k] !== 'string' || ent[k] === '')) {
+      delete ent[k];
+    }
   }
-  merged.roots = normalizeRoots(merged.roots);
-  return merged;
+  if (typeof ent.notified !== 'boolean') delete ent.notified;
+  ent.ws = ws;
+  ent.taskId = taskId;
+  return ent;
+}
+
+function looksLegacyEntry(v) {
+  return isPlainObject(v) && LEGACY_MARKERS.some((k) => k in v);
 }
 
-// 自己的文件也可能被手改或截断：非对象读成「没有 state」，数值字段入口处
-// 整型化并卡范围——否则 kill 收到字符串会抛、负数 pid 会被当成进程组号
-// 误伤无辜进程组、超 pid_t 上界的整数直到 kill 才炸。
 export function loadState() {
   let state;
   try {
@@ -152,20 +166,38 @@ export function loadState() {
   }
   if (!isPlainObject(state)) return {};
   const out = {};
+  for (const [ws, bucket] of Object.entries(state)) {
+    // 旧版顶层 entry 不是桶：跳过（由 loadLegacyEntries 收口处理）。
+    if (!isPlainObject(bucket) || looksLegacyEntry(bucket)) continue;
+    const cleanBucket = {};
+    for (const [taskId, raw] of Object.entries(bucket)) {
+      const ent = cleanEntry(raw, ws, taskId);
+      if (ent) cleanBucket[taskId] = ent;
+    }
+    if (Object.keys(cleanBucket).length > 0) out[ws] = cleanBucket;
+  }
+  return out;
+}
+
+// 旧版扁平 state（{ws: 目录级单 entry}）：升级轮用它停掉旧预热后整体丢
+// 弃，不迁移任务归属（新流程按任务重拉）。与 loadState 读同一个文件，
+// 两个读取器按标记字段互斥，互不污染。
+export function loadLegacyEntries() {
+  let state;
+  try {
+    state = JSON.parse(fs.readFileSync(deps.paths.statePath, 'utf-8'));
+  } catch {
+    return [];
+  }
+  if (!isPlainObject(state)) return [];
+  const out = [];
   for (const [ws, raw] of Object.entries(state)) {
-    if (!isPlainObject(raw)) continue;
-    const ent = { ...raw };
-    ent.pid = parsePid(ent.pid);
-    for (const k of ['startedAt', 'cooldownUntil', 'fails', 'deadSince']) {
-      if (ent[k] !== null && ent[k] !== undefined) {
-        try {
-          ent[k] = lenientInt(ent[k]);
-        } catch {
-          delete ent[k];
-        }
-      }
+    if (!looksLegacyEntry(raw)) continue;
+    const ent = cleanEntry(raw, ws, null);
+    if (ent) {
+      delete ent.taskId; // 旧 entry 没有任务身份
+      out.push(ent);
     }
-    out[ws] = ent;
   }
   return out;
 }
@@ -238,14 +270,6 @@ export function validateConfig(cfg, announce = () => {}) {
   if (!cfg.roots || cfg.roots.length === 0) {
     warnings.push('扫描目录 roots 为空：巡检不会发现任何工作区，cron-up 形同空转');
   }
-  const interval = cfg.intervalSeconds;
-  const lead = cfg.leadSeconds;
-  if (isInt(interval) && isInt(lead) && interval > 0 && lead >= 0
-      && lead < interval) {
-    warnings.push(
-      `leadSeconds=${lead} 小于 intervalSeconds=${interval}：任务可能在`
-      + '两轮巡检之间到期而来不及提前启动会话，建议 lead ≥ interval');
-  }
   for (const root of cfg.roots ?? []) {
     if (!isDir(root)) warnings.push(`扫描目录不存在，巡检不会覆盖它：${root}`);
   }

package/src/constants.mjs

@@ -1,41 +1,25 @@
 // 全部调参常量集中一处，改动时便于通盘核对。
 
+// 配置文件只有 roots 一个字段：巡检间隔、提前量、扫描深度、续期、改 id、
+// 任务归属盖印都是不可关闭的唯一行为（见 README），常量化在本文件。
 export const DEFAULT_CONFIG = {
-  // 默认只扫本人的三个任务制容器（两层深覆盖 <容器>/<仓>及其一级子目录），
-  // 不扫整个家目录——他人可写仓库里的周期任务会被自动续期永久化，默认范围
-  // 必须是用户完全掌控的领地（见 README 安全说明）。其他布局用 --roots 覆
-  // 盖；目录不存在则跳过。
+  // 默认只扫本人的三个任务制容器，不扫整个家目录——他人可写仓库里的周期
+  // 任务会被自动续期永久化，默认范围必须是用户完全掌控的领地（见 README
+  // 安全说明）。其他布局用 cron-up install --roots 覆盖；目录不存在则跳过。
   roots: ['~/space', '~/workspace', '~/tasks'],
-  maxDepth: 2,
-  intervalSeconds: 300,
-  leadSeconds: 600,
-  // 每轮巡检给周期任务补 permanent 标记，绕开 Claude Code 的 7 天周期任务
-  // 过期。loadConfig 会用默认值补缺键，所以安装或升级后的首轮会把旧任务
-  // 全部补标。配置里 autoRenew:false 可关（下轮生效），或安装时
-  // --no-auto-renew。
-  autoRenew: true,
-  // 每轮巡检把周期任务的 id 改写成小哈希值，把投递抖动压到
-  // AUTO_MIN_ID_TARGET_DELAY_MS 以内（每日任务约 1 分钟），观感近乎准点。
-  // 只改显式周期任务、只分配文件内空号、幂等。配置 autoMinId:false 可关，
-  // 或安装时 --no-auto-min-id。机制见 CC_JITTER 与 findings 主题
-  // claude-code-scheduled-task-jitter。
-  autoMinId: true,
-  // 会话保留策略：'window'（默认）——会话生命周期对齐「一次执行」：任务
-  // 触发过、执行完毕且距下次需要还有余量即回收，下次窗口重拉，任务之间
-  // 上下文不互相累积；'always'——旧常驻行为，执行间隔里也保留会话，仅受
-  // 7 天超龄换代约束。
-  sessionRetain: 'window',
-  // 任务归属改写：默认关，维持「同目录有会话就不双开」的旧行为。开启后，
-  // 即使用户本人的交互会话在场，也另拉独立预热会话，并把投递窗口内任务的
-  // createdBySessionId/createdByPid/createdByProcStart 三字段改写成预热会话
-  // ——任务按 Claude Code 自身的「创建者会话铁拿」规则投到预热会话，用户
-  // 会话主动不碰；预热死亡则自动滑回原生的死者接管规则。依赖 Claude Code
-  // 未公开的任务文件字段与进程父子关系，见 README「任务归属预热」。
-  stampOwner: false,
 };
 
+// launchd 两轮巡检之间的秒数（plist 的 StartInterval）。
+export const INTERVAL_SECONDS = 300;
+// 提前多少秒为窗口内任务备好会话：覆盖两轮巡检（本轮发现、下轮盖印），任
+// 何任务最迟在执行前一轮被发现；会话登记本身只需约 10 秒。
+export const LEAD_SECONDS = 600;
+// 工作区发现的最大递归深度（相对 roots）：深度 3 覆盖
+// <容器>/<仓>/<子目录>/<孙目录> 里的任务文件。
+export const MAX_SCAN_DEPTH = 3;
+
 // 预热会话连续三次启动后死亡，大概率是环境坏了（缺信任、env 不对），退避
-// 而不是每 5 分钟无限重拉。
+// 而不是每轮无限重拉。
 export const FAIL_LIMIT = 3;
 export const COOLDOWN_SECONDS = 1800;
 // 失败计数随死条目保留的时长。提前窗口通常只覆盖一两轮巡检（每小时任务
@@ -50,20 +34,16 @@ export const PID_T_MAX = 2 ** 31 - 1;
 // 健康会话约 10 秒内完成登记。超时仍存活却没登记，是卡在无人应答的提问
 // 界面（目录信任、工具授权）；只看存活会把它当健康，只有这个时限兜得住。
 export const WARMUP_GRACE_SECONDS = 180;
-// 预热会话是缓存不是宠物：「永久」任务让它无限常驻会把它钉死在启动当天的
-// claude 版本和不断增长的 typescript 上。超龄会话仅在日志静默一段时间后
-// 才退役——日志安静是没有任务在执行的证据，运行中的任务绝不会被切掉。
-export const SESSION_MAX_AGE_SECONDS = 7 * 86400;
-export const SESSION_IDLE_SECONDS = 3600;
-// window 模式回收判据一：界面静默超过此时长视为「本次执行已结束」。TUI
-// 工作时持续渲染（毫秒级刷新 typescript），静默 3 分钟不可能是在执行；取
-// WARMUP_GRACE 同值，结构上对齐「3 分钟定生死」的既有心智（调一个跟着
-// 动）。
+// window 回收判据一：界面静默超过此时长视为「本任务已执行完」。TUI 工作
+// 时持续渲染（毫秒级刷新 typescript），静默 3 分钟不可能是在执行；取
+// WARMUP_GRACE 同值，结构上对齐「3 分钟定生死」的既有心智。
 export const SESSION_RECYCLE_IDLE_SECONDS = WARMUP_GRACE_SECONDS;
-// window 模式回收判据二：距下次「需要会话在场」的时刻至少还有这么多秒。
-// 回收后同轮重拉的新会话约 10 秒完成登记，余量保的是登记抖动；更近的触
-// 发直接复用现有会话（时间紧邻的任务共享）。
+// window 回收判据二：距该任务下次「需要会话在场」至少还有这么多秒。回收
+// 后要经「下轮重拉 → 新会话登记 → 再下轮盖印」两步，任务才重新铁定投到
+// 新预热：一个巡检间隔加登记抖动余量。更近的触发不回收，复用现有会话。
 export const SESSION_FIRE_MARGIN_SECONDS = 120;
+export const SESSION_RECYCLE_MARGIN_SECONDS =
+  SESSION_FIRE_MARGIN_SECONDS + INTERVAL_SECONDS;
 // 巡检日志每轮两行心跳加零星事件，跑几年的机器也该有上限。launchd 每次按
 // 路径重开，轮初改名是安全的：本轮 fd 继续写改名后的 inode，下轮开新文件。
 export const PATROL_LOG_ROTATE_BYTES = 1024 * 1024;
@@ -82,7 +62,7 @@ export const PRUNE_DIRS = new Set([
 
 // Claude Code 会话投递定时任务时的抖动参数，两处使用：list/总览预测
 // 「预计实际触发时间」；巡检把「落点之后、延迟投递点之前」这段投递尾窗
-// 也算作需要会话在场，避免 window 模式在任务真正投递前回收会话。逆向自
+// 也算作需要会话在场，避免在任务真正投递前把预热回收。逆向自
 // Claude Code v2.1.285
 // （darwin-arm64 原生二进制，2026-09-30 安装）内部 createCronScheduler 的
 // gV 默认值：周期任务 fire = 落点 + min(hash(id)·recurringFrac·周期,

package/src/list.mjs

@@ -1,8 +1,10 @@
-// `cron-up list`：逐工作区列出任务的下次触发、节奏、类型与摘要，标注
-// 该目录当前有没有交互会话。
+// `cron-up list`：逐工作区列出任务的下次触发、节奏、类型、摘要与该任务
+// 的预热状态。
 
 import { deps } from './internals.mjs';
-import { loadConfig } from './config.mjs';
+import { LEAD_SECONDS } from './constants.mjs';
+import { loadConfig, loadState, isCooling } from './config.mjs';
+import { taskKey } from './tasks.mjs';
 import {
   clip,
   pad,
@@ -25,16 +27,34 @@ function statusText(v) {
   return fmtFireRange(v.nxt, v.fire);
 }
 
+// 单个任务的预热状态标签。创建者会话还开着时返回空串——任务原生投进创
+// 建者，无需预热；其余按 entry 的派生阶段给短标签。
+function warmTag(t, v, ent, liveSids, ws, cur) {
+  if (deps.creatorSessionAlive(t, liveSids)) return '';
+  if (ent) {
+    if (isCooling(ent, cur)) return '冷却中';
+    if (deps.trackedAlive(ent)) {
+      return ent.sessionId ? `预热中 ${ent.pid}` : `启动中 ${ent.pid}`;
+    }
+    if (typeof ent.sessionId === 'string'
+        && (liveSids.has(ent.sessionId))) return '终端接管';
+    if ((ent.fails ?? 0) > 0) return `失败${ent.fails}次`;
+  }
+  return v.wanted ? '待预热' : '';
+}
+
 export async function cmdList(args) {
   const cfg = loadConfig(args?.config ?? deps.paths.configPath);
   const now = new Date();
+  const cur = Math.floor(now.getTime() / 1000);
   const cols = deps.terminalWidth();
   const blocks = [];
   let total = 0;
   let filesSeen = 0;
   let unreadable = 0;
-  const [consumers] = await deps.scanSessions();
-  for (const [ws] of deps.discover(cfg.roots, cfg.maxDepth)) {
+  const [, , details] = await deps.scanSessions();
+  const state = loadState();
+  for (const [ws] of deps.discover(cfg.roots)) {
     filesSeen += 1;
     const tasks = deps.readTasks(ws);
     if (tasks === null) {
@@ -43,12 +63,21 @@ export async function cmdList(args) {
       continue;
     }
     if (tasks.length === 0) continue;
-    const views = tasks.map((t) => taskView(t, now));
+    const liveSids = deps.liveSessionIds(details, ws);
+    const views = tasks.map((t) => {
+      // 带提前量：「待预热」标签与巡检的预热窗口同一口径。
+      const v = taskView(t, now, LEAD_SECONDS * 1000);
+      return {
+        v,
+        t,
+        tag: warmTag(t, v, state[ws]?.[taskKey(t)], liveSids, ws, cur),
+      };
+    });
     // 错过待补执行排最前，然后按下次时间升序，一年内无安排的垫底，无效
     // 的最后。
-    views.sort((a, b) => rank(a) - rank(b)
-      || ((a.nxt?.getTime() ?? Infinity) - (b.nxt?.getTime() ?? Infinity)));
-    blocks.push([ws, consumers.has(ws), views]);
+    views.sort((a, b) => rank(a.v) - rank(b.v)
+      || ((a.v.nxt?.getTime() ?? Infinity) - (b.v.nxt?.getTime() ?? Infinity)));
+    blocks.push([ws, views]);
     total += tasks.length;
   }
 
@@ -68,23 +97,17 @@ export async function cmdList(args) {
   blocks.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
   deps.print(`共 ${blocks.length} 个工作区、${total} 个定时任务`);
 
-  // 列宽从全部实际文案动态算（跨天箭头最长 "09-25 08:30 → 09-26 09:00"），
-  // 改文案不会静默错位；cadence 是截断列，取固定上限。
+  // 列宽从全部实际文案动态算；cadence 是截断列，取固定上限。
   const statusW = Math.max(11,
-    ...blocks.flatMap(([, , views]) => views.map((v) => dispWidth(statusText(v)))));
+    ...blocks.flatMap(([, views]) => views.map(({ v }) => dispWidth(statusText(v)))));
   const kindW = Math.max(...['一次性', '周期', '周期·永久'].map(dispWidth)) + 1;
   const cadW = 16;
-  // 固定列（不含摘要段）："  " status "  " kind "  " cadence。摘要段再占
-  // "  " + summaryW。空间紧张时摘要先让位；为 0 则整段省略——状态箭头在
-  // 60 列下限下本身就可能占 25 列（跨天），不能再用 12 列摘要下限把行撑爆。
+  // 固定列："  " status "  " kind "  " cadence "  " summary ["  " tag]。
   const fixedW = 2 + statusW + 2 + kindW + 2 + cadW;
-  const summaryW = Math.max(0, cols - fixedW - 2);
-  for (const [ws, consumer, views] of blocks) {
+  for (const [ws, views] of blocks) {
     deps.print('');
-    const label = consumer ? '交互会话：有' : '交互会话：无';
-    const pathW = cols - dispWidth(label) - 1;
-    deps.print(`${pad(clip(ws, pathW), pathW)} ${label}`);
-    for (const v of views) {
+    deps.print(clip(ws, cols));
+    for (const { v, tag } of views) {
       let kind;
       let cadence;
       let summary;
@@ -97,11 +120,15 @@ export async function cmdList(args) {
         cadence = v.cadence;
         summary = v.summary;
       }
+      // 给预热标签预留宽度（含括号与间隔）；极窄屏摘要可以截到 0。
+      const tagPart = tag ? ` [${tag}]` : '';
+      const summaryW = Math.max(0,
+        cols - fixedW - 2 - dispWidth(tagPart));
       let line = '  ' + pad(statusText(v), statusW) + '  '
         + pad(kind, kindW) + '  '
         + pad(clip(cadence, cadW), cadW);
-      // 极窄屏摘要列算到 0：整段省略（含前导间隔），保证行宽不超终端。
       if (summaryW > 0) line += '  ' + clip(summary, summaryW);
+      line += tagPart;
       deps.print(line);
     }
   }

package/src/logs.mjs

@@ -1,40 +1,52 @@
-// `cron-up logs`：选日志文件并交给 tail。默认看巡检日志（它回答「最
-// 近怎么样」），stderr 只是崩溃收集处，不能因为一次旧故障盖住此后所有健
-// 康的巡检轮次。
+// `cron-up logs`：选日志文件并交给 tail。默认看巡检日志（它回答「最近
+// 怎么样」），stderr 只是崩溃收集处，不能因为一次旧故障盖住此后所有健
+// 康的巡检轮次。一个工作区现在有多个任务级日志，按前缀匹配，多义时列
+// 候选让人给更长的片段。
 
 import fs from 'node:fs';
 import path from 'node:path';
 
 import { deps, ExitError } from './internals.mjs';
 import { onDiskCase, lexReal } from './tasks.mjs';
-import { sessionLogPath } from './sessions.mjs';
+import { slugSegment } from './sessions.mjs';
 import { fmtMDHM } from './display.mjs';
 
+// 列出会话日志目录下当前一代（.log，不含 .log.1）的全部日志绝对路径。
+function listCurrentLogs() {
+  try {
+    return fs.readdirSync(deps.paths.sessionLogDir)
+      .filter((f) => f.endsWith('.log'))
+      .map((f) => path.join(deps.paths.sessionLogDir, f));
+  } catch {
+    return [];
+  }
+}
+
+// 多个候选时打印清单并放弃（exit 1），tail 哪一个由用户补全片段决定。
+function chooseOne(matches, say) {
+  if (matches.length === 1) return matches[0];
+  say('匹配到多个任务级会话日志，请给出更长的片段（如 目录名--任务id）：');
+  for (const f of matches.sort()) say(`  ${path.basename(f)}`);
+  throw new ExitError(1);
+}
+
 export function resolveLogPath(workspace, announce) {
   const say = announce ?? ((m) => deps.printErr(m));
   if (workspace) {
     if (path.isAbsolute(workspace)) {
-      // 日志名由工作区路径折成，而 spawn 记的是 discover 规范化后的真实
-      // 大小写：敲错大小写的绝对路径必须认回同一个文件。
-      const file = sessionLogPath(onDiskCase(lexReal(workspace)));
-      return fs.existsSync(file) ? file : null;
-    }
-    // 只匹配当前日志（*.log）：.log.1 若参与匹配，轮转过一次的工作区会永
-    // 远被报成「匹配到多个」。
-    let matches = [];
-    try {
-      matches = fs.readdirSync(deps.paths.sessionLogDir)
-        .filter((f) => f.endsWith('.log'))
-        .map((f) => path.join(deps.paths.sessionLogDir, f))
-        .filter((f) => path.basename(f).includes(workspace));
-    } catch {
-      matches = [];
-    }
-    if (matches.length > 1) {
-      say(`'${workspace}' 匹配到多个会话日志，请给出更长的片段：`);
-      for (const f of matches.sort()) say(`  ${path.basename(f)}`);
-      throw new ExitError(1);
+      // 日志名由工作区路径折成前缀，任务 id 是后缀：敲绝对路径（目录）
+      // 时按 <slug(ws)>--*.log 前缀匹配，认回磁盘真实大小写。
+      const ws = onDiskCase(lexReal(workspace));
+      const prefix = `${slugSegment(ws)}--`;
+      const matches = listCurrentLogs().filter((f) =>
+        path.basename(f).startsWith(prefix));
+      return matches.length === 0 ? null : chooseOne(matches, say);
     }
+    // 片段匹配：直接对文件名做 includes，天然覆盖「目录名」「目录名--
+    // 任务id」「任务id」三种给法。
+    const matches = listCurrentLogs()
+      .filter((f) => path.basename(f).includes(workspace));
+    if (matches.length > 1) return chooseOne(matches, say);
     return matches[0] ?? null;
   }