refactor(memory): 拆除描述式媒体索引，媒体成为一等块并按原生向量融合

背景：此前媒体是靠「生成的描述文本」将就进记忆的——写 marker 进正文、再由正则反解成 media_refs 与图库里的 type=Media 实体。这条链路有三个致命缺陷：描述由异步模型生成（未生成前媒体等于不存在）、语义检索实质上只搜描述文字、图库里的「媒体节点」是描述文本的投影而不是媒体本身。本提交把这条链路整体拆除，媒体改为按自己的原生向量参与记忆：一、描述链彻底删除（无残留、无兼容分支） - media.Item 去掉 Description/DescribedBy 与对应列； - 删除 Store.Describe / Store.Search / Store.Pending； - 删除 Agent.mediaDescribeLoop / describePendingMedia 与配置项 core.memory.media.describe_on_ingest； - SDK 侧 MediaAttachment 去掉 Description（见 SDK 仓独立提交）。二、marker 机制删除，媒体归属改为结构化块边 - 删除 mediaMarkerLine/parseMediaMarkers/mediaEntityName/mediaTriplesFromText/ extractMediaDigests/sentenceWithMediaMarkers/docMediaContext； - memory.Triple 新增 MediaDigests 结构化字段；句子文本保持原样，不再被 marker 污染； - 块以 sentence --contains--> block / document --contains--> block 结构边挂到承载节点（新增 documents 表与 document 节点种类）； - 模型未给原句时用「主谓宾。」拼一句自然语言作落点，不造 marker 文本。三、旧数据迁移（幂等） - 新增 GraphDB.MigrateLegacyMediaEntities：把 type=Media 的旧实体按短 digest 还原成原生块、挂回原句子、删除旧实体与描述关系；Agent 启动时执行； - CleanupOrphanedSentences 同时看关系引用与块边，避免把只靠块存活的句子连同块边一起删掉。四、向量融合：媒体按图本身被召回 - 新增 vector.FuseVectors（逐维求和 + L2 归一化）； - Doc.DenseVec = 文本向量 ⊕ 文档块的媒体向量（同 fingerprint 才融合），新增 Doc.DenseFP，指纹变化触发重算； - ContextEvent.DenseVec 同理融合事件块；事件新增 DenseFP，Prune 只在同一统一空间内比稠密余弦； - 跨模态视觉路只召回「仍被某层记忆块持有」的媒体，CAS 全库字节不再直接充当记忆检索结果。五、同时纳入本分支既有的嵌入基础改造（此前工作区未提交，缺它 HEAD 不可构建） - internal/tfidf 懒回退包、千问三段式多模态 ONNX 空间的 Go 侧（qwen/embedder.go、image.go、model_input.go）、CLIP 移除、 sdk.NewStore 分词器签名与调用点、embed 侧车 systemd 单元。验证：go build ./... 、go vet ./...（含 -tags medialive）均通过；在 HEAD 的独立 worktree 上重放本次暂存集后 go test -short ./internal/... 全部通过（端口冲突类用例在隔离环境中亦通过）。未提交工作区中与本改造无关的改动（HarmonyOS、waiter、devicebridge、plan.md 等）。
2026-10-04 00:03:59 +00:00 · 2026-09-11 11:45:24 +08:00
parent dae01f9c06
commit 5836c2ce5c
56 changed files with 2686 additions and 2834 deletions
--- a/internal/plugins/remotedevice/registry.go
+++ b/internal/plugins/remotedevice/registry.go
@ -104,8 +104,7 @@ var capabilityTools = map[string][]string{

 // compatFullCaps 视为「全能力」的历史 caps 值：声明了这些的设备不参与能力裁剪。
 var compatFullCaps = map[string]bool{
-	"cmd": true, "cmdrun": true, "deviceinfo": true,
-	"status": true, "cmdresult": true,
+	"cmd": true, "cmdrun": true, "cmdresult": true,
 }

 // SupportsTool 判断设备是否支持某 agent 工具（基于其声明的 caps）。
@ -400,10 +399,15 @@ func (r *Registry) PushData(deviceID, reqID, kind, mime string, data []byte) err
 	return nil
 }

