feat(gateway): 多租户增量2 —— gorm 租户插件按上下文自动隔离查询（SaaS P1）

统一强制、别靠人肉：受租户模型标记 isTenantScoped() 后，store/tenant_scope.go
的 gorm 回调按请求 ctx 自动给查询加 WHERE tenant_id、创建自动填 tenant_id。
- KB / Agent 加 TenantID 字段 + isTenantScoped() 标记
- middleware.TenantContext 把 tenant 注入 request context 供 store 插件读取
- ctx 无租户（系统/回填/未登录）不过滤，保留跨租户操作能力
- 启动 BackfillRowTenants 回填存量行 tenant_id=owner 默认租户（幂等）

live 验证：创建自动写 tenant_id ✓；同 owner 不同 tenant 的行被查询过滤 ✓。
Doc/DocLink（异步入库）、Task/Eval（无 owner）留待增量2b。

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

DEPTH_ROADMAP.md

@@ -164,7 +164,12 @@ RBAC 未做，暂以单管理员账号代理；概览口径必须是**系统级*
 > 2026-07-06 用户定方向：真·多租户商业化 + 桌面端仍主产品(非Web-first)。按 SAAS_DESIGN.md P1 分阶段。
 - [x] **增量1：租户身份地基**✅（693a8f0）—— Tenant/TenantMember 表 + 注册建默认租户 + 存量回填 +
   TenantContext 中间件注入 tenant_id + GET /tenants/current。live 验证。**未动查询隔离。**
-- [ ] 增量2：核心表加 tenant_id + 统一 gorm scope 强制隔离 + 存量行回填 + 重写查询（PG 先行）| L
+- [x] **增量2：查询隔离机制（gorm 租户插件）**✅ —— KB/Agent 加 tenant_id + `isTenantScoped()` 标记；
+  `store/tenant_scope.go` gorm 回调按请求 ctx **自动**给受租户表查询加 `WHERE tenant_id`、创建自动填
+  （统一强制、别靠人肉）；ctx 无租户(系统/回填)则不过滤；中间件把 tenant 注入 request ctx；启动回填存量行。
+  live 验证：创建自动写 tenant_id ✓；**同 owner 不同 tenant 的行被查询过滤掉** ✓（隔离机制生效）。
+  Doc/DocLink(异步入库)、Task/Eval(无 owner，待提交链改造) 下一增量铺开。
+- [ ] 增量2b：Doc/DocLink 走异步 JetStream 入库，tenant 需随 job payload 传播；Task/Eval 补 owner+tenant | M
 - [ ] Redis/MinIO/Milvus/Neo4j 的 tenant 前缀/namespace | M
 - [ ] 真正的 RBAC：User 加 role 字段 + 角色/权限表，`RequireAdmin`(middleware/auth.go:46) 从白名单升级为角色校验 | M
 - [ ] 用户管理接口：列举 / 禁用 / 改角色（现仅注册/登录/查我，handler/auth.go）| M

sundynix-gateway/cmd/server/main.go

