diff --git a/internal/db/migrations/0027_memory_temporal.down.sql b/internal/db/migrations/0027_memory_temporal.down.sql new file mode 100644 index 0000000..227b13f --- /dev/null +++ b/internal/db/migrations/0027_memory_temporal.down.sql @@ -0,0 +1,18 @@ +-- 0027 的回滚：只撤结构（删列），**不改写任何一行的数据**。 +-- +-- 回滚的代价（如实登记）：`temporal` 这一列的值全部丢失。它对本迁移之前写入的行 +-- 本来就恒为 `''`（未分型），因此丢的只是「本迁移之后提取器标出的时间性位」。 +-- +-- 真正需要说明的是**判定行为**：`retention_tier` / `expires_at` 是另两列，本回滚 +-- **刻意不动它们**。 +-- - 已被判成 temp 的行（其中一部分是 `temporal=one_off` 带来的）保持原状：读侧 +-- 时效闸与后台清扫都只认 `expires_at`（纯 SQL，不依赖本列），因此回滚后它们的 +-- 行为**逐字不变**，到期照旧消失、照旧被清扫； +-- - 若回滚时顺手把那些行的 `expires_at` 清空，那是一次 schema 回滚**改数据**， +-- 会把已经判定的临时记忆全部升回永久，同时还留在 `retention_tier='temp'` 上 +-- —— 那正是「temp ⇔ 非空 expires_at」这条不变量的反面。 +-- 要重判档位就重跑判定：列会以默认值 `''` 重建，历史行回到「未分型」。 +-- +-- SQLite 的 DROP COLUMN 要求该列不被索引/视图/触发器引用：本列没有索引（见 up）， +-- 因此无需先删索引（0026 的 down 因为带索引才要以 DROP INDEX 开头）。 +ALTER TABLE memory_items DROP COLUMN temporal; diff --git a/internal/db/migrations/0027_memory_temporal.up.sql b/internal/db/migrations/0027_memory_temporal.up.sql new file mode 100644 index 0000000..f17cfbc --- /dev/null +++ b/internal/db/migrations/0027_memory_temporal.up.sql @@ -0,0 +1,43 @@ +-- 0027_memory_temporal：提取器产出侧的**时间性元数据位**（切片 M45）。 +-- +-- 为什么需要这一列（而不是再调一次词项阈值）：M37 复审的量化结论是「defer 命中 +-- 2/500 = 0.4%」不是阈值太严，而是**判定链缺信息位** —— 真正卡住上游的是提取器的 +-- 改写：一次性事件被写成 30~80 字的第三人称长期陈述，规则闸只看落库正文，因此 +-- 看不见「这是今天的一次性事件」这一位。实测反证：把 N6 的时点词窗口从 12 放宽到 +-- 24 字，命中 2→14，多出的 11 条逐条都是**同一长期约定的重复陈述**（「一起晒太阳」 +-- 暂时搁置 ×5、「傍晚出门走十分钟…今天没走成明天补上」×6）—— 放宽阈值等于 7 天后 +-- 把约定本身删掉，违背 fail-safe。所以补的是信息位，不是阈值。 +-- +-- 为什么是**列**而不是新增一种 kind：`kind`（关于什么）、`scope`（谁的）、 +-- `retention_tier`（留多久）、本条 `temporal`（**说的是一次发生的事，还是反复/长期 +-- 成立的事**）是四根正交的轴。时间性是**提取器对原始对话的判断结果**，它必须能被 +-- 单独存下来（事后巡检「模型当时标了什么」、以及将来回填），塞进 kind 就丢了这条 +-- 观测线；靠提示词里的自然语言描述则违反 AGENTS §9「判据靠元数据，不靠提示词」。 +-- +-- 列值闭集（代码侧定义：internal/runtime/memory/temporal.go 的 TemporalKind）： +-- one_off 一次性事件（今天 / 这次 / 某一次）⇒ 判定为 temp + 非空 expires_at +-- recurring 反复发生的规律（每天 / 每周 / 每次都…）⇒ long +-- durable 长期成立的事实 / 偏好 / 约定 / 称呼 / 身份 ⇒ long +-- unknown 模型拿不准或没给出合法值 ⇒ **没有结论**，交给既有 N1~N7 规则判 +-- '' 尚未分型：本迁移之前的历史行，以及非提取器的写入路径（默认值） +-- +-- 🔴 默认值 `''` 而**不是** `unknown`：两者在判定上走同一条路（都落到旧规则），但 +-- 含义不同 —— `''` 是「没问过」，`unknown` 是「问过，模型拿不准」。把历史行写成 +-- `unknown` 会让「模型答了什么」这个观测面从第一行起就掺假。本迁移**刻意不回填**： +-- 历史行没有对应的提取器输出，拿正文反推「它当时是不是一次性事件」正是本片要消灭 +-- 的那种猜测。 +-- +-- 幂等性：`ALTER TABLE ADD COLUMN` 在 SQLite 里**没有** IF NOT EXISTS 形式，因此本 +-- 迁移与 0019 / 0026 同一手法 —— 依赖启动顺序「先 MigrateUp、后 NewStore」 +-- （cmd/cyrene/wire.go）：生产库里这一步先跑，随后 NewStore 的自举前滚 +-- （internal/runtime/memory/temporal_schema.go 的 ensureTemporalSchema）走到 +-- "duplicate column name" 是预期路径。列的形状必须与自举 DDL +-- （internal/runtime/memory/store_schema.go）**逐字同形**，由 +-- internal/runtime/memory/temporal_migration_test.go 钉住。 +-- +-- 本列**不建索引**：目前没有任何按时间性位的读路径（它是写入时的判定输入 + +-- 事后巡检的留痕列）。将来整理侧真要按它筛，再补索引不迟（两条路径一起加）。 +-- +-- 命名口径：表名复数（AGENTS §10 已登记例外）、列名与代码的 JSON 键同名 +-- （`temporal`），与 0026 的 `retention_tier` 同族。 +ALTER TABLE memory_items ADD COLUMN temporal TEXT NOT NULL DEFAULT ''; diff --git a/internal/runtime/memory/extract_retention.go b/internal/runtime/memory/extract_retention.go index aab2a11..669aed1 100644 --- a/internal/runtime/memory/extract_retention.go +++ b/internal/runtime/memory/extract_retention.go @@ -116,7 +116,11 @@ func judgeExtractionRetention(content string) retentionRule { } // 护栏①：显式「记住」是主人的直接指令，闸不许替他改判。它排在最前，因此 // 组合口径（护栏②）不会把主人的直接指令改成临时记忆。 - if containsAny(text, retentionRememberDirectives()) { + // + // 切片 M45 起它的判据抽成 retentionExplicitRemember（**一处实现、两处调用**）： + // 提取器的 `temporal=one_off` 元数据位（temporal.go 的 temporalVerdict）同样 + // 不许推翻这条护栏 —— 否则「记住我明天三点开会」会被 7 天后删掉。 + if retentionExplicitRemember(text) { return retentionNone } // 护栏②（2026-10-24 改**组合口径**，M27 体检报告 §7 第 5 批-1）：以前是 @@ -172,6 +176,19 @@ func judgeExtractionRetention(content string) retentionRule { return retentionNone } +// retentionExplicitRemember 报告正文里有没有**显式要求记住**的措辞 +// （「记住 / 记下 / 别忘了」，词表见 retentionRememberDirectives）。 +// +// 它是护栏①的判据，也由「时间性元数据位」那一路复用（temporal.go 的 +// temporalVerdict）：**一条判据只有一份实现**，否则「主人的直接指令一票否决」 +// 会在两条判定路上给出不同结论。 +// +// 入参可以是原始正文，也可以已由 normalizeRetentionText 规范化过 —— +// 规范化是幂等的（折叠空白 + 去尾标点），重复施加不改变结果。 +func retentionExplicitRemember(content string) bool { + return containsAny(normalizeRetentionText(content), retentionRememberDirectives()) +} + // retentionHasAnchor 报告正文里有没有「这条记忆可能长期成立」的锚点词 // （习惯族 tidyHabitMarkers + 长期事实族 retentionDurableMarkers）。 // diff --git a/internal/runtime/memory/llmextractor.go b/internal/runtime/memory/llmextractor.go index 2329a0c..735a06d 100644 --- a/internal/runtime/memory/llmextractor.go +++ b/internal/runtime/memory/llmextractor.go @@ -29,6 +29,14 @@ import ( // // 「允许返回 `[]`」是 Mem0 官方口径（design/23 §2：官方原话「Include examples // that should produce []」）—— 不写这一句，模型会为了「有产出」而硬凑。 +// +// 🆕 2026-10-27（切片 M45）：prompt 里追加**时间性位** `temporal`（四个枚举值）。 +// 它**不是**「又一段靠自然语言描述判据」的提示词加固：模型只负责**标注**一个值为 +// 四个枚举之一，**判定**（one_off ⇒ temp / durable ⇒ long / unknown ⇒ 走旧规则） +// 是 temporal.go 里的一段 Go 闭集 switch，落库是 `temporal` 列（迁移 0027）—— +// 因此 AGENTS §9「判据靠元数据，不靠提示词」在这里是**结构性成立**的：即便模型 +// 完全不听这段说明，最坏结果也只是它一律答 unknown（= 回到本片之前的旧规则）， +// 不会产生任何新的误判路径。 const extractSystemPrompt = `你是记忆提取器。从对话中提取**值得长期记住**的记忆项。 只保留这些（正向清单）： @@ -49,18 +57,33 @@ const extractSystemPrompt = `你是记忆提取器。从对话中提取**值得 **允许返回空数组 []**：一轮对话里没有值得长期记住的内容时，正确做法就是回 []，不要为了凑数而提取。 +每条还要标一个**时间性位** "temporal"，只能取下面四个英文值之一： +- "one_off"：这条说的是**某一次**发生的事（今天 / 昨天 / 这次 / 某个具体日子）， + 即使你已经把它写成「用户……」这样的陈述句 —— 一次性事件标成 durable 会让它 + 永远留着，标成 one_off 会让它进临时层、到期自动消失，所以只有确实只发生过 + 一次时才标它； +- "recurring"：说的是**反复发生**的规律（每天 / 每周 / 每次都…）； +- "durable"：说的是**长期成立**的事实 / 偏好 / 约定 / 称呼 / 身份； +- "unknown"：拿不准，或者上面三个都不贴切。 + +temporal 只许填这四个英文值之一（不要换成中文、不要自造新值）；拿不准就填 +"unknown" —— 标错方向的代价不对称：标成 one_off 会让本该留着的记忆被提前删掉。 + 只输出一个 JSON 数组，不要任何其他文字。每个元素形如： -{"content":"记忆内容","scope":"user|persona|project","kind":"relationship|world_event","tags":["标签"],"confidence":0.9,"project_id":"可选项目id"} -去噪去重：只保留值得长期记住的，忽略寒暄与临时信息。` +{"content":"记忆内容","scope":"user|persona|project","kind":"relationship|world_event","temporal":"one_off|recurring|durable|unknown","tags":["标签"],"confidence":0.9,"project_id":"可选项目id"} +去噪去重：只保留值得长期记住的，忽略寒暄与临时信息；确实发生过的**一次性事件** +如果值得记，也照实提取，但必须把 temporal 标成 one_off（它会进临时层）。` // llmCandidate 是提取器要求 LLM 输出的线上形状：每条候选 // 记忆一个 JSON 对象。模型未给出合法值时，Scope/Kind 取提取器配置的 -// 默认值。不含 source_conversation： +// 默认值；Temporal 则**一律归 unknown**（temporal.go 的 normalizeTemporal， +// 绝不猜：猜成 one_off 的方向是把该留的记忆删掉）。不含 source_conversation： // 模型即使回填该键也会被忽略（结构化溯源只来自持久化层）。 type llmCandidate struct { Content string `json:"content"` Scope string `json:"scope"` Kind string `json:"kind"` + Temporal string `json:"temporal"` Tags []string `json:"tags"` Confidence float64 `json:"confidence"` ProjectID string `json:"project_id"` @@ -240,6 +263,10 @@ func (e *LLMExtractor) dedupeAndBuild(cands []llmCandidate) []MemoryItem { Content: content, Tags: c.Tags, Confidence: c.Confidence, + // 时间性位（迁移 0027）在**产出侧**归一：模型只能选四个值之一， + // 其余（空 / 非法 / 自造）一律归 unknown —— 解析失败绝不报错， + // 也不拖累同批的其他候选（见 temporal.go 的 normalizeTemporal）。 + Temporal: normalizeTemporal(c.Temporal), } if !it.Scope.valid() || !it.Kind.valid() { continue diff --git a/internal/runtime/memory/preinsert.go b/internal/runtime/memory/preinsert.go index ea554ba..04b0f69 100644 --- a/internal/runtime/memory/preinsert.go +++ b/internal/runtime/memory/preinsert.go @@ -97,7 +97,13 @@ const ( // 规则。**规则内容与阈值未改**（同一份 N1~N7），但**判据的作用范围变了**： // 档位与 `expires_at` 现在对**每一行**在同一笔 INSERT 里落下，且不再依赖同步闸 // 是否开启 —— 同一对条目在 d3.3 与 d3.4 下的落库形态因此可能不同，按规矩升版。 -const IngestRuleVersion = "d3.4" +// - `d3.5`（切片 M45）加入提取器的**时间性元数据位**（`temporal`，迁移 0027）： +// `one_off` ⇒ temp（⇒ 第五态 defer）、`durable` / `recurring` ⇒ long、 +// `unknown` / 未分型 ⇒ 照旧走 N1~N7。**N1~N7 的规则内容与阈值一字未改**，但 +// 同一段正文在 d3.4 与 d3.5 下可能落到不同档位（d3.4 只能靠词判，d3.5 还能 +// 读到「这是不是一次性事件」这一位）—— 结论会变，按规矩升版，否则新旧留痕 +// 无法区分。 +const IngestRuleVersion = "d3.5" // 调优旋钮（ReviewConfig）与它们的默认值常量在 preinsert_config.go。 diff --git a/internal/runtime/memory/preinsert_defer_test.go b/internal/runtime/memory/preinsert_defer_test.go index 1727335..fb6c106 100644 --- a/internal/runtime/memory/preinsert_defer_test.go +++ b/internal/runtime/memory/preinsert_defer_test.go @@ -19,7 +19,8 @@ import ( // 2. 写进去的 `expires_at` 与读侧时效闸**同一套规范文本** // （定宽 30 字节 UTC —— 写错布局会让闸静默判错，本仓有历史事故）； // 3. TTL 坏值（≤0）**绝不放行**：回落代码默认 7 天 + WARN； -// 4. `IngestRuleVersion` 升到 `d3.4`（改判定规则必升版，否则新旧留痕无法区分）； +// 4. `IngestRuleVersion` 随判定变更升版（改判定规则必升版，否则新旧留痕无法区分； +// 当前是 `d3.5`，M37 合入时是 `d3.4`）； // 5. defer 是**软动作**：回滚 = 清空 `expires_at`，行与正文一字不动。 // readIngestExpiry 直读一行记忆的 `expires_at`（该列不在 Store.Get 的读侧面上： @@ -107,8 +108,8 @@ func TestIngestGateDeferWritesShortExpiresAt(t *testing.T) { if rev.Decision != IngestDefer || rev.Reason != retentionLowValueReason { t.Fatalf("闸留痕 = %+v, want decision=defer reason=%q", rev, retentionLowValueReason) } - if rev.RuleVer != "d3.4" { - t.Fatalf("闸留痕规则版本 = %q, want d3.4", rev.RuleVer) + if rev.RuleVer != IngestRuleVersion { + t.Fatalf("闸留痕规则版本 = %q, want %q（留痕版本必须与常量同源，不写死）", rev.RuleVer, IngestRuleVersion) } if s := r.Stats(); s.GateDeferred != 1 { t.Fatalf("闸计数 = %+v, want gate_deferred=1", s) @@ -268,16 +269,20 @@ func TestIngestGatePlanExpiresAtUsesSameLayoutAsTimeGate(t *testing.T) { } } -// TestIngestRuleVersionIsD34 钉住任务书验收点④：改判定规则必升版 +// TestIngestRuleVersionIsD35 钉住任务书验收点④：改判定规则必升版 // （design/23 §18.4），否则新旧留痕无法区分。 // // d3.4（切片 M37）把「判 defer」与「判 retention_tier=temp」合并成同一个判定， // 规则内容未改但判据的作用范围变了（每一行都在同一笔 INSERT 里落档位与有效期， // 且不再依赖同步闸是否开启），因此按规矩升版。 -func TestIngestRuleVersionIsD34(t *testing.T) { +// +// d3.5（切片 M45）给判定链补上「时间性元数据位」：`one_off` ⇒ temp、 +// `durable` / `recurring` ⇒ long、`unknown` ⇒ 旧规则。N1~N7 的规则与阈值一字未改， +// 但同一段正文的结论会变（d3.4 只能靠词判），因此同样按规矩升版。 +func TestIngestRuleVersionIsD35(t *testing.T) { t.Parallel() - if IngestRuleVersion != "d3.4" { - t.Fatalf("IngestRuleVersion = %q, want d3.4（档位与 defer 合并为同一判定）", IngestRuleVersion) + if IngestRuleVersion != "d3.5" { + t.Fatalf("IngestRuleVersion = %q, want d3.5（时间性元数据位接入判定链）", IngestRuleVersion) } } diff --git a/internal/runtime/memory/preinsert_migration_test.go b/internal/runtime/memory/preinsert_migration_test.go index dcb2da7..90a1a3b 100644 --- a/internal/runtime/memory/preinsert_migration_test.go +++ b/internal/runtime/memory/preinsert_migration_test.go @@ -52,6 +52,41 @@ func migrateUp(t *testing.T, d *sql.DB) { } } +// migrateDownToBefore 把库回滚到 id **之前**（即 id 与它之后已应用的每条都撤掉）。 +// +// 步数从 `schema_migrations` 账本现算，而不是写死一个常数：写死的口径每加一条 +// 迁移就要改一次（0026 加进来时本文件的 0025 用例的 `MigrateDown(2)`、0027 加进来时 +// 0026 用例的 `MigrateDown(1)` 都是这么被打红的）—— 而「回滚到某条之前」这个 +// 语义本身与后面还压着几条无关。 +func migrateDownToBefore(t *testing.T, d *sql.DB, id string) { + t.Helper() + ctx := context.Background() + rows, err := d.QueryContext(ctx, `SELECT id FROM schema_migrations ORDER BY id`) + if err != nil { + t.Fatalf("list applied migrations: %v", err) + } + defer func() { _ = rows.Close() }() + steps := 0 + for rows.Next() { + var got string + if err := rows.Scan(&got); err != nil { + t.Fatalf("scan applied migration: %v", err) + } + if got >= id { + steps++ + } + } + if err := rows.Err(); err != nil { + t.Fatalf("iterate applied migrations: %v", err) + } + if steps == 0 { + t.Fatalf("迁移 %s 不在账本里，无法回滚到它之前", id) + } + if err := db.MigrateDown(ctx, d, steps, testLogger()); err != nil { + t.Fatalf("MigrateDown(%d) 回到 %s 之前: %v", steps, id, err) + } +} + // tableExists 报告表是否存在。 func tableExists(t *testing.T, d *sql.DB, name string) bool { t.Helper() @@ -141,7 +176,6 @@ func countRawReviewRows(t *testing.T, d *sql.DB) int { // 索引、down 删表、再 up 能重建（回滚不留半状态）。 func TestMigration0025CreatesAndRollsBackIngestReviewTable(t *testing.T) { t.Parallel() - ctx := context.Background() d := openRawMemoryDB(t) migrateUp(t, d) @@ -162,11 +196,10 @@ func TestMigration0025CreatesAndRollsBackIngestReviewTable(t *testing.T) { } } - // 回滚：本表之上还压着一条 0026（`memory_retention_tier`，切片 M37），因此这里 - // 回滚**两条**才轮到 0025 —— 迁移账本按 id 升序、down 按降序撤，这是既有语义。 - if err := db.MigrateDown(ctx, d, 2, testLogger()); err != nil { - t.Fatalf("MigrateDown(2): %v", err) - } + // 回滚：0025 之上还压着 0026（`memory_retention_tier`，切片 M37）与 0027 + // （`temporal`，切片 M45），因此要回到 0025 **之前**才轮得到它 —— 步数由 + // migrateDownToBefore 从账本现算，不写死常数（见该 helper 的注释）。 + migrateDownToBefore(t, d, ingestReviewMigrationID) if tableExists(t, d, ingestReviewTable) { t.Fatalf("回滚后 %s 应已被删除", ingestReviewTable) } diff --git a/internal/runtime/memory/retention.go b/internal/runtime/memory/retention.go index 5d3bb90..c087a6c 100644 --- a/internal/runtime/memory/retention.go +++ b/internal/runtime/memory/retention.go @@ -95,8 +95,18 @@ type retentionVerdict struct { // 2. **显式给了有效期**（`item.ExpiresAt` 非零）⇒ 这一行会到期 ⇒ 它就是临时记忆。 // 两者是同一根轴的两种表达，因此这里不是「推导」，而是同一个事实的补全。 // 3. **受限来源**（群聊 / 陌生人）⇒ 不分型（空串）。见文件头注 ②。 -// 4. **留存规则命中**（design/03 §10.5 的 N1~N7）⇒ temp，并带回规则码。 -// 5. 其余 ⇒ long（默认落点，fail-safe）。 +// 4. **提取器的时间性元数据位**（迁移 0027、temporal.go）⇒ `one_off` 判 temp +// （先过 temporalSanityVeto：正文自己还在说「长期事实 / 反复规律 / 一份约定 / +// 主人明确要求记住」时不给结论，落回旧规则）；`durable` / `recurring` 判 long +// 并**不再跑规则**；`unknown` 与未分型 ⇒ **没有结论**，落到下一步。 +// 🔴 `unknown` 绝不等于「一次性」：不许因为正文看着像今天的事就判 temp +// （fail-safe 方向：宁可多留）。 +// 5. **留存规则命中**（design/03 §10.5 的 N1~N7）⇒ temp，并带回规则码。 +// 6. 其余 ⇒ long（默认落点，fail-safe）。 +// +// 排在第 3 步之后的理由与它自己一致：受限来源的留存由来源面决定（后台到期清扫 +// 跳过它们，expire.go 的 `nonOwnerSource`），若时间性位把它们判成 temp，就会造出 +// 一条「对读面隐藏、却永远不会被删」的行 —— 那是本条要避免的形态。 // // 🔴 「判第五态 `defer`」与「判 `retention_tier=temp`」**就是这一步**：闸与异步审查 // 都只读 `item.RetentionTier`（preinsert_judge.go），不再各自跑一遍规则。M27/M37 的 @@ -115,6 +125,9 @@ func resolveRetention(item MemoryItem) (retentionVerdict, error) { if nonOwnerSource(item.SourceConversation) { return retentionVerdict{Tier: RetentionTierUnset}, nil } + if verdict, ok := temporalVerdict(item); ok { + return verdict, nil + } if rule := judgeExtractionRetention(item.Content); rule != retentionNone { return retentionVerdict{Tier: RetentionTemp, Rule: rule}, nil } diff --git a/internal/runtime/memory/retention_migration_test.go b/internal/runtime/memory/retention_migration_test.go index 0fb7c28..837e7f6 100644 --- a/internal/runtime/memory/retention_migration_test.go +++ b/internal/runtime/memory/retention_migration_test.go @@ -7,8 +7,6 @@ import ( "strings" "testing" "time" - - "git.yeij.top/AskaEth/Cyrene_v2/internal/db" ) // 本文件钉住**迁移 0026（`memory_retention_tier`）与 Store 自举 DDL 的同形与可回滚**， @@ -69,10 +67,9 @@ func TestMigration0026AddsColumnOverExistingRows(t *testing.T) { d := openRawMemoryDB(t) migrateUp(t, d) - // 造出「既有部署」：把 0026 撤掉（列与索引消失），再按**旧形态**写入两行。 - if err := db.MigrateDown(ctx, d, 1, testLogger()); err != nil { - t.Fatalf("MigrateDown(1): %v", err) - } + // 造出「既有部署」：回到 0026 **之前**（列与索引消失），再按**旧形态**写入两行。 + // 步数由账本现算：0027（`temporal`，切片 M45）压在上面，写死 1 会撤错那条。 + migrateDownToBefore(t, d, retentionMigrationID) if hasMemoryColumn(t, d, retentionTierColumn) || hasMemoryIndex(t, d, retentionTierIndex) { t.Fatalf("0026 回滚后 %s / %s 应已消失", retentionTierColumn, retentionTierIndex) } @@ -111,9 +108,7 @@ func TestMigration0026AddsColumnOverExistingRows(t *testing.T) { } // 回滚：只撤结构，不改写任何一行的其它数据。 - if err := db.MigrateDown(ctx, d, 1, testLogger()); err != nil { - t.Fatalf("MigrateDown(1, 二次): %v", err) - } + migrateDownToBefore(t, d, retentionMigrationID) if hasMemoryColumn(t, d, retentionTierColumn) || hasMemoryIndex(t, d, retentionTierIndex) { t.Fatalf("二次回滚后 %s / %s 应已消失", retentionTierColumn, retentionTierIndex) } @@ -181,11 +176,18 @@ func TestMigration0026ShapeMatchesStoreBootstrap(t *testing.T) { t.Fatalf("%s 侧的 %s 列形状不是 TEXT NOT NULL DEFAULT 空串：%v", name, retentionTierColumn, cols) } } - // 自举 DDL 里新列写在最后一列（新建库的期望形状）——迁移路径上它后面可能还有 - // 自举追加的 project_id，因此只对自举侧断言顺序。 + // 自举 DDL 的尾序（新建库的期望形状）：`… retention_tier, temporal`。 + // 迁移路径上这两列之后可能还有自举追加的 project_id，因此只对自举侧断言顺序。 + // （0027 之后 retention_tier **不再是**最后一列 —— temporal 追加在它之后。） bootCols := tableColumns(t, bootstrapped, "memory_items") - if last := bootCols[len(bootCols)-1]; !strings.Contains(last, "|"+retentionTierColumn+"|") { - t.Fatalf("自举建的 memory_items 最后一列 = %q, want %s", last, retentionTierColumn) + if len(bootCols) < 2 { + t.Fatalf("自举建的 memory_items 列数 = %d, want ≥ 2", len(bootCols)) + } + tail := bootCols[len(bootCols)-2:] + if !strings.Contains(tail[0], "|"+retentionTierColumn+"|") || + !strings.Contains(tail[1], "|"+temporalColumn+"|") { + t.Fatalf("自举建的 memory_items 尾两列 = %v, want …, %s, %s", + tail, retentionTierColumn, temporalColumn) } } diff --git a/internal/runtime/memory/store.go b/internal/runtime/memory/store.go index d8d1a08..395d912 100644 --- a/internal/runtime/memory/store.go +++ b/internal/runtime/memory/store.go @@ -135,6 +135,17 @@ type MemoryItem struct { // 非空 = 调用方的显式断言，判据不许推翻它。读回来时： // **空串 = 尚未分型**（0026 之前的历史行 / 受限来源新行），绝不是某一档。 RetentionTier RetentionTier + + // Temporal 是**提取器给出的时间性元数据位**（迁移 0027、temporal.go）： + // one_off / recurring / durable / unknown，空串 = 未分型（历史行与 + // 非提取器写入路径）。它只由提取器在**产出侧**填，判定侧 + // （resolveRetention）读它一位，不让任何规则去猜「这句话说的是不是今天的事」。 + // + // ⚠️ **与 ExpiresAt 同样是「只写不读」的列**：`Add` 把它写进 `temporal` 列， + // 但四条列表读路径的 SELECT 与 scanItem 都不读它 —— 改扫描口径要动全部读点 + // （rules.go / store_list.go / tidy_store.go / preinsert_store.go，共 14→15 列）， + // 那是另一件事，不在本片授权范围。要按时间性位巡检/回填时直读该列即可。 + Temporal TemporalKind } // 区分 memory 包各类失败的哨兵错误。每个都在 @@ -161,6 +172,10 @@ var ( // 丢弃其中一半。 ErrRetentionConflict = errors.New("memory: retention tier conflicts with expires_at") + // ErrInvalidTemporal 在条目的 Temporal（时间性元数据位，迁移 0027）不是闭集内 + // 的值时返回。空串**不在**此列：它是「尚未分型」这一合法状态。 + ErrInvalidTemporal = errors.New("memory: invalid temporal kind") + // ErrNotFound 在条目 id 不存在时返回。 ErrNotFound = errors.New("memory: item not found") @@ -246,6 +261,10 @@ func NewStore(ctx context.Context, db *sql.DB, log *slog.Logger) (*Store, error) if err := ensureRetentionSchema(ctx, db); err != nil { return nil, err } + // 时间性元数据位（迁移 0027）：只补列、不建索引、不回填（见 temporal_schema.go）。 + if err := ensureTemporalSchema(ctx, db); err != nil { + return nil, err + } if err := normalizeMemoryTimestamps(ctx, db); err != nil { return nil, err } @@ -284,6 +303,11 @@ func NewStore(ctx context.Context, db *sql.DB, log *slog.Logger) (*Store, error) // 「档位 → expires_at」换算。两列因此**同一个判定、同一笔 INSERT**落下， // 不存在「判了 temp 却没写有效期」的中间态 —— M2 时代登记过的「INSERT 与补写 // expires_at 之间的短窗口」在本片被结构性关闭（不再有第二笔 UPDATE）。 +// +// 🆕 切片 M45：`item.Temporal`（时间性元数据位，迁移 0027）也随**这一笔** INSERT +// 落下（`temporal` 列）。它的判定作用已经折算进上面的档位（temporal.go 的 +// temporalVerdict 是 resolveRetention 的第 4 步），列值本身是**留痕**：记录提取器 +// 当时标了什么，供事后巡检「模型答的是不是 one_off」—— 判定与留痕因此不会分叉。 func (s *Store) Add(ctx context.Context, item MemoryItem) (MemoryItem, error) { if err := item.normalize(); err != nil { return MemoryItem{}, err @@ -315,12 +339,13 @@ func (s *Store) Add(ctx context.Context, item MemoryItem) (MemoryItem, error) { _, err = s.db.ExecContext(ctx, `INSERT INTO memory_items (id, persona_id, role_id, project_id, scope, kind, content, tags, confidence, source_conversation, created_at, updated_at, decay_weight, status, merged_into, - expires_at, retention_tier) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, + expires_at, retention_tier, temporal) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, item.ID, item.PersonaID, item.RoleID, item.ProjectID, string(item.Scope), string(item.Kind), item.Content, string(tagsJSON), item.Confidence, item.SourceConversation, formatTime(item.CreatedAt), formatTime(item.UpdatedAt), item.DecayWeight, - plan.insertStatus(), plan.absorbedID(), plan.expiresAt(), plan.retention()) + plan.insertStatus(), plan.absorbedID(), plan.expiresAt(), plan.retention(), + string(item.Temporal)) if err != nil { return MemoryItem{}, fmt.Errorf("memory: insert item: %w", err) } @@ -428,6 +453,13 @@ func (it *MemoryItem) validate() error { if !it.RetentionTier.valid() { return fmt.Errorf("%w: %q", ErrInvalidRetentionTier, it.RetentionTier) } + // 时间性位（迁移 0027）同样只接受闭集内的值：它是**枚举元数据**，一个自造的 + // 值（"sometimes"）既判不出档位、又不该静默落库 —— 提取器已经把模型输出归一 + // 到 unknown（temporal.go 的 normalizeTemporal），走到这里还是非法值只能是 + // 程序错误，直接拒。 + if !it.Temporal.valid() { + return fmt.Errorf("%w: %q", ErrInvalidTemporal, it.Temporal) + } return nil } diff --git a/internal/runtime/memory/store_schema.go b/internal/runtime/memory/store_schema.go index 4c3788e..a528d4b 100644 --- a/internal/runtime/memory/store_schema.go +++ b/internal/runtime/memory/store_schema.go @@ -27,7 +27,8 @@ CREATE TABLE IF NOT EXISTS memory_items ( occurred_at TEXT NOT NULL DEFAULT '', valid_to TEXT NOT NULL DEFAULT '', expires_at TEXT NOT NULL DEFAULT '', - retention_tier TEXT NOT NULL DEFAULT '' + retention_tier TEXT NOT NULL DEFAULT '', + temporal TEXT NOT NULL DEFAULT '' )` const createMemoryItemsPersonaIndex = ` @@ -43,6 +44,11 @@ CREATE INDEX IF NOT EXISTS idx_memory_items_persona_id_created_at // （回填分型的入口）都吃它。列**必须**排在 CREATE TABLE 的最后：迁移的 // `ALTER TABLE ADD COLUMN` 也把新列追加在末尾，两份 DDL 才逐列同形 // （retention_migration_test.go 钉住这条同形，少一列就是「新库有、老库无」的漂移）。 +// +// ⚠️ 0027 之后 `retention_tier` **不再是最后一列**：`temporal`（迁移 0027）追加在 +// 它之后，两条路径的尾序都是 `… expires_at, retention_tier, temporal`。新列一律 +// 追加在末尾这条口径不变，只是「末尾」会随迁移推进（那条同形断言比对**列集合**， +// 另外对尾序做一条显式断言）。 const createMemoryItemsRetentionTierIndex = ` CREATE INDEX IF NOT EXISTS idx_memory_items_retention_tier ON memory_items (retention_tier)` diff --git a/internal/runtime/memory/temporal.go b/internal/runtime/memory/temporal.go new file mode 100644 index 0000000..f47da45 --- /dev/null +++ b/internal/runtime/memory/temporal.go @@ -0,0 +1,197 @@ +package memory + +import "strings" + +// 本文件是**提取器产出侧的时间性元数据位**（`temporal`，迁移 0027）：它回答 +// 「这条记忆说的是**一次发生的事**，还是**反复 / 长期成立的事**」。 +// +// 为什么需要这一位（M37 复审的结论，逐字）：「真正卡住上游的是**提取器的改写**： +// 一次性事件被写成 30~80 字的第三人称长期陈述（同时带『近期/目前』和持久词）， +// 规则闸看不到『这是今天的一次性事件』这一位。这不是阈值问题，是**判定链缺信息位**。」 +// +// 词项规则（extract_retention.go 的 N1~N7）只能看**落库后的正文**，而正文是提取器 +// 改写过的陈述：M37 实测里多出来的 11 条命中，逐条都是「同一条一次性安排的重复 +// 陈述」（「一起晒太阳」×5、「傍晚出门走十分钟…今天没走成明天补上」×6）—— 正文里 +// 连时点词都没有，把时点窗口从 12 放宽到 24 字只会**把约定本身判成临时并删掉**。 +// 因此补的不是阈值，而是这一位。 +// +// 🔴 **它是枚举元数据，不是提示词描述**（AGENTS §9「判据靠元数据，不靠提示词」）： +// 模型只能在下面四个值里选一个，落库是**列值**（TEXT），判定走 Go 闭集 switch —— +// 不是让规则去理解一句自然语言。模型给不出合法值时**一律归 `unknown`**（绝不猜成 +// `one_off`：猜错的方向是「本该留着的被提前删掉」，不可逆）。 +// +// 闭集（与迁移 0027 的列值口径逐字一致）： +// +// one_off 一次性事件（今天 / 这次 / 某一次发生的事）⇒ temp + expires_at +// recurring 反复发生的规律（每天 / 每周 / 每次都…）⇒ long +// durable 长期成立的事实 / 偏好 / 约定 / 称呼 / 身份 ⇒ long +// unknown 模型拿不准，或没给出合法值 ⇒ **没有结论**，交给 N1~N7 旧规则 +// '' 尚未分型：0027 之前的历史行，以及**非提取器**的写入路径（调用方显式 +// 给了档位的那些）—— 它不是一个业务取值，只是列的默认值 +// +// 🔴 `unknown` 与 `”` 在判定上**走同一条路**（都落到旧规则），但在口径上是两件事： +// `unknown` 是「问过模型了，它拿不准」；`”` 是「没问过」。把两者折成一个值会让 +// 「模型到底答了什么」这个观测面当场消失，而那正是本片要验证的东西。 +type TemporalKind string + +const ( + // TemporalUnset 是「尚未分型」：历史行与非提取器写入路径。**它不是业务取值**， + // 判定上与 TemporalUnknown 同路（落到旧规则），但含义不同（见文件头注）。 + TemporalUnset TemporalKind = "" + + // TemporalOneOff 是一次性事件。它是**唯一**会把记忆推进临时层的时间性位： + // 命中 ⇒ `retention_tier=temp` + 非空 `expires_at`（7 天后从读面消失、随后被 + // 后台清扫物理删除）。因此这个值只许模型在**明确知道**「这是某一次发生的事」 + // 时给出 —— 拿不准必须给 unknown。 + TemporalOneOff TemporalKind = "one_off" + + // TemporalRecurring 是反复发生的规律（「每天散步十分钟」「每周三开会」）。 + // 「反复」= 将来还会再发生，因此不许进临时层。 + TemporalRecurring TemporalKind = "recurring" + + // TemporalDurable 是长期成立的事实 / 偏好 / 约定 / 称呼 / 身份。 + TemporalDurable TemporalKind = "durable" + + // TemporalUnknown 是「问过模型了，它拿不准」。**它绝不是「一次性」的同义词**： + // 判定上它与未分型一样落到 N1~N7，不许因为「正文看着像今天的事」就判 temp —— + // 那等于把本片要消灭的猜测重新引回判定链（fail-safe 方向：宁可多留）。 + TemporalUnknown TemporalKind = "unknown" +) + +// valid 报告 t 是否落在闭集内（**含**未分型的空串：它是合法的列值，不是错误）。 +func (t TemporalKind) valid() bool { + switch t { + case TemporalUnset, TemporalOneOff, TemporalRecurring, TemporalDurable, TemporalUnknown: + return true + default: + return false + } +} + +// assigned 报告 t 是否**已由提取器分型**（即非空串）。它是「未分型」的唯一判据， +// 与 RetentionTier.assigned 同族，调用方不许用 `t == TemporalUnknown` 之类的 +// 比较去替代它（那是「问过但拿不准」，不是「没问过」）。 +func (t TemporalKind) assigned() bool { return t != TemporalUnset } + +// normalizeTemporal 把模型输出的自由文本归一到上面四个值。 +// +// 🔴 **只做大小写折叠与首尾空白裁剪，绝不做同义词猜测**（「一次性」「once」→ 都不认）： +// 认不出来的答案就是解析失败，一律落 TemporalUnknown —— 这正是任务书 +// 「模型只能选那四个值，解析失败一律归 unknown（绝不猜）」的字面实现。 +// 猜同义词的代价是单向的：猜成 one_off 就删记忆，猜成别的只是多留一条。 +func normalizeTemporal(s string) TemporalKind { + switch TemporalKind(strings.ToLower(strings.TrimSpace(s))) { + case TemporalOneOff: + return TemporalOneOff + case TemporalRecurring: + return TemporalRecurring + case TemporalDurable: + return TemporalDurable + default: + // 空值、非法值、拼写错误、模型自造的新值：全部归 unknown（**不报错**）。 + // 一条候选记忆的价值不取决于它的时间性位是否写对，因此解析失败绝不 + // 让整批提取失败（那会静默丢掉同批的其他候选）。 + return TemporalUnknown + } +} + +// temporalRetentionTempRule 是「时间性位把条目推进临时层」时进日志的规则码。 +// +// 它**刻意不编号成 n8**：N1~N7 是**词项**规则（看正文），这一条看的是**元数据位**， +// 两者混在一套编号里会让「谁命中过」这条观测线读不出「是词判的还是模型标的」。 +// 与 retentionLowValueReason 的分工不变：规则码只进日志，留痕列仍是闭集里的 +// `t0_low_value`（extract_retention.go 的口径）。 +const retentionTemporalTempRule retentionRule = "temporal_one_off" + +// temporalVerdict 把时间性位换算成档位结论（**唯一**一处换算，只由 +// `resolveRetention` 调用，见 retention.go 的判定顺序第 4 步）。 +// +// - `one_off` ⇒ temp —— 但先过 temporalSanityVeto（语义安全阀）：正文自己还在说 +// 「长期成立 / 反复发生 / 一份约定 / 主人明确要求记住」时，这一位**不给结论**， +// 落回 N1~N7。它是本片唯一会**收紧**判定的方向，因此阀门全开在 fail-safe 一侧。 +// - `durable` / `recurring` ⇒ long，并且**不再跑规则**：模型已经回答了「这不是 +// 一次性事件」，此时规则再判 temp 就是把「判定链缺的那一位」又丢掉。方向 +// 仍是 fail-safe（多留）。 +// - `unknown` / 未分型 ⇒ 不给结论，交给 N1~N7（任务书验收点③：不许因为 +// 「看着像今天的事」就判 temp）。 +func temporalVerdict(item MemoryItem) (retentionVerdict, bool) { + switch item.Temporal { + case TemporalOneOff: + if temporalSanityVeto(item.Content) { + return retentionVerdict{}, false + } + return retentionVerdict{Tier: RetentionTemp, Rule: retentionTemporalTempRule}, true + case TemporalDurable, TemporalRecurring: + return retentionVerdict{Tier: RetentionLong}, true + default: + return retentionVerdict{}, false + } +} + +// temporalSanityVeto 是 `one_off` 支路的**语义安全阀**：正文里出现「这条说的是 +// 长期成立的东西」的任何一类信号时，元数据位**不给结论**（落回 N1~N7）。 +// +// 它回答的是一个具体的分工问题：这一位补的是**位置判据**那一块（N6 要求时点词出现在 +// 句首 12 字内，而提取器改写出的第三人称长句根本不满足），**不是**把 N6 的语义安全阀 +// 也一起换掉。判「这不是一次性事件」的词项证据在任何一遍判定里都同样有效，因此这里 +// **原样复用同一批词表**，只让「这一次到底是不是一次性」由模型来答。 +// +// 六条各自的依据（前两条是既有红线，后四条是 2026-10-27 对生产库 active 集合的离线 +// 重放实测）： +// +// 1. **显式「记住 / 记下 / 别忘了」** —— extract_retention.go 护栏①，主人的直接 +// 指令不许被任何判据改成临时记忆； +// 2. **在陈述约定 / 承诺** —— M37 量化：放宽时点窗口多命中的 11 条逐条都是「同一 +// 长期约定的重复陈述」，删掉的就是约定本身； +// 3. **习惯词**（每天 / 通常 / 喜欢…）—— 说的是「反复发生」，与一次性互斥； +// 4. **硬性长期事实词**（住 / 宿舍 / 工作 / 职业 / 称呼 / 项目 / 生日 / 过敏…）—— +// 加这条之前，最近 500 条里的 18 条「上界候选」有 12 条是「近期住宿舍（昨天住 +// 宿舍）」「项目已接近收尾」这类**被时点词捎带的状态事实**；加上之后窗口内的 +// 上界从 4.2% 降到 0%（实测见 M45 的量报告），而全量 active 的上界从 5.4% 降到 +// 2.8% —— 这一条是「宁可多留」方向上最便宜的一刀； +// 5. **永久化标记**（以后 / 往后 / 从此…）； +// 6. **状态改变标记**（换成 / 变成 / 改成…：新状态会持续）。 +// +// ⚠️ **刻意不收「具体约束」这一条**（与 N6 的第三/四条不同）：数值与频次并不排他 —— +// 「帮我订个 7 点的闹钟」恰恰是最典型的一次性事件，把数值当否决会让这一位对真事件 +// 彻底失效。 +func temporalSanityVeto(content string) bool { + text := normalizeRetentionText(content) + if retentionExplicitRemember(text) || retentionStatesAgreement(text) { + return true + } + if containsAny(text, tidyHabitMarkers()) || containsAny(text, retentionHardDurableMarkers()) { + return true + } + if containsAny(text, retentionPermanenceMarkers()) || containsAny(text, retentionStateChangeMarkers()) { + return true + } + return false +} + +// retentionStatesAgreement 报告正文是否在**陈述一项约定 / 承诺**（而不是在记录 +// 一次发生的事）。 +// +// 它是 `one_off` 支路的第二条例外，语料依据逐条可查（2026-10-27 对生产库最近 +// 500 条 active 的离线重放 + M37 复审的量化）：被判成一次性事件的高危句式不是 +// 「今天下雨了」那种流水账，而是 +// +// 「和主人有『晚饭后出门走十分钟』的约定；今天没走成，算欠着，明天补上」 +// 「两人之间有一个『晒太阳』的约定，目前暂缓，等主人想起来再提」 +// +// —— 句子的**主语是一份长期约定**，时点只修饰其中一次执行。M37 已经量过：把 N6 +// 的时点窗口放宽到 24 字，这 11 条会一起命中，而它们要删的正是约定本身。因此这条 +// 例外不是「又一条词规则」，而是把 M37 那条实测结论固化成交付物。 +// +// 词表刻意与 retentionDurableMarkers 的「关系里程碑 / 约定」族同源，但**独立列出** +// （+「约好」）：那一族还会被别的判定用到，两者的职责不同 —— 这里只回答 +// 「这句话是不是在说一份约定」。 +func retentionStatesAgreement(content string) bool { + text := normalizeRetentionText(content) + for _, marker := range []string{"约定", "承诺", "答应", "说好", "约好"} { + if strings.Contains(text, marker) { + return true + } + } + return false +} diff --git a/internal/runtime/memory/temporal_migration_test.go b/internal/runtime/memory/temporal_migration_test.go new file mode 100644 index 0000000..7c881de --- /dev/null +++ b/internal/runtime/memory/temporal_migration_test.go @@ -0,0 +1,196 @@ +package memory + +import ( + "context" + "database/sql" + "slices" + "strings" + "testing" + "time" +) + +// 本文件钉住**迁移 0027（`memory_temporal`）与 Store 自举 DDL 的同形与可回滚**， +// 手法照 retention_migration_test.go 对 0026 的那一套（同一批 helpers）。 +// +// 真实启动顺序是「先 MigrateUp、后 NewStore」（cmd/cyrene/wire.go），因此新列有两份 +// 真源：迁移（权威）与 NewStore 的幂等前滚（任意 *sql.DB 上的自举，temporal_schema.go）。 +// 少一列就是「新库有、老库无」的漂移，因此两条判据都必须有： +// +// 1. TestMigration0027AddsColumnOverExistingRows —— 迁移落在**已有数据**上：行不丢、 +// 列补上、默认值是空串（未分型）；down 真的把列删掉且**不改写任何一行的其它 +// 数据**（尤其是 `retention_tier` / `expires_at`，见 down 文件的口径）；再 up 能重建。 +// 2. TestMigration0027ShapeMatchesStoreBootstrap —— 新列在两份 DDL 里**逐字同形** +// （TEXT NOT NULL DEFAULT 空串），且自举侧尾序是 `… retention_tier, temporal`。 + +// temporalColumn 是被测列名（迁移与自举 DDL 里的字面量）。 +const temporalColumn = "temporal" + +// temporalMigrationID 是 0027 在 schema_migrations 里的记账 id（= 文件名去掉 .up.sql）。 +const temporalMigrationID = "0027_memory_temporal" + +// TestMigration0027AddsColumnOverExistingRows 钉住迁移本体落在**既有数据**上的两条： +// 行不丢、默认值是空串（未分型）；以及再 up 后历史行回到「未分型」。 +func TestMigration0027AddsColumnOverExistingRows(t *testing.T) { + t.Parallel() + ctx := context.Background() + d := openRawMemoryDB(t) + migrateUp(t, d) + if !hasMemoryColumn(t, d, temporalColumn) { + t.Fatalf("迁移后 memory_items 应带 %s 列", temporalColumn) + } + + // 造出「0027 之前的既有部署」：回到 0027 之前，按旧形态写入两行。 + migrateDownToBefore(t, d, temporalMigrationID) + if hasMemoryColumn(t, d, temporalColumn) { + t.Fatalf("0027 回滚后 %s 应已消失", temporalColumn) + } + insertLegacyMemoryRow(t, d, "legacy-1", "一条 0027 之前就存在的记忆") + insertLegacyMemoryRow(t, d, "legacy-2", "另一条 0027 之前就存在的记忆") + + // 升级：0027 落在**已有数据**上。 + migrateUp(t, d) + if !hasMemoryColumn(t, d, temporalColumn) { + t.Fatalf("迁移后 memory_items 应带 %s 列", temporalColumn) + } + var rows int + if err := d.QueryRowContext(ctx, `SELECT COUNT(*) FROM memory_items`).Scan(&rows); err != nil { + t.Fatalf("count rows: %v", err) + } + if rows != 2 { + t.Fatalf("迁移后行数 = %d, want 2（既有行一行都不能丢）", rows) + } + for _, id := range []string{"legacy-1", "legacy-2"} { + var nat, content string + if err := d.QueryRowContext(ctx, + `SELECT temporal, content FROM memory_items WHERE id = ?`, id). + Scan(&nat, &content); err != nil { + t.Fatalf("read %s: %v", id, err) + } + if nat != "" { + t.Fatalf("既有行 %s 的时间性位 = %q, want 空串（历史行必须是「未分型」）", id, nat) + } + if content == "" { + t.Fatalf("既有行 %s 的正文丢了", id) + } + } +} + +// TestMigration0027DownKeepsRowData 钉住 down 的**唯一**语义：只撤结构。判成 temp 的 +// 行在回滚之后档位与时效必须**一个字节都没变**（回滚改数据 = 把已判定的临时记忆升回 +// 永久，正是 down 文件里登记的那条反面）。 +func TestMigration0027DownKeepsRowData(t *testing.T) { + t.Parallel() + ctx := context.Background() + d := openRawMemoryDB(t) + migrateUp(t, d) + + if _, err := d.ExecContext(ctx, `INSERT INTO memory_items + (id, persona_id, scope, kind, content, created_at, updated_at, + retention_tier, expires_at, temporal) + VALUES ('temp-1', 'persona.a', 'persona', 'relationship', '一条临时记忆', + `+legacyTimeLiteral+`, `+legacyTimeLiteral+`, 'temp', ?, 'one_off')`, + formatTime(time.Date(2026, 10, 30, 0, 0, 0, 0, time.UTC))); err != nil { + t.Fatalf("seed temp row: %v", err) + } + + migrateDownToBefore(t, d, temporalMigrationID) + if hasMemoryColumn(t, d, temporalColumn) { + t.Fatalf("回滚后 %s 应已消失", temporalColumn) + } + var tier, expires string + if err := d.QueryRowContext(ctx, + `SELECT retention_tier, expires_at FROM memory_items WHERE id = 'temp-1'`). + Scan(&tier, &expires); err != nil { + t.Fatalf("read retention columns after down: %v", err) + } + if tier != string(RetentionTemp) || expires == "" { + t.Fatalf("down 改写了档位/时效 = (%q, %q), want (%q, 非空) —— 回滚只撤结构", + tier, expires, RetentionTemp) + } + + // 再 up：列以默认值重建，既有行回到「未分型」。 + migrateUp(t, d) + if !hasMemoryColumn(t, d, temporalColumn) { + t.Fatalf("再次迁移后应重建 %s 列", temporalColumn) + } + var untyped int + if err := d.QueryRowContext(ctx, + `SELECT COUNT(*) FROM memory_items WHERE temporal = ''`).Scan(&untyped); err != nil { + t.Fatalf("count untyped: %v", err) + } + if untyped != 1 { + t.Fatalf("重建后未分型行 = %d, want 1", untyped) + } +} + +// TestMigration0027ShapeMatchesStoreBootstrap 是**漂移护栏**：迁移建出的 +// memory_items（列集合）与自举 DDL 建出的必须一致，且新列在两份 DDL 里的形状 +// 逐字相同（TEXT NOT NULL DEFAULT 空串）。 +// +// 列集合的等价性由 0026 的 TestMigration0026ShapeMatchesStoreBootstrap 一并覆盖 +// （它比对整表列集合）；这里只钉本列自己的形状与自举侧的尾序。 +func TestMigration0027ShapeMatchesStoreBootstrap(t *testing.T) { + t.Parallel() + ctx := context.Background() + + migrated := openRawMemoryDB(t) + migrateUp(t, migrated) + + bootstrapped := openRawMemoryDB(t) + if _, err := NewStore(ctx, bootstrapped, testLogger()); err != nil { + t.Fatalf("NewStore: %v", err) + } + + for name, d := range map[string]*sql.DB{"迁移": migrated, "自举": bootstrapped} { + cols := sortedColumns(tableColumns(t, d, "memory_items")) + if !slices.Contains(cols, temporalColumn+"|TEXT|1|''|0") { + t.Fatalf("%s 侧的 %s 列形状不是 TEXT NOT NULL DEFAULT 空串：%v", name, temporalColumn, cols) + } + } + bootCols := tableColumns(t, bootstrapped, "memory_items") + if len(bootCols) < 2 { + t.Fatalf("自举建的 memory_items 列数 = %d, want ≥ 2", len(bootCols)) + } + tail := bootCols[len(bootCols)-2:] + if !strings.Contains(tail[0], "|"+retentionTierColumn+"|") || + !strings.Contains(tail[1], "|"+temporalColumn+"|") { + t.Fatalf("自举建的 memory_items 尾两列 = %v, want …, %s, %s", + tail, retentionTierColumn, temporalColumn) + } +} + +// TestMigration0027ThenStoreBootstrapIsARegularPath 覆盖**真实启动顺序** +// （cmd/cyrene/wire.go：先 MigrateUp、后 NewStore）：0027 先建好列，随后 Store 的 +// 自举前滚走到 "duplicate column name" —— 那是**预期路径**，必须无害；重复建 Store +// 同样幂等，且写入路径可用（时间性位随同一笔 INSERT 落下）。 +func TestMigration0027ThenStoreBootstrapIsARegularPath(t *testing.T) { + t.Parallel() + ctx := context.Background() + d := openRawMemoryDB(t) + migrateUp(t, d) + + store, err := NewStore(ctx, d, testLogger()) + if err != nil { + t.Fatalf("NewStore（列已由迁移建好）: %v", err) + } + after := tableColumns(t, d, "memory_items") + if !hasMemoryColumn(t, d, temporalColumn) { + t.Fatalf("自举之后 %s 列消失了", temporalColumn) + } + if _, err := NewStore(ctx, d, testLogger()); err != nil { + t.Fatalf("NewStore(第二次): %v", err) + } + if got := tableColumns(t, d, "memory_items"); !slices.Equal(got, after) { + t.Fatalf("第二次自举改变了表结构：\n got=%v\nwant=%v", got, after) + } + + item := habitItem(temporalOneOffCorpus()[2], tidyTestTime(t), 0.9) + item.Temporal = TemporalOneOff + got, err := store.Add(ctx, item) + if err != nil { + t.Fatalf("Add: %v", err) + } + if nat := readTemporalColumn(t, store, got.ID); nat != TemporalOneOff { + t.Fatalf("迁移建列后经 Store 落库的时间性位 = %q, want %q", nat, TemporalOneOff) + } +} diff --git a/internal/runtime/memory/temporal_schema.go b/internal/runtime/memory/temporal_schema.go new file mode 100644 index 0000000..c4f5027 --- /dev/null +++ b/internal/runtime/memory/temporal_schema.go @@ -0,0 +1,45 @@ +package memory + +import ( + "context" + "database/sql" + "fmt" + "strings" +) + +// 本文件是「时间性元数据位」轴（迁移 0027）的 schema 前滚：给**既有**的 +// memory_items 补 `temporal` 列。 +// +// 与 retention_schema.go 同一手法、同一原因：`createMemoryItemsTable` 是 +// `CREATE TABLE IF NOT EXISTS`，只对**新库**生效 —— 既有部署的表早就建好了， +// 新列不会自己长出来。记忆存储必须自包含、能在任意 *sql.DB 上使用，因此这条 +// 前滚不能只靠 `internal/db/migrations`。 +// +// 🔴 与迁移的分工（两份真源，必须同形）：权威机制是 +// `internal/db/migrations/0027_memory_temporal`；这里是「任意 *sql.DB」的前滚。 +// 启动顺序是「先 MigrateUp、后 NewStore」（cmd/cyrene/wire.go），因此生产库里 +// 0027 先落地、这里走到 `duplicate column name` 是**预期路径**。 +// +// 本列**不建索引**：目前没有任何按时间性位的读路径（它是写入侧的判定输入 + +// 事后巡检用的留痕列），提前建索引只是给每笔写入加一份没人用的维护成本。 +// 将来整理侧真要按它筛（例如「把 one_off 的行捞出来复核」）再加索引不迟， +// 那时两条路径（迁移 + 本文件）一起加。 + +// ensureTemporalSchema 幂等地给 memory_items 补上时间性位列（列缺失时 ALTER， +// 已存在时忽略 SQLite 的 "duplicate column name" —— 那是预期路径，不是错误）。 +// +// 默认值 = 空串 = 尚未分型：既有行因此**行为逐字不变**（resolveRetention 对 +// 未分型的处理与 0027 之前完全一样，只跑 N1~N7）。本前滚刻意**不做**任何回填 +// 判定：历史行没有对应的提取器输出，拿正文反推「它当时是一次性事件吗」正是 +// 本片要消灭的那种猜测。 +func ensureTemporalSchema(ctx context.Context, db *sql.DB) error { + _, err := db.ExecContext(ctx, `ALTER TABLE memory_items + ADD COLUMN temporal TEXT NOT NULL DEFAULT ''`) + if err == nil { + return nil + } + if strings.Contains(err.Error(), "duplicate column name") { + return nil + } + return fmt.Errorf("memory: roll forward temporal column: %w", err) +} diff --git a/internal/runtime/memory/temporal_test.go b/internal/runtime/memory/temporal_test.go new file mode 100644 index 0000000..40a6202 --- /dev/null +++ b/internal/runtime/memory/temporal_test.go @@ -0,0 +1,453 @@ +package memory + +import ( + "context" + "strings" + "testing" + "time" + + "git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model" +) + +// 本文件是**时间性元数据位**（迁移 0027、temporal.go）的验收用例集，逐条对应 +// 任务书的验收点： +// +// ① `one_off` 的夹具语料 ⇒ 全链落库 `(temp, 非空 expires_at)`； +// ② `durable` / `recurring` ⇒ `(long, 空)`； +// ③ `unknown` 且内容像一次性 ⇒ **仍按旧规则**（本条不含新的猜测：命中的规则码 +// 必须是 N* 词项规则的码，绝不是时间性位的码）； +// ④ 模型返回非法值 / 空值 ⇒ 归 `unknown`，且**不报错**、不拖累同批候选； +// ⑤ 变异：把 temporalVerdict 的 one_off 支路摘掉 ⇒ ① 必红（下面三条 ① 的断言 +// 都以「档位是 temp」为判据，摘掉支路后它们全部退化成 long）。 +// +// 🔴 这份语料的一半（`one_off` 那三条）**刻意挑成旧规则的非命中形态**：它们在 +// `Temporal` 为空时判 long、带上 `one_off` 时判 temp —— 于是「这一位真的改了什么」 +// 可以被单独观察，不会与 N1~N7 的效果混在一起（M37 的实测缺口正是「分不清是谁判的」）。 + +// temporalOneOffCorpus 是一次性事件的夹具语料：长句陈述形态、无句首时点词、 +// **不含约定/承诺词**（含约定词的句子由 retentionStatesAgreement 挡回旧规则， +// 见 TestTemporalOneOffDoesNotOverrideStatedAgreement）—— 正是 M37 复盘点名的 +// 「一次性事件被写成 30~80 字第三人称陈述」那种形态。 +func temporalOneOffCorpus() []string { + return []string{ + "桌面上的文件整理到一半被别的事打断了", + "傍晚出门走十分钟的散步这一回没走成", + "那条链路断线是主人自己排查到根因的", + } +} + +// readTemporalColumn 直读一行的 `temporal` 列（该列与 expires_at 一样是**只写不读** +// 的列：四条列表读路径的 SELECT 不带它，见 store.go 的 Temporal 注释）。 +func readTemporalColumn(t *testing.T, store *Store, id string) TemporalKind { + t.Helper() + var raw string + if err := store.db.QueryRowContext(context.Background(), + `SELECT temporal FROM memory_items WHERE id = ?`, id).Scan(&raw); err != nil { + t.Fatalf("read temporal column %s: %v", id, err) + } + return TemporalKind(raw) +} + +// TestTemporalOneOffLandsTempWithExpiry 钉住验收点①（也是变异点⑤的靶子）： +// 时间性位 `one_off` ⇒ 全链落库 `(temp, 非空 expires_at)`，且这一位真的写进了 +// `temporal` 列（判定与留痕不分叉）。 +// +// 「全链」= 与生产同一条写路径：`Store.Add`（唯一 INSERT 路径）→ resolveRetention +// → planIngest → 一笔 INSERT。测试**不绕开** Add，也不用任何测试专用的旁路。 +func TestTemporalOneOffLandsTempWithExpiry(t *testing.T) { + t.Parallel() + ctx := context.Background() + store := newTestStore(t) + for _, content := range temporalOneOffCorpus() { + content := content + t.Run(content, func(t *testing.T) { + // 先证明这段正文**不含** N1~N7 的命中：否则本用例就分不清是规则还是 + // 时间性位判的 temp（M37 的缺口就是分不清）。 + bare, err := resolveRetention(habitItem(content, tidyTestTime(t), 0.9)) + if err != nil { + t.Fatalf("resolveRetention(bare): %v", err) + } + if bare.Tier != RetentionLong { + t.Fatalf("夹具语料 %q 在旧规则下就判成 %q（want long）—— 这条夹具证明不了时间性位的作用，换一条", + content, bare.Tier) + } + + item := habitItem(content, tidyTestTime(t), 0.9) + item.Temporal = TemporalOneOff + got, err := store.Add(ctx, item) + if err != nil { + t.Fatalf("Add(one_off): %v", err) + } + tier, expires := readRetentionColumns(t, store, got.ID) + if tier != RetentionTemp { + t.Fatalf("%q with temporal=one_off 落库档位 = %q, want %q", content, tier, RetentionTemp) + } + if expires == "" { + t.Fatalf("%q 判成 temp 却没写 expires_at（两列分叉）", content) + } + if got.ExpiresAt.IsZero() { + t.Fatalf("%q 的 Add 返回值没回填 ExpiresAt（调用方看不见「到期到哪」）", content) + } + if nat := readTemporalColumn(t, store, got.ID); nat != TemporalOneOff { + t.Fatalf("%q 的 temporal 列 = %q, want %q（判定与留痕不许分叉）", content, nat, TemporalOneOff) + } + }) + } +} + +// TestTemporalOneOffDefersThroughGate 钉住「判定接线」：闸开着时，`one_off` 判出的 +// temp 会走**同一条**第五态 `defer` 落库（留痕 `t0_low_value`），而不是另开一条路径。 +// +// 本用例同时是「不要造第二个判定入口」的观测点：`judgeIngest` 只读档位，因此这里 +// 除了档位列以外不额外断言任何规则重判的痕迹 —— 重判会让 +// TestRetentionJudgementHasSingleRuleCallSite 先红。 +func TestTemporalOneOffDefersThroughGate(t *testing.T) { + t.Parallel() + store := newTestStore(t) + base := tidyTestTime(t) + ttl := time.Hour + r := newGateReviewer(t, store, ReviewConfig{TempTTL: ttl}, nil) + store.AttachIngestReviewer(r) + + item := habitItem(temporalOneOffCorpus()[0], base, 0.9) + item.Temporal = TemporalOneOff + got, err := store.Add(context.Background(), item) + if err != nil { + t.Fatalf("Add: %v", err) + } + rev := gateRecordFor(t, store, got.ID) + if rev.Decision != IngestDefer || rev.Reason != retentionLowValueReason { + t.Fatalf("one_off 条目的留痕 = %+v, want defer + %q", rev, retentionLowValueReason) + } + if rev.RuleVer != IngestRuleVersion { + t.Fatalf("留痕规则版本 = %q, want %q", rev.RuleVer, IngestRuleVersion) + } + tier, expires := readRetentionColumns(t, store, got.ID) + if tier != RetentionTemp { + t.Fatalf("one_off 条目档位 = %q, want %q", tier, RetentionTemp) + } + // 到期时刻来自同一个判定与同一个时钟（闸注入的 now + 面板 TTL）。 + if want := expiryText(base.Add(ttl)); expires != want { + t.Fatalf("expires_at = %q, want %q", expires, want) + } +} + +// TestTemporalDurableAndRecurringStayLong 钉住验收点②：`durable` / `recurring` ⇒ +// `(long, 空)`，**并且覆盖规则闸的 temp 结论**。 +// +// 语料故意取一条旧规则会判 temp 的正文（N6 指示性时点）：「模型已经答了这不是 +// 一次性事件」时，规则不许把它改判成临时层 —— 方向是 fail-safe（多留一条）， +// 与「规则闸拦下的不许被 T1 推翻」并不矛盾：那一条防的是**放宽**（模型把规则判成 +// 临时的改成长期），方向相反。 +func TestTemporalDurableAndRecurringStayLong(t *testing.T) { + t.Parallel() + ctx := context.Background() + store := newTestStore(t) + const content = "用户昨天发来一卷验收纸条" + // 前提：这条正文在旧规则下确实判 temp（否则本用例证明不了「覆盖」）。 + bare, err := resolveRetention(habitItem(content, tidyTestTime(t), 0.9)) + if err != nil { + t.Fatalf("resolveRetention(bare): %v", err) + } + if bare.Tier != RetentionTemp || bare.Rule != retentionTimepoint { + t.Fatalf("前提不成立：%q 旧规则判 %q/%q，want temp/%q", content, bare.Tier, bare.Rule, retentionTimepoint) + } + for _, temporal := range []TemporalKind{TemporalDurable, TemporalRecurring} { + temporal := temporal + t.Run(string(temporal), func(t *testing.T) { + item := habitItem(content, tidyTestTime(t), 0.9) + item.Temporal = temporal + got, err := store.Add(ctx, item) + if err != nil { + t.Fatalf("Add(%q): %v", temporal, err) + } + tier, expires := readRetentionColumns(t, store, got.ID) + if tier != RetentionLong { + t.Fatalf("temporal=%q 落库档位 = %q, want %q", temporal, tier, RetentionLong) + } + if expires != "" { + t.Fatalf("temporal=%q 写了 expires_at = %q（非 temp 档必须为空）", temporal, expires) + } + if nat := readTemporalColumn(t, store, got.ID); nat != temporal { + t.Fatalf("temporal 列 = %q, want %q", nat, temporal) + } + }) + } +} + +// TestTemporalUnknownFallsThroughToRules 钉住验收点③，也是最容易做偏的一条： +// `unknown`（以及未分型的空串）**不许自己判 temp** —— 它必须原样交给 N1~N7， +// 判据只有旧规则那一份。 +// +// 三条断言方向不同，缺一条都测不出「方向反了」： +// +// 1. `unknown` + 「今天下雨了」⇒ 旧规则 N6 判 temp。这是**旧规则**的结论：命中的 +// 规则码必须是 `n6_timepoint`，**绝不能**是时间性位的 `temporal_one_off` —— +// 后者出现就说明有人把「看起来像今日事」变成了新的判据； +// 2. `unknown` + 旧规则非命中的正文 ⇒ long（不许因为看着像一次性就判 temp）； +// 3. 未分型（空串）与 `unknown` 走同一条路（历史行的行为逐字不变）。 +func TestTemporalUnknownFallsThroughToRules(t *testing.T) { + t.Parallel() + ctx := context.Background() + + t.Run("unknown_旧规则命中", func(t *testing.T) { + item := habitItem("今天下雨了", tidyTestTime(t), 0.9) + item.Temporal = TemporalUnknown + verdict, err := resolveRetention(item) + if err != nil { + t.Fatalf("resolveRetention: %v", err) + } + if verdict.Tier != RetentionTemp { + t.Fatalf("unknown + 「今天下雨了」= %q, want %q（旧规则 N6 的结论）", verdict.Tier, RetentionTemp) + } + if verdict.Rule != retentionTimepoint { + t.Fatalf("命中的规则 = %q, want %q —— 若出现 %q 说明 unknown 被当成了「一次性」的新判据", + verdict.Rule, retentionTimepoint, retentionTemporalTempRule) + } + }) + + t.Run("unknown_旧规则非命中", func(t *testing.T) { + store := newTestStore(t) + item := habitItem(temporalOneOffCorpus()[2], tidyTestTime(t), 0.9) + item.Temporal = TemporalUnknown + got, err := store.Add(ctx, item) + if err != nil { + t.Fatalf("Add(unknown): %v", err) + } + tier, expires := readRetentionColumns(t, store, got.ID) + if tier != RetentionLong || expires != "" { + t.Fatalf("unknown 且旧规则不命中时落库 = (%q, %q), want (%q, 空) —— 「看着像今日事」不许判 temp", + tier, expires, RetentionLong) + } + }) + + t.Run("未分型_与unknown同路", func(t *testing.T) { + for _, temporal := range []TemporalKind{TemporalUnset, TemporalUnknown} { + item := habitItem("谢谢啦", tidyTestTime(t), 0.9) + item.Temporal = temporal + verdict, err := resolveRetention(item) + if err != nil { + t.Fatalf("resolveRetention(%q): %v", temporal, err) + } + if verdict.Tier != RetentionTemp || verdict.Rule != retentionChatter { + t.Fatalf("temporal=%q 时 %q 判成 %q/%q, want temp/%q（历史行的行为必须逐字不变）", + temporal, item.Content, verdict.Tier, verdict.Rule, retentionChatter) + } + } + }) +} + +// TestTemporalOneOffDoesNotOverrideExplicitRemember 钉住交叉规则：显式「记住」的 +// 一票否决（extract_retention.go 护栏①）对时间性位**同样有效**。 +// +// 没有这条，模型把「记住我明天三点开会」标成 one_off 就会让主人在 7 天后丢掉自己 +// 明确要求记的东西 —— 那是 fail-safe 方向的反面，且不可逆。 +func TestTemporalOneOffDoesNotOverrideExplicitRemember(t *testing.T) { + t.Parallel() + item := habitItem("记住：明天下午三点开会，别迟到", tidyTestTime(t), 0.9) + item.Temporal = TemporalOneOff + verdict, err := resolveRetention(item) + if err != nil { + t.Fatalf("resolveRetention: %v", err) + } + if verdict.Tier != RetentionLong { + t.Fatalf("显式「记住」+ one_off = %q, want %q（护栏① 一票否决对元数据位同样有效）", + verdict.Tier, RetentionLong) + } +} + +// TestTemporalOneOffDoesNotTouchRestrictedSource 钉住与受限来源的优先级：群聊 / +// 陌生人的行**不分型**（空串），因此时间性位不许把它们判成 temp —— 那会造出 +// 「对读面隐藏、却永远不会被后台清扫删除」的行（expire.go 跳过非 owner 来源）。 +func TestTemporalOneOffDoesNotTouchRestrictedSource(t *testing.T) { + t.Parallel() + store := newTestStore(t) + item := habitItem(temporalOneOffCorpus()[2], tidyTestTime(t), 0.9) + item.Temporal = TemporalOneOff + item.SourceConversation = FormatSourceConversation("sess-group-1", "msg-1") + got, err := store.Add(context.Background(), item) + if err != nil { + t.Fatalf("Add: %v", err) + } + tier, expires := readRetentionColumns(t, store, got.ID) + if tier != RetentionTierUnset || expires != "" { + t.Fatalf("受限来源 + one_off 落库 = (%q, %q), want (未分型, 空)", tier, expires) + } +} + +// TestTemporalOneOffDoesNotOverrideStatedAgreement 钉住 `one_off` 支路的第二条 +// 例外，也是本片最要紧的一条 fail-safe：**正文在陈述一份约定时，`one_off` 不许把它 +// 推进临时层**。 +// +// 用例内容逐字取自 M37 复审的量化证据（把 N6 时点窗口放宽到 24 字会多命中 11 条， +// 逐条都是「同一条长期约定的重复陈述」）： +// +// 「一起晒太阳」暂时搁置 ×5 → 今天是「约定 + 暂缓」 +// 「傍晚出门走十分钟…今天没走成明天补上」×6 → 今天是「约定 + 某一次没走成」 +// +// 这两种句子**确实在描述某一次**，因此模型很容易标成 one_off；若代码照单全收， +// 7 天后被删掉的就是约定本身 —— M37 的原话：「放宽阈值会在 7 天后把约定本身删掉， +// 违背 fail-safe」。 +func TestTemporalOneOffDoesNotOverrideStatedAgreement(t *testing.T) { + t.Parallel() + agreements := []string{ + "两人之间有一个「晒太阳」的约定，目前暂缓，等主人想起来再提", + "和主人有「晚饭后出门走十分钟」的约定；今天没走成，算欠着，明天补上", + "和叶酱约好每天出门走十分钟；今天太阳先落山没走成，这十分钟欠着", + } + for _, content := range agreements { + content := content + t.Run(content, func(t *testing.T) { + item := habitItem(content, tidyTestTime(t), 0.9) + item.Temporal = TemporalOneOff + verdict, err := resolveRetention(item) + if err != nil { + t.Fatalf("resolveRetention: %v", err) + } + if verdict.Tier == RetentionTemp { + t.Fatalf("%q 因 temporal=one_off 被判成 temp —— 这是长期约定，7 天后会被删掉（fail-safe 反了）", content) + } + if !retentionStatesAgreement(content) { + t.Fatalf("retentionStatesAgreement(%q) = false —— 例外没认出这条约定", content) + } + }) + } +} + +// TestTemporalOneOffDoesNotOverrideDurableShape 钉住 `one_off` 支路的语义安全阀 +// （temporalSanityVeto 的后四条）：正文自己在说「习惯 / 长期事实 / 自此刻起永久 / +// 状态已改变」时，模型标的一次性**不给结论**，落回旧规则。 +// +// 语料全部取自 2026-10-27 对生产库 active 集合的离线重放里**真实出现过**的形态 +// （它们是「上界候选」的主要来源：被时点词捎带的状态事实）。判成 temp 的后果是 +// 7 天后被删，因此这些形态必须留住。 +func TestTemporalOneOffDoesNotOverrideDurableShape(t *testing.T) { + t.Parallel() + cases := []struct{ content, why string }{ + {"主人有每天吃早餐的习惯，几乎不会省略早餐。", "习惯词（反复发生，与一次性互斥）"}, + {"用户近期住宿舍（昨天住宿舍，可能今晚还在），需要关心住宿情况。", "硬性长期事实词（居住）"}, + {"茂密最近换了装：蝴蝶结从棕色变成深色，脖子上多了个小铃铛。", "状态改变（新状态会持续）"}, + {"主人昨天说以后都叫我小叶", "永久化标记（自此刻起一直成立）"}, + } + for _, tc := range cases { + tc := tc + t.Run(tc.content, func(t *testing.T) { + item := habitItem(tc.content, tidyTestTime(t), 0.9) + item.Temporal = TemporalOneOff + if !temporalSanityVeto(tc.content) { + t.Fatalf("temporalSanityVeto(%q) = false（%s）", tc.content, tc.why) + } + verdict, err := resolveRetention(item) + if err != nil { + t.Fatalf("resolveRetention: %v", err) + } + if verdict.Tier == RetentionTemp { + t.Fatalf("%q 因 temporal=one_off 被判成 temp —— %s，删掉是误弃", tc.content, tc.why) + } + }) + } +} + +// TestNormalizeTemporal 钉住验收点④的归一化口径：**只认四个字面值**，其余 +// （空 / 中文 / 自造 / 拼写变体）一律 unknown。 +// +// 不做同义词映射是刻意的：猜同义词的代价是单向的（猜成 one_off 就删记忆）， +// 而「拿不准一律 long」才是 fail-safe。 +func TestNormalizeTemporal(t *testing.T) { + t.Parallel() + cases := []struct { + raw string + want TemporalKind + }{ + {"one_off", TemporalOneOff}, + {"ONE_OFF", TemporalOneOff}, + {" durable \n", TemporalDurable}, + {"recurring", TemporalRecurring}, + {"unknown", TemporalUnknown}, + {"", TemporalUnknown}, + {" ", TemporalUnknown}, + {"一次性", TemporalUnknown}, + {"one-off", TemporalUnknown}, + {"oneoff", TemporalUnknown}, + {"forever", TemporalUnknown}, + } + for _, tc := range cases { + if got := normalizeTemporal(tc.raw); got != tc.want { + t.Fatalf("normalizeTemporal(%q) = %q, want %q", tc.raw, got, tc.want) + } + } +} + +// TestTemporalKindClosedSet 钉住闭集本身：四个业务值 + 未分型都合法，其他都不合法 +// （Add 的 validate 会拒掉它们 —— 那是程序错误，不是模型输出）。 +func TestTemporalKindClosedSet(t *testing.T) { + t.Parallel() + for _, ok := range []TemporalKind{TemporalUnset, TemporalOneOff, TemporalRecurring, TemporalDurable, TemporalUnknown} { + if !ok.valid() { + t.Fatalf("%q 应在闭集内", ok) + } + } + for _, bad := range []TemporalKind{"one-off", "sometimes", "ONE_OFF", "float"} { + if bad.valid() { + t.Fatalf("%q 不应在闭集内", bad) + } + } + if TemporalUnknown.assigned() != true || TemporalUnset.assigned() != false { + t.Fatal("assigned() 只应对非空串为真（「未分型」的唯一判据）") + } + // 非法值必须被写入路径拒掉（不是静默落库成脏列值）。 + item := habitItem("一条正文", tidyTestTime(t), 0.9) + item.Temporal = TemporalKind("sometimes") + if err := item.normalize(); err == nil { + t.Fatal("validate 接受了非法的时间性位（应返回 ErrInvalidTemporal）") + } +} + +// TestLLMExtractorReadsTemporal 钉住验收点④的另一半：提取器**真的**在读模型给的 +// 这一位，且非法 / 缺失值不产生错误、只归 unknown（不拖累同批其他候选）。 +func TestLLMExtractorReadsTemporal(t *testing.T) { + t.Parallel() + adapter := &mockAdapter{fn: func(_ context.Context, _ model.Request, _ model.Options) (model.Response, error) { + return model.Response{Content: `[ + {"content":"候选一","temporal":"one_off"}, + {"content":"候选二","temporal":"durable"}, + {"content":"候选三","temporal":"Recurring"}, + {"content":"候选四","temporal":"forever"}, + {"content":"候选五"} + ]`}, nil + }} + ex := NewLLMExtractor(adapter, "persona.a", "role.1") + items, err := ex.Extract(context.Background(), []model.Message{ + model.TextMessage(model.RoleUser, "随便聊两句"), + }) + if err != nil { + t.Fatalf("Extract: %v（非法 temporal 绝不能让整批提取失败）", err) + } + want := map[string]TemporalKind{ + "候选一": TemporalOneOff, + "候选二": TemporalDurable, + "候选三": TemporalRecurring, + "候选四": TemporalUnknown, + "候选五": TemporalUnknown, + } + if len(items) != len(want) { + t.Fatalf("候选数 = %d, want %d", len(items), len(want)) + } + for _, it := range items { + if it.Temporal != want[it.Content] { + t.Fatalf("%q 的 temporal = %q, want %q", it.Content, it.Temporal, want[it.Content]) + } + } +} + +// TestExtractionPromptCarriesTemporalEnum 钉住「提示词与闭集不漂移」：模型能看到的 +// 取值必须与 normalizeTemporal 认的四个值逐字一致（提示词只是辅助，但取值口径漂了 +// 就会让每条候选都被归成 unknown，这一位等于白加）。 +func TestExtractionPromptCarriesTemporalEnum(t *testing.T) { + t.Parallel() + for _, want := range []string{"temporal", "one_off", "recurring", "durable", "unknown"} { + if !strings.Contains(extractSystemPrompt, want) { + t.Fatalf("提取提示词里缺 %q —— 模型无从给出这一位", want) + } + } +}