feat(space): 共享工作区增量3b —— KB 知识库按 Space 共享(存储 re-key)

把 3a 的 Space 作用域推到 KB 层：KB/Doc/DocLink owner→space_id，作用域键
owner/name→space_id/name，同空间成员共享知识库(检索/入库/文库/双链/图谱)。

后端:
- store: KB/Doc/DocLink 加 space_id，唯一索引 (owner,*)→(space_id,*)，owner 降级创建人；
  查询全改 space 作用域；SaveDoc/ListVault/GetDocByID/DeleteDocByID/ReplaceDocLinks/
  ResolveInboundLinks/ListLinks 改 space；tenantIDForSpace 补异步入库租户
- MigrateKBSpaces 启动迁移(space_id 回填 + 唯一索引换新，同 Agent 顺序坑规避)
- scopedKB owner/name→space_id/name；IngestJob 契约加 SpaceID；enqueueIngest/runIngest
  穿 space；MinIO 对象键改 space/kb/doc(避免跨空间同名撞键，老键不透明不迁)
- KB 写路由(create/ingest/ingest_file/note/delete)挂 RequireSpaceRole(member)：viewer 只读
- 存储层重灌迁移端点 POST /admin/migrate-kb-storage(异步)：为存量文档入队新 space
  作用域的重灌作业(复用 JetStream 入库 worker 池)，先删旧键；避免同步重嵌撑爆 HTTP 超时

桌面端:
- KbView 收 spaceId(变则重拉库)+spaceReadOnly(viewer 禁建库/入库/文件/笔记)；VaultPanel 同

验证(gateway+mcp-go+Milvus/Neo4j/embedding 全栈):
- PG 迁移: 20/21 KB + 50/54 doc 回填 space_id(4 未迁=pre-多租户 owner='wt' 空租户遗留，
  正确跳过)，唯一索引 idx_kb_sn/idx_doc_skn 换新、旧索引删除
- KB 共享: member 见共享库 / viewer 建库·入库 403 / 切回个人空间隔离(看不到)
- 全向量链路: RagA 入库(真 dashscope embedding)→ RagB(空间member)检索命中 RagA 内容
- 存储重灌: 端点异步入队 49 作业(worker 池背压处理)，重灌后老文档在新 space 键可检索

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

sundynix-gateway/internal/store/model.go

@@ -11,32 +11,34 @@ import (
 	"github.com/sundynix/sundynix-shared/contract"
 )
 
-// KB 是一个知识库（按 owner 隔离 + 按 kind 组织：文件夹/项目/案件/通用）。
-// 表名 sundynix_kb。(owner,name) 唯一 —— 同一用户下知识库名不重复。
-// 向量/全文/图谱实际以 "owner/name" 作分区键，保证只有 owner 能查到自己的库。
+// KB 是一个知识库（增量3：按 space 共享 + 按 kind 组织：文件夹/项目/案件/通用）。
+// 表名 sundynix_kb。作用域从 owner 改为 space_id——(space_id,name) 唯一，同一工作区内库名不重复；
+// owner 降级为创建人。向量/全文/图谱以 "space_id/name" 作分区键（见 handler.scopedKB）。
+// 唯一索引不在结构体标记里建（AutoMigrate 早于回填会撞车），由 MigrateKBSpaces 回填后显式建。
 type KB struct {
 	BaseModel
 	TenantID string `gorm:"size:64;index"` // 多租户作用域（gorm tenant 插件按上下文自动填/过滤）
-	Owner    string `gorm:"size:64;uniqueIndex:idx_kb_owner_name"`
-	Name     string `gorm:"size:64;uniqueIndex:idx_kb_owner_name"`
+	SpaceID  string `gorm:"size:64;index"` // 所属工作区（共享单位；唯一约束见 MigrateKBSpaces）
+	Owner    string `gorm:"size:64;index"` // 创建人 user.id（归属，非隔离键）
+	Name     string `gorm:"size:64"`
 	Kind     string `gorm:"size:16"` // folder / project / case / general
 }
 
 func (KB) TableName() string  { return "sundynix_kb" }
 func (KB) isTenantScoped()     {}
 
