@clawos-dev/clawd 0.2.274 → 0.2.276

package/dist/persona-defaults/persona-clawd-butler/.claude/skills/clawd-session-import/scripts/link-sessions.mjs

@@ -0,0 +1,665 @@
+#!/usr/bin/env node
+// 把本机 Claude Code / Codex 的历史会话关联成 clawd session。
+//
+// 原理（对 clawd 源码核实过，非猜测）：
+//   - session:create 只写一份 SessionFile 元数据，不拉起任何进程 → 批量关联很便宜
+//   - session:resume 在该 session 尚无 runner 时，只是把 toolSessionId 写进元数据
+//   - SessionStore.list() 每次都从磁盘重读 → 事后回填 createdAt/updatedAt 即时生效
+// 关联完，会话出现在 clawd sidebar；点开时由 history reader 按 (cwd, toolSessionId)
+// 渲染原始 transcript；用户发消息才真正 resume 起 CC / codex 进程接着聊。
+//
+// 不复制、不搬运任何 transcript 文件——只建立指向原文件的引用，原会话照常可用。
+//
+// 用法：
+//   node link-sessions.mjs                      # dry-run，列出候选
+//   node link-sessions.mjs --apply              # 真正关联
+//   node link-sessions.mjs --apply --limit 20   # 只关联最近 20 条
+//   node link-sessions.mjs --undo --apply       # 撤销本工具关联过的全部会话
+
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { spawnSync } from 'node:child_process'
+import { createRequire } from 'node:module'
+
+// node:sqlite 是实验特性，会打一行 ExperimentalWarning，对用户是噪音，摘掉
+process.removeAllListeners('warning')
+process.on('warning', (w) => {
+  if (w.name !== 'ExperimentalWarning') console.warn(w.message)
+})
+
+const HOME = os.homedir()
+const CLAWD_DIR = path.join(HOME, '.clawd')
+const RPC_CFG = path.join(CLAWD_DIR, 'rpc-tool.mcp.json')
+const LEDGER = path.join(CLAWD_DIR, 'session-import-ledger.json')
+const CLAUDE_PROJECTS = path.join(HOME, '.claude', 'projects')
+const CODEX_DIR = path.join(HOME, '.codex')
+
+class RpcError extends Error {}
+
+function die(msg) {
+  console.error(msg)
+  process.exit(1)
+}
+
+// ---------------------------------------------------------------- 小工具
+
+function clip(text, n) {
+  const s = String(text ?? '').split(/\s+/).filter(Boolean).join(' ')
+  return s.length <= n ? s : s.slice(0, n - 1) + '…'
+}
+
+// 中文字符占两列，纯 length 对不齐
+function width(s) {
+  let w = 0
+  for (const ch of s) w += /[ᄀ-ᅟ⺀-꓏가-힣豈-﫿︰-﹏＀-｠￠-￦]/.test(ch) ? 2 : 1
+  return w
+}
+
+function pad(s, n) {
+  return s + ' '.repeat(Math.max(0, n - width(s)))
+}
+
+// 按显示宽度截断（中文按 2 列算），否则表格列会被撑歪。
+// 顺带把换行 / 连续空白折叠成单空格——标题是单行的，不折叠会打乱终端输出和侧边栏
+function clipW(text, n) {
+  const s = String(text ?? '').split(/\s+/).filter(Boolean).join(' ')
+  if (width(s) <= n) return s
+  let out = ''
+  let w = 0
+  for (const ch of s) {
+    const cw = width(ch)
+    if (w + cw > n - 1) break
+    out += ch
+    w += cw
+  }
+  return out + '…'
+}
+
+function isoOf(ms) {
+  return new Date(ms).toISOString()
+}
+
+// codex 各版本的时间列有的是秒有的是毫秒，按量级判
+function toMs(v) {
+  const n = Number(v || 0)
+  return n > 1e11 ? Math.round(n) : Math.round(n * 1000)
+}
+
+function listFiles(dir, depth = 0, maxDepth = 8, out = []) {
+  let entries
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return out
+  }
+  for (const e of entries) {
+    const full = path.join(dir, e.name)
+    if (e.isDirectory()) {
+      if (depth < maxDepth) listFiles(full, depth + 1, maxDepth, out)
+    } else if (e.isFile()) {
+      out.push(full)
+    }
+  }
+  return out
+}
+
+function* jsonLines(file) {
+  let raw
+  try {
+    raw = fs.readFileSync(file, 'utf8')
+  } catch {
+    return
+  }
+  for (const line of raw.split('\n')) {
+    const t = line.trim()
+    if (!t) continue
+    try {
+      yield JSON.parse(t)
+    } catch {
+      /* 坏行跳过 */
+    }
+  }
+}
+
+// ---------------------------------------------------------------- RPC
+
+function rpcConfig() {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(RPC_CFG, 'utf8'))
+    const env = cfg.mcpServers['clawd-rpc'].env
+    return { url: env.CLAWD_DAEMON_URL.replace(/\/+$/, ''), token: env.CLAWD_DAEMON_TOKEN }
+  } catch (err) {
+    die(`读不到 clawd 的本地接口配置（${RPC_CFG}）：${err.message}。clawd 装好并启动过吗？`)
+  }
+}
+
+let RPC = null
+
+async function rpc(method, args = {}) {
+  RPC ||= rpcConfig()
+  let resp
+  try {
+    resp = await fetch(`${RPC.url}/rpc/${method}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${RPC.token}` },
+      body: JSON.stringify(args),
+      signal: AbortSignal.timeout(30000),
+    })
+  } catch (err) {
+    die(`连不上 clawd（${RPC.url}）：${err.message}。请先启动 Clawd 桌面端。`)
+  }
+  const text = await resp.text()
+  if (!resp.ok) throw new RpcError(`${method} → HTTP ${resp.status}: ${text.slice(0, 300)}`)
+  let body
+  try {
+    body = JSON.parse(text)
+  } catch {
+    throw new RpcError(`${method} 返回的不是 JSON：${text.slice(0, 200)}`)
+  }
+  // daemon 的 HTTP 出口统一包一层 {ok, result} / {ok:false, error}
+  if (body && typeof body === 'object' && 'ok' in body) {
+    if (!body.ok) throw new RpcError(`${method} 被拒：${JSON.stringify(body.error).slice(0, 300)}`)
+    return body.result ?? {}
+  }
+  return body
+}
+
+// ---------------------------------------------------------------- Claude Code 扫描
+
+// 真实用户输入的文本；tool_result / 图片等块返回空串
+function userText(msg) {
+  const content = msg && typeof msg === 'object' ? msg.content : null
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content.map((b) => (b && b.type === 'text' ? b.text || '' : '')).join('')
+  }
+  return ''
+}
+
+// ~/.claude/projects/<编码后的 cwd>/<toolSessionId>.jsonl —— 文件名即 CC session id
+function scanClaude(cutoffMs) {
+  const out = []
+  let dirs
+  try {
+    dirs = fs.readdirSync(CLAUDE_PROJECTS, { withFileTypes: true })
+  } catch {
+    return out
+  }
+  for (const d of dirs) {
+    if (!d.isDirectory()) continue
+    let files
+    try {
+      files = fs.readdirSync(path.join(CLAUDE_PROJECTS, d.name))
+    } catch {
+      continue
+    }
+    for (const name of files) {
+      if (!name.endsWith('.jsonl')) continue
+      const file = path.join(CLAUDE_PROJECTS, d.name, name)
+      let st
+      try {
+        st = fs.statSync(file)
+      } catch {
+        continue
+      }
+      if (st.mtimeMs < cutoffMs) continue
+
+      let cwd = ''
+      let title = ''
+      let firstUser = ''
+      let turns = 0
+      let firstTs = 0
+      let lastTs = 0
+      let hasMainLine = false // 有非 sidechain 的正文行 = 不是 subagent 支线文件
+
+      for (const rec of jsonLines(file)) {
+        if (!cwd && typeof rec.cwd === 'string') cwd = rec.cwd
+        if (typeof rec.timestamp === 'string') {
+          const t = Date.parse(rec.timestamp)
+          if (Number.isFinite(t)) {
+            firstTs ||= t
+            lastTs = t
+          }
+        }
+        if (rec.type === 'ai-title' && rec.aiTitle) {
+          title = rec.aiTitle // CC 自己生成的标题，最适合当 label
+          continue
+        }
+        if (rec.type !== 'user' && rec.type !== 'assistant') continue
+        if (!rec.isSidechain) hasMainLine = true
+        if (rec.type !== 'user' || rec.isSidechain || rec.isMeta) continue
+        const text = userText(rec.message || {})
+        if (!text.trim() || text.trimStart().startsWith('<')) continue // <command-*> 等系统注入
+        turns += 1
+        firstUser ||= text
+      }
+
+      const cand = {
+        tool: 'claude',
+        toolSessionId: name.slice(0, -'.jsonl'.length),
+        cwd,
+        // 优先 CC 生成的 ai-title，没有就拿第一句用户发言硬截
+        label: clipW(title || firstUser, 56),
+        turns,
+        createdMs: firstTs || st.mtimeMs,
+        updatedMs: lastTs || st.mtimeMs,
+        skip: '',
+        result: '',
+        path: file,
+      }
+      if (!hasMainLine) cand.skip = 'subagent 支线'
+      else if (!cwd) cand.skip = '无 cwd'
+      out.push(cand)
+    }
+  }
+  return out
+}
+
+// ---------------------------------------------------------------- Codex 扫描
+
+// 从 rollout jsonl 数真实用户轮次，顺带取第一条用户发言
+function countCodexTurns(rolloutPath) {
+  if (!rolloutPath || !fs.existsSync(rolloutPath)) return { turns: 0, first: '' }
+  let turns = 0
+  let first = ''
+  for (const rec of jsonLines(rolloutPath)) {
+    const p = rec.payload || {}
+    if (p.type !== 'message' || p.role !== 'user') continue
+    const text = (p.content || []).map((b) => (b && b.text) || '').join('')
+    if (!text.trim() || text.trimStart().startsWith('<')) continue // environment_context 等注入
+    turns += 1
+    first ||= text
+  }
+  return { turns, first }
+}
+
+// 读 threads 表：优先 node:sqlite，退而 sqlite3 CLI，都没有则返回 null 让上层回落解析 rollout
+function readCodexThreads(db) {
+  const COLS = ['id', 'cwd', 'created_at', 'updated_at', 'name', 'title', 'preview',
+    'first_user_message', 'archived', 'rollout_path']
+
+  try {
+    // node:sqlite 在 Node 22.5 以下不存在，require 会直接抛，落到下面的 sqlite3 CLI
+    const { DatabaseSync } = createRequire(import.meta.url)('node:sqlite')
+    const conn = new DatabaseSync(db, { readOnly: true })
+    try {
+      const have = new Set(conn.prepare('PRAGMA table_info(threads)').all().map((r) => r.name))
+      if (!['id', 'cwd', 'updated_at'].every((c) => have.has(c))) return null
+      const sel = COLS.map((c) => (have.has(c) ? c : `NULL AS ${c}`)).join(', ')
+      return conn.prepare(`SELECT ${sel} FROM threads`).all()
+    } finally {
+      conn.close()
+    }
+  } catch {
+    /* 落到 sqlite3 CLI */
+  }
+
+  try {
+    const info = spawnSync('sqlite3', [db, 'PRAGMA table_info(threads);'], { encoding: 'utf8' })
+    if (info.status !== 0) return null
+    const have = new Set(info.stdout.split('\n').map((l) => l.split('|')[1]).filter(Boolean))
+    if (!['id', 'cwd', 'updated_at'].every((c) => have.has(c))) return null
+    const sel = COLS.map((c) => (have.has(c) ? c : `NULL AS ${c}`)).join(', ')
+    const res = spawnSync('sqlite3', ['-json', db, `SELECT ${sel} FROM threads;`], {
+      encoding: 'utf8',
+      maxBuffer: 64 * 1024 * 1024,
+    })
+    if (res.status !== 0 || !res.stdout.trim()) return null
+    return JSON.parse(res.stdout)
+  } catch {
+    return null
+  }
+}
+
+function scanCodex(cutoffMs) {
+  let dbs = []
+  try {
+    dbs = fs.readdirSync(CODEX_DIR)
+      .filter((n) => /^state_.*\.sqlite$/.test(n))
+      .sort()
+      .map((n) => path.join(CODEX_DIR, n))
+  } catch {
+    /* 没装 codex */
+  }
+  if (dbs.length) {
+    const rows = readCodexThreads(dbs[dbs.length - 1])
+    if (rows) return codexFromRows(rows, cutoffMs)
+  }
+  return scanCodexRollouts(cutoffMs) // 老版 codex / 无 state db 时兜底
+}
+
+function codexFromRows(rows, cutoffMs) {
+  const out = []
+  for (const r of rows) {
+    const updatedMs = toMs(r.updated_at)
+    if (updatedMs < cutoffMs) continue
+    const { turns, first } = countCodexTurns(r.rollout_path || '')
+    // codex 这几列全是用户原话（name 疑似手动命名字段，本机数据全空），硬截
+    const label = clipW(r.name || r.title || r.preview || r.first_user_message || first, 56)
+    const cand = {
+      tool: 'codex',
+      toolSessionId: r.id,
+      cwd: r.cwd || '',
+      label,
+      turns,
+      createdMs: toMs(r.created_at) || updatedMs,
+      updatedMs,
+      skip: '',
+      result: '',
+      path: r.rollout_path || '',
+    }
+    if (r.archived) cand.skip = '已归档'
+    else if (!label) cand.skip = '空会话'
+    out.push(cand)
+  }
+  return out
+}
+
+function scanCodexRollouts(cutoffMs) {
+  const out = []
+  for (const file of listFiles(path.join(CODEX_DIR, 'sessions'))) {
+    if (!file.endsWith('.jsonl')) continue
+    let st
+    try {
+      st = fs.statSync(file)
+    } catch {
+      continue
+    }
+    if (st.mtimeMs < cutoffMs) continue
+    let meta = null
+    for (const rec of jsonLines(file)) {
+      if (rec.type === 'session_meta') {
+        meta = rec.payload || {}
+        break
+      }
+    }
+    const tid = meta && (meta.session_id || meta.id)
+    if (!tid) continue
+    const { turns, first } = countCodexTurns(file)
+    const cand = {
+      tool: 'codex',
+      toolSessionId: tid,
+      cwd: meta.cwd || '',
+      label: clipW(first, 56),
+      turns,
+      createdMs: st.mtimeMs,
+      updatedMs: st.mtimeMs,
+      skip: '',
+      result: '',
+      path: file,
+    }
+    if (!cand.cwd) cand.skip = '无 cwd'
+    out.push(cand)
+  }
+  return out
+}
+
+// ---------------------------------------------------------------- 过滤 / 关联
+
+async function existingToolSessionIds() {
+  const res = await rpc('session:list', { limit: 100000 })
+  return new Set((res.sessions || []).map((s) => s.toolSessionId).filter(Boolean))
+}
+
+function applyFilters(cands, args, linked) {
+  const personaRoot = path.join(CLAWD_DIR, 'personas')
+  for (const c of cands) {
+    if (c.skip) continue
+    if (linked.has(c.toolSessionId)) c.skip = '已关联'
+    else if (c.turns < args.minTurns) c.skip = `少于 ${args.minTurns} 轮`
+    else if (!c.cwd || !isDir(c.cwd)) c.skip = '工作目录已不存在'
+    else if (
+      !args.includeClawd &&
+      (c.cwd === CLAWD_DIR || c.cwd === personaRoot ||
+        c.cwd.startsWith(personaRoot + path.sep) || c.cwd.startsWith(CLAWD_DIR + path.sep))
+    ) {
+      c.skip = 'clawd 自己的会话'
+    }
+  }
+}
+
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+// SessionFile 只落这两处：<clawd>/sessions/** 和 <clawd>/personas/<id>/.clawd/sessions/**。
+// 别退化成扫整个 <clawd>/personas——那底下有用户的 projects/ 和 node_modules，而本函数
+// 每关联一条会话调一次，--limit 50 就是 50 次全树遍历。
+function sessionRoots() {
+  const roots = [path.join(CLAWD_DIR, 'sessions')]
+  let personas = []
+  try {
+    personas = fs.readdirSync(path.join(CLAWD_DIR, 'personas'), { withFileTypes: true })
+  } catch {
+    /* 没有 personas 目录 */
+  }
+  for (const d of personas) {
+    if (d.isDirectory()) roots.push(path.join(CLAWD_DIR, 'personas', d.name, '.clawd', 'sessions'))
+  }
+  return roots
+}
+
+function findSessionFile(sessionId) {
+  const want = `${sessionId}.json`
+  for (const root of sessionRoots()) {
+    const hit = listFiles(root).find((f) => path.basename(f) === want)
+    if (hit) return hit
+  }
+  return null
+}
+
+// 把 SessionFile 的时间戳改回原始会话的，sidebar 才按真实先后排
+function backfillTimestamps(sessionId, cand) {
+  const file = findSessionFile(sessionId)
+  if (!file) return '会话文件没找到，时间戳未回填'
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'))
+    data.createdAt = isoOf(cand.createdMs)
+    data.updatedAt = isoOf(cand.updatedMs)
+    const tmp = `${file}.tmp-import`
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: 0o600 })
+    fs.renameSync(tmp, file)
+    return ''
+  } catch (err) {
+    return `时间戳回填失败：${err.message}`
+  }
+}
+
+async function link(cand, icon) {
+  const created = await rpc('session:create', {
+    cwd: cand.cwd,
+    tool: cand.tool,
+    label: cand.label || `${cand.tool} 会话`,
+    iconKey: icon,
+  })
+  const sessionId = created.sessionId
+  if (!sessionId) throw new RpcError(`session:create 没返回 sessionId：${clip(JSON.stringify(created), 150)}`)
+  await rpc('session:resume', { sessionId, toolSessionId: cand.toolSessionId })
+  const warn = backfillTimestamps(sessionId, cand)
+  cand.result = sessionId + (warn ? `（${warn}）` : '')
+  return sessionId
+}
+
+// ---------------------------------------------------------------- 台账 / 撤销
+
+function ledgerRead() {
+  try {
+    const data = JSON.parse(fs.readFileSync(LEDGER, 'utf8'))
+    return Array.isArray(data) ? data : []
+  } catch {
+    return []
+  }
+}
+
+function ledgerWrite(entries) {
+  try {
+    fs.writeFileSync(LEDGER, JSON.stringify(entries, null, 2), { encoding: 'utf8', mode: 0o600 })
+  } catch (err) {
+    console.error(`（提醒：撤销台账写失败，--undo 将不可用：${err.message}）`)
+  }
+}
+
+async function doUndo(applyIt) {
+  const entries = ledgerRead()
+  if (!entries.length) {
+    console.log('台账是空的——本工具没有关联过任何会话。')
+    return
+  }
+  const res = await rpc('session:list', { limit: 100000 })
+  const alive = new Set((res.sessions || []).map((s) => s.sessionId))
+  const todo = entries.filter((e) => alive.has(e.sessionId))
+  console.log(`台账 ${entries.length} 条，其中 ${todo.length} 条还在。` +
+    (applyIt ? '正在删除……' : '（预演；加 --apply 才真删）'))
+  for (const e of todo) console.log(`  ${e.sessionId}  ${e.label || ''}`)
+  if (!applyIt) return
+  let removed = 0
+  const failed = new Set()
+  for (const e of todo) {
+    try {
+      await rpc('session:delete', { sessionId: e.sessionId })
+      removed += 1
+    } catch (err) {
+      failed.add(e.sessionId)
+      console.error(`  删 ${e.sessionId} 失败：${err.message}`)
+    }
+  }
+  const doneIds = new Set(todo.map((t) => t.sessionId).filter((id) => !failed.has(id)))
+  ledgerWrite(entries.filter((e) => !doneIds.has(e.sessionId)))
+  console.log(`已删除 ${removed} 条。原 Claude Code / Codex 的会话文件没有任何改动。`)
+}
+
+// ---------------------------------------------------------------- 参数
+
+// clawd UI 认得的图标 key（源：ui/src/lib/session-icons.ts）。协议侧 iconKey 是自由字符串，
+// daemon 不拒绝拼错的值，UI 查不到就不画图标——零提示，所以在参数层拦。
+const ICON_KEYS = ['research', 'code', 'loop', 'qa', 'reading', 'debug', 'idea', 'doc', 'assist']
+
+function parseArgs(argv) {
+  const a = {
+    days: 7, tool: 'both', apply: false, limit: 0, minTurns: 2,
+    includeClawd: false, icon: 'reading', undo: false, json: false,
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const k = argv[i]
+    const next = () => {
+      const v = argv[++i]
+      if (v === undefined) die(`${k} 后面缺参数值`)
+      return v
+    }
+    switch (k) {
+      case '--days': a.days = Number(next()); break
+      case '--tool': a.tool = next(); break
+      case '--limit': a.limit = Number(next()); break
+      case '--min-turns': a.minTurns = Number(next()); break
+      case '--icon': a.icon = next(); break
+      case '--apply': a.apply = true; break
+      case '--include-clawd': a.includeClawd = true; break
+      case '--undo': a.undo = true; break
+      case '--json': a.json = true; break
+      case '-h': case '--help': a.help = true; break
+      default: die(`不认识的参数：${k}（--help 看用法）`)
+    }
+  }
+  if (!['claude', 'codex', 'both'].includes(a.tool)) die(`--tool 只能是 claude / codex / both`)
+  // 数值参数显式校验：--min-turns abc → NaN，`turns < NaN` 恒 false，过滤会静默失灵
+  if (!Number.isFinite(a.days) || a.days <= 0) die('--days 得是正数')
+  if (!Number.isFinite(a.limit) || a.limit < 0) die('--limit 得是非负整数（0 = 不限）')
+  if (!Number.isFinite(a.minTurns) || a.minTurns < 0) die('--min-turns 得是非负整数')
+  if (!ICON_KEYS.includes(a.icon)) die(`--icon 只能是 ${ICON_KEYS.join(' / ')}`)
+  return a
+}
+
+const HELP = `把本机 Claude Code / Codex 历史会话关联进 clawd
+
+  node link-sessions.mjs [选项]
+
+  --days N          回看多少天（默认 7）
+  --tool T          claude / codex / both（默认 both）
+  --apply           真正写入；缺省只是 dry-run
+  --limit N         最多关联几条（0=不限），按最近优先
+  --min-turns N     少于这么多轮用户发言的会话跳过（默认 2）
+  --include-clawd   连 ~/.clawd 目录下的会话也关联（默认跳过）
+  --icon KEY        research/code/loop/qa/reading/debug/idea/doc/assist（默认 reading）
+  --undo            撤销本工具关联过的会话（配 --apply 才真删）
+  --json            输出 JSON（含被跳过的和原因）`
+
+// ---------------------------------------------------------------- main
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2))
+  if (args.help) {
+    console.log(HELP)
+    return
+  }
+  if (args.undo) return doUndo(args.apply)
+
+  const cutoffMs = Date.now() - args.days * 86400_000
+  let cands = []
+  if (args.tool === 'claude' || args.tool === 'both') cands = cands.concat(scanClaude(cutoffMs))
+  if (args.tool === 'codex' || args.tool === 'both') cands = cands.concat(scanCodex(cutoffMs))
+
+  applyFilters(cands, args, await existingToolSessionIds())
+  cands.sort((a, b) => b.updatedMs - a.updatedMs)
+
+  let todo = cands.filter((c) => !c.skip)
+  if (args.limit && todo.length > args.limit) {
+    for (const c of todo.slice(args.limit)) c.skip = `超出 --limit ${args.limit}`
+    todo = todo.slice(0, args.limit)
+  }
+
+  if (args.apply) {
+    for (const c of todo) {
+      try {
+        const sid = await link(c, args.icon)
+        // 每成功一条就落台账：攒到循环结束再写的话，中途崩了 --undo 就清不掉已建的会话
+        ledgerWrite(
+          ledgerRead().concat([
+            { sessionId: sid, tool: c.tool, label: c.label, toolSessionId: c.toolSessionId },
+          ]),
+        )
+      } catch (err) {
+        c.result = `失败：${err.message}`
+      }
+    }
+  }
+
+  if (args.json) {
+    console.log(JSON.stringify(cands, null, 2))
+    return
+  }
+
+  console.log(`回看 ${args.days} 天：候选 ${cands.length} 条，可关联 ${todo.length} 条` +
+    (args.apply ? '　（已写入）' : '　（预演，加 --apply 才写入）') + '\n')
+  if (todo.length) {
+    console.log(`${pad('工具', 8)}${pad('最后活跃', 14)}${pad('轮', 4)}${pad('标题', 36)}工作目录`)
+    console.log('-'.repeat(110))
+  }
+  for (const c of todo) {
+    const d = new Date(c.updatedMs)
+    const p2 = (n) => String(n).padStart(2, '0')
+    const when = `${p2(d.getMonth() + 1)}-${p2(d.getDate())} ${p2(d.getHours())}:${p2(d.getMinutes())}`
+    const cwd = c.cwd.replace(HOME, '~')
+    const tail = c.result ? `  → ${c.result}` : ''
+    console.log(pad(c.tool, 8) + pad(when, 14) + pad(String(c.turns), 4) +
+      pad(clipW(c.label, 34), 36) + clipW(cwd, 40) + tail)
+  }
+
+  const skipped = cands.filter((c) => c.skip)
+  if (skipped.length) {
+    const reasons = new Map()
+    for (const c of skipped) reasons.set(c.skip, (reasons.get(c.skip) || 0) + 1)
+    const detail = [...reasons].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k} ${v}`).join('，')
+    console.log(`\n跳过 ${skipped.length} 条：${detail}`)
+  }
+  if (args.apply && todo.length) {
+    console.log('\n原 Claude Code / Codex 的会话文件未被改动，只是在 clawd 里建了引用。' +
+      '\n撤销：node link-sessions.mjs --undo --apply')
+  }
+}
+
+main().catch((err) => die(err instanceof RpcError ? err.message : (err.stack || String(err))))

package/dist/persona-defaults/persona-clawd-butler/CLAUDE.md

@@ -16,7 +16,7 @@ call({ method: "persona:list" })   # clawd-rpc MCP tool
 
 **不猜**：拿不准就查（Read / Bash / WebFetch），不要凭印象编 clawd 功能。
 
-## 5 个 skill
+## 6 个 skill
 
 按老板意图触发对应 skill；skill 自己 fetch 线上文档回答：
 
@@ -27,6 +27,7 @@ call({ method: "persona:list" })   # clawd-rpc MCP tool
 | session 汇总 / 搜话题 / 拉全文 | `clawd-session-lens` |
 | dispatch / DM / 排定时 / 管联系人 | `clawd-orchestration` |
 | 改 persona.json / CLAUDE.md / sandbox / profile / contacts | `clawd-config-editor` |
+| 把 Claude Code / Codex 的历史会话关联进 clawd（冷启动） | `clawd-session-import` |
 
 ## Setup（新会话第一轮 check 一次）