@clawos-dev/clawd 0.2.274 → 0.2.275

package/dist/cli.cjs

@@ -48016,9 +48016,11 @@ var DEFAULT_PERSONAS = [
   {
     // clawd 管家 (chief-of-staff)：spec 2026-07-22-clawd-butler-persona
     // 新 personaId 独立于老 persona-clawd-helper（老 helper seed entry 已删；老用户机器上
-    // 若有残留目录，是他们自留物，daemon 不再触碰）。bundle 里 CLAUDE.md 骨架 + 5 个
-    // prebuild skill 走 copyBundleExtras 装到 `.claude/skills/`；skill fetch 用 daemon
-    // 注入的 env CLAWOS_API 拼 `${CLAWOS_API}/api/docs/**` 拉线上手册。
+    // 若有残留目录，是他们自留物，daemon 不再触碰）。bundle 里 CLAUDE.md 骨架 + 6 个
+    // prebuild skill：新装用户走 copyBundleExtras，存量用户走 refreshDaemonManagedDirs
+    // （`.claude/skills` 在 DAEMON_MANAGED_PATHS 里），都装到 `.claude/skills/`。
+    // 前 5 个 skill fetch 用 daemon 注入的 env CLAWOS_API 拼 `${CLAWOS_API}/api/docs/**`
+    // 拉线上手册；clawd-session-import 自带 scripts/link-sessions.mjs，只依赖 node 内置模块。
     personaId: "persona-clawd-butler",
     label: "clawd \u7BA1\u5BB6",
     model: "opus",
@@ -48257,7 +48259,22 @@ function copyBundleExtras(srcDir, dstDir) {
     }
   }
 }
