feat: 管理面板补齐(RAG导入/记忆添加/会话接history/诚实表述) + design/16 §4.6 IM多会话隔离+第三方身份+黑白名单

agent-98 面板批次:
- 会话管理面板改接 history.ListSessions(主web+次级) + 新建次级会话按钮
- 记忆面板手动添加入口 POST /admin/memories(owner)
- 知识库真正实现 IndexDocument(分块+落projectindex) + POST /admin/rag 导入端点
- 三面板空态诚实表述(去除'后端M10+提供')
- RAG嵌入降级到keyword/line(无直属embedder,不伪造语义,符合红线)

agent-99 design/16 §4.6:
- model.Message.SenderName + 迁移0006 sender_name 列
- 第三方身份边界: session.ResolveActor判定(非LLM猜) + [第三方·昵称]前缀(不改源content)
- 群聊/陌生人落独立sess-xxx(persistIsolated),不写主会话,不广播
- 黑/白名单(allowGroups/denyGroups/allowUsers/denyUsers)最前拦截,不进LLM
- 多账号 CHANNELS_JSON 配置 + 每平台多实例
- 管理只读 GET /admin/channels/{platform}/messages(该平台非主人消息流)

实机验证(JWT): 会话管理返回主会话web / 记忆添加成功 / RAG导入documents非空+Cyrene命中; 后端build/vet/test全绿 + 前端build绿

internal/runtime/knowledge/store.go

@@ -10,28 +10,36 @@
 // so a configured vector index (pgvector / SQLite vector) is genuinely used and
 // never a shell.
 //
-// The store is read-only for this milestone: upload/chunk/embed and delete land
-// in M10. The write methods return ErrWriteUnsupported so the admin handler can
-// answer honestly instead of fabricating a success.
+// The store persists knowledge documents by indexing them into the project index
+// (项目索引 → 项目描述 → 章节内容): IndexDocument chunks a document's content and
+// stores it as a project plus its chapters, making it text/keyword-searchable
+// immediately. Semantic/vector embedding of an imported document is a graceful
+// no-op here (this data source holds no vector index); the existing semantic path
+// still ranks project-linked memories via the retriever. Deletion remains
+// unimplemented (M10) and returns ErrWriteUnsupported so the admin handler
+// answers honestly instead of fabricating a success.
 package knowledge
 
 import (
 	"context"
+	"crypto/rand"
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"io"
 	"log/slog"
 	"strings"
+	"unicode/utf8"
 
 	"git.yeij.top/AskaEth/Cyrene_v2/internal/logger"
 	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/memory"
 	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/memory/projectindex"
 )
 
-// ErrWriteUnsupported is returned by the write operations. Upload/chunk/embed and
-// delete are milestone M10; the admin handler maps it to a clear 501 so the
-// frontend can explain rather than show a placeholder alert.
-var ErrWriteUnsupported = errors.New("knowledge: write operations (upload/chunk/embed/delete) land in M10")
+// ErrWriteUnsupported is returned by DeleteDocument. Deletion is milestone M10;
+// the admin handler maps it to a clear 501 so the frontend can explain rather
+// than show a placeholder alert.
+var ErrWriteUnsupported = errors.New("knowledge: delete is not implemented in this milestone")
 
 // defaultTopK bounds the semantic retrieval path.
 const defaultTopK = 8
@@ -54,8 +62,12 @@ type Doc struct {
 	Chunks int
 	// Embedded reports whether a persistent vector index is wired for this
 	// deployment. This is the deployment-level semantic capability; per-document
-	// embedding state is not tracked yet (M10).
+	// embedding state is not tracked yet.
 	Embedded bool
+	// Content is the document body supplied to IndexDocument. It is empty for
+	// documents returned by ListDocuments (they carry metadata only) and is
+	// chunked into chapters by IndexDocument.
+	Content string
 }
 
 // Hit is one retrieval result surfaced to the admin panel.
@@ -253,10 +265,61 @@ func describeProject(p *projectindex.Project) string {
 	return p.Title
 }
 
