sillyspec 3.27.11 → 3.28.0

package/.claude/worktrees/sillyspec-data-model-research/src/agent-session-log.js

@@ -1,803 +0,0 @@
-/**
- * agent-session-log.js — 本地 agent 会话日志路径探测 + 上报平台（多 harness）
- *
- * 背景：平台模式（SillyHub daemon 调 CLI）下，平台会话只能看到 CLI 内部阶段信息，
- * 看不到本地 agent 的实际执行日志——agent 的完整模型 I/O / 工具调用 / 输出都在各
- * agent CLI 本地的会话日志里（如 Codex rollout、Claude Code transcript、ZCode
- * model-io），平台无从得知。
- *
- * 方案（docs/platform-agent-log-protocol.md）：CLI 在 run 命令入口探测「当前正被哪个
- * agent CLI 驱动」，把 agent **完整会话日志**的本地绝对路径**主动 REST 上报**到平台
- * （POST /api/agent-logs，与进度上报同风格；平台端落库后在会话视图展示，再按路径让
- * daemon 读本地文件解析内容）。同时写本地产物 <runtimeRoot>/agent-session-log.json
- * 留底（上报失败兜底 + `sillyspec agent-log` 查询源）。
- *
- * 支持的 harness（探测规则全部实证——本机布局 + CLI 包源码/二进制，见 protocol 文档）：
- *   - claude-code：env CLAUDECODE / CLAUDE_CODE_ENTRYPOINT 门控；
- *       <home>/.claude/projects/<slug-cwd>/<sessionId>.jsonl（slug = 路径非字母数字全替 '-'）
- *   - codex：无可靠 env 标记，按 mtime 活跃窗口扫 <home>/.codex/sessions/YYYY/MM/DD/
- *       rollout-*.jsonl，读首行 session_meta.cwd 精确匹配 CLI cwd（并带出 originator，
- *       如 sillyhub-daemon，供平台关联派发来源）
- *   - zcode：env ZCODE_* 门控；<home>/.zcode/cli/rollout/model-io-sess_<id>.jsonl
- *   - pi：目录名即 cwd 编码（--<路径非字母数字替'-'>--），无需 env 门控；
- *       <home>/.pi/agent/sessions/<safePath>/session.jsonl
- *   - deepseek-dsh（@deepseek-ai/dsh）：同 pi 构但 ':' 删除；
- *       <home>/.dsh/sessions/<safePath>/session-<uuid>/session.jsonl.zstd（zstd 压缩）
- *   - cursor / opencode：loose 探测器（无 cwd/env 归属线索，仅 precise 全落空时启用）
- *   - 其他 CLI：env SILLYSPEC_AGENT_LOG 显式指定（绝对路径）
- *
- * 上报配置来源（优先级）：env SILLYHUB_PLATFORM_URL + SILLYHUB_PLATFORM_TOKEN（daemon
- * 注入通道）> local.yaml platform 段（与进度同步同源）。**不受平台模式 sentinel 限制**
- * （链路 A 进度同步在平台模式跳过是因为 daemon 自有进度回传链路；agent 日志没有
- * daemon 链路，本上报就是它的主通道）。env SILLYSPEC_AGENT_LOG_PUSH=0 可关。
- *
- * 铁律：全程 best-effort——探测不到不发不写、任何失败只 warn 一行绝不阻断 run 主流程。
- * 只上报路径 + 元信息（session_id/format/originator），不读日志内容（解析归平台侧），
- * 不引入新依赖。
- */
-import { existsSync, readdirSync, statSync, readFileSync, mkdirSync, openSync, readSync, closeSync } from 'fs';
-import { join, isAbsolute } from 'path';
-import { homedir } from 'os';
-import { writeAtomicSync } from './fs-atomic.js';
-import { withFileLock } from './quicklog.js';
-import { resolveRuntimeRoot } from './run/shared.js';
-
-export const AGENT_LOG_SCHEMA_VERSION = 1;
-export const AGENT_LOG_ARTIFACT_FILENAME = 'agent-session-log.json';
-/** daemon/用户显式指定 agent 日志路径的 env 名（绝对路径；相对路径忽略）。 */
-export const AGENT_LOG_ENV_OVERRIDE = 'SILLYSPEC_AGENT_LOG';
-
-// 自动探测只认「活跃窗口」内被写过的会话文件：CLI 此刻正被 agent 驱动，当前会话日志的
-// mtime 必然新鲜；窗口外的旧文件（上周的会话）不登记，防平台解析到错误日志。
-// env 覆盖不受此窗口限制（显式指定 = 调用方负责正确性）。
-const ACTIVE_WINDOW_MS = 15 * 60 * 1000;
-// 单 harness 单次探测的条目上限（并行 Wave 会同时开多个子代理会话，都算 agent 日志）。
-const MAX_PER_HARNESS = 6;
-// 产物 entries 上限（按 last_seen_at 新→旧保留；超出淘汰最旧）。
-const MAX_ENTRIES = 10;
-// 产物合并锁超时：登记是附带动作，锁竞争超时直接放弃本次（下次 run 自愈）。
-const MERGE_LOCK_TIMEOUT_MS = 2_000;
-// 上报超时（与 quicklog 推送同量级：best-effort，不拖 run 主流程）。
-const PUSH_TIMEOUT_MS = 5_000;
-
-function debugLog(msg) {
-  if (process.env.SILLYSPEC_DEBUG_AGENT_LOG || process.env.SILLYSPEC_DEBUG_SYNC) {
-    console.warn(`[agent-log] ${msg}`);
-  }
-}
-
-/** 路径归一正斜杠（跨平台产物契约：Windows 反斜杠不出现在 JSON 产物里）。 */
-function toPosix(p) {
-  return String(p).replace(/\\/g, '/');
-}
-
-/** cwd 等值比较口径：正斜杠归一 + Windows 形态路径大小写不敏感。
- * 按数据形态判而非宿主平台——平台 hub 场景 daemon 跑在任意平台，都要能与 Windows
- * agent 上报的 cwd（盘符 `c:/x` 或 UNC `\\server\share`）等值比较；toPosix 在前，
- * UNC 的反斜杠此时已成 `//`。POSIX 形态路径保持大小写敏感（文件系统语义如此）。 */
-function normCwd(p) {
-  const s = toPosix(p);
-  const winForm = /^[a-zA-Z]:\//.test(s) || s.startsWith('//');
-  return winForm ? s.toLowerCase() : s;
-}
-
-function cwdsMatch(a, b) {
-  return Boolean(a) && Boolean(b) && normCwd(a) === normCwd(b);
-}
-
-function statSafe(p) {
-  try { return statSync(p); } catch { return null; }
-}
-
-/**
- * 会话化上下文 id 消毒（2026-08-23-agent-activity-sessions）：非空字符串 trim 后返回，
- * 其余（undefined/null/空白）返回 null——best-effort 语义：ctx 解析失败不带、不抛错。
- * 只用于标识类值（hubSessionId / changeKey / quickId），非 flag 值。
- */
-function pickCtxId(v) {
-  if (typeof v !== 'string') return null;
-  const t = v.trim();
-  return t || null;
-}
-
-/**
- * 读文件首行并 JSON.parse（只读前 maxBytes 字节，防大日志整读）。
- * codex rollout 首行是 session_meta（含 cwd/originator），这是 cwd 精确匹配的数据源。
- * @returns {object|null} 解析失败/文件不可读返回 null
- */
-function readFirstLineJson(filePath, maxBytes = 16384) {
-  let fd = null;
-  try {
-    fd = openSync(filePath, 'r');
-    const buf = Buffer.alloc(maxBytes);
-    const n = readSync(fd, buf, 0, maxBytes, 0);
-    const text = buf.subarray(0, n).toString('utf8');
-    const nl = text.indexOf('\n');
-    return JSON.parse(nl === -1 ? text : text.slice(0, nl));
-  } catch {
-    return null;
-  } finally {
-    if (fd !== null) { try { closeSync(fd) } catch { /* best effort */ } }
-  }
-}
-
-// 活跃文件收集：dir 内 suffix 结尾文件，mtime 在窗口内，mtime 新→旧
-function listActiveFiles(dir, { now, windowMs, limit }) {
-  let names;
-  try {
-    names = readdirSync(dir).filter(f => f.endsWith('.jsonl'));
-  } catch {
-    return [];
-  }
-  const active = [];
-  for (const name of names) {
-    const full = join(dir, name);
-    const st = statSafe(full);
-    if (!st || now - st.mtimeMs > windowMs) continue;
-    active.push({ name, full, mtimeMs: st.mtimeMs });
-  }
-  active.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  return active.slice(0, limit);
-}
-
-/**
- * Claude Code 项目目录名 munging 规则：绝对路径所有非字母数字字符替换为 '-'。
- * 实证（本机 ~/.claude/projects/）：
- *   C:\Users\qinyi\IdeaProjects\sillyspec                → C--Users-qinyi-IdeaProjects-sillyspec
- *   C:\Users\qinyi\IdeaProjects\sillyspec\.worktrees\8f1 → C--Users-qinyi-IdeaProjects-sillyspec--worktrees-8f1
- */
-export function mungeClaudeProjectDir(cwd) {
-  return String(cwd).replace(/[^a-zA-Z0-9]/g, '-');
-}
-
-// ── harness 探测器注册表（新增 CLI = 加一个探测器对象 + protocol 文档补格式说明）──
-
-/** Claude Code：env 门控（CLAUDECODE / CLAUDE_CODE_ENTRYPOINT）+ 项目 slug 目录精确到 cwd。 */
-function detectClaudeCode(ctx) {
-  const { cwdCandidates, env, homeDir, now, windowMs } = ctx;
-  if (!(env.CLAUDECODE === '1' || (typeof env.CLAUDE_CODE_ENTRYPOINT === 'string' && env.CLAUDE_CODE_ENTRYPOINT))) {
-    return [];
-  }
-  const claudeRoot = env.CLAUDE_CONFIG_DIR || join(homeDir, '.claude');
-  const projectsRoot = join(claudeRoot, 'projects');
-  const entries = [];
-  for (const rawCwd of cwdCandidates) {
-    if (!rawCwd) continue;
-    const projectDir = join(projectsRoot, mungeClaudeProjectDir(rawCwd));
-    if (!existsSync(projectDir)) continue;
-
-    // CLAUDE_SESSION_ID 精确匹配（存在则必登）：比 newest-mtime 猜测可靠
-    const sessionId = typeof env.CLAUDE_SESSION_ID === 'string' ? env.CLAUDE_SESSION_ID.trim() : '';
-    if (sessionId) {
-      const exact = join(projectDir, `${sessionId}.jsonl`);
-      if (existsSync(exact)) {
-        entries.push({
-          harness: 'claude-code', format: 'claude-code-jsonl', detected_via: 'claude-code-session-id',
-          log_path: toPosix(exact), agent_cwd: toPosix(rawCwd),
-          session_id: sessionId, originator: null,
-          mtime_ms: statSafe(exact)?.mtimeMs ?? null,
-        });
-      }
-    }
-
-    for (const f of listActiveFiles(projectDir, { now, windowMs, limit: MAX_PER_HARNESS })) {
-      const posix = toPosix(f.full);
-      if (entries.some(e => e.log_path === posix)) continue;
-      entries.push({
-        harness: 'claude-code', format: 'claude-code-jsonl', detected_via: 'claude-code-active-scan',
-        log_path: posix, agent_cwd: toPosix(rawCwd),
-        session_id: f.name.replace(/\.jsonl$/, ''), originator: null,
-        mtime_ms: f.mtimeMs,
-      });
-    }
-  }
-  return entries;
-}
-
-/**
- * Codex：无可靠子进程 env 标记（daemon 拉起场景实证），按日期目录扫活跃 rollout，
- * 读首行 session_meta.cwd 精确匹配。originator（如 sillyhub-daemon）一并带出供平台关联。
- * 布局实证：<home>/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl，首行
- * {"type":"session_meta","payload":{"session_id","cwd","originator","cli_version",...}}。
- */
-function detectCodex(ctx) {
-  const { cwdCandidates, env, homeDir, now, windowMs } = ctx;
-  const codexHome = env.CODEX_HOME || join(homeDir, '.codex');
-  const sessionsRoot = join(codexHome, 'sessions');
-  if (!existsSync(sessionsRoot)) return [];
-
-  // 只扫今天/昨天两个日期目录（窗口 15min 跨零点最多涉及两天；目录按日期分层是天然的扫描剪枝）
-  const dayDirs = [new Date(now), new Date(now - 24 * 60 * 60 * 1000)]
-    .map(d => join(sessionsRoot, String(d.getFullYear()), String(d.getMonth() + 1).padStart(2, '0'), String(d.getDate()).padStart(2, '0')));
-
-  const entries = [];
-  for (const dir of [...new Set(dayDirs)]) {
-    for (const f of listActiveFiles(dir, { now, windowMs, limit: MAX_PER_HARNESS })) {
-      const meta = readFirstLineJson(f.full);
-      const payload = meta && meta.type === 'session_meta' ? (meta.payload || {}) : {};
-      // cwd 精确匹配：防并发其他项目的 codex 会话串台（session_meta.cwd 与 CLI cwd 等值才登记）
-      if (!cwdCandidates.some(c => c && payload.cwd && cwdsMatch(c, payload.cwd))) continue;
-      entries.push({
-        harness: 'codex', format: 'codex-rollout-jsonl', detected_via: 'codex-session-meta-cwd',
-        log_path: toPosix(f.full), agent_cwd: toPosix(payload.cwd),
-        session_id: typeof payload.session_id === 'string' ? payload.session_id : null,
-        originator: typeof payload.originator === 'string' ? payload.originator : null,
-        mtime_ms: f.mtimeMs,
-      });
-      if (entries.length >= MAX_PER_HARNESS) break;
-    }
-  }
-  return entries;
-}
-
-/**
- * ZCode：env ZCODE_* 门控（本机实证子进程可见 ZCODE_APP_VERSION/ZCODE_ENV 等）；
- * <home>/.zcode/cli/rollout/model-io-sess_<id>.jsonl（含 subagent 会话，文件名带
- * sess_subagent_agent_ 前缀），完整模型 I/O。无 cwd 字段 → env 门控即归属依据。
- */
-function detectZcode(ctx) {
-  const { cwdCandidates, env, homeDir, now, windowMs } = ctx;
-  const inZcode = Boolean(env.ZCODE_APP_VERSION || env.ZCODE_ENV || env.ZCODE_RUNTIME_ENV);
-  if (!inZcode) return [];
-  const rolloutDir = join(homeDir, '.zcode', 'cli', 'rollout');
-  const cwdPosix = toPosix(cwdCandidates[0] || '');
-  return listActiveFiles(rolloutDir, { now, windowMs, limit: MAX_PER_HARNESS }).map(f => ({
-    harness: 'zcode', format: 'zcode-model-io-jsonl', detected_via: 'zcode-env-marker',
-    log_path: toPosix(f.full), agent_cwd: cwdPosix,
-    session_id: f.name.replace(/^model-io-sess_/, '').replace(/\.jsonl$/, ''),
-    originator: null,
-    mtime_ms: f.mtimeMs,
-  }));
-}
-
-/**
- * pi（@earendil-works/pi-coding-agent）：完整会话 = <home>/.pi/agent/sessions/<safePath>/session.jsonl。
- * safePath 编码规则（dist/migrations.js:101 源码实证）：
- *   `--${cwd.replace(/^[/\\]/,'').replace(/[/\\:]/g,'-')}--`
- * 实证：C:\Users\qinyi\IdeaProjects\multi-agent-platform → --C--Users-qinyi-IdeaProjects-multi-agent-platform--
- * 目录名即 cwd 编码 → 天然精确归属，无需 env 门控。
- */
-export function mungePiSafePath(cwd) {
-  return `--${String(cwd).replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
-}
-
-function detectPi(ctx) {
-  const { cwdCandidates, homeDir, now, windowMs } = ctx;
-  const entries = [];
-  for (const rawCwd of cwdCandidates) {
-    if (!rawCwd) continue;
-    const sessionFile = join(homeDir, '.pi', 'agent', 'sessions', mungePiSafePath(rawCwd), 'session.jsonl');
-    const st = statSafe(sessionFile);
-    if (!st || now - st.mtimeMs > windowMs) continue;
-    entries.push({
-      harness: 'pi', format: 'pi-session-jsonl', detected_via: 'pi-safe-path',
-      log_path: toPosix(sessionFile), agent_cwd: toPosix(rawCwd),
-      session_id: null, originator: null,
-      mtime_ms: st.mtimeMs,
-    });
-  }
-  return entries;
-}
-
-/**
- * dsh（@deepseek-ai/dsh，DeepSeek agent CLI）：完整会话 =
- * <home>/.dsh/sessions/<safePath>/session-<uuid>/session.jsonl.zstd（zstd 压缩 jsonl）。
- * safePath 编码（sessions/ 目录名 + storages/session_projcache.json 的 cwd 字段交叉实证）：
- * 与 pi 同构但 `:` 是删除而非替换 —— `--${cwd 去首斜杠、删 ':'、[/\\]→'-'}--`。
- * 实证：C:\Users\qinyi\IdeaProjects\multi-agent-platform → --C-Users-qinyi-IdeaProjects-multi-agent-platform--
- */
-export function mungeDshSafePath(cwd) {
-  return `--${String(cwd).replace(/^[/\\]/, '').replace(/:/g, '').replace(/[/\\]/g, '-')}--`;
-}
-
-function detectDsh(ctx) {
-  const { cwdCandidates, homeDir, now, windowMs } = ctx;
-  const entries = [];
-  for (const rawCwd of cwdCandidates) {
-    if (!rawCwd) continue;
-    const projectDir = join(homeDir, '.dsh', 'sessions', mungeDshSafePath(rawCwd));
-    if (!existsSync(projectDir)) continue;
-    // 会话目录（session-<uuid>/）按 mtime 活跃窗口取最新几个，完整日志 = 目录内 session.jsonl.zstd
-    let sessionDirs;
-    try {
-      sessionDirs = readdirSync(projectDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name);
-    } catch { continue; }
-    const active = [];
-    for (const name of sessionDirs) {
-      const logFile = join(projectDir, name, 'session.jsonl.zstd');
-      const st = statSafe(logFile);
-      if (!st || now - st.mtimeMs > windowMs) continue;
-      active.push({ name, logFile, mtimeMs: st.mtimeMs });
-    }
-    active.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    for (const a of active.slice(0, MAX_PER_HARNESS)) {
-      entries.push({
-        harness: 'deepseek-dsh', format: 'dsh-session-jsonl-zstd', detected_via: 'dsh-safe-path',
-        log_path: toPosix(a.logFile), agent_cwd: toPosix(rawCwd),
-        session_id: a.name.replace(/^session-/, ''), originator: null,
-        mtime_ms: a.mtimeMs,
-      });
-    }
-  }
-  return entries;
-}
-
-/**
- * Cursor（IDE / cursor-agent CLI）：完整会话 = <home>/.cursor/chats/<workspaceHash>/<chatUuid>/
- * {meta.json, store.db(sqlite)}。无 cwd 映射（workspaceHash 算法未知）也无子进程 env 标记
- * → 宽探测器（loose）：仅按 store.db(+wal) mtime 活跃窗口登记，且只在所有精确探测器
- * 落空时启用（防 Cursor IDE 日常使用在其他项目聊天时误报为当前 agent 日志）。
- */
-function detectCursor(ctx) {
-  const { cwdCandidates, homeDir, now, windowMs } = ctx;
-  const chatsRoot = join(homeDir, '.cursor', 'chats');
-  let wsDirs;
-  try {
-    wsDirs = readdirSync(chatsRoot, { withFileTypes: true }).filter(d => d.isDirectory());
-  } catch { return []; }
-  const cwdPosix = toPosix(cwdCandidates[0] || '');
-  const active = [];
-  for (const ws of wsDirs) {
-    let chatDirs;
-    try {
-      chatDirs = readdirSync(join(chatsRoot, ws.name), { withFileTypes: true }).filter(d => d.isDirectory());
-    } catch { continue; }
-    for (const chat of chatDirs) {
-      const chatDir = join(chatsRoot, ws.name, chat.name);
-      // sqlite WAL 模式下写入打在 -wal 侧车，取两者 mtime 较大者判活跃
-      const db = statSafe(join(chatDir, 'store.db'));
-      const wal = statSafe(join(chatDir, 'store.db-wal'));
-      const st = db || wal;
-      if (!st) continue;
-      const mtime = Math.max(db?.mtimeMs ?? 0, wal?.mtimeMs ?? 0);
-      if (now - mtime > windowMs) continue;
-      active.push({ chatDir, sessionId: chat.name, mtimeMs: mtime });
-    }
-  }
-  active.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  return active.slice(0, 3).map(a => ({
-    harness: 'cursor', format: 'cursor-chat-sqlite', detected_via: 'cursor-recent-scan',
-    log_path: toPosix(a.chatDir), agent_cwd: cwdPosix,
-    session_id: a.sessionId, originator: null,
-    mtime_ms: a.mtimeMs,
-  }));
-}
-
-/**
- * opencode（opencode-ai v1.17+）：完整会话 = <dataRoot>/opencode/storage/session/ 下的
- * JSON 树（info/<id>.json 会话元信息 + message/ + part/ 全量内容；二进制字符串实证布局）。
- * dataRoot = $XDG_DATA_HOME || ~/.local/share。cwd 归属：读活跃窗口内 info/*.json 做
- * cwd 文本包含匹配（对 JSON 形状宽容）；无匹配不登记。宽探测器（loose，布局未本机实证，
- * 生产不命中时静默 no-op，env 覆盖兜底）。
- */
-function detectOpencode(ctx) {
-  const { cwdCandidates, env, homeDir, now, windowMs } = ctx;
-  const dataRoot = env.XDG_DATA_HOME || join(homeDir, '.local', 'share');
-  const sessionRoot = join(dataRoot, 'opencode', 'storage', 'session');
-  const infoDir = join(sessionRoot, 'info');
-  let infoFiles;
-  try {
-    infoFiles = readdirSync(infoDir).filter(f => f.endsWith('.json'));
-  } catch { return []; }
-  const cwdPosix = toPosix(cwdCandidates[0] || '');
-  const active = [];
-  for (const f of infoFiles) {
-    const full = join(infoDir, f);
-    const st = statSafe(full);
-    if (!st || now - st.mtimeMs > windowMs) continue;
-    active.push({ full, sessionId: f.replace(/\.json$/, ''), mtimeMs: st.mtimeMs });
-  }
-  active.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  const entries = [];
-  for (const a of active.slice(0, 3)) {
-    // cwd 包含匹配（原文本容错：原分隔符 / 正斜杠 / JSON 转义双反斜杠三形态命中其一即可）
-    let text = '';
-    try { text = readFileSync(a.full, 'utf8'); } catch { continue; }
-    const cwds = cwdCandidates.filter(Boolean);
-    const hit = cwds.some(c => text.includes(c) || text.includes(toPosix(c))
-      || text.includes(JSON.stringify(c).slice(1, -1)));
-    if (!hit) continue;
-    entries.push({
-      harness: 'opencode', format: 'opencode-session-json-tree', detected_via: 'opencode-session-info-cwd',
-      // 会话内容分散在 info/message/part 三棵子树，log_path 指向 session/ 根（平台侧按 format 遍历）
-      log_path: toPosix(sessionRoot), agent_cwd: cwdPosix,
-      session_id: a.sessionId, originator: null,
-      mtime_ms: a.mtimeMs,
-    });
-    break; // 同根目录只登一条（log_path 相同），session_id 取最新命中会话
-  }
-  return entries;
-}
-
-/**
- * 探测器注册表。tier 语义：
- *   - precise：cwd/env 精确归属（claude-code / codex / zcode / pi / deepseek-dsh），恒参与；
- *   - loose：无归属线索（cursor / opencode），**仅在 precise 全落空时启用**——
- *     防「Cursor IDE 在别的项目聊天 / 其他项目 opencode 会话活跃」被误报进当前登记。
- * 新增 CLI = 加一个探测器对象 + protocol 文档补布局与格式说明。
- */
-const HARNESS_DETECTORS = [
-  { name: 'claude-code', tier: 'precise', detect: detectClaudeCode },
-  { name: 'codex', tier: 'precise', detect: detectCodex },
-  { name: 'zcode', tier: 'precise', detect: detectZcode },
-  { name: 'pi', tier: 'precise', detect: detectPi },
-  { name: 'deepseek-dsh', tier: 'precise', detect: detectDsh },
-  { name: 'cursor', tier: 'loose', detect: detectCursor },
-  { name: 'opencode', tier: 'loose', detect: detectOpencode },
-];
-
-/**
- * 探测当前驱动 CLI 的本地 agent 会话日志（纯读，不写盘）。
- *
- * @param {object} [opts]
- * @param {string[]} [opts.cwdCandidates] - agent 可能的 cwd 列表（CLI 原始 cwd + 纠正后项目根；
- *   agent 在子目录启动时部分 harness 日志挂在子目录维度，两者都探）
- * @param {object}   [opts.env]       - 默认 process.env（可注入测试）
- * @param {string}   [opts.homeDir]   - 默认 homedir()（可注入测试）
- * @param {number}   [opts.now]       - 默认 Date.now()（可注入测试）
- * @param {number}   [opts.windowMs]  - 活跃窗口，默认 15min
- * @returns {Array<{harness:string, log_path:string, format:string, detected_via:string,
- *   agent_cwd:string, session_id:string|null, originator:string|null, mtime_ms:number|null}>}
- *   探测结果（mtime_ms 新→旧）；空数组 = 未探测到（不在 agent 环境或无活跃会话）
- */
-export function detectAgentLogEntries({
-  cwdCandidates = [],
-  env = process.env,
-  homeDir = homedir(),
-  now = Date.now(),
-  windowMs = ACTIVE_WINDOW_MS,
-} = {}) {
-  const entries = [];
-
-  // ── 优先级 1：env 显式覆盖（绝对路径；相对路径忽略——产物里的路径必须可直接消费）──
-  // 不依赖任何 harness 标记：daemon/用户最可靠的指定通道（其他 CLI 一律走这条路）
-  const override = env[AGENT_LOG_ENV_OVERRIDE];
-  if (typeof override === 'string' && override.trim()) {
-    const p = override.trim();
-    if (isAbsolute(p)) {
-      entries.push({
-        harness: 'env-override', format: p.endsWith('.jsonl') ? 'jsonl' : 'unknown',
-        detected_via: 'env',
-        log_path: toPosix(p), agent_cwd: toPosix(cwdCandidates[0] || ''),
-        session_id: null, originator: null,
-        mtime_ms: statSafe(p)?.mtimeMs ?? null,
-      });
-    } else {
-      debugLog(`${AGENT_LOG_ENV_OVERRIDE} 非绝对路径，忽略: ${p}`);
-    }
-  }
-
-  // ── 优先级 2：已登记 harness 自动探测（precise 恒参与；loose 仅在 precise 全落空时启用）──
-  const ctx = { cwdCandidates, env, homeDir, now, windowMs };
-  let preciseFound = false;
-  for (const h of HARNESS_DETECTORS) {
-    if (h.tier === 'loose' && preciseFound) continue;
-    try {
-      const found = h.detect(ctx);
-      if (found.length > 0) {
-        entries.push(...found);
-        if (h.tier === 'precise') preciseFound = true;
-      }
-    } catch (e) {
-      debugLog(`${h.name} 探测异常（跳过）: ${e && e.message ? e.message : e}`);
-    }
-  }
-
-  entries.sort((a, b) => (b.mtime_ms ?? 0) - (a.mtime_ms ?? 0));
-  return entries.slice(0, 12);
-}
-
-/**
- * 读 agent 日志上报配置（与进度同步 quicklog 推送同风格，自带轻量 local.yaml 解析，
- * 不 import sync.js 防拖 ProgressManager 重链）。
- *
- * 优先级：env SILLYHUB_PLATFORM_URL + SILLYHUB_PLATFORM_TOKEN（两键齐全才生效——
- * daemon 注入通道，平台模式 specRoot 的 local.yaml 无 platform 段时靠它）>
- * specBase/local.yaml platform 段（url + token，与链路 A 同源）。
- * @returns {{url:string, token:string}|null} 未配置返回 null（合法状态，静默跳过上报）
- */
-function readPlatformPushConfig(specBase, env = process.env) {
-  if (env.SILLYHUB_PLATFORM_URL && env.SILLYHUB_PLATFORM_TOKEN) {
-    return { url: env.SILLYHUB_PLATFORM_URL, token: env.SILLYHUB_PLATFORM_TOKEN };
-  }
-  try {
-    const yamlPath = join(specBase, 'local.yaml');
-    if (!existsSync(yamlPath)) return null;
-    const lines = readFileSync(yamlPath, 'utf8').split(/\r?\n/);
-    let inPlatform = false;
-    const cfg = {};
-    for (const line of lines) {
-      if (!line.trim() || line.trim().startsWith('#')) continue;
-      if (!/^\s/.test(line)) inPlatform = line.startsWith('platform:');
-      else if (inPlatform) {
-        const m = line.match(/^\s+(url|token)\s*:\s*(.*)$/);
-        if (m) {
-          let v = m[2].trim();
-          if (v.length >= 2 && ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'")))) v = v.slice(1, -1);
-          if (v) cfg[m[1]] = v;
-        }
-      }
-    }
-    if (!cfg.url || !cfg.token) return null;
-    return cfg;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * 上报 agent 日志登记到平台：POST {url}/api/agent-logs（Bearer platform token）。
- * 平台端落库后在会话视图展示；内容解析由平台/daemon 按路径读本地文件完成。
- * best-effort：无配置静默跳过；网络/非 2xx/超时 warn 一行不抛（本地产物已落盘兜底）。
- * @param {object} p
- * @param {string} p.specBase - local.yaml 所在 spec 基路径
- * @param {object} [p.env]    - env（默认 process.env；测试注入用）
- * @param {object} p.payload  - 上报 body（见 protocol 文档 §3）
- * @returns {Promise<{pushed:boolean|null, reason?:string}>} pushed=null 表示未配置/被禁用
- */
-async function pushAgentLogToPlatform({ specBase, env = process.env, payload }) {
-  if (env.SILLYSPEC_AGENT_LOG_PUSH === '0') {
-    debugLog('SILLYSPEC_AGENT_LOG_PUSH=0，上报关闭');
-    return { pushed: null, reason: 'disabled' };
-  }
-  const cfg = readPlatformPushConfig(specBase, env);
-  if (!cfg) {
-    debugLog('未配置 platform 段/env（未连接平台，合法状态），跳过上报');
-    return { pushed: null, reason: 'no-config' };
-  }
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), PUSH_TIMEOUT_MS);
-  try {
-    const res = await fetch(`${cfg.url.replace(/\/+$/, '')}/api/agent-logs`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${cfg.token}` },
-      body: JSON.stringify(payload),
-      signal: controller.signal,
-    });
-    if (!res.ok) {
-      console.warn(`[agent-log-push] → HTTP ${res.status}（本地产物已落盘兜底，不影响主流程）`);
-      return { pushed: false, reason: `http-${res.status}` };
-    }
-    return { pushed: true };
-  } catch (err) {
-    const msg = err && err.name === 'AbortError' ? '超时' : (err && err.message ? err.message : err);
-    console.warn(`[agent-log-push] 上报失败: ${msg}（本地产物已落盘兜底）`);
-    return { pushed: false, reason: 'network' };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-/**
- * 读 agent-session-log.json 产物（不存在/损坏返回 null）。
- * @param {string} runtimeRoot - .runtime 根目录（resolveRuntimeRoot 的返回值）
- * @returns {object|null}
- */
-export function readAgentLogArtifact(runtimeRoot) {
-  const p = join(runtimeRoot, AGENT_LOG_ARTIFACT_FILENAME);
-  if (!existsSync(p)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync(p, 'utf8'));
-    return parsed && typeof parsed === 'object' ? parsed : null;
-  } catch {
-    debugLog(`产物损坏，按无产物处理: ${p}`);
-    return null;
-  }
-}
-
-/**
- * 登记 agent 会话日志路径进 <runtimeRoot>/agent-session-log.json（run 命令入口调用）。
- *
- * 合并语义：按 log_path 去重——同路径 invocations+1 / 刷新 last_seen_at 与文件 stat；
- * 新路径追加；entries 按 last_seen_at 新→旧排序（同毫秒平局按 seq 登记序决胜），
- * 上限 10 条（超出淘汰最旧）。
- * 探测不到（非 agent 环境）不写盘不上报。全程 best-effort：失败 warn 一行返回 null 不抛。
- * 落盘后立即 REST 上报平台（POST /api/agent-logs，主通道），上报失败本地产物兜底。
- *
- * @param {object} p
- * @param {string}   p.cwd          - CLI 当前 cwd（项目根；平台模式 = source root）
- * @param {string}   [p.invokedCwd] - CLI 原始 cwd（cwd 纠正前；agent 子目录启动时探测用）
- * @param {object}   [p.platformOpts] - 平台参数（workspaceId/scanRunId 进产物元信息）
- * @param {string}   p.specBase     - 规范基路径（本地模式 cwd/.sillyspec；平台模式 specRoot）
- * @param {string}   [p.command]    - 触发登记的命令描述（flag 名级，不含 flag 值）
- * @param {object}   [p.context]    - 会话化上下文（2026-08-23-agent-activity-sessions，可选）：
- *   {hubSessionId, changeKey, quickId}——hubSessionId 为 body 级（run 所属平台会话唯一，
- *   daemon 注入 env SILLYHUB_SESSION_ID 的兜底也在此读取）；changeKey/quickId 为 entry 级
- *   （本次 run 检出/更新的 entry 随 run 持久化，quick 会话 quickId 优先互斥）。缺省全不带。
- * @param {object}   [p.env]        - 探测用 env（默认 process.env；测试注入用）
- * @param {string}   [p.homeDir]    - 探测用 home（默认 homedir()；测试注入用）
- * @param {number}   [p.now]        - 探测用时钟（默认 Date.now()；测试注入用）
- * @param {number}   [p.windowMs]   - 活跃窗口（默认 15min）
- * @returns {Promise<{artifactPath:string, detected:number, latestLogPath:string|null, isNew:boolean, pushed:boolean|null}|null>}
- *   null = 未探测到 / 失败（调用方无需区分）
- */
-export async function recordAgentLogInvocation({ cwd, invokedCwd, platformOpts = {}, specBase, command, context = {}, env, homeDir, now, windowMs } = {}) {
-  try {
-    if (!cwd || !specBase) return null;
-    const cwdCandidates = [...new Set([invokedCwd, cwd].filter(Boolean))];
-    const detected = detectAgentLogEntries({ cwdCandidates, env, homeDir, now, windowMs });
-    if (detected.length === 0) return null;
-
-    // 会话化上下文（best-effort 消毒，解析失败不带）：entry 级 ctx（changeKey/quickId）随
-    // 检出/更新该 entry 的本次 run 持久化；hubSessionId 为 body 级——context 显式传入优先，
-    // 缺省回落 env SILLYHUB_SESSION_ID（daemon 派发平台会话时的注入通道，见 protocol 文档 §1）。
-    const hubSessionId = pickCtxId(context.hubSessionId) || pickCtxId((env || process.env).SILLYHUB_SESSION_ID);
-    const ctxChangeKey = pickCtxId(context.changeKey);
-    const ctxQuickId = pickCtxId(context.quickId);
-
-    const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase);
-    const artifactPath = join(runtimeRoot, AGENT_LOG_ARTIFACT_FILENAME);
-    const nowIso = new Date().toISOString();
-
-    // 读-改-写按文件锁串行化（BUG-17 同款口径：多会话并发 run 时防互相覆盖丢条目）
-    const merged = await withFileLock(`${artifactPath}.lock`, () => {
-      const existing = readAgentLogArtifact(runtimeRoot);
-      const byPath = new Map((existing?.entries || []).map(e => [e.log_path, e]));
-
-      // 平局决胜序号：last_seen_at 是毫秒精度 ISO，快机器上连续登记落在同一毫秒打平，
-      // 稳定排序会让旧条目留在首位（latestLogPath 假"未更新"）。seq 按登记触及顺序单调
-      // 递增并随条目持久化，平局时后触及者胜（存量产物无 seq 视为 0，老条目间次序不变）。
-      let seq = (existing?.entries || []).reduce((m, e) => Math.max(m, Number(e.seq) || 0), 0);
-
-      for (const det of detected) {
-        const st = statSafe(det.log_path);
-        const prev = byPath.get(det.log_path);
-        byPath.set(det.log_path, {
-          ...(prev || {}),
-          harness: det.harness,
-          log_path: det.log_path,
-          format: det.format,
-          detected_via: det.detected_via,
-          agent_cwd: det.agent_cwd,
-          session_id: det.session_id ?? prev?.session_id ?? null,
-          originator: det.originator ?? prev?.originator ?? null,
-          // entry 级 ctx（D-009）：本次 run 非空者写入；context 未带（如无 --change 的 run）
-          // 保留原值——未被本次 run 触及的存量 entry 不进此循环，展开即保留原 ctx 不追新
-          change_key: ctxChangeKey ?? prev?.change_key ?? null,
-          quick_id: ctxQuickId ?? prev?.quick_id ?? null,
-          exists: Boolean(st),
-          size_bytes: st ? st.size : null,
-          mtime_ms: st ? st.mtimeMs : (det.mtime_ms ?? null),
-          first_seen_at: prev?.first_seen_at || nowIso,
-          last_seen_at: nowIso,
-          invocations: (prev?.invocations || 0) + 1,
-          last_command: command || null,
-          seq: ++seq,
-        });
-      }
-
-      const entries = [...byPath.values()]
-        .sort((a, b) => (b.last_seen_at || '').localeCompare(a.last_seen_at || '') || ((b.seq || 0) - (a.seq || 0)))
-        .slice(0, MAX_ENTRIES);
-
-      const artifact = {
-        schema_version: AGENT_LOG_SCHEMA_VERSION,
-        generated_at: nowIso,
-        agent_cwd: toPosix(invokedCwd || cwd),
-        workspace_id: platformOpts.workspaceId ?? null,
-        scan_run_id: platformOpts.scanRunId ?? null,
-        entries,
-      };
-      mkdirSync(runtimeRoot, { recursive: true });
-      writeAtomicSync(artifactPath, JSON.stringify(artifact, null, 2) + '\n');
-      return { entries, prevLatest: existing?.entries?.[0]?.log_path || null };
-    }, { timeoutMs: MERGE_LOCK_TIMEOUT_MS });
-
-    const latest = merged.entries[0] || null;
-    const isNew = Boolean(latest && latest.log_path !== merged.prevLatest);
-
-    // 上报平台（主通道，与进度上报同风格；失败本地产物兜底）。不受平台模式 sentinel
-    // 限制——进度同步在平台模式跳过是因为 daemon 有自有进度链路，agent 日志没有。
-    const push = await pushAgentLogToPlatform({
-      specBase,
-      env: env || process.env,
-      payload: {
-        schema_version: AGENT_LOG_SCHEMA_VERSION,
-        pushed_at: nowIso,
-        agent_cwd: toPosix(invokedCwd || cwd),
-        workspace_id: platformOpts.workspaceId ?? null,
-        scan_run_id: platformOpts.scanRunId ?? null,
-        // body 级会话关联键（run 所属平台会话唯一；非空才带，schema_version 保持 1 纯可选增量）
-        ...(hubSessionId ? { hub_session_id: hubSessionId } : {}),
-        // entries 各自带 entry 级 ctx（change_key/quick_id，随 entry 持久化的原值或本次 run 的新值）
-        entries: merged.entries,
-      },
-    });
-
-    return {
-      artifactPath: toPosix(artifactPath),
-      detected: detected.length,
-      latestLogPath: latest ? latest.log_path : null,
-      isNew,
-      pushed: push.pushed,
-    };
-  } catch (e) {
-    console.warn(`[agent-log] 登记失败（忽略，不影响主流程）: ${e && e.message ? e.message : e}`);
-    return null;
-  }
-}
-
-/**
- * 解析 agent-session-log.json 产物路径的落点（查询命令用；与写入侧同口径）。
- *
- * 优先级：平台指针（cwd/.sillyspec-platform.json 的 runtimeRoot/specRoot）> 显式 specDir
- * > 本地 cwd/.sillyspec。runtimeRoot 缺省回落 <specRoot>/.runtime（对齐 resolveRuntimeRoot）。
- * @returns {{artifactPath: string, runtimeRoot: string, restored: boolean}}
- */
-export function resolveAgentLogArtifactPath({ cwd, specDir } = {}) {
-  let runtimeRoot = null;
-  let restored = false;
-  if (cwd) {
-    try {
-      const pointerPath = join(cwd, '.sillyspec-platform.json');
-      if (existsSync(pointerPath)) {
-        const saved = JSON.parse(readFileSync(pointerPath, 'utf8'));
-        if (saved.runtimeRoot) {
-          runtimeRoot = saved.runtimeRoot;
-          restored = true;
-        } else if (saved.specRoot) {
-          runtimeRoot = join(saved.specRoot, '.runtime');
-          restored = true;
-        }
-      }
-    } catch { /* 指针损坏按本地模式处理 */ }
-  }
-  if (!runtimeRoot) {
-    const specBase = specDir || join(cwd || process.cwd(), '.sillyspec');
-    runtimeRoot = join(specBase, '.runtime');
-  }
-  return { artifactPath: join(runtimeRoot, AGENT_LOG_ARTIFACT_FILENAME), runtimeRoot, restored };
-}
-
-/**
- * `sillyspec agent-log` 查询命令实现（index.js case 'agent-log' 薄封装）。
- *
- * 默认读产物展示；--detect 现场探测（不写盘）。--json 输出纯 JSON（stdout 无其他内容）。
- * @param {string[]} subArgs - 'agent-log' 之后的参数
- * @param {object} opts - { json, cwd, specDir }
- */
-export async function cmdAgentLog(subArgs, { json = false, cwd = process.cwd(), specDir = null } = {}) {
-  const detectOnly = subArgs.includes('--detect');
-  if (detectOnly) {
-    const detected = detectAgentLogEntries({ cwdCandidates: [cwd] });
-    if (json) {
-      console.log(JSON.stringify({ detected }, null, 2));
-      return;
-    }
-    if (detected.length === 0) {
-      console.log('📭 未探测到本地 agent 会话日志。');
-      console.log('   支持: Claude Code / Codex / ZCode 自动探测；其他 CLI 用 SILLYSPEC_AGENT_LOG=<日志绝对路径> 显式指定。');
-      return;
-    }
-    console.log(`🔍 现场探测到 ${detected.length} 条 agent 日志：`);
-    for (const d of detected) {
-      console.log(`   📄 ${d.log_path}`);
-      console.log(`      ${d.harness} / ${d.format} / via=${d.detected_via}${d.session_id ? ` / session=${d.session_id}` : ''}${d.originator ? ` / originator=${d.originator}` : ''}`);
-    }
-    return;
-  }
-
-  const { artifactPath, runtimeRoot, restored } = resolveAgentLogArtifactPath({ cwd, specDir });
-  const artifact = readAgentLogArtifact(runtimeRoot);
-  if (json) {
-    console.log(JSON.stringify({ artifact_path: toPosix(artifactPath), platform_restored: restored, artifact }, null, 2));
-    return;
-  }
-  if (!artifact || !Array.isArray(artifact.entries) || artifact.entries.length === 0) {
-    console.log(`📭 无 agent 日志登记产物（${toPosix(artifactPath)}）。`);
-    console.log('   run <stage> 命令在 agent 环境内执行时自动登记；或用 agent-log --detect 现场探测。');
-    return;
-  }
-  console.log(`📄 本地 agent 会话日志登记（${toPosix(artifactPath)}，${artifact.entries.length} 条）`);
-  if (artifact.workspace_id || artifact.scan_run_id) {
-    console.log(`   workspace=${artifact.workspace_id || '-'} scan_run=${artifact.scan_run_id || '-'}`);
-  }
-  for (const e of artifact.entries) {
-    const state = e.exists ? '✅' : '⚠️（文件已不存在）';
-    console.log(`   ${state} ${e.log_path}`);
-    const meta = [e.harness, e.format, e.session_id ? `session=${e.session_id}` : null, e.originator ? `originator=${e.originator}` : null]
-      .filter(Boolean).join(' / ');
-    console.log(`      ${meta} / 见过 ${e.invocations} 次 / 最近 ${e.last_seen_at}${e.last_command ? ` / ${e.last_command}` : ''}`);
-  }
-  console.log('   协议: docs/platform-agent-log-protocol.md（run 命令自动 REST 上报平台 POST /api/agent-logs；此产物为本地留底）');
-}