@a9i5k4/dsh-auto-memory 3.0.0 → 3.1.0

package/lib/skill-export.js

@@ -0,0 +1,239 @@
+/**
+ * M9-3 Skill 导出层（procedure → SKILL.md 目录束）。
+ *
+ * ★ 2026-09-19 用户拍板（三项）：
+ *   ⑪-1 形态：`SKILL.md` + **附上过程中用到的程序**（如 `.py`），且 SKILL.md 里
+ *        必须明写：这些程序**只是参考性的** —— 若当前做的事情与之前**根本不同**，
+ *        可以用来**迁移**，**不能直接运行**。
+ *   ⑪-2 时机：**晋升为 `active` 后自动导出**。
+ *   ⑪-3 目录：**用户级**（软件层面，可跨项目迁移）；但导出物**必须标注适用于哪个项目**，
+ *        项目不一样时**只作参考，不能直接用**。
+ *
+ * 本模块是**纯渲染层**（无 IO、无状态），便于直接单测：
+ *   - `renderSkillMarkdownPre(procedure, opts)` → SKILL.md 文本
+ *   - `skillDirNamePre(procedure)` → 目录名（稳定、可预测）
+ *   - `SKILL_USAGE_NOTICE_V1` → 使用约束条款（导出物必须原样包含）
+ *
+ * 设计纪律（与 procedure 引擎同源）：
+ *   ① **不新增状态源** —— 导出物是 procedure 的**派生物**，不是新的事实来源；
+ *   ② **不自动执行任何导出的程序** —— 程序是**参考资料**，不是可调用入口；
+ *   ③ 全部 fail-soft，但**返回可观察结果**（ok/reason），不静默。
+ */
+
+// ★ T7-b（2026-09-20）：纯计算依赖，用于给「纯中文标题」生成稳定的 ASCII 目录名。
+//   node 内建模块，不引入外部依赖、不做 IO、不持有状态 —— 与本模块「纯渲染层」定位不冲突。
+import { createHash } from 'node:crypto'
+
+/** 导出物的使用约束条款 —— **必须原样出现在每个 SKILL.md 中**（用户 ⑪-1 硬要求）。 */
+export const SKILL_USAGE_NOTICE_V1 = [
+  '> **⚠️ 使用约束（必读）**',
+  '>',
+  '> 本技能由 **dsh-auto-memory** 从一次真实工作过程**自动沉淀**而来，**不是通用最佳实践**。',
+  '>',
+  '> 1. **附带程序仅供参考**：本目录下的脚本（如 `.py`）是**当时那次工作用过的程序**，',
+  '>    **不是可直接调用的工具**。它们可能依赖当时的路径、环境变量、数据格式或版本。',
+  '> 2. **场景根本不同时 → 只做迁移，不要直接运行**：若当前任务与下方「来源」描述的场景',
+  '>    **有根本差异**，请把附带的程序**当作思路参考**，按当前场景**重写**，而不是直接执行。',
+  '> 3. **跨项目使用须先核对**：本技能的「适用项目」若与当前项目**不一致**，',
+  '>    **一律只作参考**，不得直接套用其路径、命令与判据。',
+  '> 4. **高风险步骤需人工确认**：涉及删除、发布、付费、外部发送等动作，必须先向用户复述确认。',
+].join('\n')
+
+/** SKILL.md 中必须出现的约束锚点（供套件断言，防止被后续改动悄悄删掉）。 */
+export const SKILL_NOTICE_ANCHORS_V1 = Object.freeze([
+  '使用约束（必读）',
+  '附带程序仅供参考',
+  '只做迁移，不要直接运行',
+  '跨项目使用须先核对',
+  '高风险步骤需人工确认',
+])
+
+const MAX_TITLE_LEN = 80
+
+/**
+ * 目录名 / `name:` 字段：`mem-skill-<slug>-<procId前12位>` —— 稳定、可预测、不冲突。
+ *
+ * ★ T7-b（2026-09-20 用户报「所有中文技能都叫 untitled」）修复：
+ *   **根因**：原实现 `title.replace(/[^a-z0-9]+/g,'-')` 只保留 ASCII ⇒ **纯中文标题 slug 成空串**
+ *   ⇒ 一律回落字面量 `'untitled'`。后果是每个中文技能都叫 `mem-skill-untitled-<id>`，
+ *   用户看到的技能列表名字毫无意义（实测：本机导出的
+ *   `~/.dsh/skills/mem-skill-untitled-aa2153f33507/SKILL.md`）。
+ *
+ *   **为什么不能用「保留中文」这个修法**：DSH 宿主对 skill name 是**硬校验**，不是建议 ——
+ *   `SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/`（宿主 `index.js:17`），且
+ *   `:481` 直接 `throw new Error('loaded skill has invalid name "…"')`。
+ *   ⇒ 中文进 name 会让**技能加载直接失败**（比 untitled 更糟）。故必须产出 ASCII 安全名。
+ *
+ *   **采用的修法**：slug 为空时，取标题的 **sha1 前 8 位十六进制**做 `t-<hash>` 前缀。
+ *   - ASCII 安全：`t-1a2b3c4d` 完全符合上面的 SKILL_NAME 正则；
+ *   - 稳定：同一 title ⇒ 同一 hash ⇒ 目录名不变（自动化重导出不会产生新目录）；
+ *   - 可区分：不同标题 hash 不同，不再出现「一堆 untitled」；
+ *   - 中文原文**不丢**：仍完整出现在 SKILL.md 的 `# <title>` 与 `description` 里，
+ *     用户/模型在技能列表看到的是中文标题，name 只承担「唯一标识」职责。
+ *
+ *   ⚠️ 哈希算法用 node 内建 `createHash('sha1')`（纯计算，不引入 IO/状态），
+ *   与 FNV-1a 那种"自造哈希"区分开 —— 本仓有过 sha256Hex 同名异义的教训（#86-1）。
+ */
+export function skillDirNamePre(procedure) {
+  const id = String((procedure && procedure.procedureId) || '')
+  const short = id.replace(/^proc_/, '').slice(0, 12)
+  const title = String((procedure && procedure.title) || '')
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40)
+  // 纯中文（或纯符号）标题：ASCII slug 为空 ⇒ 用标题哈希代替，绝不留 'untitled'
+  const stem = slug || ('t-' + createHash('sha1').update(title, 'utf8').digest('hex').slice(0, 8))
+  return 'mem-skill-' + stem + '-' + (short || 'noid')
+}
+
+/** 一句话摘要（取步骤首条或标题）——用于 SKILL.md 的 description。 */
+/**
+ * 一句话摘要 —— 用于 SKILL.md 的 `description:` 字段。
+ *
+ * ★ T7-b（2026-09-20）修正取值优先级：**title 优先，steps[0] 兜底**（原来是反的）。
+ *   为什么反了不行：`description` 是模型在技能目录里看到的那句话，应当回答
+ *   「这个技能**是干什么的**」—— title 正是这件事；而 steps[0] 是**第一个动作**
+ *   （实测导出的描述成了「备份：Copy-Item lib/index.js …」，完全看不出技能用途）。
+ *   仅当 title 缺失时才用 steps[0] 兜底（此时有总比没有好）。
+ */
+function summaryOfPre(p) {
+  const t = String(p.title || '').trim()
+  const step = Array.isArray(p.steps) && p.steps.length ? String(p.steps[0]).trim() : ''
+  const s = t || step
+  return s.length > MAX_TITLE_LEN ? s.slice(0, MAX_TITLE_LEN - 1) + '…' : s
+}
+
+/**
+ * 渲染 SKILL.md。
+ *
+ * @param {object} procedure  procedure 记录（stage 应为 active）
+ * @param {object} opts
+ * @param {string} opts.projectName   适用项目名（**必填**，⑪-3）
+ * @param {string} opts.projectPath   项目根绝对路径（用于溯源）
+ * @param {string[]} opts.programs     附带程序文件名列表（⑪-1，仅列名）
+ * @param {string} opts.exportedAt    导出时间（ISO 字符串；缺省由调用方给）
+ * @returns {{ok:true, fileName:string, dirName:string, content:string} | {ok:false, reason:string}}
+ */
+export function renderSkillMarkdownPre(procedure, opts = {}) {
+  const p = procedure || {}
+  if (!p.procedureId) return { ok: false, reason: 'no-procedure-id' }
+  if (!p.title) return { ok: false, reason: 'no-title' }
+  const projectName = String(opts.projectName || '').trim()
+  if (!projectName) return { ok: false, reason: 'no-project-name' }   // ⑪-3 硬要求：必须标项目
+  const projectPath = String(opts.projectPath || '').trim()
+  const programs = Array.isArray(opts.programs) ? opts.programs.filter(Boolean).map(String) : []
+  const exportedAt = String(opts.exportedAt || '')
+
+  const L = []
+  L.push('---')
+  L.push('name: ' + skillDirNamePre(p))
+  L.push('description: ' + summaryOfPre(p).replace(/\r?\n/g, ' '))
+  L.push('---')
+  L.push('')
+  L.push('# ' + String(p.title).trim())
+  L.push('')
+  L.push(SKILL_USAGE_NOTICE_V1)
+  L.push('')
+
+  // ── 来源（⑪-3：必须标注适用于哪个项目）──
+  L.push('## 来源')
+  L.push('')
+  L.push('- **适用项目**：`' + projectName + '`' + (projectPath ? '（`' + projectPath + '`）' : ''))
+  L.push('- **沉淀自**：dsh-auto-memory 技能库（procedure `' + p.procedureId + '`）')
+  if (p.riskLevel) L.push('- **风险等级**：`' + p.riskLevel + '`' + (p.requiresApproval ? '（需人工批准）' : ''))
+  if (exportedAt) L.push('- **导出时间**：' + exportedAt)
+  L.push('')
+  L.push('> 若你的当前项目**不是** `' + projectName + '`，请**只作参考**，不要直接套用下方路径与命令。')
+  L.push('')
+
+  // ── 适用条件 ──
+  if (Array.isArray(p.preconditions) && p.preconditions.length) {
+    L.push('## 何时适用')
+    L.push('')
+    for (const x of p.preconditions) L.push('- ' + String(x))
+    L.push('')
+  }
+
+  // ── 步骤 ──
+  if (Array.isArray(p.steps) && p.steps.length) {
+    L.push('## 步骤')
+    L.push('')
+    p.steps.forEach((s, i) => L.push(String(i + 1) + '. ' + String(s)))
+    L.push('')
+  }
+
+  // ── 检查点 ──
+  if (Array.isArray(p.checks) && p.checks.length) {
+    L.push('## 检查点')
+    L.push('')
+    for (const x of p.checks) L.push('- [ ] ' + String(x))
+    L.push('')
+  }
+
+  // ── 成功判据 ──
+  if (Array.isArray(p.successCriteria) && p.successCriteria.length) {
+    L.push('## 成功判据')
+    L.push('')
+    for (const x of p.successCriteria) L.push('- ' + String(x))
+    L.push('')
+  }
+
+  // ── 回滚 ──
+  if (Array.isArray(p.rollback) && p.rollback.length) {
+    L.push('## 回滚')
+    L.push('')
+    for (const x of p.rollback) L.push('- ' + String(x))
+    L.push('')
+  }
+
+  // ── 附带程序（⑪-1）──
+  if (programs.length) {
+    L.push('## 附带程序（**参考性**）')
+    L.push('')
+    L.push('以下文件是**当时那次工作用过的程序**，随本技能一起导出：')
+    L.push('')
+    for (const f of programs) L.push('- `' + f + '`')
+    L.push('')
+    L.push('> **不要直接运行**。先读一遍，判断它与当前场景的差异；')
+    L.push('> 若场景根本不同，请**按当前场景迁移重写**；确需运行时，先向用户说明并确认。')
+    L.push('')
+  }
+
+  // ── 证据 ──
+  if (Array.isArray(p.sourceEpisodes) && p.sourceEpisodes.length) {
+    L.push('## 依据')
+    L.push('')
+    L.push('- 来源 episode 数：' + p.sourceEpisodes.length)
+    if (p.evidence && typeof p.evidence === 'object') {
+      const ev = p.evidence
+      const parts = []
+      if (Number.isFinite(ev.seen)) parts.push('seen=' + ev.seen)
+      if (Number.isFinite(ev.success)) parts.push('success=' + ev.success)
+      if (Number.isFinite(ev.correction)) parts.push('correction=' + ev.correction)
+      if (parts.length) L.push('- 证据统计：' + parts.join(' / '))
+    }
+    L.push('')
+  }
+
+  return { ok: true, fileName: 'SKILL.md', dirName: skillDirNamePre(p), content: L.join('\n') + '\n' }
+}
+
+/**
+ * 导出完整性校验（供套件与调用方共用）。
+ * **判据是"用户 ⑪-1/⑪-3 的硬要求"本身**，不是实现细节。
+ */
+export function validateSkillMarkdownPre(content, expect = {}) {
+  const s = String(content == null ? '' : content)
+  const problems = []
+  if (!s.trim()) problems.push('empty')
+  for (const a of SKILL_NOTICE_ANCHORS_V1) if (!s.includes(a)) problems.push('missing-notice:' + a)
+  if (!/^---\r?\n[\s\S]*?\r?\n---/.test(s)) problems.push('no-frontmatter')
+  if (!/^name:\s*\S+/m.test(s)) problems.push('no-name')
+  if (!/^description:\s*\S+/m.test(s)) problems.push('no-description')
+  if (expect.projectName && !s.includes('`' + expect.projectName + '`')) problems.push('no-project-tag')
+  // ⑪-1：附带程序必须被运行约束**包裹**，而不是只列个名。
+  // ★ 判据必须锚定属于「程序块」的形态：
+  //   顶层约束条款里也出现「不要直接运行」四字（后接 `**：`），
+  //   只用该四字做判据会**同义反复**（永远为真）——套件 [5] 组已实跑抓到这一版缺陷。
+  //   程序块独有形态 = 加粗短语**后紧跟句号**：`**不要直接运行**。`
+  if (expect.hasPrograms && !/\*\*不要直接运行\*\*。/.test(s)) problems.push('programs-not-constrained')
+  return { ok: problems.length === 0, problems }
+}

