feat(knowledge): 目录批量导入 + 派生数据批量收口

## 能力缺口

导入只能一条条 Add（knowledge_create）。agent 拿到一份 200 页的
文档目录要调 200 次工具，且每次都得自己决定分类与名字。

新增工具 `knowledge_import_dir(dir, category?, include_media?, dry_run?, max_items?)`。
语义是**复制**不是引用：源文件删改不影响已导入的副本。
- 文本经 Write 整份写入 <知识根>/<分类>/<名>/content.md
- 媒体按 sha256 进媒体库（内容寻址天然去重），条目只存 digest 引用

## 目录约定（自动适配，不要求改造资料）

1. 含 content.md 的目录 ⇒ 整体作为一个条目（与 scanDir 既有语义一致，
   所以知识库自身目录能被原样再导入而不会被拆散）
2. 否则 .md/.txt 等文件各成一条，**目录路径即分类**

## 三个语义决策

- category 是**前缀叠加**（tech + 源结构），不替换：替换会丢掉源目录
  自身最有价值的层级信息
- 同名冲突**跳过并计数**，绝不覆盖：Write 对同名本就是覆盖语义
  （knowledge_create 靠它做更新），若直接调它，一次重导就会把手工
  补充的内容悄悄抹掉，而日志只写"导入完成"
- dry_run **默认 true**：批量写，agent 第一次试某目录应先看清会写什么

## 安全边界（批量操作，缺一道就可能读到不该读的）

- 必须绝对路径：agent 的 cwd 不受控，相对路径会静默导到别处
- 符号链接不跟随：否则一个软链就把知识根之外的文件导进来
- 拒绝把知识库自身当源（自导会无限自我复制）
- category 复用 normalizeName（与 Write 同一道闸，两处分叉就成了绕过）
- MaxItems 默认 500：防 agent 误传 "/" 把盘灌满

## ★ 批量导入暴露的既有 O(N²)

Write 每条末尾都调 flushDenseLocked，而 saveDenseCacheLocked 是
**全量序列化整个 items map 再重写整个文件**。按 512 维 float64 估，
单条约 10KB，导入 500 条累计要写约 1.4GB。

仓库里索引侧早已有 indexDirty 的「标脏+延迟收口」（实测 writeIndexLocked
6.7ms/次、占单条 Add 绝大部分），**稠密缓存却还是逐条全量重写** ——
同一类开销只修了一半。

照 indexDirty 的模式补 batchDepth：批量期只标脏，endBatch 收口一次。
用 defer 保证提前 return 也会收口 —— 否则这批向量会留成"标脏未写"，
下次启动被当作缺失而全量重算。

## 判据：17 条 + 变异

安全边界做了 4 组变异验证（去符号链接拦截/去绝对路径要求/去自导检查/
content.md 目录不下钻）。

★ 判据第一版有两处自己骗自己，被变异抓出来：
1. 符号链接判据造的是**目录软链**，而 WalkDir 对目录软链本来就不下钻
   ⇒ 有无防护结果都一样，是假绿。改成**文件软链**后才真正判红。
2. 同名冲突判据里已有条目写成 "a/b"、源映射出的是 "b"（不同名），
   判据自己就错了 —— 修判据而不是改实现。

媒体路径用假 MediaPutter：验的是「调了 Put 且 digest 挂到条目上」，
媒体库自身的落盘去重是 media 包的判据，不该在这里重测。

全量 41 包绿。

internal/agent/core/agent.go

