// 织忆 MemoryWeave — SQLite 持久存储后端(CGO,实现 LanceDB 接口) package storage /* #cgo LDFLAGS: -lsqlite3 #include #include */ import "C" import ( "bytes" "encoding/binary" "fmt" "sort" "sync" "time" "unsafe" "github.com/xiaoxue/memoryweave/internal/models" ) // SQLiteClient CGO 直连 SQLite3,实现 LanceDB 接口。 // 生产环境持久化存储,替代 MemLanceClient。 type SQLiteClient struct { mu sync.RWMutex db *C.sqlite3 path string } func NewSQLiteClient(dbPath string) (*SQLiteClient, error) { if dbPath == "" { dbPath = "/var/lib/zhiyi/data/memoryweave.db" } cPath := C.CString(dbPath) defer C.free(unsafe.Pointer(cPath)) var db *C.sqlite3 rc := C.sqlite3_open(cPath, &db) if rc != C.SQLITE_OK { errMsg := C.GoString(C.sqlite3_errmsg(db)) C.sqlite3_close(db) return nil, fmt.Errorf("sqlite open: %s", errMsg) } // 性能优化 C.sqlite3_exec(db, C.CString("PRAGMA journal_mode=WAL"), nil, nil, nil) C.sqlite3_exec(db, C.CString("PRAGMA synchronous=NORMAL"), nil, nil, nil) C.sqlite3_exec(db, C.CString("PRAGMA busy_timeout=5000"), nil, nil, nil) C.sqlite3_exec(db, C.CString("PRAGMA cache_size=-20000"), nil, nil, nil) sc := &SQLiteClient{db: db, path: dbPath} if err := sc.migrate(); err != nil { C.sqlite3_close(db) return nil, err } return sc, nil } func (sc *SQLiteClient) Close() error { sc.mu.Lock() defer sc.mu.Unlock() if sc.db != nil { C.sqlite3_close(sc.db) sc.db = nil } return nil } // ─── migration ──────────────────────────────────────── func (sc *SQLiteClient) migrate() error { sqls := []string{ `CREATE TABLE IF NOT EXISTS memories ( id TEXT PRIMARY KEY, agent_id TEXT NOT NULL, namespace TEXT NOT NULL DEFAULT '', content TEXT NOT NULL, category TEXT NOT NULL DEFAULT 'general', vector BLOB, tier TEXT NOT NULL DEFAULT 'normal', importance REAL DEFAULT 1.0, quality_score REAL DEFAULT 0.0, recall_count INTEGER DEFAULT 0, -- GA-P0-2 (t_c6d41ac6):拆分 recall_count 的两种语义 recall_seen_count INTEGER DEFAULT 0, recall_verified_count INTEGER DEFAULT 0, useful_count INTEGER DEFAULT 0, not_useful_count INTEGER DEFAULT 0, -- GA-P0-1 (t_718d8707):拆分 not_useful_count 的两种语义(人工没用 / dedup 自动降权) human_not_useful_count INTEGER DEFAULT 0, dedup_downweight_count INTEGER DEFAULT 0, freshness TEXT DEFAULT 'fresh', version INTEGER DEFAULT 1, version_history TEXT DEFAULT '[]', source TEXT DEFAULT '', volatile_flag INTEGER DEFAULT 0, is_deleted INTEGER DEFAULT 0, -- GA-P0-3 (t_f785d7f2):删除原因枚举(merge_dup|contradiction|manual|retention|unknown) delete_reason TEXT DEFAULT '', depends_on TEXT DEFAULT '[]', derived_from TEXT DEFAULT '', source_events TEXT DEFAULT '[]', supersedes TEXT DEFAULT '[]', -- 2026-10-14 (t_3e98b65a):被取代方标记(反向指针,写时 UPDATE 在旧记忆上写) superseded_by TEXT DEFAULT '[]', -- 2026-10-14 (t_3ada332b):bi-temporal 有效期(默认 NULL=永久有效)+ provenance 来源类型 valid_from TEXT DEFAULT '', valid_to TEXT DEFAULT '', provenance TEXT DEFAULT '', last_recalled_at TEXT DEFAULT '', created_at TEXT NOT NULL, updated_at TEXT NOT NULL )`, `CREATE TABLE IF NOT EXISTS episodes ( id TEXT PRIMARY KEY, agent_id TEXT NOT NULL, namespace TEXT NOT NULL DEFAULT '', content TEXT NOT NULL, category TEXT NOT NULL DEFAULT 'general', distilled_to TEXT DEFAULT '', distill_status TEXT DEFAULT 'pending', created_at TEXT NOT NULL )`, `CREATE TABLE IF NOT EXISTS tombstones ( id TEXT PRIMARY KEY, original_id TEXT NOT NULL, content_snapshot TEXT DEFAULT '', namespace TEXT DEFAULT '', reason TEXT NOT NULL DEFAULT '', merged_into TEXT DEFAULT '', deleted_at TEXT NOT NULL )`, `CREATE TABLE IF NOT EXISTS version_history ( id INTEGER PRIMARY KEY AUTOINCREMENT, memory_id TEXT NOT NULL, version INTEGER NOT NULL, content TEXT NOT NULL, source TEXT DEFAULT '', reason TEXT DEFAULT '', timestamp TEXT NOT NULL, FOREIGN KEY (memory_id) REFERENCES memories(id) )`, `CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id)`, `CREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories(namespace)`, `CREATE INDEX IF NOT EXISTS idx_memories_deleted ON memories(is_deleted)`, // GA-P0-4 (t_bb10e8bc):hits+/hits− outcome 事件(append-only 事件表,语义定义见 hit_event.go)。 // 每次真实 outcome 追加一行,带 created_at 时间戳,**不覆盖式累加** —— 便于按周窗口聚合。 // 只由真实 outcome 写入(人工反馈/矛盾/取代/下游引用);dedup 降权 / 单纯召回出现禁止写入。 `CREATE TABLE IF NOT EXISTS hit_events ( id INTEGER PRIMARY KEY AUTOINCREMENT, memory_id TEXT NOT NULL, outcome TEXT NOT NULL, reason TEXT NOT NULL, source TEXT DEFAULT '', created_at TEXT NOT NULL, FOREIGN KEY (memory_id) REFERENCES memories(id) )`, `CREATE INDEX IF NOT EXISTS idx_hit_events_memory ON hit_events(memory_id)`, `CREATE INDEX IF NOT EXISTS idx_hit_events_memory_outcome_created ON hit_events(memory_id, outcome, created_at)`, // 2026-10-13 (t_e9a4d18f P2) 常设答案:knowledge pages 的落地表(mental models)。 // question_id 唯一;answer 为生成的常设答案;source_memories 是可追溯的证据记忆 ID // 列表("这个答案是根据哪几条改的");version 每次改写 +1;updated_at 记录改写时间。 // 读取 = 一次 DB 读(question_id 主键查询),无检索、无 LLM 调用(Hindsight 原则)。 `CREATE TABLE IF NOT EXISTS standing_answers ( question_id TEXT PRIMARY KEY, question TEXT NOT NULL, answer TEXT NOT NULL, source_memories TEXT DEFAULT '[]', version INTEGER DEFAULT 1, created_at TEXT NOT NULL, updated_at TEXT NOT NULL )`, // 下面是原 migrate 里回忆 INDEX 占位,勿删(保持行号稳定)。 `CREATE INDEX IF NOT EXISTS idx_episodes_agent ON episodes(agent_id)`, `CREATE INDEX IF NOT EXISTS idx_version_history_mem ON version_history(memory_id)`, } for _, s := range sqls { if err := sc.exec(s); err != nil { return fmt.Errorf("migrate: %w", err) } } // GA-P0-1 (t_718d8707):存量表 add 拆分列(additive,不删旧列 not_useful_count) for _, c := range []struct{ col, ddl string }{ {"human_not_useful_count", "ALTER TABLE memories ADD COLUMN human_not_useful_count INTEGER DEFAULT 0"}, {"dedup_downweight_count", "ALTER TABLE memories ADD COLUMN dedup_downweight_count INTEGER DEFAULT 0"}, // GA-P0-2 (t_c6d41ac6):拆分 recall_count 的两种语义(additive,不删旧列 recall_count) {"recall_seen_count", "ALTER TABLE memories ADD COLUMN recall_seen_count INTEGER DEFAULT 0"}, {"recall_verified_count", "ALTER TABLE memories ADD COLUMN recall_verified_count INTEGER DEFAULT 0"}, // GA-P0-3 (t_f785d7f2):is_deleted 的删除原因(additive,TEXT 存固定枚举) {"delete_reason", "ALTER TABLE memories ADD COLUMN delete_reason TEXT DEFAULT ''"}, // 2026-10-13 (t_e9a4d18f P1) 证据链:全量来源 episode ID(additive,TEXT JSON 数组) {"source_events", "ALTER TABLE memories ADD COLUMN source_events TEXT DEFAULT '[]'"}, // 2026-10-13 (t_e9a4d18f P1) 矛盾保留:被取代的旧记忆 ID(additive) {"supersedes", "ALTER TABLE memories ADD COLUMN supersedes TEXT DEFAULT '[]'"}, // 2026-10-14 (t_3e98b65a) 被取代方标记:反向指针(additive,写时 UPDATE 在旧记忆上写) {"superseded_by", "ALTER TABLE memories ADD COLUMN superseded_by TEXT DEFAULT '[]'"}, // 2026-10-14 (t_3ada332b) bi-temporal 有效期 + provenance(additive;存量缺省空串=永久有效) {"valid_from", "ALTER TABLE memories ADD COLUMN valid_from TEXT DEFAULT ''"}, {"valid_to", "ALTER TABLE memories ADD COLUMN valid_to TEXT DEFAULT ''"}, {"provenance", "ALTER TABLE memories ADD COLUMN provenance TEXT DEFAULT ''"}, } { rows, err := sc.query("PRAGMA table_info(memories)") if err != nil { return fmt.Errorf("migrate pragma: %w", err) } has := false for _, r := range rows { if r["name"] == c.col { has = true break } } if !has { if err := sc.exec(c.ddl); err != nil { return fmt.Errorf("migrate add %s: %w", c.col, err) } } } return nil } // ─── CGO helpers ────────────────────────────────────── func (sc *SQLiteClient) exec(sql string) error { cSQL := C.CString(sql) defer C.free(unsafe.Pointer(cSQL)) var errMsg *C.char rc := C.sqlite3_exec(sc.db, cSQL, nil, nil, &errMsg) if rc != C.SQLITE_OK { msg := C.GoString(errMsg) C.sqlite3_free(unsafe.Pointer(errMsg)) return fmt.Errorf("sqlite: %s", msg) } return nil } func (sc *SQLiteClient) execWithArgs(sql string, args ...interface{}) error { cSQL := C.CString(sql) defer C.free(unsafe.Pointer(cSQL)) var stmt *C.sqlite3_stmt rc := C.sqlite3_prepare_v2(sc.db, cSQL, C.int(len(sql)), &stmt, nil) if rc != C.SQLITE_OK { return fmt.Errorf("sqlite prepare: %s", C.GoString(C.sqlite3_errmsg(sc.db))) } defer C.sqlite3_finalize(stmt) for i, arg := range args { idx := C.int(i + 1) switch v := arg.(type) { case nil: C.sqlite3_bind_null(stmt, idx) case int: C.sqlite3_bind_int64(stmt, idx, C.sqlite3_int64(v)) case int64: C.sqlite3_bind_int64(stmt, idx, C.sqlite3_int64(v)) case float64: C.sqlite3_bind_double(stmt, idx, C.double(v)) case bool: if v { C.sqlite3_bind_int(stmt, idx, 1) } else { C.sqlite3_bind_int(stmt, idx, 0) } case string: cStr := C.CString(v) C.sqlite3_bind_text(stmt, idx, cStr, C.int(len(v)), (*[0]byte)(C.free)) case []byte: if len(v) == 0 { C.sqlite3_bind_null(stmt, idx) } else { C.sqlite3_bind_blob(stmt, idx, unsafe.Pointer(&v[0]), C.int(len(v)), nil) } default: return fmt.Errorf("unsupported arg type %T", arg) } } rc = C.sqlite3_step(stmt) if rc != C.SQLITE_DONE && rc != C.SQLITE_ROW { return fmt.Errorf("sqlite step: %s", C.GoString(C.sqlite3_errmsg(sc.db))) } return nil } type sqliteRow map[string]interface{} func (sc *SQLiteClient) query(sql string) ([]sqliteRow, error) { cSQL := C.CString(sql) defer C.free(unsafe.Pointer(cSQL)) var stmt *C.sqlite3_stmt rc := C.sqlite3_prepare_v2(sc.db, cSQL, C.int(len(sql)), &stmt, nil) if rc != C.SQLITE_OK { return nil, fmt.Errorf("sqlite prepare: %s", C.GoString(C.sqlite3_errmsg(sc.db))) } defer C.sqlite3_finalize(stmt) var rows []sqliteRow for { rc = C.sqlite3_step(stmt) if rc == C.SQLITE_DONE { break } if rc != C.SQLITE_ROW { return nil, fmt.Errorf("sqlite step: %s", C.GoString(C.sqlite3_errmsg(sc.db))) } colCount := int(C.sqlite3_column_count(stmt)) row := make(sqliteRow, colCount) for i := 0; i < colCount; i++ { name := C.GoString(C.sqlite3_column_name(stmt, C.int(i))) colType := C.sqlite3_column_type(stmt, C.int(i)) switch colType { case C.SQLITE_INTEGER: row[name] = int64(C.sqlite3_column_int64(stmt, C.int(i))) case C.SQLITE_FLOAT: row[name] = float64(C.sqlite3_column_double(stmt, C.int(i))) case C.SQLITE_TEXT: row[name] = C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, C.int(i))))) case C.SQLITE_BLOB: n := int(C.sqlite3_column_bytes(stmt, C.int(i))) ptr := C.sqlite3_column_blob(stmt, C.int(i)) blob := make([]byte, n) if n > 0 { copy(blob, (*[1 << 30]byte)(ptr)[:n]) } row[name] = blob case C.SQLITE_NULL: row[name] = nil } } rows = append(rows, row) } return rows, nil } // ─── vector helpers ─────────────────────────────────── func vectorToBlob(v []float32) []byte { buf := new(bytes.Buffer) for _, f := range v { binary.Write(buf, binary.LittleEndian, f) } return buf.Bytes() } func blobToVector(b []byte) []float32 { if len(b) == 0 { return nil } vec := make([]float32, len(b)/4) buf := bytes.NewReader(b) for i := range vec { binary.Read(buf, binary.LittleEndian, &vec[i]) } return vec } // ─── LanceDB 接口 ───────────────────────────────────── func (sc *SQLiteClient) InsertEpisode(agentID, namespace, content, category string) (string, error) { id := fmt.Sprintf("ep_%d", time.Now().UnixNano()) now := time.Now().Format(time.RFC3339) sc.mu.Lock() defer sc.mu.Unlock() return id, sc.execWithArgs( "INSERT INTO episodes(id,agent_id,namespace,content,category,created_at) VALUES(?,?,?,?,?,?)", id, agentID, namespace, content, category, now, ) } func (sc *SQLiteClient) InsertMemory(m models.MemoryRecord) error { now := time.Now().Format(time.RFC3339) vecBlob := vectorToBlob(m.Vector) sc.mu.Lock() defer sc.mu.Unlock() return sc.execWithArgs( `INSERT INTO memories(id,agent_id,namespace,content,category,vector,tier,importance,quality_score, source,depends_on,derived_from,source_events,supersedes,superseded_by,valid_from,valid_to,provenance,version,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,?)`, m.ID, m.AgentID, m.Namespace, m.Content, m.Category, vecBlob, m.Tier, 1.0, m.QualityScore, "", "[]", m.DerivedFrom, seJSON(m.SourceEvents), seJSON(m.Supersedes), seJSON(m.SupersededBy), m.ValidFrom, m.ValidTo, m.Provenance, now, now, ) } func (sc *SQLiteClient) Insert(table string, record any) error { sc.mu.Lock() defer sc.mu.Unlock() now := time.Now().Format(time.RFC3339) switch r := record.(type) { case models.MemoryRecord: return sc.InsertMemory(r) case models.EpisodeRecord: return sc.execWithArgs( "INSERT INTO episodes(id,agent_id,namespace,content,category,distilled_to,distill_status,created_at) VALUES(?,?,?,?,?,?,?,?)", r.ID, r.AgentID, r.Namespace, r.Content, r.Category, "", "pending", now, ) case models.TombstoneRecord: delTime := r.CreatedAt.Format(time.RFC3339) return sc.execWithArgs( "INSERT INTO tombstones(id,original_id,content_snapshot,namespace,reason,merged_into,deleted_at) VALUES(?,?,?,?,?,?,?)", r.ID, r.OriginalID, "", "", r.Reason, "", delTime, ) default: return fmt.Errorf("sqlite: unsupported record type %T", record) } } // Scan SQLite 后端的全表扫描(is_deleted=0 + 可选 namespace,按 created_at 倒序)。 func (sc *SQLiteClient) Scan(limit int, namespaceFilter string) ([]models.MemoryRecord, error) { if limit <= 0 { limit = 100 } sc.mu.RLock() defer sc.mu.RUnlock() q := "SELECT id, content, category, namespace, importance, quality_score, recall_count, recall_seen_count, recall_verified_count, not_useful_count, human_not_useful_count, dedup_downweight_count, tier, source, created_at, updated_at, source_events, supersedes, superseded_by, valid_from, valid_to, provenance FROM memories WHERE is_deleted=0" if namespaceFilter != "" { q += " AND namespace='" + sanitizeIdent(namespaceFilter) + "'" } q += " ORDER BY created_at DESC LIMIT " + fmt.Sprintf("%d", limit) rows, err := sc.query(q) if err != nil { return nil, err } out := make([]models.MemoryRecord, 0, len(rows)) for _, row := range rows { rec := models.MemoryRecord{} rec.ID, _ = row["id"].(string) rec.Content, _ = row["content"].(string) rec.Category, _ = row["category"].(string) rec.Namespace, _ = row["namespace"].(string) rec.Importance, _ = row["importance"].(float64) rec.QualityScore, _ = row["quality_score"].(float64) rec.Tier, _ = row["tier"].(string) rec.Source, _ = row["source"].(string) if se, ok := row["source_events"].(string); ok { rec.SourceEvents = parseSourceEvents(se) // 2026-10-13 P1 } if ss, ok := row["supersedes"].(string); ok { rec.Supersedes = parseSourceEvents(ss) // 2026-10-13 P1 } if sb, ok := row["superseded_by"].(string); ok { rec.SupersededBy = parseSourceEvents(sb) // 2026-10-14 t_3e98b65a } if n, ok := row["recall_count"].(int64); ok { rec.RecallCount = int(n) } // GA-P0-2 (t_c6d41ac6):拆分字段读侧接线 if n, ok := row["recall_seen_count"].(int64); ok { rec.RecallSeenCount = int(n) } if n, ok := row["recall_verified_count"].(int64); ok { rec.RecallVerifiedCount = int(n) } if n, ok := row["not_useful_count"].(int64); ok { rec.NotUsefulCount = int(n) } if n, ok := row["human_not_useful_count"].(int64); ok { rec.HumanNotUsefulCount = int(n) } if n, ok := row["dedup_downweight_count"].(int64); ok { rec.DedupDownweightCount = int(n) } if ts, ok := row["created_at"].(string); ok { if t, e := time.Parse(time.RFC3339, ts); e == nil { rec.CreatedAt = t } } if ts, ok := row["updated_at"].(string); ok { if t, e := time.Parse(time.RFC3339, ts); e == nil { rec.UpdatedAt = t } } // 2026-10-14 (t_3ada332b):bi-temporal 有效期 + provenance 读回 rec.ValidFrom, _ = row["valid_from"].(string) rec.ValidTo, _ = row["valid_to"].(string) rec.Provenance, _ = row["provenance"].(string) out = append(out, rec) } return out, nil } func (sc *SQLiteClient) Search(table string, vector []float32, topK int, namespaceFilter string) ([]models.MemoryRecord, error) { sc.mu.RLock() defer sc.mu.RUnlock() // 加载所有未被删除的记录 + 向量 (按 importance 加权排序) query := "SELECT id, content, category, namespace, vector, importance, created_at, valid_from, valid_to, provenance FROM memories WHERE is_deleted=0" if namespaceFilter != "" { query += " AND namespace='" + sanitizeIdent(namespaceFilter) + "'" } rows, err := sc.query(query) if err != nil { return nil, err } type candidate struct { rec models.MemoryRecord score float64 } var candidates []candidate for _, row := range rows { vecBlob, _ := row["vector"].([]byte) candVec := blobToVector(vecBlob) sim := cosineSim(vector, candVec) importance, _ := row["importance"].(float64) if importance <= 0 { importance = 1.0 } createdAt, _ := time.Parse(time.RFC3339, strVal(row, "created_at")) candidates = append(candidates, candidate{ rec: models.MemoryRecord{ ID: strVal(row, "id"), Content: strVal(row, "content"), Category: strVal(row, "category"), Namespace: strVal(row, "namespace"), CreatedAt: createdAt, ValidFrom: strVal(row, "valid_from"), ValidTo: strVal(row, "valid_to"), Provenance: strVal(row, "provenance"), }, score: sim * importance, // importance 加权 }) } sort.Slice(candidates, func(i, j int) bool { return candidates[i].score > candidates[j].score }) if topK > len(candidates) { topK = len(candidates) } results := make([]models.MemoryRecord, topK) for i := 0; i < topK; i++ { results[i] = candidates[i].rec } return results, nil } func (sc *SQLiteClient) GetTopByQuality(agentID string, limit int) ([]models.MemoryRecord, error) { sc.mu.RLock() defer sc.mu.RUnlock() rows, err := sc.query( "SELECT id,content,category,namespace,created_at FROM memories WHERE is_deleted=0 ORDER BY quality_score DESC LIMIT " + itoa(limit), ) if err != nil { return nil, err } return sc.rowsToMemories(rows), nil } func (sc *SQLiteClient) Stats() (map[string]interface{}, error) { sc.mu.RLock() defer sc.mu.RUnlock() var memCount, epCount, tombCount int64 rows, _ := sc.query("SELECT COUNT(*) as cnt FROM memories WHERE is_deleted=0") if len(rows) > 0 { memCount, _ = rows[0]["cnt"].(int64) } rows, _ = sc.query("SELECT COUNT(*) as cnt FROM episodes") if len(rows) > 0 { epCount, _ = rows[0]["cnt"].(int64) } rows, _ = sc.query("SELECT COUNT(*) as cnt FROM tombstones") if len(rows) > 0 { tombCount, _ = rows[0]["cnt"].(int64) } return map[string]interface{}{ "memory_count": memCount, "episode_count": epCount, "tombstone_count": tombCount, "backend": "sqlite3 (CGO)", "db_path": sc.path, }, nil } func (sc *SQLiteClient) SoftDelete(id, reason string) error { sc.mu.Lock() defer sc.mu.Unlock() now := time.Now().Format(time.RFC3339) // GA-P0-3 (t_f785d7f2):写 delete_reason(归一化枚举),让 is_deleted=1 可分原因。 dr := NormalizeDeleteReason(reason) if err := sc.execWithArgs( "UPDATE memories SET is_deleted=1, delete_reason=?, updated_at=? WHERE id=?", dr, now, id, ); err != nil { return err } tombID := fmt.Sprintf("tomb_%d", time.Now().UnixNano()) return sc.execWithArgs( "INSERT INTO tombstones(id,original_id,reason,deleted_at) VALUES(?,?,?,?)", tombID, id, reason, now, ) } func (sc *SQLiteClient) SoftDeleteBatch(table string, ids []string, updatedAt string) (int64, error) { if table != "memories" { return 0, fmt.Errorf("unsupported table: %s", table) } sc.mu.Lock() defer sc.mu.Unlock() var updated int64 // GA-P0-3 (t_f785d7f2):批量软删不携带逐条原因 ⇒ delete_reason=unknown(兜底)。 for _, id := range ids { res := sc.execWithArgs( "UPDATE memories SET is_deleted=1, delete_reason=?, updated_at=? WHERE id=?", DeleteReasonUnknown, updatedAt, id, ) if res != nil { return updated, res } updated++ } return updated, nil } func (sc *SQLiteClient) GetVersionHistory(id string) ([]map[string]interface{}, error) { sc.mu.RLock() defer sc.mu.RUnlock() rows, err := sc.query( "SELECT version,content,source,reason,timestamp FROM version_history WHERE memory_id=? ORDER BY version DESC", ) if err != nil { return nil, err } // 用笨办法实现参数化查询避免重写 query 函数 if len(rows) == 0 { return nil, nil } // 直接重新查询带参数 cSQL := C.CString("SELECT version,content,source,reason,timestamp FROM version_history WHERE memory_id=? ORDER BY version DESC") defer C.free(unsafe.Pointer(cSQL)) var stmt *C.sqlite3_stmt C.sqlite3_prepare_v2(sc.db, cSQL, -1, &stmt, nil) defer C.sqlite3_finalize(stmt) cID := C.CString(id) defer C.free(unsafe.Pointer(cID)) C.sqlite3_bind_text(stmt, 1, cID, C.int(len(id)), (*[0]byte)(C.free)) var result []map[string]interface{} for C.sqlite3_step(stmt) == C.SQLITE_ROW { result = append(result, map[string]interface{}{ "version": int64(C.sqlite3_column_int64(stmt, 0)), "content": C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 1)))), "source": C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 2)))), "reason": C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 3)))), "timestamp": C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 4)))), }) } return result, nil } func (sc *SQLiteClient) GetCandidatesForForgetting() ([]map[string]interface{}, error) { sc.mu.RLock() defer sc.mu.RUnlock() rows, err := sc.query( "SELECT id, content, namespace, category, last_recalled_at, recall_count, recall_seen_count, recall_verified_count, tier, importance, created_at FROM memories WHERE is_deleted=0 AND tier!='core' ORDER BY last_recalled_at ASC LIMIT 200", ) if err != nil { return nil, err } var results []map[string]interface{} for _, r := range rows { results = append(results, map[string]interface{}{ "id": r["id"], "content": r["content"], "namespace": r["namespace"], "category": r["category"], "last_recalled_at": r["last_recalled_at"], "recall_count": r["recall_count"], // GA-P0-2 (t_c6d41ac6):衰减/遗忘决策读 recall_verified_count "recall_seen_count": r["recall_seen_count"], "recall_verified_count": r["recall_verified_count"], "tier": r["tier"], "importance": r["importance"], "created_at": r["created_at"], }) } return results, nil } // G7.2: GetSkillCandidates 返回适合结晶为 skill 的记忆候选 // 条件: recall_count >= minRecalls, quality_score >= 0.7, tier != 'core' func (sc *SQLiteClient) GetSkillCandidates(minRecalls, limit int) ([]models.MemoryRecord, error) { sc.mu.RLock() defer sc.mu.RUnlock() sql := `SELECT id, agent_id, namespace, content, category, recall_count, quality_score, importance, tier, last_recalled_at, created_at, updated_at, not_useful_count, human_not_useful_count, dedup_downweight_count, recall_seen_count, recall_verified_count FROM memories WHERE is_deleted = 0 AND tier != 'core' -- GA-P0-2 (t_c6d41ac6):技能候选 = 观测/选择(被召回多次)→ 用 recall_seen_count AND recall_seen_count >= ? AND quality_score >= 0.7 ORDER BY recall_seen_count DESC, quality_score DESC LIMIT ?` cSQL := C.CString(sql) defer C.free(unsafe.Pointer(cSQL)) var stmt *C.sqlite3_stmt rc := C.sqlite3_prepare_v2(sc.db, cSQL, C.int(len(sql)), &stmt, nil) if rc != C.SQLITE_OK { return nil, fmt.Errorf("prepare skill candidates: %s", C.GoString(C.sqlite3_errmsg(sc.db))) } defer C.sqlite3_finalize(stmt) C.sqlite3_bind_int(stmt, 1, C.int(minRecalls)) C.sqlite3_bind_int(stmt, 2, C.int(limit)) var results []models.MemoryRecord for { rc = C.sqlite3_step(stmt) if rc == C.SQLITE_DONE { break } if rc != C.SQLITE_ROW { break } rec := models.MemoryRecord{ ID: C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 0)))), AgentID: C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 1)))), Namespace: C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 2)))), Content: C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 3)))), Category: C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 4)))), RecallCount: int(C.sqlite3_column_int64(stmt, 5)), QualityScore: float64(C.sqlite3_column_double(stmt, 6)), Importance: float64(C.sqlite3_column_double(stmt, 7)), Tier: C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_text(stmt, 8)))), } if lastRecalled := C.sqlite3_column_text(stmt, 9); lastRecalled != nil { rec.LastRecalledAt, _ = time.Parse(time.RFC3339, C.GoString((*C.char)(unsafe.Pointer(lastRecalled)))) } if createdAt := C.sqlite3_column_text(stmt, 10); createdAt != nil { rec.CreatedAt, _ = time.Parse(time.RFC3339, C.GoString((*C.char)(unsafe.Pointer(createdAt)))) } if updatedAt := C.sqlite3_column_text(stmt, 11); updatedAt != nil { rec.UpdatedAt, _ = time.Parse(time.RFC3339, C.GoString((*C.char)(unsafe.Pointer(updatedAt)))) } // GA-P0-1 (t_718d8707):读侧接线拆分字段(追加在 SELECT 尾部,索引 12/13/14) rec.NotUsefulCount = int(C.sqlite3_column_int64(stmt, 12)) rec.HumanNotUsefulCount = int(C.sqlite3_column_int64(stmt, 13)) rec.DedupDownweightCount = int(C.sqlite3_column_int64(stmt, 14)) // GA-P0-2 (t_c6d41ac6):拆分字段(追加在 SELECT 尾部,索引 15/16) rec.RecallSeenCount = int(C.sqlite3_column_int64(stmt, 15)) rec.RecallVerifiedCount = int(C.sqlite3_column_int64(stmt, 16)) results = append(results, rec) } return results, nil } func (sc *SQLiteClient) Backup(path string) error { sc.mu.RLock() defer sc.mu.RUnlock() // SQLite 在线备份 API var pBackup *C.sqlite3_backup cDestPath := C.CString(path) defer C.free(unsafe.Pointer(cDestPath)) var destDB *C.sqlite3 rc := C.sqlite3_open(cDestPath, &destDB) if rc != C.SQLITE_OK { return fmt.Errorf("backup open dest: %s", C.GoString(C.sqlite3_errmsg(destDB))) } defer C.sqlite3_close(destDB) pBackup = C.sqlite3_backup_init(destDB, C.CString("main"), sc.db, C.CString("main")) if pBackup == nil { return fmt.Errorf("backup init: %s", C.GoString(C.sqlite3_errmsg(destDB))) } C.sqlite3_backup_step(pBackup, -1) C.sqlite3_backup_finish(pBackup) return nil } func (sc *SQLiteClient) GetAuditLog(limit int) ([]map[string]interface{}, error) { sc.mu.RLock() defer sc.mu.RUnlock() rows, err := sc.query( "SELECT id,original_id,reason,deleted_at FROM tombstones ORDER BY deleted_at DESC LIMIT " + itoa(limit), ) if err != nil { return nil, err } var results []map[string]interface{} for _, r := range rows { results = append(results, map[string]interface{}{ "id": r["id"], "original_id": r["original_id"], "reason": r["reason"], "deleted_at": r["deleted_at"], }) } return results, nil } func (sc *SQLiteClient) IncrementUseful(id string) error { sc.mu.Lock() defer sc.mu.Unlock() // GA-P0-2 (t_c6d41ac6):正反馈 → useful_count+1 且 recall_verified_count+1。 // 不再碰 recall_count(冻结,保留历史值)。 sc.execWithArgs( "UPDATE memories SET useful_count=useful_count+1, recall_verified_count=recall_verified_count+1, updated_at=? WHERE id=?", time.Now().Format(time.RFC3339), id, ) return nil } // IncrementNotUseful [DEPRECATED](GA-P0-1 t_718d8707)递增 not_useful_count(历史混写列)。 // 新代码走 IncrementHumanNotUseful(人工) / IncrementDedupDownweight(dedup 降权)。 func (sc *SQLiteClient) IncrementNotUseful(id string) error { sc.mu.Lock() defer sc.mu.Unlock() sc.execWithArgs( "UPDATE memories SET not_useful_count=not_useful_count+1, updated_at=? WHERE id=?", time.Now().Format(time.RFC3339), id, ) return nil } // IncrementHumanNotUseful 递增 human_not_useful_count(用户人工点「没用」,GA-P0-1)。 func (sc *SQLiteClient) IncrementHumanNotUseful(id string) error { sc.mu.Lock() defer sc.mu.Unlock() sc.execWithArgs( "UPDATE memories SET human_not_useful_count=human_not_useful_count+1, updated_at=? WHERE id=?", time.Now().Format(time.RFC3339), id, ) return nil } // IncrementDedupDownweight 递增 dedup_downweight_count(dedup/合并流程自动降权,GA-P0-1)。 func (sc *SQLiteClient) IncrementDedupDownweight(id string) error { sc.mu.Lock() defer sc.mu.Unlock() sc.execWithArgs( "UPDATE memories SET dedup_downweight_count=dedup_downweight_count+1, updated_at=? WHERE id=?", time.Now().Format(time.RFC3339), id, ) return nil } // AppendHitEvent 追加一条真实 outcome 事件(GA-P0-4 t_bb10e8bc)。 // 铁律:outcome 必须是 pos/neg(非则报错不写库);dedup 降权 / 单纯召回出现禁止调用。 func (sc *SQLiteClient) AppendHitEvent(memoryID, outcome, reason string) error { outcome = NormalizeHitOutcome(outcome) if !ValidHitOutcomes[outcome] { return fmt.Errorf("AppendHitEvent: invalid outcome %q (must be pos/neg); dedup-demote/recall-appearance are NOT outcomes", outcome) } reason = NormalizeHitReason(reason) sc.mu.Lock() defer sc.mu.Unlock() return sc.execWithArgs( "INSERT INTO hit_events (memory_id, outcome, reason, source, created_at) VALUES (?,?,?,?,?)", memoryID, outcome, reason, "append_hit_event", time.Now().UTC().Format(time.RFC3339), ) } // CountHitEvents 统计某 memory 在某时间窗起点之后的 outcome 事件数(P2 自适应阈值按周窗口用)。 func (sc *SQLiteClient) CountHitEvents(memoryID, outcome string, since time.Time) (int, error) { outcome = NormalizeHitOutcome(outcome) if !ValidHitOutcomes[outcome] { return 0, fmt.Errorf("CountHitEvents: invalid outcome %q", outcome) } sc.mu.RLock() defer sc.mu.RUnlock() // created_at 以 UTC 存储(AppendHitEvent 用 UTC().Format)。since 归一为 UTC 再字符串比较, // 避免本地时区("+08:00")与 UTC("Z") 跨时区错位(与 Rust 侧 count_hit_events 一致)。 rows, err := sc.query("SELECT COUNT(*) AS n FROM hit_events WHERE memory_id='" + sanitizeIdent(memoryID) + "' AND outcome='" + sanitizeIdent(outcome) + "' AND created_at >= '" + since.UTC().Format(time.RFC3339) + "'") if err != nil { return 0, err } if len(rows) == 0 { return 0, nil } n, _ := rows[0]["n"].(int64) return int(n), nil } // GetHitEvents 读回某 memory 的事件明细(read-back 取证,非只看函数返回)。 func (sc *SQLiteClient) GetHitEvents(memoryID string, limit int) ([]models.HitEvent, error) { sc.mu.RLock() defer sc.mu.RUnlock() if limit <= 0 { limit = 100 } rows, err := sc.query("SELECT id, memory_id, outcome, reason, source, created_at FROM hit_events WHERE memory_id='" + sanitizeIdent(memoryID) + "' ORDER BY created_at DESC LIMIT " + fmt.Sprintf("%d", limit)) if err != nil { return nil, err } events := make([]models.HitEvent, 0, len(rows)) for _, r := range rows { ev := models.HitEvent{ MemoryID: r["memory_id"].(string), Outcome: r["outcome"].(string), Reason: r["reason"].(string), Source: r["source"].(string), } if id, ok := r["id"].(int64); ok { ev.ID = id } if ts, ok := r["created_at"].(string); ok { if t, err := time.Parse(time.RFC3339, ts); err == nil { ev.CreatedAt = t } } events = append(events, ev) } return events, nil } func (sc *SQLiteClient) UpdateMemoryContent(id, newContent, source string) error { sc.mu.Lock() defer sc.mu.Unlock() now := time.Now().Format(time.RFC3339) // 记录版本历史 rows, _ := sc.query("SELECT version FROM memories WHERE id='" + sanitizeIdent(id) + "'") version := int64(1) if len(rows) > 0 { if v, ok := rows[0]["version"].(int64); ok { version = v + 1 } } sc.execWithArgs( "INSERT INTO version_history(memory_id,version,content,source,reason,timestamp) VALUES(?,?,?,?,?,?)", id, version, newContent, source, "corrected", now, ) return sc.execWithArgs( "UPDATE memories SET content=?, source=?, version=?, updated_at=? WHERE id=?", newContent, source, version, now, id, ) } func (sc *SQLiteClient) Update(table, id string, fields map[string]any) error { sc.mu.Lock() defer sc.mu.Unlock() if table != "memories" { return nil } now := time.Now().Format(time.RFC3339) // GA-P0-2 (t_c6d41ac6):recall_count 冻结,不再增长。召回命中改走 recall_seen_count; // 正反馈(IncrementUseful)走 recall_verified_count。 if _, ok := fields["recall_seen_count"]; ok { return sc.execWithArgs( "UPDATE memories SET recall_seen_count=recall_seen_count+1, updated_at=? WHERE id=?", now, id, ) } if _, ok := fields["recall_verified_count"]; ok { return sc.execWithArgs( "UPDATE memories SET recall_verified_count=recall_verified_count+1, updated_at=? WHERE id=?", now, id, ) } if _, ok := fields["recall_count"]; ok { return sc.execWithArgs( "UPDATE memories SET recall_count=recall_count+1, updated_at=? WHERE id=?", now, id, ) } if _, ok := fields["useful_count"]; ok { return sc.execWithArgs( "UPDATE memories SET useful_count=useful_count+1, updated_at=? WHERE id=?", now, id, ) } // generic update for k, v := range fields { if err := sc.execWithArgs( "UPDATE memories SET "+sanitizeIdent(k)+"=?, updated_at=? WHERE id=?", v, now, id, ); err != nil { return err } } return nil } // PurgeInvalid 清理 id 为空的垃圾行(P1-1 2026-10-08,SQLite 兜底实现)。 // 软删(is_deleted=1 + updated_at=now)而非硬删,语义与 Rust LanceDB 一致。 // execWithArgs 只返回 error,受影响行数用前后 COUNT 差值近似(空 id 行必然 is_deleted=0 才被清, // 且这些行不参与任何读取路径,直接用 UPDATE 前的空 id 存活计数作为「受影响行数」)。 func (sc *SQLiteClient) PurgeInvalid() (int64, error) { sc.mu.Lock() defer sc.mu.Unlock() rows, err := sc.query("SELECT COUNT(*) as cnt FROM memories WHERE is_deleted=0 AND (id='' OR trim(id)='')") if err != nil { return 0, err } before := int64(0) if len(rows) > 0 { before, _ = rows[0]["cnt"].(int64) } if before == 0 { return 0, nil } now := time.Now().Format(time.RFC3339) // GA-P0-3 (t_f785d7f2):清理 id 为空垃圾行 = 保留策略清理 ⇒ delete_reason=retention。 if err := sc.execWithArgs( "UPDATE memories SET is_deleted=1, delete_reason=?, updated_at=? WHERE id='' OR trim(id)=''", DeleteReasonRetention, now, ); err != nil { return 0, err } return before, nil } // ─── helpers ────────────────────────────────────────── func strVal(row sqliteRow, key string) string { if v, ok := row[key]; ok { if s, ok := v.(string); ok { return s } } return "" } func (sc *SQLiteClient) rowsToMemories(rows []sqliteRow) []models.MemoryRecord { results := make([]models.MemoryRecord, 0, len(rows)) for _, row := range rows { createdAt, _ := time.Parse(time.RFC3339, strVal(row, "created_at")) results = append(results, models.MemoryRecord{ ID: strVal(row, "id"), Content: strVal(row, "content"), Category: strVal(row, "category"), Namespace: strVal(row, "namespace"), CreatedAt: createdAt, }) } return results } func itoa(n int) string { if n <= 0 { return "10" } return fmt.Sprintf("%d", n) } func sanitizeIdent(s string) string { // 简单防注入:仅允许字母、数字、下划线 for _, c := range s { if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '-') { return "'invalid'" } } return s }