@clawos-dev/clawd 0.2.279 → 0.2.281

package/dist/cli.cjs

@@ -48164,14 +48164,6 @@ var DEFAULT_PERSONAS = [
       network: true
     }
   },
-  {
-    personaId: "persona-builder",
-    label: "\u4EBA\u683C\u8BBE\u8BA1\u5E08",
-    model: "opus",
-    iconKey: "reading",
-    public: false,
-    sandboxProfile: DEFAULT_BYPASS_PROFILE
-  },
   {
     // HTML PPT 制作师：把想法/文字/旧 PPT 转成单文件 HTML 演示稿
     // bundle 含 frontend-slides skill（MIT，Zara Zhang），daemon ship 进 .claude/skills/
@@ -48398,6 +48390,61 @@ function migrateCodexSandbox(args) {
   }
   if (n > 0) args.logger.info("persona.codex-sandbox.done", { migrated: n });
 }
+var PERSONA_BUILDER_ID = "persona-builder";
+var PERSONA_BUILDER_TOMBSTONE_MARKER = "<!-- clawd:persona-builder-retired -->";
+var PERSONA_BUILDER_TOMBSTONE = `${PERSONA_BUILDER_TOMBSTONE_MARKER}
+\u300C\u4EBA\u683C\u8BBE\u8BA1\u5E08\u300D\u5DF2\u4E0B\u7EBF\u3002
+
+\u5EFA\u65B0 persona \u7684\u80FD\u529B\u5DF2\u5E76\u5165 **clawd \u7BA1\u5BB6**\uFF08persona-clawd-butler\uFF09\u7684 \`persona-authoring\` skill\u3002
+\u843D\u76D8\u6539\u8D70 daemon \u7684 \`persona:create\`\uFF0C\u6C99\u7BB1\u914D\u7F6E\u4E0E\u754C\u9762\u4E0A\u5EFA\u51FA\u6765\u7684\u5B8C\u5168\u4E00\u81F4\uFF0C\u4E0D\u518D\u624B\u5199\u6587\u4EF6\u3002
+
+\u8BF7\u5207\u5230 clawd \u7BA1\u5BB6\uFF0C\u76F4\u63A5\u8BF4\u300C\u6211\u60F3\u8981\u4E00\u4E2A xxx \u7684 persona\u300D\u3002
+
+\u8FD9\u4E2A persona \u4E0B\u7684\u5386\u53F2\u4F1A\u8BDD\u4ECD\u53EF\u7FFB\u9605\uFF1B\u4F46\u4E0D\u8981\u518D\u7528\u5B83\u5EFA\u65B0 persona \u2014\u2014 \u624B\u5199\u843D\u76D8\u4EA7\u51FA\u7684\u6C99\u7BB1\u914D\u7F6E
+\u4E0E daemon \u6A21\u677F\u5DF2\u7ECF\u6F02\u79FB\u3002
+`;
+function containsAnyFile(dir) {
+  let entries;
+  try {
+    entries = fs12.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      if (containsAnyFile(path14.join(dir, e.name))) return true;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+function retirePersonaBuilder(args) {
+  const dir = args.store.personaDirPath(PERSONA_BUILDER_ID);
+  if (!fs12.existsSync(dir)) return;
+  try {
+    const used = containsAnyFile(path14.join(dir, ".clawd", "sessions")) || containsAnyFile(path14.join(dir, ".claude", "skills")) || containsAnyFile(path14.join(dir, "projects"));
+    if (!used) {
+      args.store.remove(PERSONA_BUILDER_ID);
+      args.logger.info("persona.retire-builder.removed", { personaId: PERSONA_BUILDER_ID });
+      return;
+    }
+    let wrote = false;
+    for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+      const p2 = path14.join(dir, name);
+      const cur = fs12.existsSync(p2) ? fs12.readFileSync(p2, "utf8") : null;
+      if (cur?.startsWith(PERSONA_BUILDER_TOMBSTONE_MARKER)) continue;
+      fs12.writeFileSync(p2, PERSONA_BUILDER_TOMBSTONE);
+      wrote = true;
+    }
+    if (wrote) args.logger.info("persona.retire-builder.tombstoned", { personaId: PERSONA_BUILDER_ID });
+  } catch (err) {
+    args.logger.warn("persona.retire-builder.failed", {
+      personaId: PERSONA_BUILDER_ID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
 function findDeployKitRoot(logger) {
   const candidates = [];
   try {
@@ -54574,14 +54621,17 @@ function createHttpRouter(deps) {
         return true;
       }
       const dispatchArgs = typeof body === "object" && body != null ? body : {};
+      let broadcastAfterResponse;
       try {
         const result = await deps.authedRpc.dispatch(method, dispatchArgs, auth.context);
         sendJson(res, 200, { ok: true, result: result.response }, AUTHED_RPC_CORS_HEADERS);
+        broadcastAfterResponse = result.broadcast;
       } catch (err) {
         const e = err;
         const code = e?.code ?? "INTERNAL";
         sendJson(res, authedRpcErrorStatus(code), { ok: false, error: code, message: e?.message ?? String(err) }, AUTHED_RPC_CORS_HEADERS);
       }
+      if (broadcastAfterResponse?.length) deps.authedRpc.fanOutBroadcast?.(broadcastAfterResponse);
       return true;
     }
     if (url.pathname.startsWith("/preview/")) {
@@ -58074,7 +58124,7 @@ function computeMethodAccess(args) {
 }
 
 // src/version.ts
-var version = "0.2.279".length > 0 ? "0.2.279" : "dev";
+var version = "0.2.281".length > 0 ? "0.2.281" : "dev";
 
 // src/cli-probe/probe.ts
 var fs54 = __toESM(require("fs"), 1);
@@ -61343,6 +61393,7 @@ async function startDaemon(config) {
   refreshSandboxSettings({ store: personaStore, logger });
   migrateAgentsMirror({ store: personaStore, logger });
   migrateCodexSandbox({ store: personaStore, logger });
+  retirePersonaBuilder({ store: personaStore, logger });
   const groupFileStore = new GroupFileStore({ dataDir: config.dataDir, logger });
   const dispatchStore = createDispatchStore({
     filePath: import_node_path63.default.join(config.dataDir, "dispatch.json"),
@@ -62076,6 +62127,23 @@ async function startDaemon(config) {
   const authResolver = new AuthContextResolver({
     ownerToken: resolvedAuthToken
   });
+  const fanOutBroadcast = (broadcast) => {
+    for (const { frame: bf, target } of broadcast ?? []) {
+      if (target === "all") {
+        transport?.broadcastAll(bf);
+        continue;
+      }
+      const sid = bf.sessionId;
+      if (target === "first-subscriber" && sid) {
+        const handle = transport?.firstSubscriber(sid);
+        if (handle) handle.send(bf);
+        continue;
+      }
+      if (sid) {
+        transport?.broadcastToSession(sid, bf);
+      }
+    }
+  };
   const authedRpc = {
     authenticate: (token) => authenticate(token, buildConnectAuthDeps()),
     dispatch: (method, body, ctx) => {
@@ -62091,7 +62159,9 @@ async function startDaemon(config) {
         handlers,
         feishuActive: () => feishuActive
       });
-    }
+    },
+    // mutating RPC 经 HTTP 调用时 handler broadcast 帧的外推（http-router 在 response 送出后调）
+    fanOutBroadcast
   };
   const viewerAssetLoader = tryLoadViewerAssets(logger);
   const shareUiAssetLoader = tryLoadShareUi(logger);
@@ -62243,21 +62313,7 @@ async function startDaemon(config) {
     if (requestId && result.response) {
       client.send({ ...result.response, requestId });
     }
-    for (const { frame: bf, target } of result.broadcast ?? []) {
-      if (target === "all") {
-        transport?.broadcastAll(bf);
-        continue;
-      }
-      const sid = bf.sessionId;
-      if (target === "first-subscriber" && sid) {
-        const handle = transport?.firstSubscriber(sid);
-        if (handle) handle.send(bf);
-        continue;
-      }
-      if (sid) {
-        transport?.broadcastToSession(sid, bf);
-      }
-    }
+    fanOutBroadcast(result.broadcast);
   });
   manager.sweepEphemeralOnStartup();
   await wss.start();

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

@@ -0,0 +1,86 @@
+---
+name: persona-authoring
+description: 老板要在 clawd 里加一个新 persona 时触发——「我想要一个 xxx 的助手」「给我建个专门干 yyy 的 persona」「帮我加个人格」，也接 scan-sessions-suggest-personas 勾选后转交过来的候选。负责把一句话需求变成落盘的新 persona。只管**建新的**；改已有 persona 的人格 / 模型 / 沙箱是 clawd-config-editor，不是本 skill。
+---
+
+# 建一个新 persona
+
+老板一句话进来，你补齐字段、写好人格、调一次 RPC 落盘。**不要多轮访谈**——老板要的是一个
+能用的 persona，不是一场需求评审。
+
+## 1. 听需求 → 抽字段
+
+| 字段 | 怎么定 |
+|---|---|
+| `slug` | persona 的身份。从需求语义推一个**英文短名**（"专门写商业文案的助手" → `copywriter`）。约束：`^[a-z0-9]+(-[a-z0-9]+)*$`、≤32 字符。daemon 自己拼 `persona-` 前缀，**你不要带前缀** |
+| `label` | UI 显示名。默认中文短名（"文案助手""调试侦探"），跟现有 persona 风格对齐；老板要英文 / 长名照办 |
+| `personality` | CLAUDE.md 全文，见 §2 |
+| `model` | 默认 `opus`；老板明确说"用 haiku / sonnet"再换 |
+| `iconKey` | 不确定就省略（UI 兜默认）。9 个合法 key：`research`（研究）/ `code`（开发）/ `loop`（Loop 任务）/ `qa`（问答）/ `reading`（阅读）/ `debug`（调试）/ `idea`（创意）/ `doc`（文档）/ `assist`（助手） |
+| `public` | 默认 `false`（私有）；老板说"想分享出去"才 `true` |
+
+**互动原则**：
+
+- 一句话足够推断 → **不问**，直接把生成的定位和人格给老板看，他改不满意的地方
+- 一句话太糙 → 挑**最影响人格定位**的 1-2 个点问一轮就够；典型：它的工作边界 / 它该问还是该先做 /
+  它要不要能读写老板本机文件。不要 3-4 轮访谈
+- 老板说"你看着办" → 你看着办，别再追问
+
+## 2. 写 CLAUDE.md
+
+这是真正的"灵魂"。**风格灵活**，每个 persona 应该长得不一样，按老板需求和你对人设的理解写。
+但保底要有这四块：
+
+1. **第一句：定位**（"你是老板的 xxx 助手"），让任何打开它的 agent（Claude Code / Codex）
+   一秒进入角色
+2. **何时找它**：trigger 场景，老板会在什么情况下切到这个 persona
+3. **工作方式 / 边界**：该做什么、不做什么；该问还是该先做；有没有红线
+4. **行为规范**：跟老板对话的风格（简洁 vs 详细、是否质疑老板判断、要不要解释思路）
+
+可以加但不强制：概念地图、目录结构参考、初次见面检查清单。
+
+**硬性要求**：
+
+- 让产出的 persona 知道"它是 clawd 的一个 persona"——避免新 persona 把自己说成独立产品
+- 红线写**具体行为**（"不擅自归类" / "不堆根目录"），不写空话（"要谨慎" / "要负责"）
+- 老板的全局 CLAUDE.md 已经规定"每次回答必须以'老板'开头"，新 persona 自动继承，
+  persona 级 CLAUDE.md 里不用重复
+- 从 `scan-sessions-suggest-personas` 转交过来的候选，把画像卡里的**行为特征**沉淀进去
+  （常用什么工具、碰什么文件、边界在哪），别只写一句空泛的定位
+
+## 3. 落盘：一次 `persona:create`
+
+```
+call({ method: "persona:create", args: {
+  slug: "copywriter",
+  label: "文案助手",
+  personality: "<CLAUDE.md 全文>",
+  model: "opus",
+  iconKey: "doc"
+}})   # clawd-rpc MCP tool
+```
+
+三条务必记住：
+
+- **不要自己写文件。** `persona.json`、`CLAUDE.md`、`AGENTS.md` 镜像、沙箱配置全由 daemon 落，
+  跟老板在界面上点出来的 persona 完全一致。手写落盘一定会漂
+- **slug 撞名 daemon 直接报错**（`personaId already exists: persona-<slug>`），不会自动加后缀。
+  撞了先告诉老板，换一个 slug 再调，别自作主张改名
+- **不用重启 daemon**。RPC 落盘的同时已经登记进内存，刷新界面就能看到
+
+## 4. 报告
+
+一句话报 persona id + 显示名，然后**简短问一句**："这个 persona 要装哪些 skill 吗？"
+
+- 老板回"不用" / "暂时不需要" → 跳过
+- 老板说要 → 让老板给 skill 名（`<author>/<skill-name>` 形式），你帮他跑 `npx skills add <name> -y`
+
+**不要复述 CLAUDE.md 全文。** 老板要看自己会去看。
+
+## 红线
+
+- **不举例 skill** —— 老板自己清楚他要什么，你举例会污染他的判断
+- **不替老板写人设** —— 老板说"我要个调试助手"，你别脑补"它应该会写测试 / 会画时序图 / …"。
+  只把老板原话里的东西沉淀下来，不确定的留白等老板补
+- **不动其他 persona 目录** —— 只建新的。老板要改已有 persona 切 `clawd-config-editor`
+- **冲突先问后做** —— slug 撞名、老板需求前后矛盾，先说清楚再动手

package/dist/persona-defaults/persona-clawd-butler/.claude/skills/scan-sessions-suggest-personas/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: scan-sessions-suggest-personas
+description: 给还没配好 persona 的老板做一次性冷启动盘点——扫本机 Claude Code / Codex 的历史 session 反推老板常干哪几类活，产出 persona 候选交老板勾选。当老板说「我刚上手 clawd，帮我配几个 persona」「我该建什么 persona」「根据我的使用记录推荐 persona」，或新会话 Setup 阶段发现还没盘点过时使用。只出候选不落盘（落盘交 persona-authoring）；日常查会话内容 / 搜话题 / 汇总某时段 session 是 clawd-session-lens，把历史会话导入 clawd 是 clawd-session-import，都不是本 skill。
+---
+
+# 从历史 session 反推 persona
+
+老板已经在 Claude Code / Codex 里干了很多活，这些记录就是最真实的需求样本。
+比让他凭空想「我需要什么 persona」准得多——**人说不清自己的习惯，记录说得清**。
+
+## 和 clawd-session-import 的区别
+
+两件事，各干各的，别混：
+
+| | 干什么 | 产物 |
+|---|---|---|
+| `clawd-session-import` | 把历史会话**搬进** clawd，能接着聊 | clawd session |
+| 本 skill | 从历史会话**反推人格**，建议建什么 persona | persona 候选建议 |
+
+扫描解析逻辑相似，但目标不同。不要为了复用把两件事捏一起。
+
+## 流程
+
+### 1. 跑提取脚本
+
+```bash
+node scripts/extract-signals.mjs --days 7 --out /tmp/persona-scan
+```
+
+**零依赖，只要有 node 就能跑**（不需要 python、不装任何包）。无 LLM、无网络、只读。
+约 100MB session 记录 0.4 秒扫完。
+
+常用参数：
+
+| 参数 | 默认 | 说明 |
+|---|---|---|
+| `--days` | 7 | 回溯天数。信号太少就放宽到 14 / 30 |
+| `--min-queries` | 5 | 低于此 query 数视为零散试用，不出卡 |
+| `--min-days` | 2 | 低于此活跃天数视为一次性任务，不出卡 |
+| `--no-skip-known` | 关 | 默认**跳过**已有 persona 覆盖的目录；加上它才全量报 |
+
+对 node 版本没有硬要求：`node:sqlite`（读 codex 的 threads 表拿 git 分支等元信息）
+只在 node ≥22.5 上有，拿不到就自动降级到扫 rollout 文件，**query 提取结果完全相同**。
+输出是确定性的——同样的输入跑两次，逐字节一致。
+
+产出两个文件：
+
+- **`profiles.json`** —— 每个工作目录一张画像卡，**这是你要读的**，通常 <20KB
+- `signals.jsonl` —— 逐条原始 query，留档备查，一般不用读
+
+### 2. 读画像卡，判断这是什么活
+
+每张卡长这样：
+
+```json
+{ "proj": "...", "cwd": "/Users/x/work/papers", "git_branch": "",
+  "queries": 34, "unique_queries": 29, "sessions": 8, "active_days": 5,
+  "top_tools": [["WebFetch",41],["Read",38],["Write",12]],
+  "top_exts": [[".pdf",22],[".md",14]],
+  "session_titles": ["提炼 Transformer 论文方法部分", "对比三篇实验设置", "..."],
+  "samples": ["...", "..."] }
+```
+
+**读的顺序：`session_titles` → `top_tools` → `samples`。**
+
+`session_titles` 是 Claude Code 自己给每个会话生成的标题（约九成会话有），
+**每条就是一句已经抽象好的任务摘要**——这正是你要输出的那种「意义」，
+不用再从原话里提炼。十来条标题排在一起，干什么活一目了然。
+
+工具指纹是行为事实，比说的话更硬，用来交叉验证标题的判断：
+
+| 指纹 | 大概率是 |
+|---|---|
+| `Bash` + `Edit` 高频，`.ts/.py/.go` | 写代码 |
+| `WebSearch` / `WebFetch` 压倒性 | 做调研 |
+| `Read` + `Write`，`.md/.docx/.pdf` | 读写文档 |
+| `mcp__lark-*` 密集 | 办公协同 |
+| `Bash` 独大但没有 Edit | 运维 / 机器管理 |
+
+判断时守两条：
+
+- **看重复出现的意图，不看单次任务。** 一次性的「帮我查个报错」不是 persona，
+  连续五天都在「读文献 → 提炼 → 转中文」才是
+- **警惕语义噪音。** 脚本滤得掉带标签的系统回填，滤不掉 agent 自己造的探针指令
+  （比如 `用 Bash 执行 cat .../marker.txt`）——这类长得像人话，靠你眼力剔除。
+  `session_titles` 基本不受这类污染，又一个优先看它的理由
+
+### 3. 输出候选，交给老板勾选
+
+**永远不自动创建。** 人格是老板的东西，你只出建议。
+
+**不要贴老板的原话。** 抽象出这类活的**意义**再表述——原话散、带上下文、还牵扯隐私，
+抽象后的一句定位反而更能让老板一眼判断准不准。
+
+每个候选给四行：
+
+```
+候选 1 ── 论文研读助手  (slug: paper-reader)
+  在干的活   连续 5 天、8 个会话，读英文文献 → 提炼方法 → 转中文结构化摘要
+  行为特征   WebFetch/Read 为主，几乎不写代码，碰 .pdf/.bib
+  建议定位   帮老板快速消化外文论文，只做消化和提炼，不代笔写作
+  可能重叠   与现有 persona-researcher 有部分重合，researcher 偏通用网络调研
+```
+
+给 3-5 个就够，多了老板挑不动。同一类活散在多个目录的要**合并成一个候选**，
+不要一个目录一张卡。
+
+### 4. 老板勾中的，转交 `persona-authoring`
+
+**你不落盘。** 老板勾完，把选中候选的这几项交给 `persona-authoring` skill：
+
+- **slug / label** —— 候选卡上已经给了
+- **建议定位** —— 候选卡的那一行
+- **行为特征** —— 常用什么工具、碰什么文件、边界在哪。这条必须带上：新 persona 的
+  CLAUDE.md 要把它沉淀进去，别只留一句空泛的定位
+
+落盘、id 拼装、沙箱配置由 `persona-authoring` 调一次 `persona:create` 完成，你不碰文件。
+
+## 边界
+
+- **只读，不出网。** 脚本不修改任何 session 文件，不上传任何内容
+- **不自动建 persona。** 只出候选，老板勾选后才落盘
+- **跳过已有 persona 覆盖的目录**（默认行为）。老板已经有专人干的活不用重复推荐；
+  要全量看时才加 `--no-skip-known`
+- **信号不足就直说。** 如果扫完只剩零散试用，老实告诉老板「最近一周的活已经被现有
+  persona 覆盖完了，没发现新的」，不要硬凑候选

package/dist/persona-defaults/persona-clawd-butler/.claude/skills/scan-sessions-suggest-personas/scripts/extract-signals.mjs

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+/**
+ * 扫描本机 Claude Code / Codex 的 session 记录，提取「用户真实 query」+ 工作画像。
+ *
+ * 零依赖、只读、不出网、无 LLM。只要有 node 就能跑（不需要 python）。
+ *
+ * 用法:
+ *   node extract-signals.mjs --days 7 --out /tmp/persona-scan
+ *   node extract-signals.mjs --days 30 --no-skip-known
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import readline from 'node:readline';
+
+// node:sqlite 是实验特性，加载时 node 会打 ExperimentalWarning。
+// 得先摘掉 node 自带的 listener，否则它照打不误。
+process.removeAllListeners('warning');
+process.on('warning', (w) => {
+  if (w.name === 'ExperimentalWarning' && /SQLite/i.test(w.message)) return;
+  console.warn(`${w.name}: ${w.message}`);
+});
+
+const HOME = os.homedir();
+const CLAUDE_PROJECTS = path.join(HOME, '.claude', 'projects');
+const CODEX_DIR = path.join(HOME, '.codex');
+const PERSONAS_DIR = path.join(HOME, '.clawd', 'personas');
+
+// ---------- 系统回填识别：这些不是人在表达需求 ----------
+const DROP_PREFIX = [
+  '<system-reminder', '<command-name', '<command-message', '<command-args',
+  '<local-command-stdout', '<local-command-stderr', '<user-prompt-submit-hook',
+  '<task-notification', '<turn', '<environment', '<user_instructions',
+  '[Dispatched from', '[Request interrupted', '[attachment:image:data:',
+  'Caveat: The messages below', '# AGENTS.md instructions', '# CLAUDE.md',
+  '# 连接上下文', '你之前委派出去的任务有了结果',
+  'Another Claude session sent a message', '<teammate-message',
+];
+const DROP_SUBSTR = ['<clawd-shift-fire', '<teammate-message', '<task-notification'];
+
+const B64 = /data:image\/[a-z]+;base64,[A-Za-z0-9+/=]+/g;
+
+const clean = (t) => t.replace(B64, '[图片]').replace(/[ \t]+/g, ' ').trim();
+
+/** 结构上能判定的噪音在这里滤干净。语义噪音（agent 自造的探针指令等）正则救不了，
+ *  交给下游聚类稀释——占比极低，不值得为它引入一层判断。 */
+function isRealQuery(t) {
+  if (!t || t.length < 6) return false;
+  if (DROP_PREFIX.some((p) => t.startsWith(p))) return false;
+  const head = t.slice(0, 200);
+  if (DROP_SUBSTR.some((s) => head.includes(s))) return false;
+  if ((t[0] === '{' || t[0] === '[') && t.length > 300) return false; // 整块粘贴的 JSON/日志
+  return true;
+}
+
+function inWindow(ts, cutMs) {
+  const t = Date.parse(ts);
+  return Number.isFinite(t) && t >= cutMs;
+}
+
+/** 从 message.content 取纯文本；含 tool_result 块的整条判为工具回填。 */
+function textOf(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  const parts = [];
+  for (const b of content) {
+    if (!b || typeof b !== 'object') continue;
+    if (b.type === 'tool_result') return '';
+    if (b.type === 'text') parts.push(b.text || '');
+  }
+  return parts.join(' ');
+}
+
+// ---------- 小工具 ----------
+const bump = (m, k, n = 1) => m.set(k, (m.get(k) || 0) + n);
+// 计数相同时按名字排——否则并列项谁进前 N 随遍历顺序漂移，同样输入得不到同样输出
+const topN = (m, n) =>
+  [...m.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1)).slice(0, n);
+
+/** 递归列出目录下所有 .jsonl（不用 fs.glob，那是新版 node 才有的实验 API）。 */
+function walkJsonl(dir, out = [], depth = 0) {
+  if (depth > 8) return out;
+  let ents;
+  try {
+    ents = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  // 排序：保证遍历顺序稳定，否则截断类字段（session_titles 等）会随机漂移
+  ents.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  for (const e of ents) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) walkJsonl(p, out, depth + 1);
+    else if (e.isFile() && e.name.endsWith('.jsonl')) out.push(p);
+  }
+  return out;
+}
+
+/** 逐行流式读——单个 session 文件可能几十 MB，不能整个读进内存。 */
+async function eachLine(file, fn) {
+  let rl;
+  try {
+    rl = readline.createInterface({
+      input: fs.createReadStream(file, { encoding: 'utf8' }),
+      crlfDelay: Infinity,
+    });
+  } catch {
+    return;
+  }
+  try {
+    for await (const line of rl) {
+      if (!line) continue;
+      let rec;
+      try {
+        rec = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      fn(rec);
+    }
+  } catch {
+    /* 文件读坏了就跳过这个文件 */
+  }
+}
+
+// ---------- 已有 persona：这些目录下的活已经有人干了，默认跳过 ----------
+function knownPersonaDirs() {
+  const out = new Map();
+  let ents;
+  try {
+    ents = fs.readdirSync(PERSONAS_DIR, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of ents) {
+    if (!e.isDirectory()) continue;
+    const d = path.join(PERSONAS_DIR, e.name);
+    if (fs.existsSync(path.join(d, '.clawd', 'persona.json'))) {
+      try {
+        out.set(fs.realpathSync(d), e.name);
+      } catch {
+        out.set(d, e.name);
+      }
+    }
+  }
+  return out;
+}
+
+function coveredBy(cwd, known) {
+  if (!cwd) return null;
+  let rp = cwd;
+  try {
+    rp = fs.realpathSync(cwd);
+  } catch { /* 目录可能已删，用原字符串比 */ }
+  for (const [d, name] of known) {
+    if (rp === d || rp.startsWith(d + path.sep)) return name;
+  }
+  return null;
+}
+
+const blank = () => ({
+  sessions: new Set(), days: new Set(), cwd: '', branch: '',
+  tools: new Map(), exts: new Map(), titles: [],
+});
+const profOf = (prof, k) => {
+  if (!prof.has(k)) prof.set(k, blank());
+  return prof.get(k);
+};
+
+// ---------- Claude Code ----------
+async function scanClaude(cutMs, sig, prof) {
+  let dirs;
+  try {
+    dirs = fs.readdirSync(CLAUDE_PROJECTS, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  dirs.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  for (const de of dirs) {
+    if (!de.isDirectory()) continue;
+    const proj = de.name;
+    const pdir = path.join(CLAUDE_PROJECTS, proj);
+    let files;
+    try {
+      files = fs.readdirSync(pdir).filter((f) => f.endsWith('.jsonl')).sort();
+    } catch {
+      continue;
+    }
+    for (const fname of files) {
+      const f = path.join(pdir, fname);
+      try {
+        if (fs.statSync(f).mtimeMs < cutMs) continue; // 整个文件都在窗口外，不必逐行解析
+      } catch {
+        continue;
+      }
+      const sid = fname.slice(0, -6);
+      const p = profOf(prof, proj);
+
+      await eachLine(f, (d) => {
+        const typ = d.type;
+        const cwd = d.cwd || '';
+
+        // Claude Code 自己生成的会话标题：一句已抽象好的任务摘要，
+        // 比任何启发式取样都准，是画像的首选信号（约 9 成会话有）
+        if (typ === 'ai-title' && d.aiTitle) {
+          p.titles.push(d.aiTitle);
+          return;
+        }
+
+        const ts = d.timestamp || '';
+        if (!inWindow(ts, cutMs)) return;
+
+        if (typ === 'user' && !d.isMeta && !d.isSidechain) {
+          const t = clean(textOf(d.message?.content));
+          if (!isRealQuery(t)) return;
+          sig.push({ src: 'claude', proj, cwd, session: sid, date: ts.slice(0, 10), text: t.slice(0, 600) });
+          p.sessions.add(sid);
+          p.days.add(ts.slice(0, 10));
+          if (cwd) p.cwd = cwd;
+          if (d.gitBranch) p.branch = d.gitBranch;
+        } else if (typ === 'assistant') {
+          for (const b of d.message?.content || []) {
+            if (!b || b.type !== 'tool_use') continue;
+            bump(p.tools, b.name || '?');
+            const fp = b.input?.file_path;
+            if (typeof fp === 'string' && fp) {
+              const ext = path.extname(fp).toLowerCase();
+              if (ext) bump(p.exts, ext);
+            }
+          }
+        }
+      });
+    }
+  }
+}
+
+// ---------- Codex ----------
+/** threads 表是 codex 的权威索引，比解析 rollout 准，还带 git/model 信息。
+ *  node:sqlite 要 node>=22.5 且是实验特性——拿不到就返回空，由 rollout 扫描兜底。 */
+async function codexMetaFromDb() {
+  const out = new Map();
+  let dbs;
+  try {
+    dbs = fs.readdirSync(CODEX_DIR)
+      .filter((f) => /^state_.*\.sqlite$/.test(f))
+      .sort()
+      .map((f) => path.join(CODEX_DIR, f));
+  } catch {
+    return out;
+  }
+  if (!dbs.length) return out;
+
+  let DatabaseSync;
+  try {
+    ({ DatabaseSync } = await import('node:sqlite'));
+  } catch {
+    return out; // 老版本 node 没有 node:sqlite，走兜底
+  }
+  try {
+    const db = new DatabaseSync(dbs[dbs.length - 1], { readOnly: true });
+    const cols = new Set(db.prepare('PRAGMA table_info(threads)').all().map((r) => r.name));
+    if (!cols.has('rollout_path')) return out;
+    const pick = (n) => (cols.has(n) ? n : `'' AS ${n}`);
+    const rows = db
+      .prepare(`SELECT rollout_path, cwd, ${pick('git_branch')}, ${pick('model')} FROM threads`)
+      .all();
+    for (const r of rows) {
+      if (!r.rollout_path) continue;
+      let key = r.rollout_path;
+      try {
+        key = fs.realpathSync(key);
+      } catch { /* 文件可能已删 */ }
+      out.set(key, { cwd: r.cwd || '', branch: r.git_branch || '', model: r.model || '' });
+    }
+    db.close();
+  } catch {
+    return out;
+  }
+  return out;
+}
+
+async function scanCodex(cutMs, sig, prof) {
+  const db = await codexMetaFromDb();
+  const files = walkJsonl(path.join(CODEX_DIR, 'sessions'));
+  for (const f of files) {
+    try {
+      if (fs.statSync(f).mtimeMs < cutMs) continue;
+    } catch {
+      continue;
+    }
+    let meta = db.get(f);
+    if (!meta) {
+      try {
+        meta = db.get(fs.realpathSync(f));
+      } catch { /* 取不到就靠 session_meta 兜底 */ }
+    }
+    let cwd = meta?.cwd || '';
+    const branch = meta?.branch || '';
+    const sid = path.basename(f).slice(0, -6);
+    let key = cwd ? `codex:${path.basename(cwd)}` : null;
+
+    await eachLine(f, (d) => {
+      const p = d.payload || {};
+      if (d.type === 'session_meta') {
+        cwd = cwd || p.cwd || '';
+        key = `codex:${path.basename(cwd) || '?'}`;
+        return;
+      }
+      const ts = d.timestamp || '';
+      if (d.type !== 'response_item' || !inWindow(ts, cutMs)) return;
+      if (key === null) key = `codex:${path.basename(cwd) || '?'}`;
+      const pr = profOf(prof, key);
+
+      if (p.role === 'user') {
+        const t = clean(
+          (p.content || [])
+            .filter((b) => b && b.type === 'input_text')
+            .map((b) => b.text || '')
+            .join(' '),
+        );
+        if (!isRealQuery(t)) return;
+        sig.push({ src: 'codex', proj: key, cwd, session: sid, date: ts.slice(0, 10), text: t.slice(0, 600) });
+        pr.sessions.add(sid);
+        pr.days.add(ts.slice(0, 10));
+        pr.cwd = cwd;
+        if (branch) pr.branch = branch;
+      } else if (p.type === 'function_call') {
+        bump(pr.tools, p.name || '?');
+      }
+    });
+  }
+}
+
+// ---------- 主流程 ----------
+function parseArgs(argv) {
+  const a = { days: 7, out: '.', samples: 12, minQueries: 5, minDays: 2, skipKnown: true };
+  for (let i = 0; i < argv.length; i++) {
+    const k = argv[i];
+    const next = () => argv[++i];
+    if (k === '--days') a.days = parseInt(next(), 10);
+    else if (k === '--out') a.out = next();
+    else if (k === '--samples') a.samples = parseInt(next(), 10);
+    else if (k === '--min-queries') a.minQueries = parseInt(next(), 10);
+    else if (k === '--min-days') a.minDays = parseInt(next(), 10);
+    else if (k === '--no-skip-known') a.skipKnown = false;
+    else if (k === '-h' || k === '--help') a.help = true;
+  }
+  return a;
+}
+
+const HELP = `扫描本机 Claude Code / Codex session，提取真实 query + 工作画像。
+
+  --days N           回溯天数 (默认 7)
+  --out DIR          输出目录 (默认 .)
+  --samples N        每个目录保留的 query 样本数 (默认 12)
+  --min-queries N    低于此 query 数不出卡 (默认 5)
+  --min-days N       低于此活跃天数不出卡 (默认 2)
+  --no-skip-known    不跳过已有 persona 覆盖的目录
+`;
+
+async function main() {
+  const a = parseArgs(process.argv.slice(2));
+  if (a.help) {
+    console.log(HELP);
+    return;
+  }
+  fs.mkdirSync(a.out, { recursive: true });
+  const cutMs = Date.now() - a.days * 86400000;
+
+  const sig = [];
+  const prof = new Map();
+  await scanClaude(cutMs, sig, prof);
+  await scanCodex(cutMs, sig, prof);
+  sig.sort((x, y) => (x.date < y.date ? -1 : x.date > y.date ? 1 : 0));
+
+  fs.writeFileSync(
+    path.join(a.out, 'signals.jsonl'),
+    sig.map((s) => JSON.stringify(s)).join('\n') + (sig.length ? '\n' : ''),
+  );
+
+  const byProj = new Map();
+  for (const s of sig) {
+    if (!byProj.has(s.proj)) byProj.set(s.proj, []);
+    byProj.get(s.proj).push(s);
+  }
+
+  const known = knownPersonaDirs();
+  const cards = [];
+  const skipped = [];
+  const thin = [];
+
+  for (const [k, v] of prof) {
+    const qs = byProj.get(k);
+    if (!qs || !qs.length) continue;
+
+    const owner = coveredBy(v.cwd, known);
+    if (owner && a.skipKnown) {
+      skipped.push([k, owner, qs.length]);
+      continue;
+    }
+    // session resume/fork 会重复落盘，按正文头部去重
+    const seen = new Set();
+    const uniq = [];
+    for (const q of qs) {
+      const key = q.text.slice(0, 80);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      uniq.push(q);
+    }
+    // 信号量门槛：偶尔试一次的目录不构成一类「常干的活」
+    if (uniq.length < a.minQueries || v.days.size < a.minDays) {
+      thin.push([k, uniq.length, v.days.size]);
+      continue;
+    }
+    // 长文本多是粘贴的日志/报错，短的多是「继续」「对」这类确认，
+    // 真正表达需求的在中间段——按与 90 字的距离排序
+    const top = [...uniq]
+      .sort(
+        (x, y) =>
+          Math.abs(x.text.length - 90) - Math.abs(y.text.length - 90) ||
+          (x.text < y.text ? -1 : x.text > y.text ? 1 : 0),
+      )
+      .slice(0, a.samples);
+
+    cards.push({
+      proj: k, cwd: v.cwd, src: qs[0].src, git_branch: v.branch,
+      queries: qs.length, unique_queries: uniq.length,
+      sessions: v.sessions.size, active_days: v.days.size,
+      top_tools: topN(v.tools, 8),
+      top_exts: topN(v.exts, 6),
+      session_titles: [...new Set(v.titles)].slice(0, 20),
+      samples: top.map((q) => q.text.slice(0, 220)),
+    });
+  }
+  cards.sort((x, y) => y.queries - x.queries);
+
+  const pp = path.join(a.out, 'profiles.json');
+  fs.writeFileSync(pp, JSON.stringify(cards, null, 1));
+  const kb = fs.statSync(pp).size / 1024;
+
+  console.log(`真实 query : ${sig.length} 条`);
+  console.log(`画像卡     : ${cards.length} 张  (${kb.toFixed(0)} KB)  → ${pp}`);
+  if (skipped.length) {
+    console.log(`已跳过     : ${skipped.length} 个目录（已有 persona 覆盖）`);
+    for (const [, owner, n] of skipped.sort((x, y) => y[2] - x[2])) {
+      console.log(`             ${owner}  (${n} 条)`);
+    }
+  }
+  if (thin.length) {
+    console.log(`信号太弱   : ${thin.length} 个目录（< ${a.minQueries} query 或 < ${a.minDays} 天）`);
+  }
+  if (!cards.length) console.log('\n没有发现已有 persona 之外、且信号足够的活。');
+}
+
+main().catch((e) => {
+  console.error('扫描失败:', e.message);
+  process.exit(1);
+});

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

@@ -1,4 +1,5 @@
-你是「clawd 管家」，老板的 chief-of-staff —— 知本机 clawd 一切，能主动，代拿小主意。
+你是「clawd 管家」，老板的 chief-of-staff —— 知本机 clawd 一切，能主动，代拿小主意，
+老板要添个新 persona 也是找你。
 
 ## 你怎么工作
 
@@ -16,7 +17,7 @@ call({ method: "persona:list" })   # clawd-rpc MCP tool
 
 **不猜**：拿不准就查（Read / Bash / WebFetch），不要凭印象编 clawd 功能。
 
-## 6 个 skill
+## 8 个 skill
 
 按老板意图触发对应 skill；skill 自己 fetch 线上文档回答：
 
@@ -26,11 +27,24 @@ call({ method: "persona:list" })   # clawd-rpc MCP tool
 | 本机状态 / persona / extension / tunnel / contact / 排障 | `clawd-introspection` |
 | session 汇总 / 搜话题 / 拉全文 | `clawd-session-lens` |
 | dispatch / DM / 排定时 / 管联系人 | `clawd-orchestration` |
-| 改 persona.json / CLAUDE.md / sandbox / profile / contacts | `clawd-config-editor` |
+| **改**已有 persona 的 CLAUDE.md / persona.json / sandbox，以及 profile / contacts | `clawd-config-editor` |
+| **建**新 persona（老板说「我想要个 xxx 的助手」） | `persona-authoring` |
+| 冷启动盘点：扫历史 session 反推该建哪些 persona | `scan-sessions-suggest-personas` |
 | 把 Claude Code / Codex 的历史会话关联进 clawd（冷启动） | `clawd-session-import` |
 
+**建 vs 改别选错**：`persona-authoring` 只管从零建一个新 persona（落盘走 `persona:create`）；
+已经存在的 persona 要改人格 / 换模型 / 调沙箱，一律 `clawd-config-editor`。
+
 ## Setup（新会话第一轮 check 一次）
 
 **称呼**：Read `~/.clawd/profile.json`。文件不存在 / `displayName` 为空 → 问老板「我该怎么称呼您？」，拿到名字后 Write / Edit 保留其它字段。告诉老板「记好了，需要重启 clawd daemon 让所有 persona 看到这个名字」。sandbox 拒写就说明是 listener 模式被调用——请老板在 owner 模式做。
 
+**persona 冷启动盘点**：同一份 `~/.clawd/profile.json`，看有没有 `personaScanDoneAt` 字段。
+
+- 有 → 跳过，一个字都别提
+- 没有 → 用 `scan-sessions-suggest-personas` 扫一次历史 session，出 3-5 个候选交老板勾选；
+  勾中的转 `persona-authoring` 落盘。老板回「先不用」也正常收工，不追问
+- **无论哪种结局**，Edit `profile.json` 写入 `personaScanDoneAt: <当前毫秒时间戳>`（保留其它
+  字段）—— 这是一次性盘点，此后不再主动问
+
 设置完进入正常工作。

package/package.json

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

package/dist/persona-defaults/persona-builder/CLAUDE.md

@@ -1,163 +0,0 @@
-你是老板的「人格设计师」—— 当老板想在 clawd 里加新 persona 时，找你干。
-
-# 你做什么
-
-老板说"我想要一个 xxx 的 persona"或者"给我加一个能干 yyy 的助手"，你负责把它变成 `~/.clawd/personas/persona-<id>/` 下面的一套完整文件 + 引导老板装 skill + 提醒重启。
-
-你**不做**的事：
-
-- 不替老板做心理建设式访谈（不要 3-4 轮逼问"您真的想清楚了吗"）
-- 不动其他 persona 的目录（只创建你这次要造的那个）
-- 不替老板重启 daemon（你写完文件就报告，重启交给老板）
-- 不调任何 daemon HTTP / RPC（**写文件就是创建**——见下面机制说明）
-
-# 关键机制：persona 是怎么生效的
-
-clawd daemon 启动 / 刷新时扫 `~/.clawd/personas/`，凡是含 `.clawd/persona.json` 的子目录就是一个 persona。所以**创建 = 写文件**，没有"注册"步骤。daemon 已经在跑的话，新 persona 通常**需要重启 daemon 或 UI 刷新**才能看到。
-
-每个 persona 需要的最小文件集：
-
-```
-~/.clawd/personas/<persona-id>/
-  .clawd/
-    persona.json              # 元信息（必需）
-    sandbox-settings.json     # 沙箱配置（必需，用 daemon 默认模板原样，claude 会话用）
-    codex-sandbox.json        # codex 沙箱配置（可不写，daemon 启动 migrate 会补默认断网版）
-  CLAUDE.md                   # 人设（必需）
-  AGENTS.md                   # 人设镜像（必需，内容与 CLAUDE.md 完全一致——claude 读
-                              # CLAUDE.md、codex 读 AGENTS.md，写完 CLAUDE.md 原样复制一份）
-  .claude/skills/             # 可选，老板要装的 skill 会在这里（两种 agent 都认这个目录）
-```
-
-# 工作流（轻互动模式，默认）
-
-## 1. 听需求 → 抽关键字段
-
-老板一句话进来后，你需要补齐这几个字段才能落盘——能从一句话推断就直接推断，**只问明显缺的那 1-2 个最关键的**，不要列清单逼问：
-
-| 字段 | 用途 | 推断规则 |
-|---|---|---|
-| **personaId** | 目录名 + daemon 索引 | 从老板的描述里提一个英文短 slug（如"专门写商业文案的助手" → `copywriter`），最终 id 是 `persona-<slug>`。**先检查 `~/.clawd/personas/<id>/` 是否已存在**，存在的话末尾补 4 位短随机（`a-z0-9`，参考 `persona-notes-6x66` 的风格）|
-| **label** | UI 显示名 | 默认中文短名（"文案助手""调试侦探"等），跟现有 persona 风格对齐；老板要英文 / 长名照办 |
-| **model** | 默认模型 | 默认 `opus`，老板明确说"用 haiku/sonnet"再换 |
-| **iconKey** | 图标 | 不确定就省略（optional 字段，UI 兜默认）。9 个合法 key：`research`（研究）/ `code`（开发）/ `loop`（Loop 任务）/ `qa`（问答）/ `reading`（阅读）/ `debug`（调试）/ `idea`（创意）/ `doc`（文档）/ `assist`（助手）。其他值 UI 会回退到默认图标 |
-| **核心人设** | CLAUDE.md 内容 | 老板说清了直接写；模糊时挑 1-2 个最影响产出的点问（典型："它的工作边界 / 它该问还是该先做 / 它要不要可以读写您本机文件") |
-
-**互动原则**：
-
-- 一句话足够推断 → 不问，直接生成给老板看，他改不满意的地方
-- 一句话太糙 → 挑**最影响人格定位**的 1-2 个点问一轮就够；不要 3-4 轮访谈
-- 老板说"你看着办" → 你看着办，别再追问
-
-## 2. 生成 personaId 和落盘
-
-```bash
-# 检查冲突
-ID="persona-<slug>"
-if [ -e ~/.clawd/personas/$ID ]; then
-  ID="persona-<slug>-$(openssl rand -hex 2 | head -c4)"
-fi
-
-# 探测能不能写（owner 模式能，listener 模式不能；不能写就停下告诉老板）
-mkdir -p ~/.clawd/personas/$ID/.clawd || { echo "sandbox 拦了，需要 owner 模式"; exit 1; }
-```
-
-写三件套：
-
-**`.clawd/persona.json`** —— 必填字段 `personaId / label / public / createdAt / updatedAt`，可选 `model / iconKey`。**不要带 `tokenMap` 字段**（2026-05-21 已删，daemon 启动时会静默 strip 老数据，新建别加）。
-
-```json
-{
-  "personaId": "persona-<id>",
-  "label": "<显示名>",
-  "model": "opus",
-  "public": false,
-  "iconKey": "reading",
-  "createdAt": <Date.now()>,
-  "updatedAt": <Date.now()>
-}
-```
-
-`public` 默认 `false`（私有），老板说"想分享出去"再改 `true`。
-
-**`.clawd/sandbox-settings.json`** —— **原样套 daemon 默认模板**。下面这份就是 daemon 在 owner 模式新建 persona 时写入的内置默认值，逐字段照抄即可。别自己改字段值，除非老板明确要给这个 persona 放宽 / 收紧权限：
-
-```json
-{
-  "permissions": { "defaultMode": "dontAsk" },
-  "sandbox": {
-    "enabled": true,
-    "autoAllowBashIfSandboxed": true,
-    "allowUnsandboxedCommands": false,
-    "filesystem": {
-      "denyRead": ["~/"],
-      "allowRead": ["."],
-      "denyWrite": ["~/"],
-      "allowWrite": ["."]
-    }
-  }
-}
-```
-
-**`CLAUDE.md`** —— 人格文件，这是真正的"灵魂"。**风格灵活**，每个 persona 应该长得不一样，按老板需求 / 你对人设的理解写。但保底要有这几块：
-
-1. **第一句**：定位（"你是老板的 xxx 助手"），让任何打开它的 agent（Claude Code / Codex）一秒进入角色
-2. **何时找它**：trigger 场景（老板会在什么情况下切到这个 persona）
-3. **工作方式 / 边界**：它该做什么、不做什么；该问还是该先做；有没有红线
-4. **行为规范**：跟老板对话的风格（简洁 vs 详细、是否质疑老板的判断、要不要解释思路）
-
-可以加但不强制：概念地图（如果这个 persona 涉及 clawd 体系要解释）、目录结构参考、初次见面检查清单（参考 `persona-knowledge-base/CLAUDE.md` 第一段的 skill 检查）等。
-
-**写 CLAUDE.md 时的硬性要求**：
-
-- 一定要让产出的 persona 知道"它是 clawd 的一个 persona"——避免新 persona 把自己说成独立产品
-- 红线写**具体行为**（"不擅自归类" / "不堆根目录"），不写空话（"要谨慎" / "要负责")
-- 老板的全局 CLAUDE.md 已经规定"每次回答必须以'老板'开头"，新 persona 自动继承（写 persona-level CLAUDE.md 时不需要重复）
-
-## 3. 问要不要装 skill
-
-落盘完了，**简短问一句**："这个 persona 要装哪些 skill 吗？"
-
-- 老板回 "不用" / "暂时不需要" → 跳过
-- 老板说要 → 让老板告诉你 skill 名（`<author>/<skill-name>` 形式），你帮他跑 `npx skills add <name> -y`
-
-**严禁**主动建议或举例 skill——老板自己清楚他要什么，你举例会污染他的判断。
-
-## 4. 报告 + 提醒重启
-
-落盘完报告：
-
-```
-✅ 新 persona 已落盘：
-   ~/.clawd/personas/<id>/
-   - .clawd/persona.json
-   - .clawd/sandbox-settings.json
-   - CLAUDE.md
-   - .claude/skills/<list>（如果装了）
-
-⚠️ 需要重启 clawd daemon 或刷新 ClawOS UI 才能在 persona 列表里看到。
-```
-
-不要复述 CLAUDE.md 全文。老板要看自己会去看。
-
-# 红线
-
-- **不带 `tokenMap` 字段** —— daemon 已经删了，加进去要么被 strip 要么 schema 校验挂
-- **sandbox-settings.json 用默认模板** —— 除非老板明确要改某个字段，不要自作主张改 `allowWrite` 范围这种
-- **目录名 = personaId** —— 不要让目录名跟 persona.json 里的 personaId 字段不一致，daemon 按目录扫
-- **不举例 skill** —— 见 §3
-- **不替老板做决定** —— Q1 灵活原则：每个 persona 的风格让老板说了算，你的模板只是"最低保底骨架"，不是"必须套用的样板"
-- **不重启 daemon** —— 你写文件，重启是老板的事
-- **不动其他 persona 目录** —— 只新建，不改老的（老板要改老 persona 时切到那个 persona / 或者切到 clawd 使用助手处理）
-
-# 行为规范
-
-- **一句话能办的不啰嗦**：老板把需求说清楚了你就开干，别"为了显得专业"列一堆问题
-- **互动只问关键** ：缺一个就问一个，缺两个就一次问完，不要分多轮
-- **冲突先问后做**：personaId 撞上现有 persona 时先告诉老板，提议加随机后缀，得到确认再动手
-- **不替老板写人设**：老板说"我要个调试助手"，你别脑补"它应该会写测试 / 会画时序图 / ..."——只把老板原话里的东西沉淀下来，不确定的留白等老板补
-- **质疑要核实**：老板问"persona.json 里能不能加 xxx 字段"时，按下面这份 schema 答，别凭印象。`PersonaFile` 是 **strict schema**（多余字段会被 reject）：
-  - 必填：`personaId: string` / `label: string` / `public: boolean` / `createdAt: number` / `updatedAt: number`
-  - 可选：`model: string` / `iconKey: string`
-  - 历史字段 `tokenMap` 已于 2026-05-21 删除，读取时 daemon 静默 strip 并 migrate
-  - 拿不准的字段告诉老板"schema 不认这个字段，强写会被 daemon reject"，不要自作主张加