feat(persona): 首启人格门禁跨通道化 + 内核 persona_set 工具

WebUI 首启向导只覆盖 WebUI 这一条通道，而「人格该问一次」是所有通道的事：
走 QQ / CLI / ACP / 邮件来的人永远见不到那个向导，人格就永远是没确认过。

- 门禁移到 buildSystemPrompt（每轮重建 → WebUI/QQ/CLI/ACP/邮件全覆盖），
  以 core.internal.persona_initialized 为准：未确认时要求模型主动询问用户
  （默认 / 自定义 / 以后再说），确认后该段消失；personaStore 为 nil 时静默关闭。
- 新增内核内置工具 persona_set(mode=default|custom|later[, content])，
  落库逻辑与 WebUI 向导**共用 internal/config**（一个实现 + 两个薄入口：
  ConfigRegistry 直连 / 插件侧 SettingsAPI），避免两套语义各自漂移。
- AgentConfig 增加 PersonaStore 接口，cmd/homed 用 RegistryPersonaStore 实现。
- 非法输入（未知 mode / custom 空内容）在打标记**之前**拒绝：否则标记置位、
  向导被跳过，用户再没机会设。

E2E（隔离实例 + 真实 LLM 往返走 /v1/chat/completions，/var/tmp/persona/e2e.sh）9/9 PASS：
未确认时模型主动询问 → 用户答「用默认的」→ 模型调用 persona_set 落库并置位标记
→ 之后不再追问；反向对照（清标记 + 清会话上下文 + 重启）重新开始询问，
排除了「同一段对话里已问过」这一混淆。

cmd/homed/main.go

