diff --git a/go/cmd/pattern-fullscan-probe/main.go b/go/cmd/pattern-fullscan-probe/main.go index 5e8c89b..e3c880c 100644 --- a/go/cmd/pattern-fullscan-probe/main.go +++ b/go/cmd/pattern-fullscan-probe/main.go @@ -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) } } diff --git a/go/internal/api/routes/patterns.go b/go/internal/api/routes/patterns.go index 4411011..0dddfd0 100644 --- a/go/internal/api/routes/patterns.go +++ b/go/internal/api/routes/patterns.go @@ -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 diff --git a/go/internal/api/server.go b/go/internal/api/server.go index da16801..efb0c13 100644 --- a/go/internal/api/server.go +++ b/go/internal/api/server.go @@ -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() diff --git a/go/internal/skillgen/cluster.go b/go/internal/skillgen/cluster.go new file mode 100644 index 0000000..fe9721a --- /dev/null +++ b/go/internal/skillgen/cluster.go @@ -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(各成孤例), + // 调用方按"最大簇 = 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) +} + + diff --git a/go/internal/skillgen/cluster_test.go b/go/internal/skillgen/cluster_test.go new file mode 100644 index 0000000..f1e231c --- /dev/null +++ b/go/internal/skillgen/cluster_test.go @@ -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) + } +} diff --git a/go/internal/skillgen/evidence.go b/go/internal/skillgen/evidence.go index 92ab00b..c5890f7 100644 --- a/go/internal/skillgen/evidence.go +++ b/go/internal/skillgen/evidence.go @@ -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() } diff --git a/go/internal/skillgen/generator.go b/go/internal/skillgen/generator.go index f945df1..bd8fc0e 100644 --- a/go/internal/skillgen/generator.go +++ b/go/internal/skillgen/generator.go @@ -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()) diff --git a/go/internal/skillgen/skillgen.go b/go/internal/skillgen/skillgen.go index e2b19ec..c99cc6a 100644 --- a/go/internal/skillgen/skillgen.go +++ b/go/internal/skillgen/skillgen.go @@ -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//skill-draft.md。 +// 2. 主题聚类:clusters = clusterer.Cluster(ev),取最大簇;簇内证据 /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)) } diff --git a/go/internal/skillgen/store.go b/go/internal/skillgen/store.go index 1759b4a..3481923 100644 --- a/go/internal/skillgen/store.go +++ b/go/internal/skillgen/store.go @@ -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()