dsh-selfnote 0.13.1 → 0.13.3

package/README.md

@@ -252,6 +252,29 @@ DSH 的会话文件是**逐条追写**的 zstd 序列（一次写入 = 一个 fr
 - **采纳 / 退役都要人点**：出现次数再多也不会自动采纳；退役的事实不会因为新候选出现就自己复活。
 - **留痕**：每次改状态记下时间、从哪改的（`via: settings`）、前后状态（`history`），事后可查。
 
+### 候选为空时，怎么知道它到底有没有在听
+
+`GET /api/selfnote/capture` 是这块的诊断口（要带 `x-selfnote` 头，值见 `~/.dsh/selfnote/auth-token`）：
+
+```json
+{
+  "since": "2026-11-04T07:31:02.114Z",
+  "events": 160,
+  "types": { "user/message": 12, "job/registered": 40, "turn/ended": 108 },
+  "reasons": { "written": 1, "no-candidate": 11, "not-user-authored": 148 },
+  "candidates": 1,
+  "written": 1,
+  "lastType": "turn/ended",
+  "trace": [{ "at": "…", "sid": "session-", "type": "user/message", "seq": 91, "reason": "no-candidate" }]
+}
+```
+
+- `types` 是事件类型直方图：`user/message` 在涨，说明**你的话真的进来了**；不涨才是链路断了。
+- `reasons` 是每一条的最后落点：`written` 写出了候选、`no-candidate` 过了人审但没命中触发词、`not-user-authored` 不是人打的、`no-session` 没有会话 id、`error` 采集抛错。
+- `trace` 保留最近 40 条，带时间、会话前缀、seq 和落点。
+
+候选区空着有两种情况，这里能分开：**没在听**（`types` 里没有 `user/message`）和**在听但没话可采**（`no-candidate` 在涨）。这两个计数是 0.13.2 才补的 —— 上一版有两个计数器声明了从来没人加一，读出来永远 0，排查时反而把结论带偏。
+
 ## 注入预算
 
 每回合五段，合计 800 字（自述占最大一份）：

package/lib/client.js

