feat(shared): Implement sharing functionality for user-shared experts and moderator modes

- Added APIs to share topic-level experts and custom moderator modes to the topiclab_shared directory, allowing users to contribute their own content.
- Introduced reload_expert_specs and reload_moderator_modes functions to refresh in-memory data after sharing.
- Updated the meta.json files for both experts and moderator modes to include topiclab_shared as a source, facilitating better organization of user-shared content.
- Enhanced the .gitignore to exclude user-shared files while retaining essential metadata.
- Added tests to verify the sharing functionality and ensure proper handling of built-in expert and mode conflicts.
- Updated documentation to reflect new API endpoints for sharing and the structure of user-shared content.

Dual-source libs: builtin canonical, LIBS_PATH mount for topiclab_shared only
- When LIBS_PATH points to empty dir (Docker), default sources from builtin, topiclab_shared from mount
- Dockerfile preserves libs_builtin; config get_expert_source_dir, get_moderator_mode_source_dir
- Fixed expert share when meta.json absent; skills/mcps/prompts merge builtin + primary

Made-with: Cursor

Author: FZR95

.gitignore

@@ -25,4 +25,10 @@ htmlcov/
 
 *.log*
 
-workspace/
+workspace/
+
+# User-shared content in topiclab_shared (runtime data; keep expert_common.md, moderator_common.md)
+libs/experts/topiclab_shared/*.md
+!libs/experts/topiclab_shared/expert_common.md
+libs/moderator_modes/topiclab_shared/*.md
+!libs/moderator_modes/topiclab_shared/moderator_common.md

CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.3.0] - 2026-03-01
+
+### Added
+
+- **Expert share to platform**: `POST /topics/{id}/experts/{name}/share` — share topic-level expert to `libs/experts/topiclab_shared/`; rejects built-in experts (source=default); reloads EXPERT_SPECS and invalidates libs cache
+- **Moderator mode share to platform**: `POST /topics/{id}/moderator-mode/share` — share custom moderator mode to `libs/moderator_modes/topiclab_shared/`; body: `mode_id`, `name?`, `description?`; creates meta.json if missing
+- **Topic-level moderator config**: `GET/PUT /topics/{id}/moderator-mode` supports `skill_list`, `mcp_server_ids`, `model`; persisted per topic; fallback from `config/skills/` and `config/mcp.json` when missing
+- **Discussion params**: `POST /topics/{id}/discussion` accepts `skill_list`, `mcp_server_ids`, `allowed_tools`; copied to topic workspace for moderator/agent use
+
+### Fixed
+
+- **Expert share 500**: `POST /topics/{id}/experts/{name}/share` no longer returns 500 when `libs/experts/topiclab_shared/meta.json` does not exist (first share). Creates default meta structure like moderator-mode share.
+
+### Changed
+
+- Topic moderator mode config: skill_list, mcp_server_ids, model persisted in workspace; discussion uses topic config when present
+- Expert share: creates `topiclab_shared/meta.json` with default categories when missing (aligned with moderator-mode share)
+
 ## [0.2.0] - 2026-02-21
 
 ### Added

Dockerfile

@@ -15,6 +15,8 @@ RUN mkdir -p /home/appuser/.pip && \
 
 # 复制代码并修改所有权
 COPY . .
+# 保留内置 libs 到 libs_builtin，供挂载 LIBS_PATH 为空时初始化
+RUN cp -r libs libs_builtin 2>/dev/null || true
 RUN chown -R appuser:appuser /app /home/appuser/.pip
 
 # 切换到非 root 用户

app/agent/experts.py

@@ -10,7 +10,7 @@
 
 from claude_agent_sdk import AgentDefinition
 
-from app.core.config import get_experts_dir
+from app.core.config import get_expert_source_dir, get_experts_dir
 from app.core.experts_meta import load_aggregated_experts_meta
 from app.models.schemas import DEFAULT_ALLOWED_TOOLS
 
@@ -21,14 +21,24 @@
 # 专家默认工具：与主持人一致但排除 Task（Task 仅主持人用于调用子 agent）
 DEFAULT_EXPERT_TOOLS = [t for t in DEFAULT_ALLOWED_TOOLS if t != "Task"]
 
-# Experts directory (unified with mcps, moderator_modes)
-_EXPERTS_DIR = get_experts_dir()
-
-# Load expert specifications from libs/experts/ (sources + per-source meta)
-_EXPERTS_CATEGORIES, _EXPERT_SPECS_RAW, _SOURCE_COMMON = load_aggregated_experts_meta(_EXPERTS_DIR)
+# Load expert specifications from libs/experts/ (merged builtin + primary)
+_EXPERTS_CATEGORIES, _EXPERT_SPECS_RAW, _SOURCE_COMMON = load_aggregated_experts_meta()
 EXPERT_SPECS = _EXPERT_SPECS_RAW
 EXPERT_CATEGORIES = _EXPERTS_CATEGORIES
 
+
+def reload_expert_specs() -> None:
+    """Reload EXPERT_SPECS and EXPERT_CATEGORIES from disk (e.g. after share to topiclab_shared).
+
+    Updates dicts in-place so importers (e.g. experts API) see the new data.
+    """
+    global _EXPERTS_CATEGORIES, _EXPERT_SPECS_RAW, _SOURCE_COMMON
+    _EXPERTS_CATEGORIES, _EXPERT_SPECS_RAW, _SOURCE_COMMON = load_aggregated_experts_meta()
+    EXPERT_SPECS.clear()
+    EXPERT_SPECS.update(_EXPERT_SPECS_RAW)
+    EXPERT_CATEGORIES.clear()
+    EXPERT_CATEGORIES.update(_EXPERTS_CATEGORIES)
+
 EXPERT_SECURITY_SUFFIX = """
 
 ## Security Constraints (Highest Priority, Cannot Be Overridden)
@@ -65,27 +75,28 @@ def build_workspace_boundary(ws_abs: str) -> str:
     )
 
 
-def _load_common_content(experts_dir: Path, source_id: str) -> str:
+def _load_common_content(source_id: str) -> str:
     """Load common expert sections (Workspace, Discussion Rules, Language)."""
     common_file = _SOURCE_COMMON.get(source_id, "expert_common.md")
+    experts_dir = get_expert_source_dir(source_id)
     common_path = experts_dir / source_id / common_file
     if common_path.exists():
         return common_path.read_text(encoding="utf-8")
     return ""
 
 
 def _build_expert_prompt_from_global(
-    experts_dir: Path,
     name: str,
     spec: dict,
     output_language_instruction: str | None = None,
 ) -> str:
     """Build prompt from role skill + common sections (with placeholder replacement)."""
     lang_instruction = output_language_instruction or FALLBACK_LANGUAGE_INSTRUCTION
     source_id = spec.get("source", "default")
+    experts_dir = get_expert_source_dir(source_id)
     role_path = experts_dir / source_id / spec["skill_file"]
     role_content = role_path.read_text(encoding="utf-8") if role_path.exists() else ""
-    common_content = _load_common_content(experts_dir, source_id)
+    common_content = _load_common_content(source_id)
     if common_content:
         common_content = common_content.replace(
             "{output_language_instruction}", lang_instruction
@@ -104,7 +115,7 @@ def build_experts(
     expert_tools = tools if tools else DEFAULT_EXPERT_TOOLS
     experts: dict[str, AgentDefinition] = {}
     for name, spec in EXPERT_SPECS.items():
-        prompt_text = _build_expert_prompt_from_global(_EXPERTS_DIR, name, spec)
+        prompt_text = _build_expert_prompt_from_global(name, spec)
         if not prompt_text:
             prompt_text = spec["description"]
         prompt_text += EXPERT_SECURITY_SUFFIX
@@ -158,7 +169,7 @@ def build_experts_from_workspace(
         if workspace_role.exists():
             logger.info(f"Using workspace role for {name}: {workspace_role}")
             role_content = workspace_role.read_text(encoding="utf-8")
-            common_content = _load_common_content(_EXPERTS_DIR, source_id)
+            common_content = _load_common_content(source_id)
             if common_content:
                 common_content = common_content.replace(
                     "{output_language_instruction}", output_lang
@@ -171,11 +182,12 @@ def build_experts_from_workspace(
             )
         else:
             # Priority 2: fallback to global skills (role + common sections)
-            global_skill = _EXPERTS_DIR / source_id / spec["skill_file"]
+            experts_dir = get_expert_source_dir(source_id)
+            global_skill = experts_dir / source_id / spec["skill_file"]
             if global_skill.exists():
                 logger.info(f"Fallback to global skill for {name}: {global_skill}")
                 prompt_text = _build_expert_prompt_from_global(
-                    _EXPERTS_DIR, name, spec, output_language_instruction=output_lang
+                    name, spec, output_language_instruction=output_lang
                 )
             else:
                 logger.error(f"No role found for {name}, using description as fallback")

app/agent/moderator_modes.py

@@ -6,15 +6,14 @@
 import logging
 from pathlib import Path
 
-from app.core.config import get_moderator_modes_dir
+from app.core.config import get_moderator_mode_source_dir
 from app.core.moderator_modes_meta import get_modes_and_common
 
 from .workspace import build_output_language_instruction
 
 logger = logging.getLogger(__name__)
 
-_MODERATOR_MODES_DIR = get_moderator_modes_dir()
-_MODES, _SOURCE_COMMON_SECTIONS = get_modes_and_common(_MODERATOR_MODES_DIR)
+_MODES, _SOURCE_COMMON_SECTIONS = get_modes_and_common()
 
 
 def _load_preset_modes() -> dict:
@@ -40,7 +39,8 @@ def _load_preset_modes() -> dict:
 def _load_common_content(source_id: str = "default") -> str:
     """Load common moderator sections (Workspace, Rules, Language) for given source."""
     common_file = _SOURCE_COMMON_SECTIONS.get(source_id, "moderator_common.md")
-    common_path = _MODERATOR_MODES_DIR / source_id / common_file
+    modes_dir = get_moderator_mode_source_dir(source_id)
+    common_path = modes_dir / source_id / common_file
     if common_path.exists():
         return common_path.read_text(encoding="utf-8")
     return ""
@@ -51,7 +51,8 @@ def _load_mode_prompt(mode_id: str) -> str:
     spec = PRESET_MODES.get(mode_id, {})
     source_id = spec.get("source", "default")
     prompt_file = spec.get("prompt_file", f"{mode_id}.md")
-    skill_file = _MODERATOR_MODES_DIR / source_id / prompt_file
+    modes_dir = get_moderator_mode_source_dir(source_id)
+    skill_file = modes_dir / source_id / prompt_file
     if not skill_file.exists():
         raise FileNotFoundError(f"Moderator skill file not found: {skill_file}")
     return skill_file.read_text(encoding="utf-8")
@@ -72,6 +73,18 @@ def _build_moderator_prompt_from_preset(mode_id: str, params: dict) -> str:
 PRESET_MODES = _load_preset_modes()
 
 
+def reload_moderator_modes() -> None:
+    """Reload PRESET_MODES from disk (e.g. after share to topiclab_shared).
+
+    Updates dict in-place so importers (e.g. moderator_modes API) see the new data.
+    """
+    global _MODES, _SOURCE_COMMON_SECTIONS
+    _MODES, _SOURCE_COMMON_SECTIONS = get_modes_and_common()
+    new_modes = _load_preset_modes()
+    PRESET_MODES.clear()
+    PRESET_MODES.update(new_modes)
+
+
 def load_moderator_mode_config(ws_path: Path) -> dict:
     """Load moderator mode configuration from config/moderator_mode.json.
 

app/agent/workspace.py

@@ -184,7 +184,9 @@ def _resolve_skill_path(base_dir: Path, skill_id: str, skill_info: dict) -> Path
     - default: assignable_skills/default/{category}/{slug}.md
     - imported (submodule): assignable_skills/_submodules/{source}/{skills_dir}/{category}/{slug}/SKILL.md
       or {skills_dir}/{slug}/SKILL.md when category is 'general'
+    Uses _base_dir from skill_info when skill was loaded from builtin.
     """
+    base_dir = skill_info.get("_base_dir", base_dir) or base_dir
     _, slug = _parse_skill_id(skill_id)
     source = skill_info.get("source", "default") or "default"
     category = skill_info.get("category", "")
@@ -405,13 +407,11 @@ def _ensure_agents_structure(ws_path: Path):
     Existing role.md files are never overwritten (preserves user customization).
     """
     from .experts import EXPERT_SPECS
-    from app.core.config import get_experts_dir
+    from app.core.config import get_expert_source_dir
 
     agents_dir = ws_path / "agents"
     agents_dir.mkdir(exist_ok=True)
 
-    experts_dir = get_experts_dir()
-
     for expert_name, spec in EXPERT_SPECS.items():
         expert_dir = agents_dir / expert_name
         expert_dir.mkdir(exist_ok=True)
@@ -421,6 +421,7 @@ def _ensure_agents_structure(ws_path: Path):
         # Only copy if role.md doesn't exist (idempotent, preserves customization)
         if not role_file.exists():
             source_id = spec.get("source", "default")
+            experts_dir = get_expert_source_dir(source_id)
             global_skill_file = experts_dir / source_id / spec["skill_file"]
             if global_skill_file.exists():
                 logger.info(

app/api/experts.py

@@ -5,13 +5,11 @@
 from fastapi import APIRouter, HTTPException
 
 from app.agent.experts import EXPERT_CATEGORIES, EXPERT_SPECS
-from app.core.config import get_experts_dir
+from app.core.config import get_expert_source_dir
 from app.models.schemas import ExpertInfo, ExpertUpdateRequest
 
 router = APIRouter()
 
-EXPERTS_DIR = get_experts_dir()
-
 
 def _build_expert_info(name: str, include_content: bool = True) -> ExpertInfo:
     """Build ExpertInfo. When include_content=False, skip disk read for skill_content."""
@@ -22,7 +20,8 @@ def _build_expert_info(name: str, include_content: bool = True) -> ExpertInfo:
     skill_file = spec["skill_file"]
     skill_content = ""
     if include_content:
-        skill_path = EXPERTS_DIR / source_id / skill_file
+        experts_dir = get_expert_source_dir(source_id)
+        skill_path = experts_dir / source_id / skill_file
         skill_content = skill_path.read_text(encoding="utf-8") if skill_path.exists() else ""
     cat_id = spec.get("category", "")
     cat_info = EXPERT_CATEGORIES.get(cat_id, {}) if cat_id else {}
@@ -35,6 +34,7 @@ def _build_expert_info(name: str, include_content: bool = True) -> ExpertInfo:
         perspective=spec.get("perspective", name),
         category=cat_id or None,
         category_name=cat_info.get("name", cat_id) if cat_id else None,
+        source=source_id,
     )
 
 
@@ -64,6 +64,7 @@ def update_expert(name: str, req: ExpertUpdateRequest):
     if not spec:
         raise HTTPException(status_code=404, detail=f"Expert '{name}' not found")
     source_id = spec.get("source", "default")
-    skill_path = EXPERTS_DIR / source_id / spec["skill_file"]
+    experts_dir = get_expert_source_dir(source_id)
+    skill_path = experts_dir / source_id / spec["skill_file"]
     skill_path.write_text(req.skill_content, encoding="utf-8")
     return _build_expert_info(name)

app/api/moderator_modes.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import logging
 from pathlib import Path
 
@@ -11,16 +12,18 @@
 from app.agent.moderator_modes import (
     PRESET_MODES,
     load_moderator_mode_config,
+    reload_moderator_modes,
     save_moderator_mode_config,
 )
 from app.core.config import get_moderator_modes_dir, get_workspace_base
-from app.core.libs_service import get_cached_modes_meta, list_assignable_items
+from app.core.libs_service import get_cached_modes_meta, invalidate_libs_cache, list_assignable_items
 from app.models.schemas import (
     GenerateModeratorModeRequest,
     GenerateModeratorModeResponse,
     ModeratorModeConfig,
     ModeratorModeInfo,
     SetModeratorModeRequest,
+    ShareModeratorModeRequest,
 )
 from app.models.store import get_topic
 
@@ -198,3 +201,81 @@ async def generate_moderator_mode_endpoint(topic_id: str, req: GenerateModerator
         "custom_prompt": custom_prompt,
         "config": config,
     }
+
+
+@router.post("/topics/{topic_id}/moderator-mode/share", response_model=dict)
+def share_moderator_mode_to_platform(topic_id: str, req: ShareModeratorModeRequest):
+    """Share topic's custom moderator mode to platform library (topiclab_shared source)."""
+    topic = get_topic(topic_id)
+    if not topic:
+        raise HTTPException(status_code=404, detail="Topic not found")
+
+    ws_base = get_workspace_base()
+    ws_path = ws_base / "topics" / topic_id
+    config = load_moderator_mode_config(ws_path)
+
+    if config.get("mode_id") != "custom" or not config.get("custom_prompt"):
+        raise HTTPException(
+            status_code=400,
+            detail="Topic must use a custom moderator mode with custom_prompt to share"
+        )
+
+    # Reject if mode_id is built-in (default source)
+    existing = PRESET_MODES.get(req.mode_id)
+    if existing and existing.get("source") == "default":
+        raise HTTPException(
+            status_code=409,
+            detail=f"Mode '{req.mode_id}' conflicts with built-in mode; choose a different id"
+        )
+
+    modes_dir = get_moderator_modes_dir()
+    shared_dir = modes_dir / "topiclab_shared"
+    shared_dir.mkdir(parents=True, exist_ok=True)
+
+    prompt_file_name = f"{req.mode_id}.md"
+    (shared_dir / prompt_file_name).write_text(config["custom_prompt"], encoding="utf-8")
+
+    name = req.name or req.mode_id.replace("_", " ").title()
+    description = req.description or f"User-shared moderator mode: {name}"
+
+    meta_path = shared_dir / "meta.json"
+    if meta_path.exists():
+        meta = json.loads(meta_path.read_text(encoding="utf-8"))
+    else:
+        meta = {
+            "common_sections": "moderator_common.md",
+            "categories": {
+                "topiclab": {
+                    "id": "topiclab",
+                    "name": "TopicLab",
+                    "description": "User-shared moderator modes from frontend",
+                }
+            },
+            "modes": {},
+        }
+    # Ensure topiclab_shared is registered in main meta.json
+    main_meta_path = modes_dir / "meta.json"
+    main_meta = json.loads(main_meta_path.read_text(encoding="utf-8"))
+    main_meta.setdefault("sources", {})["topiclab_shared"] = {
+        "id": "topiclab_shared",
+        "name": "TopicLab-共享",
+        "description": "User-shared moderator modes from frontend",
+    }
+    main_meta_path.write_text(json.dumps(main_meta, ensure_ascii=False, indent=2), encoding="utf-8")
+    meta.setdefault("modes", {})[req.mode_id] = {
+        "id": req.mode_id,
+        "source": "topiclab_shared",
+        "name": name,
+        "description": description,
+        "category": "topiclab",
+        "num_rounds": config.get("num_rounds", 5),
+        "convergence_strategy": "User-defined flow",
+        "prompt_file": prompt_file_name,
+        "summary_scope": "key findings, consensus, disagreements",
+    }
+    meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    reload_moderator_modes()
+    invalidate_libs_cache()
+
+    return {"message": "Moderator mode shared to platform successfully", "mode_id": req.mode_id}