@@ -346,6 +346,10 @@ func New(cfg AgentConfig) *Agent {
 			// 若先重建后接线，首次启动算出的向量会被丢掉而不落盘。
 			cfg.Knowledge.SetDenseSpace(cfg.MultimodalSpace)
 			cfg.Knowledge.SetMediaGetter(cfg.MediaStore)
+			// 媒体**写入**器：ImportDir 复制图片/音视频时用。
+			// 不接的话 include_media=true 会静默失效（媒体全被跳过、
+			// 只在导入结果里留一行"媒体库不可用"），模型无从察觉。
+			cfg.Knowledge.SetMediaPutter(cfg.MediaStore)
 			built, skipped := cfg.Knowledge.ReindexDense()
 			if built > 0 || skipped > 0 {
 				log.Printf("[knowledge] 多模态稠密索引: 新建 %d 跳过 %d（其余命中缓存）", built, skipped)

internal/agent/core/toolcall.go

@@ -615,6 +615,66 @@ func (a *Agent) executeKnowledgeTool(tc agentAPI.ToolCall) string {
 		tree := a.knowledge.BuildTree()
 		return formatTree(tree, 0)
 
+	case "knowledge_import_dir":
+		dir, _ := tc.Arguments["dir"].(string)
+		category, _ := tc.Arguments["category"].(string)
+		// dry_run 默认 true：导入是批量写，agent 第一次试某个目录时
+		// 应该先看清会写什么。默认直接写等于让它盲写一批数据。
+		dryRun := true
+		if b, ok := getBool(tc.Arguments, "dry_run"); ok {
+			dryRun = b
+		}
+		includeMedia := false
+		if b, ok := getBool(tc.Arguments, "include_media"); ok {
+			includeMedia = b
+		}
+		st, err := a.knowledge.ImportDir(knowledge.ImportOptions{
+			Dir:          dir,
+			Category:     category,
+			DryRun:       dryRun,
+			IncludeMedia: includeMedia,
+			MaxItems:     int(getFloat(tc.Arguments, "max_items")),
+		})
+		if err != nil {
+			return fmt.Sprintf("知识导入失败: %v", err)
+		}
+		var b strings.Builder
+		verb := "已导入"
+		if dryRun {
+			verb = "将导入（dry_run，未实际写入）"
+		}
+		fmt.Fprintf(&b, "%s %d 条", verb, st.Imported)
+		if category != "" {
+			fmt.Fprintf(&b, "（分类前缀 %s）", category)
+		}
+		if st.Media > 0 {
+			fmt.Fprintf(&b, "，含 %d 个媒体", st.Media)
+		}
+		if st.Skipped > 0 {
+			fmt.Fprintf(&b, "；跳过 %d", st.Skipped)
+		}
+		if st.Failed > 0 {
+			fmt.Fprintf(&b, "；失败 %d", st.Failed)
+		}
+		if st.Truncated {
+			fmt.Fprintf(&b, "；★ 超出 max_items 被截断，未导完（可调大 max_items 或分批）")
+		}
+		if len(st.Names) > 0 {
+			show := st.Names
+			if len(show) > 10 {
+				show = show[:10]
+			}
+			fmt.Fprintf(&b, "。知识名：%s", strings.Join(show, "、"))
+			if len(st.Names) > 10 {
+				fmt.Fprintf(&b, " …共 %d 个", len(st.Names))
+			}
+		}
+		// 失败原因要报给 agent：否则它只知道"失败 37 条"却无从下手。
+		for _, e := range st.Errors {
+			fmt.Fprintf(&b, "\n- %s", e)
+		}
+		return b.String()
+
 	case "knowledge_delete":
 		name, _ := tc.Arguments["name"].(string)
 		if name == "" {

internal/agent/core/tooldefs.go

@@ -391,6 +391,25 @@ func (a *Agent) buildToolDefs() []interface{} {
 				"description": "可选：关联的媒体 digest（可传前缀）。媒体作为一等节点参与跨模态检索——知识能按图本身被搜到，而不依赖生成的描述文本",
 			},
 		}, "name", "content"))
+		tools = append(tools, toolDef("knowledge_import_dir",
+			"从目录批量导入知识（复制，不是引用）。递归扫描该目录，把文档复制进知识库并自动完成索引与向量化，之后即可被 knowledge_search 检索到。\n"+
+				"目录约定（自动适配，无需改造资料）：含 content.md 的目录整体作为一条知识；否则目录里的 .md/.txt 等文件各成一条，**目录路径即分类**。\n"+
+				"注意：dir 必须是绝对路径（你的工作目录不等于进程 cwd）；同名条目会跳过而不覆盖。",
+			map[string]interface{}{
+				"dir":      map[string]interface{}{"type": "string", "description": "源目录的绝对路径，如 /home/qq/notes。不接受相对路径"},
+				"category": map[string]interface{}{"type": "string", "description": "可选：分类前缀，叠加在源目录结构之上。导入 ~/docs/go/x.md 配 category=tech 得到 tech/go/x。留空则沿用源目录自身的层级"},
+				"include_media": map[string]interface{}{
+					"type":        "boolean",
+					"description": "可选：是否把目录里的图片/音视频也导入（复制进媒体库，使该知识能按图本身被搜到）。默认 false",
+					"default":     false,
+				},
+				"dry_run": map[string]interface{}{
+					"type":        "boolean",
+					"description": "可选：只报告将导入什么，不实际写入。试探性导入时建议先跑一次",
+					"default":     true,
+				},
+				"max_items": map[string]interface{}{"type": "integer", "description": "可选：本次最多导入多少条（默认 500，防误传大目录）"},
+			}, "dir"))
 		tools = append(tools, toolDef("knowledge_delete", "删除知识库中的指定知识条目。", map[string]interface{}{
 			"name": map[string]interface{}{"type": "string", "description": "要删除的知识名称"},
 		}, "name"))

internal/agent/core/utils.go

@@ -17,6 +17,33 @@ func getString(m map[string]interface{}, key string) string {
 	return ""
 }
 
+// getBool 从工具参数里取布尔值。
+//
+// 为何不直接 v.(bool)：LLM 的工具参数经 JSON 解码后可能是
+// bool、也可能是字符串（"true"）或数字（1）—— 实际调用里三种都出现过。
+// 只认 bool 会让模型明明传了 true 却走默认值（表现为「参数被无视」，
+// 排查时很难看出是解析问题）。
+func getBool(m map[string]interface{}, key string) (bool, bool) {
+	v, ok := m[key]
+	if !ok {
+		return false, false
+	}
+	switch b := v.(type) {
+	case bool:
+		return b, true
+	case string:
+		switch strings.ToLower(strings.TrimSpace(b)) {
+		case "1", "true", "yes", "on":
+			return true, true
+		case "0", "false", "no", "off":
+			return false, true
+		}
+	case float64:
+		return b != 0, true
+	}
+	return false, false
+}
+
 func getFloat(m map[string]interface{}, key string) float64 {
 	if v, ok := m[key]; ok {
 		switch n := v.(type) {