dsh-selfnote 0.13.3 → 0.14.0

package/lib/persona-tx.js

@@ -0,0 +1,308 @@
+/**
+ * 保存人格的那一次跨文件写入（persona.md + corrections.jsonl + persona.evidence.json）。
+ *
+ * 为什么不能各写各的：persona 写成功、进程被杀、证据还没标 used ——
+ * 下次启动规则已经生效，证据却还挂在「未处理」里，人会以为自己没采纳过。
+ * 所以先落一份日志，日志里写的是**目标状态**（新 persona 的摘要 + 证据文件写完之后应该长什么样），
+ * 恢复时只是「把文件写成目标状态」，重放多少次结果都一样。
+ */
+import { createHash, randomBytes } from 'node:crypto'
+import { closeSync, existsSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync } from 'node:fs'
+import { join } from 'node:path'
+import { selfnoteRoot } from './store.js'
+import { writeAtomic, writeJsonAtomic } from './atomic.js'
+import { validatePersona, renderPersona, personaPath } from './persona.js'
+import { findById, markUsed } from './corrections.js'
+
+/** 指纹算法的版本名：换算法就让旧记录失效，而不是悄悄算出另一批指纹。 */
+export const RULE_ALGO = 'nfkc-wp1'
+
+const TX_PATH = join(selfnoteRoot(), 'persona.pending.json')
+const EVIDENCE_PATH = join(selfnoteRoot(), 'persona.evidence.json')
+const LOCK_PATH = join(selfnoteRoot(), 'persona.lock')
+
+export class LockedError extends Error {
+  constructor(message = '另一次人格保存正在进行，稍后再试') {
+    super(message)
+    this.code = 'locked'
+  }
+}
+
+/** 规则正文的规范化：全角折半角、去空白、去标点、小写 —— 措辞没变就不该算成两条规则。 */
+export function normalizeRule(text) {
+  return String(text ?? '')
+    .normalize('NFKC')
+    .replace(/[\p{P}\p{Z}\s]/gu, '')
+    .toLowerCase()
+}
+
+export function ruleFingerprint(text) {
+  return createHash('sha1').update(`${RULE_ALGO}|${normalizeRule(text)}`, 'utf8').digest('hex').slice(0, 16)
+}
+
+export function readEvidence() {
+  if (!existsSync(EVIDENCE_PATH)) return { v: 1, algo: RULE_ALGO, rules: {} }
+  try {
+    const parsed = JSON.parse(readFileSync(EVIDENCE_PATH, 'utf8'))
+    const rules = parsed !== null && typeof parsed.rules === 'object' && parsed.rules !== null ? parsed.rules : {}
+    // 换了算法（RULE_ALGO）就等于换了一把尺子：旧指纹对新规则一文不值，宁可当空账重来
+    if (String(parsed.algo ?? RULE_ALGO) !== RULE_ALGO) return { v: 1, algo: RULE_ALGO, rules: {} }
+    return { v: 1, algo: RULE_ALGO, rules }
+  } catch {
+    return { v: 1, algo: RULE_ALGO, rules: {} }
+  }
+}
+
+export function writeEvidenceAfter(evidence) {
+  writeJsonAtomic(EVIDENCE_PATH, evidence)
+}
+
+/**
+ * 由 base 算出「写完之后应该是什么样」。纯函数：同样的 base 算多少次都一样，
+ * 恢复时直接拿日志里的快照覆盖，不需要再算一遍（也就不会因为重算而多计一次）。
+ */
+export function buildEvidenceAfter(base, rules, now) {
+  const next = { v: 1, algo: RULE_ALGO, rules: { ...(base?.rules ?? {}) } }
+  for (const text of rules) {
+    const body = String(text ?? '').trim()
+    if (body === '') continue
+    const fp = ruleFingerprint(body)
+    const old = next.rules[fp]
+    next.rules[fp] = old
+      ? { count: Number(old.count ?? 0) + 1, firstAt: String(old.firstAt ?? now), lastAt: now }
+      : { count: 1, firstAt: now, lastAt: now }
+  }
+  return next
+}
+
+/** 进程内单飞：保存人格、消费证据、恢复，全排一条队 —— 交叉跑必然半新半旧。 */
+let chain = Promise.resolve()
+export function runSerial(job) {
+  const run = chain.then(job, job)
+  chain = run.then(
+    () => undefined,
+    () => undefined,
+  )
+  return run
+}
+
+/** 锁最长活多久：超过这个岁数又探不到活进程，就当是上次被任务管理器杀掉留下的。 */
+const STALE_LOCK_MS = 10 * 60 * 1000
+
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    // EPERM = 进程活着，只是不是我们能管的
+    return error?.code === 'EPERM'
+  }
+}
+
+/** 锁里记的是 pid：进程已经没了（或者锁老得离谱）就清掉，否则用户只能手动删文件。 */
+export function lockState(now = Date.now()) {
+  if (!existsSync(LOCK_PATH)) return { exists: false, stale: false, pid: 0, ageMs: 0 }
+  let pid = 0
+  let ageMs = 0
+  try {
+    pid = Number(readFileSync(LOCK_PATH, 'utf8').trim())
+    ageMs = now - statSync(LOCK_PATH).mtimeMs
+  } catch {
+    return { exists: true, stale: true, pid: 0, ageMs: 0 }
+  }
+  const stale = !pidAlive(pid) || !Number.isFinite(ageMs) || ageMs > STALE_LOCK_MS
+  return { exists: true, stale, pid: Number.isInteger(pid) ? pid : 0, ageMs }
+}
+
+function clearStaleLock() {
+  const state = lockState()
+  if (!state.exists || !state.stale) return false
+  try {
+    unlinkSync(LOCK_PATH)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** 跨进程互斥：O_EXCL 建锁，拿不到就是「有人正在保存」，直接报错而不是排队等死。 */
+export async function withPersonaLock(job) {
+  let fd
+  try {
+    fd = openSync(LOCK_PATH, 'wx')
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error
+    // 上次被强杀的残留锁：清掉再试一次，否则「保存人格」会永久 409
+    if (!clearStaleLock()) throw new LockedError()
+    try {
+      fd = openSync(LOCK_PATH, 'wx')
+    } catch (retryError) {
+      if (retryError?.code === 'EEXIST') throw new LockedError()
+      throw retryError
+    }
+  }
+  try {
+    try {
+      writeSync(fd, String(process.pid))
+    } catch {
+      // 写不进去不影响互斥本身
+    }
+  } finally {
+    closeSync(fd)
+  }
+  try {
+    return await job()
+  } finally {
+    try {
+      unlinkSync(LOCK_PATH)
+    } catch {
+      // 已经被恢复流程清掉了
+    }
+  }
+}
+
+function readTxRaw() {
+  if (!existsSync(TX_PATH)) return { kind: 'missing' }
+  try {
+    const parsed = JSON.parse(readFileSync(TX_PATH, 'utf8'))
+    if (parsed === null || typeof parsed !== 'object' || typeof parsed.txId !== 'string') return { kind: 'bad' }
+    return { kind: 'ok', tx: parsed }
+  } catch {
+    return { kind: 'bad' }
+  }
+}
+
+export function readTx() {
+  const raw = readTxRaw()
+  return raw.kind === 'ok' ? raw.tx : null
+}
+
+export function beginTx(tx) {
+  // 已有未结日志时绝不覆盖：盖掉就等于把上一次的 evidenceAfter 永久蒸发，
+  // 而那条证据的 consumedBy 已经指向旧 txId —— 计数再也补不回来，doctor 也看不到。
+  if (existsSync(TX_PATH)) throw new PendingTxError()
+  writeJsonAtomic(TX_PATH, tx)
+}
+
+export class PendingTxError extends Error {
+  constructor(message = '上一次人格保存还没结清（有未完成的事务日志）') {
+    super(message)
+    this.code = 'pending'
+  }
+}
+
+export function clearTx() {
+  try {
+    unlinkSync(TX_PATH)
+  } catch {
+    // 本来就没有
+  }
+}
+
+export function sha256OfCurrentPersona() {
+  const text = existsSync(personaPath()) ? readFileSync(personaPath(), 'utf8') : ''
+  return createHash('sha256').update(text, 'utf8').digest('hex')
+}
+
+const MAX_UNUSED_DAYS = 90
+
+/**
+ * 保存人格：校验 → 写日志 → 写 persona → 消费证据 + 写证据快照 → 删日志。
+ * 第 4 步出错时 persona 已经生效了，所以只能报 pending（200），
+ * 让恢复流程下次启动把它补完 —— 谎报「保存失败」会让人以为规则没生效。
+ */
+export async function commitPersona({ l0 = '', l1 = '', l2 = '', consume = [] } = {}) {
+  return runSerial(async () => {
+    let locked = false
+    try {
+      return await withPersonaLock(async () => {
+        // 上一次崩在半路的事务必须先结清，否则 beginTx 会把它盖掉
+        const pending = recover()
+        const verdict = validatePersona({ l0, l1, l2 })
+        if (!verdict.ok) return { ok: false, code: verdict.code, error: verdict.error }
+
+        const ids = consume.map((id) => String(id))
+        const seen = new Set()
+        for (const id of ids) {
+          if (seen.has(id)) return { ok: false, code: 'validation', error: `证据 ${id} 重复出现在同一次提交里` }
+          seen.add(id)
+          const entry = findById(id)
+          if (entry === undefined) return { ok: false, code: 'validation', error: `证据 ${id} 不存在` }
+          if (entry.used) {
+            // used 且没有 consumedBy = 用户亲手丢弃的，同样不能再当依据
+            const why = entry.consumedBy === null ? '已被丢弃' : '已被另一次保存消费过'
+            return { ok: false, code: 'validation', error: `证据 ${id} ${why}` }
+          }
+          const at = Date.parse(entry.at)
+          if (Number.isFinite(at) && Date.now() - at > MAX_UNUSED_DAYS * 86400000) {
+            return { ok: false, code: 'validation', error: `证据 ${id} 已超过 ${MAX_UNUSED_DAYS} 天，不再作为依据` }
+          }
+        }
+
+        const now = new Date().toISOString()
+        const txId = `tx-${now.replace(/[-:.TZ]/g, '').slice(0, 15)}-${randomBytes(2).toString('hex')}`
+        const text = renderPersona({ l0, l1, l2 })
+        const rules = String(l1 ?? '')
+          .split('\n')
+          .map((line) => line.trim())
+          .filter((line) => line !== '')
+        const evidenceAfter = buildEvidenceAfter(readEvidence(), rules, now)
+        beginTx({ txId, at: now, personaSha256: createHash('sha256').update(text, 'utf8').digest('hex'), consume: ids, evidenceAfter })
+
+        writeAtomic(personaPath(), text)
+        try {
+          markUsed(ids, txId)
+          writeEvidenceAfter(evidenceAfter)
+        } catch (error) {
+          return { ok: true, pending: true, error: `persona 已保存，但证据记账没写完：${String(error?.message ?? error)}` }
+        }
+        clearTx()
+        return { ok: true, consumed: ids }
+      })
+    } catch (error) {
+      if (error instanceof LockedError) {
+        locked = true
+        return { ok: false, code: 'locked', error: error.message }
+      }
+      if (error instanceof PendingTxError) {
+        return { ok: false, code: 'pending', error: error.message }
+      }
+      throw error
+    } finally {
+      // locked 分支没有任何副作用，不需要补偿
+      void locked
+    }
+  })
+}
+
+/**
+ * 启动恢复。四行决策：
+ *   没日志        → 什么都不做
+ *   摘要对得上    → 重放第 4 步（消费 + 写证据快照），然后删日志
+ *   摘要对不上    → persona 没写成这样：不动证据，删日志
+ *   日志本身坏了  → 留档改名，不动数据
+ */
+export function recover() {
+  const raw = readTxRaw()
+  if (raw.kind === 'missing') return { action: 'none' }
+  if (raw.kind === 'bad') {
+    try {
+      renameSync(TX_PATH, join(selfnoteRoot(), `persona.pending.bad-${Date.now()}.json`))
+    } catch {
+      // 改名失败也别把启动卡死
+    }
+    return { action: 'quarantined' }
+  }
+  const tx = raw.tx
+  if (sha256OfCurrentPersona() !== String(tx.personaSha256 ?? '')) {
+    clearTx()
+    return { action: 'rolled-back', detail: 'persona 与日志里的摘要不一致' }
+  }
+  const consume = Array.isArray(tx.consume) ? tx.consume.map((id) => String(id)) : []
+  markUsed(consume, String(tx.txId))
+  const evidence = tx.evidenceAfter
+  if (evidence !== null && typeof evidence === 'object') writeEvidenceAfter(evidence)
+  clearTx()
+  return { action: 'replayed' }
+}

package/lib/persona.js

@@ -0,0 +1,248 @@
+// persona.md：三段（L0 核心身份 / L1 行为规则 / L2 扩展设定）的解析、渲染与字符计数。
+//
+// 计数口径是全插件唯一的：按 Unicode 码点（[...text].length）。
+// ZWJ 组合 emoji（如 👨‍👩‍👧 五个码点）会算成多个 —— 这是统一的预算单位，
+// 不要在任何界面或文档里说成「视觉上一个 emoji 只算一个字」。
+//
+// 解析规则见 docs/分层人格-20261105.md §4：
+//   - 先去掉 BOM、把 CRLF 规整成 LF
+//   - `## L0` / `## L1` / `## L2`（也认「核心身份 / 行为规则 / 扩展设定」）开新段，标题行本身丢弃
+//   - 同一层出现两次 → 用换行拼接
+//   - 标题在、正文空 → 这一层当不存在（返回空串）
+//   - 全篇没有可认的标题 → 整篇进 L1，sectionless = true
+//   - 认不出的标题行原样留在正文里（不吞内容）
+
+import { readFileSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { writeAtomic, writeJsonAtomic } from './atomic.js'
+import { selfnoteRoot } from './store.js'
+
+const TITLE_RE = /^#{1,6}\s*(.*)$/
+
+// L0 硬上限 = 320 × 0.25；L0 + L1 硬顶 320；整份文件（含 L2）上限 8000。
+export const PERSONA_L0_MAX = 80
+export const PERSONA_TOTAL = 320
+export const MAX_PERSONA_CHARS = 8000
+export const MAX_PERSONA_BYTES = 1024 * 1024
+
+export class PersonaValidationError extends Error {
+  constructor(message, code = 'total-too-long') {
+    super(message)
+    this.name = 'PersonaValidationError'
+    this.code = code
+  }
+}
+
+const ZH_LABELS = [
+  ['核心身份', 'l0'],
+  ['行为规则', 'l1'],
+  ['扩展设定', 'l2'],
+]
+
+function tierOfLine(line) {
+  const match = TITLE_RE.exec(line)
+  if (!match) return null
+  const label = match[1].trim()
+  const head = label.toUpperCase()
+  if (/^L0\b/.test(head)) return 'l0'
+  if (/^L1\b/.test(head)) return 'l1'
+  if (/^L2\b/.test(head)) return 'l2'
+  for (const [word, tier] of ZH_LABELS) {
+    if (label.startsWith(word)) return tier
+  }
+  return null
+}
+
+function joinBlocks(blocks) {
+  return blocks
+    .map((lines) => lines.join('\n').replace(/^\n+|\n+$/g, ''))
+    .filter((text) => text !== '')
+    .join('\n')
+}
+
+export function countChars(text) {
+  return [...String(text ?? '')].length
+}
+
+export function parsePersona(raw) {
+  const text = String(raw ?? '')
+    .replace(/^\uFEFF/, '')
+    .replace(/\r\n?/g, '\n')
+  if (text.trim() === '') return { l0: '', l1: '', l2: '', sectionless: true }
+
+  const blocks = { l0: [], l1: [], l2: [] }
+  const orphan = []
+  let current = null
+
+  for (const line of text.split('\n')) {
+    const tier = tierOfLine(line)
+    if (tier !== null) {
+      current = tier
+      blocks[tier].push([])
+      continue
+    }
+    if (current === null) {
+      orphan.push(line)
+      continue
+    }
+    blocks[current][blocks[current].length - 1].push(line)
+  }
+
+  const sectionless = current === null
+  if (sectionless) {
+    return { l0: '', l1: text.replace(/^\n+|\n+$/g, ''), l2: '', sectionless: true }
+  }
+
+  // 第一个标题之前的零散行不丢：并入 L1 的最前面
+  if (orphan.length > 0) {
+    const lead = orphan.join('\n').replace(/^\n+|\n+$/g, '')
+    if (lead !== '') blocks.l1.unshift([lead])
+  }
+
+  return {
+    l0: joinBlocks(blocks.l0),
+    l1: joinBlocks(blocks.l1),
+    l2: joinBlocks(blocks.l2),
+    sectionless: false,
+  }
+}
+
+const HEADINGS = [
+  ['l0', '## L0 核心身份'],
+  ['l1', '## L1 行为规则'],
+  ['l2', '## L2 扩展设定'],
+]
+
+export function renderPersona({ l0 = '', l1 = '', l2 = '' } = {}) {
+  const parts = []
+  for (const [key, heading] of HEADINGS) {
+    const body = String({ l0, l1, l2 }[key] ?? '').replace(/^\n+|\n+$/g, '')
+    if (body === '') continue
+    parts.push(`${heading}\n${body}`)
+  }
+  return parts.length === 0 ? '' : `${parts.join('\n\n')}\n`
+}
+
+export function personaPath() {
+  return join(selfnoteRoot(), 'persona.md')
+}
+
+const nonEmptyLines = (raw) =>
+  String(raw ?? '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line !== '')
+
+/** 一组行拼成文本要占多少字：每行的字 + 行与行之间那一个换行。 */
+export function costOfLines(lines) {
+  return lines.length === 0 ? 0 : lines.reduce((sum, line) => sum + countChars(line), 0) + lines.length - 1
+}
+
+/**
+ * 人格进注入时到底占多少字 —— **校验和注入必须用同一把尺子**。
+ * 只数正文（不含行间换行、不含 L0/L1 之间那个分隔）会放过「正好 320」的人格，
+ * 而注入时按带换行的口径一算就是 321，于是最后两个字被静默换成省略号。
+ */
+export function personaCost({ l0 = '', l1 = '' } = {}) {
+  const a = costOfLines(nonEmptyLines(l0))
+  const b = costOfLines(nonEmptyLines(l1))
+  return { l0: a, l1: b, total: a + b + (a > 0 && b > 0 ? 1 : 0) }
+}
+
+// 逐段比，错误文案逐字对应 spec §3.2 / §8：
+//   L0 现有 92 字，超过 80 字上限
+//   L0 72 + L1 249 = 322，超了 2 字（含行间换行，与注入同一口径）
+//   合计 8213 字，超过 8000 字上限
+export function validatePersona({ l0 = '', l1 = '', l2 = '' } = {}) {
+  const cost = personaCost({ l0, l1 })
+  const a = cost.l0
+  const b = cost.l1
+  const c = countChars(l2)
+  if (a > PERSONA_L0_MAX) {
+    return { ok: false, code: 'l0-too-long', error: `L0 现有 ${a} 字，超过 ${PERSONA_L0_MAX} 字上限` }
+  }
+  if (cost.total > PERSONA_TOTAL) {
+    return {
+      ok: false,
+      code: 'total-too-long',
+      // 那 1 个字是 L0 与 L1 之间的换行，不写出来使用者会以为算错了
+      error: `L0 ${a} + L1 ${b}${cost.total > a + b ? ' + 换行 1' : ''} = ${cost.total}，超了 ${cost.total - PERSONA_TOTAL} 字`,
+    }
+  }
+  if (a + b + c > MAX_PERSONA_CHARS) {
+    return { ok: false, code: 'file-too-long', error: `合计 ${a + b + c} 字，超过 ${MAX_PERSONA_CHARS} 字上限` }
+  }
+  return { ok: true }
+}
+
+const EMPTY_PERSONA = { l0: '', l1: '', l2: '', sectionless: true, chars: 0, truncated: false }
+
+// 读文件不截断：运行期怎么装进 320 是注入层的事（Task 3），
+// 这里只负责「读不出内容时别抛给上层」。
+export function readPersona() {
+  const file = personaPath()
+  let size
+  try {
+    size = statSync(file).size
+  } catch {
+    return { ...EMPTY_PERSONA, error: 'missing' }
+  }
+  if (size > MAX_PERSONA_BYTES) return { ...EMPTY_PERSONA, error: 'not-text' }
+  let raw
+  try {
+    raw = readFileSync(file, 'utf8')
+  } catch {
+    return { ...EMPTY_PERSONA, error: 'not-text' }
+  }
+  if (raw.includes('\0')) return { ...EMPTY_PERSONA, error: 'not-text' }
+  const parsed = parsePersona(raw)
+  return {
+    ...parsed,
+    chars: countChars(parsed.l0) + countChars(parsed.l1) + countChars(parsed.l2),
+    truncated: false,
+    error: '',
+  }
+}
+
+export function savePersonaFile({ l0 = '', l1 = '', l2 = '' } = {}) {
+  const verdict = validatePersona({ l0, l1, l2 })
+  if (!verdict.ok) throw new PersonaValidationError(verdict.error, verdict.code)
+  writeAtomic(personaPath(), renderPersona({ l0, l1, l2 }))
+}
+
+/* ---------------- 取用记账：L2 到底有没有人看 ---------------- */
+
+const STATS_PATH = join(selfnoteRoot(), 'persona.reads.json')
+
+export function personaStatsPath() {
+  return STATS_PATH
+}
+
+/**
+ * 读「取用过几次」。
+ * 记这个不为统计好看：L2 是设了不看的死配置，30 天没人取就得在体检里说一声。
+ */
+export function readPersonaStats() {
+  try {
+    const raw = JSON.parse(readFileSync(STATS_PATH, 'utf8'))
+    return {
+      reads: Number.isFinite(Number(raw?.reads)) ? Number(raw.reads) : 0,
+      lastReadAt: typeof raw?.lastReadAt === 'string' ? raw.lastReadAt : '',
+    }
+  } catch {
+    return { reads: 0, lastReadAt: '' }
+  }
+}
+
+/** 只有「真的取到了一段非空 L2」才计数：取了个空壳不算有人看过。 */
+export function notePersonaRead(now = new Date()) {
+  const before = readPersonaStats()
+  const next = { reads: before.reads + 1, lastReadAt: now.toISOString() }
+  try {
+    writeJsonAtomic(STATS_PATH, next)
+  } catch {
+    /* 记不上账不该影响这次取用 */
+  }
+  return next
+}

package/lib/transfer.js

@@ -9,7 +9,7 @@
  * 索引不导出：它记的是磁盘路径与 mtime，搬过去必然过期，导入后重建一次就行。
  */
 
-export const BUNDLE_VERSION = 1
+export const BUNDLE_VERSION = 2
 export const BUNDLE_APP = 'dsh-selfnote'
 
 const CONFIG_FIELDS = [
@@ -22,6 +22,10 @@ const CONFIG_FIELDS = [
   'profileMaxChars',
   'halfLifeDays',
   'noteGuide',
+  // v2 加的两个：人格开关与临时自述保质期。它们决定「搬过去之后样子一样不一样」，
+  // 不带的话，同一份导出在另一台机器上会长得不一样
+  'personaEnabled',
+  'tempTtlDays',
 ]
 
 function isObject(value) {
@@ -32,8 +36,16 @@ function textOf(value) {
   return typeof value === 'string' ? value.trim() : ''
 }
 
+/** 人格三段：只有非空的才算「带了人格」，全空等同于没带。 */
+function normalizePersona(value) {
+  if (!isObject(value)) return null
+  const out = { l0: textOf(value.l0), l1: textOf(value.l1), l2: textOf(value.l2) }
+  if (out.l0 === '' && out.l1 === '' && out.l2 === '') return null
+  return out
+}
+
 /** 导出：只挑能带走的东西，配置只挑用户可调的那几项。 */
-export function buildBundle({ notes = [], facts = [], habits = [], config = {}, now = new Date() } = {}) {
+export function buildBundle({ notes = [], facts = [], habits = [], config = {}, persona = null, now = new Date() } = {}) {
   const safeConfig = {}
   for (const field of CONFIG_FIELDS) {
     if (config[field] !== undefined) safeConfig[field] = config[field]
@@ -46,6 +58,8 @@ export function buildBundle({ notes = [], facts = [], habits = [], config = {},
     notes: notes.map((entry) => ({ date: entry.date ?? '', text: entry.text ?? '' })),
     facts: facts.map((fact) => ({ ...fact })),
     habits: habits.map((habit) => ({ ...habit })),
+    // 人格跟着走（v2）；纠偏候选不跟 —— 它是「这台机器上攒下的证据」，搬过去就失了上下文
+    persona: normalizePersona(persona),
     config: safeConfig,
   }
 }
@@ -60,9 +74,33 @@ export function validateBundle(bundle) {
   for (const key of ['notes', 'facts', 'habits']) {
     if (bundle[key] !== undefined && !Array.isArray(bundle[key])) return `${key} 不是数组`
   }
+  if (bundle.persona !== undefined && bundle.persona !== null) {
+    if (!isObject(bundle.persona)) return 'persona 不是对象'
+    for (const field of ['l0', 'l1', 'l2']) {
+      const value = bundle.persona[field]
+      if (value !== undefined && typeof value !== 'string') return `persona.${field} 不是字符串`
+    }
+  }
   return null
 }
 
+/**
+ * 人格怎么合并：**永远不覆盖**。
+ * - 包里没带、或者全空 → none
+ * - 本机还没有人格 → adopt（用导入的）
+ * - 本机有且一模一样 → same（不写盘，省一次无意义的原子写）
+ * - 本机有但不一样 → conflict，调用方把它落到 persona.imported-<ts>.md，
+ *   绝不悄悄盖掉本机那份 —— 人格是人一条条确认出来的，不该被一次导入换掉。
+ */
+export function mergePersona(incoming, current) {
+  const next = normalizePersona(incoming)
+  if (next === null) return { action: 'none' }
+  const now = normalizePersona(current)
+  if (now === null) return { action: 'adopt', persona: next }
+  if (now.l0 === next.l0 && now.l1 === next.l1 && now.l2 === next.l2) return { action: 'same' }
+  return { action: 'conflict', persona: next }
+}
+
 /**
  * 合并：返回「合并后的三份数据 + 账目」。
  * 纯函数，不写盘 —— 写盘由调用方做，失败才好回滚。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-selfnote",
-  "version": "0.13.3",
+  "version": "0.14.0",
   "type": "module",
   "description": "Self-narrative memory for DeepSeek Harness: the model writes notes to itself, which persist across sessions and are injected back. | 人格库：模型写给自己看的话，跨会话保留并每回合注入。",
   "keywords": [
@@ -27,7 +27,7 @@
     "assets"
   ],
   "scripts": {
-    "test": "node tests/smoke.mjs && node tests/memory.mjs && node tests/roles.mjs && node tests/heat.mjs && node tests/fair.mjs && node tests/capture-debug.mjs && node tests/facts-tx.mjs && node tests/crash-write.mjs && node tests/capture.mjs && node tests/capture-p1b.mjs && node tests/index.mjs && node tests/incremental.mjs && node tests/profile.mjs && node tests/warm.mjs && node tests/transfer.mjs && node tests/api.mjs && node tests/notes-tier.mjs && node tests/client-state.mjs && node tests/client.mjs",
+    "test": "node tests/smoke.mjs && node tests/memory.mjs && node tests/roles.mjs && node tests/heat.mjs && node tests/fair.mjs && node tests/capture-debug.mjs && node tests/facts-tx.mjs && node tests/crash-write.mjs && node tests/capture.mjs && node tests/capture-p1b.mjs && node tests/index.mjs && node tests/incremental.mjs && node tests/profile.mjs && node tests/warm.mjs && node tests/transfer.mjs && node tests/api.mjs && node tests/notes-tier.mjs && node tests/persona.mjs && node tests/corrections.mjs && node tests/client-state.mjs && node tests/client.mjs",
     "test:accept": "node tests/acceptance-runtime.mjs"
   },
   "engines": {