-// IndexDocument is not implemented in this milestone. It returns
-// ErrWriteUnsupported so the handler answers honestly (upload/chunk/embed = M10).
-func (s *Store) IndexDocument(_ context.Context, _ Doc) error {
-	return ErrWriteUnsupported
+// IndexDocument persists a document into the project index: it creates a project
+// entry (title + description), chunks the content into chapters and adds each
+// chapter, so the document becomes immediately text/keyword-searchable via
+// projectindex.Search. A blank name or content returns an error. When the
+// project-index store is not wired there is nowhere to persist, so it returns an
+// error rather than a fabricated success.
+//
+// Semantic embedding is a graceful no-op: this data source does not own a vector
+// index, so a document imported here is keyword-searchable, and the existing
+// semantic path (project-linked memories ranked by the retriever) is untouched.
+// Per the red line that a configured vector enhancement must be genuinely used
+// and never a shell, we do not pretend to embed; the "Embedded" flag still
+// reflects the deployment-level vector capability reported by ListDocuments.
+func (s *Store) IndexDocument(ctx context.Context, doc Doc) error {
+	name := strings.TrimSpace(doc.Name)
+	if name == "" {
+		return errors.New("knowledge: index document: name is required")
+	}
+	content := strings.TrimSpace(doc.Content)
+	if content == "" {
+		return errors.New("knowledge: index document: content is required")
+	}
+	if s.projects == nil {
+		return errors.New("knowledge: index document: project index store is not configured")
+	}
+
+	projectID := strings.TrimSpace(doc.ID)
+	if projectID == "" {
+		id, err := newProjectID()
+		if err != nil {
+			return fmt.Errorf("knowledge: index document: %w", err)
+		}
+		projectID = id
+	}
+
+	if err := s.projects.PutProject(ctx, projectindex.Project{
+		ID:    projectID,
+		Title: name,
+		Desc:  strings.TrimSpace(doc.Desc),
+	}); err != nil {
+		return fmt.Errorf("knowledge: index project: %w", err)
+	}
+
+	chunks := chunkDocument(content)
+	for i, ch := range chunks {
+		if err := s.projects.AddChapter(ctx, projectID, projectindex.Chapter{
+			ProjectID: projectID,
+			Title:     fmt.Sprintf("第 %d 节", i+1),
+			Content:   ch,
+		}); err != nil {
+			return fmt.Errorf("knowledge: index chapter %d: %w", i+1, err)
+		}
+	}
+	s.log.Info("indexed document", "project", projectID, "name", name, "chapters", len(chunks))
+	return nil
 }
 
 // DeleteDocument is not implemented in this milestone. It returns
@@ -264,3 +327,53 @@ func (s *Store) IndexDocument(_ context.Context, _ Doc) error {
 func (s *Store) DeleteDocument(_ context.Context, _ string) error {
 	return ErrWriteUnsupported
 }
+
+// maxChapterRunes bounds a single chapter's content length. Paragraphs longer
+// than this are split into fixed-run pieces so no chapter is overwhelmingly large.
+const maxChapterRunes = 500
+
+// chunkDocument splits content into chapter-sized strings. Paragraphs are
+// split on blank lines (a run of two or more newlines); a paragraph longer than
+// maxChapterRunes is cut into fixed-run pieces at a rune boundary. Empty
+// paragraphs are dropped and a non-nil (possibly empty) slice is returned.
+func chunkDocument(content string) []string {
+	paragraphs := strings.Split(content, "\n\n")
+	chunks := make([]string, 0, len(paragraphs))
+	for _, p := range paragraphs {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		if utf8.RuneCountInString(p) <= maxChapterRunes {
+			chunks = append(chunks, p)
+			continue
+		}
+		chunks = append(chunks, splitRunes(p, maxChapterRunes)...)
+	}
+	return chunks
+}
+
+// splitRunes breaks s into pieces of at most n runes each.
+func splitRunes(s string, n int) []string {
+	rs := []rune(s)
+	out := make([]string, 0, (len(rs)+n-1)/n)
+	for len(rs) > 0 {
+		if len(rs) <= n {
+			out = append(out, string(rs))
+			break
+		}
+		out = append(out, string(rs[:n]))
+		rs = rs[n:]
+	}
+	return out
+}
+
+// newProjectID returns a 128-bit cryptographically random id, hex-encoded. It
+// avoids a UUID dependency so the package stays self-contained.
+func newProjectID() (string, error) {
+	b := make([]byte, 16)
+	if _, err := rand.Read(b); err != nil {
+		return "", fmt.Errorf("knowledge: generate id: %w", err)
+	}
+	return hex.EncodeToString(b), nil
+}

internal/runtime/knowledge/store_test.go

@@ -0,0 +1,108 @@
+package knowledge
+
+import (
+	"context"
+	"errors"
+	"io"
+	"log/slog"
+	"testing"
+
+	"git.yeij.top/AskaEth/Cyrene_v2/internal/db"
+	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/memory/projectindex"
+)
+
+func testLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(io.Discard, nil))
+}
+
+// newTestStore builds a Store backed by an isolated in-memory SQLite project index.
+func newTestStore(t *testing.T) *Store {
+	t.Helper()
+	ctx := context.Background()
+	d, err := db.Open(ctx, ":memory:", testLogger())
+	if err != nil {
+		t.Fatalf("open in-memory db: %v", err)
+	}
+	t.Cleanup(func() { _ = d.Close() })
+	ps, err := projectindex.New(ctx, d, testLogger())
+	if err != nil {
+		t.Fatalf("projectindex.New: %v", err)
+	}
+	return New(Deps{Projects: ps, Log: testLogger()})
+}
+
+func TestIndexDocumentPersistsProjectAndChapters(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	s := newTestStore(t)
+
+	doc := Doc{Name: "Cyrene 设计", Desc: "v2 设计文档", Content: "这是项目描述段落。\n\n第二段：内部实现要点。\n第三行补充说明。"}
+	if err := s.IndexDocument(ctx, doc); err != nil {
+		t.Fatalf("IndexDocument: %v", err)
+	}
+
+	docs, err := s.ListDocuments(ctx)
+	if err != nil {
+		t.Fatalf("ListDocuments: %v", err)
+	}
+	if len(docs) != 1 {
+		t.Fatalf("documents = %d, want 1", len(docs))
+	}
+	if docs[0].Name != "Cyrene 设计" || docs[0].Desc != "v2 设计文档" {
+		t.Fatalf("doc = %+v, want name/desc set", docs[0])
+	}
+	if docs[0].Chunks != 2 {
+		t.Fatalf("chunks = %d, want 2 (two paragraphs)", docs[0].Chunks)
+	}
+
+	// The imported content is keyword-searchable via the project index.
+	hits, err := s.Search(ctx, "内部实现")
+	if err != nil {
+		t.Fatalf("Search: %v", err)
+	}
+	if len(hits) == 0 {
+		t.Fatalf("search returned no hits for imported content")
+	}
+	found := false
+	for _, h := range hits {
+		if h.DocName == "Cyrene 设计" && h.Chapter == "第 2 节" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("hits = %+v, want chapter 第 2 节 under Cyrene 设计", hits)
+	}
+}
+
+func TestIndexDocumentRejectsBlankNameOrContent(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	s := newTestStore(t)
+
+	if err := s.IndexDocument(ctx, Doc{Content: "有内容没名字"}); err == nil {
+		t.Fatal("IndexDocument with blank name should error")
+	}
+	if err := s.IndexDocument(ctx, Doc{Name: "有名字没内容"}); err == nil {
+		t.Fatal("IndexDocument with blank content should error")
+	}
+}
+
+func TestIndexDocumentRequiresProjectStore(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	s := New(Deps{Log: testLogger()}) // projects == nil
+
+	err := s.IndexDocument(ctx, Doc{Name: "x", Content: "y"})
+	if err == nil {
+		t.Fatal("IndexDocument without a project index should error")
+	}
+}
+
+func TestDeleteDocumentStillUnsupported(t *testing.T) {
+	t.Parallel()
+	s := New(Deps{Log: testLogger()})
+	if err := s.DeleteDocument(context.Background(), "any"); !errors.Is(err, ErrWriteUnsupported) {
+		t.Fatalf("DeleteDocument err = %v, want ErrWriteUnsupported", err)
+	}
+}