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:
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
|
||||
|
||||
@@ -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())
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user