From c7c0294a16141880fd2ec0695d502632ff4c0431 Mon Sep 17 00:00:00 2001 From: AskaEth Date: Mon, 26 Oct 2026 19:21:24 +0800 Subject: [PATCH] =?UTF-8?q?refactor(memory):=20M45=20=E8=A3=81=E5=86=B3=20?= =?UTF-8?q?D=20=E2=80=94=E2=80=94=20temporal=20=E4=BD=8D=E6=92=A4=E5=87=BA?= =?UTF-8?q?=E5=88=A4=E5=AE=9A=EF=BC=8C=E5=8F=AA=E4=BF=9D=E7=95=99=E8=A7=82?= =?UTF-8?q?=E6=B5=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 按 r1 复审裁决 D：这一位先只做观测，`resolveRetention` 不许读它。理由（实测）： 无条件 one_off ⇒ temp 会当天删 21 条长期约定；只放开 N6 位置判据能翻的 13 条 逐条是约定、而复审点名的三条目标行 0/3 救得了。在「模型真实标签分布」这份证据 缺位时不该做 7 天后物理删的不可逆决定。 撤接线（结论集逐字回到 M45 之前）： - retention.go：resolveRetention 不再读 item.Temporal；与之对比 dev base （af61b8c）本文件**只有注释差异**，规则与判定入口逐字未变。 - extract_retention.go：judgeExtractionRetention 签名回退单参；删除 judgeRetentionTimepointWide 与 n6_timepoint_wide 规则码。与 dev base 对比 **同样只有注释差异** ⇒ 「结论集 = 不含 temporal 的那个集合」是结构性的， 不是靠调用点记得别传。 - 连带取消初版的 durable / recurring ⇒ long（零影响必须是双向的）。 保留观测面（一律未动）：迁移 0027 的列、自举前滚、提取器的 temporal 产出、 prompt 枚举、闭集与 normalizeTemporal、store_temporal.go 的校验/编码。 另外把 prompt 里「标成 one_off 会让它进临时层、到期消失」这句**撤接线后已是假话** 改成中性标注说明 —— 否则会诱导模型避开 one_off，观测数据直接被污染。 测试： - TestTemporalBitDoesNotAffectRetention —— 4 类语料 × 5 个取值，(档位,规则码) 与未分型逐字相同（核心正断言）； - TestTemporalOneOffDoesNotMakeAnythingTemporary / ...DoesNotRescueRuleHitRows —— 零影响的双向点名； - TestTemporalIsStillRecorded —— one_off 的约定行仍落 temporal='one_off' 而档位 long、expires 空（观测在、判定不动）； - TestTemporalDoesNotTouchExplicitTierOrRestrictedSource —— 人工入口与受限来源不变。 变异实测：把 `if item.Temporal == TemporalOneOff { return temp }` 插回 resolveRetention ⇒ 上述四条用例全红（FAIL 输出已贴给塔），恢复后全绿。 IngestRuleVersion 保持 d3.5，注释改准为「记录 temporal 信号，但不参与判定」 （留痕面变了：库里多了「模型当时标了什么」这一维，回退会让新旧留痕混在一起）。 P2 三条保留：store.go 500 行（拆 store_temporal.go）、temporal.go 头注（'' 的口径 + 两次被否的接线方案 + 接线前必须看的那两条统计 SQL）、报告语境段。 回归：go build ./... + go vet ./... 全绿；memory/db 包测试全绿；memory -race 38.2s 全绿。 --- internal/runtime/memory/extract_retention.go | 74 +-- .../runtime/memory/extract_retention_test.go | 20 +- .../extract_retention_transient_test.go | 22 +- internal/runtime/memory/llmextractor.go | 19 +- internal/runtime/memory/preinsert.go | 13 +- .../runtime/memory/preinsert_defer_test.go | 10 +- internal/runtime/memory/retention.go | 27 +- internal/runtime/memory/store.go | 15 +- internal/runtime/memory/temporal.go | 121 ++--- .../runtime/memory/temporal_migration_test.go | 2 +- internal/runtime/memory/temporal_test.go | 508 ++++++------------ 11 files changed, 280 insertions(+), 551 deletions(-) diff --git a/internal/runtime/memory/extract_retention.go b/internal/runtime/memory/extract_retention.go index 0063fde..d132789 100644 --- a/internal/runtime/memory/extract_retention.go +++ b/internal/runtime/memory/extract_retention.go @@ -67,14 +67,6 @@ const ( // 没有数值、没有约束、没有硬性长期事实词。它是「一次性事件」的形态判据 // （M27 体检报告 §4 的 R4），因此落 `defer`（临时层，7 天后到期）。 retentionTimepoint retentionRule = "n6_timepoint" - // retentionTimepointWide 是对 **N6 的位置判据被时间性元数据位放开**后才命中的 - // 那一种（切片 M45，迁移 0027）：时点词确实在正文里，但**不在句首 12 字内**， - // 因此只有模型说「这是某一次发生的事」时才开火。 - // - // 它与 retentionTimepoint 分开编号是刻意的：句式相同、结论相同，但**判据来源 - // 不同**（词项位置 vs 模型位）。折成一个码，「这一位到底救了几条」就只能靠猜 —— - // 而那正是 M27 体检发现「闸形同虚设」时缺的那条观测线。 - retentionTimepointWide retentionRule = "n6_timepoint_wide" // retentionInProgress 对应 **N7 进行中状态**（2026-10-24 新增）：正文说的是 // 「正在/暂时 做某件事」（正在测通道、暂时搁置、正在慢慢想），同样是时效轴上的 // 状态而不是长期事实。安全阀与 N6 完全一致（见 judgeRetentionInProgress）。 @@ -109,15 +101,14 @@ const ( // 的 N1~N5 与 M34 新增的 N6/N7）。命中返回该规则码（调用方据此定 temp 档）， // 否则返回 retentionNone。 // -// 它**不读任何状态、不写任何东西、零模型调用**：入参只有正文与**时间性元数据位** -// （temporal，迁移 0027），出参只有规则码，因此在写路径上是微秒级且可完全单测 -// （design/03 §10.3 A 级的「零成本」要求）。`temporal` 的作用**只有一处**：把 N6 的 -// 位置判据放开（见 judgeRetentionTransient），其余分支一字不看它 —— 判定链没有 -// 第二个入口，这一点由 retention_test.go 的源码级断言钉住。 -// +// 它**不读任何状态、不写任何东西、零模型调用**：入参只有正文，出参只有规则码， +// 因此在写路径上是微秒级且可完全单测（design/03 §10.3 A 级的「零成本」要求）。 +// 🔴 时间性元数据位（temporal，迁移 0027）**不是**它的入参：r1 复审裁决 D 之后 +// 这一位只观测、不参与判定（见 retention.go 的 resolveRetention 头注与 temporal.go）。 // 🔴 全仓**唯一**调用点是 `resolveRetention`（retention.go）：任何地方再跑一遍 -// 就是「两套规则各判一遍」—— 那正是 M27 体检发现缺口（1082 次只判出 1 条）的成因。 -func judgeExtractionRetention(content string, temporal TemporalKind) retentionRule { +// 就是「两套规则各判一遍」—— 那正是 M27 体检发现缺口（1082 次只判出 1 条）的成因， +// retention_test.go 有一条源码级断言钉住这个唯一性。 +func judgeExtractionRetention(content string) retentionRule { text := normalizeRetentionText(content) if text == "" { // 空 / 纯空白内容在 Add 的 normalize 就被拒了，走不到这里；真走到了也只 @@ -177,7 +168,7 @@ func judgeExtractionRetention(content string, temporal TemporalKind) retentionRu // N6/N7：**指示性时点 / 进行中状态**的窄规则（2026-10-24 新增，M27 §4 R4）。 // 它们与 N1~N5 同性质（纯词项 + 形态），但判的是「这份记忆的锚点是一个正在 // 过去/即将到来的时刻」，而不是「这句话没有信息」。判据与安全阀见各自函数。 - if rule := judgeRetentionTransient(text, temporal); rule != retentionNone { + if rule := judgeRetentionTransient(text); rule != retentionNone { return rule } return retentionNone @@ -270,16 +261,14 @@ func judgeRetentionOneOff(text string) retentionRule { // ~0：`用户是上班族，需要上班（曾说明天要上班并感到不开心）`、`睡前会道晚安… // 并约好「明天中午见」` 这类「时点词只出现在引语/从句里」的长期事实，锚点 // 不是那个时点，因此不许开火；而 `昨天用户发来…`、`用户近期在看…` 的锚点就是它。 -// 🆕 **M45 起这一条是有条件的**：`temporal=one_off` 时位置判据不生效（时点词 -// 出现在中段也算锚点，见 judgeRetentionTimepointWide）。上面 1~4、6、7 条语义 -// 安全阀**不受这一位影响** —— 那是 r1 复审的裁定：这一位只接管「词在句子的哪个 -// 位置」，不接管「这句话是不是一次性事件」。 +// 🆕 **M45 曾把这一条接到时间性元数据位上，r1 复审裁决 D 又撤掉了**（原因见 +// temporal.go 头注：位置放宽能翻的行逐条都是长期约定）。因此位置判据对**每一行** +// 无条件生效，与 0027 之前逐字相同。 // // **N7（进行中状态）** 是同一时效轴的第二形态：「正在/暂时/眼下」说的事情有始有终 // （正在测通道、暂时搁置、正在慢慢想），安全阀与 N6 完全一致，并且**位置判据也一致** // （r1 复审 P2-2：`用户会主动维护…并告诉助手她正在维护…` 里的「正在」只出现在从句， -// 是「会…」的习惯陈述，不许开火）。N7 的位置判据**不受**时间性位影响（M45 只放开 -// N6）：`one_off` + 「正在」出现在从句里仍然是习惯陈述，没有放开的理由。 +// 是「会…」的习惯陈述，不许开火）。 // // 🔴 **刻意不做的事**（M27 §4 的实测反例，别再重新发明）： // - 不做**长度阈值**筛（R3：≤15 字的条目抽 8 条 8/8 是可复用事实）； @@ -287,7 +276,7 @@ func judgeRetentionOneOff(text string) retentionRule { // - 不做**一次性事件动词表**（曾/发来/分享…）：实测会命中「助手曾经历三千万次 // 轮回」「用户曾发来『i love you』文件」「海报就是助手本人」这类**长期身份与 // 关系里程碑**（抽检误杀 ≈ 50%），方向错误。 -func judgeRetentionTransient(text string, temporal TemporalKind) retentionRule { +func judgeRetentionTransient(text string) retentionRule { // 安全阀 1~4：与 N1~N5 不同，它们在这里是**硬门**（命中即放行），因为 N6/N7 // 判的是「这条记忆的锚点是一个时刻」，而锚点词/数值/约束都在说「它不止是一个时刻」。 if containsAny(text, tidyHabitMarkers()) { @@ -318,18 +307,8 @@ func judgeRetentionTransient(text string, temporal TemporalKind) retentionRule { if containsAny(text, retentionChatterWords()) || containsAny(text, retentionEmotionWords()) { return retentionNone } - // 安全阀 8（**切片 M45**，唯一由时间性元数据位影响的一处）：N6 的**位置判据**。 - // - // - `temporal=one_off` ⇒ **不看位置**：时点词出现在句中（提取器改写出的第三人称 - // 长句就是这样）也算锚点。这是本片补的那一位的全部作用 —— 它替代的是那个 - // 不可靠的位置窗口，**不是**上面 1~7 条语义安全阀； - // - 其余（unknown / 未分型 / durable / recurring 已在 temporal.go 里先判成 - // long，走不到这里）⇒ 位置判据照旧（`< retentionTimepointLeadRunes`）。 - // - // 规则码分两档是为了让**观测面**能回答「这一条是词判的还是模型放开位置后判的」： - // 只有「恰好靠放开位置才命中」时返回 retentionTimepointWide。 - if wide := judgeRetentionTimepointWide(text, temporal); wide != retentionNone { - return wide + if judgeRetentionTimepoint(text) != retentionNone { + return retentionTimepoint } if judgeRetentionInProgress(text) != retentionNone { return retentionInProgress @@ -349,29 +328,6 @@ func judgeRetentionTimepoint(text string) retentionRule { return retentionNone } -// judgeRetentionTimepointWide 是 N6 在**时间性位放开位置判据**时的形态判定。 -// -// - 位置内命中 ⇒ 返回 retentionTimepoint（词项规则自己的结论，与放开前逐字一致）； -// - 位置外命中**且**时点词确实存在 ⇒ 返回 retentionTimepointWide（模型放开位置后 -// 才命中，留痕用）； -// - 没有时点词 / 没有放开 ⇒ retentionNone。 -// -// ⚠️ 它只延长**位置**，不新增任何词表，也不越过 judgeRetentionTransient 的 1~7 条 -// 语义安全阀（那些在调用它之前就判完了）。 -func judgeRetentionTimepointWide(text string, temporal TemporalKind) retentionRule { - rule := judgeRetentionTimepoint(text) - if rule != retentionNone { - return rule - } - if !temporal.unlocksTimepointPosition() { - return retentionNone - } - if retentionFrontedTimepoint(text) >= 0 { - return retentionTimepointWide - } - return retentionNone -} - // judgeRetentionInProgress 是 N7 的形态判定：**句首前 N 个字内**出现进行中标记 // （正在 / 暂时 / 眼下 / 这会儿）。位置判据与 N6 同口径 —— 它挡的是「正在」只出现在 // 从句里、而主句其实是习惯陈述的那些句子（r1 复审 P2-2 的实测反例）。 diff --git a/internal/runtime/memory/extract_retention_test.go b/internal/runtime/memory/extract_retention_test.go index 3d5e9c8..4ebe6f4 100644 --- a/internal/runtime/memory/extract_retention_test.go +++ b/internal/runtime/memory/extract_retention_test.go @@ -18,14 +18,6 @@ import ( // **不进灰区**（于是 T1 一个 token 都花不出去）；把闸摘掉时那条断言会立刻变红 // （判成 create 且灰区非空）。 -// judgeRetentionNoTemporal 是**本文件与 transient 测试的便捷封装**：不带时间性位 -// （= 0027 之前的旧规则）。切片 M45 把 `temporal` 作为入参加进了规则函数（它只在 -// N6 的位置判据上起作用），因此「旧规则」的每一处断言都显式传 TemporalUnset， -// 而不是靠一个隐式默认值 —— 「不带这一位时行为逐字不变」这件事必须在调用点看得见。 -func judgeRetentionNoTemporal(content string) retentionRule { - return judgeExtractionRetention(content, TemporalUnset) -} - // retentionPositiveCases 是正向清单（design/03 §10.4）的脱敏样本与**两道护栏** // 的样本：它们必须**全部**放行（retentionNone）。 func retentionPositiveCases() []struct { @@ -126,8 +118,8 @@ func TestExtractionRetention_EmotionWithObjectIsNotDeferred(t *testing.T) { t.Fatalf("%q：余部为空 = %t 与 wantDefer = %t 不一致", tc.content, rest == "", tc.wantDefer) } - if rule := judgeRetentionNoTemporal(tc.content); (rule == retentionEmotion) != tc.wantDefer { - t.Fatalf("judgeRetentionNoTemporal(%q) = %q, wantEmotionDefer=%t —— 带宾语的与纯情绪的必须给出相反结论", + if rule := judgeExtractionRetention(tc.content); (rule == retentionEmotion) != tc.wantDefer { + t.Fatalf("judgeExtractionRetention(%q) = %q, wantEmotionDefer=%t —— 带宾语的与纯情绪的必须给出相反结论", tc.content, rule, tc.wantDefer) } }) @@ -169,7 +161,7 @@ func TestExtractionRetention_PositivesAreNeverDeferred(t *testing.T) { tc := tc t.Run(tc.name, func(t *testing.T) { t.Parallel() - if rule := judgeRetentionNoTemporal(tc.content); rule != retentionNone { + if rule := judgeExtractionRetention(tc.content); rule != retentionNone { t.Fatalf("正例 %q 被拦成 %q —— 那是把真记忆丢进临时层（fail-safe 方向被违反）", tc.content, rule) } @@ -185,7 +177,7 @@ func TestExtractionRetention_NegativesAreDeferred(t *testing.T) { tc := tc t.Run(tc.name, func(t *testing.T) { t.Parallel() - if rule := judgeRetentionNoTemporal(tc.content); rule != tc.rule { + if rule := judgeExtractionRetention(tc.content); rule != tc.rule { t.Fatalf("反例 %q 命中 %q, want %q", tc.content, rule, tc.rule) } }) @@ -197,7 +189,7 @@ func TestExtractionRetention_NegativesAreDeferred(t *testing.T) { func TestExtractionRetention_UpperCaseASCII(t *testing.T) { t.Parallel() for _, content := range []string{"HI", "Thanks", "hello~"} { - if rule := judgeRetentionNoTemporal(content); rule != retentionChatter { + if rule := judgeExtractionRetention(content); rule != retentionChatter { t.Fatalf("%q 命中 %q, want %q（ASCII 词应先折小写）", content, rule, retentionChatter) } } @@ -302,7 +294,7 @@ func TestExtractionRetention_PersistentFactsAreNeverDeferred(t *testing.T) { content := content t.Run(content, func(t *testing.T) { t.Parallel() - if rule := judgeRetentionNoTemporal(content); rule != retentionNone { + if rule := judgeExtractionRetention(content); rule != retentionNone { t.Fatalf("持久事实 %q 被判成 %q —— 它会进临时层、7 天后被物理删除（不可逆）", content, rule) } diff --git a/internal/runtime/memory/extract_retention_transient_test.go b/internal/runtime/memory/extract_retention_transient_test.go index 5306666..bbc3930 100644 --- a/internal/runtime/memory/extract_retention_transient_test.go +++ b/internal/runtime/memory/extract_retention_transient_test.go @@ -73,7 +73,7 @@ func retentionLongTermCases() []struct { func TestExtractionRetention_TimepointIsDeferred(t *testing.T) { t.Parallel() for _, content := range retentionTimepointCases() { - if got := judgeRetentionNoTemporal(content); got != retentionTimepoint && got != retentionInProgress { + if got := judgeExtractionRetention(content); got != retentionTimepoint && got != retentionInProgress { t.Fatalf("%q 判成 %q, want %q（锚点是一个时刻 ⇒ 临时层）", content, got, retentionTimepoint) } @@ -84,10 +84,10 @@ func TestExtractionRetention_TimepointIsDeferred(t *testing.T) { // 它让两条规则的词表**各自**可被单测，不会一条盖住另一条。 func TestRetentionTimepointHitsBySpecificRule(t *testing.T) { t.Parallel() - if got := judgeRetentionNoTemporal("用户昨天发送了一份长达一万两千行的验收纸条"); got != retentionTimepoint { + if got := judgeExtractionRetention("用户昨天发送了一份长达一万两千行的验收纸条"); got != retentionTimepoint { t.Fatalf("时点句 = %q, want %q", got, retentionTimepoint) } - if got := judgeRetentionNoTemporal("用户正在验证分享确认面板的展开功能"); got != retentionInProgress { + if got := judgeExtractionRetention("用户正在验证分享确认面板的展开功能"); got != retentionInProgress { t.Fatalf("进行中句 = %q, want %q", got, retentionInProgress) } } @@ -97,7 +97,7 @@ func TestRetentionTimepointHitsBySpecificRule(t *testing.T) { func TestExtractionRetention_RealLongTermFactsSurviveTimepoints(t *testing.T) { t.Parallel() for _, tc := range retentionLongTermCases() { - if got := judgeRetentionNoTemporal(tc.content); got != retentionNone { + if got := judgeExtractionRetention(tc.content); got != retentionNone { t.Fatalf("长期事实 %q（%s）被判成 %q —— 它会在 7 天后被物理删除（不可逆）", tc.content, tc.name, got) } @@ -110,10 +110,10 @@ func TestExtractionRetention_TimepointMustBeFronted(t *testing.T) { t.Parallel() fronted := "用户昨天发来一卷验收纸条" buried := "用户与助手讨论过验收纸条的格式（他自己说昨天发来一卷）" - if got := judgeRetentionNoTemporal(fronted); got != retentionTimepoint { + if got := judgeExtractionRetention(fronted); got != retentionTimepoint { t.Fatalf("时点在句首 = %q, want %q", got, retentionTimepoint) } - if got := judgeRetentionNoTemporal(buried); got != retentionNone { + if got := judgeExtractionRetention(buried); got != retentionNone { t.Fatalf("时点埋在从句里 = %q, want %q（位置安全阀失效会误杀长内容）", got, retentionNone) } } @@ -124,17 +124,17 @@ func TestExtractionRetention_TimepointMustBeFronted(t *testing.T) { // 前一半会变红；把组合条件删成「任一命中即放行」时，整条用例会红。 func TestExtractionRetention_ConjunctionIsNotANoOp(t *testing.T) { t.Parallel() - if got := judgeRetentionNoTemporal("约定下周给用户留一个安静的午后"); got != retentionTimepoint { + if got := judgeExtractionRetention("约定下周给用户留一个安静的午后"); got != retentionTimepoint { t.Fatalf("「约定 + 时点、无约束」= %q, want %q（锚点单独出现不再一票放行）", got, retentionTimepoint) } - if got := judgeRetentionNoTemporal("约定每天给主人留一个安静的午后"); got != retentionNone { + if got := judgeExtractionRetention("约定每天给主人留一个安静的午后"); got != retentionNone { t.Fatalf("「约定 + 每天（具体约束）」= %q, want 放行（组合条件命中即长期）", got) } - if got := judgeRetentionNoTemporal("主人每天要喝 2 杯咖啡"); got != retentionNone { + if got := judgeExtractionRetention("主人每天要喝 2 杯咖啡"); got != retentionNone { t.Fatalf("「偏好 + 数值」= %q, want 放行", got) } - if got := judgeRetentionNoTemporal("主人说过不要在群里提她的工作"); got != retentionNone { + if got := judgeExtractionRetention("主人说过不要在群里提她的工作"); got != retentionNone { t.Fatalf("「禁忌」= %q, want 放行", got) } } @@ -159,7 +159,7 @@ func TestExtractionRetention_TimepointSafetyValves(t *testing.T) { {"用户昨夜睡得还行，今天心情不错", "情绪词 ⇒ 归 N2 判"}, } for _, tc := range cases { - got := judgeRetentionNoTemporal(tc.content) + got := judgeExtractionRetention(tc.content) if got == retentionTimepoint || got == retentionInProgress { t.Fatalf("%q 判成 %q, want 不被 N6/N7 判临时（%s）", tc.content, got, tc.why) } diff --git a/internal/runtime/memory/llmextractor.go b/internal/runtime/memory/llmextractor.go index 735a06d..789f3b4 100644 --- a/internal/runtime/memory/llmextractor.go +++ b/internal/runtime/memory/llmextractor.go @@ -32,11 +32,12 @@ import ( // // 🆕 2026-10-27（切片 M45）：prompt 里追加**时间性位** `temporal`（四个枚举值）。 // 它**不是**「又一段靠自然语言描述判据」的提示词加固：模型只负责**标注**一个值为 -// 四个枚举之一，**判定**（one_off ⇒ temp / durable ⇒ long / unknown ⇒ 走旧规则） -// 是 temporal.go 里的一段 Go 闭集 switch，落库是 `temporal` 列（迁移 0027）—— -// 因此 AGENTS §9「判据靠元数据，不靠提示词」在这里是**结构性成立**的：即便模型 -// 完全不听这段说明，最坏结果也只是它一律答 unknown（= 回到本片之前的旧规则）， -// 不会产生任何新的误判路径。 +// 四个枚举之一，落库是 `temporal` 列（迁移 0027）。 +// +// 🔴 **这一位目前不参与判定**（r1 复审裁决 D）：`resolveRetention` 不读它，判定的 +// 结论集与没有它逐字相同 —— 保留它只为积累「模型到底怎么标」的证据（temporal.go +// 头注记着两次被生产重放否掉的接线方案与接线前必须看的那份分布）。因此这段 prompt +// 的**唯一**作用是让观测面有数据；即便模型完全不听，判定的行为与今天一致。 const extractSystemPrompt = `你是记忆提取器。从对话中提取**值得长期记住**的记忆项。 只保留这些（正向清单）： @@ -59,20 +60,18 @@ const extractSystemPrompt = `你是记忆提取器。从对话中提取**值得 每条还要标一个**时间性位** "temporal"，只能取下面四个英文值之一： - "one_off"：这条说的是**某一次**发生的事（今天 / 昨天 / 这次 / 某个具体日子）， - 即使你已经把它写成「用户……」这样的陈述句 —— 一次性事件标成 durable 会让它 - 永远留着，标成 one_off 会让它进临时层、到期自动消失，所以只有确实只发生过 - 一次时才标它； + 即使你已经把它写成「用户……」这样的陈述句； - "recurring"：说的是**反复发生**的规律（每天 / 每周 / 每次都…）； - "durable"：说的是**长期成立**的事实 / 偏好 / 约定 / 称呼 / 身份； - "unknown"：拿不准，或者上面三个都不贴切。 temporal 只许填这四个英文值之一（不要换成中文、不要自造新值）；拿不准就填 -"unknown" —— 标错方向的代价不对称：标成 one_off 会让本该留着的记忆被提前删掉。 +"unknown"。这个标记会被记录下来供以后核对用途，如实标注即可，不要为了省字省掉它。 只输出一个 JSON 数组，不要任何其他文字。每个元素形如： {"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（它会进临时层）。` +如果值得记，也照实提取，并把 temporal 标成 one_off。` // llmCandidate 是提取器要求 LLM 输出的线上形状：每条候选 // 记忆一个 JSON 对象。模型未给出合法值时，Scope/Kind 取提取器配置的 diff --git a/internal/runtime/memory/preinsert.go b/internal/runtime/memory/preinsert.go index 04b0f69..473161f 100644 --- a/internal/runtime/memory/preinsert.go +++ b/internal/runtime/memory/preinsert.go @@ -97,12 +97,13 @@ const ( // 规则。**规则内容与阈值未改**（同一份 N1~N7），但**判据的作用范围变了**： // 档位与 `expires_at` 现在对**每一行**在同一笔 INSERT 里落下，且不再依赖同步闸 // 是否开启 —— 同一对条目在 d3.3 与 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 还能 -// 读到「这是不是一次性事件」这一位）—— 结论会变，按规矩升版，否则新旧留痕 -// 无法区分。 +// - `d3.5`（切片 M45）**记录 `temporal` 信号，但不参与判定**：提取器在产出侧多 +// 标了一维时间性位（`one_off` / `recurring` / `durable` / `unknown`，迁移 0027）， +// 随同一笔 INSERT 落库。**判定的结论集与 d3.4 逐字相同**（`resolveRetention` +// 不读这一位，见 retention.go 头注：复审裁决 D —— 两次候选接线都被生产重放否掉）。 +// 那为什么仍升版？因为**留痕面变了**：同一对条目在 d3.4 与 d3.5 下虽然结论相同， +// 但 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 fb6c106..03d08d1 100644 --- a/internal/runtime/memory/preinsert_defer_test.go +++ b/internal/runtime/memory/preinsert_defer_test.go @@ -276,13 +276,15 @@ func TestIngestGatePlanExpiresAtUsesSameLayoutAsTimeGate(t *testing.T) { // 规则内容未改但判据的作用范围变了（每一行都在同一笔 INSERT 里落档位与有效期， // 且不再依赖同步闸是否开启），因此按规矩升版。 // -// d3.5（切片 M45）给判定链补上「时间性元数据位」：`one_off` ⇒ temp、 -// `durable` / `recurring` ⇒ long、`unknown` ⇒ 旧规则。N1~N7 的规则与阈值一字未改， -// 但同一段正文的结论会变（d3.4 只能靠词判），因此同样按规矩升版。 +// d3.5（切片 M45）**记录 `temporal` 信号，但不参与判定**：提取器产出侧多标了一维 +// 时间性位（迁移 0027），随同一笔 INSERT 落库；`resolveRetention` 不读它，因此 +// 判定的结论集与 d3.4 逐字相同。仍升版是因为**留痕面变了**（库里多了「模型当时标了 +// 什么」这一维），将来接线时要能区分「接线前/后」的结论 —— 理由见 preinsert.go +// 的版本史。 func TestIngestRuleVersionIsD35(t *testing.T) { t.Parallel() if IngestRuleVersion != "d3.5" { - t.Fatalf("IngestRuleVersion = %q, want d3.5（时间性元数据位接入判定链）", IngestRuleVersion) + t.Fatalf("IngestRuleVersion = %q, want d3.5（记录 temporal 信号，但不参与判定）", IngestRuleVersion) } } diff --git a/internal/runtime/memory/retention.go b/internal/runtime/memory/retention.go index 6225003..759e32b 100644 --- a/internal/runtime/memory/retention.go +++ b/internal/runtime/memory/retention.go @@ -95,18 +95,16 @@ type retentionVerdict struct { // 2. **显式给了有效期**（`item.ExpiresAt` 非零）⇒ 这一行会到期 ⇒ 它就是临时记忆。 // 两者是同一根轴的两种表达，因此这里不是「推导」，而是同一个事实的补全。 // 3. **受限来源**（群聊 / 陌生人）⇒ 不分型（空串）。见文件头注 ②。 -// 4. **提取器的时间性元数据位**（迁移 0027、temporal.go）： -// `durable` / `recurring` ⇒ long 并**不再跑规则**（模型已答「不是一次性事件」， -// 方向是 fail-safe：多留）；`one_off` ⇒ **不作结论**，只把 N6 的位置判据放开 -// （交给下一步的同一份规则跑，语义安全阀照旧）；`unknown` / 未分型 ⇒ 规则照旧。 -// 🔴 `one_off` **不是**「无条件 temp」：r1 复审裁定这一位只接管位置判据， -// 不接管语义判据（详见 temporal.go 头注）。🔴 `unknown` 也绝不等于「一次性」。 -// 5. **留存规则命中**（design/03 §10.5 的 N1~N7）⇒ temp，并带回规则码。 -// 6. 其余 ⇒ long（默认落点，fail-safe）。 +// 4. **留存规则命中**（design/03 §10.5 的 N1~N7）⇒ temp，并带回规则码。 +// 5. 其余 ⇒ long（默认落点，fail-safe）。 // -// 排在第 3 步之后的理由与它自己一致：受限来源的留存由来源面决定（后台到期清扫 -// 跳过它们，expire.go 的 `nonOwnerSource`），若时间性位把它们判成 temp，就会造出 -// 一条「对读面隐藏、却永远不会被删」的行 —— 那是本条要避免的形态。 +// 🔴 **`temporal`（迁移 0027 的时间性元数据位）不在这个列表里**（r1 复审裁决 D， +// 2026-10-27）：这一位目前**只落库、只观测，不参与任何判定**。它被接进判定的两个 +// 候选设计都已被生产重放否掉 —— ①无条件 `one_off ⇒ temp` 会当天删掉 21 条长期约定； +// ②只放开 N6 位置判据，最近 500 条里能翻的 13 条**逐条都是约定**、而复审点名的 +// 三条目标行 0/3 救得了（详见 temporal.go 头注）。因此判定的结论集与「没有这一位」 +// 逐字相同；temporal_test.go 有一条正断言钉住「喂 one_off 不影响任何结论」， +// 另有一条变异靶子（把这一位重新接进本函数 ⇒ 那条正断言必红）。 // // 🔴 「判第五态 `defer`」与「判 `retention_tier=temp`」**就是这一步**：闸与异步审查 // 都只读 `item.RetentionTier`（preinsert_judge.go），不再各自跑一遍规则。M27/M37 的 @@ -125,12 +123,7 @@ func resolveRetention(item MemoryItem) (retentionVerdict, error) { if nonOwnerSource(item.SourceConversation) { return retentionVerdict{Tier: RetentionTierUnset}, nil } - // 时间性位只有 `durable` / `recurring` 直接出结论；`one_off` 作为**输入**进规则层 - // （放开 N6 的位置判据），因此下面这一行必须把 `item.Temporal` 传下去。 - if tier, ok := temporalTier(item.Temporal); ok { - return retentionVerdict{Tier: tier}, nil - } - if rule := judgeExtractionRetention(item.Content, item.Temporal); rule != retentionNone { + if rule := judgeExtractionRetention(item.Content); rule != retentionNone { return retentionVerdict{Tier: RetentionTemp, Rule: rule}, nil } return retentionVerdict{Tier: RetentionLong}, nil diff --git a/internal/runtime/memory/store.go b/internal/runtime/memory/store.go index 9b829b6..0c0ca7c 100644 --- a/internal/runtime/memory/store.go +++ b/internal/runtime/memory/store.go @@ -138,8 +138,11 @@ type MemoryItem struct { // Temporal 是**提取器给出的时间性元数据位**（迁移 0027、temporal.go）： // one_off / recurring / durable / unknown，空串 = 未分型（历史行与没做时间性 - // 判断的写入路径，口径见 temporal.go 头注）。它只由提取器在**产出侧**填，判定侧 - // （resolveRetention）读它一位，不让任何规则去猜「这句话说的是不是今天的事」。 + // 判断的写入路径，口径见 temporal.go 头注）。 + // + // 🔴 **它目前只观测、不参与判定**（r1 复审裁决 D）：`resolveRetention` 不读它， + // 判定的结论集与「没有这一位」逐字相同。保留它是为了积累「模型到底怎么标」的 + // 证据 —— 接线前必须先看那份分布（temporal.go 头注里给了查询）。 // // ⚠️ **与 ExpiresAt 同样是「只写不读」的列**：`Add` 把它写进 `temporal` 列， // 但四条列表读路径的 SELECT 与 scanItem 都不读它 —— 改扫描口径要动全部读点 @@ -302,10 +305,10 @@ func NewStore(ctx context.Context, db *sql.DB, log *slog.Logger) (*Store, error) // expires_at 之间的短窗口」在本片被结构性关闭（不再有第二笔 UPDATE）。 // // 🆕 切片 M45：`item.Temporal`（时间性元数据位，迁移 0027）也随**这一笔** INSERT -// 落下（`temporal` 列）。它的判定作用发生在同一次 `resolveRetention` 里（temporal.go -// 的 temporalTier 出 long 结论 / judgeExtractionRetention 放开 N6 的位置判据，两处都 -// 在那一个函数内），列值本身是**留痕**：记录提取器当时标了什么，供事后巡检 -// 「模型答的是不是 one_off」—— 判定与留痕因此不会分叉。 +// 落下（`temporal` 列）。**它只落库、不参与判定**（r1 复审裁决 D）：`resolveRetention` +// 不读这一位，因此档位/有效期与「没有这一位」逐字相同；列值的作用是**观测**—— +// 事后能按它分组统计、抽样看模型把哪些行标成了 `one_off`（这是将来决定要不要接线 +// 的唯一证据来源，见 temporal.go 头注的查询）。 func (s *Store) Add(ctx context.Context, item MemoryItem) (MemoryItem, error) { if err := item.normalize(); err != nil { return MemoryItem{}, err diff --git a/internal/runtime/memory/temporal.go b/internal/runtime/memory/temporal.go index 87354d6..3184ed3 100644 --- a/internal/runtime/memory/temporal.go +++ b/internal/runtime/memory/temporal.go @@ -2,86 +2,71 @@ package memory import "strings" -// 本文件是**提取器产出侧的时间性元数据位**（`temporal`，迁移 0027）：它回答 -// 「这条记忆说的是**一次发生的事**，还是**反复 / 长期成立的事**」。 +// 本文件是**提取器产出侧的时间性元数据位**（`temporal`，迁移 0027）：它记录模型对 +// 「这条记忆说的是**一次发生的事**，还是**反复 / 长期成立的事**」的判断。 // -// 为什么需要这一位（M37 复审的结论，逐字）：「真正卡住上游的是**提取器的改写**： +// 当初为什么要这一位（M37 复审的结论，逐字）：「真正卡住上游的是**提取器的改写**： // 一次性事件被写成 30~80 字的第三人称长期陈述（同时带『近期/目前』和持久词）， // 规则闸看不到『这是今天的一次性事件』这一位。这不是阈值问题，是**判定链缺信息位**。」 // -// 🔴 **这一位只接管 N6 的「位置判据」**（2026-10-27 r1 复审裁定）：词项规则里唯一 -// 真正不可靠的是 **N6 的「时点词必须出现在句首 12 字内」**——提取器改写出的第三人称 -// 长句本来就把时点埋在中段，窗口再放宽（12→24）就会连「同一条长期约定的重复陈述」 -// 一起命中并删掉约定（M37 已量：2→14，多出的 11 条逐条都是约定）。因此： +// 🔴 **当前状态：只观测，不参与判定**（r1 复审裁决 D，2026-10-27）。`resolveRetention` +// **不读**这一位，判定的结论集与「没有这一位」逐字相同。保留它的唯一目的是**积累 +// 证据**：等真实提取跑出一批标签之后，再回答「模型到底怎么标」以及「接进判定是赚 +// 还是亏」。 // -// - 模型说 `one_off` ⇒ **N6 忽略位置窗口**（时点词出现在哪儿都算锚点）； -// - **N6 的全部语义安全阀照旧**（习惯词 / 硬性长期事实词 / 具体约束 / 永久化 / -// 状态改变 / 寒暄情绪）—— 它们判的是「这句话不止是一个时刻」，与位置无关； -// - N1~N5、N7、护栏①② 一字不动。 +// 为什么撤（两次候选接线都被生产重放否掉，别再凭直觉改回去）： // -// 🔴 r1 复审推翻的两条自造设计（别再写回来）： +// ① **无条件 `one_off ⇒ temp`**（任务书初版口径）：最近 500 条 active 里人工按 +// 提取器口径标出的 23 条 `one_off`，其中 21 条是「约定 + 某一次没走成」形态 ⇒ +// 7 天后**把约定本身物理删掉**（不可撤回）。 +// ② **只放开 N6 的位置判据**（r1 复审给的改法）：能翻的行在窗口内 13 条、**逐条都是 +// 约定**（`约定/约好 + 今天没走成`），而复审点名的三条目标行 **0/3** 救得了 +// （`…睡得比平时早` 被习惯词、`…以后不用再惦记` 被永久化标记、`自行车链条` 那条 +// 没有时点词）⇒ 收益为 0、风险集中在长期约定。 // -// ① **不要**给 `one_off` 再叠一层「约定/长期事实」词表否决 —— 它既把该救的行一起 -// 杀了（「昨晚…睡得比平时早」被习惯词杀掉、「今天就终于把 bug 修好了，以后不用 -// 再惦记」被永久化标记杀掉，而这两条正是这一位该救的），又挡不住同义异形的 -// 约定（`说定`/`约了` 不在任何词表里）—— 词面否决在**两个方向**上都不安全； -// ② **不要**用「句首时点词且不触发任何阀门」当上界 —— 那种行 N6 本来就判 temp， -// 拿它当上界是同义反复，恰好把本片要救的「时点词不在句首」整类排除在外。 +// 还有一层方法论上的理由：以上两轮数字**全部**建立在「对历史改写正文**人工**标注」 +// 上 —— 生产库里 `temporal` 列当时还不存在，模型从未在这批正文上产出过标签。 +// 用人工标签去决定一条「模型标签驱动」的接线，证据链是断的。 // -// ⚠️ **已知代价（2026-10-27 生产重放实测，r1 复审要求如实登记，不许美化）**： -// 位置窗口今天**正是**那批「约定 + 某一次没走成」行的唯一保护（它们的时点词都埋在 -// 中段）。放开位置之后： +// 将来真要接线，前置条件是**这份数据**（不是又一次重放）： // -// - 最近 500 条 active 里**能翻的 13 条逐条都是这种约定**（`约定/约好 + 今天没走成`）； -// - 全量 3694 条里能翻 26 条，其中 13 条是约定，另 13 条是「项目/宿舍/换装/探针」 -// 这类状态行； -// - 而 r1 复审点名的两条目标行（`昨晚…睡得比平时早` 被习惯词、 -// `今天就终于把 bug 修好了，以后不用再惦记` 被永久化标记）**本片救不了** —— -// 它们是被语义安全阀挡的，与位置无关。 +// SELECT temporal, COUNT(*) FROM memory_items GROUP BY temporal; +// SELECT created_at, retention_tier, content FROM memory_items +// WHERE temporal = 'one_off' ORDER BY created_at DESC LIMIT 10; // -// 也就是说：**在当前语料上，这一位没有可测收益，风险集中在长期约定上。** 是否保留 -// 是产品裁决（M45 报告 §决策矩阵），不是代码判断；本文件只保证「放开位置的边界」是 -// 确定的、可测的、可回退的。 +// 看 `one_off` 那 10 条里有多少是长期约定 —— 那才是「这一位能不能用」的判据。 // // 闭集（与迁移 0027 的列值口径逐字一致）： // -// one_off 一次性事件（今天 / 这次 / 某一次发生的事）⇒ 放开 N6 的位置判据 -// recurring 反复发生的规律（每天 / 每周 / 每次都…）⇒ long（不进规则） -// durable 长期成立的事实 / 偏好 / 约定 / 称呼 / 身份 ⇒ long（不进规则） -// unknown 模型拿不准，或没给出合法值 ⇒ **没有结论**，规则照旧 -// '' 尚未分型 ⇒ 与 unknown 同路（规则照旧）。它出现在两类行上： -// ① 0027 之前的历史行； -// ② **没做时间性判断的写入路径** —— `ManualExtractor`（「记住 X」， -// 它把档位显式钉成 long，见 extract.go）、网关/管理面的手写记忆 -// （`RetentionTier: long`）、整理侧回填。这些路径本来就由调用方 -// 显式给档位，因此空串在这里不丢信息（档位判定第 1 步先命中）。 +// one_off 一次性事件（今天 / 这次 / 某一次发生的事） +// recurring 反复发生的规律（每天 / 每周 / 每次都…） +// durable 长期成立的事实 / 偏好 / 约定 / 称呼 / 身份 +// unknown 模型拿不准，或没给出合法值 +// '' 尚未分型：0027 之前的历史行 + 没做时间性判断的写入路径 +// （`ManualExtractor` 的「记住 X」、网关/管理面手写、整理侧回填 —— +// 它们本来就由调用方显式给档位） // -// 🔴 `unknown` 与 `”` 在判定上**走同一条路**（规则照旧），但在口径上是两件事： -// `unknown` 是「问过模型了，它拿不准」；`”` 是「这条路径没问过」。把两者折成一个值 -// 会让「模型到底答了什么」这个观测面当场消失，而那正是本片要验证的东西。 +// 🔴 `unknown` 与 `”` 是两件事：`unknown` 是「问过模型了，它拿不准」；`”` 是 +// 「这条路径没问过」。把两者折成一个值会让「模型到底答了什么」这个观测面当场消失， +// 而那正是保留这一位的全部意义。 type TemporalKind string const ( // TemporalUnset 是「尚未分型」：历史行与没做时间性判断的写入路径（见文件头注）。 - // **它不是业务取值**，判定上与 TemporalUnknown 同路，但含义不同。 + // **它不是业务取值**，也**不是**「unknown」的同义词。 TemporalUnset TemporalKind = "" - // TemporalOneOff 是一次性事件。它是本片唯一会**收紧**判定的时间性位：命中即 - // 让 N6 忽略位置窗口（时点词出现在句子中段也算锚点）。语义安全阀照旧，因此它 - // 仍然不是「无条件判 temp」——这一点是 r1 复审的裁定，别再改回去。 + // TemporalOneOff 是一次性事件。它目前**不改变任何判定**：写入时只落库， + // 供事后统计「模型把哪些行标成了某一次发生的事」。 TemporalOneOff TemporalKind = "one_off" // TemporalRecurring 是反复发生的规律（「每天散步十分钟」「每周三开会」）。 - // 「反复」= 将来还会再发生，因此不许进临时层：命中即判 long，不再跑规则。 TemporalRecurring TemporalKind = "recurring" - // TemporalDurable 是长期成立的事实 / 偏好 / 约定 / 称呼 / 身份。同样判 long、 - // 不再跑规则（方向仍是 fail-safe：多留一条）。 + // TemporalDurable 是长期成立的事实 / 偏好 / 约定 / 称呼 / 身份。 TemporalDurable TemporalKind = "durable" - // TemporalUnknown 是「问过模型了，它拿不准」。**它绝不是「一次性」的同义词**： - // 判定上它与未分型一样落到 N1~N7，不许因为「正文看着像今天的事」就判 temp —— - // 那等于把本片要消灭的猜测重新引回判定链。 + // TemporalUnknown 是「问过模型了，它拿不准」。 TemporalUnknown TemporalKind = "unknown" ) @@ -100,21 +85,12 @@ func (t TemporalKind) valid() bool { // 比较去替代它（那是「问过但拿不准」，不是「没问过」）。 func (t TemporalKind) assigned() bool { return t != TemporalUnset } -// unlocksTimepointPosition 报告这一位是否**放开 N6 的位置判据**。 -// -// 只有 `one_off` 会：模型已经回答了「这是某一次发生的事」，那么时点词埋在句中 -// （「…整理到一半，今天下午才收尾」）就不再是「它不是一个时刻锚点」的证据。 -// `unknown` / 未分型 / durable / recurring 一律不放开。 -func (t TemporalKind) unlocksTimepointPosition() bool { - return t == TemporalOneOff -} - // normalizeTemporal 把模型输出的自由文本归一到上面四个值。 // // 🔴 **只做大小写折叠与首尾空白裁剪，绝不做同义词猜测**（「一次性」「once」→ 都不认）： // 认不出来的答案就是解析失败，一律落 TemporalUnknown —— 这正是任务书 -// 「模型只能选那四个值，解析失败一律归 unknown（绝不猜）」的字面实现。 -// 猜同义词的代价是单向的：猜成 one_off 就删记忆，猜成别的只是多留一条。 +// 「模型只能选那四个值，解析失败一律归 unknown（绝不猜）」的字面实现。将来接线时 +// 这条尤其重要：猜同义词的代价是单向的（猜成 one_off 就删记忆）。 func normalizeTemporal(s string) TemporalKind { switch TemporalKind(strings.ToLower(strings.TrimSpace(s))) { case TemporalOneOff: @@ -130,20 +106,3 @@ func normalizeTemporal(s string) TemporalKind { return TemporalUnknown } } - -// temporalTier 给出**模型直接给出的档位结论**（只由 resolveRetention 第 4 步调用）。 -// -// 只有 `durable` / `recurring` 有结论（long）：模型已经回答了「这不是一次性事件」， -// 此时再让词项规则判 temp 就是把「判定链缺的那一位」又丢掉；方向是 fail-safe（多留）。 -// -// `one_off` **不在这里**出结论 —— 它作为**输入**进规则层（放开 N6 的位置判据）， -// 语义安全阀照旧（r1 复审裁定，见文件头注）；`unknown` / 未分型同样没有结论， -// 规则照旧。 -func temporalTier(t TemporalKind) (RetentionTier, bool) { - switch t { - case TemporalDurable, TemporalRecurring: - return RetentionLong, true - default: - return RetentionTierUnset, false - } -} diff --git a/internal/runtime/memory/temporal_migration_test.go b/internal/runtime/memory/temporal_migration_test.go index 540435c..369cfa2 100644 --- a/internal/runtime/memory/temporal_migration_test.go +++ b/internal/runtime/memory/temporal_migration_test.go @@ -184,7 +184,7 @@ func TestMigration0027ThenStoreBootstrapIsARegularPath(t *testing.T) { t.Fatalf("第二次自举改变了表结构：\n got=%v\nwant=%v", got, after) } - item := habitItem(temporalWideTimepointCorpus()[0], tidyTestTime(t), 0.9) + item := habitItem("主人有一条真实落库的观测样本", tidyTestTime(t), 0.9) item.Temporal = TemporalOneOff got, err := store.Add(ctx, item) if err != nil { diff --git a/internal/runtime/memory/temporal_test.go b/internal/runtime/memory/temporal_test.go index b14abb1..9d775c4 100644 --- a/internal/runtime/memory/temporal_test.go +++ b/internal/runtime/memory/temporal_test.go @@ -4,30 +4,172 @@ import ( "context" "strings" "testing" - "time" "git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model" ) // 本文件是**时间性元数据位**（迁移 0027、temporal.go）的验收用例集。 // -// 🔴 这一位的职责边界（r1 复审裁定，决定了下面每条断言的写法）： +// 🔴 当前契约（r1 复审裁决 D，2026-10-27）：**这一位只观测，不参与判定。** +// `resolveRetention` 不读它，判定的结论集与「没有这一位」逐字相同。因此本文件最重要 +// 的一条断言是**零影响**（TestTemporalBitDoesNotAffectRetention）：同一段正文， +// 无论 `temporal` 是 five 个取值里的哪一个，档位与规则码都必须完全相同。 // -// 它**只接管 N6 的位置判据** —— 模型说「这是某一次发生的事」⇒ 时点词埋在句子中段 -// 也算锚点。N6 的**全部语义安全阀照旧**（习惯词 / 硬性长期事实词 / 具体约束 / -// 永久化 / 状态改变 / 寒暄情绪），N1~N5、N7、护栏①② 一字不动。 -// -// 因此「`one_off` ⇒ 一定 temp」**不是**本片的语义（那是任务书初版口径，r1 复审用 -// 生产语料推翻了：按它实现会当天删掉 21 条长期约定）。下面的用例逐条钉住的是 -// 「放开位置后能翻哪些行」与「翻不了哪些行」——后者同样是断言，因为它们是**已知的 -// 边界**，不是待修的缺陷。 +// 变异靶子与之配套：谁把这一位重新接进 `resolveRetention`（例如先加一句 +// `if item.Temporal == TemporalOneOff { return temp }`），那条正断言必红 —— +// 这不是「测试太严」，而是「接线前必须先有模型真实标签分布」这个裁决的守卫。 -// temporalWideTimepointCorpus 是**只有放开位置判据才会命中**的夹具语料：时点词都在 -// 12 字之后（或句中没有），语义安全阀全部不触发。 -func temporalWideTimepointCorpus() []string { +// temporalObservationCorpus 覆盖三类正文，每类都必须对 temporal 免疫： +// +// ① 旧规则判 long 的行（接线的「收益」候选）； +// ② 旧规则判 temp 的行（`durable` 也不能把它们救回来 —— 零影响是双向的）； +// ③ 受限来源 / 显式档位这类「更早的分支」（它们更不该被这一位碰到）。 +func temporalObservationCorpus() []string { return []string{ - "桌面上的文件整理到一半，今天下午才收尾", - "主人把桌面上的文件整理到一半，昨天被别的事打断了", + "和主人有一个出门走十分钟的约定；今天没走成，明天要补上。", + "主人有每天吃早餐的习惯，几乎不会省略早餐。", + "今天下雨了", + "谢谢啦", + } +} + +// temporalAllKinds 是「业务上可能出现的全部取值」+ 未分型。 +func temporalAllKinds() []TemporalKind { + return []TemporalKind{ + TemporalUnset, TemporalOneOff, TemporalRecurring, TemporalDurable, TemporalUnknown, + } +} + +// TestTemporalBitDoesNotAffectRetention 是本文件的核心断言：**temporal 对留存判定零影响** +// ——对同一段正文，五个取值的 `(档位, 规则码)` 必须逐字相同（且都以未分型为基准）。 +func TestTemporalBitDoesNotAffectRetention(t *testing.T) { + t.Parallel() + for _, content := range temporalObservationCorpus() { + content := content + t.Run(content, func(t *testing.T) { + base, err := resolveRetention(habitItem(content, tidyTestTime(t), 0.9)) + if err != nil { + t.Fatalf("resolveRetention(base): %v", err) + } + for _, temporal := range temporalAllKinds() { + item := habitItem(content, tidyTestTime(t), 0.9) + item.Temporal = temporal + got, err := resolveRetention(item) + if err != nil { + t.Fatalf("resolveRetention(temporal=%q): %v", temporal, err) + } + if got != base { + t.Fatalf("%q with temporal=%q 判成 %+v, want %+v（这一位必须零影响；"+ + "接线前必须先拿到模型真实标签分布，见 temporal.go 头注）", + content, temporal, got, base) + } + } + }) + } +} + +// TestTemporalOneOffDoesNotMakeAnythingTemporary 是上一条的正向版本，单独成例是为了 +// 让「接线会怎样」在失败信息里一眼可见：它只喂 `one_off`，并点名断言「旧规则判 long +// 的行仍然 long」。 +func TestTemporalOneOffDoesNotMakeAnythingTemporary(t *testing.T) { + t.Parallel() + const content = "和主人有一个出门走十分钟的约定；今天没走成，明天要补上。" + base, err := resolveRetention(habitItem(content, tidyTestTime(t), 0.9)) + if err != nil { + t.Fatalf("resolveRetention(base): %v", err) + } + if base.Tier != RetentionLong { + t.Fatalf("前提不成立：%q 旧规则判 %q（want long）", content, base.Tier) + } + item := habitItem(content, tidyTestTime(t), 0.9) + item.Temporal = TemporalOneOff + got, err := resolveRetention(item) + if err != nil { + t.Fatalf("resolveRetention(one_off): %v", err) + } + if got.Tier != RetentionLong || got.Rule != retentionNone { + t.Fatalf("temporal=one_off 把 %q 判成 %+v —— 这一位不得参与判定（裁决 D）", content, got) + } +} + +// TestTemporalIsStillRecorded 钉住「撤接线不等于撤观测」：`temporal` 仍随同一笔 +// INSERT 落库（迁移 0027 的列），而档位/有效期保持旧规则的结论 —— 这正是 D 要的 +// 数据来源：全库按 temporal 分组统计、抽样看 one_off 到底长什么样。 +func TestTemporalIsStillRecorded(t *testing.T) { + t.Parallel() + ctx := context.Background() + store := newTestStore(t) + const content = "和主人有一个出门走十分钟的约定；今天没走成，明天要补上。" + item := habitItem(content, 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("temporal 列 = %q, want %q（观测面必须保留）", nat, TemporalOneOff) + } + tier, expires := readRetentionColumns(t, store, got.ID) + if tier != RetentionLong || expires != "" { + t.Fatalf("落库档位/时效 = (%q, %q), want (long, 空) —— 观测不得改变判定", + tier, expires) + } +} + +// TestTemporalDoesNotRescueRuleHitRows 钉住零影响是**双向**的：`durable` 曾经（M45 +// 初版）能把规则判 temp 的行救回 long；裁决 D 之后这条也取消 —— 判定只由 N1~N7 决定。 +func TestTemporalDoesNotRescueRuleHitRows(t *testing.T) { + t.Parallel() + const content = "今天下雨了" + base, err := resolveRetention(habitItem(content, tidyTestTime(t), 0.9)) + if err != nil { + t.Fatalf("resolveRetention(base): %v", err) + } + if base.Tier != RetentionTemp { + t.Fatalf("前提不成立：%q 旧规则判 %q（want temp）", content, base.Tier) + } + for _, temporal := range []TemporalKind{TemporalDurable, TemporalRecurring} { + item := habitItem(content, tidyTestTime(t), 0.9) + item.Temporal = temporal + got, err := resolveRetention(item) + if err != nil { + t.Fatalf("resolveRetention(%q): %v", temporal, err) + } + if got != base { + t.Fatalf("%q with temporal=%q 判成 %+v, want %+v（这一位不得推翻规则）", + content, temporal, got, base) + } + } +} + +// TestTemporalDoesNotTouchExplicitTierOrRestrictedSource 钉住「更早的分支」不被这一位 +// 影响：显式档位（人工入口）与受限来源（群聊/陌生人）都排在第 1/3 步。 +func TestTemporalDoesNotTouchExplicitTierOrRestrictedSource(t *testing.T) { + t.Parallel() + ctx := context.Background() + store := newTestStore(t) + + explicit := habitItem("谢谢啦", tidyTestTime(t), 0.9) + explicit.RetentionTier = RetentionLong + explicit.Temporal = TemporalOneOff + got, err := store.Add(ctx, explicit) + if err != nil { + t.Fatalf("Add(explicit long): %v", err) + } + if tier, _ := readRetentionColumns(t, store, got.ID); tier != RetentionLong { + t.Fatalf("显式 long + one_off 落库 = %q, want long（调用方显式档位不许被推翻）", tier) + } + + restricted := habitItem("今天下雨了", tidyTestTime(t), 0.9) + restricted.Temporal = TemporalOneOff + restricted.SourceConversation = FormatSourceConversation("sess-group-1", "msg-1") + got, err = store.Add(ctx, restricted) + if err != nil { + t.Fatalf("Add(restricted): %v", err) + } + tier, expires := readRetentionColumns(t, store, got.ID) + if tier != RetentionTierUnset || expires != "" { + t.Fatalf("受限来源 + one_off 落库 = (%q, %q), want (未分型, 空)", tier, expires) } } @@ -43,321 +185,11 @@ func readTemporalColumn(t *testing.T, store *Store, id string) TemporalKind { return TemporalKind(raw) } -// TestTemporalOneOffWidensTimepointPosition 钉住本片**唯一**的判定效果（也是变异靶子）： -// 时点词在句中时，`temporal=one_off` ⇒ N6 照常命中（规则码 `n6_timepoint_wide`）⇒ -// 全链落库 `(temp, 非空 expires_at)`；而**同一段正文**在未分型时是 long。 +// TestNormalizeTemporal 钉住归一化口径：**只认四个字面值**，其余（空 / 中文 / 自造 / +// 拼写变体）一律 unknown。 // -// 变异方向：把 unlocksTimepointPosition 改成恒 false（或把 temporal 参数丢掉） -// ⇒ 本用例的三条断言全红。 -func TestTemporalOneOffWidensTimepointPosition(t *testing.T) { - t.Parallel() - ctx := context.Background() - store := newTestStore(t) - for _, content := range temporalWideTimepointCorpus() { - content := content - t.Run(content, func(t *testing.T) { - // 前提：这段正文在**旧规则**下是 long（时点不在句首 12 字内）。 - 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) - } - // 放开位置后：命中 N6，规则码是 **wide** 那一档（可区分「词判」与「模型放开位置」）。 - item := habitItem(content, tidyTestTime(t), 0.9) - item.Temporal = TemporalOneOff - verdict, err := resolveRetention(item) - if err != nil { - t.Fatalf("resolveRetention(one_off): %v", err) - } - if verdict.Tier != RetentionTemp || verdict.Rule != retentionTimepointWide { - t.Fatalf("temporal=one_off 的 %q = %q/%q, want temp/%q", - content, verdict.Tier, verdict.Rule, retentionTimepointWide) - } - // 全链落库：与生产同一条写路径（Store.Add 是唯一 INSERT 路径）。 - got, err := store.Add(ctx, item) - if err != nil { - t.Fatalf("Add: %v", err) - } - tier, expires := readRetentionColumns(t, store, got.ID) - if tier != RetentionTemp { - t.Fatalf("落库档位 = %q, want %q", tier, RetentionTemp) - } - if expires == "" { - t.Fatalf("判成 temp 却没写 expires_at（两列分叉）") - } - if got.ExpiresAt.IsZero() { - t.Fatalf("Add 返回值没回填 ExpiresAt（调用方看不见「到期到哪」）") - } - if nat := readTemporalColumn(t, store, got.ID); nat != TemporalOneOff { - t.Fatalf("temporal 列 = %q, want %q（判定与留痕不许分叉）", nat, TemporalOneOff) - } - }) - } -} - -// TestTemporalOneOffKeepsFrontedTimepointRule 钉住「放开位置」不改变**已经命中**的 -// 那些行：时点在句首时，规则码仍是 `n6_timepoint`（不是 wide）—— 否则留痕里就分不清 -// 「词判的」与「模型放开位置后判的」，而那条观测线正是本片要交的东西。 -func TestTemporalOneOffKeepsFrontedTimepointRule(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.Rule != retentionTimepoint { - t.Fatalf("时点在句首时规则码 = %q, want %q（这一条不需要模型放开位置）", - verdict.Rule, retentionTimepoint) - } -} - -// TestTemporalOneOffWidenedPositionTouchesAgreements 把 r1 复审指出的**已知风险** -// 写成断言（而不是留一个词表去掩盖它）。 -// -// 事实：N6 的位置窗口**今天正是**那批「约定 + 某一次没走成」行的唯一保护 —— 它们的 -// 时点词都埋在中段。放开位置之后，只要模型把这些行标成 `one_off`，它们就会判 temp、 -// 7 天后被删。2026-10-27 生产重放实测：最近 500 条里**能翻的 13 条逐条都是这种约定** -// （全量 3694 条里 26 条，其中 13 条是约定）。 -// -// 为什么不在这里加词表：r1 复审已经用两条反例否掉了词面否决 —— 它既挡不住同义异形 -// 的约定（`说定`/`约了`），又会误伤该救的行。因此**安全边界落在这里，而不是代码里**： -// 这些行是否被删，取决于模型把它们标成 durable（prompt 的 durable 定义里就写着 -// 「约定」）还是 one_off。本用例的作用是让这条边界在 diff 里显形、可被复审追踪； -// 是否接受它，是塔的裁决（见 M45 报告的决策矩阵）。 -func TestTemporalOneOffWidenedPositionTouchesAgreements(t *testing.T) { - t.Parallel() - const content = "和主人约了傍晚出门走十分钟，今天没走成，明天补" - 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 = %q —— 若这里变成 long，说明位置判据没有被放开（本片的全部作用消失）；"+ - "若它一直是 temp，则是已知的误弃风险，见本用例头注", content, verdict.Tier) - } -} - -// TestTemporalOneOffKeepsSemanticValves 钉住这一位**翻不了**的那两类（r1 复审点名的 -// 生产行）。它们不是缺陷，是职责边界：语义安全阀判的是「这句话不止是一个时刻」， -// 与「时点词在第几个字」无关，因此时间性位不参与它们的判定。 -// -// 如实记录（复审要求）：**这两条正是 M37 说该救的行，而本片救不了它们** —— -// 要救就得让模型推翻习惯词/永久化标记，那是另一件事（见报告）。 -func TestTemporalOneOffKeepsSemanticValves(t *testing.T) { - t.Parallel() - cases := []struct{ content, blockedBy string }{ - {"昨晚主人喝了一杯热牛奶才睡下，睡得比平时早", "习惯词（平时）"}, - {"今天就终于把拖了一个月的 bug 修好了，以后不用再惦记", "永久化标记（以后）"}, - } - 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 - verdict, err := resolveRetention(item) - if err != nil { - t.Fatalf("resolveRetention: %v", err) - } - if verdict.Tier == RetentionTemp { - t.Fatalf("%q 被判成 temp —— 语义安全阀（%s）失效了；这一位只接管位置判据，不许动语义阀", - tc.content, tc.blockedBy) - } - }) - } -} - -// TestTemporalOneOffInProgressPositionUnchanged 钉住 N7 的位置判据**不**被放开： -// r1 复审的裁定只覆盖 N6。「正在」出现在从句里仍然是习惯陈述（「…她正在维护…」）， -// 时间性位没有理由替它开火。 -func TestTemporalOneOffInProgressPositionUnchanged(t *testing.T) { - t.Parallel() - const content = "那件还没有结论的事，主人正在慢慢想" - 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 被判成 temp —— N7 的位置判据不该被时间性位放开（裁定只覆盖 N6）", content) - } -} - -// TestTemporalOneOffWithoutTimepointIsInert 钉住「这一位不是无条件 temp」：正文里 -// 一个时点词都没有时，放开位置也无事可做 —— 结论仍是旧的 long。 -func TestTemporalOneOffWithoutTimepointIsInert(t *testing.T) { - t.Parallel() - const content = "桌面上的文件整理到一半被别的事打断了" - 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 != RetentionLong { - t.Fatalf("%q 没有时点词却判成 %q —— 这一位只放开 N6 的位置，不新造判据", content, verdict.Tier) - } -} - -// TestTemporalDurableAndRecurringStayLong 钉住任务书验收点②：`durable` / `recurring` -// ⇒ `(long, 空)`，**并且覆盖规则闸的 temp 结论**（模型已答「不是一次性事件」， -// 方向是 fail-safe：多留）。 -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) - } - }) - } -} - -// TestTemporalUnknownAndUnsetFollowOldRules 钉住任务书验收点③：`unknown`（以及未分型 -// 的空串）**不许自己判 temp** —— 它们必须原样交给 N1~N7，判据只有旧规则那一份。 -// -// 三条断言方向不同，缺一条都测不出「方向反了」： -// -// 1. `unknown` + 「今天下雨了」⇒ 旧规则 N6 判 temp。这是**旧规则**的结论：规则码必须 -// 是 `n6_timepoint`，**绝不能**是 `n6_timepoint_wide`（后者出现就说明位置判据被 -// 一个「拿不准」的答案放开了）； -// 2. `unknown` + 旧规则非命中的正文 ⇒ long（不许因为看着像一次性就判 temp）； -// 3. 未分型（空串）与 `unknown` 走同一条路（历史行的行为逐字不变）。 -func TestTemporalUnknownAndUnsetFollowOldRules(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 || verdict.Rule != retentionTimepoint { - t.Fatalf("unknown + 「今天下雨了」= %q/%q, want temp/%q（旧规则 N6 的结论，不是 wide）", - verdict.Tier, verdict.Rule, retentionTimepoint) - } - }) - - t.Run("unknown_旧规则非命中", func(t *testing.T) { - store := newTestStore(t) - item := habitItem(temporalWideTimepointCorpus()[0], 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, 空) —— 拿不准就必须留", - 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) - } - } - }) -} - -// TestTemporalOneOffDoesNotTouchRestrictedSource 钉住与受限来源的优先级：群聊 / -// 陌生人的行**不分型**（空串），因此时间性位不许把它们判成 temp —— 那会造出 -// 「对读面隐藏、却永远不会被后台清扫删除」的行（expire.go 跳过非 owner 来源）。 -func TestTemporalOneOffDoesNotTouchRestrictedSource(t *testing.T) { - t.Parallel() - store := newTestStore(t) - item := habitItem("今天下雨了", 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) - } -} - -// TestTemporalBitDrivesDeferThroughGate 钉住判定接线：闸开着时，位置被放开后判出的 -// temp 会走**同一条**第五态 `defer` 落库（留痕 `t0_low_value`），不是另开一条路径。 -func TestTemporalBitDrivesDeferThroughGate(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(temporalWideTimepointCorpus()[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 放开位置后判 temp 的留痕 = %+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("档位 = %q, want %q", tier, RetentionTemp) - } - // 到期时刻来自同一个判定与同一个时钟（闸注入的 now + 面板 TTL）。 - if want := expiryText(base.Add(ttl)); expires != want { - t.Fatalf("expires_at = %q, want %q", expires, want) - } -} - -// TestNormalizeTemporal 钉住验收点④的归一化口径：**只认四个字面值**，其余 -// （空 / 中文 / 自造 / 拼写变体）一律 unknown。 -// -// 不做同义词映射是刻意的：猜同义词的代价是单向的（猜成 one_off 就放开位置判据）， -// 而「拿不准一律留」才是 fail-safe。 +// 不做同义词映射是刻意的：将来接线时猜同义词的代价是单向的（猜成 one_off 就删记忆）， +// 而「拿不准一律 unknown」才是 fail-safe。 func TestNormalizeTemporal(t *testing.T) { t.Parallel() cases := []struct { @@ -387,7 +219,7 @@ func TestNormalizeTemporal(t *testing.T) { // （Add 的 validate 会拒掉它们 —— 那是程序错误，不是模型输出）。 func TestTemporalKindClosedSet(t *testing.T) { t.Parallel() - for _, ok := range []TemporalKind{TemporalUnset, TemporalOneOff, TemporalRecurring, TemporalDurable, TemporalUnknown} { + for _, ok := range temporalAllKinds() { if !ok.valid() { t.Fatalf("%q 应在闭集内", ok) } @@ -400,15 +232,6 @@ func TestTemporalKindClosedSet(t *testing.T) { if TemporalUnknown.assigned() != true || TemporalUnset.assigned() != false { t.Fatal("assigned() 只应对非空串为真（「未分型」的唯一判据）") } - // 只有 one_off 会放开 N6 的位置判据。 - for _, t2 := range []TemporalKind{TemporalUnset, TemporalUnknown, TemporalDurable, TemporalRecurring} { - if t2.unlocksTimepointPosition() { - t.Fatalf("%q 不该放开位置判据", t2) - } - } - if !TemporalOneOff.unlocksTimepointPosition() { - t.Fatal("one_off 必须放开 N6 的位置判据（本片的全部作用）") - } // 非法值必须被写入路径拒掉（不是静默落库成脏列值）。 item := habitItem("一条正文", tidyTestTime(t), 0.9) item.Temporal = TemporalKind("sometimes") @@ -417,8 +240,9 @@ func TestTemporalKindClosedSet(t *testing.T) { } } -// TestLLMExtractorReadsTemporal 钉住验收点④的另一半：提取器**真的**在读模型给的 -// 这一位，且非法 / 缺失值不产生错误、只归 unknown（不拖累同批其他候选）。 +// TestLLMExtractorReadsTemporal 钉住产出侧：提取器**真的**在读模型给的这一位， +// 且非法 / 缺失值不产生错误、只归 unknown（不拖累同批其他候选）。观测面的数据 +// 质量由这条用例守住。 func TestLLMExtractorReadsTemporal(t *testing.T) { t.Parallel() adapter := &mockAdapter{fn: func(_ context.Context, _ model.Request, _ model.Options) (model.Response, error) { @@ -456,7 +280,7 @@ func TestLLMExtractorReadsTemporal(t *testing.T) { // TestExtractionPromptCarriesTemporalEnum 钉住「提示词与闭集不漂移」：模型能看到的 // 取值必须与 normalizeTemporal 认的四个值逐字一致（提示词只是辅助，但取值口径漂了 -// 就会让每条候选都被归成 unknown，这一位等于白加）。 +// 就会让每条候选都被归成 unknown，观测面等于白留）。 func TestExtractionPromptCarriesTemporalEnum(t *testing.T) { t.Parallel() for _, want := range []string{"temporal", "one_off", "recurring", "durable", "unknown"} {