feat(session,runtime): 多角色并存—按会话选角（迁移0011 + 按回合解析 + agent池 + 提取器修正）

按 DevDocs/design/22 批次 1 后端（§2/§3/§4.1-4.5/§4.7/§5 验收 1-6）。
- 迁移 0011：chat_sessions.persona_id + chat_messages.persona_id（均 DEFAULT ''，无回填 → 升级零风险）；同步包内幂等 DDL；**真实库升级验证**（拷贝 data/cyrene.db 到临时目录跑 MigrateUp：既有 1 会话/109 消息 persona 仍为 ''，原库未被触碰）
- history：SessionMeta/Message 加 PersonaID + SetSessionPersona；ListSessions/List/scan/Append 带上
- runtime：SessionEnv.PersonaID + loop.personaFor(ctx) 替换固定 l.personaID（memory/request/turn）+ **agent 池**（Options.Agents，按角色取 instructions，未命中回落）+ **提取器不再把 persona 烤死在构造期**（多角色下记忆不再永远记在 cyrene 名下）+ **thinking 旋钮改为按会话角色解析**（否则角色 Y 会用角色 X 的预算/展示）
- gateway：会话 DTO/POST/PATCH 支持 personaId；ws/rest/voice 的 OwnerEnv 硬编改为**按会话解析角色**（actor 元数据语义不变）；admin memories 搜索去掉硬编 cyrene
- Docs/api-client v0.42；**两处有意的行为收紧**已写明：POST /sessions body 非法 JSON → 400（原先完全忽略 body；空/null/{} 仍 201）；POST /admin/memories/search 省略 personaId 且无默认角色 → 400（原先默认查 cyrene）
- 测试：design/22 §5 验收 1-6（记忆隔离/提示词首条 system/情绪按角色/提取 persona 归属/迁移兼容）+ 进程内 e2e（断言 adapter 收到的 model.Request.Messages[0] 即该角色的 systemPrompt）
- **已知未做（留批次 2 / 待确认）**：① IM 与渠道级未做 → **§7-3「owner 私聊镜像随主会话角色」尚未生效**；② 请求级覆盖未实现（本批只做会话级）；③ **§7-5 的「上下文发送角色标记」只完成存储+DTO 半边**——消息 persona 已落库且 DTO 已带，但模型上下文不从 chat_messages 重建，「第 N 条是谁说的」尚未进上下文（需确认是否属批次 2）；④「切角色重建摘要」当前是空操作（压缩未接线）；⑤ thinking 旋钮仅在流式路径生效（非流式 agent.RunStep 不带，A 批次既有性质）
- 验收：go build/vet/test 全绿 + linux/amd64 与 darwin/arm64 交叉编译（既有 flake 本轮未触发；同批 session_orchestrator.go 一度 501 行 → 抽出 session_tail.go）

internal/services/gateway/session_orchestrator.go

@@ -128,11 +128,12 @@ type sessionState struct {
 }
 
 // pendingMsg is one queued user turn. It carries its own env so a resume runs
