fix(skillgen): L3 草稿按证据主题簇生成 — bge-m3 聚类+最大簇门+簇快照头,禁跨主题拼接 (t_45677e64)

病根: 78条不同主题记忆全塞LLM→跨主题拼接成大杂烩(小怡抽2条全废)。
修法:
- cluster.go: BGEClusterer(bge-m3余弦贪心)+最大簇选择+纯函数clusterByCosine(确定性)
- DraftSkillClustered: 只对最大簇(≥3条)生成; 簇不足拒绝(宁缺毋滥); 溯源证据集=簇
- 草稿头嵌 cluster_id+簇内证据id+一句话簇主题(人审)
- generator: prompt禁抄红线规则+空占位省略+sanitizeDraft去污染
- store: MarkAllStale() 重生成前作废旧draft; PutDraft支持stale→draft复活
- probe/server: 生产装配BGEClusterer; 重生成前标stale
实测: 8 pattern过L3→聚类后4条同主题簇生成(4条因最大簇<3诚实拒) draft4/stale4/active0; 召回基线top5不变
This commit is contained in:
小唯
2026-11-09 03:08:17 +08:00
parent d95245f45c
commit 58b196ae25
9 changed files with 793 additions and 22 deletions
+13 -2
View File
@@ -158,15 +158,25 @@ func main() {
if len(draftOK) > 0 {
sstore := skillgen.NewStore(graphPath)
defer sstore.Close()
// 返修 #5:重生成前把现存 draft 全部作废(stale),防止人 promote 到上一版拼接怪。
// 本轮重新过闸的 pattern 会在 PutDraft 里把对应行从 stale 复位成 draft。
if n, serr := sstore.MarkAllStale(); serr == nil && n > 0 {
fmt.Printf("L3 stale-marked 旧草稿 %d 条(重生成前作废)\n", n)
}
gen := skillgen.NewLocal2BGenerator()
// t_9ccbca15(D2 反幻觉):用同一 sidecar(rc)取 pattern 命中记忆的真实原文注入 prompt。
prov := skillgen.NewLanceEvidenceProvider(rc)
// t_45677e64(返修 #1):bge-m3 向量聚类,证据按主题成簇,只对最大簇生成(防跨主题拼接)。
// 端点默认 http://localhost:8000/v1/embeddings(VLLM_ENDPOINT 可覆盖),不可用时退化为
// 逐条孤例 ⇒ 最大簇<3 ⇒ 该 pattern 本轮不出草稿(宁缺毋滥,不产杂烩)。
emb := storage.NewEmbedder("")
clusterer := skillgen.NewBGEClusterer(emb.Encode)
root := *attRoot
if root == "" {
root = skillgen.DefaultAttachmentsRoot()
}
for _, p := range draftOK {
sk, path, derr := skillgen.DraftSkill(sstore, gen, prov, p, root)
sk, path, derr := skillgen.DraftSkillClustered(sstore, gen, prov, clusterer, p, root)
if derr != nil {
fmt.Printf(" L3 draft FAIL %s: %v\n", p.Name, derr)
continue
@@ -174,6 +184,7 @@ func main() {
fmt.Printf(" L3 draft OK %s -> status=%s file=%s\n", p.Name, sk.Status, path)
}
n, _ := sstore.Count("draft")
fmt.Printf("skills draft count=%d\n", n)
s, _ := sstore.Count("stale")
fmt.Printf("skills draft count=%d stale count=%d\n", n, s)
}
}
+5 -1
View File
@@ -40,6 +40,10 @@ type PatternAPI struct {
// t_9ccbca15(D2 反幻觉):生成草稿前取真实证据原文的提供者(LanceDB 原文层)。
EvidenceProv skillgen.EvidenceProvider
// t_45677e64(返修 #1):证据主题聚类器(bge-m3 向量)。非 nil 时草稿按最大主题簇生成,
// 不跨主题拼接;nil 时 DraftSkill 退化为全证据一簇(仅兼容旧测试)。
Clusterer skillgen.TopicClusterer
// L3 skill 草稿评估(t_4594b632):promote 前生成评审摘要(人仍拍板,不自动 promote)。
Evaluator skillgen.Evaluator
}
@@ -199,7 +203,7 @@ func (pa *PatternAPI) Draft(w http.ResponseWriter, r *http.Request, id string) {
respondError(w, 503, "skillgen 未装配(EvidenceProv 为空)")
return
}
sk, path, derr := skillgen.DraftSkill(pa.SkillStore, pa.Generator, pa.EvidenceProv, pat, attRoot)
sk, path, derr := skillgen.DraftSkillClustered(pa.SkillStore, pa.Generator, pa.EvidenceProv, pa.Clusterer, pat, attRoot)
if derr != nil {
respondError(w, 400, "draft skill: "+derr.Error())
return
+3
View File
@@ -206,6 +206,9 @@ func NewServer() http.Handler {
patternAPI.AttachmentsDir = os.Getenv("ZHIYI_SKILL_ATTACHMENTS")
// t_9ccbca15(D2 反幻觉):生成草稿前取 pattern 命中记忆的真实原文注入 prompt。
patternAPI.EvidenceProv = skillgen.NewLanceEvidenceProvider(ldb)
// t_45677e64(返修 #1):bge-m3 向量聚类 —— 草稿按主题簇生成,不跨主题拼接。
// emb 复用 L2 同款编码客户端(命中缓存、L2 归一化);端点异常时退化为逐条孤例 ⇒ 最大簇<3 ⇒ 不出草稿。
patternAPI.Clusterer = skillgen.NewBGEClusterer(emb.Encode)
// t_4594b632:promote 前评审摘要(SkillEvaluator)。本地 2B 重写理由、确定性四维分兜底;
// 默认装配(评审信息参考,非 promote 依据)。2B 失败自动回退确定性理由,不阻塞 promote。
patternAPI.Evaluator = skillgen.NewLLMEvaluator()
+255
View File
@@ -0,0 +1,255 @@
// 织忆 MemoryWeave — L3 草稿证据主题聚类(t_45677e64 返修)
//
// 病根(小怡验收 2026-11-09):一个 pattern 的证据来自几十条不同主题的记忆
// (78 条"我备份过"分属 78 个任务),生成时全塞给 LLM ⇒ 只能跨主题拼接,
// 草稿成"大杂烩"。
//
// 修法:生成前先把 pattern 的证据按【主题簇】分组(用 bge-m3 向量做余弦聚类),
// 只对【最大簇】生成 skill;簇内 <3 条证据 ⇒ 拒绝生成(宁缺毋滥)。
//
// 设计约束(与既有 skillgen 范式一致):
// · 聚类逻辑 = 纯函数 clusterByCosine(向量进、标签出),零网络、确定性、
// 单测机械可复算。
// · 生产取向量 = storage.Embedder(bge-m3,命中缓存,L2 归一化);
// 向量拿不到时 BGEClusterer 退化为"每条各成单例"(不报错,交给 ≥3 门槛拒绝)。
// · 测试用 FakeClusterer(按关键词分簇),零依赖。
package skillgen
import (
"crypto/sha1"
"fmt"
"sort"
"strings"
)
// MinClusterEvidence 一个主题簇够生成草稿的最小证据数(卡 AC2:簇内 <3 不生成)。
const MinClusterEvidence = 3
// DefaultClusterSim 主题聚类的余弦相似度阈值(bge-m3 归一化向量,同主题短句经验值 0.80)。
// 太高分不开(拼接头依旧),太低会把无关主题误并回大杂烩。0.80 经证据簇抽样标定。
const DefaultClusterSim = 0.80
// EvidenceCluster 一个主题簇:簇标签 + 成员证据 + 代表性证据(离簇心最近的一条,做"簇主题"底本)。
type EvidenceCluster struct {
Label int // 簇序号(草稿头 cluster_id 的来源)
Members []Evidence // 簇内证据(喂给 LLM 的全部证据集)
Representative Evidence // 代表证据(首条成员,用于人审一句话主题底本)
}
// TopicClusterer 把一组证据按主题分成簇。生产用向量聚类,测试用关键词聚类。
type TopicClusterer interface {
// Cluster 返回与 ev 等长的标签数组(同标签 = 同簇)。实现失败可返回全 -1(各成孤例),
// 调用方按"最大簇 <MinClusterEvidence"拒绝生成,不会误产大杂烩。
Cluster(ev []Evidence) ([]int, error)
}
// clusterByCosine 纯函数:给定归一化向量 + 相似度阈值,做贪心"代表元"聚类(leader clustering)。
// 返回与 vectors 等长的标签数组。算法:
// 1. 按输入序遍历,每条向量若与已有某簇代表元余弦 ≥ sim 则并入该簇,
// 否则自成新簇(代表元=它本身)。
// 2. 簇数 ≤ N(无全对相似度 O(N²),N≤单 pattern 证据数,最多 ~百级,可接受)。
//
// 不依赖任何外部服务;相同输入永远相同输出(机械可复算)。
func clusterByCosine(vectors [][]float32, sim float64) []int {
labels := make([]int, len(vectors))
var reps [][]float32 // 每簇代表元向量(首条成员)
for i, v := range vectors {
best, bestSim := -1, -1.0
for ci, r := range reps {
s := cosineSim(v, r)
if s >= sim && s > bestSim {
best, bestSim = ci, s
}
}
if best >= 0 {
labels[i] = best
} else {
labels[i] = len(reps)
reps = append(reps, v)
}
}
return labels
}
// cosineSim L2 归一化向量的余弦(点积即余弦);维度不等取交集,防越界。
func cosineSim(a, b []float32) float64 {
n := len(a)
if len(b) < n {
n = len(b)
}
var dot float64
for i := 0; i < n; i++ {
dot += float64(a[i]) * float64(b[i])
}
return dot
}
// groupClusters 按标签把证据归簇,返回按簇内证据数降序(最大簇在前)。
// 代表元取簇内首条成员。
func groupClusters(ev []Evidence, labels []int) []EvidenceCluster {
if len(labels) != len(ev) {
labels = make([]int, len(ev))
for i := range labels {
labels[i] = i // 长度不匹配(异常)⇒ 每条各成簇,绝不并成杂烩
}
}
byLabel := map[int][]Evidence{}
for i, e := range ev {
l := labels[i]
byLabel[l] = append(byLabel[l], e)
}
out := make([]EvidenceCluster, 0, len(byLabel))
for l, members := range byLabel {
if len(members) == 0 {
continue
}
out = append(out, EvidenceCluster{Label: l, Members: members, Representative: members[0]})
}
// 最大簇在前;同大小按 label 升序保序(确定性)
sort.SliceStable(out, func(i, j int) bool {
if len(out[i].Members) != len(out[j].Members) {
return len(out[i].Members) > len(out[j].Members)
}
return out[i].Label < out[j].Label
})
return out
}
// largestCluster 返回证据数最多的簇(已按大小降序,取第一个);无簇返回 nil。
func largestCluster(ev []Evidence, labels []int) *EvidenceCluster {
cs := groupClusters(ev, labels)
if len(cs) == 0 {
return nil
}
return &cs[0]
}
// ─── 生产:bge-m3 向量聚类 ────────────────────────────────────────────────
// EmbedFunc 把文本批量编码为向量(注入以便单测替换;生产传 storage.Embedder.Encode)。
type EmbedFunc func(texts []string) ([][]float32, error)
// BGEClusterer 用 bge-m3 向量对证据做主题聚类(贪心余弦)。
type BGEClusterer struct {
embed EmbedFunc
sim float64
}
// NewBGEClusterer 用给定编码函数 + 默认阈值构造。embed 传 storage.Embedder 的 Encode 方法值。
func NewBGEClusterer(embed EmbedFunc) *BGEClusterer {
return &BGEClusterer{embed: embed, sim: DefaultClusterSim}
}
// Cluster 取每条证据内容的向量(失败/维度异常 ⇒ 退化为逐条孤例标签,
// 由调用方按"最大簇 <3"拒绝生成,绝不静默产出杂烩),再贪心余弦聚类。
func (b *BGEClusterer) Cluster(ev []Evidence) ([]int, error) {
if len(ev) == 0 {
return nil, nil
}
if b == nil || b.embed == nil {
return nil, fmt.Errorf("skillgen: BGEClusterer 未装配 embed")
}
texts := make([]string, len(ev))
for i, e := range ev {
texts[i] = e.Content
}
vecs, err := b.embed(texts)
if err != nil || len(vecs) != len(ev) {
// 编码失败不致命:每条各成簇(全 -1 风格:i),最大簇=1<3 ⇒ 上游拒绝生成。
fallback := make([]int, len(ev))
for i := range fallback {
fallback[i] = i
}
return fallback, nil
}
return clusterByCosine(vecs, b.sim), nil
}
// ─── 测试:关键词聚类(零依赖、确定性)──────────────────────────────────
// FakeClusterer 按关键词表分簇(命中第一个关键词 = 该关键词的簇;都不命中 = 各自孤例)。
// 供单测与离线复算:不经网络即可验证"最大簇选择 / 跨主题不拼接 / <3 拒绝"三条判据。
type FakeClusterer struct {
// Keywords: 簇名 → 关键词列表。证据内容含某簇的任一关键词 ⇒ 归该簇(先命中先归,顺序稳定)。
Keywords []struct {
Name string
Kws []string
}
}
// Cluster 按 Keywords 给证据打标签(同簇名 ⇒ 同标签值,用簇名首次出现的索引作标签)。
func (f *FakeClusterer) Cluster(ev []Evidence) ([]int, error) {
labels := make([]int, len(ev))
clusterIdx := map[string]int{}
next := 0
for i, e := range ev {
matched := false
for _, kf := range f.Keywords {
for _, kw := range kf.Kws {
if kw != "" && strings.Contains(e.Content, kw) {
if _, ok := clusterIdx[kf.Name]; !ok {
clusterIdx[kf.Name] = next
next++
}
labels[i] = clusterIdx[kf.Name]
matched = true
break
}
}
if matched {
break
}
}
if !matched {
labels[i] = 1000000 + i // 不命中 ⇒ 各自孤例(永不与其他合并)
}
}
return labels, nil
}
// ─── 簇标识 / 簇主题(草稿头人审用,返修 #4)─────────────────────────────
// clusterID 由簇内成员 id 排序后取 sha1 前 8 位派生(稳定:同簇成员不变 ⇒ id 不变,便于复算比对)。
func clusterID(c *EvidenceCluster) string {
if c == nil {
return ""
}
ids := evidenceIDs(c.Members)
sorted := append([]string(nil), ids...)
sort.Strings(sorted)
h := sha1.Sum([]byte(strings.Join(sorted, "|")))
return fmt.Sprintf("c%x", h[:4])
}
// clusterTopic 用代表证据的首行(去 markdown 前缀/空白)做一句话簇主题底本,截断 60 rune。
// 人审据此判断"这簇在讲什么",与草稿场景/步骤是否一致一眼可核。
func clusterTopic(c *EvidenceCluster) string {
if c == nil {
return ""
}
first := firstLine(c.Representative.Content)
r := []rune(first)
const max = 60
if len(r) > max {
first = string(r[:max]) + "…"
}
return strings.TrimSpace(first)
}
// firstLine 取内容首个非空行,去掉常见的 markdown 引用/列表前缀(> - * #)。
func firstLine(s string) string {
for _, ln := range strings.Split(s, "\n") {
ln = strings.TrimSpace(ln)
if ln == "" {
continue
}
ln = strings.TrimLeft(ln, "#>-* ")
if ln == "" {
continue
}
return ln
}
return strings.TrimSpace(s)
}
+353
View File
@@ -0,0 +1,353 @@
// 织忆 MemoryWeave — L3 证据主题聚类测试(t_45677e64 返修)
//
// 覆盖返修卡 AC 的机械判据(零网络 / 确定性 / 复算):
// AC1 跨主题不拼接:FakeClusterer 下 DraftSkill 只喂最大簇证据,异主题证据不进 prompt。
// AC2 簇 <3 拒绝生成:最大簇只有 1~2 条 ⇒ DraftSkill 报错、不写库、不落盘。
// AC3 溯源证据集=簇:VerifyEvidenceTrace 用簇证据,异主题命令 token 判不可溯。
// AC4 草稿头含簇信息:cluster_id + 簇内 id + 簇主题。
// 纯函数 clusterByCosine:相同向量输入 ⇒ 相同标签(确定性)。
package skillgen
import (
"fmt"
"os"
"strings"
"testing"
"github.com/xiaoxue/memoryweave/internal/pattern"
)
// --- 确定性向量助手:把若干主题词映射成低维单位向量,主题不同⇒正交(cos=0),同主题⇒同向量 ---
func vec(axis int, dim int) []float32 {
v := make([]float32, dim)
v[axis] = 1.0
return v
}
// --- clusterByCosine 纯函数 ---
func TestClusterByCosine_DeterministicAndGrouped(t *testing.T) {
// 3 条主题A(axis0) + 2 条主题B(axis1) + 1 条孤例C(axis2)
vecs := [][]float32{
vec(0, 4), vec(0, 4), vec(0, 4),
vec(1, 4), vec(1, 4),
vec(2, 4),
}
labels := clusterByCosine(vecs, 0.80)
if len(labels) != len(vecs) {
t.Fatalf("标签数应等向量数,实际 %d", len(labels))
}
// 前 3 条同簇,4/5 同簇,6 自成簇
if !(labels[0] == labels[1] && labels[1] == labels[2]) {
t.Fatalf("前 3 条应同簇,实际 %v", labels)
}
if labels[3] != labels[4] {
t.Fatalf("4/5 应同簇,实际 %v", labels)
}
if labels[0] == labels[3] {
t.Fatalf("A 簇与 B 簇不应同标签")
}
if labels[5] == labels[0] || labels[5] == labels[3] {
t.Fatalf("C 孤例不应并入 A/B")
}
// 确定性:重跑一致
again := clusterByCosine(vecs, 0.80)
for i := range labels {
if labels[i] != again[i] {
t.Fatalf("非确定性:i=%d %d vs %d", i, labels[i], again[i])
}
}
}
// --- 最大簇选择 ---
func TestLargestCluster_PicksBiggest(t *testing.T) {
ev := []Evidence{
{ID: "a1", Content: "备份数据库前先 cp -a"},
{ID: "a2", Content: "改配置前全量备份 /etc"},
{ID: "a3", Content: "动库前先 cp -a 备份"},
{ID: "b1", Content: "重启服务前先跑测试"},
{ID: "b2", Content: "清理 /tmp 前先 dry-run"}, // 2 条 ≠ 最大
}
// A 簇(备份主题)=3,B 簇=2
fc := &FakeClusterer{}
fc.Keywords = append(fc.Keywords, struct {
Name string
Kws []string
}{"backup", []string{"备份"}}, struct {
Name string
Kws []string
}{"ops", []string{"重启", "清理"}})
labels, err := fc.Cluster(ev)
if err != nil {
t.Fatal(err)
}
big := largestCluster(ev, labels)
if big == nil {
t.Fatal("应选出最大簇")
}
if len(big.Members) != 3 {
t.Fatalf("最大簇应 3 条,实际 %d(簇内 id=%v)", len(big.Members), evidenceIDs(big.Members))
}
for _, m := range big.Members {
if !strings.Contains(m.Content, "备份") {
t.Fatalf("最大簇混入异主题:%s", m.Content)
}
}
}
// --- AC1 + AC4:DraftSkill 走最大簇,草稿头带簇信息 ---
// mixedPattern 的 SourceTasks 含两主题证据;FakeClusterer 分开;草稿只能从最大簇生成。
func mixedEvidence() []Evidence {
return []Evidence{
{ID: "m_bak1", Content: "改配置前全量备份 /etc,cp -a 留底"},
{ID: "m_bak2", Content: "动库前先 cp -a 备份一份"},
{ID: "m_bak3", Content: "迁移前全量备份,快照 backup.tar"},
{ID: "m_clean1", Content: "清理 /tmp zytr-* 前先执行 ls"}, // 异主题:清理
{ID: "m_clean2", Content: "删除前 ls -la 确认文件"}, // 异主题:删除
}
}
func mixedProvider() *FakeEvidenceProvider {
m := map[string]string{}
for _, e := range mixedEvidence() {
m[e.ID] = e.Content
}
return &FakeEvidenceProvider{Map: m}
}
func mixedClusterer() *FakeClusterer {
fc := &FakeClusterer{}
fc.Keywords = append(fc.Keywords,
struct {
Name string
Kws []string
}{"backup", []string{"备份", "cp -a", "留底", "快照"}},
struct {
Name string
Kws []string
}{"clean", []string{"清理", "删除", "rm"}},
)
return fc
}
func mixedPattern() pattern.Pattern {
return pattern.Pattern{
ID: "pat_discipline:*先备份",
Type: "discipline",
Name: "discipline:*先备份",
Data: "*先备份",
Confidence: 0.9,
SourceTasks: []string{"m_bak1", "m_bak2", "m_bak3", "m_clean1", "m_clean2"},
}
}
func TestDraft_OnlyLargestClusterIntoPrompt(t *testing.T) {
store := newTestStore(t)
// FakeGenerator 把注入它的证据 id 写进正文,便于断言"只喂了最大簇"
gen := &RecordingGenerator{}
attRoot := t.TempDir()
sk, path, err := DraftSkillClustered(store, gen, mixedProvider(), mixedClusterer(), mixedPattern(), attRoot)
if err != nil {
t.Fatalf("DraftSkill 报错: %v", err)
}
// 最大簇 = 3 条备份证据,clean 主题的 2 条不得进入 prompt
got := strings.Join(gen.seenIDs, ",")
for _, id := range []string{"m_bak1", "m_bak2", "m_bak3"} {
if !strings.Contains(got, id) {
t.Fatalf("最大簇证据 %s 未注入 prompt,实际=%s", id, got)
}
}
for _, id := range []string{"m_clean1", "m_clean2"} {
if strings.Contains(got, id) {
t.Fatalf("跨主题证据 %s 违规进入 prompt(拼接怪回归)", id)
}
}
// AC4:草稿头含簇信息(cluster_id + 簇内 id + 簇主题)
head := sk.Content
if !strings.Contains(head, "主题簇") {
t.Fatalf("草稿头应含簇标识行,实际:\n%s", head)
}
if !strings.Contains(head, "簇内证据 id") {
t.Fatalf("草稿头应含簇内证据 id 列表")
}
if !strings.Contains(head, "簇主题") {
t.Fatalf("草稿头应含一句话簇主题")
}
// 簇主题应取自备份主题(代表证据含「备份」字样)
if !strings.Contains(head, "备份") {
t.Fatalf("簇主题应与最大簇同主题(含「备份」),实际:\n%s", head)
}
// 簇内证据 id 应是 3 条备份 id,不含 clean
if strings.Contains(head, "m_clean1") || strings.Contains(head, "m_clean2") {
t.Fatalf("簇快照不应含异主题 id,实际:\n%s", head)
}
// 落盘文件存在
if path == "" {
t.Fatal("应有落盘文件路径")
}
}
// RecordingGenerator 记录 Generate 看到的证据 id(验证只喂最大簇)。
type RecordingGenerator struct {
seenIDs []string
}
func (g *RecordingGenerator) Generate(p pattern.Pattern, ev []Evidence) (string, error) {
g.seenIDs = nil
for _, e := range ev {
g.seenIDs = append(g.seenIDs, e.ID)
}
// 草稿正文只用证据里出现过的 token,保证可溯率 100%
return "## 适用场景\n改配置前用 `cp -a` 留底备份。\n", nil
}
// --- AC2:最大簇 <3 ⇒ 拒绝生成、不写库、不落盘 ---
func TestDraft_LargestClusterTooSmallRejects(t *testing.T) {
store := newTestStore(t)
attRoot := t.TempDir()
// 证据里只有 2 条同主题,最大簇=2 <3
ev := []Evidence{
{ID: "x1", Content: "清理 /tmp 前先 ls"},
{ID: "x2", Content: "删除前先确认"},
{ID: "y1", Content: "重启前先跑测试"},
}
prov := &FakeEvidenceProvider{Map: map[string]string{"x1": ev[0].Content, "x2": ev[1].Content, "y1": ev[2].Content}}
fc := &FakeClusterer{}
fc.Keywords = append(fc.Keywords,
struct {
Name string
Kws []string
}{"clean", []string{"清理", "删除"}},
struct {
Name string
Kws []string
}{"ops", []string{"重启"}},
)
pat := pattern.Pattern{ID: "p", Name: "p", Confidence: 0.9, SourceTasks: []string{"x1", "x2", "y1"}}
_, _, err := DraftSkillClustered(store, &RecordingGenerator{}, prov, fc, pat, attRoot)
if err == nil {
t.Fatal("最大簇=2(<3) 应拒绝生成")
}
if !strings.Contains(err.Error(), "宁缺毋滥") && !strings.Contains(err.Error(), "<3") {
t.Fatalf("报错应说明簇不足,实际: %v", err)
}
if n, _ := store.Count(""); n != 0 {
t.Fatalf("拒绝生成不应写库,实际 %d 行", n)
}
ents, _ := readDirLen(attRoot)
if ents != 0 {
t.Fatalf("拒绝生成不应落盘,实际 %d 项", ents)
}
}
func readDirLen(dir string) (int, error) {
ents, err := os.ReadDir(dir)
return len(ents), err
}
// --- AC3:异主题命令 token 不可溯(证据集=簇,非全证据)---
func TestVerifyTrace_EvidenceSetIsCluster(t *testing.T) {
// 簇证据只含备份原文;草稿写了「清理 /tmp zytr-*」token ⇒ 应判不可溯(<100%)
clusterEV := []Evidence{
{ID: "m_bak1", Content: "改配置前全量备份 /etc,cp -a 留底"},
{ID: "m_bak2", Content: "动库前先 cp -a 备份一份"},
{ID: "m_bak3", Content: "迁移前全量备份"},
}
// 含 /tmp zytr-* 路径 token(来自异主题,簇内不存在)
draft := "先 `cp -a` 备份,再清理 `/tmp zytr-*` 目录"
rate, missing := VerifyEvidenceTrace(draft, clusterEV)
if rate >= 1.0 {
t.Fatalf("异主题 token 应被溯源拦下,实际可溯率=%.2f", rate)
}
if len(missing) == 0 {
t.Fatal("应报缺失 token")
}
found := false
for _, tok := range missing {
if strings.Contains(tok, "zytr") || strings.Contains(tok, "/tmp") {
found = true
}
}
if !found {
t.Fatalf("缺失 token 应含异主题路径,实际 %v", missing)
}
}
// --- BGEClusterer 退化路径:embed 返回错误 ⇒ 逐条孤例,绝不并成杂烩 ---
func TestBGEClusterer_EmbedFailDegradesToSingletons(t *testing.T) {
failing := func(texts []string) ([][]float32, error) { return nil, fmt.Errorf("embed down") }
bc := NewBGEClusterer(failing)
ev := mixedEvidence()
labels, err := bc.Cluster(ev)
if err != nil {
t.Fatalf("embed 失败应退化为孤例而非报错: %v", err)
}
// 每条标签唯一(孤例)⇒ 最大簇=1
uniq := map[int]bool{}
for _, l := range labels {
if uniq[l] {
t.Fatalf("失败路径不应把不同主题并到同标签")
}
uniq[l] = true
}
if len(uniq) != len(ev) {
t.Fatalf("应全孤例,实际唯一簇=%d vs %d 证据", len(uniq), len(ev))
}
}
func TestBGEClusterer_GroupsSameTopic(t *testing.T) {
// 注入确定性向量:相同 axis = 同主题
emb := func(texts []string) ([][]float32, error) {
out := make([][]float32, len(texts))
for i, s := range texts {
if strings.Contains(s, "备份") || strings.Contains(s, "cp -a") {
out[i] = vec(0, 4)
} else {
out[i] = vec(1+i%3, 4) // 异主题各向
}
}
return out, nil
}
bc := NewBGEClusterer(emb)
labels, err := bc.Cluster(mixedEvidence())
if err != nil {
t.Fatal(err)
}
big := largestCluster(mixedEvidence(), labels)
if big == nil || len(big.Members) < 3 {
t.Fatalf("备份主题 3 条应成最大簇,实际=%v", big)
}
}
// --- sanitizeDraft:删漏抄规则行 + 空占位行("照着能做"判据)---
func TestSanitizeDraft_StripsLeakedRulesAndEmptyPlaceholders(t *testing.T) {
dirty := `适用场景 / 关键步骤 / 命令或操作要点 / 注意事项
- 适用场景:改脚本前先查引用
- 命令或操作要点:` + "`grep -rn script` 看谁在调用" + `
- 注意事项:无
- 注意事项:只提炼证据里真实发生过的操作与踩坑;不确定的细节宁缺毋滥,不要脑补。
- 注意事项:草稿里出现的每一条命令都必须逐字来自证据原文。
`
clean := sanitizeDraft(dirty)
for _, bad := range []string{"宁缺毋滥", "逐字来自证据", "真实发生过", "注意事项:无", "不要脑补"} {
if strings.Contains(clean, bad) {
t.Fatalf("sanitizeDraft 未删污染 %q,输出:\n%s", bad, clean)
}
}
// 保真:真实内容(命令 + 适用场景)应保留
if !strings.Contains(clean, "grep -rn") {
t.Fatalf("sanitizeDraft 误删真实命令:\n%s", clean)
}
if !strings.Contains(clean, "改脚本前先查引用") {
t.Fatalf("sanitizeDraft 误删真实场景:\n%s", clean)
}
}
+14
View File
@@ -43,6 +43,11 @@ type PatternSnapshot struct {
EvidenceIDs []string `json:"evidence_ids"` // ≥3 条 episode id,单向追到 episode
EvidenceCount int `json:"evidence_count"`
CreatedAt string `json:"created_at"` // pattern 落库时间(空=未知)
// ── 主题簇快照(t_45677e64 返修 #4:草稿头标注簇信息,便于人审"这簇在讲什么")──
ClusterID string `json:"cluster_id,omitempty"` // 簇标识(pattern + 成员 id 哈希前缀)
ClusterEvidenceIDs []string `json:"cluster_evidence_ids,omitempty"` // 簇内证据 id 列表
ClusterTopic string `json:"cluster_topic,omitempty"` // 一句话簇主题(代表证据摘要)
ClusterSize int `json:"cluster_size,omitempty"` // 簇内证据数
}
// ─── 命令 token 抽取与溯源校验(D2 #3)───────────────────────────────────
@@ -130,6 +135,15 @@ func (s PatternSnapshot) SnapString() string {
b.WriteString(fmt.Sprintf("- 来源 pattern: `%s` (name=`%s`, conf=%.2f)\n", s.SourcePattern, s.PatternName, s.Confidence))
b.WriteString(fmt.Sprintf("- pattern 快照 created_at: %s\n", orDash(s.CreatedAt)))
b.WriteString(fmt.Sprintf("- 支撑证据 episode id (%d条): `%s`\n", s.EvidenceCount, strings.Join(ev, "`,`")))
if s.ClusterID != "" {
cids := s.ClusterEvidenceIDs
if cids == nil {
cids = []string{}
}
b.WriteString(fmt.Sprintf("- 主题簇: `%s` (簇内 %d 条同主题证据)\n", s.ClusterID, s.ClusterSize))
b.WriteString(fmt.Sprintf("- 簇主题: %s\n", orDash(s.ClusterTopic)))
b.WriteString(fmt.Sprintf("- 簇内证据 id (%d条): `%s`\n", len(cids), strings.Join(cids, "`,`")))
}
return b.String()
}
+81 -2
View File
@@ -95,7 +95,82 @@ func (g *Local2BGenerator) Generate(p pattern.Pattern, ev []Evidence) (string, e
if len(out.Choices) == 0 || out.Choices[0].Message.Content == "" {
return "", fmt.Errorf("本地 2B 空输出")
}
return out.Choices[0].Message.Content, nil
return sanitizeDraft(out.Choices[0].Message.Content), nil
}
// leakedInstructionSubstrings 是 draftPrompt 里给模型的"红线规则"原句片段。
// 小模型常把这些约束文本当成内容抄进草稿正文(实测:注意事项里出现"禁止杜撰/禁止通用模板填空"),
// 污染"照着能做"的可读性。sanitizeDraft 据此删除命中这些片段的输出行。
var leakedInstructionSubstrings = []string{
"禁止杜撰", "禁止通用模板填空", "逐字来自", "逐字来自证据", "原样出处",
"不要脑补", "宁缺毋滥", "不要标题外的寒暄", "不要脑补。",
"草稿里出现的每一条命令", "只提炼证据里真实发生过",
}
// emptyPlaceholderRe 命中的是"要点:无 / 注意事项:无"这类空占位行(无信息量)。
// sanitizeDraft 删除它们(草稿宁短勿水,空段直接省略)。
// sanitizeDraft 清理本地 2B 输出里的两类污染(返修:"照着能做"判据):
// 1. 删掉把 prompt 红线规则抄进正文的行(含 leakedInstructionSubstrings 任一子串)。
// 2. 删掉"X:无"空占位行(无任何信息,纯模板填空)。
// 3. 折叠连续空行为单个空行,去掉首尾空白。
// 纯文本处理,无副作用,单测可复算。
func sanitizeDraft(s string) string {
lines := strings.Split(s, "\n")
out := make([]string, 0, len(lines))
blank := false
for _, ln := range lines {
trimmed := strings.TrimSpace(ln)
if trimmed == "" {
// 折叠连续空行:只在非空段之间留一个空行
if len(out) > 0 && !blank {
out = append(out, "")
blank = true
}
continue
}
blank = false
if hasAnySubstring(trimmed, leakedInstructionSubstrings) {
continue // 抄进去的规则文本,删
}
if isEmptyPlaceholder(trimmed) {
continue // "要点:无"这类空占位,删
}
out = append(out, ln)
}
// 去首尾空行
for len(out) > 0 && strings.TrimSpace(out[0]) == "" {
out = out[1:]
}
for len(out) > 0 && strings.TrimSpace(out[len(out)-1]) == "" {
out = out[:len(out)-1]
}
return strings.Join(out, "\n")
}
func hasAnySubstring(s string, subs []string) bool {
for _, sub := range subs {
if strings.Contains(s, sub) {
return true
}
}
return false
}
// isEmptyPlaceholder 判定"要点:无 / 注意事项:无 / X: 无"这类空占位行。
func isEmptyPlaceholder(s string) bool {
// 去掉 markdown 列表符
s = strings.TrimLeft(strings.TrimSpace(s), "-*# ")
for _, sep := range []string{":", ":"} {
i := strings.Index(s, sep)
if i >= 0 {
val := strings.TrimSpace(s[i+len(sep):])
if val == "无" || val == "-" || val == "—" || val == "N/A" || val == "n/a" {
return true
}
}
}
return false
}
// draftPrompt 生成 skill 草稿的提示词。证据原文(≥3 条优先,少于则全注入)注入 prompt,
@@ -123,6 +198,10 @@ func draftPrompt(p pattern.Pattern, ev []Evidence) string {
2. 只提炼证据里真实发生过的操作与踩坑;不确定的细节宁缺毋滥,不要脑补。
3. 用简体中文;结构包含「适用场景 / 关键步骤 / 命令或操作要点 / 注意事项」;
直接给正文,不要标题外的寒暄。
4. 上面 1-3 条是给你的写作规则,绝对不许把它们(或"禁止杜撰""宁缺毋滥""逐字来自证据"
这类字样)写进草稿正文;草稿正文只能是证据里的操作内容。
5. 某一节若证据里没有可写内容,就整节省略,不要写"要点:无""注意事项:无"这种空占位。
6. 优先写证据里出现过的具体命令/路径/参数(可照做的操作),而不是复述纪律口号。
模式类型:%s
模式名:%s
@@ -131,7 +210,7 @@ func draftPrompt(p pattern.Pattern, ev []Evidence) string {
支撑任务数:%d
涉及工具:%s
【证据原文(来自真实记忆,起草稿的唯一依据)】%s
【证据原文(来自同一主题的簇,是起草稿的唯一依据)】%s
技能草稿:`,
p.Type, p.Name, p.Confidence, p.Data, len(p.SourceTasks), joinTools(p.Tools), b.String())
+50 -15
View File
@@ -64,16 +64,26 @@ type Generator interface {
Generate(p pattern.Pattern, ev []Evidence) (string, error)
}
// DraftSkill 核心编排:conf≥0.85 的 pattern → 取证据 → 生成草稿 → 校验溯源 → 写库(draft) → 落盘。
// DraftSkill 核心编排:conf≥0.85 的 pattern → 取证据 → 主题聚类 → 取证据 → 生成草稿 → 校验溯源 → 写库(draft) → 落盘。
// 返回落盘文件的绝对路径。任何一步失败都不落盘、不改库。
//
// 流程(t_9ccbca15 返修后):
// 流程(t_45677e64 返修后):
// 1. 取证据:ev = EvidenceProvider.FetchEvidence(p.SourceTasks),<3 条 → 拒绝(D2 无证据不许写)。
// 2. 生成草稿:gen.Generate(p, ev),prompt 已注入真实原文。
// 3. 溯源校验:VerifyEvidenceTrace(body, ev),命令可溯率 <100% → 拒绝(D2 兜底)。
// 4. 嵌溯源快照:PatternSnapshot(source_pattern + evidence ids + created_at)写进草稿头(D1)。
// 5. 写库(status=draft) + 落盘 attachments/<pattern>/skill-draft.md。
// 2. 主题聚类:clusters = clusterer.Cluster(ev),取最大簇;簇内证据 <MinClusterEvidence(3) → 拒绝
// (卡返修 #1/#2:不许把几十条不同主题证据混着喂 LLM,宁缺毋滥)。
// 3. 生成草稿:gen.Generate(p, 最大簇证据),prompt 只注入【同簇】原文。
// 4. 溯源校验:VerifyEvidenceTrace(body, 最大簇证据),命令可溯率 <100% → 拒绝(证据集=簇,#3)。
// 5. 嵌快照:PatternSnapshot(source_pattern + 簇内证据 ids + cluster 信息 + created_at)写进草稿头(D1 + #4)。
// 6. 写库(status=draft) + 落盘 attachments/<pattern>/skill-draft.md。
//
// clusterer 传 nil 时退化为"全部证据一个簇"(兼容旧调用方;不推荐——会重现拼接怪)。
func DraftSkill(store *Store, gen Generator, prov EvidenceProvider, p pattern.Pattern, attachmentsRoot string) (*Skill, string, error) {
return DraftSkillClustered(store, gen, prov, nil, p, attachmentsRoot)
}
// DraftSkillClustered 是 DraftSkill 的显式聚类版:clusterer 非 nil 时按主题簇生成。
// 生产(probe / API)应传 BGEClusterer,确保场景/步骤/要点同簇(卡返修 #3)。
func DraftSkillClustered(store *Store, gen Generator, prov EvidenceProvider, clusterer TopicClusterer, p pattern.Pattern, attachmentsRoot string) (*Skill, string, error) {
if store == nil || gen == nil {
return nil, "", fmt.Errorf("skillgen: store/generator 未注入")
}
@@ -96,18 +106,39 @@ func DraftSkill(store *Store, gen Generator, prov EvidenceProvider, p pattern.Pa
return nil, "", fmt.Errorf("skillgen: pattern %s 证据不足 %d 条(<3),拒绝生成(D2 红线)",
p.Name, len(ev))
}
body, err := gen.Generate(p, ev)
// 2. 主题聚类(返修 #1/#2):最大簇 = 生成用的唯一证据集
var cluster *EvidenceCluster
if clusterer != nil {
labels, cerr := clusterer.Cluster(ev)
if cerr != nil {
return nil, "", fmt.Errorf("skillgen: 主题聚类失败: %w", cerr)
}
cluster = largestCluster(ev, labels)
if cluster == nil || len(cluster.Members) < MinClusterEvidence {
n := 0
if cluster != nil {
n = len(cluster.Members)
}
return nil, "", fmt.Errorf("skillgen: pattern %s 最大主题簇仅 %d 条(<%d),拒绝生成(返修红线:宁缺毋滥,别拿 1 条撑)",
p.Name, n, MinClusterEvidence)
}
} else {
// 兼容旧调用方:不聚类 = 全证据一簇(会拼接头,生产应传 clusterer)
cluster = &EvidenceCluster{Label: 0, Members: ev, Representative: ev[0]}
}
clusterEV := cluster.Members
body, err := gen.Generate(p, clusterEV)
if err != nil {
return nil, "", fmt.Errorf("skillgen: 生成草稿失败: %w", err)
}
// 3. 溯源校验(D2 #3:命令可溯率 <100% 一律不合格)
rate, missing := VerifyEvidenceTrace(body, ev)
// 4. 溯源校验(返修 #3:证据集=簇,可溯率 <100% 一律不合格)
rate, missing := VerifyEvidenceTrace(body, clusterEV)
if rate < 1.0 {
return nil, "", fmt.Errorf("skillgen: 草稿命令可溯率 %.0f%%(<100%%),拒绝落盘;未溯源 token: %v",
rate*100, missing)
}
// 4+2. 统一包一层 [AUTO-DRAFT] 头 + 溯源快照(D1:单行可追到 episode)
content := draftHeader(p, ev) + "\n" + body
// 5+3. 统一包一层 [AUTO-DRAFT] 头 + 溯源快照(D1 + #4:簇信息便于人审)
content := draftHeader(p, clusterEV, cluster) + "\n" + body
created, err := store.PutDraft(p.ID, content)
if err != nil {
@@ -127,8 +158,8 @@ func DraftSkill(store *Store, gen Generator, prov EvidenceProvider, p pattern.Pa
return sk, path, nil
}
// draftHeader 草稿头部:marker + status + 来源 pattern + 溯源快照(D1)。
func draftHeader(p pattern.Pattern, ev []Evidence) string {
// draftHeader 草稿头部:marker + status + 来源 pattern + 溯源快照 + 簇快照(D1 + #4)。
func draftHeader(p pattern.Pattern, ev []Evidence, cluster *EvidenceCluster) string {
snap := PatternSnapshot{
SourcePattern: p.ID,
PatternName: p.Name,
@@ -137,8 +168,12 @@ func draftHeader(p pattern.Pattern, ev []Evidence) string {
EvidenceCount: len(ev),
CreatedAt: nowUTC(),
}
// 快照里的 created_at 取 pattern 落库时间(graph_nodes.created_at),这里先用生成时刻;
// 能读到节点 created_at 的调用方(API 层)可覆写,见 WithCreatedAt 选项。
if cluster != nil {
snap.ClusterID = clusterID(cluster)
snap.ClusterEvidenceIDs = evidenceIDs(cluster.Members)
snap.ClusterTopic = clusterTopic(cluster)
snap.ClusterSize = len(cluster.Members)
}
return fmt.Sprintf("# %s %s\n\n> status: draft | %s | 需人工审核进技能库\n\n%s",
AUTO_DRAFT_MARKER, skillTitle(p), snap.SnapString(), snapLine(snap))
}
+19 -2
View File
@@ -91,6 +91,7 @@ func (s *Store) Close() {
// PutDraft 写入/覆盖一条 draft 草稿。返回 created(true=新插入)。
// active 已有行 → 不改(保护人工审核成果)。
// stale 已有行 → 覆盖内容并复位为 draft(旧草稿重生成,返修 #5 的复活路径)。
func (s *Store) PutDraft(sourcePattern, content string) (bool, error) {
db, err := s.open()
if err != nil {
@@ -103,8 +104,8 @@ func (s *Store) PutDraft(sourcePattern, content string) (bool, error) {
// 人工已升级,不覆盖
return false, nil
}
if status == "draft" {
_, err = db.Exec(`UPDATE skills SET content=?, last_updated_at=? WHERE source_pattern=?`,
if status == "draft" || status == "stale" {
_, err = db.Exec(`UPDATE skills SET status='draft', content=?, last_updated_at=? WHERE source_pattern=?`,
content, now, sourcePattern)
return false, err
}
@@ -113,6 +114,22 @@ func (s *Store) PutDraft(sourcePattern, content string) (bool, error) {
return err == nil, err
}
// MarkAllStale 把全部 status='draft' 的行标记为 'stale'(返修 #5:旧草稿重生成前先作废,
// 防止人 promote 到上一版拼接怪)。已是 stale/active 的行不动。返回受影响行数。
func (s *Store) MarkAllStale() (int, error) {
db, err := s.open()
if err != nil {
return 0, err
}
now := time.Now().UTC().Format(time.RFC3339)
res, err := db.Exec(`UPDATE skills SET status='stale', last_updated_at=? WHERE status='draft'`, now)
if err != nil {
return 0, err
}
n, _ := res.RowsAffected()
return int(n), nil
}
// Promote draft→active(人工确认升级)。未找到行 → 报错。
func (s *Store) Promote(sourcePattern string) error {
db, err := s.open()