-// AwaitResult 等待某请求的结果（带超时）。
+// AwaitResult 等待某请求的结果（带超时）。快速回执会先留在 results，
+// 因而 PushCmd 后才开始等待也不会丢失。
 func (r *Registry) AwaitResult(reqID string, timeout time.Duration) (map[string]interface{}, error) {
 	ch := make(chan map[string]interface{}, 1)
 	r.mu.Lock()
+	if e, ok := r.results[reqID]; ok {
+		r.mu.Unlock()
+		return e.Result, nil
+	}
 	r.cmdPending[reqID] = ch
 	r.mu.Unlock()
 	defer func() {
@ -419,11 +423,15 @@ func (r *Registry) AwaitResult(reqID string, timeout time.Duration) (map[string]
 	}
 }

-// deliverResult 设备回执结果时由 handleWS 调用。
+// deliverResult 先留档再通知等待者，消除设备极速回执早于 AwaitResult 的竞态。
 func (r *Registry) deliverResult(reqID string, res map[string]interface{}) {
-	r.mu.RLock()
+	r.mu.Lock()
+	if r.results == nil {
+		r.results = make(map[string]resultEntry)
+	}
+	r.results[reqID] = resultEntry{Result: res, Time: time.Now()}
 	ch, ok := r.cmdPending[reqID]
-	r.mu.RUnlock()
+	r.mu.Unlock()
 	if ok {
 		select {
 		case ch <- res:
@ -621,6 +629,9 @@ func (r *Registry) ServeWS(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 	token := req.URL.Query().Get("token")
+	if token == "" {
+		token = strings.TrimSpace(req.Header.Get("X-API-Key"))
+	}
 	if token == "" {
 		for _, p := range req.Header.Values("Sec-WebSocket-Protocol") {
 			if strings.HasPrefix(p, "homeagent.") {
@ -629,7 +640,8 @@ func (r *Registry) ServeWS(w http.ResponseWriter, req *http.Request) {
 			}
 		}
 	}
-	if token != "" && !r.acceptBind(token) {
+	handshakeAuthorized := token != "" && r.acceptBind(token)
+	if token != "" && !handshakeAuthorized {
 		http.Error(w, "unauthorized", http.StatusUnauthorized)
 		return
 	}
@ -639,7 +651,7 @@ func (r *Registry) ServeWS(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 	log.Printf("[remotedevice] ws connected from %s", conn.RemoteAddr())
-	go r.handleWS(conn, rw)
+	go r.handleWS(conn, rw, handshakeAuthorized)
 }

 // wsWriteLocked 在指定设备连接的写锁保护下执行写回调。
@ -662,12 +674,20 @@ func (r *Registry) wsWriteLocked(deviceID string, fn func(w *bufio.Writer) error
 	return fn(w)
 }

-func (r *Registry) handleWS(conn net.Conn, rw *bufio.ReadWriter) {
+func (r *Registry) handleWS(conn net.Conn, rw *bufio.ReadWriter, handshakeAuthorized bool) {
 	defer conn.Close()
 	var curID string
+	var pendingMeta *DeviceMeta
+	var bound bool
 	defer func() {
 		if curID != "" {
-			r.markOffline(curID)
+			if bound {
+				r.markOffline(curID)
+			} else {
+				r.mu.Lock()
+				delete(r.conns, curID)
+				r.mu.Unlock()
+			}
 		}
 	}()

@ -697,9 +717,12 @@ func (r *Registry) handleWS(conn net.Conn, rw *bufio.ReadWriter) {
 				dataAccum.chunks = append(dataAccum.chunks, payload)
 				dataAccum.got += len(payload)
 				// 防滥用：超出声明 total 的 2 倍或硬上限 64MB 时放弃聚合
-				limit := int64(dataAccum.total)*2 + 1024
-				if limit < 64<<20 {
-					limit = 64 << 20
+				limit := int64(64 << 20)
+				if dataAccum.total > 0 {
+					declaredLimit := int64(dataAccum.total)*2 + 1024
+					if declaredLimit < limit {
+						limit = declaredLimit
+					}
 				}
 				if int64(dataAccum.got) > limit {
 					log.Printf("[remotedevice] data accumulation exceeded limit for req %s, dropped", dataAccum.reqID)
@ -713,6 +736,9 @@ func (r *Registry) handleWS(conn net.Conn, rw *bufio.ReadWriter) {
 			continue
 		}
 		op, _ := msg["op"].(string)
+		if !bound && op != "hello" && op != "bind" {
+			continue
+		}
 		switch op {
 		case "hello":
 			meta := metaFromMsg(msg)
@ -720,41 +746,35 @@ func (r *Registry) handleWS(conn net.Conn, rw *bufio.ReadWriter) {
 				continue
 			}
 			meta.RemoteAddr = conn.RemoteAddr().String()
+			pendingMeta = &meta
 			curID = meta.DeviceID
-			r.register(meta)
-			r.mu.Lock()
-			r.conns[meta.DeviceID] = &wconn{deviceID: meta.DeviceID, w: rw.Writer}
-			r.mu.Unlock()
-			if err := r.wsWriteLocked(meta.DeviceID, func(w *bufio.Writer) error {
-				return writeText(w, mustJSON(map[string]interface{}{
-					"op":     "hello_ack",
-					"device": meta.DeviceID,
-					"online": true,
-				}))
-			}); err != nil {
+			// Bind 前不把连接暴露给查询或命令下发路径；此时只有当前读循环会写。
+			if err := writeText(rw.Writer, mustJSON(map[string]interface{}{
+				"op":     "hello_ack",
+				"device": meta.DeviceID,
+				"online": false,
+			})); err != nil {
 				return
 			}
 		case "bind":
 			token, _ := msg["token"].(string)
-			if r.acceptBind(token) {
-				id, _ := msg["device_id"].(string)
-				if id != "" {
-					// 默认不授权：bind 仅验证 token + 登记设备；授权完全由用户手动
-					// （GUI 设备页 / REST /api/v1/device/auth）控制，绝不自动授权。
-				}
-				err := r.wsWriteLocked(curID, func(w *bufio.Writer) error {
-					return writeText(w, mustJSON(map[string]interface{}{"op": "bind_ack", "ok": true}))
-				})
-				if err != nil {
-					return
-				}
-			} else {
-				err := r.wsWriteLocked(curID, func(w *bufio.Writer) error {
-					return writeText(w, mustJSON(map[string]interface{}{"op": "bind_ack", "ok": false, "error": "bad token"}))
-				})
-				if err != nil {
-					return
-				}
+			id, _ := msg["device_id"].(string)
+			bindAuthorized := handshakeAuthorized || r.acceptBind(token)
+			if pendingMeta == nil || id == "" || id != pendingMeta.DeviceID || !bindAuthorized {
+				_ = writeText(rw.Writer, mustJSON(map[string]interface{}{
+					"op": "bind_ack", "ok": false, "error": "bind rejected",
+				}))
+				return
+			}
+			r.mu.Lock()
+			r.conns[id] = &wconn{deviceID: id, w: rw.Writer}
+			r.mu.Unlock()
+			bound = true
+			r.register(*pendingMeta)
+			if err := r.wsWriteLocked(curID, func(w *bufio.Writer) error {
+				return writeText(w, mustJSON(map[string]interface{}{"op": "bind_ack", "ok": true}))
+			}); err != nil {
+				return
 			}
 		case "status":
 			id, _ := msg["device_id"].(string)