// 织忆 MemoryWeave — L2 模式检测引擎(t_d32e5f8a) // // 背景:MemOS 血统的 L2「跨任务重复模式」检测。原实现活在 Python daemon 的 // main_loop(30s tick),2026-09-24 为 state-db 写安全整体退役后 L2 pattern 蒸馏 // 停摆(graph_nodes type='pattern' 停为 0 行;旧 Python daemon 残留的 85 行是 // type='pattern_stat',id 全 NULL、语义为 L1 命名空间统计快照,非 L2 pattern / 2026-09-18)。本包把 L1→L2 蒸馏 // 复活成**短命单发**(modernc sqlite 直连 graph.db,开/关不占长连接,不碰 state.db), // 并按设计 §4.1 叠加两条检测规则: // - 工具组合频率:同一 tool 组合(成员 ∈ knownTools 白名单、≥2 成员、排除通用词) // 被 ≥2 条独立来源记忆支撑 → tool_combo pattern(confidence = min(freq*0.1, 1.0)); // 落库另需 confidence ≥ MinWriteConfidence=0.5(判据收紧史见 t_639c5a03) // - 相似解决路径聚类:cosine ≥0.85 成簇且簇内 ≥3 条 → workflow pattern // // 存储:复用现有 graph_nodes(type='pattern'),**不另开新表**(避免与现存图谱查询割裂; // 表内另有 85 行 type='pattern_stat' 属旧 daemon 统计快照,与 L2 pattern 无关)。 // namespace='daemon-distill' 沿用旧 daemon 约定。 package pattern import ( "fmt" "math" "sort" "strings" "github.com/xiaoxue/memoryweave/internal/models" ) // Pattern 一个被检测出的 L2 模式。 type Pattern struct { ID string Type string // "tool_combo" | "workflow" Name string // 稳定命名键(同组合去重) Data string // tool_combo=排序后工具串;workflow=共同步骤/代表路径摘要 Confidence float64 SourceTasks []string // 支撑该 pattern 的记忆 ID(设计 source_tasks) Tools []string // tool_combo 专用 } // Config 检测参数(设计 §4.1)。 type Config struct { MinComboFreq int // 工具组合需 ≥ N 条**独立来源记忆**才产 pattern(默认 2,t_639c5a03 门槛) ClusterThresh float64 // 相似路径聚类 cosine 阈值(默认 0.85) MinClusterSize int // 簇内 ≥ N 条才产 workflow pattern(默认 3) MaxRecords int // 单次扫描参与检测的记忆上限(防 O(n²) 爆炸,默认 500) TopKPatternList int // 召回/列出取前 N(默认 10) // WorkflowPatterns 是否启用「相似解决路径聚类」workflow 分支。 // t_639c5a03 三审(小怡 2026-10-30)后决定**默认退役**:该分支把簇内最长记忆正文当 // Data(truncate 120 字),在自然语言语料上产出即「整句记忆正文 conf=1.0」的伪 pattern, // 违反「不许把记忆正文当 pattern name」硬约束。通道退役,默认关闭;仅当显式开启才跑。 WorkflowPatterns bool } // DefaultConfig 设计参数。WorkflowPatterns 默认 false = workflow 分支退役(t_639c5a03 三审)。 func DefaultConfig() Config { return Config{ MinComboFreq: 2, ClusterThresh: 0.85, MinClusterSize: 3, MaxRecords: 500, TopKPatternList: 10, WorkflowPatterns: false, } } // MinWriteConfidence 落库置信度门槛(小怡二轮裁定 #5,2026-10-30):conf<0.5 一律不写库。 // tool_combo 的 conf=来源数×0.1 ⇒ 实际要求 ≥5 条独立来源;workflow 簇需平均相似度 ≥0.5。 const MinWriteConfidence = 0.5 // knownTools 真实命令/CLI 名(小写)白名单 —— tool_combo 成员的**唯一**来源。 // t_639c5a03 二轮(小怡 2026-10-30 裁定):原"含 -/数字即可"的命令式标识兜底放行是 // hash 片段(374b20f98c44/ac10)、目录名(05-ai-agent)、文件名(dispatch-backlog.jsonl)、 // CVE/协议碎片(cve-2026-99999/ipv4)的进入路径,已整体移除;白名单外一律不进组合键。 // 同时移除过于通用的条目(git/go/curl/grep/cat/ls/find/…,见 genericTools)。 // 新增工具 = 改这张表(可审计),不再靠形态猜测。 var knownTools = map[string]bool{ "jq": true, "yq": true, "sed": true, "awk": true, "wget": true, "tar": true, "zip": true, "unzip": true, "docker": true, "kubectl": true, "helm": true, "npm": true, "pip": true, "python": true, "python3": true, "node": true, "pnpm": true, "make": true, "cmake": true, "gcc": true, "gcc-12": true, "clang": true, "sqlite3": true, "psql": true, "mysql": true, "redis-cli": true, "ssh": true, "scp": true, "rsync": true, "systemctl": true, "journalctl": true, "systemd-run": true, "crontab": true, "rg": true, "ripgrep": true, "fd": true, "fzf": true, "gh": true, "gcloud": true, "aws": true, "hermes": true, "zhiyi": true, "obsidian": true, "esbuild": true, "tsc": true, "cargo": true, "rustc": true, "swift": true, "brew": true, "bash": true, "sh": true, "zsh": true, "openssl": true, "flock": true, "nc": true, "java": true, "javac": true, "mvn": true, "gradle": true, "dotnet": true, "remotion": true, "uv": true, "pytest": true, "gofmt": true, "golangci-lint": true, } // genericTools 过于通用的词/命令(小怡二轮裁定 #4 点名 git/go/curl/grep/bot-chat/mcp/api「等」): // 几乎任何任务都命中 ⇒ 进 pattern 等于往召回 top-3 灌噪声。即使形态合格也**绝不**作为组合成员。 // md/json/py/api/log/db 等亦在 toolStopwords 覆盖内,这里重复登记作双保险。 // 后半段是 shell 基础词(cat/ls/find/…,「等」的裁量延伸:与 git 同级别的散文高频词)。 var genericTools = map[string]bool{ "git": true, "go": true, "curl": true, "grep": true, "bot-chat": true, "mcp": true, "api": true, "md": true, "json": true, "py": true, "cat": true, "ls": true, "cp": true, "mv": true, "rm": true, "mkdir": true, "head": true, "tail": true, "sort": true, "uniq": true, "wc": true, "find": true, "xargs": true, "kill": true, "ps": true, "chmod": true, "touch": true, "diff": true, "echo": true, "ping": true, "lsof": true, "tar": true, } // commonExts 常见文件扩展名(小写,含点)。token 以此结尾 ⇒ 文件名/扩展名,不是工具。 var commonExts = map[string]bool{ ".md": true, ".go": true, ".json": true, ".py": true, ".js": true, ".ts": true, ".tsx": true, ".jsx": true, ".yaml": true, ".yml": true, ".toml": true, ".sh": true, ".db": true, ".sql": true, ".csv": true, ".log": true, ".txt": true, ".html": true, ".css": true, ".rs": true, ".c": true, ".h": true, ".cpp": true, ".conf": true, ".xml": true, ".ini": true, ".env": true, ".pdf": true, ".png": true, ".jpg": true, ".jpeg": true, ".svg": true, ".gif": true, ".ipynb": true, ".lock": true, ".sum": true, ".bak": true, ".tmp": true, ".gz": true, ".mp4": true, ".mp3": true, ".docx": true, ".xlsx": true, ".pptx": true, ".service": true, ".sock": true, ".socket": true, } // toolStopwords 常见停用词(小写):高频非工具词,绝不作为工具名(卡要求第 1 条)。 var toolStopwords = map[string]bool{ "the": true, "and": true, "for": true, "with": true, "that": true, "this": true, "from": true, "into": true, "then": true, "when": true, "what": true, "they": true, "have": true, "will": true, "your": true, "not": true, "but": true, "all": true, "can": true, "use": true, "via": true, "per": true, "are": true, "was": true, "one": true, "two": true, "ok": true, "yes": true, "true": true, "false": true, "null": true, "none": true, "etc": true, "vs": true, "id": true, "ids": true, "ns": true, "log": true, "logs": true, "file": true, "files": true, "path": true, "line": true, "lines": true, "name": true, "type": true, "data": true, "time": true, "date": true, "test": true, "note": true, "step": true, "steps": true, "first": true, "last": true, "next": true, "top": true, "api": true, "http": true, "https": true, "url": true, "uri": true, "json": true, "yaml": true, "yml": true, "md": true, "txt": true, "tmp": true, "dev": true, "prod": true, "src": true, "doc": true, "docs": true, "ref": true, "config": true, "default": true, "error": true, "errors": true, "warn": true, "info": true, "debug": true, "fail": true, "failed": true, "success": true, "start": true, "stop": true, "check": true, "list": true, "get": true, "set": true, "new": true, "old": true, "fix": true, "pr": true, "mr": true, "db": true, } // DetectFromRecords 纯检测核心:从 L1 记忆列表发现重复模式。 // 不读 LanceDB / 不写库,只做「记录 → pattern 候选」,便于确定性单测。 // 返回合并去重后的 pattern 列表(同 Name 合并 source_tasks、取更高 confidence)。 func DetectFromRecords(records []models.MemoryRecord, cfg Config) []Pattern { if cfg.MinComboFreq <= 0 { cfg.MinComboFreq = 2 } if cfg.MinClusterSize <= 0 { cfg.MinClusterSize = 3 } if cfg.ClusterThresh <= 0 { cfg.ClusterThresh = 0.85 } lim := cfg.MaxRecords if lim <= 0 { lim = 500 } if len(records) > lim { records = records[:lim] } combined := make(map[string]*Pattern) // Name → merged pattern order := []string{} merge := func(p Pattern) { if ex, ok := combined[p.Name]; ok { ex.SourceTasks = append(ex.SourceTasks, p.SourceTasks...) if p.Confidence > ex.Confidence { ex.Confidence = p.Confidence } return } combined[p.Name] = &p order = append(order, p.Name) } // 1. 工具组合频率分析 comboCount := map[string]*struct { tools []string tasks []string }{} for _, rec := range records { tools := ExtractTools(rec.Content) if len(tools) == 0 { continue } tools = dedupeSorted(tools) key := "tool_combo:" + strings.Join(tools, "+") c := comboCount[key] if c == nil { c = &struct { tools []string tasks []string }{tools: tools} comboCount[key] = c } c.tasks = append(c.tasks, rec.ID) } for name, c := range comboCount { // 二轮:「组合」语义 —— 单工具无共现信息量,≥2 个成员才产 tool_combo。 if len(c.tools) < 2 { continue } // t_639c5a03 门槛:支撑数按**独立来源记忆**(去重且非空 ID)计,< MinComboFreq 直接丢。 seen := map[string]bool{} var sources []string for _, id := range c.tasks { if id != "" && !seen[id] { seen[id] = true sources = append(sources, id) } } if len(sources) < cfg.MinComboFreq { continue } merge(Pattern{ Type: "tool_combo", Name: name, Data: strings.Join(c.tools, "+"), Tools: c.tools, Confidence: confidenceFromFreq(len(sources)), SourceTasks: sources, }) } // 2. 相似解决路径聚类(cosine ≥ 阈值 成簇,簇内 ≥ N 条) // t_639c5a03 三审:该分支把记忆正文当 pattern Data(整句注入),默认退役;仅 cfg.WorkflowPatterns 显式开启才跑。 if cfg.WorkflowPatterns { paths := clusterPaths(records, cfg.ClusterThresh, cfg.MinClusterSize) for _, cluster := range paths { // 代表路径 = 簇内最长 content(共同步骤近似) rep := "" var ids []string for _, r := range cluster { ids = append(ids, r.ID) if len(r.Content) > len(rep) { rep = r.Content } } conf := clusterConfidence(cluster) // 平均两两 cosine,封顶 1.0 if conf > 1.0 { conf = 1.0 } // 簇名带代表内容哈希前 8 位 —— 同 size 不同内容簇不碰撞(否则 cluster-3 撞簇) name := fmt.Sprintf("workflow:cluster-%d-%s", len(cluster), contentFingerprint(rep)) merge(Pattern{ Type: "workflow", Name: name, Data: truncateForPattern(rep, 120), Confidence: conf, SourceTasks: ids, }) } } out := make([]Pattern, 0, len(order)) for _, n := range order { p := *combined[n] p.SourceTasks = dedupeStrings(p.SourceTasks) if p.Type == "tool_combo" { p.ID = "pat_" + p.Name } else { p.ID = "pat_" + p.Name } out = append(out, p) } sort.SliceStable(out, func(i, j int) bool { if out[i].Type != out[j].Type { return out[i].Type < out[j].Type } return out[i].Name < out[j].Name }) return out } // confidenceFromFreq 设计公式:min(freq*0.1, 1.0)。 func confidenceFromFreq(freq int) float64 { c := float64(freq) * 0.1 if c > 1.0 { c = 1.0 } return c } // isNumericUnitFragment 数值+单位碎片(小怡二轮裁定 #2):^\d+(\.\d+)?(mb|kb|gb|tb|ms|ns|us|s|m|h|x|%)?$ // 例:"2.6mb"、"512kb"、"100ms"、"3x"。纯数字无单位形态由 isNumericFragment 拦截,这里不重复依赖它。 func isNumericUnitFragment(tok string) bool { i := 0 for i < len(tok) && tok[i] >= '0' && tok[i] <= '9' { i++ } if i == 0 { return false // 无数字前缀 ⇒ 不是该形态 } if i < len(tok) && tok[i] == '.' { j := i + 1 for j < len(tok) && tok[j] >= '0' && tok[j] <= '9' { j++ } if j == i+1 { return false // '.' 后无数字 ⇒ 不是该形态 } i = j } switch strings.ToLower(tok[i:]) { case "": return true // 纯数字 case "mb", "kb", "gb", "tb", "ms", "ns", "us", "s", "m", "h", "x", "%": return true } return false } // isHexOnly token 是否只由 [0-9a-f] 构成(非空)。 func isHexOnly(s string) bool { if s == "" { return false } for i := 0; i < len(s); i++ { c := s[i] if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) { return false } } return true } // isHashFragment hash/uuid 碎片(小怡二轮裁定 #1): // - 纯 [0-9a-f] 且 len≥6 ⇒ hash 片段(374b20f98c44 / b713b48a70ad / 635dccc0); // - 纯 [0-9a-f] 且 len≥4 且含数字 ⇒ 短 hash(ac10);'cafe'/'beef' 类纯字母词放行; // - 形如 - 前缀 ⇒ uuid 段(^[0-9a-f]{2,}-[0-9a-f]{2,},如 b713-48a7)。 // 'gcc-12'(gcc 非 hex)、'redis-cli'(r 非 hex)不受影响。 func isHashFragment(tok string) bool { if idx := strings.IndexByte(tok, '-'); idx > 0 { head, rest := tok[:idx], tok[idx+1:] tail := rest if k := strings.IndexByte(rest, '-'); k >= 0 { tail = rest[:k] } if len(head) >= 2 && isHexOnly(head) && len(tail) >= 2 && isHexOnly(tail) { return true } } if !isHexOnly(tok) { return false } if len(tok) >= 6 { return true } return len(tok) >= 4 && strings.ContainsAny(tok, "0123456789") } // isNumberedDirName 数字编号目录名(小怡二轮裁定 #3):^\d+(-[a-z]+)+$ // 例:"05-ai-agent"、"38-patternfix"。"gcc-12"(首段非数字)不受影响。 func isNumberedDirName(tok string) bool { parts := strings.Split(tok, "-") if len(parts) < 2 { return false } first := parts[0] if first == "" { return false } for i := 0; i < len(first); i++ { if first[i] < '0' || first[i] > '9' { return false // 首段非纯数字 } } for _, seg := range parts[1:] { if seg == "" { return false } for i := 0; i < len(seg); i++ { if seg[i] < 'a' || seg[i] > 'z' { return false // 某段含数字/非法字符 } } } return true } // clusterPaths 贪心成簇:为每条未分配记忆开一个簇,把与其 cosine≥阈值 的其余未分配 // 记忆并入;最终只保留 size≥minSize 的簇。向量缺失时用记录自带 Vector,全缺则退到 // 文本 bigram Jaccard(确定性,不依赖网络)。 func clusterPaths(records []models.MemoryRecord, thresh float64, minSize int) [][]models.MemoryRecord { n := len(records) if n < minSize { return nil } type sig struct { vec []float32 big map[string]bool text string } sigs := make([]sig, n) for i, r := range records { sigs[i] = sig{vec: r.Vector, text: r.Content} } sim := func(a, b int) float64 { sa, sb := sigs[a], sigs[b] if len(sa.vec) > 0 && len(sb.vec) > 0 { return cosineF32(sa.vec, sb.vec) } if len(sa.vec) == 0 && len(sb.vec) == 0 { return bigramJaccard(sa.text, sb.text) } return 0 } assigned := make([]bool, n) var clusters [][]models.MemoryRecord for i := 0; i < n; i++ { if assigned[i] { continue } cluster := []models.MemoryRecord{records[i]} assigned[i] = true for j := i + 1; j < n; j++ { if assigned[j] { continue } if sim(i, j) >= thresh { cluster = append(cluster, records[j]) assigned[j] = true } } if len(cluster) >= minSize { clusters = append(clusters, cluster) } } return clusters } // clusterConfidence 簇内平均两两相似度(cosine 或 Jaccard)。 func clusterConfidence(cluster []models.MemoryRecord) float64 { n := len(cluster) if n < 2 { return 1.0 } sum := 0.0 pairs := 0 for i := 0; i < n; i++ { for j := i + 1; j < n; j++ { var s float64 a, b := cluster[i], cluster[j] if len(a.Vector) > 0 && len(b.Vector) > 0 { s = cosineF32(a.Vector, b.Vector) } else { s = bigramJaccard(a.Content, b.Content) } sum += s pairs++ } } if pairs == 0 { return 1.0 } return sum / float64(pairs) } // ExtractTools 从记忆内容提取工具/命令名(t_639c5a03 二轮:白名单唯一来源)。 // 判据(卡·必须实现 #1「来自 tool_use 记录或白名单」+ 小怡二轮"更硬判据"取向): // 成员必须**命中 knownTools 白名单**(词边界),且过 isValidTool 形态闸(通用词黑名单、 // hash/uuid 片段、数值+单位、数字编号目录名、扩展名、日期/版本片段、停用词等)。 // // 旧实现的"命令式标识"兜底(白名单外、含 -/数字即放行)是二轮 dry-run 里 // hash 片段(374b20f98c44/ac10)、目录名(05-ai-agent)、文件名(dispatch-backlog.jsonl)、 // CVE/协议碎片(cve-2026-99999/ipv4)的进入路径,已整体移除。 // 确定性:结果排序去重。 func ExtractTools(content string) []string { lower := strings.ToLower(content) out := make([]string, 0, 4) for t := range knownTools { // 词边界匹配(避免 "go" 命中 "google") if isValidTool(t) && tokenPresent(lower, t) { out = append(out, t) } } sort.Strings(out) return out } // isValidTool token 形态判据(lowercase):是否为真实命令/工具标识的形状。 // 排除:长度 <2 或 >32;含 '/'、'\\'、'_'(路径、usage_track 键、t_9143c968 任务 ID); // 以 '.' 开头(".md");无字母(纯数字/纯标点/数字+分隔符);以常见扩展名结尾 // (report.md / a.py);数字/日期/版本片段(2026、2026-09-23、2026+23、09:23、1.2.3、v1.2.3); // 停用词。 func isValidTool(tok string) bool { if len(tok) < 2 || len(tok) > 32 { return false } if genericTools[tok] { return false // 通用词黑名单(二轮 #4) } if strings.ContainsAny(tok, `/_\`) { return false } if tok[0] == '.' || tok[0] == '-' { return false // 隐藏文件 / CLI flag } hasLetter := false for i := 0; i < len(tok); i++ { if c := tok[i]; (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') { hasLetter = true break } } if !hasLetter { return false } if i := strings.LastIndexByte(tok, '.'); i > 0 && commonExts[tok[i:]] { return false } if isNumericFragment(tok) { return false } if isNumericUnitFragment(tok) { return false // 二轮 #2:2.6mb / 512kb / 100ms } if isHashFragment(tok) { return false // 二轮 #1:374b20f98c44 / ac10 / uuid 片段 } if isNumberedDirName(tok) { return false // 二轮 #3:05-ai-agent / 38-patternfix } if toolStopwords[tok] { return false } return true } // isNumericFragment 纯数字 / 日期 / 时间 / 版本片段: // - 只由数字与分隔符 [-+:./] 组成("2026"、"2026-09-23"、"2026+23"、"09:23"、"1.2.3"),或 // - 至多一个前导字母 + 其余全为数字/分隔符("v1.2.3"、"v2")。 // // "gcc-12"/"sqlite3" 这类字母出现在数字之前且不止前导一个 ⇒ 正常标识,返回 false。 func isNumericFragment(tok string) bool { if tok == "" { return false } seenDigit := false rest := tok if c := rest[0]; (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') { rest = rest[1:] // 至多剥一个前导字母 } for _, r := range rest { switch { case r >= '0' && r <= '9': seenDigit = true case r == '-' || r == '+' || r == ':' || r == '.' || r == '/': // 分隔符放行 default: return false // 还有别的字母/字符 ⇒ 不是纯数字片段 } } return seenDigit } // tokenPresent 检查 lower 文本中 t 是否作为独立 token 出现(词边界,避免 "go" 命中 "google")。 func tokenPresent(lower, t string) bool { if t == "" { return false } // 切词精确匹配 for _, w := range strings.Fields(lower) { // 剥掉包裹的引号/逗号/括号 w = strings.Trim(w, `"',()[]|;:`) if w == t { return true } } // 空格/首尾边界 if strings.Contains(lower, " "+t+" ") || strings.HasPrefix(lower, t+" ") || strings.HasSuffix(lower, " "+t) { return true } return false } func dedupeSorted(in []string) []string { seen := map[string]bool{} out := make([]string, 0, len(in)) for _, s := range in { if !seen[s] { seen[s] = true out = append(out, s) } } sort.Strings(out) return out } func dedupeStrings(in []string) []string { seen := map[string]bool{} out := make([]string, 0, len(in)) for _, s := range in { if !seen[s] { seen[s] = true out = append(out, s) } } return out } func cosineF32(a, b []float32) float64 { if len(a) == 0 || len(b) == 0 || len(a) != len(b) { return 0 } var dot, na, nb float64 for i := range a { x, y := float64(a[i]), float64(b[i]) dot += x * y na += x * x nb += y * y } if na == 0 || nb == 0 { return 0 } c := dot / (float64(math.Sqrt(na)) * float64(math.Sqrt(nb))) if c > 1.0 { c = 1.0 } if c < -1.0 { c = -1.0 } return c } // bigramJaccard 字符 bigram Jaccard 相似度(无向量时的确定性回退)。 func bigramJaccard(a, b string) float64 { bg := func(s string) map[string]bool { m := make(map[string]bool) r := []rune(s) for i := 0; i+1 < len(r); i++ { m[string(r[i:i+2])] = true } return m } ma, mb := bg(a), bg(b) if len(ma) == 0 && len(mb) == 0 { return 1.0 } if len(ma) == 0 || len(mb) == 0 { return 0.0 } inter := 0 for k := range ma { if mb[k] { inter++ } } uni := len(ma) + len(mb) - inter if uni == 0 { return 0 } return float64(inter) / float64(uni) } // contentFingerprint 取 content 稳定短指纹(FNV 前 8 hex 位)——同 size 不同内容簇去重。 func contentFingerprint(s string) string { if s == "" { return "empty" } // FNV-1a 32 h := uint32(2166136261) for i := 0; i < len(s); i++ { h ^= uint32(s[i]) h *= 16777619 } return fmt.Sprintf("%08x", h) } func truncateForPattern(s string, n int) string { r := []rune(s) if len(r) <= n { return s } return string(r[:n]) + "…" } // IsValidPatternName pattern 命名键合法性闸门(t_639c5a03,写入前最后防线)。 // 合法形态: // - tool_combo:(+)* —— 每个成员过 isValidTool // - workflow:cluster-- // // 其余("tool_combo:.md"、"tool_combo:2026+23" 等垃圾键)一律拒绝, // UpsertPatterns 拒写 —— 即使调用方判据再退化,垃圾也进不了 graph_nodes。 func IsValidPatternName(name string) bool { i := strings.IndexByte(name, ':') if i <= 0 { return false } body := name[i+1:] if body == "" { return false } switch name[:i] { case "tool_combo": parts := strings.Split(body, "+") if len(parts) < 2 { return false // 「组合」语义:单成员键拒写(二轮) } for _, t := range parts { // 写入闸 = 白名单唯一来源 + 形态检查(通用词/hash/数值/目录碎片黑名单)。 if !knownTools[t] || !isValidTool(t) { return false } } return true case "workflow": return strings.HasPrefix(body, "cluster-") } return false }