package/lib/storage-manage.js

@@ -116,6 +116,12 @@ export function createStorageManagerPre(opts = {}) {
   /** 读取既有 sidecar(尽力而为):用于 rebuildSidecar 继承 epoch/version,避免无谓的 epoch 漂移。 */
   function readSidecarPrev(file) {
     try {
+      // ★ issue #55 修复（2026-09-18，2026-09-19 补回）：函数体内**自行活读** docStore。
+      //   旧写法直接引用闭包里的 `docStore`，但该名只在 `repair`/`deleteMemory` 内部局部声明
+      //   ⇒ 本函数作用域内**未定义** ⇒ 每次调用抛 ReferenceError ⇒ 被下方 `catch (_)` 吞掉
+      //   ⇒ **恒返回 null** ⇒ `rebuildSidecar` 拿不到 prev ⇒ epoch 漂移、fresh 被翻成 stale。
+      //   必须走 `docStoreOf()` 工厂活读（getter 语义：memoryAnchorEnabled 后续生效也能拿到）。
+      const docStore = docStoreOf()
       if (!docStore || typeof docStore.sidecarPath !== 'function') return null
       const sp = docStore.sidecarPath(file)
       if (!sp) return null

package/lib/temporal-parse.js

@@ -1,159 +1,191 @@
-/**
- * temporal-parse-pre —— 中文时间表达解析(P12 后新增时间检索臂 Phase 1, 2026-09-09)。
- *
- * 目标:把查询里的中文时间表达("上周""三天前""最近一周""上个月"等)解析为
- * [startMs, endMs) 时间范围,供检索的软性第三臂(time arm)做 rank-space 提升。
- * 查询无时间表达 → 返回 null → 调用方零行为变更。
- *
- * 边界:纯函数、零 IO、零依赖;禁止 LLM/第三方日期库;确定性(同输入同 now 逐字节相同输出)。
- * 时刻必须经 opts.now 注入(缺省 Date.now() 仅为便利;测试一律注入)。
- *
- * 时区假设(显式声明):全部自然日/周/月/年边界用宿主**本地时间**计算
- * (new Date(y,m,d) 系列本地方法)。部署机时区为 Asia/Shanghai(CST,UTC+8,无夏令时),
- * 与记忆日志文件名日期(本地日期)一致;若部署到其他时区,范围语义跟随宿主本地时区。
- */
-
-/** 中文数字表(支持零〇一二两三四五六七八九十百,≤999,够 366 上限)。 */
-const CN_DIGIT = { '零': 0, '〇': 0, '一': 1, '二': 2, '两': 2, '三': 3, '四': 4, '五': 5, '六': 6, '七': 7, '八': 8, '九': 9 }
-
-/** N 的合法区间(含端点);超界视为未识别。 */
-const N_MIN = 1
-const N_MAX = 366
-
-const DAY_MS = 86400000
-
-/** 中文/阿拉伯数字 → 整数;非法返回 NaN。 */
-function numToInt(s) {
-  if (/^\d{1,3}$/.test(s)) return parseInt(s, 10)
-  let total = 0
-  let num = 0
-  for (const ch of String(s)) {
-    if (ch === '十') { total += (num || 1) * 10; num = 0 }
-    else if (ch === '百') { total += (num || 1) * 100; num = 0 }
-    else if (ch === '零' || ch === '〇') { /* 占位,跳过 */ }
-    else if (CN_DIGIT[ch] !== undefined) { num = CN_DIGIT[ch] }
-    else return NaN
-  }
-  const out = total + num
-  return out > 0 ? out : NaN
-}
-
-/** 本地自然日 00:00 的毫秒时间戳。 */
-function startOfDay(d) {
-  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime()
-}
-
-/** 本地自然周(周一 00:00 起)的毫秒时间戳。 */
-function startOfWeek(d) {
-  const monday = new Date(d.getFullYear(), d.getMonth(), d.getDate())
-  monday.setDate(monday.getDate() - ((monday.getDay() + 6) % 7))
-  return monday.getTime()
-}
-
-/** 本地自然月 1 日 00:00 的毫秒时间戳。 */
-function startOfMonth(d) {
-  return new Date(d.getFullYear(), d.getMonth(), 1).getTime()
-}
-
-/** 按本地月序号(可为负,自动借位)取自然月起点。 */
-function monthStartShift(d, shift) {
-  return new Date(d.getFullYear(), d.getMonth() + shift, 1).getTime()
-}
-
-/** 从 d 往前/后 n 个日历月,锚定同一日与时分秒(月末溢出由 Date 自动进位,确定性)。 */
-function nowShiftMonths(d, n) {
-  return new Date(d.getFullYear(), d.getMonth() + n, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()).getTime()
-}
-
-/** 日期 d 所在月的下个月起点。 */
-function nextMonthStart(d) {
-  return new Date(d.getFullYear(), d.getMonth() + 1, 1).getTime()
-}
-
-/**
- * 解析查询文本中的中文时间表达。
- *
- * @param {string} text 查询文本
- * @param {{now?:number}} [opts] now:毫秒时间戳(注入以保证确定性;缺省 Date.now())
- * @returns {null | {startMs:number, endMs:number, matched:string}}
- *   null=未识别到时间表达(调用方零行为变更);否则为半开区间 [startMs, endMs)
- *   与命中的原文子串 matched。多个表达命中时取**首个**(按下方模式表顺序,确定性)。
- */
-export function parseTemporalQueryPre(text, opts = {}) {
-  try {
-    if (typeof text !== 'string' || !text) return null
-    const nowMs = Number.isFinite(opts.now) ? opts.now : Date.now()
-    const now = new Date(nowMs)
-    const today0 = startOfDay(now)
-    // 模式表(顺序即优先级:长/特异表达在前,防止子串误配,如"大前天"先于"前天"、"上上周"先于"上周")
-    const patterns = [
-      { re: /大前天/, fn: () => ({ startMs: today0 - 3 * DAY_MS, endMs: today0 - 2 * DAY_MS }) },
-      { re: /前天/, fn: () => ({ startMs: today0 - 2 * DAY_MS, endMs: today0 - DAY_MS }) },
-      { re: /昨天/, fn: () => ({ startMs: today0 - DAY_MS, endMs: today0 }) },
-      { re: /今天/, fn: () => ({ startMs: today0, endMs: today0 + DAY_MS }) },
-      { re: /上上周/, fn: () => ({ startMs: startOfWeek(now) - 14 * DAY_MS, endMs: startOfWeek(now) - 7 * DAY_MS }) },
-      { re: /上周/, fn: () => ({ startMs: startOfWeek(now) - 7 * DAY_MS, endMs: startOfWeek(now) }) },
-      { re: /本周|这一周|这个星期/, fn: () => ({ startMs: startOfWeek(now), endMs: startOfWeek(now) + 7 * DAY_MS }) },
-      { re: /上个月|上月/, fn: () => ({ startMs: monthStartShift(now, -1), endMs: startOfMonth(now) }) },
-      { re: /本月|这个月/, fn: () => ({ startMs: startOfMonth(now), endMs: nextMonthStart(now) }) },
-      { re: /去年/, fn: () => ({ startMs: new Date(now.getFullYear() - 1, 0, 1).getTime(), endMs: new Date(now.getFullYear(), 0, 1).getTime() }) },
-      { re: /今年/, fn: () => ({ startMs: new Date(now.getFullYear(), 0, 1).getTime(), endMs: new Date(now.getFullYear() + 1, 0, 1).getTime() }) },
-      // 最近 N 个自然周期:从 now 往前 N 个周期(半开区间 [now-N周期, now));月按日历月锚定 now 时刻
-      { re: /最近\s*([0-9零〇一二两三四五六七八九十百]+)\s*个?\s*月/, fn: (m) => {
-          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
-          return { startMs: nowShiftMonths(now, -n), endMs: nowMs }
-        } },
-      { re: /最近\s*([0-9零〇一二两三四五六七八九十百]+)\s*个?\s*(?:星期|周)/, fn: (m) => {
-          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
-          return { startMs: nowMs - n * 7 * DAY_MS, endMs: nowMs }
-        } },
-      { re: /最近\s*([0-9零〇一二两三四五六七八九十百]+)\s*(?:天|日)/, fn: (m) => {
-          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
-          return { startMs: nowMs - n * DAY_MS, endMs: nowMs }
-        } },
-      // N 个月前:定位到那个自然月(整月)
-      { re: /([0-9零〇一二两三四五六七八九十百]+)\s*个?\s*月前/, fn: (m) => {
-          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
-          return { startMs: monthStartShift(now, -n), endMs: monthStartShift(now, -n + 1) }
-        } },
-      // N 周(星期)前:定位到那个自然周(周一 00:00 起整周)
-      { re: /([0-9零〇一二两三四五六七八九十百]+)\s*个?\s*(?:星期|周)前/, fn: (m) => {
-          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
-          const base = startOfWeek(now) - n * 7 * DAY_MS
-          return { startMs: base, endMs: base + 7 * DAY_MS }
-        } },
-      // N 天(日)前:定位到那个自然日 00:00–24:00
-      { re: /([0-9零〇一二两三四五六七八九十百]+)\s*(?:天|日)前/, fn: (m) => {
-          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
-          const base = today0 - n * DAY_MS
-          return { startMs: base, endMs: base + DAY_MS }
-        } },
-    ]
-    for (const p of patterns) {
-      const m = p.re.exec(text)
-      if (!m) continue
-      const range = p.fn(m)
-      if (!range) continue
-      return { startMs: range.startMs, endMs: range.endMs, matched: m[0] }
-    }
-    return null
-  } catch (_) {
-    return null
-  }
-}
-
-/**
- * 从 L0 候选 label 抽取候选时间戳(当日 00:00 本地)。
- * label 形如日志/反思文件名(含 YYYY-MM-DD,如 "2026-09-09.md"、"reflections/2026-08-19.md");
- * 非日期来源(".../MEMORY.md"、"~/MEMORY.md")→ null → 时间臂对该候选不参与(中性)。
- */
-export function labelToDateMsPre(label) {
-  try {
-    const m = /(\d{4})-(\d{2})-(\d{2})/.exec(String(label || ''))
-    if (!m) return null
-    const d = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]))
-    return Number.isFinite(d.getTime()) ? d.getTime() : null
-  } catch (_) {
-    return null
-  }
-}
+/**
+ * temporal-parse-pre —— 中文时间表达解析(P12 后新增时间检索臂 Phase 1, 2026-09-09)。
+ *
+ * 目标:把查询里的中文时间表达("上周""三天前""最近一周""上个月"等)解析为
+ * [startMs, endMs) 时间范围,供检索的软性第三臂(time arm)做 rank-space 提升。
+ * 查询无时间表达 → 返回 null → 调用方零行为变更。
+ *
+ * 边界:纯函数、零 IO、零依赖;禁止 LLM/第三方日期库;确定性(同输入同 now 逐字节相同输出)。
+ * 时刻必须经 opts.now 注入(缺省 Date.now() 仅为便利;测试一律注入)。
+ *
+ * 时区假设(显式声明):全部自然日/周/月/年边界用宿主**本地时间**计算
+ * (new Date(y,m,d) 系列本地方法)。部署机时区为 Asia/Shanghai(CST,UTC+8,无夏令时),
+ * 与记忆日志文件名日期(本地日期)一致;若部署到其他时区,范围语义跟随宿主本地时区。
+ */
+
+/** 中文数字表(支持零〇一二两三四五六七八九十百,≤999,够 366 上限)。 */
+const CN_DIGIT = { '零': 0, '〇': 0, '一': 1, '二': 2, '两': 2, '三': 3, '四': 4, '五': 5, '六': 6, '七': 7, '八': 8, '九': 9 }
+
+/** N 的合法区间(含端点);超界视为未识别。 */
+const N_MIN = 1
+const N_MAX = 366
+
+const DAY_MS = 86400000
+
+/** 中文/阿拉伯数字 → 整数;非法返回 NaN。 */
+function numToInt(s) {
+  if (/^\d{1,3}$/.test(s)) return parseInt(s, 10)
+  let total = 0
+  let num = 0
+  for (const ch of String(s)) {
+    if (ch === '十') { total += (num || 1) * 10; num = 0 }
+    else if (ch === '百') { total += (num || 1) * 100; num = 0 }
+    else if (ch === '零' || ch === '〇') { /* 占位,跳过 */ }
+    else if (CN_DIGIT[ch] !== undefined) { num = CN_DIGIT[ch] }
+    else return NaN
+  }
+  const out = total + num
+  return out > 0 ? out : NaN
+}
+
+/** 本地自然日 00:00 的毫秒时间戳。 */
+function startOfDay(d) {
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime()
+}
+
+/** 本地自然周(周一 00:00 起)的毫秒时间戳。 */
+function startOfWeek(d) {
+  const monday = new Date(d.getFullYear(), d.getMonth(), d.getDate())
+  monday.setDate(monday.getDate() - ((monday.getDay() + 6) % 7))
+  return monday.getTime()
+}
+
+/** 本地自然月 1 日 00:00 的毫秒时间戳。 */
+function startOfMonth(d) {
+  return new Date(d.getFullYear(), d.getMonth(), 1).getTime()
+}
+
+/** 按本地月序号(可为负,自动借位)取自然月起点。 */
+function monthStartShift(d, shift) {
+  return new Date(d.getFullYear(), d.getMonth() + shift, 1).getTime()
+}
+
+/**
+ * 从 d 往前/后 n 个日历月,锚定同一日与时分秒。
+ * ★ issue #74 CB-6 修复（2026-09-19）：**月末钳制**。
+ *   旧实现直接 `new Date(y, m+n, d)` ⇒ d=31 而目标月只有 30 天时**自动进位到下月 1 日**
+ *   ⇒ now=2026-03-31 的「最近一个月」起点变成 03-03（而非 02-28/03-01），窗口缩水 2–3 天，
+ *   且 29/30/31 日**周期性复发**；而「N 个月前」走 `monthStartShift(day=1)` 无此病
+ *   ⇒ 两个时间臂语义不一致。现钳制到目标月最后一天（与「同一天，不存在则取月末」的直觉一致）。
+ */
+function nowShiftMonths(d, n) {
+  const y = d.getFullYear()
+  const m = d.getMonth() + n
+  // 目标月的最后一天：把「下月第 0 天」交给 Date 归一化即得
+  const lastDayOfTarget = new Date(y, m + 1, 0).getDate()
+  const day = Math.min(d.getDate(), lastDayOfTarget)
+  return new Date(y, m, day, d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()).getTime()
+}
+
+/** 日期 d 所在月的下个月起点。 */
+function nextMonthStart(d) {
+  return new Date(d.getFullYear(), d.getMonth() + 1, 1).getTime()
+}
+
+/**
+ * 解析查询文本中的中文时间表达。
+ *
+ * @param {string} text 查询文本
+ * @param {{now?:number}} [opts] now:毫秒时间戳(注入以保证确定性;缺省 Date.now())
+ * @returns {null | {startMs:number, endMs:number, matched:string}}
+ *   null=未识别到时间表达(调用方零行为变更);否则为半开区间 [startMs, endMs)
+ *   与命中的原文子串 matched。多个表达命中时取**首个**(按下方模式表顺序,确定性)。
+ */
+export function parseTemporalQueryPre(text, opts = {}) {
+  try {
+    if (typeof text !== 'string' || !text) return null
+    const nowMs = Number.isFinite(opts.now) ? opts.now : Date.now()
+    const now = new Date(nowMs)
+    const today0 = startOfDay(now)
+    // 模式表(顺序即优先级:长/特异表达在前,防止子串误配,如"大前天"先于"前天"、"上上周"先于"上周")
+    const patterns = [
+      { re: /大前天/, fn: () => ({ startMs: today0 - 3 * DAY_MS, endMs: today0 - 2 * DAY_MS }) },
+      { re: /前天/, fn: () => ({ startMs: today0 - 2 * DAY_MS, endMs: today0 - DAY_MS }) },
+      { re: /昨天/, fn: () => ({ startMs: today0 - DAY_MS, endMs: today0 }) },
+      { re: /今天/, fn: () => ({ startMs: today0, endMs: today0 + DAY_MS }) },
+      { re: /上上周/, fn: () => ({ startMs: startOfWeek(now) - 14 * DAY_MS, endMs: startOfWeek(now) - 7 * DAY_MS }) },
+      { re: /上周/, fn: () => ({ startMs: startOfWeek(now) - 7 * DAY_MS, endMs: startOfWeek(now) }) },
+      { re: /本周|这一周|这个星期/, fn: () => ({ startMs: startOfWeek(now), endMs: startOfWeek(now) + 7 * DAY_MS }) },
+      { re: /上个月|上月/, fn: () => ({ startMs: monthStartShift(now, -1), endMs: startOfMonth(now) }) },
+      { re: /本月|这个月/, fn: () => ({ startMs: startOfMonth(now), endMs: nextMonthStart(now) }) },
+      { re: /去年/, fn: () => ({ startMs: new Date(now.getFullYear() - 1, 0, 1).getTime(), endMs: new Date(now.getFullYear(), 0, 1).getTime() }) },
+      { re: /今年/, fn: () => ({ startMs: new Date(now.getFullYear(), 0, 1).getTime(), endMs: new Date(now.getFullYear() + 1, 0, 1).getTime() }) },
+      // 最近 N 个自然周期:从 now 往前 N 个周期(半开区间 [now-N周期, now));月按日历月锚定 now 时刻
+      { re: /最近\s*([0-9零〇一二两三四五六七八九十百]+)\s*个?\s*月/, fn: (m) => {
+          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
+          return { startMs: nowShiftMonths(now, -n), endMs: nowMs }
+        } },
+      { re: /最近\s*([0-9零〇一二两三四五六七八九十百]+)\s*个?\s*(?:星期|周)/, fn: (m) => {
+          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
+          return { startMs: nowMs - n * 7 * DAY_MS, endMs: nowMs }
+        } },
+      { re: /最近\s*([0-9零〇一二两三四五六七八九十百]+)\s*(?:天|日)/, fn: (m) => {
+          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
+          return { startMs: nowMs - n * DAY_MS, endMs: nowMs }
+        } },
+      // N 个月前:定位到那个自然月(整月)
+      { re: /([0-9零〇一二两三四五六七八九十百]+)\s*个?\s*月前/, fn: (m) => {
+          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
+          return { startMs: monthStartShift(now, -n), endMs: monthStartShift(now, -n + 1) }
+        } },
+      // N 周(星期)前:定位到那个自然周(周一 00:00 起整周)
+      { re: /([0-9零〇一二两三四五六七八九十百]+)\s*个?\s*(?:星期|周)前/, fn: (m) => {
+          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
+          const base = startOfWeek(now) - n * 7 * DAY_MS
+          return { startMs: base, endMs: base + 7 * DAY_MS }
+        } },
+      // N 天(日)前:定位到那个自然日 00:00–24:00
+      { re: /([0-9零〇一二两三四五六七八九十百]+)\s*(?:天|日)前/, fn: (m) => {
+          const n = numToInt(m[1]); if (!Number.isInteger(n) || n < N_MIN || n > N_MAX) return null
+          const base = today0 - n * DAY_MS
+          return { startMs: base, endMs: base + DAY_MS }
+        } },
+    ]
+    for (const p of patterns) {
+      const m = p.re.exec(text)
+      if (!m) continue
+      // ★ issue #74 CC-3a 修复（2026-09-19）：**模糊量词不得落精确日期**。
+      //   旧行为：`几十天前` 里数字类从「十」起匹配 ⇒ `matched='十天前'` ⇒ 被当**精确** -10 天
+      //   （实测 startMs=now-10d 单日区间），而用户说的是「几十」（不确定量）⇒ 语义错位。
+      //   现加一道统一守卫：数字捕获组**紧跟「几」之后**即视为模糊表达，本模式不适用
+      //   （`几天前`/`几个月前` 本就不匹配数字类；此处补的是 `几十天前`/`几十个月前` 这类
+      //    「几 + 数字字」被数字类从中间截断匹配的形态）。不落精确日期 ⇒ 落 null(未识别)。
+      if (m.index > 0 && text[m.index - 1] === '几') continue
+      const range = p.fn(m)
+      if (!range) continue
+      return { startMs: range.startMs, endMs: range.endMs, matched: m[0] }
+    }
+    return null
+  } catch (_) {
+    return null
+  }
+}
+
+/**
+ * 从 L0 候选 label 抽取候选时间戳(当日 00:00 本地)。
+ * label 形如日志/反思文件名(含 YYYY-MM-DD,如 "2026-09-09.md"、"reflections/2026-08-19.md");
+ * 非日期来源(".../MEMORY.md"、"~/MEMORY.md")→ null → 时间臂对该候选不参与(中性)。
+ */
+export function labelToDateMsPre(label) {
+  try {
+    // ★ issue #74 CC-3b 修复（2026-09-19）：正则**锚定日期形态**（原先裸露的
+    //   `/(\d{4})-(\d{2})-(\d{2})/` 会从 `x2026-09-09y`、`v1-2026-09-09-extra` 这类
+    //   任意含该子串的 label 里**抽取伪日期**）。现要求日期处于**边界**：
+    //   前置 = 串首 或 分隔符（`/`、`\`、`.`、`-`、`_`、空格）；
+    //   后置 = 串尾 或 扩展名/分隔符起点。
+    //   真实生产者形态全覆盖：`2026-09-09.md`、`reflections/2026-08-19.md`、`…/MEMORY.md`(不匹配→null)。
+    const m = /(^|[\/\\.\-_ ])(\d{4})-(\d{2})-(\d{2})(?=$|[.\\/_\-\s])/.exec(String(label || ''))
+    if (!m) return null
+    const Y = Number(m[2]); const Mo = Number(m[3]); const D = Number(m[4])
+    // ★ issue #74 CC-3b（第二半）：**日期分量范围校验**。旧实现 `new Date(2026, 12, 45)`
+    //   会被 Date **静默进位**成 2027-02-14（实测）⇒ 非法日期伪装成合法时间戳。
+    //   现显式拒绝越界分量，并**回读校验**（防闰年外的 2/30 等被进位）。
+    if (!(Mo >= 1 && Mo <= 12)) return null
+    if (!(D >= 1 && D <= 31)) return null
+    const d = new Date(Y, Mo - 1, D)
+    if (d.getFullYear() !== Y || d.getMonth() !== Mo - 1 || d.getDate() !== D) return null
+    return Number.isFinite(d.getTime()) ? d.getTime() : null
+  } catch (_) {
+    return null
+  }
+}