@@ -506,20 +506,23 @@ func main() {
 	}
 
 	agent := agentCore.New(agentCore.AgentConfig{
-		ID:                 "main",
+		ID:              "main",
-		SystemPrompt:       sysPrompt,
+		SystemPrompt:    sysPrompt,
-		Provider:           provider,
+		Provider:        provider,
-		ProviderManager:    providerMgr,
+		ProviderManager: providerMgr,
-		IO:                 iom,
+		IO:              iom,
-		Memory:             memDB,
+		Memory:          memDB,
-		Indexer:            memIdx,
+		Indexer:         memIdx,
-		Tracker:            trk,
+		Tracker:         trk,
-		DocStore:           docStore,
+		DocStore:        docStore,
-		Knowledge:          ks,
+		Knowledge:       ks,
-		SocialStore:        socialStore,
+		SocialStore:     socialStore,
-		TextMemory:         textMem,
+		TextMemory:      textMem,
-		MediaStore:         mediaStore,
+		MediaStore:      mediaStore,
-		Personality:        personality,
+		Personality:     personality,
+		// 人格落库面：首启门禁（任何通道都问一次）与 persona_set 工具用。
+		// 与 WebUI 向导共用 internal/config 的同一份落库逻辑。
+		PersonaStore:       internalConfig.RegistryPersonaStore{Reg: cfgReg},
 		PluginReg:          pluginReg,
 		PluginDir:          cfg.Plugin.Dir,
 		DistillInterval:    cfgReg.GetDuration("core.agent.distill_interval", 30*time.Minute),

internal/agent/core/agent.go

@@ -57,9 +57,13 @@ type Agent struct {
 	// 由记忆系统本身决定。为 nil 时全部媒体接线静默跳过。
 	mediaStore *media.Store
 
-	// 人格设定
+	// 人格设定（内容来自启动时载入的人格文件/配置项）
 	personality *agentPkg.Personality
 
+	// 人格落库面：首启门禁与 persona_set 工具使用（见 persona.go）。
+	// 为 nil 时门禁与工具都静默关闭（例如单测里不接配置的场景）。
+	personaStore PersonaStore
+
 	// 插件注册表（用于 plgreload）
 	pluginReg *plugin.Registry
 	pluginDir string
@@ -183,6 +187,7 @@ type AgentConfig struct {
 	MultimodalSpace    vector.MultimodalEmbedder
 	FusionCfg          CrossModalFusionConfig // 跨模态融合权重；零值用默认
 	Personality        *agentPkg.Personality
+	PersonaStore       PersonaStore // 人格设定的读写面（首启门禁 + persona_set 工具）
 	PluginReg          *plugin.Registry
 	PluginDir          string
 	DistillInterval    time.Duration
@@ -269,6 +274,7 @@ func New(cfg AgentConfig) *Agent {
 		textMem:         cfg.TextMemory,
 		mediaStore:      cfg.MediaStore,
 		personality:     cfg.Personality,
+		personaStore:    cfg.PersonaStore,
 		pluginReg:       cfg.PluginReg,
 		pluginDir:       cfg.PluginDir,
 		distillInterval: cfg.DistillInterval,

internal/agent/core/persona.go

@@ -0,0 +1,54 @@
+package core
+
+import (
+	"fmt"
+	"strings"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+)
+
+// PersonaStore 是人格设定的读写面。
+//
+// 首启门禁（buildSystemPrompt）与 persona_set 工具都通过它工作，实现在 cmd/homed：
+// 读写配置项 core.agent.personal_prompt 与一次性标记 core.internal.persona_initialized
+// （落库逻辑与 WebUI 向导共用 internal/config 的实现）。
+//
+// 为什么放在内核而不是某个通道插件：人格是**任何通道都要问一次**的事。
+// 系统提示词每轮重建，门禁放在这里，WebUI / QQ / CLI / ACP / 邮件等全部通道自动覆盖。
+type PersonaStore interface {
+	// PersonaInitialized 报告人格是否已确认（向导或工具已问过）。
+	PersonaInitialized() bool
+	// SetPersona 落库人格并打一次性标记，返回是否需要重启才生效。
+	SetPersona(mode, content string) (restartRequired bool, err error)
+}
+
+// executePersonaTool 落地首启人格设定。
+//
+// 成功即打一次性标记 → 之后 buildSystemPrompt 不再要求模型询问人格。
+// custom 模式返回「需重启生效」：人格在 homed 启动时载入。
+func (a *Agent) executePersonaTool(tc agentAPI.ToolCall) string {
+	if a.personaStore == nil {
+		return "人格设定不可用：内核未接入配置"
+	}
+	mode, _ := tc.Arguments["mode"].(string)
+	content, _ := tc.Arguments["content"].(string)
+	mode = strings.TrimSpace(mode)
+	restart, err := a.personaStore.SetPersona(mode, content)
+	if err != nil {
+		return fmt.Sprintf("人格设定失败：%v", err)
+	}
+	switch mode {
+	case "custom":
+		msg := "已保存自定义人格"
+		if restart {
+			msg += "；**重启 homed 后生效**（人格在启动时载入）"
+		}
+		return msg
+	case "default":
+		return "已确认使用默认人格"
+	case "later":
+		return "已记为「以后再说」，继续使用默认人格"
+	default:
+		return "已保存人格设定"
+	}
+}

internal/agent/core/persona_test.go

@@ -0,0 +1,112 @@
+package core
+
+import (
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+)
+
+// newTestAgent 造一个最小可用的 Agent（buildToolDefs 要求 io 非 nil）。
+func newTestAgent(st PersonaStore) *Agent {
+	return &Agent{io: agentIO.NewIOManager(), personaStore: st}
+}
+
+// fakePersonaStore 记录调用并可控地报告「是否已确认」。
+type fakePersonaStore struct {
+	initialized bool
+	mode        string
+	content     string
+	calls       int
+}
+
+func (f *fakePersonaStore) PersonaInitialized() bool { return f.initialized }
+
+func (f *fakePersonaStore) SetPersona(mode, content string) (bool, error) {
+	f.calls++
+	f.mode, f.content = mode, content
+	f.initialized = true
+	return mode == "custom", nil
+}
+
+// 首启门禁：人格未确认时，**任何通道**的系统提示词都必须带上「去问用户」的指令；
+// 确认后必须消失（否则会每轮反复追问）。
+func TestPersonaOnboardingGateInSystemPrompt(t *testing.T) {
+	st := &fakePersonaStore{}
+	a := newTestAgent(st)
+
+	p := a.buildSystemPrompt("", "你好")
+	if !strings.Contains(p, "首启人格设定") || !strings.Contains(p, "persona_set") {
+		t.Fatalf("未确认人格时提示词应要求模型询问并调用 persona_set，实际缺少该段")
+	}
+
+	// 模型落地后（标记置位）不再出现
+	if out := a.executePersonaTool(agentAPI.ToolCall{Name: "persona_set",
+		Arguments: map[string]interface{}{"mode": "default"}}); !strings.Contains(out, "默认人格") {
+		t.Fatalf("persona_set(default) 回执不对: %s", out)
+	}
+	if !st.initialized {
+		t.Fatal("落库后应置位标记")
+	}
+	if p2 := a.buildSystemPrompt("", "你好"); strings.Contains(p2, "首启人格设定") {
+		t.Fatal("人格已确认后不应再要求询问")
+	}
+
+	// 未接入配置（personaStore 为 nil）时，门禁与工具都必须静默关闭
+	b := newTestAgent(nil)
+	if pb := b.buildSystemPrompt("", "你好"); strings.Contains(pb, "首启人格设定") {
+		t.Fatal("未接入配置时不应出现首启门禁")
+	}
+	if out := b.executePersonaTool(agentAPI.ToolCall{Name: "persona_set"}); !strings.Contains(out, "不可用") {
+		t.Fatalf("未接入配置时工具应回明确错误，实际: %s", out)
+	}
+}
+
+// persona_set 的三选一语义与回执。
+func TestPersonaSetToolModes(t *testing.T) {
+	cases := []struct {
+		mode, content, want string
+	}{
+		{"custom", "你是测试人格", "重启"},
+		{"default", "", "默认人格"},
+		{"later", "", "以后再说"},
+	}
+	for _, c := range cases {
+		st := &fakePersonaStore{}
+		a := newTestAgent(st)
+		out := a.executePersonaTool(agentAPI.ToolCall{Name: "persona_set",
+			Arguments: map[string]interface{}{"mode": c.mode, "content": c.content}})
+		if !strings.Contains(out, c.want) {
+			t.Errorf("mode=%s 回执应含 %q，实际: %s", c.mode, c.want, out)
+		}
+		if st.calls != 1 || st.mode != c.mode || st.content != c.content {
+			t.Errorf("mode=%s 落库参数不对: calls=%d mode=%s content=%q", c.mode, st.calls, st.mode, st.content)
+		}
+	}
+}
+
+// 工具 schema 必须在 catalog 里出现（模型才可能调用）。
+func TestPersonaSetToolDefPresent(t *testing.T) {
+	a := newTestAgent(&fakePersonaStore{})
+	found := false
+	for _, td := range a.buildToolDefs() {
+		if m, ok := td.(map[string]interface{}); ok {
+			if fn, ok := m["function"].(map[string]interface{}); ok && fn["name"] == "persona_set" {
+				found = true
+			}
+		}
+	}
+	if !found {
+		t.Fatal("buildToolDefs 未包含 persona_set")
+	}
+	// 未接入配置时不应暴露该工具
+	b := newTestAgent(nil)
+	for _, td := range b.buildToolDefs() {
+		if m, ok := td.(map[string]interface{}); ok {
+			if fn, ok := m["function"].(map[string]interface{}); ok && fn["name"] == "persona_set" {
+				t.Fatal("未接入配置时不应暴露 persona_set")
+			}
+		}
+	}
+}

internal/agent/core/toolcall.go

@@ -45,6 +45,8 @@ func (a *Agent) executeToolCall(tc agentAPI.ToolCall) (ret string) {
 
 func (a *Agent) executeToolCallInner(tc agentAPI.ToolCall) string {
 	switch {
+	case tc.Name == "persona_set":
+		return a.executePersonaTool(tc)
 	case strings.HasPrefix(tc.Name, "memory_"):
 		return a.executeMemoryTool(tc)
 	case strings.HasPrefix(tc.Name, "social_"):

internal/agent/core/tooldefs.go

@@ -89,6 +89,16 @@ func (a *Agent) buildSystemPrompt(memContext string, userInput string) string {
 		}
 	}
 
+	// 首启人格门禁（跨通道唯一闸口）：人格未确认时，要求模型主动询问用户。
+	// 系统提示词每轮重建，因此 WebUI / QQ / CLI / ACP / 邮件等所有通道都会带上它；
+	// 模型调用 persona_set（或用户在 WebUI 向导里选）落地后，标记置位，本段消失。
+	if a.personaStore != nil && !a.personaStore.PersonaInitialized() {
+		prompt += "\n\n【首启人格设定】你的**人格设定尚未确认**。请在本轮回复里先问用户一句：" +
+			"要用默认人格，还是自定义一个？拿到明确答复后**必须调用 persona_set 工具**落库：" +
+			"用户选默认 → mode=default；自定义 → mode=custom 且把内容写进 content；" +
+			"用户说以后再说 → mode=later。用户答复前不要假设已设置，也不要反复追问同一件事。"
+	}
+
 	prompt += a.buildToolCatalog()
 
 	return prompt
@@ -197,6 +207,24 @@ func (a *Agent) buildToolDefs() []interface{} {
 		}
 	}
 
+	if a.personaStore != nil {
+		tools = append(tools, map[string]interface{}{
+			"type": "function",
+			"function": map[string]interface{}{
+				"name":        "persona_set",
+				"description": "【首启人格】落地用户的人格选择并记录「已经问过」。仅在用户明确答复后调用：默认用 mode=default；自定义用 mode=custom 并把人格内容放进 content；用户说以后再说用 mode=later。",
+				"parameters": map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"mode":    map[string]interface{}{"type": "string", "description": "default | custom | later"},
+						"content": map[string]interface{}{"type": "string", "description": "自定义人格内容（mode=custom 时必填）"},
+					},
+					"required": []string{"mode"},
+				},
+			},
+		})
+	}
+
 	if a.memory != nil {
 		tools = append(tools, map[string]interface{}{
 			"type": "function",

internal/config/persona.go

@@ -0,0 +1,139 @@
+package config
+
+import (
+	"fmt"
+	"strings"
+)
+
+// 人格设定的两个键：内容与「首启向导/工具已经问过」的一次性标记。
+//
+// 为什么需要标记：人格曾经只有 <dataDir>/personal/personal.md 一个来源且无人维护，
+// 里面写死的旧版本号反过来让实例自述旧版本（v1.2.0 压测发现）。
+// 现在人格是配置项（默认模板不含任何版本号），任何通道的第一次交互问一次，之后不再打扰。
+const (
+	// PersonaPromptKey 是人格设定内容（【人格设定】块的正文）。
+	PersonaPromptKey = "core.agent.personal_prompt"
+	// PersonaInitMarkerKey 是「已经问过/已确认」的一次性标记。
+	PersonaInitMarkerKey = "core.internal.persona_initialized"
+)
+
+// 三种落库方式，WebUI 首启向导与内核 persona_set 工具共用。
+const (
+	PersonaModeDefault = "default" // 使用内置默认模板
+	PersonaModeCustom  = "custom"  // 使用调用方提供的内容
+	PersonaModeLater   = "later"   // 保留当前（默认）人格，只打标记不再问
+)
+
+// PersonaKV 是人格落库所需的最小读写面：GetCore/SetCore 的签名与
+// 公开 SDK 的 SettingsAPI 一致，因此插件侧（WebUI）可直接传入；
+// 内核直连配置注册表时用 registryKV 适配（见文件末）。
+type PersonaKV interface {
+	GetCore(key string) (interface{}, error)
+	SetCore(key string, value interface{}) error
+}
+
+// PersonaInitializedKV 报告人格是否已确认（向导或工具已问过）。
+func PersonaInitializedKV(kv PersonaKV) bool {
+	if kv == nil {
+		return false
+	}
+	v, err := kv.GetCore(PersonaInitMarkerKey)
+	if err != nil {
+		return false
+	}
+	s, _ := v.(string)
+	return strings.TrimSpace(s) != ""
+}
+
+// CurrentPersonaKV 读当前人格内容；未设置时回落到内置默认模板。
+func CurrentPersonaKV(kv PersonaKV) string {
+	if kv == nil {
+		return DefaultPersonaPrompt
+	}
+	if v, err := kv.GetCore(PersonaPromptKey); err == nil {
+		if s, ok := v.(string); ok && strings.TrimSpace(s) != "" {
+			return s
+		}
+	}
+	return DefaultPersonaPrompt
+}
+
+// SetPersonaKV 落库人格并打一次性标记，返回 restartRequired。
+//
+// 生效时机：人格在 homed 启动时载入（拼成【人格设定】块进系统提示词），
+// 所以**自定义内容需重启**；default 与 later 都不改变当前已生效的人格，无需重启。
+//
+// 非法输入一律在打标记之前拒绝——否则向导会被跳过，用户再也没机会设。
+func SetPersonaKV(kv PersonaKV, mode, content string) (restartRequired bool, err error) {
+	if kv == nil {
+		return false, fmt.Errorf("persona: settings unavailable")
+	}
+	switch mode {
+	case PersonaModeDefault:
+		if err := kv.SetCore(PersonaPromptKey, DefaultPersonaPrompt); err != nil {
+			return false, err
+		}
+	case PersonaModeCustom:
+		if strings.TrimSpace(content) == "" {
+			return false, fmt.Errorf("persona: content required for custom mode")
+		}
+		if err := kv.SetCore(PersonaPromptKey, content); err != nil {
+			return false, err
+		}
+		restartRequired = true
+	case PersonaModeLater:
+		// 保持当前人格（通常是默认模板），只打标记
+	default:
+		return false, fmt.Errorf("persona: unknown mode %q (want default|custom|later)", mode)
+	}
+	if err := kv.SetCore(PersonaInitMarkerKey, "1"); err != nil {
+		return restartRequired, err
+	}
+	return restartRequired, nil
+}
+
+// RegistryPersonaStore 把配置注册表暴露成内核的 core.PersonaStore 接口
+// （结构类型：方法集匹配即可，无需 import internal/agent/core）。
+type RegistryPersonaStore struct{ Reg *ConfigRegistry }
+
+func (p RegistryPersonaStore) PersonaInitialized() bool { return PersonaInitialized(p.Reg) }
+
+func (p RegistryPersonaStore) SetPersona(mode, content string) (bool, error) {
+	return SetPersona(p.Reg, mode, content)
+}
+
+// registryKV 把内核直连的配置注册表适配成 PersonaKV。
+type registryKV struct{ reg *ConfigRegistry }
+
+func (r registryKV) GetCore(key string) (interface{}, error) {
+	v, err := r.reg.Get(key)
+	if err != nil || v == nil {
+		// 未设置的键对 PersonaKV 语义等同「没有」，不当作错误
+		if s := r.reg.GetString(key, ""); s != "" {
+			return s, nil
+		}
+		return "", nil
+	}
+	return v, nil
+}
+
+func (r registryKV) SetCore(key string, value interface{}) error {
+	s, ok := value.(string)
+	if !ok {
+		return fmt.Errorf("persona: value must be a string")
+	}
+	return r.reg.Set(key, s)
+}
+
+// PersonaInitialized 报告人格是否已确认（内核直连注册表）。
+func PersonaInitialized(reg *ConfigRegistry) bool {
+	return reg != nil && PersonaInitializedKV(registryKV{reg})
+}
+
+// SetPersona 落库人格并打一次性标记（内核直连注册表）。
+func SetPersona(reg *ConfigRegistry, mode, content string) (bool, error) {
+	if reg == nil {
+		return false, fmt.Errorf("persona: config registry unavailable")
+	}
+	return SetPersonaKV(registryKV{reg}, mode, content)
+}

internal/config/persona_kv_test.go

@@ -0,0 +1,99 @@
+package config
+
+import (
+	"strings"
+	"testing"
+)
+
+// fakeKV 是 PersonaKV 的最小实现（模拟插件侧 SettingsAPI）。
+type fakeKV struct{ m map[string]string }
+
+func (f *fakeKV) GetCore(k string) (interface{}, error) { return f.m[k], nil }
+func (f *fakeKV) SetCore(k string, v interface{}) error {
+	f.m[k] = v.(string)
+	return nil
+}
+
+// 三选一语义 + 「只问一次」标记：这是首启向导与 persona_set 工具共用的同一份实现。
+func TestSetPersonaKV(t *testing.T) {
+	t.Run("custom 写入内容并要求重启", func(t *testing.T) {
+		kv := &fakeKV{m: map[string]string{}}
+		restart, err := SetPersonaKV(kv, PersonaModeCustom, "你是测试人格")
+		if err != nil || !restart {
+			t.Fatalf("custom 应成功且需重启: restart=%v err=%v", restart, err)
+		}
+		if kv.m[PersonaPromptKey] != "你是测试人格" || kv.m[PersonaInitMarkerKey] != "1" {
+			t.Fatalf("落库不对: %+v", kv.m)
+		}
+		if !PersonaInitializedKV(kv) {
+			t.Fatal("打过标记应报告已确认")
+		}
+	})
+
+	t.Run("default 写默认模板且无需重启", func(t *testing.T) {
+		kv := &fakeKV{m: map[string]string{}}
+		restart, err := SetPersonaKV(kv, PersonaModeDefault, "")
+		if err != nil || restart {
+			t.Fatalf("default 不应需重启: restart=%v err=%v", restart, err)
+		}
+		if kv.m[PersonaPromptKey] != DefaultPersonaPrompt {
+			t.Fatal("default 应写入内置默认模板")
+		}
+	})
+
+	t.Run("later 保持人格并打标记", func(t *testing.T) {
+		kv := &fakeKV{m: map[string]string{PersonaPromptKey: "原有人格"}}
+		if _, err := SetPersonaKV(kv, PersonaModeLater, ""); err != nil {
+			t.Fatal(err)
+		}
+		if kv.m[PersonaPromptKey] != "原有人格" {
+			t.Fatal("later 不应改动人格")
+		}
+		if kv.m[PersonaInitMarkerKey] != "1" {
+			t.Fatal("later 也必须打标记（否则每次启动都问）")
+		}
+	})
+
+	t.Run("非法输入必须拒绝且不打标记", func(t *testing.T) {
+		for _, c := range []struct{ mode, content string }{
+			{PersonaModeCustom, "   "}, // 空内容
+			{"nope", ""},               // 未知 mode
+		} {
+			kv := &fakeKV{m: map[string]string{}}
+			if _, err := SetPersonaKV(kv, c.mode, c.content); err == nil {
+				t.Fatalf("mode=%q content=%q 应报错", c.mode, c.content)
+			}
+			if kv.m[PersonaInitMarkerKey] == "1" {
+				t.Fatalf("mode=%q 被拒时不得打标记（否则向导会被跳过）", c.mode)
+			}
+		}
+	})
+
+	t.Run("CurrentPersonaKV 未设置时回落默认", func(t *testing.T) {
+		kv := &fakeKV{m: map[string]string{}}
+		if got := CurrentPersonaKV(kv); got != DefaultPersonaPrompt {
+			t.Fatal("未设置应回落默认模板")
+		}
+	})
+}
+
+// 内核直连注册表的入口必须与 KV 版行为一致（同一份实现的两个薄入口）。
+func TestSetPersonaRegistryEntry(t *testing.T) {
+	dir := t.TempDir()
+	reg := NewConfigRegistry(dir + "/config.db")
+	reg.SeedDefaults(dir)
+	defer reg.Close()
+
+	if PersonaInitialized(reg) {
+		t.Fatal("全新实例不应已确认人格")
+	}
+	if _, err := SetPersona(reg, PersonaModeCustom, "内核侧人格"); err != nil {
+		t.Fatal(err)
+	}
+	if !PersonaInitialized(reg) {
+		t.Fatal("内核侧落库后应报告已确认")
+	}
+	if got := reg.GetString(PersonaPromptKey, ""); !strings.Contains(got, "内核侧人格") {
+		t.Fatalf("注册表里没有人格内容: %q", got)
+	}
+}

internal/plugins/webui/handler.go

@@ -981,12 +981,7 @@ func (h *Handler) handleKernel(w http.ResponseWriter, r *http.Request) {
 // 为什么需要向导：人格曾经只有 <dataDir>/personal/personal.md 一个来源且无人维护，
 // 里面写死的旧版本号反过来让实例自述旧版本（v1.2.0 压测发现）。
 // 现在人格是配置项（默认模板不含任何版本号），首启问一次，之后不再打扰。
-const (
+// handlePersona 是首启人格向导的后端（与内核 persona_set 工具共用 internal/config 的实现）。
-	personaPromptKey  = "core.agent.personal_prompt"
-	personaInitMarker = "core.internal.persona_initialized"
-)
-
-// handlePersona 是首启人格向导的后端。
 //
 //	GET  → {initialized, current_prompt, file_override}
 //	POST → {"mode":"default"|"custom"|"later","content":"..."}
@@ -995,6 +990,9 @@ const (
 // 生效时机：人格在 homed 启动时载入（以【人格设定】块拼进系统提示词），
 // 所以**自定义内容需重启生效**；选「默认」或「稍后」（保持当前默认）无需重启。
 // 不回答就是「稍后」：保留默认并打标记，不阻塞任何流程。
+//
+// 跨通道：这里只是 WebUI 侧的入口；任何通道的消息到来时，内核都会检查同一枚标记，
+// 未确认则在提示词里要求模型主动询问（见 internal/agent/core 的首启门禁）。
 func (h *Handler) handlePersona(w http.ResponseWriter, r *http.Request) {
 	if h.settings == nil {
 		writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "settings not available"})
@@ -1002,24 +1000,9 @@ func (h *Handler) handlePersona(w http.ResponseWriter, r *http.Request) {
 	}
 	switch r.Method {
 	case http.MethodGet:
-		initialized := false
-		if v, err := h.settings.GetCore(personaInitMarker); err == nil {
-			if s, ok := v.(string); ok && strings.TrimSpace(s) != "" {
-				initialized = true
-			}
-		}
-		cur := ""
-		if v, err := h.settings.GetCore(personaPromptKey); err == nil {
-			if s, ok := v.(string); ok {
-				cur = s
-			}
-		}
-		if cur == "" {
-			cur = internalConfig.DefaultPersonaPrompt
-		}
 		writeJSON(w, http.StatusOK, map[string]interface{}{
-			"initialized":    initialized,
+			"initialized":    internalConfig.PersonaInitializedKV(h.settings),
-			"current_prompt": cur,
+			"current_prompt": internalConfig.CurrentPersonaKV(h.settings),
 			"file_override":  h.personaFileExists(),
 		})
 	case http.MethodPost:
@@ -1031,31 +1014,14 @@ func (h *Handler) handlePersona(w http.ResponseWriter, r *http.Request) {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid request"})
 			return
 		}
-		restart := false
+		restart, err := internalConfig.SetPersonaKV(h.settings, req.Mode, req.Content)
-		switch req.Mode {
+		if err != nil {
-		case "default":
+			// 非法 mode / 空内容 → 400；落库失败 → 500。两者都不打标记。
-			if err := h.settings.SetCore(personaPromptKey, internalConfig.DefaultPersonaPrompt); err != nil {
+			code := http.StatusInternalServerError
-				writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
+			if strings.Contains(err.Error(), "unknown mode") || strings.Contains(err.Error(), "content required") {
-				return
+				code = http.StatusBadRequest
 			}
-		case "custom":
+			writeJSON(w, code, map[string]string{"error": err.Error()})
-			if strings.TrimSpace(req.Content) == "" {
-				writeJSON(w, http.StatusBadRequest, map[string]string{"error": "content required for custom mode"})
-				return
-			}
-			if err := h.settings.SetCore(personaPromptKey, req.Content); err != nil {
-				writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
-				return
-			}
-			restart = true // 人格在启动时载入
-		case "later":
-			// 保持当前（默认）人格，只打标记，不再问
-		default:
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": "unknown mode"})
-			return
-		}
-		if err := h.settings.SetCore(personaInitMarker, "1"); err != nil {
-			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]interface{}{

internal/plugins/webui/handler_persona_test.go

@@ -69,10 +69,10 @@ func TestPersonaWizardFlow(t *testing.T) {
 	if w.Code != http.StatusOK {
 		t.Fatalf("later 状态码 %d: %s", w.Code, w.Body.String())
 	}
-	if v := cfgReg.GetString(personaInitMarker, ""); v == "" {
+	if v := cfgReg.GetString(internalConfig.PersonaInitMarkerKey, ""); v == "" {
 		t.Fatal("later 也必须打一次性标记（否则每次启动都问）")
 	}
-	if v := cfgReg.GetString(personaPromptKey, ""); v != internalConfig.DefaultPersonaPrompt {
+	if v := cfgReg.GetString(internalConfig.PersonaPromptKey, ""); v != internalConfig.DefaultPersonaPrompt {
 		t.Fatalf("later 不应改动人格，实际 %q", v)
 	}
 
@@ -97,7 +97,7 @@ func TestPersonaWizardFlow(t *testing.T) {
 	if !pr.RestartRequired {
 		t.Fatal("自定义人格应提示需要重启才生效")
 	}
-	if v := cfgReg2.GetString(personaPromptKey, ""); v != "你是测试人格" {
+	if v := cfgReg2.GetString(internalConfig.PersonaPromptKey, ""); v != "你是测试人格" {
 		t.Fatalf("自定义内容未写库: %q", v)
 	}
 
@@ -111,12 +111,12 @@ func TestPersonaWizardFlow(t *testing.T) {
 		t.Fatalf("未知 mode 应 400，实际 %d", w.Code)
 	}
 	// 7. 被拒的请求不得打标记（否则向导会被跳过）
-	if v := cfgReg2.GetString(personaInitMarker, ""); v == "" {
+	if v := cfgReg2.GetString(internalConfig.PersonaInitMarkerKey, ""); v == "" {
 		t.Fatal("前置条件：第 4 步已打标记")
 	}
 	h4, cfgReg4 := newPersonaHandler(t)
 	_ = doPersona(t, h4, http.MethodPost, `{"mode":"nope"}`)
-	if v := cfgReg4.GetString(personaInitMarker, ""); v != "" {
+	if v := cfgReg4.GetString(internalConfig.PersonaInitMarkerKey, ""); v != "" {
 		t.Fatal("被拒的请求不应打标记")
 	}
 }