-// under the same memory-isolation boundary the message arrived with, plus the
-// client deviceID of the originating turn (design/16 §4.5) so the resumed
-// assistant reply is tagged with the same client that sent the message, and the
-// turn's behavior mode (design/16 §5.1) so the resumed reply is persisted under
-// the same mode as the user message that started it.
+// under the same memory-isolation boundary — and, since design/22, the same role
+// (env.PersonaID) — the message arrived with, plus the client deviceID of the
+// originating turn (design/16 §4.5) so the resumed assistant reply is tagged with
+// the same client that sent the message, and the turn's behavior mode (design/16
+// §5.1) so the resumed reply is persisted under the same mode as the user message
+// that started it.
 type pendingMsg struct {
 	messages []model.Message
 	env      loop.SessionEnv
@@ -234,7 +235,7 @@ func (o *Orchestrator) submitInternal(ctx context.Context, sessionID string, mes
 		depth := len(st.pending)
 		mode := st.mode
 		o.mu.Unlock()
-		o.persistUserMessages(ctx, sessionID, messages, deviceID, msgMode)
+		o.persistUserMessages(ctx, sessionID, messages, deviceID, msgMode, env.PersonaID)
 		o.emitState(sessionID, EventPendingAck, map[string]any{"sessionId": sessionID, "mode": mode, "queueDepth": depth})
 		return SubmitResult{Accepted: true, Pending: true, QueueDepth: depth}, nil
 	}
@@ -248,14 +249,14 @@ func (o *Orchestrator) submitInternal(ctx context.Context, sessionID string, mes
 	o.mu.Unlock()
 
 	o.emitState(sessionID, EventSessionBusy, map[string]any{"sessionId": sessionID, "mode": ModeThinking})
-	o.persistUserMessages(ctx, sessionID, messages, deviceID, msgMode)
+	o.persistUserMessages(ctx, sessionID, messages, deviceID, msgMode, env.PersonaID)
 
 	if sync {
 		res, err := o.run(runCtx, sessionID, messages, env)
 		if err != nil {
 			o.log.Error("orchestrator turn", "err", err, "session", sessionID)
 		}
-		_ = o.completeTurn(sessionID, gen, res, err, deviceID, msgMode)
+		_ = o.completeTurn(sessionID, gen, res, err, deviceID, msgMode, env.PersonaID)
 		return SubmitResult{Accepted: true, Immediate: true, Err: err}, res
 	}
 
@@ -266,14 +267,16 @@ func (o *Orchestrator) submitInternal(ctx context.Context, sessionID string, mes
 // goTurn runs a single turn on a background goroutine and, when it finishes,
 // hands the outcome to completeTurn so the orchestrator can resume the queue.
 // deviceID tags the persistent assistant reply with the client that sent the turn
-// (design/16 §4.5) and mode with the turn's behavior mode (design/16 §5.1).
+// (design/16 §4.5), mode with the turn's behavior mode (design/16 §5.1) and env is
+// the turn's resolved role/isolation environment (design/22 §4.5), so the reply is
+// filed under the role that produced it.
 func (o *Orchestrator) goTurn(sessionID string, gen uint64, messages []model.Message, env loop.SessionEnv, ctx context.Context, cancel context.CancelFunc, deviceID, mode string) {
 	defer cancel()
 	res, err := o.run(ctx, sessionID, messages, env)
 	if err != nil && ctx.Err() == nil {
 		o.log.Error("orchestrator turn", "err", err, "session", sessionID)
 	}
-	_ = o.completeTurn(sessionID, gen, res, err, deviceID, mode)
+	_ = o.completeTurn(sessionID, gen, res, err, deviceID, mode, env.PersonaID)
 }
 
 // completeTurn runs after a turn settles (either it finished, errored, or was
@@ -282,10 +285,11 @@ func (o *Orchestrator) goTurn(sessionID string, gen uint64, messages []model.Mes
 // message "remembers" the prior context instead of starting from a blank slate
 // (design/15 §2.2: incremental, not full replay). A stale generation (an
 // interrupt or a newer top-level turn superseded this one) is a no-op.
-// deviceID is the originating turn's client id and mode its behavior mode, both
-// used to tag the persisted reply (design/16 §4.5, §5.1).
-func (o *Orchestrator) completeTurn(sessionID string, gen uint64, res *loop.Result, runErr error, deviceID, mode string) error {
-	o.persistAssistantReply(sessionID, res, deviceID, mode)
+// deviceID is the originating turn's client id, mode its behavior mode and
+// personaID the role it spoke as, all used to tag the persisted reply
+// (design/16 §4.5, §5.1; design/22 §7-5).
+func (o *Orchestrator) completeTurn(sessionID string, gen uint64, res *loop.Result, runErr error, deviceID, mode, personaID string) error {
+	o.persistAssistantReply(sessionID, res, deviceID, mode, personaID)
 	o.mu.Lock()
 	st := o.states[sessionID]
 	if st == nil || st.gen != gen {
@@ -458,40 +462,3 @@ func deviceIDFrom(ctx context.Context) string {
 	v, _ := ctx.Value(deviceIDContextKey{}).(string)
 	return v
 }
-
-// boundedTail returns a fresh copy of the last maxTail messages, so continuation
-// stays incremental and bounded (design/15 §2.2, §4) and never aliases the input
-// slice or another state's tail.
-func (o *Orchestrator) boundedTail(msgs []model.Message) []model.Message {
-	if len(msgs) <= o.maxTail {
-		return append([]model.Message(nil), msgs...)
-	}
-	out := make([]model.Message, o.maxTail)
-	copy(out, msgs[len(msgs)-o.maxTail:])
-	return out
-}
-
-// messagesEmpty reports whether a turn carries no usable text or image, so the
-// orchestrator does not mark a session busy on a vacuous message.
-func (o *Orchestrator) messagesEmpty(msgs []model.Message) bool {
-	for _, m := range msgs {
-		for _, c := range m.Content {
-			if c.Type == model.ContentTypeText && c.Text != "" {
-				return false
-			}
-			if c.Type == model.ContentTypeImage && c.ImageURL != "" {
-				return false
-			}
-		}
-	}
-	return true
-}
-
-// concatMessages returns a new slice combining a and b (never reusing a or b
-// backing arrays) so the continuation tail is safe to hand to a concurrent run.
-func concatMessages(a []model.Message, b ...model.Message) []model.Message {
-	out := make([]model.Message, 0, len(a)+len(b))
-	out = append(out, a...)
-	out = append(out, b...)
-	return out
-}