-// ListKB 列出某 owner 的全部知识库（按创建时间）。
-func (p *Postgres) ListKB(ctx context.Context, owner string) ([]KB, error) {
+// ListKB 列出某工作区的全部知识库（按创建时间；tenant 插件仍按 ctx 租户过滤）。
+func (p *Postgres) ListKB(ctx context.Context, spaceID string) ([]KB, error) {
 	if p.db == nil {
 		return nil, nil
 	}
 	var rows []KB
-	err := p.db.WithContext(ctx).Where("owner = ?", owner).Order("id").Find(&rows).Error
+	err := p.db.WithContext(ctx).Where("space_id = ?", spaceID).Order("id").Find(&rows).Error
 	return rows, err
 }
 
-// EnsureKB 幂等登记一个知识库（已存在则保持，不覆盖 kind）。
-func (p *Postgres) EnsureKB(ctx context.Context, owner, name, kind string) error {
+// EnsureKB 幂等登记一个知识库到某工作区（已存在则保持，不覆盖 kind；owner 记创建人）。
+func (p *Postgres) EnsureKB(ctx context.Context, spaceID, owner, name, kind string) error {
 	if p.db == nil {
 		return nil // 降级模式：不持久化注册表，不阻断入库
 	}
@@ -44,9 +46,9 @@ func (p *Postgres) EnsureKB(ctx context.Context, owner, name, kind string) error
 		kind = "general"
 	}
 	return p.db.WithContext(ctx).Clauses(clause.OnConflict{
-		Columns:   []clause.Column{{Name: "owner"}, {Name: "name"}},
+		Columns:   []clause.Column{{Name: "space_id"}, {Name: "name"}},
 		DoNothing: true,
-	}).Create(&KB{Owner: owner, Name: name, Kind: kind}).Error
+	}).Create(&KB{SpaceID: spaceID, Owner: owner, Name: name, Kind: kind}).Error
 }
 
 // Agent 是一份保存的 Agent 编排（React Flow 图 JSON）。
@@ -126,14 +128,16 @@ func (p *Postgres) DeleteAgent(ctx context.Context, spaceID, name string) error
 }
 
 // Doc 是入库的一份文件/笔记 —— 文件主表（供 Obsidian 式"文库"浏览：列表 + Markdown 阅读 + 双链）。