-var DAEMON_MANAGED_PATHS = ["extension-kit", "CLAUDE.md", ".mcp.json"];
+var DAEMON_MANAGED_PATHS = ["extension-kit", "CLAUDE.md", ".mcp.json", ".claude/skills"];
+function replaceManagedPath(src, dst) {
+  if (!fs12.statSync(src).isDirectory()) {
+    fs12.mkdirSync(path14.dirname(dst), { recursive: true });
+    fs12.rmSync(dst, { recursive: true, force: true });
+    fs12.cpSync(src, dst, { dereference: true });
+    return;
+  }
+  fs12.mkdirSync(dst, { recursive: true });
+  for (const e of fs12.readdirSync(src, { withFileTypes: true })) {
+    if (e.name === "node_modules") continue;
+    const child = path14.join(dst, e.name);
+    fs12.rmSync(child, { recursive: true, force: true });
+    fs12.cpSync(path14.join(src, e.name), child, { recursive: true, dereference: true });
+  }
+}
 function refreshDaemonManagedDirs(args) {
   const entries = args.entries ?? DEFAULT_PERSONAS;
   for (const entry of entries) {
@@ -48270,9 +48287,9 @@ function refreshDaemonManagedDirs(args) {
       if (!fs12.existsSync(srcPath)) continue;
       const dstPath = path14.join(personaDir, relPath);
       try {
-        fs12.cpSync(srcPath, dstPath, { recursive: true, force: true, dereference: true, filter: skipNodeModulesUnder(srcPath) });
+        replaceManagedPath(srcPath, dstPath);
         if (relPath === "CLAUDE.md") {
-          fs12.cpSync(srcPath, path14.join(personaDir, "AGENTS.md"), { force: true, dereference: true });
+          replaceManagedPath(srcPath, path14.join(personaDir, "AGENTS.md"));
         }
         args.logger.info("persona.refresh.synced", {
           personaId: entry.personaId,
@@ -57914,7 +57931,7 @@ function computeMethodAccess(args) {
 }
 
 // src/version.ts
-var version = "0.2.274".length > 0 ? "0.2.274" : "dev";
+var version = "0.2.275".length > 0 ? "0.2.275" : "dev";
 
 // src/cli-probe/probe.ts
 var fs54 = __toESM(require("fs"), 1);

package/dist/persona-defaults/persona-app-builder/extension-kit/README.md

@@ -85,11 +85,24 @@ PR="$HOME/.clawd/personas/persona-app-builder"; DK="$HOME/.clawd/deploy-kit"
 ## 换语言(Node → Python/Go…)
 
 1. `config.env` 的 `NODE_LAYER` 换成对应语言的 FC 运行时层
-2. 替换 `contract/bootstrap`(如 `exec python app.py`)
+2. 替换 bootstrap(如 `exec python app.py`)—— 先读下面的「⚠️ bootstrap 归 daemon 管」
 3. `ext.conf` 的 `BUILD_CMD` 改成对应构建命令
 
 `s.yaml.tmpl` 结构不变。
 
+### ⚠️ bootstrap 归 daemon 管,改了会被还原
+
+`publish.sh` 用的是**共享 deploy-kit** 那份:`$HOME/.clawd/deploy-kit/contract/bootstrap`
+(不是本目录下的)。而 `deploy-kit/contract/` 和本 `extension-kit/` 一样,**每次 daemon 启动
+都会被 bundle 版本无条件覆盖**——就地改它,下次重启就没了,而且没有 `.secrets/*.local`
+那样的个人 override 豁免。
+
+在本目录下新建 `contract/bootstrap` 也不行:`extension-kit/` 是 daemon-managed 路径,
+`contract/` 是 bundle 里有的子目录,整个会被替换掉。
+
+所以**换语言目前没有能存住的改法**,需要产品侧先给 bootstrap 一个 override 机制。
+在那之前,非 Node 运行时请找老板确认怎么走,别就地改了以为生效。
+
 ## 红线(都是踩坑换来的,见记忆 fc-nodejs-deploy-recipe)
 
 - **Supabase 是 clawos 共享生产库**:新表必须 `${APP_NAME}_${SLUG}_` 前缀(从 ext.conf 读),**绝不 drop/alter clawos 已有表**

package/dist/persona-defaults/persona-clawd-butler/.claude/skills/clawd-session-import/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: clawd-session-import
+description: 把用户本机 Claude Code / Codex 的历史会话关联成 clawd 会话，让他们在 clawd 里直接看到并接着聊。当用户说「把我之前在 Claude Code / Codex 的对话弄进 clawd」「刚从别的工具切过来，历史记录能带过来吗」「clawd 里怎么是空的，我以前的会话呢」「导入 / 关联历史会话」，或刚开始用 clawd 需要冷启动时使用。不负责删除会话、不负责搬运文件。
+---
+
+# 把 Claude Code / Codex 的历史会话接进 clawd
+
+用户在 Claude Code 或 Codex 里已经聊过很多，刚切到 clawd 会看到一个空侧边栏，
+不知道从哪儿接着干。这个 skill 扫描本机这两个工具最近的会话，在 clawd 里给每条
+建一个引用，于是它们出现在侧边栏——点开能看到完整原始对话，发消息就接着往下聊。
+
+**只建引用，不复制、不移动、不修改任何原始会话文件**，原会话在 Claude Code / Codex
+里照常可用。关联是可撤销的。
+
+## 用法
+
+只依赖 node（clawd 本身就是 node 跑的，必然有）。脚本就在本 skill 目录下，下面的命令
+按会话工作目录（persona 目录）写相对路径。
+
+先预演，看看会关联哪些（不写任何东西）：
+
+```bash
+node .claude/skills/clawd-session-import/scripts/link-sessions.mjs --days 7
+```
+
+**把预演结果念给用户看**（几条、都是什么话题、来自哪些目录），确认后再执行：
+
+```bash
+node .claude/skills/clawd-session-import/scripts/link-sessions.mjs --days 7 --apply
+```
+
+常用参数：
+
+| 参数 | 作用 |
+|---|---|
+| `--days N` | 回看多少天，默认 7 |
+| `--tool claude\|codex\|both` | 只处理其中一边，默认两边都要 |
+| `--limit N` | 最多关联 N 条（按最近优先）。会话多的用户建议先 `--limit 20`，别一次灌满侧边栏 |
+| `--min-turns N` | 少于 N 轮用户发言的会话跳过，默认 2（滤掉「hello」这种试水会话） |
+| `--include-clawd` | 连 `~/.clawd` 目录下的会话也关联。默认跳过——那些本来就是 clawd 自己开的 |
+| `--icon KEY` | 侧边栏图标：`research/code/loop/qa/reading/debug/idea/doc/assist`，默认 `reading` |
+| `--json` | 输出 JSON，含被跳过的条目和原因，便于你自己筛 |
+
+撤销（删掉本工具建过的全部引用，原会话文件不受影响）：
+
+```bash
+node .claude/skills/clawd-session-import/scripts/link-sessions.mjs --undo          # 预演
+node .claude/skills/clawd-session-import/scripts/link-sessions.mjs --undo --apply  # 真删
+```
+
+## 原理（已对 clawd 源码核实）
+
+一条 clawd 会话的元数据里有 `cwd` + `toolSessionId` 两个字段，指向底层工具那条真实
+对话。关联就是把这两个字段填对：
+
+1. `session:create` —— 只写一份元数据文件，**不拉起任何进程**，所以批量关联很便宜
+2. `session:resume` —— 该会话还没进程时，只是把 `toolSessionId` 写进元数据
+3. 脚本再把元数据里的创建/更新时间改回原会话的真实时间，侧边栏才按真实先后排序
+   （clawd 每次列会话都重读磁盘，改完立刻生效，不用重启）
+
+用户点开时，clawd 按 `(cwd, toolSessionId)` 去读原始 transcript 渲染；发消息才真正
+把 Claude Code / Codex 进程拉起来 resume 那条对话。
+
+两边的会话数据在哪：
+
+- Claude Code：`~/.claude/projects/<编码后的 cwd>/<会话 id>.jsonl`，文件名就是会话 id
+- Codex：`~/.codex/state_*.sqlite` 的 `threads` 表（权威索引，含 cwd / 时间 / 标题 /
+  rollout 路径）。读表按 `node:sqlite` → `sqlite3` 命令行 → 解析
+  `~/.codex/sessions/**/rollout-*.jsonl` 三级回落，老 Node / 老 codex 都能work
+
+## 标题（label）从哪来
+
+**Claude Code 有现成的**：transcript 里 `type: "ai-title"` 那行的 `aiTitle`，是 CC 自己
+生成的会话标题（如「扫描设备sessions创建用户persona」），直接拿来用。实测覆盖率 89%，
+且缺失的那批全是 0~1 轮的「hello」「你是谁」，被默认 `--min-turns 2` 挡掉了——**实际关联
+进来的 CC 会话都有现成标题**。
+
+（注：clawd 原生的历史列表用的是另一套优先级 `last-prompt` → `summary` → 首句前 120 字，
+没用 `ai-title`。所以这里的标题会比 clawd 历史列表更像标题，属预期。）
+
+**Codex 没有**：`threads` 表的 `title` / `preview` / `first_user_message` 三列都是第一条
+用户消息**原文**，不是 AI 摘要；`name` 疑似手动命名字段，实测数据全空。取值顺序
+`name` → `title` → `preview` → `first_user_message` → 解析 rollout 取首句，将来 codex
+补上真标题能自动吃到。
+
+拿到什么就是什么，**按显示宽度硬截到 56 列**（中文算 2 列），不做任何清洗或改写——
+标题应当忠实反映用户原话，不引入猜测。唯一的处理是把换行 / 连续空白折叠成单空格，
+因为标题是单行的。所以开头是长 URL 的 codex 会话，标题就是那段 URL，这是预期行为；
+用户在 clawd 里随时能手动改标题。
+
+## 会被跳过的（脚本自动处理，不用你操心）
+
+- **已关联**：该会话 id 已经出现在某条 clawd 会话里，不会重复建
+- **clawd 自己的会话**：`cwd` 在 `~/.clawd` 底下的，本来就是 clawd 开的（`--include-clawd` 可覆盖）
+- **subagent 支线**：Claude Code 的子 agent transcript，不是独立会话
+- **工作目录已不存在**：原目录被删了，clawd 建不了会话
+- **轮次太少**：低于 `--min-turns`
+
+## 注意
+
+- clawd 桌面端得在跑，否则脚本连不上（会明确报错）
+- 关联完让用户刷新一下 clawd 界面才看得到
+- Codex 会话在 clawd 里不支持回滚 / fork / 实时接管（这是 codex 侧的能力边界，
+  不是关联的问题）；能看能续聊
+- 会话很多时一次全灌会把侧边栏冲爆，建议配 `--limit` 分批，或先用 `--days 3` 试水

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 一次）
 

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/README.md

@@ -75,11 +75,24 @@ PR="$HOME/.clawd/personas/persona-dataclaw-builder"; DK="$HOME/.clawd/deploy-kit
 ## 换语言(Node → Python/Go…)
 
 1. `config.env` 的 `NODE_LAYER` 换成对应语言的 FC 运行时层
-2. 替换 `contract/bootstrap`(如 `exec python app.py`)
+2. 替换 bootstrap(如 `exec python app.py`)—— 先读下面的「⚠️ bootstrap 归 daemon 管」
 3. `ext.conf` 的 `BUILD_CMD` 改成对应构建命令
 
 `s.yaml.tmpl` 结构不变。
 
+### ⚠️ bootstrap 归 daemon 管,改了会被还原
+
+`publish.sh` 用的是**共享 deploy-kit** 那份:`$HOME/.clawd/deploy-kit/contract/bootstrap`
+(不是本目录下的)。而 `deploy-kit/contract/` 和本 `extension-kit/` 一样,**每次 daemon 启动
+都会被 bundle 版本无条件覆盖**——就地改它,下次重启就没了,而且没有 `.secrets/*.local`
+那样的个人 override 豁免。
+
+在本目录下新建 `contract/bootstrap` 也不行:`extension-kit/` 是 daemon-managed 路径,
+`contract/` 是 bundle 里有的子目录,整个会被替换掉。
+
+所以**换语言目前没有能存住的改法**,需要产品侧先给 bootstrap 一个 override 机制。
+在那之前,非 Node 运行时请找老板确认怎么走,别就地改了以为生效。
+
 ## 红线(都是踩坑换来的,见记忆 fc-nodejs-deploy-recipe)
 
 - **必须绑自定义域名**(fc3-domain auto),否则 `fcapp.run` 默认 URL 强制下载网页、浏览器不渲染

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.274",
+  "version": "0.2.275",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",