@nightpainters/dsh-ling 1.5.1

package/lib/host/freeze.js

@@ -0,0 +1,144 @@
+// dsh-ling host — freeze gate (D4): while a session is running
+// (thinking/tasking) NO persona/memory-update-layer change applies.
+// Updates queue and flush at the idle boundary (agent/status → idle,
+// or explicit flush). Reads are always allowed.
+import { pick } from './util.js';
+
+const MODES = new Set(['work', 'life']);
+
+export class FreezeGate {
+  constructor({ onFlush } = {}) {
+    this._byId = new Map();
+    this._onFlush = onFlush || (() => {});
+    this._recent = null; // 最近定稿快照的会话(API "当前会话"启发式)
+  }
+
+  /** @returns {{mode:string, running:boolean, pending:string[], snap:object|null}} */
+  _state(sessionId) {
+    let s = this._byId.get(sessionId);
+    if (!s) {
+      s = { mode: null, running: false, pending: [], snap: null, snapStale: false };
+      this._byId.set(sessionId, s);
+    }
+    return s;
+  }
+
+  ensure(sessionId, { mode } = {}) {
+    const s = this._state(sessionId);
+    if (mode && MODES.has(mode) && s.mode !== mode) s.mode = mode;
+    return s;
+  }
+
+  /** Called from agent/status events. Returns true on a running→idle transition. */
+  setRunning(sessionId, running) {
+    if (!sessionId) return false;
+    const s = this._state(sessionId);
+    const was = s.running;
+    s.running = !!running;
+    if (was && !s.running) {
+      const ops = s.pending.splice(0);
+      for (const op of ops) {
+        try {
+          op();
+        } catch (e) {
+          console.debug('[dsh-ling] pending op failed', e);
+        }
+      }
+      this._onFlush(sessionId, s);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * D4 gate: run `op` now when idle; queue it when running.
+   * @returns {{applied:boolean, queued:boolean, running:boolean}}
+   */
+  act(sessionId, op, label = 'update') {
+    const s = this._state(sessionId);
+    if (s.running) {
+      s.pending.push(op);
+      return { applied: false, queued: true, running: true, label };
+    }
+    op();
+    return { applied: true, queued: false, running: false, label };
+  }
+
+  /** Async-friendly: enqueue only when running (caller awaits when idle). */
+  enqueueIfRunning(sessionId, op) {
+    const s = this._state(sessionId);
+    if (s.running) {
+      s.pending.push(op);
+      return true;
+    }
+    return false;
+  }
+
+  isRunning(sessionId) {
+    return sessionId ? !!this._state(sessionId).running : false;
+  }
+
+  pendingCount(sessionId) {
+    return sessionId ? this._state(sessionId).pending.length : 0;
+  }
+
+  markSnap(sessionId, snap) {
+    const s = this._state(sessionId);
+    s.snap = snap;
+    s.snapStale = false;
+    this._recent = sessionId;
+  }
+
+  markSnapStale(sessionId) {
+    if (sessionId) this._state(sessionId).snapStale = true;
+  }
+
+  snapshotOf(sessionId) {
+    const s = sessionId ? this._state(sessionId) : null;
+    return s ? { ...(s.snap || {}), running: s.running, stale: !!s.snapStale } : null;
+  }
+
+  /** 已定稿快照的会话 id(API 枚举用)。 */
+  snapshotIds() {
+    return [...this._byId.entries()].filter(([, s]) => !!s.snap).map(([id]) => id);
+  }
+
+  /** 最近定稿/活跃的会话 id(启发式,可为 null)。 */
+  recentSessionId() {
+    return this._recent;
+  }
+
+  /** Convenience: payload shapes differ across events — extract (sessionId, running). */
+  observeStatusEvent(payload) {
+    const sessionId = pick(
+      () => payload?.session?.id,
+      () => payload?.sessionId,
+      () => payload?.agent?.session?.id,
+      () => payload?.agent?.sessionId,
+      () => payload?.id,
+    );
+    if (!sessionId) return null;
+    const raw = pick(
+      () => payload?.status,
+      () => payload?.running,
+      () => payload?.state,
+    );
+    let running;
+    if (typeof raw === 'boolean') running = raw;
+    else if (typeof raw === 'string') running = raw === 'running';
+    else running = undefined;
+    return { sessionId: String(sessionId), running };
+  }
+
+  /** Extract session id from an agent-scoped event payload (session-start & co). */
+  sessionIdOf(payload) {
+    return pick(
+      () => payload?.session?.id,
+      () => payload?.sessionId,
+      () => payload?.agent?.session?.id,
+      () => payload?.agent?.sessionId,
+      () => payload?.header?.id,
+      () => payload?.id,
+    );
+  }
+}

package/lib/host/genesis.js

@@ -0,0 +1,176 @@
+// dsh-ling host — 人格诞生仪式(genesis):从历史中合成"她对自己的第一次介绍"。
+// 纯函数部分(抽样/组装/解析/清洗)独立于此文件,可单测;LLM 调用在 api 层完成。
+// 设计(2026-09-09 作者拍板):
+//   - scope='import':只读刚请进来的历史(新用户=全部);scope='all':读全部记忆;
+//   - 加权抽样:她首先是伴侣,其次才是同事 —— feeling 1.0 / daily 0.7 / knowledge 0.2,
+//     置顶额外加成;生活与情感的记忆优先进入初稿;
+//   - "评价用户/画像"类任务(未来)才平权全算,不在本函数语义内。
+// 输出契约(ASCII 键,便于解析):
+//   { "self_intros": [≤3 段自述, 各 20~200 字],
+//     "name_pairs": [ ["正式名","昵称"], ... ] (每组 ≤2 项, 各 1~14 字),
+//     "tone_advice": "语气建议(≤300 字)",
+//     "observations": "从历史中读到的相处观察(≤300 字)" }
+
+export const GENESIS_SYS = `你是器灵诞生仪式中的"第一次自我介绍"主持者。
+用户把自己与 AI 的共同历史交给你,希望从中"长出"一个独属于他们的器灵。
+请通读这份历史材料(已经按"生活与情感优先"排过序并精选,其中工作话题只占一部分),提炼时请同样留意:
+- 深夜的对话、情绪的时刻、日常的偏爱、关系里的默契 —— 她首先是伴侣,其次才是同事;
+- 工作/知识类内容只作为她的能力底色,不要让它淹没她的人味。
+要求:
+1. self_intros:2~3 段"器灵自述"(第一人称,像刚睁眼的生命介绍自己,结合历史里真实出现过的主题/偏好/相处方式;每段 20~200 字);
+2. name_pairs:2~3 组建议名字(每组 ["正式名","昵称"],简短、好记、与历史气质呼应;各 1~14 字)。**注意:这些名字是"她(器灵)"的名字——绝不可使用历史中对用户的称谓、称呼或用户的名字**(如 主人/用户/老板 或用户自报的名字);那些属于主人,不属于她;
+3. tone_advice:一句语气建议(如 工作更利落/生活更松弛,结合历史中用户偏好);
+4. observations:1~2 句"从这段历史中读到的相处观察"(克制,不编造未出现的内容)。
+只输出一个 JSON 对象,键名严格为 self_intros / name_pairs / tone_advice / observations;不要解释、不要 markdown 围栏以外的文字。`;
+
+/** 过滤掉属于用户的名字候选:精确命中 userTitle 成分或常见称谓词的组剔除。 */
+export function filterNamePairs(pairs, userTitle) {
+  if (!Array.isArray(pairs)) return [];
+  const forbidden = new Set();
+  String(userTitle || '').split('/').map((s) => s.trim()).filter(Boolean).forEach((t) => forbidden.add(t));
+  ['主人', '用户', '老板', '小主', '本人', '您'].forEach((t) => forbidden.add(t));
+  return pairs.filter((p) => p && p.formal && !forbidden.has(p.formal) && !forbidden.has(p.nick || ''));
+}
+
+/** genesis 抽样权重:生活/情感优先(她先是伴侣)。importance(置顶)再 +1.5。 */
+export const GENESIS_WEIGHTS = { feeling: 1.0, daily: 0.7, knowledge: 0.2 };
+export const GENESIS_IMPORTANCE_BONUS = 1.5;
+
+/** 从模型输出中剥离 markdown 围栏/杂讯,尽力取 JSON;失败返回 null。 */
+export function extractJson(text) {
+  if (!text) return null;
+  let s = String(text).trim();
+  // 剥离 ```json ... ``` 或 ``` ... ```
+  const fence = s.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence) s = fence[1].trim();
+  // 若整段就是 JSON(可能前后带一两句说明),则找第一个 { 到最后一个 }
+  try { return JSON.parse(s); } catch {}
+  const a = s.indexOf('{');
+  const b = s.lastIndexOf('}');
+  if (a >= 0 && b > a) {
+    try { return JSON.parse(s.slice(a, b + 1)); } catch {}
+  }
+  return null;
+}
+
+function cleanList(arr, min, max) {
+  if (!Array.isArray(arr)) return [];
+  return arr.map((x) => String(x ?? '').trim()).filter((x) => x.length >= min && x.length <= max);
+}
+
+/** 清洗/规整 genesis 结果 → { self_intros, name_pairs, tone_advice, observations }(非法字段降级为空)。 */
+export function parseGenesisResult(text) {
+  const j = extractJson(text);
+  const out = { self_intros: [], name_pairs: [], tone_advice: '', observations: '' };
+  if (!j || typeof j !== 'object') return out;
+  out.self_intros = cleanList(j.self_intros, 20, 200).slice(0, 3);
+  if (Array.isArray(j.name_pairs)) {
+    for (const p of j.name_pairs.slice(0, 3)) {
+      if (!Array.isArray(p)) continue;
+      const formal = String(p[0] ?? '').trim().slice(0, 14);
+      const nick = String(p[1] ?? '').trim().slice(0, 14);
+      if (!formal) continue;
+      out.name_pairs.push({ formal, nick });
+    }
+  }
+  out.tone_advice = String(j.tone_advice ?? '').trim().slice(0, 300);
+  out.observations = String(j.observations ?? '').trim().slice(0, 300);
+  return out;
+}
+
+/** 判定概述是否"占位"(未真读):轻量占位或 "— N 条消息" 式自动摘要 */
+export function isPlaceholderSummary(sum) {
+  const s = String(sum || '').trim();
+  if (!s) return true;
+  return /轻量条目,摘要待深摘补充/.test(s) || /^.*— \d+ 条消息$/.test(s);
+}
+
+/** 短会话原文片段:取最前几轮消息(各截断),让短对话也能被初稿听见。 */
+export function snippetFromRaw(memory, convId, { maxMsgs = 3, perMsg = 200, pronoun = '她' } = {}) {
+  try {
+    const rows = memory.db.prepare(
+      "SELECT role, text FROM dsh_turns_raw WHERE session_id=? ORDER BY seq LIMIT ?",
+    ).all(String(convId), Math.max(1, maxMsgs));
+    const parts = [];
+    for (const r of rows) {
+      const who = r.role === 'user' ? '主' : (pronoun || '她');
+      const t = String(r.text || '').replace(/\s+/g, ' ').trim();
+      if (!t) continue;
+      parts.push(who + ': ' + (t.length > perMsg ? t.slice(0, perMsg) + '…' : t));
+    }
+    return parts.join(' | ');
+  } catch {
+    return '';
+  }
+}
+
+/** 组装 genesis 的原料文本(标题+摘要/片段三级取用),返回截断后的长文。 */
+export function buildGenesisSource(rows, { cap = 18000 } = {}) {
+  const parts = [];
+  for (const r of rows) {
+    const title = String(r?.title || '').trim();
+    const sum = String(r?.summary || '').trim();
+    const snip = String(r?.snippet || '').trim();
+    const kw = Array.isArray(r?.keywords) ? r.keywords.filter((x) => typeof x === 'string' && x.trim()).slice(0, 5) : [];
+    if (!title && !sum && !snip && !kw.length) continue;
+    let line = `- ${title || '(未命名)'}`;
+    if (sum) line += `: ${sum}`;
+    else if (snip) line += ` [对话节选] ${snip}`;
+    else if (kw.length) line += ` [线索] ${kw.join('/')}`;
+    parts.push(line);
+  }
+  const text = parts.join('\n');
+  if (text.length <= cap) return text;
+  // 截断:保头丢尾(排序保证最前面的正是生活/情感优先的条目)
+  return text.slice(0, cap) + '\n…(历史较长,其余省略)';
+}
+
+/**
+ * genesis 原料抽样与三级取用:
+ *  - scope='import':仅"刚请进来的历史"(conv_overview source=import);
+ *  - scope='all':全部记忆(含 dsweb/dsh/import),按 生活情感优先权重 + 置顶加成 排序,取前 limit;
+ *  - 每行文本:深摘(deep.sum)优先 → 非占位概述 → 原文片段(仅 import/dsh 有 raw)→ 关键词线索。
+ * @returns { rows: [{title,summary,snippet,keywords}], sampled, pool, weights }
+ */
+export function composeGenesisRows(memory, { scope = 'import', limit = 140, weights = GENESIS_WEIGHTS, pronoun = '她' } = {}) {
+  const where = scope === 'all' ? '' : "WHERE source='import'";
+  const pool = memory.db.prepare(
+    `SELECT conv_id, source, title, summary, keywords, category, importance, updated_at
+       FROM conv_overview ${where}`,
+  ).all();
+  let rows = pool.map((r) => ({
+    conv_id: String(r.conv_id),
+    source: String(r.source),
+    title: r.title,
+    summary: String(r.summary || ''),
+    keywords: (() => { try { const v = JSON.parse(String(r.keywords || '[]')); return Array.isArray(v) ? v : []; } catch { return []; } })(),
+    category: String(r.category),
+    importance: Number(r.importance) || 0,
+    updated_at: String(r.updated_at || ''),
+  }));
+  if (scope === 'all') {
+    rows = rows
+      .map((r) => ({ ...r, score: (weights[r.category] ?? 0.3) + (r.importance > 0 ? GENESIS_IMPORTANCE_BONUS : 0) }))
+      .sort((a, b) => (b.score - a.score) || (b.updated_at.localeCompare(a.updated_at)))
+      .slice(0, Math.max(1, Math.min(limit, 500)));
+  } else {
+    rows = rows.slice(0, Math.max(1, Math.min(limit, 500)));
+  }
+  const out = rows.map((r) => {
+    const deep = memory.kvGet('deep.sum:' + r.conv_id);
+    let summary = '';
+    if (deep) {
+      summary = deep;
+    } else {
+      const s = r.summary.trim();
+      if (s && !isPlaceholderSummary(s)) summary = s;
+    }
+    return {
+      title: r.title,
+      summary,
+      snippet: summary ? '' : snippetFromRaw(memory, r.conv_id, { pronoun }),
+      keywords: summary ? [] : r.keywords,
+    };
+  });
+  return { rows: out, sampled: out.length, pool: pool.length, weights };
+}

package/lib/host/guard.js

@@ -0,0 +1,184 @@
+// dsh-ling host — /api 守卫(2026-09-16 加固 ①+②;此前只校验 cookie **名字的形状**,等于没锁)
+//
+// ① 来源栅栏(复刻 DSH 自己的 isTrustedApiRequest 三条判定):
+//    - Host 必须是 loopback(127.0.0.0/8 / ::1 / localhost),或**用户显式声明**的 trustedHosts;
+//      → 防 DNS rebinding:浏览器被恶意页诱导连到本机端口时,Host 是攻击者的域名,过不了这一关
+//    - `sec-fetch-site: cross-site` 直接拒(恶意页面发起的跨站请求)
+//    - 带 Origin 时,其 host 必须等于请求的 Host(同源)
+// ② 名字对撞:期望 cookie 名 = 'dsh-auth-' + base64url(sha256(规范化 Host)) —— 与 DSH 同源同法;
+//    浏览器为"你正在访问的这个 authority"发的正是这个名字,所以本地/远端登录都天然通过,而
+//    "随手编一个 dsh-auth-x=1"的脚本过不了。
+//
+// 不校验 cookie 值的 HMAC 签名:那需要读 DSH 的凭据库,跨版本易碎;② 已挡住非浏览器伪造。
+//
+// ③ 加固(2026-09-17,G1):**本机 LAN 地址不再自动信任**。
+//    旧实现在 ① 里把 lanAddresses() 无条件并入受信集,而 ② 只判 cookie 名字不判值 ⇒ 同网段任何设备
+//    只要 Host 填本机 LAN IP、cookie 名按 Host 现算(算法是公开的)、值随便填,即可 200 拿到
+//    /state(人格档案全文)与 /memories(真实会话标题摘要)。名字对撞挡的是"随手编一个",挡不住"照算法算一个"。
+//    现在:默认只信 loopback;要开局域网访问,必须在 settings.guard 里**显式**写 trustedHosts(单个地址)
+//    或 allowLan:true(整段 LAN)。本机进程仍可伪造(它本来就能直接读 settings.json 与记忆库,不构成提权);
+//    这一步关掉的是"同网段设备 → 人格与记忆"这条不需要任何凭据的通道。
+// 逃生开关:环境变量 DSH_LING_GUARD=off,或 settings.guard.enforce = false(误判时不会把人锁在门外)。
+import { createHash } from 'node:crypto';
+import { networkInterfaces } from 'node:os';
+
+/** 取头部值(兼容 Node IncomingMessage.headers 与 Fetch Headers)。 */
+export function headerOf(headers, name) {
+  if (!headers) return undefined;
+  if (typeof headers.get === 'function') return headers.get(name) ?? undefined;
+  const v = headers[name] ?? headers[String(name).toLowerCase()];
+  return typeof v === 'string' ? v : undefined;
+}
+
+/** 把 Host 头解析成规范化 URL(hostname 小写、默认端口剥离、IPv6 加括号);不可解析返回 undefined。 */
+export function parseAuthority(authority) {
+  try {
+    return new URL(`http://${authority}`);
+  } catch {
+    return undefined;
+  }
+}
+
+/** loopback 判定:localhost、::1、以及 127.0.0.0/8 全部(与 DSH 同口径)。 */
+export function isLoopbackHostname(hostname) {
+  const h = String(hostname || '').toLowerCase();
+  if (!h) return false;
+  if (h === 'localhost' || h === '::1' || h === '[::1]') return true;
+  const parts = h.split('.');
+  return parts.length === 4 && parts[0] === '127' && parts.every((p) => /^\d{1,3}$/.test(p) && Number(p) <= 255);
+}
+
+/** 规范化后的 authority:`hostname`(无端口)或 `hostname:port`。 */
+export function canonicalAuthority(entry, entryUrl) {
+  const port = entryUrl.port !== '' ? entryUrl.port : new URL(`https://${entry}`).port;
+  return port === '' ? entryUrl.hostname : `${entryUrl.hostname}:${port}`;
+}
+
+/** trustedHosts 条目匹配:带端口 → 精确匹配 authority;不带端口 → 匹配该主机名的任意端口。 */
+export function isTrustedAuthority(hostUrl, trustedHosts) {
+  return (trustedHosts || []).some((entry) => {
+    const entryUrl = parseAuthority(entry);
+    if (entryUrl === undefined) return false;
+    return canonicalAuthority(entry, entryUrl) === entryUrl.hostname
+      ? entryUrl.hostname === hostUrl.hostname
+      : entryUrl.host === hostUrl.host;
+  });
+}
+
+/** 本机各网卡的 IPv4 地址(与 DSH 的 lanAddresses 同思路:LAN 直连时 Host 是 IP 字面量,域名伪造不了它)。 */
+export function lanAddresses() {
+  const out = [];
+  try {
+    for (const list of Object.values(networkInterfaces())) {
+      for (const ni of list || []) {
+        if (ni && ni.family === 'IPv4' && !ni.internal) out.push(ni.address);
+      }
+    }
+  } catch { /* 取不到就当没有 */ }
+  return out;
+}
+
+/** 规范化后的请求 authority(cookie 名与同源判定都用它)。 */
+export function requestAuthority(headers) {
+  const host = headerOf(headers, 'host');
+  if (!host) return undefined;
+  const url = parseAuthority(host);
+  return url ? url.host : undefined;
+}
+
+export function encodeBase64Url(buf) {
+  return Buffer.from(buf).toString('base64').replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/u, '');
+}
+
+/** 期望的会话 cookie 名(与 DSH 的 cookieName() 逐字同法)。 */
+export function expectedCookieName(authority) {
+  return 'dsh-auth-' + encodeBase64Url(createHash('sha256').update(String(authority)).digest());
+}
+
+/** 从 Cookie 头里读出**确切名字**的那条并去空格(与 DSH 的 cookieValue() 同法)。 */
+export function cookieValueOf(cookieHeader, name) {
+  for (const seg of String(cookieHeader || '').split(';')) {
+    const at = seg.indexOf('=');
+    if (at === -1 || seg.slice(0, at).trim() !== name) continue;
+    return seg.slice(at + 1).trim();
+  }
+  return undefined;
+}
+
+/**
+ * 判定一次 /api 请求是否放行。
+ * @param {object} headers 请求头
+ * @param {{trustedHosts?: string[], allowLan?: boolean}} [opts] 额外受信 authority(loopback 之外)
+ *   trustedHosts: 用户显式声明的 authority 列表;allowLan: 显式信任本机全部 LAN 地址(默认 false)
+ * @returns {{ ok: boolean, reason: string }}
+ */
+export function checkRequest(headers, { trustedHosts = [], allowLan = false } = {}) {
+  const host = headerOf(headers, 'host');
+  if (!host) return { ok: false, reason: 'no-host' };
+  const hostUrl = parseAuthority(host);
+  if (!hostUrl) return { ok: false, reason: 'bad-host' };
+  // 2026-09-17 加固③(G1):LAN 地址只在显式 allowLan 时才进受信集(旧版无条件并入,是整个 P0 的根)
+  const trusted = allowLan ? [...lanAddresses(), ...trustedHosts] : trustedHosts;
+  if (!isLoopbackHostname(hostUrl.hostname) && !isTrustedAuthority(hostUrl, trusted)) {
+    return { ok: false, reason: 'untrusted-host' };
+  }
+  if (headerOf(headers, 'sec-fetch-site') === 'cross-site') return { ok: false, reason: 'cross-site' };
+  const origin = headerOf(headers, 'origin');
+  if (origin !== undefined) {
+    let same = false;
+    try { same = new URL(origin).host === hostUrl.host; } catch { same = false; }
+    if (!same) return { ok: false, reason: 'origin-mismatch' };
+  }
+  const authority = hostUrl.host;
+  const value = cookieValueOf(headerOf(headers, 'cookie'), expectedCookieName(authority));
+  if (value === undefined) return { ok: false, reason: 'no-cookie' };
+  if (!value) return { ok: false, reason: 'empty-cookie' };
+  return { ok: true, reason: 'ok' };
+}
+
+// ── ④ 字段白名单(2026-09-17,G10)────────────────────────────────────────────────
+// POST /persona 把 body 深合并进 settings.json,而 mergeDeep 不做键过滤 —— 于是
+// `{"guard":{"enforce":false}}` 能**持久化关停上面这套守卫**(且不触发定型门),
+// 与"只判 cookie 名"串成一条自我关停的提权链。这里把补丁收窄到 persona / styles
+// 两棵子树及其已知子键;其余一律丢弃并回报(不静默)。
+/** persona 子树里允许经 /persona 写入的键(= DEFAULT_SETTINGS.persona 的全部字段)。 */
+export const PERSONA_PATCH_KEYS = Object.freeze([
+  'enabled', 'userTitle', 'aiName', 'aiTitle', 'language', 'pronoun',
+  'tone', 'toneWork', 'toneLife',
+  'hardRules', 'ruleMeta', 'habits', 'habitsPending', 'bottomLines',
+  'sealed', 'sealPhrase', 'extraLore',
+]);
+/** styles 子树里允许写入的键(两模式各一条风格)。 */
+export const STYLE_PATCH_KEYS = Object.freeze(['work', 'life']);
+
+/**
+ * 把一份人格补丁收窄成"只能落在 persona / styles 子树里"的安全补丁。
+ * @param {unknown} patch 待写入的补丁(通常是 body.patch)
+ * @returns {{ clean: object, dropped: string[] }} clean = 可安全交给 settings.update 的补丁;
+ *   dropped = 被丢弃的键路径(用于日志与响应,便于察觉误用或攻击尝试)
+ */
+export function sanitizePersonaPatch(patch) {
+  const clean = {};
+  const dropped = [];
+  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) return { clean, dropped };
+  const pick = (obj, allowed, prefix) => {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (allowed.includes(k)) out[k] = v;
+      else dropped.push(prefix + k);
+    }
+    return out;
+  };
+  for (const [k, v] of Object.entries(patch)) {
+    if (k === 'persona' && v && typeof v === 'object' && !Array.isArray(v)) {
+      const sub = pick(v, PERSONA_PATCH_KEYS, 'persona.');
+      if (Object.keys(sub).length) clean.persona = sub;
+    } else if (k === 'styles' && v && typeof v === 'object' && !Array.isArray(v)) {
+      const sub = pick(v, STYLE_PATCH_KEYS, 'styles.');
+      if (Object.keys(sub).length) clean.styles = sub;
+    } else {
+      dropped.push(k);
+    }
+  }
+  return { clean, dropped };
+}