@@ -155,6 +155,11 @@ window.__ModuleLoader__.load({
       var headingTuple = useState('')
       var heading = headingTuple[0]
       var setHeading = headingTuple[1]
+      // 新写的那条算哪一型：核心先装、稳定默认、临时只活当下
+      // 放在最后：上面那些 useState 的调用序号被测试依赖，别插在中间
+      var draftTierTuple = useState('stable')
+      var draftTier = draftTierTuple[0]
+      var setDraftTier = draftTierTuple[1]
 
       function apply(data) {
         setState(data)
@@ -299,11 +304,12 @@ window.__ModuleLoader__.load({
           return
         }
         setBusy('note')
-        apiPost('/note', { text: text })
+        apiPost('/note', { text: text, tier: draftTier })
           .then(function (data) {
             apply(data)
             setDraft('')
-            setNotice({ tone: 'ok', text: '写好了。' })
+            var add = data.noteAdd || {}
+            setNotice(add.warning ? { tone: 'warn', text: '写好了，但' + add.warning } : { tone: 'ok', text: '写好了。' })
           })
           .catch(function (error) {
             setNotice({ tone: 'warn', text: '写入失败：' + error.message })
@@ -351,6 +357,22 @@ window.__ModuleLoader__.load({
           })
       }
 
+      // 改类型 / pin：正文一个字不动，只换这条排在哪一队
+      function setNoteTier(index, patch) {
+        setBusy('note-meta')
+        apiPost('/note/meta', { index: index, tier: patch.tier, pin: patch.pin })
+          .then(function (data) {
+            apply(data)
+            setNotice({ tone: 'ok', text: '改好了，下一回合按新的位置装。' })
+          })
+          .catch(function (error) {
+            setNotice({ tone: 'warn', text: '没改成：' + error.message })
+          })
+          .then(function () {
+            setBusy('')
+          })
+      }
+
       function removeNote(index) {
         if (pendingDelete !== index) {
           setPendingDelete(index)
@@ -1049,12 +1071,31 @@ window.__ModuleLoader__.load({
         h(
           'div',
           { className: 'sn-actions' },
+          h(
+            'select',
+            {
+              className: 'sn-tier',
+              value: draftTier,
+              title: '核心=人格与长期身份（先装，最多占自述段的 60%）；稳定=表达习惯与工作偏好；临时=当前阶段在做什么',
+              onChange: function (e) { setDraftTier(e.target.value) },
+            },
+            h('option', { value: 'core' }, '核心身份'),
+            h('option', { value: 'stable' }, '稳定偏好'),
+            h('option', { value: 'temp' }, '临时自述'),
+          ),
           h('button', { className: 'sn-btn', onClick: addNote, disabled: busy !== '' }, '写进去'),
           h('span', { className: 'sn-grow' }),
           h('button', { className: 'sn-btn sn-btn-danger', onClick: clearAll, disabled: busy !== '' }, confirming ? '真的清空' : '清空当前（进归档）'),
         ),
       )
 
+      var tierCounts = { core: 0, stable: 0, temp: 0, expired: 0 }
+      notes.forEach(function (entry) {
+        var key = entry.tier === 'core' || entry.tier === 'temp' ? entry.tier : 'stable'
+        tierCounts[key] += 1
+        if (entry.expired === true) tierCounts.expired += 1
+      })
+
       var notesList = h(
         'div',
         { className: 'sn-card', key: 'notes' },
@@ -1062,7 +1103,13 @@ window.__ModuleLoader__.load({
         h(
           'div',
           { className: 'sn-hint' },
-          '每一行都会进注入：最新的优先，合计 ≤ ' + caps.notes + ' 字，放不下的整条跳过（不截半句）。改完/删完下一回合生效。',
+          '按「核心 → 稳定（★ 先装）→ 临时」的顺序装，合计 ≤ ' + caps.notes + ' 字（核心最多占 60%）。放不下的整条跳过、不截半句，注入里会留一句「另有 N 条」当门牌。改完/删完下一回合生效。',
+        ),
+        h(
+          'div',
+          { className: 'sn-hint' },
+          '核心 ' + tierCounts.core + ' 条　稳定 ' + tierCounts.stable + ' 条　临时 ' + tierCounts.temp + ' 条' +
+            (tierCounts.expired > 0 ? '（其中 ' + tierCounts.expired + ' 条已过期，不再自动进场）' : ''),
         ),
         reversed.length === 0
           ? h('div', { className: 'sn-empty' }, '还没有任何自述。模型攒到第一条时会出现在这里。')
@@ -1096,12 +1143,46 @@ window.__ModuleLoader__.load({
                           h('button', { className: 'sn-btn sn-btn-ghost', onClick: cancelEditNote, disabled: busy !== '' }, '取消'),
                         ),
                       )
-                    : h('span', { className: 'sn-text' }, entry.text),
+                    : h(
+                        'span',
+                        { className: 'sn-text' },
+                        entry.text,
+                        entry.expired === true
+                          ? h(
+                              'span',
+                              { className: 'sn-expired', title: '临时自述过了保质期，不再自动进上下文；内容还在，改成「稳定」或重写一条就回来' },
+                              '已过期',
+                            )
+                          : null,
+                      ),
                   isEditing
                     ? null
                     : h(
                         'span',
                         { className: 'sn-row-actions' },
+                        h(
+                          'select',
+                          {
+                            className: 'sn-tier',
+                            value: entry.tier || 'stable',
+                            title: '这条属于哪一型：核心先装（人格、长期身份）、稳定按 pin 排、临时最后',
+                            onChange: function (e) { setNoteTier(stored, { tier: e.target.value }) },
+                            disabled: busy !== '',
+                          },
+                          h('option', { value: 'core' }, '核心'),
+                          h('option', { value: 'stable' }, '稳定'),
+                          h('option', { value: 'temp' }, '临时'),
+                        ),
+                        h(
+                          'button',
+                          {
+                            className: 'sn-btn sn-btn-ghost sn-pin' + (entry.pin === true ? ' sn-pin-on' : ''),
+                            title: entry.pin === true ? '已钉住：同一型里优先装进去（再点取消）' : '钉住：同一型里优先装进去',
+                            onClick: function () { setNoteTier(stored, { pin: entry.pin !== true }) },
+                            disabled: busy !== '',
+                          },
+                          entry.pin === true ? '★' : '☆',
+                        ),
                         h('button', { className: 'sn-btn sn-btn-ghost', onClick: function () { startEditNote(stored, entry.text) }, disabled: busy !== '' }, '改'),
                         h('button', { className: 'sn-btn sn-btn-danger', onClick: function () { removeNote(stored) }, disabled: busy !== '' }, pendingDelete === stored ? '真的删' : '删'),
                       ),
@@ -1575,6 +1656,10 @@ window.__ModuleLoader__.load({
       '.sn-edit{flex:1;min-width:0;display:flex;flex-direction:column;gap:6px}',
       '.sn-row-actions{display:flex;gap:6px;margin-left:auto;flex:none;opacity:.55;transition:opacity .12s ease}',
       '.sn-item:hover .sn-row-actions,.sn-item:focus-within .sn-row-actions{opacity:1}',
+      '.sn-tier{font-size:11px;font-family:inherit;padding:2px 4px;border-radius:6px;border:1px solid var(--dsw-alias-border-subtle,#d1d5db);background:var(--dsw-alias-bg-primary,#fff);color:inherit;cursor:pointer}',
+      '.sn-pin{padding:2px 8px;line-height:1.6}',
+      '.sn-pin-on{color:#b45309;border-color:#fcd34d}',
+      '.sn-expired{font-size:11px;color:#9ca3af;border:1px solid #e5e7eb;border-radius:6px;padding:0 6px;margin-left:6px;white-space:nowrap}',
       '.sn-fact-edit{display:flex;flex-direction:column;gap:6px}',
       '.sn-empty{font-size:12px;color:var(--dsw-alias-text-secondary,#9ca3af)}',
       '.sn-sources{list-style:none;margin:0;padding:0;display:flex;flex-wrap:wrap;gap:6px}',

package/lib/index.js

@@ -16,11 +16,14 @@ import {
   clearNotes,
   configPath,
   deleteNote,
+  isExpiredNote,
   notesPath,
+  normalizeTier,
   readAuthToken,
   readConfig,
   readNotes,
   renderNotes,
+  setNoteMeta,
   trim,
   selfnoteRoot,
   stats,
@@ -30,6 +33,7 @@ import {
   writeNotes,
   DEFAULT_MAX_CHARS,
   DEFAULT_MAX_ENTRIES,
+  DEFAULT_TEMP_TTL_DAYS,
   MAX_ENTRY_CHARS,
 } from './store.js'
 
@@ -81,16 +85,62 @@ export const name = 'selfnote'
 /** 声明式依赖：systemPrompt 注入，tools 写入，webServer 提供设置页 API。 */
 export const inject = ['systemPrompt', 'tools', 'webServer']
 
-/** 自动采集的现场计数器：只用于排查「事件到底有没有到」，不参与业务。 */
+/**
+ * 自动采集的现场情况：只用于排查「事件到底有没有到、卡在哪一步」，不参与业务。
+ *
+ * 以前这里有两个 userAuthored / noSeq 计数器，声明了从来没人加一，读出来永远是 0 ——
+ * 排查时反而误导（看起来像「消息一条都没进来」）。现在换成两条真账：
+ * types（按事件类型计数）与 reasons（按落点计数），外加最近若干条轨迹。
+ */
+const CAPTURE_TRACE_MAX = 40
+
 const captureDebug = {
+  since: null,
   events: 0,
-  userAuthored: 0,
-  noSeq: 0,
+  types: {},
+  reasons: {},
   candidates: 0,
   written: 0,
   lastType: null,
   lastKeys: null,
   lastError: null,
+  trace: [],
+}
+
+function bumpCounter(bucket, key) {
+  if (typeof key !== 'string' || key === '') return
+  bucket[key] = (bucket[key] ?? 0) + 1
+}
+
+/** 事件一进来先记账：类型直方图 + 最近几条。返回类型，供后面的落点记录复用。 */
+function noteCaptureEvent(sessionId, event) {
+  captureDebug.events += 1
+  const type = typeof event?.type === 'string' && event.type !== '' ? event.type : 'unknown'
+  bumpCounter(captureDebug.types, type)
+  captureDebug.lastType = event?.type ?? null
+  captureDebug.lastKeys = event !== null && typeof event === 'object' ? Object.keys(event).slice(0, 12) : null
+  uploadTrace({
+    at: new Date().toISOString(),
+    sid: typeof sessionId === 'string' ? sessionId.slice(0, 8) : '',
+    type,
+    seq: Number.isSafeInteger(event?.seq) ? event.seq : null,
+    reason: null,
+  })
+  return type
+}
+
+/** 这一轮采集最后落在哪：写进去了 / 没候选 / 不是人说的 / 没 seq …… */
+function noteCaptureOutcome(reason) {
+  bumpCounter(captureDebug.reasons, reason)
+  const last = captureDebug.trace[captureDebug.trace.length - 1]
+  if (last !== undefined) last.reason = reason
+}
+
+function uploadTrace(entry) {
+  captureDebug.trace.push(entry)
+  if (captureDebug.trace.length > CAPTURE_TRACE_MAX) {
+    captureDebug.trace.splice(0, captureDebug.trace.length - CAPTURE_TRACE_MAX)
+  }
 }
 
 const API_PREFIX = '/api/selfnote'
@@ -109,6 +159,8 @@ const DEFAULT_CONFIG = {
   halfLifeDays: DEFAULT_HALF_LIFE_DAYS,
   /** 自定义「写自述的时机」；留空就用工具说明里的默认判据。 */
   noteGuide: '',
+  /** 临时自述的保质期（天）：过了就不自动进场，只留在库里。核心与稳定型不受影响。 */
+  tempTtlDays: DEFAULT_TEMP_TTL_DAYS,
 }
 
 const TOOL_DESCRIPTION = `维护「我自己的叙述」——不是记用户的事，是记我自己的。
@@ -122,6 +174,7 @@ const TOOL_DESCRIPTION = `维护「我自己的叙述」——不是记用户的
 写法：
 - 第一人称，一句话到三句话；写「我」的做法和判断，不复述用户的原话。
 - 一条写一件事。空话、套话、复述人格设定都不值得写。
+- 写的时候用 tier 标明这是哪一型：core=核心身份（人格、长期身份、基本原则）、stable=稳定偏好（语言、表达习惯、工作偏好）、temp=临时自述（当前阶段的目标、近期变化）。不写按 stable 算。
 - 只追加，不能改写历史。写满后最旧的条目自动进归档，不会丢，只是不再每回合注入。
 - 这是明文保存在本机、并且每回合都会进上下文的文件：密码、密钥、验证码这类凭据别写。
 - 记用户本人（名字、习惯、处境、在意的点）是有用的，但那些更适合进事实库：用 memory_stage。
@@ -142,6 +195,15 @@ const PARAMETERS = {
       type: 'string',
       description: 'action=write 时的正文，一句话到三句话，第一人称。最多 600 字，超出截断。',
     },
+    tier: {
+      type: 'string',
+      enum: ['core', 'stable', 'temp'],
+      description: '这条属于哪一型：core=核心身份（人格、长期身份、基本原则，先装）；stable=稳定偏好（表达习惯、工作偏好，默认）；temp=临时自述（当前阶段的目标、近期变化，最后装）。',
+    },
+    pin: {
+      type: 'boolean',
+      description: '钉住：同一型里优先装进上下文。只给「绝不能忘」的那一两条用，钉多了等于没钉。',
+    },
   },
   required: ['action'],
 }
@@ -169,6 +231,9 @@ function currentConfig(inline) {
     // 存的正好是老默认 → 跟着换代；用户自己改过的（不等于老默认）一个字都不动。
     heading: merged.heading === LEGACY_HEADING ? DEFAULT_CONFIG.heading : merged.heading,
     noteGuide: typeof merged.noteGuide === 'string' ? merged.noteGuide.trim().slice(0, GUIDE_LIMIT) : '',
+    tempTtlDays: Number.isFinite(Number(merged.tempTtlDays))
+      ? Math.max(1, Math.min(Math.round(Number(merged.tempTtlDays)), 90))
+      : DEFAULT_TEMP_TTL_DAYS,
   }
 }
 
@@ -187,6 +252,14 @@ function limitsOf(cfg) {
 const BUDGET = { notes: 200, profile: 130, env: 320, facts: 110, habits: 40 }
 /** 五段合计，别在别处再手写一个数字。 */
 export const TOTAL_BUDGET = BUDGET.notes + BUDGET.profile + BUDGET.env + BUDGET.facts + BUDGET.habits
+
+/**
+ * 自述段的内部分账。核心身份（人格、长期身份）先装，最多吃 60%：
+ * 人格优先，但不能一条人格把整个自述段占死，后面的人味就全没了。
+ */
+const CORE_SHARE = 0.6
+/** 临时自述的保底比例：别让长期偏好把「当前阶段在做什么」全部挤掉。 */
+const TEMP_SHARE = 0.25
 /** 自定义「写自述的时机」那行的上限（字）。 */
 export const GUIDE_LIMIT = 80
 /** 注入抬头那一行的上限（字）。它是每回合固定开销，不设限等于让人用一句话吃掉预算。 */
@@ -310,6 +383,129 @@ function fit(items, limit) {
   return fitDetailed(items, limit).text
 }
 
+/**
+ * 自述段的三型分账。顺序就是优先级：
+ *   核心（旧→新，人格底子先在场）→ 稳定（pin 先，再新→旧）→ 临时（新→旧）。
+ * 稳定段有上限（给临时留 1/4 保底），临时段拿走剩下的全部 —— 临时条目都很短，通常吃不完。
+ * 为什么要分：混着装的时候，一条 90 字的人格自述和五条「今晚提醒」抢同一个 200 字，
+ * 抢输的总是人格那条，而且没人看得出来谁被挤掉了。
+ * 临时型还会过期：过了 tempTtlDays 就不再自动进场（数据一个字没删，只是不进上下文）。
+ */
+function packNotes(entries, limit, ttl) {
+  const ttlDays = Number.isFinite(Number(ttl)) ? Number(ttl) : DEFAULT_TEMP_TTL_DAYS
+  const core = []
+  const stable = []
+  const temp = []
+  const expired = []
+  for (const entry of entries) {
+    const tier = normalizeTier(entry?.tier)
+    if (tier === 'core') core.push(entry)
+    else if (tier === 'temp') {
+      if (isExpiredNote(entry, ttlDays)) expired.push(entry)
+      else temp.push(entry)
+    } else stable.push(entry)
+  }
+  const coreList = core.map((entry) => entry.text)
+  const stableList = stable
+    .slice()
+    .reverse()
+    .sort((a, b) => (b.pin === true ? 1 : 0) - (a.pin === true ? 1 : 0))
+    .map((entry) => entry.text)
+  const tempList = temp.slice().reverse().map((entry) => entry.text)
+
+  const coreLimit = Math.min(limit, Math.round(limit * CORE_SHARE))
+  const coreFit = fitDetailed(coreList, coreLimit)
+  let used = coreFit.text === '' ? 0 : coreFit.text.length + 1
+  const tail = Math.max(0, limit - used)
+  const tempFloor = tempList.length === 0 ? 0 : Math.min(tail, Math.max(24, Math.round(tail * TEMP_SHARE)))
+  const stableLimit = Math.max(0, tail - tempFloor)
+  const stableFit = fitDetailed(stableList, stableLimit)
+  used += stableFit.text === '' ? 0 : stableFit.text.length + 1
+  const tempLimit = Math.max(0, limit - used)
+  const tempFit = fitDetailed(tempList, tempLimit)
+
+  const parts = [coreFit.text, stableFit.text, tempFit.text].filter((part) => part !== '')
+  // 过期的也算「没进上下文」：它们还在库里，模型得靠门牌知道有这么几条，
+  // 所以并进 skipped 一起报数 —— 少报就是骗人。
+  const expiredTexts = expired.map((entry) => entry.text)
+  return {
+    text: parts.join('\n'),
+    kept: [...coreFit.kept, ...stableFit.kept, ...tempFit.kept],
+    skipped: [...coreFit.skipped, ...stableFit.skipped, ...tempFit.skipped, ...expiredTexts],
+    // 每型的账：设置页要能指着说「核心 3 条全进了，临时 2 条被挤掉」
+    tiers: {
+      core: { total: coreList.length, kept: coreFit.kept.length, skipped: coreFit.skipped.length, limit: coreLimit },
+      stable: { total: stableList.length, kept: stableFit.kept.length, skipped: stableFit.skipped.length, limit: stableLimit },
+      temp: {
+        total: tempList.length + expired.length,
+        kept: tempFit.kept.length,
+        skipped: tempFit.skipped.length,
+        expired: expired.length,
+        limit: tempLimit,
+      },
+    },
+  }
+}
+
+/**
+ * 自述段 + 门牌。
+ * 门牌必须收敛：它自己占字，加进去可能又挤掉一条，条数一变门牌上的数字就是错的。
+ * 所以两轮：先按全长排，用剩下的条数算门牌，再按「减掉门牌」的长度重排，直到条数不再变。
+ */
+function notesSegment(entries, limit, ttl) {
+  const packed = packNotes(entries, limit, ttl)
+  if (packed.skipped.length === 0) return { ...packed, pointer: '' }
+  let current = packed
+  let pointer = ''
+  for (let pass = 0; pass < 3; pass += 1) {
+    const next = `另有 ${current.skipped.length} 条自述（self_note read）`
+    if (next.length + 1 >= limit) break
+    const refit = packNotes(entries, Math.max(0, limit - next.length - 1), ttl)
+    const converged = refit.skipped.length === current.skipped.length
+    pointer = next
+    current = { ...refit, text: refit.text === '' ? next : `${refit.text} ${next}` }
+    if (converged) break
+  }
+  if (pointer !== '') current.text = current.text.includes(pointer) ? current.text : `${current.text} ${pointer}`.trim()
+  return { ...current, pointer }
+}
+
+/** 结论段打包：要连 id 一起留下（归属统计靠它），所以不能直接用 fitDetailed。 */
+function packFacts(ranked, limit) {
+  const kept = []
+  const skipped = []
+  let used = 0
+  for (const item of ranked) {
+    const text = String(item?.text ?? '').trim()
+    if (text === '') continue
+    if (used + text.length > limit) {
+      skipped.push(text)
+      continue
+    }
+    kept.push(item)
+    used += text.length + 1
+  }
+  return { text: kept.map((item) => item.text).join('\n'), kept, skipped, used }
+}
+
+/** 结论段 + 门牌：和自述同一套收敛逻辑，否则「另有 N 条」会少报。 */
+function factsSegment(ranked, limit) {
+  const packed = packFacts(ranked, limit)
+  if (packed.skipped.length === 0) return { ...packed, pointer: '' }
+  let current = packed
+  let pointer = ''
+  for (let pass = 0; pass < 3; pass += 1) {
+    const next = `另有 ${current.skipped.length} 条结论（memory_recall 查）`
+    if (next.length + 1 >= limit) break
+    const refit = packFacts(ranked, Math.max(0, limit - next.length - 1))
+    const converged = refit.skipped.length === current.skipped.length
+    pointer = next
+    current = { ...refit, text: refit.text === '' ? next : `${refit.text} ${next}` }
+    if (converged) break
+  }
+  return { ...current, pointer }
+}
+
 let injectCache = { key: '', text: '' }
 
 /** 注入文本的缓存键：三份数据只要有一份变了，就重算。 */
@@ -325,8 +521,11 @@ function injectionKey(cfg) {
     }
   })
   const profileKey = [cfg.profileEnabled, cfg.profileMaxChars, cfg.profileOverride.length, cfg.profileOverride].join('~')
+  // 临时自述会自己到期：文件一个字没改，跨过保质期那天注入也得重算。
+  // 按「天」进键就够了，不必精确到毫秒 —— 一天最多重算一次。
+  const dayKey = 'd' + Math.floor(Date.now() / 86400000)
   // 半衰期也影响排序（facts / env 段按热度排），不改文件只改它时也得重算
-  return stamps.join('|') + '|' + cfg.enabled + '|' + cfg.heading + '|' + profileKey + '|hl' + cfg.halfLifeDays
+  return stamps.join('|') + '|' + cfg.enabled + '|' + cfg.heading + '|' + profileKey + '|hl' + cfg.halfLifeDays + '|ttl' + cfg.tempTtlDays + '|' + dayKey
 }
 
 /**
@@ -338,14 +537,18 @@ function assembleInjection(cfg, options = {}) {
   const segments = []
   const parts = []
 
-  const noteFit = fitDetailed(
-    readNotes()
-      .slice()
-      .reverse()
-      .map((entry) => entry.text),
-    BUDGET.notes,
-  )
-  segments.push({ key: 'notes', label: '自述', limit: BUDGET.notes, chars: noteFit.text.length, kept: noteFit.kept, skipped: noteFit.skipped })
+  // 自述：三型分账 + 门牌。装不下的那几条，模型必须知道存在，否则它会把「没看见」当成「没有」。
+  const noteFit = notesSegment(readNotes(), BUDGET.notes, cfg.tempTtlDays)
+  segments.push({
+    key: 'notes',
+    label: '自述',
+    limit: BUDGET.notes,
+    chars: noteFit.text.length,
+    kept: noteFit.kept,
+    skipped: noteFit.skipped,
+    tiers: noteFit.tiers,
+    pointer: noteFit.pointer ?? '',
+  })
   if (noteFit.text !== '') parts.push(noteFit.text)
 
   // 自定义「写自述的时机」：工具说明在注册时就定型了，改一句要重启；
@@ -407,10 +610,8 @@ function assembleInjection(cfg, options = {}) {
   if (envLine !== '') parts.push(envLine)
 
   const ranked = factsForInjection(cfg)
-  const factFit = fitDetailed(
-    ranked.map((item) => item.text),
-    BUDGET.facts,
-  )
+  // 结论段也带门牌：装不下的不只是「没用」，是「查得到但现在不在场」
+  const factFit = factsSegment(ranked, BUDGET.facts)
   // 只有真的进了上下文才算「用到」；被检索到但没进上下文的不涨热度。
   // 画像段也是真贴进提示词的一行 —— 被画像吸收的条目同样要记账，
   // 否则「关于他：…」里天天在用的那句会一直显示「0 次 / 从没进过」。
@@ -420,10 +621,7 @@ function assembleInjection(cfg, options = {}) {
   const placements = {}
   for (const id of profile.sources ?? []) placements[id] = 'profile'
   for (const id of env.ids) placements[id] = 'env'
-  let factChars = 0
-  for (const item of ranked) {
-    if (factChars + item.text.length > BUDGET.facts) continue
-    factChars += item.text.length + 1
+  for (const item of factFit.kept) {
     factIds.push(item.id)
     placements[item.id] = 'facts'
   }
@@ -433,8 +631,9 @@ function assembleInjection(cfg, options = {}) {
     label: '结论',
     limit: BUDGET.facts,
     chars: factFit.text.length,
-    kept: factFit.kept,
+    kept: factFit.kept.map((item) => item.text),
     skipped: factFit.skipped,
+    pointer: factFit.pointer ?? '',
     absorbed: factFit.text === '' ? (profile.sources ?? []).length : 0,
   })
   if (factFit.text !== '') parts.push(factFit.text)
@@ -1189,7 +1388,9 @@ function stateOfInner(inline) {
     entries: s.entries,
     chars: s.chars,
     archiveFiles: s.archiveFiles,
-    notes: readNotes(),
+    // 每行带上「到期没有」：设置页要能把过期的临时自述标出来，而不是让人以为它这回合还在
+    notes: readNotes().map((entry) => ({ ...entry, expired: isExpiredNote(entry, cfg.tempTtlDays) })),
+    tempTtlDays: cfg.tempTtlDays,
     noteGuide: cfg.noteGuide,
     notesLastWrite: s.lastWrite,
     notesFile: s.notesFile,
@@ -1272,14 +1473,11 @@ function currentProfileText(cfg) {
 function budgetOf(inline) {
   const cfg = currentConfig(inline)
   if (!cfg.enabled) return { total: 0, limit: TOTAL_BUDGET, notes: 0, profile: 0, env: 0, facts: 0, habits: 0, enabled: false, caps: { ...BUDGET } }
-  const notes = fit(readNotes().slice().reverse().map((entry) => entry.text), BUDGET.notes)
+  // 和 assembleInjection 用同一套分账打包，否则设置页的读数跟真注入对不上（门牌也要算进去）
+  const notes = notesSegment(readNotes(), BUDGET.notes, cfg.tempTtlDays).text
   const profile = currentProfile(cfg)
-  // 和 assembleInjection 用同一套分账打包，否则设置页的读数跟真注入对不上
   const env = packEnvFair(envForInjection(cfg), BUDGET.env).text
-  const facts = fit(
-    factsForInjection(cfg).map((item) => item.text),
-    BUDGET.facts,
-  )
+  const facts = factsSegment(factsForInjection(cfg), BUDGET.facts).text
   const habits = fit(readHabits().filter((habit) => habit.status === 'active').map((habit) => '· ' + habit.text), BUDGET.habits)
   return {
     enabled: true,
@@ -1295,11 +1493,34 @@ function budgetOf(inline) {
   }
 }
 
+const TIER_WORD = { core: '核心身份', stable: '稳定偏好', temp: '临时自述' }
+
+/**
+ * 写完的那条到底进不进得了上下文 —— 提前说清楚。
+ * 超过整段预算的条目，保存会成功、注入会静默跳过，人只会觉得「我写了怎么没生效」。
+ */
+function noteCapacityWarning(tier, text, inline) {
+  const cfg = currentConfig(inline)
+  if (cfg.enabled === false) return '注入已关闭，这条暂时不会进上下文。'
+  const key = normalizeTier(tier)
+  const body = String(text ?? '')
+  const caps = { core: Math.round(BUDGET.notes * CORE_SHARE), stable: BUDGET.notes, temp: BUDGET.notes }
+  if (body.length > caps[key]) {
+    return `这条 ${body.length} 字，超过${TIER_WORD[key]}段的上限（约 ${caps[key]} 字），模型每回合都看不到它 —— 要么写短，要么拆成几条。`
+  }
+  const info = packNotes(readNotes(), BUDGET.notes, cfg.tempTtlDays).tiers[key]
+  if (info.skipped > 0) return `${TIER_WORD[key]}现在共 ${info.total} 条，这轮有 ${info.skipped} 条被挤掉（排在前面的才进上下文）。`
+  return ''
+}
+
 function renderText(args, value) {
   if (value?.error) return `⚠️ ${value.error}`
   if (value.action === 'write') {
     const tail = value.archived > 0 ? `，最旧的 ${value.archived} 条已归档到 ${value.archivedFile}` : ''
-    return `已写下。现在生效 ${value.entries} 条 / ${value.chars} 字${tail}。`
+    const kind = TIER_WORD[value.tier ?? 'stable'] ?? TIER_WORD.stable
+    const pin = value.pin === true ? '、已 pin' : ''
+    const warn = value.warning ? `\n注意：${value.warning}` : ''
+    return `已写下（${kind}${pin}）。现在生效 ${value.entries} 条 / ${value.chars} 字${tail}。${warn}`
   }
   if (value.action === 'read') {
     if (value.entries === 0) return '还没有任何自述。'
@@ -1769,15 +1990,18 @@ export function apply(ctx, config) {
           if (action === 'write') {
             const text = String(args?.text ?? '').trim()
             if (text === '') return { action, error: 'text 不能为空' }
-            const result = appendNote(text, limits)
+            const result = appendNote(text, limits, { tier: args?.tier, pin: args?.pin })
             const after = stats()
             return {
               action,
               text,
+              tier: result.tier,
+              pin: result.pin,
               entries: after.entries,
               chars: after.chars,
               archived: result.archived,
               archivedFile: result.archivedFile || '',
+              warning: noteCapacityWarning(result.tier, text, inline),
             }
           }
           if (action === 'read') {
@@ -2008,6 +2232,13 @@ export function apply(ctx, config) {
                 }
                 next.profileMaxChars = Math.round(value)
               }
+              if (body.tempTtlDays !== undefined) {
+                const value = Number(body.tempTtlDays)
+                if (!Number.isFinite(value) || value < 1 || value > 90) {
+                  return sendJson(res, 400, { ok: false, error: 'tempTtlDays 要在 1–90 天之间' })
+                }
+                next.tempTtlDays = Math.round(value)
+              }
               writeConfig(next)
               return sendJson(res, 200, stateOf(inline))
             }
@@ -2015,15 +2246,30 @@ export function apply(ctx, config) {
               const body = await readBody(req)
               const text = typeof body?.text === 'string' ? body.text.trim() : ''
               if (text === '') return sendJson(res, 400, { ok: false, error: '内容不能为空' })
-              appendNote(text, limitsOf(currentConfig(inline)))
-              return sendJson(res, 200, stateOf(inline))
+              const result = appendNote(text, limitsOf(currentConfig(inline)), { tier: body?.tier, pin: body?.pin })
+              auditAction('note-add', { tier: result.tier, pin: result.pin, chars: text.length }, req)
+              return sendJson(res, 200, {
+                ...stateOf(inline),
+                noteAdd: { tier: result.tier, pin: result.pin, warning: noteCapacityWarning(result.tier, text, inline) },
+              })
+            }
+            // 只改类型 / pin：把一条人格自述标成「核心身份」，就是这个接口
+            if (req.method === 'POST' && route === '/note/meta') {
+              const body = await readBody(req)
+              try {
+                const result = setNoteMeta(body?.index, { tier: body?.tier, pin: body?.pin })
+                auditAction('note-meta', { index: body?.index, tier: result.tier, pin: result.pin }, req)
+                return sendJson(res, 200, { ...stateOf(inline), noteMeta: result })
+              } catch (error) {
+                return sendJson(res, 400, { ok: false, error: error?.message ?? String(error) })
+              }
             }
             // 改一条 / 删一条。0.11.x 之前只有「追加」和「整份清空」：
             // 注入里出现一句话说错了，只能整份清掉重写 —— 这就是「看得见、改不掉」。
             if (req.method === 'POST' && route === '/note/update') {
               const body = await readBody(req)
               try {
-                const result = updateNote(body?.index, body?.text, limitsOf(currentConfig(inline)))
+                const result = updateNote(body?.index, body?.text, limitsOf(currentConfig(inline)), { tier: body?.tier, pin: body?.pin })
                 auditAction('note-update', { index: body?.index, archived: result.archived }, req)
                 return sendJson(res, 200, { ...stateOf(inline), noteUpdate: result })
               } catch (error) {
@@ -2209,12 +2455,14 @@ export function apply(ctx, config) {
   /* ---- 自动采集（P1-B）：只发现，不确认 ---- */
   // session/event 是 fire-and-forget：这里绝不能把异常抛回宿主，也不能阻塞对话
   if (typeof ctx?.on === 'function') {
+    captureDebug.since = new Date().toISOString()
     const offCapture = ctx.on('session/event', (session, event) => {
-      captureDebug.events += 1
-      captureDebug.lastType = event?.type ?? null
-      captureDebug.lastKeys = event !== null && typeof event === 'object' ? Object.keys(event).slice(0, 12) : null
+      const type = noteCaptureEvent(session?.id, event)
       const sessionId = session?.id
-      if (typeof sessionId !== 'string' || sessionId === '') return
+      if (typeof sessionId !== 'string' || sessionId === '') {
+        noteCaptureOutcome('no-session')
+        return
+      }
       // 压缩发生了就记一笔：下一轮把这个会话用过的记忆再贴一遍
       noteCompaction(session, event)
       // 同一会话按到达顺序串行，避免 seq=11 先完成把游标推到 11、把 seq=10 挤掉
@@ -2229,17 +2477,20 @@ export function apply(ctx, config) {
       )
         .then((result) => {
           captureDebug.candidates += result?.plan?.created?.length ?? 0
-          if (result?.handled === true) {
+          const written = result?.handled === true
+          if (written) {
             captureDebug.written += 1
             const plan = result.plan ?? {}
             ctx.logger?.info?.(
               `selfnote: 采集到 ${plan.created?.length ?? 0} 条候选（合并 ${plan.merged?.length ?? 0}，冲突 ${plan.conflicts?.length ?? 0}）`,
             )
           }
+          noteCaptureOutcome(written ? 'written' : String(result?.reason ?? type + ':unknown'))
         })
         .catch((error) => {
           // 采集坏掉不许影响对话
           captureDebug.lastError = String(error?.message ?? error)
+          noteCaptureOutcome('error')
           ctx.logger?.warn?.('selfnote: 自动采集失败 ' + String(error?.message ?? error))
         })
     })

package/lib/store.js

@@ -21,6 +21,49 @@ export const DEFAULT_MAX_ENTRIES = 40
 /** 单条自述的硬上限，防止一次写入撑爆。 */
 export const MAX_ENTRY_CHARS = 600
 
+/**
+ * 自述分三型。混在一起装的时候，人格和「今晚推个提醒」抢同一份预算，
+ * 抢输的永远是人味那一条 —— 所以分开排：
+ *   core   核心身份（人格、长期身份、基本原则），先装，独立配额
+ *   stable 稳定偏好（语言、表达习惯、工作偏好），按 pin → 时间
+ *   temp   临时自述（当前阶段的目标、近期变化），最后装，时间倒序
+ */
+export const NOTE_TIERS = ['core', 'stable', 'temp']
+/** 类型在 notes.md 里写成中文：人打开文件看得懂、改得动，不用查代码。 */
+export const TIER_TAG = { core: '核心', stable: '稳定', temp: '临时' }
+const TAG_TO_TIER = { 核心: 'core', 稳定: 'stable', 临时: 'temp' }
+/** 没打标记的按「稳定」算：存量条目零迁移，行为跟改版前一模一样。 */
+export const DEFAULT_TIER = 'stable'
+
+/**
+ * 临时自述的保质期（天）。过了就不再每回合自动在场 —— 只留在库里，等人自己翻，
+ * 这样「这周在弄什么」不会一直跟人格抢预算。核心与稳定型永不到期。
+ */
+export const DEFAULT_TEMP_TTL_DAYS = 14
+
+/**
+ * 一条自述到期没有。
+ * date 只有「年月日」（没有时刻），按当天零点算；正好第 N 天还在保质期内，
+ * 免得写出「今天刚写、明天就过期」这种一日游。
+ */
+export function isExpiredNote(entry, ttlDays = DEFAULT_TEMP_TTL_DAYS, now = Date.now()) {
+  if (normalizeTier(entry?.tier) !== 'temp') return false
+  const raw = typeof entry?.date === 'string' ? entry.date.trim() : ''
+  const at = Date.parse(`${raw}T00:00:00`)
+  if (!Number.isFinite(at)) return false
+  const days = Number.isFinite(Number(ttlDays)) ? Math.max(1, Math.round(Number(ttlDays))) : DEFAULT_TEMP_TTL_DAYS
+  return now - at > days * 86400000
+}
+
+/** 把外部传进来的 tier 收成合法值，认不出就是默认型（不抛错 —— 别为了个标记把写自述弄失败）。 */
+export function normalizeTier(value) {
+  if (typeof value !== 'string') return DEFAULT_TIER
+  const raw = value.trim().toLowerCase()
+  if (NOTE_TIERS.includes(raw)) return raw
+  // 也认中文写法，方便人直接对着接口手搓
+  return TAG_TO_TIER[raw] ?? TAG_TO_TIER[value.trim()] ?? DEFAULT_TIER
+}
+
 function dshHome() {
   const fromEnv = typeof process.env.DSH_HOME === 'string' ? process.env.DSH_HOME.trim() : ''
   return fromEnv.length > 0 ? fromEnv : join(homedir(), '.dsh')
@@ -49,17 +92,38 @@ export function today() {
   return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`
 }
 
-/** 把 notes.md 解析成 [{ date, text }]，忽略空行与注释。 */
+/** 正文归一：回车换行压成空格、去掉首尾空白、截到硬上限。 */
+function cleanEntryText(text) {
+  return String(text ?? '').replace(/\s+/g, ' ').trim().slice(0, MAX_ENTRY_CHARS)
+}
+
+/**
+ * 把 notes.md 解析成 [{ date, text, tier, pin }]，忽略空行与注释。
+ * 行格式：`- 2026-11-04 [核心*] 正文` —— 日期可省、标记可省、`*` 表示 pin。
+ * 标记认不出就原样留在正文里：宁可多显示一个怪括号，也不能吞掉人写的内容。
+ */
 export function parseNotes(raw) {
   const out = []
   for (const line of String(raw ?? '').split(/\r?\n/)) {
     const trimmed = line.trim()
     if (trimmed === '' || trimmed.startsWith('#')) continue
-    const m = trimmed.match(/^[-*]\s+(\d{4}-\d{2}-\d{2})?\s*(.*)$/)
+    const m = trimmed.match(/^[-*]\s+(\d{4}-\d{2}-\d{2})?\s*(?:\[([^\]]{1,8})\]\s*)?(.*)$/)
     if (!m) continue
-    const text = (m[2] ?? '').trim()
+    let text = (m[3] ?? '').trim()
+    let tier = DEFAULT_TIER
+    let pin = false
+    const tag = (m[2] ?? '').trim()
+    if (tag !== '') {
+      const hit = tag.match(/^(核心|稳定|临时)\s*(\*)?$/)
+      if (hit) {
+        tier = TAG_TO_TIER[hit[1]]
+        pin = hit[2] === '*'
+      } else {
+        text = `[${tag}] ${text}`.trim()
+      }
+    }
     if (text === '') continue
-    out.push({ date: m[1] ?? '', text })
+    out.push({ date: m[1] ?? '', text, tier, pin })
   }
   return out
 }
@@ -71,9 +135,20 @@ export function readNotes() {
   return parseNotes(readFileSync(file, 'utf8'))
 }
 
+/**
+ * 标记只在「非默认」时才写出来：稳定型且没 pin 的条目不带前缀，
+ * 存量 notes.md 不会因为升级平白多出一堆 `[稳定]`。
+ */
+function tagOf(entry) {
+  const tier = normalizeTier(entry?.tier)
+  const pin = entry?.pin === true
+  if (tier === DEFAULT_TIER && !pin) return ''
+  return `[${TIER_TAG[tier]}${pin ? '*' : ''}] `
+}
+
 /** 渲染成注入/展示用的文本（最新在后）。 */
 export function renderNotes(entries) {
-  return entries.map((entry) => `- ${entry.date ? `${entry.date} ` : ''}${entry.text}`).join('\n')
+  return entries.map((entry) => `- ${entry.date ? `${entry.date} ` : ''}${tagOf(entry)}${entry.text}`).join('\n')
 }
 
 /** 写回当前生效的自述（整份重写，内容不超过上限）。 */
@@ -114,18 +189,19 @@ export function archive(entries) {
 }
 
 /** 追加一条自述并裁剪归档。返回 { kept, archived, notesFile }。 */
-export function appendNote(text, limits) {
-  const clean = String(text ?? '').replace(/\s+/g, ' ').trim().slice(0, MAX_ENTRY_CHARS)
+export function appendNote(text, limits, meta = {}) {
+  const clean = cleanEntryText(text)
   if (clean === '') throw new Error('自述内容不能为空')
   const entries = readNotes()
-  entries.push({ date: today(), text: clean })
+  const entry = { date: today(), text: clean, tier: normalizeTier(meta.tier), pin: meta.pin === true }
+  entries.push(entry)
   const { kept, overflow } = trim(entries, limits)
   // 先归档、再改 notes.md：反过来的话，归档一抛错（磁盘满、被占用），
   // 被挤出预算的那几条既已从 notes.md 消失、又没进归档，等于静默丢掉。
   // 万一 notes.md 写失败，最坏是归档里有重复，还能人工删 —— 丢内容没法补。
   const archivedFile = archive(overflow)
   writeNotes(kept)
-  return { kept: kept.length, archived: overflow.length, archivedFile, notesFile: notesPath() }
+  return { kept: kept.length, archived: overflow.length, archivedFile, notesFile: notesPath(), tier: entry.tier, pin: entry.pin }
 }
 
 /**
@@ -133,21 +209,53 @@ export function appendNote(text, limits) {
  * 日期保留原样：改的是措辞，不是「今天又写了一条」。
  * 改长了照样按容量裁剪，被挤出去的进归档 —— 和追加走同一条规则。
  */
-export function updateNote(index, text, limits) {
+export function updateNote(index, text, limits, meta = {}) {
   const entries = readNotes()
   const at = Number(index)
   if (!Number.isInteger(at) || at < 0 || at >= entries.length) {
     // 列表可能是几秒前拉的：给一句能照着做的话，而不是「非法参数」
     throw new Error('没有这一条了（可能刚被改过），刷新一下再试')
   }
-  const clean = String(text ?? '').replace(/\s+/g, ' ').trim().slice(0, MAX_ENTRY_CHARS)
+  const clean = cleanEntryText(text)
   if (clean === '') throw new Error('自述内容不能为空')
-  if (clean === entries[at].text) return { kept: entries.length, archived: 0, unchanged: true, notesFile: notesPath() }
-  entries[at] = { date: entries[at].date || today(), text: clean }
+  const prev = entries[at]
+  const next = {
+    date: prev.date || today(),
+    text: clean,
+    // meta 没传 = 保留原来那个型，别偷偷把一条核心身份降级成临时
+    tier: meta.tier === undefined ? normalizeTier(prev.tier) : normalizeTier(meta.tier),
+    pin: meta.pin === undefined ? prev.pin === true : meta.pin === true,
+  }
+  if (next.text === prev.text && next.tier === normalizeTier(prev.tier) && next.pin === (prev.pin === true)) {
+    return { kept: entries.length, archived: 0, unchanged: true, notesFile: notesPath() }
+  }
+  entries[at] = next
   const { kept, overflow } = trim(entries, limits)
   const archivedFile = archive(overflow)
   writeNotes(kept)
-  return { kept: kept.length, archived: overflow.length, archivedFile, unchanged: false, notesFile: notesPath() }
+  return { kept: kept.length, archived: overflow.length, archivedFile, unchanged: false, notesFile: notesPath(), tier: next.tier, pin: next.pin }
+}
+
+/**
+ * 只改一条的类型 / pin，不动正文。设置页上「把这条设成核心身份」就是这个接口。
+ * 不走 trim：标记只多几个字，为这点长度把一条旧自述挤进归档不值当。
+ */
+export function setNoteMeta(index, meta = {}) {
+  const entries = readNotes()
+  const at = Number(index)
+  if (!Number.isInteger(at) || at < 0 || at >= entries.length) {
+    throw new Error('没有这一条了（可能刚被改过），刷新一下再试')
+  }
+  const prev = entries[at]
+  const next = {
+    date: prev.date,
+    text: prev.text,
+    tier: meta.tier === undefined ? normalizeTier(prev.tier) : normalizeTier(meta.tier),
+    pin: meta.pin === undefined ? prev.pin === true : meta.pin === true,
+  }
+  entries[at] = next
+  writeNotes(entries)
+  return { kept: entries.length, tier: next.tier, pin: next.pin, notesFile: notesPath() }
 }
 
 /** 删一条：先归档再摘除，删掉的东西仍然找得回来（archive/YYYY-MM.md）。 */
@@ -163,6 +271,13 @@ export function deleteNote(index) {
   return { kept: entries.length, removed: dropped, archivedFile, notesFile: notesPath() }
 }
 
+/** 三型各几条。 */
+export function countTiers(entries) {
+  const out = { core: 0, stable: 0, temp: 0 }
+  for (const entry of entries) out[normalizeTier(entry.tier)] += 1
+  return out
+}
+
 /** 统计：生效条数、字符数、归档文件数。 */
 export function stats() {
   const entries = readNotes()
@@ -176,6 +291,9 @@ export function stats() {
   return {
     entries: entries.length,
     chars: renderNotes(entries).length,
+    // 三型各几条：设置页要能解释「为什么我这条没进上下文」
+    tiers: countTiers(entries),
+    pinned: entries.filter((entry) => entry.pin === true).length,
     archiveFiles,
     notesFile: notesPath(),
     // 上次真正写进 notes.md 的时刻：条目里只存日期（YYYY-MM-DD），看不出「几小时前」，

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-selfnote",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "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/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/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/client-state.mjs && node tests/client.mjs",
     "test:accept": "node tests/acceptance-runtime.mjs"
   },
   "engines": {