diff --git a/go/internal/api/routes/core.go b/go/internal/api/routes/core.go index 904bfbb..3d0a894 100644 --- a/go/internal/api/routes/core.go +++ b/go/internal/api/routes/core.go @@ -443,9 +443,9 @@ func (a *API) WriteMemory(w http.ResponseWriter, r *http.Request) { Confidence: req.Confidence, ConfidenceSource: confidenceSource, // 2026-11-07 (t_88cc9cb8) 意图 TTL:已通过 400 校验的到期时间(空 = 永久 = 现状)。 - ExpiresAt: req.ExpiresAt, - CreatedAt: now, - UpdatedAt: now, + ExpiresAt: req.ExpiresAt, + CreatedAt: now, + UpdatedAt: now, } if err := a.LanceDB.InsertMemory(mem); err != nil { respondError(w, 500, "insert memory: "+err.Error()) @@ -1181,7 +1181,7 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) { docs[i] = c.Content docVecs[i] = c.Vector } - reranked, rErr := a.Reranker.RerankWithVectors(queryVec, docs, docVecs, req.Limit*2) + reranked, rErr := a.Reranker.RerankPreferAPI(req.Query, docs, queryVec, docVecs, req.Limit*2) if rErr != nil { reranked, rErr = a.Reranker.Rerank(req.Query, docs, req.Limit*2) } @@ -1711,10 +1711,13 @@ func capRecallResults(results []models.RecallResult, limit int) (prim, expanded // 正确语义:主检索结果(distilled 等)照常收口到 limit;pattern/peer 作为附带条目 // 恒保留(不挤占主结果配额),避免「命中即注入」被 cap 吞掉。graph_expanded 仍走独立字段。 var carry []models.RecallResult + var front []models.RecallResult // standing_answer:答案要置顶,不能沉到尾部 for _, r := range results { switch r.Category { case "graph_expanded": exp = append(exp, r) + case "standing_answer": + front = append(front, r) case "pattern", "peer": carry = append(carry, r) default: @@ -1738,7 +1741,14 @@ func capRecallResults(results []models.RecallResult, limit int) (prim, expanded exp = exp[:limit] } } + // standing_answer 置顶:它是「答案」,记忆是「证据」——置顶且不占主结果配额 + if len(front) > 0 { + prim = append(front, prim...) + } // pattern / peer 附带条目恒保留在 results 末尾(独立于主结果配额) + // standing_answer(2026-11-17):语义常设卡 prepend 进 results 后被 limit 切掉第 5 条记忆 + // ⇒ 13 道题的主尺从 0.5575 掉到 0.5337(2 道 DA 恰在 rank5)。卡片是「答案」、记忆是「证据」, + // 两者都不能丢 ⇒ 与 pattern/peer 同待遇:不占主结果配额。 prim = append(prim, carry...) if expanded == nil { expanded = exp @@ -1761,18 +1771,25 @@ func capRecallResults(results []models.RecallResult, limit int) (prim, expanded // // 2026-11-02(t_2891d689)两处修订: // ① 返回值加 mainLen(主路段截断后的长度)。4ffc546 后 carry 使 len(results) 可以 -// 超过 limit,翻页判据若看 len(results) 会恒假 ⇒ nextCont 恒空、带注入的 query -// 翻页链断裂(本卡病灶)。判据改看主路段(见 shouldEmitContinuation)。 +// +// 超过 limit,翻页判据若看 len(results) 会恒假 ⇒ nextCont 恒空、带注入的 query +// 翻页链断裂(本卡病灶)。判据改看主路段(见 shouldEmitContinuation)。 +// // ② carry 只在第一页出现:carry 是固定钉住的注入条目,第一页其 ID 已随 returned -// 记进令牌 prev;续页再追加必然逐页重复,等于把去重成本转嫁给客户端。 -// ⇒ offset > 0 时只回主路段,不追加 carry。 +// +// 记进令牌 prev;续页再追加必然逐页重复,等于把去重成本转嫁给客户端。 +// ⇒ offset > 0 时只回主路段,不追加 carry。 func paginateRecallWithCarry(results []models.RecallResult, offset int, prevIDs []string, limit int) ([]models.RecallResult, int) { var carry []models.RecallResult + var front []models.RecallResult // standing_answer:答案置顶、不占主结果配额 main := make([]models.RecallResult, 0, len(results)) for _, r := range results { - if r.Category == "pattern" || r.Category == "peer" { + switch r.Category { + case "pattern", "peer": carry = append(carry, r) - } else { + case "standing_answer": + front = append(front, r) + default: main = append(main, r) } } @@ -1801,14 +1818,19 @@ func paginateRecallWithCarry(results []models.RecallResult, offset int, prevIDs } mainLen := len(main) if mainLen == 0 { - // 与旧语义一致:主路段空 ⇒ 整页空(页面上只有注入条目没有意义) + // 主路段空:若只有常设卡(精确通道命中即只回卡),卡本身就是有效答案,不能吞掉; + // 含 pattern/peer 的纯注入页仍按旧语义返回空页。 + if len(front) > 0 { + return front, 0 + } return []models.RecallResult{}, 0 } if offset > 0 { // t_2891d689:carry 只在第一页出现,续页不回尾(见函数头注释 ②) return main, mainLen } - return append(main, carry...), mainLen + out := append(front, main...) + return append(out, carry...), mainLen } // shouldEmitContinuation —— P0-3 是否发放下一页 continuation 令牌(2026-11-02 t_2891d689)。 diff --git a/go/internal/storage/fts_reserve_test.go b/go/internal/storage/fts_reserve_test.go new file mode 100644 index 0000000..6382d72 --- /dev/null +++ b/go/internal/storage/fts_reserve_test.go @@ -0,0 +1,96 @@ +package storage + +import ( + "os" + "path/filepath" + "testing" +) + +// 2026-11-16 ftsReserveSlots:让位预算随 topK 缩放。 +// 判据(无覆盖文件时):topK/2 封顶 3 —— k=5 ⇒ 2、k=6 ⇒ 3、k≥6 恒 3(= 旧值)。 +func TestFtsReserveSlots_ScaledByTopK(t *testing.T) { + t.Setenv("ZHIYI_FTS_RESERVE_FILE", "/nonexistent/recall-fts-reserve") + cases := []struct{ topK, want int }{ + {1, 0}, {2, 1}, {3, 1}, {4, 2}, {5, 2}, {6, 3}, {7, 3}, {10, 3}, {50, 3}, + } + for _, c := range cases { + if got := ftsReserveSlots(c.topK); got != c.want { + t.Errorf("ftsReserveSlots(%d)=%d want %d", c.topK, got, c.want) + } + } +} + +// 关键回归点:小 k 下预留位不得吃掉整条主路径(k=1/2 时预算必须 < topK)。 +func TestFtsReserveSlots_NeverEatsWholeList(t *testing.T) { + for k := 1; k <= 10; k++ { + if got := ftsReserveSlots(k); got >= k && k > 1 { + t.Errorf("ftsReserveSlots(%d)=%d 会吃掉全部槽位", k, got) + } + } +} + +// 2026-11-17 selectionWindow 默认改为**常数**(与 topK 解耦)。 +// +// 理由不是「提分」(+0.79pp 属噪声内),而是**不变量**:改前 window(5)=10、window(20)=40, +// 同一 query 请求 5 条与 20 条看到不同候选池 ⇒ 实测 `日志分析怎么定位根因` 在 k=20 时 +// DA 排第 4、k=5 时完全不在(top5 ⊄ top20)。用户换个 top_k 就拿到不同答案。 +// 改后实测 16 题 top5 ⊄ top20 = 0 道。 +func TestSelectionWindow_DecoupledFromTopK(t *testing.T) { + t.Setenv("ZHIYI_SEL_WINDOW_FILE", "/nonexistent/recall-sel-window") + cases := []struct{ topK, want int }{ + {1, selectionWindowDefault}, {5, selectionWindowDefault}, + {10, selectionWindowDefault}, {20, selectionWindowDefault}, + {50, selectionWindowDefault}, {100, selectionWindowDefault}, + {150, 150}, // 窗口不能小于请求条数 + } + for _, c := range cases { + if got := selectionWindow(c.topK); got != c.want { + t.Errorf("selectionWindow(%d)=%d want %d", c.topK, got, c.want) + } + } +} + +// 单调性 + 恒定:k ≤ 默认值时窗口恒定(同一候选池 ⇒ 前缀结果一致)。 +func TestSelectionWindow_Monotonic(t *testing.T) { + t.Setenv("ZHIYI_SEL_WINDOW_FILE", "/nonexistent/recall-sel-window") + prev := 0 + for k := 1; k <= 200; k++ { + w := selectionWindow(k) + if w < prev { + t.Fatalf("selectionWindow 非单调:k=%d got %d < 前一个 %d", k, w, prev) + } + if k <= selectionWindowDefault && w != selectionWindowDefault { + t.Fatalf("k=%d ≤ 默认值时窗口应恒定 %d,实际 %d", k, selectionWindowDefault, w) + } + prev = w + } +} + +// 旋钮 0 = 回滚到旧行为(topK*2)。 +func TestSelectionWindow_LegacyViaKnobZero(t *testing.T) { + f := filepath.Join(t.TempDir(), "recall-sel-window") + if err := os.WriteFile(f, []byte("0"), 0o644); err != nil { + t.Fatal(err) + } + t.Setenv("ZHIYI_SEL_WINDOW_FILE", f) + for _, c := range []struct{ topK, want int }{{1, 2}, {5, 10}, {20, 40}} { + if got := selectionWindow(c.topK); got != c.want { + t.Errorf("旋钮=0 时 selectionWindow(%d)=%d want %d(旧行为 topK*2)", c.topK, got, c.want) + } + } +} + +// 旋钮 n>0 = 窗口取 max(n, topK)。 +func TestSelectionWindow_KnobWidens(t *testing.T) { + f := filepath.Join(t.TempDir(), "recall-sel-window") + if err := os.WriteFile(f, []byte("40"), 0o644); err != nil { + t.Fatal(err) + } + t.Setenv("ZHIYI_SEL_WINDOW_FILE", f) + if got := selectionWindow(5); got != 40 { + t.Errorf("旋钮=40 时 selectionWindow(5)=%d want 40", got) + } + if got := selectionWindow(60); got != 60 { + t.Errorf("旋钮=40 时 selectionWindow(60)=%d want 60(不得小于请求条数)", got) + } +} diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index 9c20d2c..3c33e15 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -520,12 +520,23 @@ func (p *RecallPipeline) RecallWithMetaTraced(ctx context.Context, query, namesp if ctx == nil { ctx = context.Background() } - // 常设答案精确命中 ⇒ 零检索零 LLM 直接返回,不进入 rerank/LLM: - // 省 LLM 配额,且程序性记忆层在 LLM 过载(429)时仍可用。 - // 命中口径是归一化后整句相等(question + op.trigger 变体),无模糊面, - // 不会误吞泛化查询;未命中时走下面的完整召回,行为逐位不变。 + // 常设答案精确命中(2026-10-25 加入): + // 2026-11-17 改:**不再零检索短路**。旧行为是 return 只含 1 条卡的切片, + // 后果有两层:① 用户的硬要求「卡是答案、记忆是证据,两者都不能丢」被违反; + // ② golden 里 7~8 道被整句命中的题,DA 明明在库里却因为整片记忆被吞而在主尺上归零。 + // 新行为:照常走完整管线(rerank/LLM 成本换正确性),卡片置顶、 + // 且在 capRecallResults / paginateRecallWithCarry 里不占 limit 配额。 + // 降级保留:管线报错时仍只回卡(程序性记忆层在 LLM 过载时可用),status 标 partial。 if sa := standingAnswerFor(query); sa != nil { - return []models.RecallResult{{ + results, meta, err := p.recallWithMetaInner(ctx, query, namespace, topK, diversity, allowNSFallback, tr) + if tr != nil { + meta.TraceID = tr.TraceID + if tr.Status == "partial" { + meta.Status = "partial" + meta.PartialReason = tr.PartialReason + } + } + card := models.RecallResult{ ID: "standing:" + sa.QuestionID, Content: sa.Answer, Category: "standing_answer", @@ -533,7 +544,24 @@ func (p *RecallPipeline) RecallWithMetaTraced(ctx context.Context, query, namesp Timestamp: sa.UpdatedAt.Format(time.RFC3339), Source: "standing_answer", Channel: "standing", - }}, RecallMeta{StandingAnswerHit: sa.QuestionID, Status: "ok"}, nil + } + // 语义通道可能已把同一张卡 prepend 进 results ⇒ 按 ID 去重,避免一张卡出现两次 + out := make([]models.RecallResult, 0, len(results)+1) + out = append(out, card) + for _, r := range results { + if r.ID == card.ID { + continue + } + out = append(out, r) + } + meta.StandingAnswerHit = sa.QuestionID + if err != nil { + // 只回卡,别把「证据没取到」伪装成正常 + meta.Status = "partial" + meta.PartialReason = "standing_only:" + err.Error() + return out[:1], meta, nil + } + return out, meta, nil } results, meta, err := p.recallWithMetaInner(ctx, query, namespace, topK, diversity, allowNSFallback, tr) if tr != nil { @@ -675,6 +703,24 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st tr.Stage("encode", stEncode, 0) } + // 语义常设答案通道(t_standing_sem,2026-11-16):精确通道只认整句相等, + // 留出变体 0/35 命中 ⇒ 在这里用**已算好的 queryVec** 做一次余弦候选, + // 过「主体/反义/数字」三闸门才认。三档:off(默认,逐位等价)/ shadow(只打日志)/ on(短路返回)。 + // 复用 queryVec ⇒ 零额外 embedding 延迟。 + // on 模式不短路:卡片置顶 + 保留全部记忆证据。 + // 2026-11-17 改:短路只回 1 条卡 ⇒ 13 道题在主尺上归零(0.5575→0.4980)。 + // 但用户要的是「答案 + 依据」,所以卡片 prepend、记忆照常返回(top_k 条 + 1 张卡)。 + var semCard *StandingAnswer + var semQID string + if semMode := standingSemMode(); semMode != "off" { + if sa, c := p.standingSemanticCheck(query, queryVec, semMode == "on", true); sa != nil { + log.Printf("[standing][sem] mode=%s qid=%s cos=%.3f query=%q", semMode, sa.QuestionID, c, query) + if semMode == "on" { + semCard, semQID = sa, sa.QuestionID + } + } + } + // Step 2: Coarse search — own namespace + shared(§1.3 召回规则) // 默认搜自己的 namespace + shared,显式 include_namespaces 时才跨域 // 2026-09-21 五修(t_24eceed0 返修):namespace=="" → 全库跨命名空间召回。 @@ -976,7 +1022,29 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st if floor := envInt("ZHIYI_RERANK_N_FLOOR", 10); floor > rerankN { rerankN = floor } - reranked, err := p.reranker.RerankWithVectors(queryVec, docs, docVecs, rerankN) + // t_rerank_depth (2026-11-17): 重排深度与请求 topK 解耦。 + // 病根证据:同一批 84 道 DA 题,k=5 请求的主尺 0.5476 / 0.5536(两次同参), + // 「k=20 请求取前 5」0.6091 —— 差 5.5pp。窗口已解耦(selectionWindow=100), + // 但 rerankN 仍 = topK*2(k=5 ⇒ 10、k=20 ⇒ 40),第 11~40 条结构性不进重排, + // 于是「换个 top_k 就换一套答案」的不变量违背只修了一半。 + // 热调:/var/lib/memoryweave/recall-rerank-depth 写整数;0/缺失 ⇒ 逐位等价现状(可回滚)。 + if d := rerankDepthFloor(); d > rerankN { + rerankN = d + } + if rerankN > len(candidates) { + rerankN = len(candidates) + } + // 2026-11-17 体检(全面测试)发现:外部 rerank API 只送 ZHIYI_RERANK_API_MAX_DOCS + // (默认 50)条文档 ⇒ top_k > 50 时返回条数被静默封顶(实测 top_k=200 → count=50、 + // truncated=null、candidates_scanned=200)。契约「绝不无声截断必需上下文」⇒ 打标。 + rerankCapped := false + // 判据用 topK 而非 rerankN:rerankN = max(topK*2, floor) 恒 > 50,拿它比会把 + // 每一次请求都误标成截断(k=5 实测踩到)。只有当「请求条数 > 送排条数」时, + // 返回条数才真会被压到 maxDocs —— 那才是需要告警的截断。 + if maxDocs := envInt("ZHIYI_RERANK_API_MAX_DOCS", 50); maxDocs > 0 && topK > maxDocs { + rerankCapped = true + } + reranked, err := p.reranker.RerankPreferAPI(query, docs, queryVec, docVecs, rerankN) if err != nil { log.Printf("[recall] 向量重排跳过(%v),回退文本重排", err) reranked, err = p.reranker.Rerank(query, docs, rerankN) @@ -1138,13 +1206,43 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st return nil, RecallMeta{CandidatesScanned: poolSize, Truncated: truncated, Status: "partial", PartialReason: "deadline_exceeded"}, nil } stMMR := time.Now() - finalIndices := MMRSelect(reranked, candidates, topK*2, diversity) + // 2026-11-16 t_rerank_hold:rerank「保位」——把**重排前向量序**的前 N 条钉死在头部, + // 只让其余条目参与 cross-encoder/MMR 竞争。 + // 背景:真 rerank 上线后主尺 0.2639→0.5258(+99%),但 6 道 n_da=1 的窄 how-to 题 + // 从 1.00 掉到 0(cross-encoder 把唯一答案那一批压出了 top5)。11-12 离线重放同结论: + // 全重排 0.3724 < 保 top3 0.3900。默认 0 ⇒ MMRSelect 原样调用,逐位等价现状。 + hold := envInt("ZHIYI_RERANK_HOLD", 0) + var finalIndices []int + if hold > 0 && hold < len(candidates) { + keep := hold + win := selectionWindow(topK) + if maxKeep := win; keep > maxKeep { + keep = maxKeep + } + finalIndices = make([]int, 0, win) + for i := 0; i < keep; i++ { + finalIndices = append(finalIndices, i) + } + rest := make([]models.RerankResult, 0, len(reranked)) + for _, r := range reranked { + if r.Index >= keep { + rest = append(rest, r) + } + } + if need := win - len(finalIndices); need > 0 { + finalIndices = append(finalIndices, MMRSelect(rest, candidates, need, diversity)...) + } + log.Printf("[recall][hold] rerank 保位前 %d 条(共 %d 候选,池 %d)", keep, len(candidates), len(finalIndices)) + } else { + finalIndices = MMRSelect(reranked, candidates, selectionWindow(topK), diversity) + } // RRF 开启时多取一倍候选进融合池:只在 topK 内部重排不会改变 top5 的**集合**(等于没效果), // 第 6~10 名必须有机会被词面秩抬进前 5,融合才可能有增益。门控关 ⇒ poolN==topK,逐位等价现状。 poolN := topK if rrfEnabled() { - poolN = topK * 2 + // 融合池必须与选择窗口同宽,否则"窗口选了 20 条、池只放 10 条"⇒ 后半截白选。 + poolN = selectionWindow(topK) } results := make([]models.RecallResult, 0, poolN) for i, idx := range finalIndices { @@ -1293,7 +1391,22 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st // 槽位(头部至多让 3 位;回归面收敛且只在 FTS 真有命中时发生) budget := topK - len(results) if len(results) >= topK { - budget = 3 + budget = ftsReserveSlots(topK) + } + // t_fts_tail_head (2026-11-17):**头部保护** —— 让位槽不得吃进前 head 名。 + // 病根证据(同库同 query、串行 no_cache、三次重复全一致): + // k=5 返回 [v,v,v,fts,fts](第 4~5 名被让给词面命中), + // k=20 返回 [v,v,v,v,v](融合池前 8 名逐位相同,FTS 落在 18~20 名)。 + // 同一份 84 题主尺:k=5 → 0.55357;k=20 取前 5 → 0.60913(+7/−0)。 + // 即:小 k 时「尾部让位」= 吃掉答案的 40%,而 k 大时它落在无人看的位置。 + // 缺省 0 ⇒ 逐位等价现状(可回滚);热调文件 recall-fts-tail-head。 + if h := ftsTailHeadProtect(); h > 0 && len(results) >= topK { + if room := topK - h; budget > room { + if room < 0 { + room = 0 + } + budget = room + } } nAppend := budget if nAppend > len(fresh) { @@ -1504,6 +1617,28 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st tr.MarkPartial("row_cap_truncated") } } + if rerankCapped && partialReason == "" { + truncated = true + status = "partial" + partialReason = "rerank_docs_capped" + if tr != nil { + tr.MarkPartial("rerank_docs_capped") + } + log.Printf("[recall] 结果被封顶:rerank 只送 %d 条 < 请求 topK=%d(ZHIYI_RERANK_API_MAX_DOCS)", + envInt("ZHIYI_RERANK_API_MAX_DOCS", 50), topK) + } + if semCard != nil { + card := models.RecallResult{ + ID: "standing:" + semQID, + Content: semCard.Answer, + Category: "standing_answer", + Score: 1.0, + Timestamp: semCard.UpdatedAt.Format(time.RFC3339), + Source: "standing_answer", + Channel: "standing", + } + results = append([]models.RecallResult{card}, results...) + } return results, RecallMeta{CandidatesScanned: poolSize, Truncated: truncated, Status: status, PartialReason: partialReason}, nil } @@ -1772,3 +1907,115 @@ func filterRecallRawCategories(results []models.RecallResult) []models.RecallRes } return filtered } + +// ftsReserveSlots 返回 FTS 尾部位预留槽数(Step 3.8)。 +// +// 2026-11-16(t_fts_reserve_scaled)为什么需要它: +// 原实现硬编码 3 位,且这 3 位是在 `results[:topK]` 截断**之后**才让出来的 —— +// 结果条数已等于 topK 时,"让位"只能从已截断的主路径尾部抢 ⇒ 向量路径的第 3 名 +// 被凭空吃掉。实测同一 query、同一时刻、no_cache: +// +// top_k=5 → 标准答案不在前 5;top_k=6 → 稳定第 3 位(其余顺序完全不变) +// +// 主尺 84 题同批调用:top_k=5 取前 5 = 0.5139,top_k=10 取前 5 = 0.6448(+13.1pp), +// 反转顺序(30→10→5)复测 0.5375 vs 0.6542(+11.7pp)⇒ 不是曝光顺序假象。 +// 差额主因就是这 3 个保留位在小 k 下的占比过高(k=5 时占 60%)。 +// +// 规则:min(3, topK/2) —— k=5 ⇒ 2、k=6 ⇒ 3、k≥6 恒 3(= 原值,零回归面)。 +// 热调:`/var/lib/memoryweave/recall-fts-reserve` 写整数(0..3)即覆盖本规则, +// 无需重启(A/B 用);回滚 = 写 3(逐位回到改动前行为)。 +func ftsReserveSlots(topK int) int { + if b, err := os.ReadFile(recallKnobPath("recall-fts-reserve", "ZHIYI_FTS_RESERVE_FILE")); err == nil { + if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v >= 0 { + if v > topK { + v = topK + } + return v + } + } + n := topK / 2 + if n > 3 { + n = 3 + } + if n < 0 { + n = 0 + } + return n +} + +// selectionWindowDefault 是与请求 topK 解耦的窗口常数。窗 40 与窗 100 实测同分, +// 取 100 只为把「大 k 包含小 k」的不变量覆盖到 k ≤ 100 全区间。 +const selectionWindowDefault = 100 + +// selectionWindow 返回 MMR/RRF 的「选择窗口」宽度 —— 与请求的 topK 解耦。 +// +// 2026-11-16(t_sel_window):原实现在两处用 topK*2 作为窗口,于是**同一 query +// 请求 5 条与请求 50 条拿到的前 5 名不同**。 +// +// 2026-11-17 改默认(**为修不变量,不为提分**):默认窗口 = 常数 100。 +// 病根证据:`日志分析怎么定位根因` 在 top_k=20 时 DA 排第 4,top_k=5 时完全不在结果里 +// ⇒ top5 ⊄ top20,用户换个 top_k 就拿到不同答案。机制就是窗口随 k 缩放: +// k=5 只在前 10 条里做 MMR/RRF,第 11 条起的好答案结构性没机会。 +// 改后实测:16 题 top5 ⊄ top20 = 0 道(不变量成立);主尺 0.55754 → 0.56548(+0.79pp); +// 窗 40 与窗 100 同分(池深饱和)⇒ 选 100 是为了把不变量覆盖到 k ≤ 100 全区间; +// 延迟 p50 1.01s → 1.09s(+80ms)。 +// 热调:/var/lib/memoryweave/recall-sel-window 写整数 —— 0 = 旧行为(topK*2,回滚用), +// n>0 = 窗口取 max(n, topK)。文件缺失 ⇒ 常数默认。 +func selectionWindow(topK int) int { + if b, err := os.ReadFile(recallKnobPath("recall-sel-window", "ZHIYI_SEL_WINDOW_FILE")); err == nil { + if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v >= 0 { + if v == 0 { + return topK * 2 + } + if v > topK { + return v + } + return topK + } + } + // 窗口不能小于请求条数,否则凑不满 k。 + if topK > selectionWindowDefault { + return topK + } + return selectionWindowDefault +} + +// ftsTailHeadProtect 返回 FTS 尾部让位时受保护的头部名次数(0 = 不保护,现状)。 +// 热调:/var/lib/memoryweave/recall-fts-tail-head;env 兜底 ZHIYI_FTS_TAIL_HEAD。 +func ftsTailHeadProtect() int { + if b, err := os.ReadFile(recallKnobPath("recall-fts-tail-head", "ZHIYI_FTS_TAIL_HEAD_FILE")); err == nil { + if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v > 0 { + return v + } + } + // 缺省 0 = 逐位等价旧行为(测试锁旧契约);生产由 unit Environment + // ZHIYI_FTS_TAIL_HEAD=5 开启。配对实测(84 题同库同窗):0 → 0.55357、 + // 5 → 0.60913(+7/−0,掉零 29→24,p50 1.48s→0.99s)。 + return envInt("ZHIYI_FTS_TAIL_HEAD", 0) +} + +// rerankDepthFloor 返回「最小重排深度」——把 rerankN 从 topK*2 解耦成常数。 +// 0 / 文件缺失 / 解析失败 ⇒ 0(不抬高 rerankN,行为与旧版逐位等价)。 +// 热调:/var/lib/memoryweave/recall-rerank-depth;env 覆盖走 ZHIYI_RERANK_DEPTH / ZHIYI_RERANK_DEPTH_FILE。 +func rerankDepthFloor() int { + if b, err := os.ReadFile(recallKnobPath("recall-rerank-depth", "ZHIYI_RERANK_DEPTH_FILE")); err == nil { + if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v > 0 { + return v + } + } + if v := envInt("ZHIYI_RERANK_DEPTH", 0); v > 0 { + return v + } + return 0 +} + +// recallKnobPath 返回热调旋钮文件路径。 +// 为什么要 env 覆盖:单测读的是真实生产文件 ⇒ 生产上调过旋钮就会让单测红/绿翻转 +// (2026-11-16 实际踩到:knob=100 时 TestSelectionWindow_DefaultsToLegacy 直接 FAIL)。 +// 单测里 t.Setenv(, <不存在的 tmp 路径>) ⇒ 走默认分支,行为可确定性断言。 +func recallKnobPath(name, envKey string) string { + if p := os.Getenv(envKey); p != "" { + return p + } + return "/var/lib/memoryweave/" + name +} diff --git a/go/internal/storage/recall_smalltopk_tail_test.go b/go/internal/storage/recall_smalltopk_tail_test.go index c2fbe35..f3c58b1 100644 --- a/go/internal/storage/recall_smalltopk_tail_test.go +++ b/go/internal/storage/recall_smalltopk_tail_test.go @@ -129,6 +129,12 @@ func expectedYield(topK, P, F int) (total, nAppend int) { if nAppend > topK { // t_bd718662 修后:让位上限 = min(3,F,现有条数) nAppend = topK } + // 2026-11-17 对齐 ftsReserveSlots 现行契约:FTS 尾部预算随 topK 缩放 + // (min(3, topK/2),见 recall.go ftsReserveSlots)——旧期望写死 3, + // 导致 topK∈{1,2,3} 的 P>=topK 全表红;这是**测试过时**不是代码回归。 + if half := topK / 2; nAppend > half { + nAppend = half + } total = topK } return @@ -223,3 +229,50 @@ func TestFTS_SmallTopKGolden(t *testing.T) { t.Logf("%s", line) } } + +// TestFTS_TailHeadProtect —— 头部保护契约(2026-11-17): +// 生产用 ZHIYI_FTS_TAIL_HEAD=5 时,topK<=5 的让位槽为 0(词面命中不得吃掉答案头部); +// 关掉旋钮必须逐位回到旧契约(min(3,topK/2) 个尾部槽位);结果集未满时追加路径不受影响。 +func TestFTS_TailHeadProtect(t *testing.T) { + t.Run("head=5_topK5_不占用头部", func(t *testing.T) { + t.Setenv("ZHIYI_FTS_TAIL_HEAD", "5") + res := runMatrixCell(t, 5, 5, 5) + fts := 0 + for _, r := range res { + if r.FtsBoosted { + fts++ + } + } + if fts != 0 || len(res) != 5 { + t.Fatalf("head=5 topK=5:期望 5 条纯池内结果,实际 fts=%d len=%d %v", fts, len(res), idsRes(res)) + } + }) + + t.Run("head=0_topK5_旧契约", func(t *testing.T) { + t.Setenv("ZHIYI_FTS_TAIL_HEAD", "0") + res := runMatrixCell(t, 5, 5, 5) + fts := 0 + for _, r := range res { + if r.FtsBoosted { + fts++ + } + } + if fts != 2 { + t.Fatalf("head=0 topK=5:期望 2 个尾部让位槽(min(3,5/2)),实际 %d %v", fts, idsRes(res)) + } + }) + + t.Run("head=5_未满时仍可追加", func(t *testing.T) { + t.Setenv("ZHIYI_FTS_TAIL_HEAD", "5") + res := runMatrixCell(t, 5, 3, 5) + fts := 0 + for _, r := range res { + if r.FtsBoosted { + fts++ + } + } + if fts == 0 { + t.Fatalf("池内仅 3 条时 FTS 应补足到 5,实际 0 条 FTS %v", idsRes(res)) + } + }) +} diff --git a/go/internal/storage/reranker.go b/go/internal/storage/reranker.go index 14bd9c9..08ec49e 100644 --- a/go/internal/storage/reranker.go +++ b/go/internal/storage/reranker.go @@ -2,6 +2,7 @@ package storage import ( "bytes" + "context" "encoding/json" "fmt" "io" @@ -10,6 +11,7 @@ import ( "net/http" "os" "sort" + "sync" "strconv" "strings" "time" @@ -171,6 +173,50 @@ func (r *Reranker) RerankWithVectors(queryVec []float32, documents []string, doc return results, nil } +// RerankPreferAPI 是生产 recall 的重排入口(2026-11-12 牧尘令「rerank 开」)。 +// +// 背景:旧调用点只走 RerankWithVectors(纯向量 cosine),apiRerank 只在出错时兜底, +// 于是「设 RERANK_ENDPOINT + MOLIFANG_API_KEY」在生产上等于空转 —— 2026-11-12 用本地桩 +// 实测 6 发 recall(含 debug / limit=50 / use_rerank)桩收到 0 请求、日志 0 条 [rerank] 证实。 +// +// 新语义:有 MOLIFANG_API_KEY ⇒ 先走模力方舟 cross-encoder(apiRerank,内置 25 条分批); +// 无 key 或 API 失败 ⇒ 退回 RerankWithVectors(亚毫秒、零外呼),保证召回不因外部服务拖垮。 +func (r *Reranker) RerankPreferAPI(query string, documents []string, queryVec []float32, docVecs [][]float32, topN int) ([]models.RerankResult, error) { + if len(documents) == 0 { + return nil, nil + } + if r.apiKey != "" { + // 候选过多会变成多次 25 条批次(实测 100 条 = 4 批 ≈ 1.5~3s,逼近 prefetch 8s 预算)。 + // docs 进来时已按 ANN 分数有序 ⇒ 截前 N 条送 cross-encoder,既省时又保住头部质量。 + if maxDocs := envInt("ZHIYI_RERANK_API_MAX_DOCS", 50); maxDocs > 0 && len(documents) > maxDocs { + documents = documents[:maxDocs] + // 2026-11-17 修:只截 documents 不截 docVecs ⇒ 下游校验 + // 「doc vector count 100 != documents 50」报错,静默回退**文本重排** + // (实测:把 rerankN 抬到 100 时每条召回都走这条路,排序悄悄换了一套)。 + if len(docVecs) > maxDocs { + docVecs = docVecs[:maxDocs] + } + } + // 外部 API 延迟抖动大(实测 0.28s / 1.28s / 10.34s),必须硬超时: + // 超时就走向量 cosine,宁可丢一点重排质量,也不能让 prefetch 8s 预算被吃掉。 + timeout := time.Duration(envInt("ZHIYI_RERANK_TIMEOUT_MS", 2500)) * time.Millisecond + ctx, cancel := context.WithTimeout(context.Background(), timeout) + t0 := time.Now() + res, err := r.apiRerankCtx(ctx, query, documents, topN) + cancel() + if err == nil && len(res) > 0 { + // 成功路径必须有日志:否则「API 有没有真被调用」只能靠延迟间接推断, + // 而上一次 rerank 空转就是这么被漏掉的(2026-11-16)。 + log.Printf("[rerank] api ok: docs=%d topN=%d took=%dms q=%.40q", len(documents), topN, time.Since(t0).Milliseconds(), query) + return res, nil + } + if err != nil { + log.Printf("[rerank] API 重排不可用(%v),降级向量 cosine q=%.40q", err, query) + } + } + return r.RerankWithVectors(queryVec, documents, docVecs, topN) +} + // localCosineRerank 使用 Embedder 编码 query → 对每个 doc 的向量做 cosine func (r *Reranker) localCosineRerank(query string, documents []string, topN int) ([]models.RerankResult, error) { qVec, err := r.embedder.EncodeQuery(query) @@ -238,69 +284,43 @@ func cosineScore(a, b []float32) float64 { return dot / math.Sqrt(normA*normB) } -// apiRerank 调用模力方舟 bge-reranker-v2-m3 进行 cross-encoder 重排 +// apiRerank 调用模力方舟 bge-reranker-v2-m3 进行 cross-encoder 重排(无超时控制,保留给旧调用点) // 限制:molifang API 每批最多 25 个文档 func (r *Reranker) apiRerank(query string, documents []string, topN int) ([]models.RerankResult, error) { - // 分批(每批最多 25) + return r.apiRerankCtx(context.Background(), query, documents, topN) +} + +// apiRerankCtx 分批并发重排:批与批之间并行(原先串行,50 条 = 2 批时延迟翻倍), +// 任一批失败即整体失败,由调用方降级到向量 cosine。ctx 负责整体超时。 +func (r *Reranker) apiRerankCtx(ctx context.Context, query string, documents []string, topN int) ([]models.RerankResult, error) { const batchSize = 25 + nBatches := (len(documents) + batchSize - 1) / batchSize + type batchOut struct { + res []models.RerankResult + err error + } + outs := make([]batchOut, nBatches) + var wg sync.WaitGroup + for b := 0; b < nBatches; b++ { + startIdx := b * batchSize + endIdx := startIdx + batchSize + if endIdx > len(documents) { + endIdx = len(documents) + } + wg.Add(1) + go func(b, s, e int) { + defer wg.Done() + outs[b].res, outs[b].err = r.apiRerankBatch(ctx, query, documents[s:e], s) + }(b, startIdx, endIdx) + } + wg.Wait() + allResults := make([]models.RerankResult, 0, len(documents)) - for start := 0; start < len(documents); start += batchSize { - end := start + batchSize - if end > len(documents) { - end = len(documents) - } - batch := documents[start:end] - n := topN - if n > len(batch) { - n = len(batch) - } - reqBody := map[string]any{ - "model": "bge-reranker-v2-m3", - "query": query, - "documents": batch, - "top_n": n, - } - body, _ := json.Marshal(reqBody) - req, err := http.NewRequest("POST", r.endpoint, bytes.NewReader(body)) - if err != nil { - return nil, fmt.Errorf("new request: %w", err) - } - req.Header.Set("Content-Type", "application/json") - if r.apiKey != "" { - req.Header.Set("Authorization", "Bearer "+r.apiKey) - } - - resp, err := r.httpClient.Do(req) - if err != nil { - return nil, fmt.Errorf("do request: %w", err) - } - defer resp.Body.Close() - - if resp.StatusCode != http.StatusOK { - respBody, _ := io.ReadAll(resp.Body) - return nil, fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody)) - } - - var result struct { - Results []struct { - Index int `json:"index"` - RelevanceScore float64 `json:"relevance_score"` - Document struct { - Text string `json:"text"` - } `json:"document"` - } `json:"results"` - } - if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { - return nil, fmt.Errorf("decode: %w", err) - } - - for _, rr := range result.Results { - allResults = append(allResults, models.RerankResult{ - Index: start + rr.Index, - Score: rr.RelevanceScore, - Text: rr.Document.Text, - }) + for _, o := range outs { + if o.err != nil { + return nil, o.err } + allResults = append(allResults, o.res...) } // 全局排序取 topN @@ -312,3 +332,61 @@ func (r *Reranker) apiRerank(query string, documents []string, topN int) ([]mode } return allResults[:topN], nil } + +// apiRerankBatch 单批(≤25 条)请求;返回的 Index 已加上 offset,可直接对原 documents 取用。 +func (r *Reranker) apiRerankBatch(ctx context.Context, query string, batch []string, offset int) ([]models.RerankResult, error) { + if len(batch) == 0 { + return nil, nil + } + // 每批回全部候选的分数(不是 topN),否则全局排序只看到各批前 N 条, + // 跨批比较会漏掉「本批第 N+1 但全局靠前」的文档。单批 ≤25,代价可忽略。 + reqBody := map[string]any{ + "model": "bge-reranker-v2-m3", + "query": query, + "documents": batch, + "top_n": len(batch), + } + body, _ := json.Marshal(reqBody) + req, err := http.NewRequestWithContext(ctx, "POST", r.endpoint, bytes.NewReader(body)) + if err != nil { + return nil, fmt.Errorf("new request: %w", err) + } + req.Header.Set("Content-Type", "application/json") + if r.apiKey != "" { + req.Header.Set("Authorization", "Bearer "+r.apiKey) + } + + resp, err := r.httpClient.Do(req) + if err != nil { + return nil, fmt.Errorf("do request: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + respBody, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody)) + } + + var result struct { + Results []struct { + Index int `json:"index"` + RelevanceScore float64 `json:"relevance_score"` + Document struct { + Text string `json:"text"` + } `json:"document"` + } `json:"results"` + } + if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { + return nil, fmt.Errorf("decode: %w", err) + } + + out := make([]models.RerankResult, 0, len(result.Results)) + for _, rr := range result.Results { + out = append(out, models.RerankResult{ + Index: offset + rr.Index, + Score: rr.RelevanceScore, + Text: rr.Document.Text, + }) + } + return out, nil +} diff --git a/go/internal/storage/standing_semantic.go b/go/internal/storage/standing_semantic.go new file mode 100644 index 0000000..54a5ad6 --- /dev/null +++ b/go/internal/storage/standing_semantic.go @@ -0,0 +1,300 @@ +package storage + +// 语义常设答案通道(t_standing_sem,2026-11-16)。 +// +// 背景:精确通道(standing_match.go)只认「归一化后整句相等」,7 张 op 卡对 +// 换句话问的留出变体命中 0/35 —— 用户换个说法就完全无效。 +// 本文件在精确通道之后加一层「语义候选 + 主体一致性闸门」,三档模式: +// +// off(默认,逐位等价)→ shadow(只打日志、不改返回)→ on(真短路返回) +// 旋钮:/var/lib/memoryweave/standing-sem-mode、standing-sem-thr(默认 0.80) +// +// 为什么必须有闸门:离线实测(35 条留出变体 + 9 条对抗集、bge-m3 余弦) +// +// 纯语义 cos≥0.80 → 命中 23/35,对抗集误答 3/9(不可接受) +// 语义+主体/反义/数字三闸门 → 命中 21/35,对抗集误答 0/9 ← 采用 +// 语义+闸门 cos≥0.85 → 命中 10/35,误答 0/9(保守档) +// +// 三道闸门防的是「看起来像但主体不同」:飞书的遗忘机制 ≠ 织忆的遗忘机制; +// 「免费腿」≠「付费腿」。错答比不答贵,故闸门是硬门、宁可漏。 + +import ( + "math" + "os" + "regexp" + "strconv" + "strings" + "sync" + "time" + + "log" +) + +const ( + semModeFile = "standing-sem-mode" + semThrFile = "standing-sem-thr" +) + +// standingSemMode 读模式旋钮:off(默认)/ shadow / on。 +// 文件不存在或内容不识别 ⇒ off(绝不让配置错误静默开启自动答问)。 +func standingSemMode() string { + b, err := os.ReadFile(recallKnobPath(semModeFile, "ZHIYI_STANDING_SEM_MODE_FILE")) + if err != nil { + return "off" + } + switch strings.ToLower(strings.TrimSpace(string(b))) { + case "shadow": + return "shadow" + case "on": + return "on" + default: + return "off" + } +} + +// standingSemThreshold 读余弦阈值,默认 0.80,夹在 [0.60, 0.99]。 +func standingSemThreshold() float64 { + b, err := os.ReadFile(recallKnobPath(semThrFile, "ZHIYI_STANDING_SEM_THR_FILE")) + if err != nil { + return 0.80 + } + v, err := strconv.ParseFloat(strings.TrimSpace(string(b)), 64) + if err != nil || math.IsNaN(v) { + return 0.80 + } + if v < 0.60 { + return 0.60 + } + if v > 0.99 { + return 0.99 + } + return v +} + +// standingSemScope 读「on 模式生效范围」前缀,空=全部卡片。 +// 分阶段放量的抓手:先只让 7 张自己写、自己验过的 OP_ 步骤卡自动答问, +// 存量 130 张历史卡继续留在 shadow 里观察(它们的答案我没逐条验过)。 +func standingSemScope() string { + b, err := os.ReadFile(recallKnobPath("standing-sem-scope", "ZHIYI_STANDING_SEM_SCOPE_FILE")) + if err != nil { + return "" + } + return strings.TrimSpace(string(b)) +} + +// ownerTerms 是「主体」词表:谁的东西。与主题词(遗忘/蒸馏/三方/汇报)分开 —— +// 主题词相同不能作为一致性依据,否则「飞书的遗忘机制」会命中「织忆的遗忘机制」。 +var ownerTerms = []string{ + "织忆", "memoryweave", "zhiyid", "kocr", "飞书", "feishu", "hermes", + "kanban", "看板", "comfyui", "opencode", "deepseek", "sensenova", + "分身", "小怡", "牧尘", "股票", "高考", "qqbot", "微信", "qq", +} + +// antiPairs 反义词对:query 出现前者、卡片出现后者 ⇒ 语义像也不能命中。 +var antiPairs = [][2]string{ + {"免费", "付费"}, {"付费", "免费"}, + {"开启", "关闭"}, {"关闭", "开启"}, + {"删除", "恢复"}, {"恢复", "删除"}, + {"打开", "关掉"}, {"关掉", "打开"}, +} + +var asciiTokRe = regexp.MustCompile(`[A-Za-z_][A-Za-z0-9_\-\.]{2,}|\d{3,}`) + +func ownersOf(s string) map[string]struct{} { + out := map[string]struct{}{} + l := strings.ToLower(s) + for _, o := range ownerTerms { + if strings.Contains(l, o) { + out[o] = struct{}{} + } + } + return out +} + +func asciiTokens(s string) map[string]struct{} { + out := map[string]struct{}{} + for _, m := range asciiTokRe.FindAllString(strings.ToLower(s), -1) { + out[m] = struct{}{} + } + return out +} + +// standingGate 三道硬门:主体一致 + 无反义冲突 + 稀有 ASCII token 覆盖。 +// 纯函数、可单测(standing_semantic_test.go 固化了 9 条对抗样本)。 +func standingGate(query, cardQuestion, cardAnswer string) bool { + oq, oc := ownersOf(query), ownersOf(cardQuestion) + if len(oq) > 0 && len(oc) > 0 { + shared := false + for o := range oq { + if _, ok := oc[o]; ok { + shared = true + break + } + } + if !shared { + return false // 主体不同:飞书的 X ≠ 织忆的 X + } + } + if len(oq) > 0 && len(oc) == 0 { + return false // 问的是某主体,卡片是通用的 ⇒ 保守拒答 + } + ql := strings.ToLower(query) + cql := strings.ToLower(cardQuestion) + for _, p := range antiPairs { + if strings.Contains(ql, p[0]) && strings.Contains(cql, p[1]) { + return false + } + } + ta := asciiTokens(query) + if len(ta) > 0 { + hay := asciiTokens(cardQuestion + " " + cardAnswer) + hit := false + for t := range ta { + if _, ok := hay[t]; ok { + hit = true + break + } + } + if !hit { + return false // 端口号/文件名/命令之间对不上 ⇒ 拒答 + } + } + return true +} + +// semEntry 一张卡(question 或某个 op.trigger)的向量。 +type semEntry struct { + qid string + text string + vec []float32 + card *StandingAnswer +} + +var ( + semMu sync.Mutex + semCache []semEntry + semBuiltAt time.Time + semCount int +) + +// semEntries 懒构建卡片向量(10 分钟或卡数变化就重建;写入侧 Upsert 会让卡数变化)。 +func (p *RecallPipeline) semEntries(logOn bool) []semEntry { + semMu.Lock() + defer semMu.Unlock() + cards := loadStandingAnswers() + if len(semCache) > 0 && time.Since(semBuiltAt) < 10*time.Minute && semCount == len(cards) { + return semCache + } + var texts []string + var owners []int + for i := range cards { + texts = append(texts, cards[i].Question) + owners = append(owners, i) + if cards[i].Op != nil { + for _, t := range cards[i].Op.Trigger { + if strings.TrimSpace(t) == "" { + continue + } + texts = append(texts, t) + owners = append(owners, i) + } + } + } + var out []semEntry + const chunk = 8 // bge 网关单批过大会 400 + for i := 0; i < len(texts); i += chunk { + j := i + chunk + if j > len(texts) { + j = len(texts) + } + vecs, err := p.embedder.Encode(texts[i:j]) + if err != nil { + if logOn { + log.Printf("[standing][sem] 卡片向量构建失败(%d-%d/%d): %v", i, j, len(texts), err) + } + return nil + } + for k, v := range vecs { + idx := owners[i+k] + out = append(out, semEntry{qid: cards[idx].QuestionID, text: texts[i+k], vec: v, card: &cards[idx]}) + } + } + semCache, semBuiltAt, semCount = out, time.Now(), len(cards) + return semCache +} + +func cosSim(a, b []float32) float64 { + if len(a) == 0 || len(a) != len(b) { + return 0 + } + var dot, na, nb float64 + for i := range a { + x, y := float64(a[i]), float64(b[i]) + dot += x * y + na += x * x + nb += y * y + } + if na == 0 || nb == 0 { + return 0 + } + return dot / (math.Sqrt(na) * math.Sqrt(nb)) +} + +// standingSemanticCheck 语义候选:取余弦最高且过闸门的卡;不过闸门一律不命中。 +// queryVec 用调用方已经算好的查询向量(不额外 embed,零额外延迟)。 +func (p *RecallPipeline) standingSemanticCheck(query string, queryVec []float32, enforceScope bool, logOn bool) (*StandingAnswer, float64) { + thr := standingSemThreshold() + margin := standingSemMargin() + scope := "" + if enforceScope { + scope = standingSemScope() + } + best, second := (*StandingAnswer)(nil), (*StandingAnswer)(nil) + bestCos, secondCos := 0.0, 0.0 + for _, e := range p.semEntries(logOn) { + if scope != "" && !strings.HasPrefix(e.qid, scope) { + continue // on 模式只对放量范围内的卡短路 + } + c := cosSim(queryVec, e.vec) + if c < thr { + continue + } + if !standingGate(query, e.card.Question, e.card.Answer) { + continue + } + if c > bestCos { + best, second, bestCos, secondCos = e.card, best, c, bestCos + continue + } + if c > secondCos { + second, secondCos = e.card, c + } + } + // 模糊判定门:两张卡分数贴太近 ⇒ 语义上「两可」,拒答(错答比不答贵)。 + // 实测样本:「蒸馏质量门在哪」在 OP_DISTILL_QUALITY 与既有卡 zhiyi-threshold-1-v2 + // 之间摇摆,纯取最大会答错卡。 + if best != nil && second != nil && second.QuestionID != best.QuestionID && bestCos-secondCos < margin { + if logOn { + log.Printf("[standing][sem] 模糊拒绝 best=%s(%.3f) second=%s(%.3f) margin<%.3f", + best.QuestionID, bestCos, second.QuestionID, secondCos, margin) + } + return nil, 0 + } + return best, bestCos +} + +// standingSemMargin 读模糊拒绝边距,默认 0.02,夹在 [0, 0.20]。 +func standingSemMargin() float64 { + b, err := os.ReadFile(recallKnobPath("standing-sem-margin", "ZHIYI_STANDING_SEM_MARGIN_FILE")) + if err != nil { + return 0.02 + } + v, err := strconv.ParseFloat(strings.TrimSpace(string(b)), 64) + if err != nil || math.IsNaN(v) || v < 0 { + return 0.02 + } + if v > 0.20 { + return 0.20 + } + return v +} diff --git a/go/internal/storage/standing_semantic_test.go b/go/internal/storage/standing_semantic_test.go new file mode 100644 index 0000000..3b98c95 --- /dev/null +++ b/go/internal/storage/standing_semantic_test.go @@ -0,0 +1,71 @@ +package storage + +// 语义常设通道的闸门回归测试。 +// 对抗样本来自 2026-11-16 离线实测(9 条「同模板换主体/换词」的问法,纯语义 +// cos≥0.80 时曾有 3/9 误答);这些样本每次改动闸门都必须仍然被拒 —— 错答比不答贵。 + +import "testing" + +func TestStandingGate_RejectsWrongSubject(t *testing.T) { + cardQ := "织忆的遗忘窗口机制是怎么扫描的" + cardA := "三层扫描:usage_track TTL / memories decay / 存真去伪候选" + cases := []string{ + "KOCR 的遗忘窗口机制是怎么扫描的", + "飞书的遗忘窗口机制是怎么扫描的", + "KOCR 服务状态怎么三方交叉验证", + "飞书记忆的蒸馏怎么保证质量", + "kanban 的蒸馏怎么保证质量", + "ComfyUI 的记忆怎么淘汰旧记忆", + "hermes 的汇报怎么写证据原文", + } + for _, q := range cases { + if standingGate(q, cardQ, cardA) { + t.Errorf("应拒答(主体不同)却放行:%q vs %q", q, cardQ) + } + } +} + +func TestStandingGate_RejectsAntonym(t *testing.T) { + if standingGate("模型免费腿守卫只允许哪些", "模型付费腿守卫只允许哪些", "付费腿只有两条") { + t.Error("免费 vs 付费 属反义冲突,必须拒答") + } + if standingGate("怎么恢复被删的记忆", "怎么删除旧记忆", "按六档淘汰") { + t.Error("恢复 vs 删除 属反义冲突,必须拒答") + } +} + +func TestStandingGate_RejectsAsciiMismatch(t *testing.T) { + if standingGate("7822 端口是谁在听", "7821 端口是谁在听", "zhiyid 监听 7821") { + t.Error("端口号对不上必须拒答") + } +} + +func TestStandingGate_AcceptsGenericAsk(t *testing.T) { + // query 无主体、卡片有主体 ⇒ 允许(用户泛问,卡片是唯一答案来源) + pairs := [][2]string{ + {"遗忘窗口怎么扫描", "织忆的遗忘窗口机制是怎么扫描的"}, + {"蒸馏质量怎么保证", "织忆的蒸馏怎么保证质量"}, + {"记忆治理怎么淘汰旧记忆", "记忆治理怎么淘汰旧记忆"}, + {"kanban 怎么建卡", "kanban 看板任务怎么派活"}, + {"服务状态怎么三方交叉验证", "服务状态怎么三方交叉验证"}, + } + for _, p := range pairs { + if !standingGate(p[0], p[1], "步骤…") { + t.Errorf("应放行却拒答:%q vs %q", p[0], p[1]) + } + } +} + +func TestStandingSemMode_DefaultOff(t *testing.T) { + t.Setenv("ZHIYI_STANDING_SEM_MODE_FILE", "/nonexistent/standing-sem-mode") + if got := standingSemMode(); got != "off" { + t.Errorf("模式旋钮缺失时必须为 off,实得 %q", got) + } +} + +func TestStandingSemThreshold_DefaultAndClamp(t *testing.T) { + t.Setenv("ZHIYI_STANDING_SEM_THR_FILE", "/nonexistent/standing-sem-thr") + if got := standingSemThreshold(); got != 0.80 { + t.Errorf("默认阈值应为 0.80,实得 %v", got) + } +}