@@ -45,12 +45,15 @@ func main() {
 
 	db := store.OpenPostgres(pgDSN) // MainDB: Users / Billing / DSL（连不上则降级）
 	defer db.Close()
-	// 多租户回填：给存量用户补建默认租户（幂等；每次启动跑一次）。
+	// 多租户回填：给存量用户补建默认租户 + 给受租户表存量行回填 tenant_id（幂等；每次启动跑一次）。
 	if n, err := db.BackfillDefaultTenants(context.Background()); err != nil {
 		log.Printf("[startup] 默认租户回填失败: %v", err)
 	} else if n > 0 {
 		log.Printf("[startup] 为 %d 个存量用户补建了默认租户", n)
 	}
+	if err := db.BackfillRowTenants(context.Background()); err != nil {
+		log.Printf("[startup] 存量行 tenant_id 回填失败: %v", err)
+	}
 	cache := store.OpenRedis(redisAddr) // CacheDB: Session / Rate Limit（连不上则降级）
 	defer cache.Close()
 	bus := nats.MustConnect(natsURL) // 接入 NATS 零拷贝骨干网 + 声明任务流

sundynix-gateway/internal/middleware/tenant.go

@@ -20,6 +20,9 @@ func TenantContext(db *store.Postgres) gin.HandlerFunc {
 			if uid, _ := v.(string); uid != "" {
 				if t, err := db.EnsureDefaultTenant(c.Request.Context(), uid, ""); err == nil && t != nil {
 					c.Set(CtxTenantID, t.ID)
+					// 注入请求 context：store 的 gorm 租户插件据此对受租户表自动加 tenant_id 过滤/填充。
+					// handler 须用 c.Request.Context() 调 store（现有代码已如此），隔离才会生效。
+					c.Request = c.Request.WithContext(store.WithTenant(c.Request.Context(), t.ID))
 				}
 			}
 		}

sundynix-gateway/internal/store/model.go

@@ -16,12 +16,14 @@ import (
 // 向量/全文/图谱实际以 "owner/name" 作分区键，保证只有 owner 能查到自己的库。
 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"`
 	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) {
@@ -51,12 +53,14 @@ func (p *Postgres) EnsureKB(ctx context.Context, owner, name, kind string) error
 // 表名 sundynix_agent。(owner,name) 唯一 —— 同一用户下编排名不重复。
 type Agent struct {
 	BaseModel
+	TenantID string `gorm:"size:64;index"` // 多租户作用域（tenant 插件自动填/过滤）
 	Owner    string `gorm:"size:64;uniqueIndex:idx_agent_on"`
 	Name     string `gorm:"size:128;uniqueIndex:idx_agent_on"`
 	Graph    string `gorm:"type:text"` // {nodes,edges} 的 JSON（含布局）
 }
 
 func (Agent) TableName() string { return "sundynix_agent" }
+func (Agent) isTenantScoped()   {}
 
 // ListAgents 返回某 owner 的全部编排（最近更新在前）。
 func (p *Postgres) ListAgents(ctx context.Context, owner string) ([]Agent, error) {

sundynix-gateway/internal/store/pgsql.go

@@ -70,6 +70,7 @@ func OpenPostgres(dsn string) *Postgres {
 		log.Printf("[store] postgres AutoMigrate 失败，降级运行: %v", err)
 		return &Postgres{}
 	}
+	registerTenantScope(db) // 多租户：受租户模型的查询/创建自动按上下文注入 tenant_id（统一强制隔离）
 	log.Println("[store] postgres connected & migrated (雪花 id + 软删 规约)")
 	return &Postgres{db: db}
 }

sundynix-gateway/internal/store/tenant_scope.go

@@ -0,0 +1,91 @@
+package store
+
+import (
+	"context"
+	"reflect"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+// tenantScopedMarker：模型实现此(空)接口即"受租户隔离"——gorm tenant 插件据此对其
+// 查询/更新/删除自动加 `tenant_id = <ctx租户>`、创建时自动填 tenant_id。
+// 未实现的模型（User/Tenant/TenantMember/Prompt/Model/Pricing…）不受影响。
+// 未实现方法用小写→只有本包模型能标记（KB/Agent 已标；Doc/DocLink/Task 待增量铺开）。
+type tenantScopedMarker interface{ isTenantScoped() }
+
+// ---- 请求上下文携带 tenant_id（中间件注入 → 传到 store → 插件读取）----
+type ctxKeyTenant struct{}
+
+// WithTenant 把 tenant_id 放进 context（空则原样返回，避免污染系统/回填查询）。
+func WithTenant(ctx context.Context, tenantID string) context.Context {
+	if tenantID == "" {
+		return ctx
+	}
+	return context.WithValue(ctx, ctxKeyTenant{}, tenantID)
+}
+
+func tenantFromCtx(ctx context.Context) string {
+	if ctx == nil {
+		return ""
+	}
+	s, _ := ctx.Value(ctxKeyTenant{}).(string)
+	return s
+}
+
+// registerTenantScope 挂 gorm 回调，实现"统一强制、别靠人肉"的租户隔离。
+func registerTenantScope(db *gorm.DB) {
+	q := func(d *gorm.DB) { addTenantWhere(d) }
+	_ = db.Callback().Query().Before("gorm:query").Register("tenant:query", q)
+	_ = db.Callback().Update().Before("gorm:update").Register("tenant:update", q)
+	_ = db.Callback().Delete().Before("gorm:delete").Register("tenant:delete", q)
+	_ = db.Callback().Create().Before("gorm:create").Register("tenant:create", setTenantOnCreate)
+}
+
+func isTenantScopedStmt(db *gorm.DB) bool {
+	if db.Statement.Schema == nil {
+		return false
+	}
+	_, ok := reflect.New(db.Statement.Schema.ModelType).Interface().(tenantScopedMarker)
+	return ok
+}
+
+// addTenantWhere：受租户模型 + ctx 有 tenant → 追加 tenant_id 过滤。
+// ctx 无 tenant（系统/回填/未登录）→ 不过滤（这些路径本就需跨租户；用户面由中间件保证有 tenant）。
+func addTenantWhere(db *gorm.DB) {
+	if !isTenantScopedStmt(db) {
+		return
+	}
+	if tid := tenantFromCtx(db.Statement.Context); tid != "" {
+		db.Statement.AddClause(clause.Where{Exprs: []clause.Expression{
+			clause.Eq{Column: clause.Column{Table: db.Statement.Table, Name: "tenant_id"}, Value: tid},
+		}})
+	}
+}
+
+// setTenantOnCreate：受租户模型 + ctx 有 tenant → 强制把 tenant_id 设为 ctx 租户（防越权写他租）。
+func setTenantOnCreate(db *gorm.DB) {
+	if !isTenantScopedStmt(db) {
+		return
+	}
+	if tid := tenantFromCtx(db.Statement.Context); tid != "" {
+		db.Statement.SetColumn("TenantID", tid)
+	}
+}
+
+// BackfillRowTenants 给受租户表的存量行回填 tenant_id = owner 的默认租户（幂等：只填空的）。
+// 系统操作、无 ctx 租户 → 不受插件过滤影响。当前覆盖 KB / Agent（同步路径已接插件）。
+func (p *Postgres) BackfillRowTenants(ctx context.Context) error {
+	if p.db == nil {
+		return errStoreDisabled
+	}
+	// 子查询：owner(user) → 其默认(最早 active)租户。
+	sub := "SELECT tenant_id FROM sundynix_tenant_member m WHERE m.user_id = t.owner AND m.status = 'active' ORDER BY m.created_at ASC LIMIT 1"
+	for _, tbl := range []string{"sundynix_kb", "sundynix_agent"} {
+		q := "UPDATE " + tbl + " t SET tenant_id = (" + sub + ") WHERE (t.tenant_id IS NULL OR t.tenant_id = '')"
+		if err := p.db.WithContext(ctx).Exec(q).Error; err != nil {
+			return err
+		}
+	}
+	return nil
+}