-// 表名 sundynix_doc。(owner,kb,name) 唯一；按 owner 隔离。文档间关联一律用本表的雪花 ID 关联。
+// 表名 sundynix_doc。增量3：作用域 owner→space_id，(space_id,kb,name) 唯一；owner 降级为创建人（上传者）。
+// 唯一索引由 MigrateKBSpaces 回填后显式建（AutoMigrate 早于回填会撞车）。
 type Doc struct {
 	BaseModel
 	TenantID  string `gorm:"size:64;index"` // 多租户作用域（入库异步无请求 ctx，SaveDoc 按 owner 补）
-	Owner     string `gorm:"size:64;uniqueIndex:idx_doc_okn"`
-	KB        string `gorm:"size:64;uniqueIndex:idx_doc_okn"`
-	Name      string `gorm:"size:160;uniqueIndex:idx_doc_okn"` // 文件名称（不含扩展名 / 笔记名）
-	Ext       string `gorm:"size:16"`                          // 文件后缀（.md/.pdf/.docx…；笔记/文本为空）
+	SpaceID   string `gorm:"size:64;index"` // 所属工作区（共享单位；唯一约束见 MigrateKBSpaces）
+	Owner     string `gorm:"size:64;index"` // 创建人/上传者 user.id（归属，非隔离键）
+	KB        string `gorm:"size:64;index"`
+	Name      string `gorm:"size:160"` // 文件名称（不含扩展名 / 笔记名）
+	Ext       string `gorm:"size:16"`  // 文件后缀（.md/.pdf/.docx…；笔记/文本为空）
 	Size      int    // 原文字数（rune）
 	Preview   string `gorm:"size:600"`  // 前若干字预览（列表/反链用，不拉全文）
 	Content   string `gorm:"type:text"` // 正文一律落 MinIO 后置空；仅 MinIO 不可用时回退内联存这里
@@ -143,14 +147,15 @@ type Doc struct {
 func (Doc) TableName() string { return "sundynix_doc" }
 func (Doc) isTenantScoped()   {}
 
-// DocLink 是文档间 [[双链]] 的索引（owner+kb 内 from→to），以 Doc.ID 关联，供反链/笔记关系图按 SQL 查询，
-// 避免在前端扫全部正文。入库/编辑时按 from 文档重建其出链；目标尚未入库时 ToID 为空（悬空，记 ToName 待回填）。
+// DocLink 是文档间 [[双链]] 的索引（space+kb 内 from→to），以 Doc.ID 关联，供反链/笔记关系图按 SQL 查询。
+// 增量3：作用域 owner→space_id。入库/编辑时按 from 文档重建其出链；目标尚未入库时 ToID 为空（悬空）。
 type DocLink struct {
 	BaseModel
-	TenantID string `gorm:"size:64;index"` // 多租户作用域（ReplaceDocLinks 按 owner 补）
-	Owner    string `gorm:"size:64;index:idx_link_of"`
-	KB     string `gorm:"size:64;index:idx_link_of"`
-	FromID string `gorm:"size:24;index:idx_link_of"` // 源文档 Doc.ID
+	TenantID string `gorm:"size:64;index"` // 多租户作用域（ReplaceDocLinks 按 space 的租户补）
+	SpaceID  string `gorm:"size:64;index:idx_link_sf"`
+	Owner    string `gorm:"size:64;index"`             // 创建人（归属）
+	KB     string `gorm:"size:64;index:idx_link_sf"`
+	FromID string `gorm:"size:24;index:idx_link_sf"` // 源文档 Doc.ID
 	ToID   string `gorm:"size:24;index"`             // 目标文档 Doc.ID（空=悬空：目标尚未入库）
 	ToName string `gorm:"size:160"`                  // [[原始名]]，供悬空链接展示 / 目标入库后回填 ToID
 }
@@ -158,19 +163,17 @@ type DocLink struct {
 func (DocLink) TableName() string { return "sundynix_doc_link" }
 func (DocLink) isTenantScoped()   {}
 
-// SaveDoc 写入/更新一份文件（owner+kb+name 唯一，重名覆盖），返回 (文件雪花 ID, 被覆盖的旧对象键)。
-// oldObjectKey 是重名覆盖前该文档的 ObjectKey（新建则为空）—— 供调用方清理 MinIO 孤儿对象。
-// content 为内联正文（大文档转 MinIO 时传空 + objectKey）；ext/md5/preview/size 由调用方按全文给出。
-func (p *Postgres) SaveDoc(ctx context.Context, owner, kb, name, ext, content, objectKey string, size int, preview string) (id, oldObjectKey string, err error) {
+// SaveDoc 写入/更新一份文件（space_id+kb+name 唯一，重名覆盖），返回 (文件雪花 ID, 被覆盖的旧对象键)。
+// space_id 是作用域，owner 记创建人（上传者）。tenant_id 从 space 的租户补（异步入库无请求 ctx 租户）。
+func (p *Postgres) SaveDoc(ctx context.Context, spaceID, owner, kb, name, ext, content, objectKey string, size int, preview string) (id, oldObjectKey string, err error) {
 	if p.db == nil {
 		return "", "", nil
 	}
-	// 入库为异步 worker（无请求 ctx 租户）→ 显式按 owner 补 tenant_id（插件在此不会自动填）。
-	tenantID := p.tenantIDForOwner(ctx, owner)
+	tenantID := p.tenantIDForSpace(ctx, spaceID)
 	var d Doc
-	qerr := p.db.WithContext(ctx).Where("owner = ? AND kb = ? AND name = ?", owner, kb, name).First(&d).Error
+	qerr := p.db.WithContext(ctx).Where("space_id = ? AND kb = ? AND name = ?", spaceID, kb, name).First(&d).Error
 	if errors.Is(qerr, gorm.ErrRecordNotFound) {
-		d = Doc{TenantID: tenantID, Owner: owner, KB: kb, Name: name, Ext: ext, Content: content, ObjectKey: objectKey, Size: size, Preview: preview}
+		d = Doc{TenantID: tenantID, SpaceID: spaceID, Owner: owner, KB: kb, Name: name, Ext: ext, Content: content, ObjectKey: objectKey, Size: size, Preview: preview}
 		if err := p.db.WithContext(ctx).Create(&d).Error; err != nil {
 			return "", "", err
 		}
@@ -181,7 +184,7 @@ func (p *Postgres) SaveDoc(ctx context.Context, owner, kb, name, ext, content, o
 	}
 	oldObjectKey = d.ObjectKey // 覆盖前的旧对象键
 	if tenantID != "" {
-		d.TenantID = tenantID // 覆盖路径也补齐（老行可能为空）；查不到租户则不动，别把已有值抹空
+		d.TenantID = tenantID // 覆盖路径也补齐（老行可能为空）；查不到则不动，别把已有值抹空
 	}
 	d.Ext, d.Content, d.ObjectKey, d.Size, d.Preview = ext, content, objectKey, size, preview
 	if err := p.db.WithContext(ctx).Save(&d).Error; err != nil {
@@ -191,52 +194,50 @@ func (p *Postgres) SaveDoc(ctx context.Context, owner, kb, name, ext, content, o
 }
 
 // ListVault 返回文库列表（仅元数据 + 预览，不含全文），避免一次拉回整库正文。
-func (p *Postgres) ListVault(ctx context.Context, owner, kb string) ([]Doc, error) {
+func (p *Postgres) ListVault(ctx context.Context, spaceID, kb string) ([]Doc, error) {
 	if p.db == nil {
 		return nil, nil
 	}
 	var rows []Doc
 	err := p.db.WithContext(ctx).
-		Select("id", "name", "ext", "size", "preview", "object_key", "updated_at").
-		Where("owner = ? AND kb = ?", owner, kb).Order("updated_at desc").Find(&rows).Error
+		Select("id", "name", "ext", "size", "preview", "object_key", "owner", "updated_at").
+		Where("space_id = ? AND kb = ?", spaceID, kb).Order("updated_at desc").Find(&rows).Error
 	return rows, err
 }
 
-// GetDocByID 按文件 ID 取单篇文档（含全文 Content 与 ObjectKey），owner 作用域防越权。
-func (p *Postgres) GetDocByID(ctx context.Context, owner, id string) (*Doc, error) {
+// GetDocByID 按文件 ID 取单篇文档（含全文 Content 与 ObjectKey），space 作用域防越权。
+func (p *Postgres) GetDocByID(ctx context.Context, spaceID, id string) (*Doc, error) {
 	if p.db == nil {
 		return nil, nil
 	}
 	var d Doc
-	if err := p.db.WithContext(ctx).Where("owner = ? AND id = ?", owner, id).First(&d).Error; err != nil {
+	if err := p.db.WithContext(ctx).Where("space_id = ? AND id = ?", spaceID, id).First(&d).Error; err != nil {
 		return nil, err
 	}
 	return &d, nil
 }
 
-// DeleteDocByID 删除一份文件的 PG 痕迹（owner 作用域防越权）：doc 行 + 其出链/入链。
-// 入链（别处指向本文件）一并删，避免悬空脏链。文档不存在视作已删（返回 nil）。
-func (p *Postgres) DeleteDocByID(ctx context.Context, owner, kb, id string) error {
+// DeleteDocByID 删除一份文件的 PG 痕迹（space 作用域防越权）：doc 行 + 其出链/入链。
+func (p *Postgres) DeleteDocByID(ctx context.Context, spaceID, kb, id string) error {
 	if p.db == nil {
 		return nil
 	}
 	return p.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		if err := tx.Where("owner = ? AND kb = ? AND (from_id = ? OR to_id = ?)", owner, kb, id, id).Delete(&DocLink{}).Error; err != nil {
+		if err := tx.Where("space_id = ? AND kb = ? AND (from_id = ? OR to_id = ?)", spaceID, kb, id, id).Delete(&DocLink{}).Error; err != nil {
 			return err
 		}
-		return tx.Where("owner = ? AND id = ?", owner, id).Delete(&Doc{}).Error
+		return tx.Where("space_id = ? AND id = ?", spaceID, id).Delete(&Doc{}).Error
 	})
 }
 
 // ReplaceDocLinks 以源文件 ID 重建其出链（先删旧，再按 [[名称]] 解析目标 ID 后插新）—— 入库/编辑时调用。
-// 目标文档尚未入库时 ToID 留空（悬空），待其入库时由 ResolveInboundLinks 回填。
-func (p *Postgres) ReplaceDocLinks(ctx context.Context, owner, kb, fromID string, toNames []string) error {
+func (p *Postgres) ReplaceDocLinks(ctx context.Context, spaceID, owner, kb, fromID string, toNames []string) error {
 	if p.db == nil {
 		return nil
 	}
-	tenantID := p.tenantIDForOwner(ctx, owner) // 异步入库路径无请求 ctx 租户，按 owner 补
+	tenantID := p.tenantIDForSpace(ctx, spaceID)
 	return p.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		if err := tx.Where("owner = ? AND kb = ? AND from_id = ?", owner, kb, fromID).Delete(&DocLink{}).Error; err != nil {
+		if err := tx.Where("space_id = ? AND kb = ? AND from_id = ?", spaceID, kb, fromID).Delete(&DocLink{}).Error; err != nil {
 			return err
 		}
 		for _, name := range toNames {
@@ -245,13 +246,13 @@ func (p *Postgres) ReplaceDocLinks(ctx context.Context, owner, kb, fromID string
 			}
 			var t Doc
 			toID := ""
-			if e := tx.Select("id").Where("owner = ? AND kb = ? AND name = ?", owner, kb, name).First(&t).Error; e == nil {
+			if e := tx.Select("id").Where("space_id = ? AND kb = ? AND name = ?", spaceID, kb, name).First(&t).Error; e == nil {
 				toID = t.ID
 			}
 			if toID == fromID { // 自链跳过
 				continue
 			}
-			if err := tx.Create(&DocLink{TenantID: tenantID, Owner: owner, KB: kb, FromID: fromID, ToID: toID, ToName: name}).Error; err != nil {
+			if err := tx.Create(&DocLink{TenantID: tenantID, SpaceID: spaceID, Owner: owner, KB: kb, FromID: fromID, ToID: toID, ToName: name}).Error; err != nil {
 				return err
 			}
 		}
@@ -259,23 +260,23 @@ func (p *Postgres) ReplaceDocLinks(ctx context.Context, owner, kb, fromID string
 	})
 }
 
-// ResolveInboundLinks 把指向 name 的悬空链接（ToID 空）回填为 id —— 目标文档入库后调用，使反链/关系图即时成形。
-func (p *Postgres) ResolveInboundLinks(ctx context.Context, owner, kb, name, id string) error {
+// ResolveInboundLinks 把指向 name 的悬空链接（ToID 空）回填为 id —— 目标文档入库后调用。
+func (p *Postgres) ResolveInboundLinks(ctx context.Context, spaceID, kb, name, id string) error {
 	if p.db == nil {
 		return nil
 	}
 	return p.db.WithContext(ctx).Model(&DocLink{}).
-		Where("owner = ? AND kb = ? AND to_name = ? AND (to_id = '' OR to_id IS NULL)", owner, kb, name).
+		Where("space_id = ? AND kb = ? AND to_name = ? AND (to_id = '' OR to_id IS NULL)", spaceID, kb, name).
 		Update("to_id", id).Error
 }
 
 // ListLinks 返回某 kb 已解析（两端均为本库文件）的 [[双链]]（FromID→ToID），供反链/笔记关系图按 ID 渲染。
-func (p *Postgres) ListLinks(ctx context.Context, owner, kb string) ([]DocLink, error) {
+func (p *Postgres) ListLinks(ctx context.Context, spaceID, kb string) ([]DocLink, error) {
 	if p.db == nil {
 		return nil, nil
 	}
 	var rows []DocLink
-	err := p.db.WithContext(ctx).Where("owner = ? AND kb = ? AND to_id <> ''", owner, kb).Find(&rows).Error
+	err := p.db.WithContext(ctx).Where("space_id = ? AND kb = ? AND to_id <> ''", spaceID, kb).Find(&rows).Error
 	return rows, err
 }