diff --git a/backend/agents/skill_creation_agent.py b/backend/agents/skill_creation_agent.py
new file mode 100644
index 000000000..3dc0cfa80
--- /dev/null
+++ b/backend/agents/skill_creation_agent.py
@@ -0,0 +1,122 @@
+"""Skill creation agent module for interactive skill generation."""
+
+import logging
+import threading
+from typing import List
+
+from nexent.core.agents.agent_model import AgentConfig, AgentRunInfo, ModelConfig, ToolConfig
+from nexent.core.agents.run_agent import agent_run_thread
+from nexent.core.utils.observer import MessageObserver
+
+logger = logging.getLogger("skill_creation_agent")
+
+
+def create_skill_creation_agent_config(
+    system_prompt: str,
+    model_config_list: List[ModelConfig],
+    local_skills_dir: str = ""
+) -> AgentConfig:
+    """
+    Create agent config for skill creation with builtin tools.
+
+    Args:
+        system_prompt: Custom system prompt to replace smolagent defaults
+        model_config_list: List of model configurations
+
+    Returns:
+        AgentConfig configured for skill creation
+    """
+    if not model_config_list:
+        raise ValueError("model_config_list cannot be empty")
+
+    first_model = model_config_list[0]
+
+    prompt_templates = {
+        "system_prompt": system_prompt,
+        "managed_agent": {
+            "task": "{task}",
+            "report": "## {name} Report\n\n{final_answer}"
+        },
+        "planning": {
+            "initial_plan": "",
+            "update_plan_pre_messages": "",
+            "update_plan_post_messages": ""
+        },
+        "final_answer": {
+            "pre_messages": "",
+            "post_messages": ""
+        }
+    }
+
+    return AgentConfig(
+        name="__skill_creator__",
+        description="Internal skill creator agent",
+        prompt_templates=prompt_templates,
+        tools=[],
+        max_steps=5,
+        model_name=first_model.cite_name
+    )
+
+
+def run_skill_creation_agent(
+    query: str,
+    agent_config: AgentConfig,
+    model_config_list: List[ModelConfig],
+    observer: MessageObserver,
+    stop_event: threading.Event,
+) -> None:
+    """
+    Run the skill creator agent synchronously.
+
+    Args:
+        query: User query for the agent
+        agent_config: Pre-configured agent config
+        model_config_list: List of model configurations
+        observer: Message observer for capturing agent output
+        stop_event: Threading event for cancellation
+    """
+    agent_run_info = AgentRunInfo(
+        query=query,
+        model_config_list=model_config_list,
+        observer=observer,
+        agent_config=agent_config,
+        stop_event=stop_event
+    )
+
+    agent_run_thread(agent_run_info)
+
+
+def create_simple_skill_from_request(
+    system_prompt: str,
+    user_prompt: str,
+    model_config_list: List[ModelConfig],
+    observer: MessageObserver,
+    stop_event: threading.Event,
+    local_skills_dir: str = ""
+) -> None:
+    """
+    Run skill creation agent to create a skill interactively.
+
+    The agent will write the skill content to tmp.md in local_skills_dir.
+    Frontend should read tmp.md after agent completes to get the skill content.
+
+    Args:
+        system_prompt: System prompt with skill creation instructions
+        user_prompt: User's skill description request
+        model_config_list: List of model configurations
+        observer: Message observer for capturing agent output
+        stop_event: Threading event for cancellation
+        local_skills_dir: Path to local skills directory for file operations
+    """
+    agent_config = create_skill_creation_agent_config(
+        system_prompt=system_prompt,
+        model_config_list=model_config_list,
+        local_skills_dir=local_skills_dir
+    )
+
+    thread_agent = threading.Thread(
+        target=run_skill_creation_agent,
+        args=(user_prompt, agent_config, model_config_list, observer, stop_event)
+    )
+    thread_agent.start()
+    thread_agent.join()
diff --git a/backend/apps/runtime_app.py b/backend/apps/runtime_app.py
index 7420a14a2..ba856b3ce 100644
--- a/backend/apps/runtime_app.py
+++ b/backend/apps/runtime_app.py
@@ -6,6 +6,7 @@
 from apps.conversation_management_app import router as conversation_management_router
 from apps.memory_config_app import router as memory_config_router
 from apps.file_management_app import file_management_runtime_router as file_management_router
+from apps.skill_app import skill_creator_router
 from middleware.exception_handler import ExceptionHandlerMiddleware
 
 # Create logger instance
@@ -22,3 +23,4 @@
 app.include_router(memory_config_router)
 app.include_router(file_management_router)
 app.include_router(voice_router)
+app.include_router(skill_creator_router)
diff --git a/backend/apps/skill_app.py b/backend/apps/skill_app.py
index 8bf19e8b7..dd1f1d2d3 100644
--- a/backend/apps/skill_app.py
+++ b/backend/apps/skill_app.py
@@ -1,22 +1,28 @@
 """Skill management HTTP endpoints."""
 
+import asyncio
 import logging
 import os
-import re
+import threading
 from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, HTTPException, Query, UploadFile, File, Form, Header
-from starlette.responses import JSONResponse
+from starlette.responses import JSONResponse, StreamingResponse
 from pydantic import BaseModel
 
 from consts.exceptions import SkillException, UnauthorizedError
 from services.skill_service import SkillService
 from consts.model import SkillInstanceInfoRequest
-from utils.auth_utils import get_current_user_id
+from utils.auth_utils import get_current_user_id, get_current_user_info
+from utils.prompt_template_utils import get_skill_creation_simple_prompt_template
+from nexent.core.agents.agent_model import ModelConfig
+from agents.skill_creation_agent import create_simple_skill_from_request
+from nexent.core.utils.observer import MessageObserver
 
 logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/skills", tags=["skills"])
+skill_creator_router = APIRouter(prefix="/skills", tags=["simple-skills"])
 
 
 class SkillCreateRequest(BaseModel):
@@ -453,88 +459,143 @@ async def delete_skill(
         raise HTTPException(status_code=500, detail="Internal server error")
 
 
-@router.delete("/{skill_name}/files/{file_path:path}")
-async def delete_skill_file(
-    skill_name: str,
-    file_path: str,
-    authorization: Optional[str] = Header(None)
-) -> JSONResponse:
-    """Delete a specific file within a skill directory.
+class SkillCreateSimpleRequest(BaseModel):
+    """Request model for interactive skill creation."""
+    user_request: str
 
-    Args:
-        skill_name: Name of the skill
-        file_path: Relative path to the file within the skill directory
-    """
-    try:
-        _, _ = get_current_user_id(authorization)
-        service = SkillService()
 
-        # Validate skill_name so it cannot be used for path traversal
-        if not skill_name:
-            raise HTTPException(status_code=400, detail="Invalid skill name")
-        if os.sep in skill_name or "/" in skill_name or ".." in skill_name:
-            raise HTTPException(status_code=400, detail="Invalid skill name")
-
-        # Read config to get temp_filename for validation
-        config_content = service.get_skill_file_content(skill_name, "config.yaml")
-        if config_content is None:
-            raise HTTPException(status_code=404, detail="Config file not found")
-
-        # Parse config to get temp_filename
-        import yaml
-        config = yaml.safe_load(config_content)
-        temp_filename = config.get("temp_filename", "")
-
-        # Get the base directory for the skill
-        local_dir = os.path.join(service.skill_manager.local_skills_dir, skill_name)
-
-        # Check for path traversal patterns in the raw file_path BEFORE any normalization
-        # This catches attempts like ../../etc/passwd or /etc/passwd
-        normalized_for_check = os.path.normpath(file_path)
-        if ".." in file_path or file_path.startswith("/") or (os.sep in file_path and file_path.startswith(os.sep)):
-            # Additional check: ensure the normalized path doesn't escape local_dir
-            abs_local_dir = os.path.abspath(local_dir)
-            abs_full_path = os.path.abspath(os.path.join(local_dir, normalized_for_check))
-            try:
-                common = os.path.commonpath([abs_local_dir, abs_full_path])
-                if common != abs_local_dir:
-                    raise HTTPException(status_code=400, detail="Invalid file path: path traversal detected")
-            except ValueError:
-                raise HTTPException(status_code=400, detail="Invalid file path: path traversal detected")
-
-        # Normalize the requested file path - use basename to strip directory components
-        safe_file_path = os.path.basename(os.path.normpath(file_path))
-
-        # Build full path and validate it stays within local_dir
-        full_path = os.path.normpath(os.path.join(local_dir, safe_file_path))
-        abs_local_dir = os.path.abspath(local_dir)
-        abs_full_path = os.path.abspath(full_path)
-
-        # Check for path traversal: abs_full_path should be within abs_local_dir
-        try:
-            common = os.path.commonpath([abs_local_dir, abs_full_path])
-            if common != abs_local_dir:
-                raise HTTPException(status_code=400, detail="Invalid file path: path traversal detected")
-        except ValueError:
-            # Different drives on Windows
-            raise HTTPException(status_code=400, detail="Invalid file path: path traversal detected")
+def _build_model_config_from_tenant(tenant_id: str) -> ModelConfig:
+    """Build ModelConfig from tenant's quick-config LLM model."""
+    from utils.config_utils import tenant_config_manager, get_model_name_from_config
+    from consts.const import MODEL_CONFIG_MAPPING
 
-        # Validate the filename matches temp_filename
-        if not temp_filename or safe_file_path != temp_filename:
-            raise HTTPException(status_code=400, detail="Can only delete temp_filename files")
+    quick_config = tenant_config_manager.get_model_config(
+        key=MODEL_CONFIG_MAPPING["llm"],
+        tenant_id=tenant_id
+    )
+    if not quick_config:
+        raise ValueError("No LLM model configured for tenant")
 
-        # Check if file exists
-        if not os.path.exists(full_path):
-            raise HTTPException(status_code=404, detail=f"File not found: {safe_file_path}")
+    return ModelConfig(
+        cite_name=quick_config.get("display_name", "default"),
+        api_key=quick_config.get("api_key", ""),
+        model_name=get_model_name_from_config(quick_config),
+        url=quick_config.get("base_url", ""),
+        temperature=0.1,
+        top_p=0.95,
+        ssl_verify=True,
+        model_factory=quick_config.get("model_factory")
+    )
 
-        os.remove(full_path)
-        logger.info(f"Deleted skill file: {full_path}")
 
-        return JSONResponse(content={"message": f"File {safe_file_path} deleted successfully"})
-    except UnauthorizedError as e:
-        raise HTTPException(status_code=401, detail=str(e))
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error deleting skill file {skill_name}/{file_path}: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+@skill_creator_router.post("/create-simple")
+async def create_simple_skill(
+    request: SkillCreateSimpleRequest,
+    authorization: Optional[str] = Header(None)
+):
+    """Create a simple skill interactively via LLM agent.
+
+    Loads the skill_creation_simple prompt template, runs an internal agent
+    with WriteSkillFileTool and ReadSkillMdTool, extracts the <SKILL> block
+    from the final answer, and streams step progress and token content via SSE.
+
+    Yields SSE events:
+        - step_count: Current agent step number
+        - skill_content: Token-level content (thinking, code, deep_thinking, tool output)
+        - final_answer: Complete skill content
+        - done: Stream completion signal
+    """
+    # Message types to stream as skill_content (token-level output)
+    STREAMABLE_CONTENT_TYPES = frozenset([
+        "model_output_thinking",
+        "model_output_code",
+        "model_output_deep_thinking",
+        "tool",
+        "execution_logs",
+    ])
+
+    async def generate():
+        import json
+        try:
+            _, tenant_id, language = get_current_user_info(authorization)
+
+            template = get_skill_creation_simple_prompt_template(language)
+
+            model_config = _build_model_config_from_tenant(tenant_id)
+            observer = MessageObserver(lang=language)
+            stop_event = threading.Event()
+
+            # Get local_skills_dir from SkillManager
+            skill_service = SkillService()
+            local_skills_dir = skill_service.skill_manager.local_skills_dir or ""
+
+            # Start skill creation in background thread
+            def run_task():
+                create_simple_skill_from_request(
+                    system_prompt=template.get("system_prompt", ""),
+                    user_prompt=request.user_request,
+                    model_config_list=[model_config],
+                    observer=observer,
+                    stop_event=stop_event,
+                    local_skills_dir=local_skills_dir
+                )
+
+            thread = threading.Thread(target=run_task)
+            thread.start()
+
+            # Poll observer for step_count and token content messages
+            while thread.is_alive():
+                cached = observer.get_cached_message()
+                for msg in cached:
+                    if isinstance(msg, str):
+                        try:
+                            data = json.loads(msg)
+                            msg_type = data.get("type", "")
+                            content = data.get("content", "")
+
+                            # Stream step progress
+                            if msg_type == "step_count":
+                                yield f"data: {json.dumps({'type': 'step_count', 'content': content}, ensure_ascii=False)}\n\n"
+                            # Stream token content (thinking, code, deep_thinking, tool output)
+                            elif msg_type in STREAMABLE_CONTENT_TYPES:
+                                yield f"data: {json.dumps({'type': 'skill_content', 'content': content}, ensure_ascii=False)}\n\n"
+                            # Stream final_answer content separately
+                            elif msg_type == "final_answer":
+                                yield f"data: {json.dumps({'type': 'final_answer', 'content': content}, ensure_ascii=False)}\n\n"
+                        except (json.JSONDecodeError, Exception):
+                            pass
+                await asyncio.sleep(0.1)
+
+            thread.join()
+
+            # Stream any remaining cached messages after thread completes
+            remaining = observer.get_cached_message()
+            for msg in remaining:
+                if isinstance(msg, str):
+                    try:
+                        data = json.loads(msg)
+                        msg_type = data.get("type", "")
+                        content = data.get("content", "")
+
+                        if msg_type == "step_count":
+                            yield f"data: {json.dumps({'type': 'step_count', 'content': content}, ensure_ascii=False)}\n\n"
+                        elif msg_type in STREAMABLE_CONTENT_TYPES:
+                            yield f"data: {json.dumps({'type': 'skill_content', 'content': content}, ensure_ascii=False)}\n\n"
+                        elif msg_type == "final_answer":
+                            yield f"data: {json.dumps({'type': 'final_answer', 'content': content}, ensure_ascii=False)}\n\n"
+                    except (json.JSONDecodeError, Exception):
+                        pass
+
+            # Stream final answer content from observer
+            final_result = observer.get_final_answer()
+            if final_result:
+                yield f"data: {json.dumps({'type': 'final_answer', 'content': final_result}, ensure_ascii=False)}\n\n"
+
+            # Send done signal
+            yield f"data: {json.dumps({'type': 'done'}, ensure_ascii=False)}\n\n"
+
+        except Exception as e:
+            logger.error(f"Error in create_simple_skill stream: {e}")
+            yield f"data: {json.dumps({'type': 'error', 'message': str(e)}, ensure_ascii=False)}\n\n"
+
+    return StreamingResponse(generate(), media_type="text/event-stream")
diff --git a/backend/prompts/skill_creation_simple_zh.yaml b/backend/prompts/skill_creation_simple_zh.yaml
new file mode 100644
index 000000000..e089c2999
--- /dev/null
+++ b/backend/prompts/skill_creation_simple_zh.yaml
@@ -0,0 +1,71 @@
+system_prompt: |-
+  你是一个专业的技能创建助手，用于帮助用户创建简单的技能 Markdown 说明文件，内容包括：技能名称、技能描述、技能标签、技能提示词等。
+
+  ## 工作流程
+
+  根据用户请求，直接生成技能内容并输出。**不要分步骤执行**，直接整合所有内容返回。
+
+  ## 输出格式
+
+  **重要**：所有需要写入 SKILL.md 的内容必须用 `<SKILL>` 和 `</SKILL>` XML 分隔符包裹。
+
+  ### 格式示例
+
+  ```
+  <SKILL>
+  ---
+  name: your-skill-name
+  description: 简短的第三人称描述，说明此 skill 的功能及何时应使用。包含触发词。
+  tags:
+    - tag1
+    - tag2
+  ---
+
+  # 该 Skill 的名称
+
+  ## 使用说明
+
+  Agent 的分步指导。要简洁——假设 Agent 已具备相关知识。
+
+  ## 示例（可选）
+
+  具体的使用示例。
+  </SKILL>
+
+  [这里是你对用户的友好说明，如技能已创建、功能亮点等]
+  ```
+
+  ## 编写描述（关键）
+
+  `description` 字段会被注入到 Agent 的系统提示词中用于 skill 发现。
+
+  - **使用第三人称书写**："处理 Excel 文件并生成报告"（而非"我可以帮助你..."）。
+  - **包含触发词**：特定文件类型、命令或激活此 skill 的场景。
+  - **要具体**：覆盖 WHAT 和 WHEN。
+
+  ## 禁止行为清单
+
+  - **不要**使用 "Thought:"、"Thinking:" 或任何英文思考标签 — Agent 必须使用中文格式。
+  - **不要**调用额外工具写入或读取技能文件，直接生成技能内容。
+  - **不要**在 XML 分隔符外包含 SKILL.md 的完整内容。
+  - **不要**创建多个文件、scripts/、reference.md 或 examples.md。仅限单个文件。
+  - **不要**在路径中使用 Windows 风格的反斜杠。
+
+user_prompt: |-
+  请帮我创建一个技能，需求如下：
+
+  {{user_request}}
+
+  技能内容应该包括：
+  - name: 技能名称（使用英文或拼音，字母小写，单词用连字符分隔）
+  - description: 简短的中文描述，说明此技能的功能及何时应使用，包含触发词
+  - tags: 1-3 个分类标签
+  - 主要内容：包含 ## 使用说明 和可选的 ## 示例 部分
+
+  **重要要求**：请严格按以下两个步骤进行：
+
+  **步骤 1**：生成 SKILL.md 内容并保存到文件
+
+  **步骤 2**：生成简洁的总结作为最终回答（包括技能名称、功能亮点、适用场景）
+
+  请确保两个步骤都执行完成！
diff --git a/backend/utils/prompt_template_utils.py b/backend/utils/prompt_template_utils.py
index 7e45d8eb5..271c60a0c 100644
--- a/backend/utils/prompt_template_utils.py
+++ b/backend/utils/prompt_template_utils.py
@@ -54,6 +54,10 @@ def get_prompt_template(template_type: str, language: str = LANGUAGE["ZH"], **kw
         'cluster_summary_reduce': {
             LANGUAGE["ZH"]: 'backend/prompts/cluster_summary_reduce_zh.yaml',
             LANGUAGE["EN"]: 'backend/prompts/cluster_summary_reduce_en.yaml'
+        },
+        'skill_creation_simple': {
+            LANGUAGE["ZH"]: 'backend/prompts/skill_creation_simple_zh.yaml',
+            LANGUAGE["EN"]: 'backend/prompts/skill_creation_simple_en.yaml'
         }
     }
 
@@ -144,3 +148,35 @@ def get_cluster_summary_reduce_prompt_template(language: str = LANGUAGE["ZH"]) -
         dict: Loaded cluster summary reduce prompt template configuration
     """
     return get_prompt_template('cluster_summary_reduce', language)
+
+
+def get_skill_creation_simple_prompt_template(language: str = LANGUAGE["ZH"]) -> Dict[str, str]:
+    """
+    Get skill creation simple prompt template.
+
+    This template is now structured YAML with system_prompt and user_prompt sections.
+
+    Args:
+        language: Language code ('zh' or 'en')
+
+    Returns:
+        Dict[str, str]: Template with keys 'system_prompt' and 'user_prompt'
+    """
+    template_path_map = {
+        LANGUAGE["ZH"]: 'backend/prompts/skill_creation_simple_zh.yaml',
+        LANGUAGE["EN"]: 'backend/prompts/skill_creation_simple_en.yaml'
+    }
+
+    template_path = template_path_map.get(language, template_path_map[LANGUAGE["ZH"]])
+
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    backend_dir = os.path.dirname(current_dir)
+    absolute_template_path = os.path.join(backend_dir, template_path.replace('backend/', ''))
+
+    with open(absolute_template_path, 'r', encoding='utf-8') as f:
+        template_data = yaml.safe_load(f)
+
+    return {
+        "system_prompt": template_data.get("system_prompt", ""),
+        "user_prompt": template_data.get("user_prompt", "")
+    }
diff --git a/frontend/app/[locale]/agents/components/agentConfig/SkillBuildModal.tsx b/frontend/app/[locale]/agents/components/agentConfig/SkillBuildModal.tsx
index 46307a0d2..0a6892487 100644
--- a/frontend/app/[locale]/agents/components/agentConfig/SkillBuildModal.tsx
+++ b/frontend/app/[locale]/agents/components/agentConfig/SkillBuildModal.tsx
@@ -2,7 +2,6 @@
 
 import { useState, useEffect, useMemo, useRef } from "react";
 import { useTranslation } from "react-i18next";
-import ReactMarkdown from "react-markdown";
 import {
   Modal,
   Tabs,
@@ -13,7 +12,6 @@ import {
   Select,
   message,
   Flex,
-  Progress,
   Row,
   Col,
   Spin,
@@ -24,10 +22,9 @@ import {
   Trash2,
   MessagesSquare,
   HardDriveUpload,
+  Loader2,
 } from "lucide-react";
-import { getAgentByName } from "@/services/agentConfigService";
-import { conversationService } from "@/services/conversationService";
-import { extractSkillInfo } from "@/lib/skillFileUtils";
+import { extractSkillInfo, extractSkillInfoFromContent } from "@/lib/skillFileUtils";
 import {
   MAX_RECENT_SKILLS,
   THINKING_STEPS_ZH,
@@ -38,12 +35,13 @@ import {
   fetchSkillsList,
   submitSkillForm,
   submitSkillFromFile,
-  processSkillStream,
-  deleteSkillCreatorTempFile,
   findSkillByName,
   searchSkillsByName as searchSkillsByNameUtil,
+  createSimpleSkillStream,
+  clearChatAndTempFile,
   type SkillListItem,
 } from "@/services/skillService";
+import { MarkdownRenderer } from "@/components/ui/markdownRenderer";
 import log from "@/lib/logger";
 
 const { TextArea } = Input;
@@ -61,14 +59,7 @@ export default function SkillBuildModal({
 }: SkillBuildModalProps) {
   const { t } = useTranslation("common");
   const [form] = Form.useForm<SkillFormData>();
-  // TODO: [FEATURE] Re-enable interactive skill creation tab
-  // Reason: Interactive tab depends on skill_creator agent which may not be available in all deployments
-  // When to re-enable:
-  //   1. Ensure skill_creator agent is properly configured and deployed
-  //   2. Verify conversationService works correctly with the agent
-  //   3. Test the full chat-to-form workflow end-to-end
-  //   4. Remove this TODO and restore the interactive tab in tabItems
-  const [activeTab, setActiveTab] = useState<string>("upload");
+  const [activeTab, setActiveTab] = useState<string>("interactive");
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [allSkills, setAllSkills] = useState<SkillListItem[]>([]);
   const [searchResults, setSearchResults] = useState<SkillListItem[]>([]);
@@ -86,13 +77,20 @@ export default function SkillBuildModal({
   const [isThinkingVisible, setIsThinkingVisible] = useState(false);
   const [interactiveSkillName, setInteractiveSkillName] = useState<string>("");
   const chatContainerRef = useRef<HTMLDivElement>(null);
+  const contentTextAreaId = useRef<string>("skill-content-textarea-" + Date.now());
 
-  // skill_creator agent state (cached after first lookup)
-  const [skillCreatorAgentId, setSkillCreatorAgentId] = useState<number | null>(null);
-  const skillCreatorAgentIdRef = useRef<number | null>(null);
+  // Content input streaming state
+  const [formStreamingContent, setFormStreamingContent] = useState<string>("");
+  const [isContentStreaming, setIsContentStreaming] = useState(false);
+  const [thinkingStreamingContent, setThinkingStreamingContent] = useState<string>("");
+  const [summaryStreamingContent, setSummaryStreamingContent] = useState<string>("");
+  const [isSummaryVisible, setIsSummaryVisible] = useState(false);
 
   // Track if component is mounted to prevent state updates after unmount
   const isMountedRef = useRef(true);
+  const currentAssistantIdRef = useRef<string>("");
+  // Track if streaming is complete to prevent late onFormContent callbacks from overwriting cleaned content
+  const isStreamingCompleteRef = useRef(false);
 
   // Name input dropdown control
   const [isNameDropdownOpen, setIsNameDropdownOpen] = useState(false);
@@ -128,11 +126,10 @@ export default function SkillBuildModal({
     };
   }, [isOpen]);
 
-  // TODO: [FEATURE] Update setActiveTab("upload") when interactive tab is re-enabled
   useEffect(() => {
     if (!isOpen) {
       form.resetFields();
-      setActiveTab("upload");
+      setActiveTab("interactive");
       setSelectedSkillName("");
       setUploadFile(null);
       setSearchResults([]);
@@ -144,11 +141,15 @@ export default function SkillBuildModal({
       setIsCreateMode(true);
       setUploadExtractingName(false);
       setUploadExtractedSkillName("");
-      setSkillCreatorAgentId(null);
-      skillCreatorAgentIdRef.current = null;
       setThinkingStep(0);
       setThinkingDescription("");
       setIsThinkingVisible(false);
+      setFormStreamingContent("");
+      setThinkingStreamingContent("");
+      setSummaryStreamingContent("");
+      setIsSummaryVisible(false);
+      setIsContentStreaming(false);
+      currentAssistantIdRef.current = "";
     }
   }, [isOpen, form]);
 
@@ -160,6 +161,27 @@ export default function SkillBuildModal({
     };
   }, []);
 
+  // Sync streaming content to the current assistant chat message for real-time display.
+  // Show thinking content while thinking is visible, then switch to summary.
+  useEffect(() => {
+    if (!currentAssistantIdRef.current) return;
+    const displayContent = isSummaryVisible ? summaryStreamingContent : thinkingStreamingContent;
+    if (!displayContent) return;
+    setChatMessages((prev) =>
+      prev.map((msg) =>
+        msg.id === currentAssistantIdRef.current
+          ? { ...msg, content: displayContent }
+          : msg
+      )
+    );
+  }, [thinkingStreamingContent, summaryStreamingContent, isSummaryVisible]);
+
+  // Sync formStreamingContent to the form content field for real-time display
+  useEffect(() => {
+    if (!formStreamingContent) return;
+    form.setFieldValue("content", formStreamingContent);
+  }, [formStreamingContent, form]);
+
   // Detect create/update mode when skill name changes
   useEffect(() => {
     const nameValue = interactiveSkillName.trim();
@@ -238,7 +260,7 @@ export default function SkillBuildModal({
       form.setFieldsValue({
         name: skill.name,
         description: skill.description || "",
-        source: skill.source || "Custom",
+        source: skill.source || "自定义",
         content: skill.content || "",
       });
     }
@@ -261,11 +283,8 @@ export default function SkillBuildModal({
     }, 200);
   };
 
-  // Cleanup temp file when modal is closed
-  const handleModalClose = async () => {
-    if (activeTab === "interactive" && chatMessages.length > 0) {
-      await deleteSkillCreatorTempFile();
-    }
+  // Cleanup when modal is closed
+  const handleModalClose = () => {
     onCancel();
   };
 
@@ -313,19 +332,6 @@ export default function SkillBuildModal({
     }
   };
 
-  // Resolve skill_creator agent
-  const resolveSkillCreatorAgent = async (): Promise<number | null> => {
-    if (skillCreatorAgentIdRef.current !== null) {
-      const cached = skillCreatorAgentIdRef.current;
-      return cached < 0 ? null : cached;
-    }
-    const result = await getAgentByName("skill_creator");
-    if (!result) return null;
-    skillCreatorAgentIdRef.current = -result.agent_id;
-    setSkillCreatorAgentId(result.agent_id);
-    return result.agent_id;
-  };
-
   // Handle chat send for interactive creation
   const handleChatSend = async () => {
     if (!chatInput.trim() || isChatLoading) return;
@@ -333,6 +339,15 @@ export default function SkillBuildModal({
     const currentInput = chatInput.trim();
     setChatInput("");
 
+    // Read current form fields to provide context to the model
+    const formValues = form.getFieldsValue();
+    const formContext = [
+      formValues.name ? `当前技能名称：${formValues.name}` : "",
+      formValues.description ? `当前技能描述：${formValues.description}` : "",
+      formValues.tags?.length ? `当前标签：${formValues.tags.join(", ")}` : "",
+      formValues.content ? `当前内容：\n${formValues.content}` : "",
+    ].filter(Boolean).join("\n\n");
+
     const userMessage: ChatMessage = {
       id: Date.now().toString(),
       role: "user",
@@ -342,123 +357,119 @@ export default function SkillBuildModal({
 
     setChatMessages((prev) => [...prev, userMessage]);
     setIsChatLoading(true);
-    setThinkingStep(0);
-    setThinkingDescription(THINKING_STEPS_ZH.find((s) => s.step === 0)?.description || "");
+    setThinkingStep(1);
+    setThinkingDescription(THINKING_STEPS_ZH.find((s) => s.step === 1)?.description || "生成技能内容中 ...");
     setIsThinkingVisible(true);
 
+    // Clear content input before streaming
+    form.setFieldValue("content", "");
+    setFormStreamingContent("");
+    setThinkingStreamingContent("");
+    setSummaryStreamingContent("");
+    setIsSummaryVisible(false);
+    setIsContentStreaming(true);
+    // Reset streaming complete flag
+    isStreamingCompleteRef.current = false;
+
     const assistantId = (Date.now() + 1).toString();
+
     setChatMessages((prev) => [
       ...prev,
       { id: assistantId, role: "assistant", content: "", timestamp: new Date() },
     ]);
 
-    try {
-      const agentId = await resolveSkillCreatorAgent();
-      if (!agentId) {
-        throw new Error("skill_creator agent not found");
-      }
+    // Track current assistant message ID for streaming updates
+    currentAssistantIdRef.current = assistantId;
 
-      const history = chatMessages.map((msg) => ({
-        role: msg.role === "user" ? "user" : "assistant",
-        content: msg.content,
-      }));
+    try {
+      // Build user prompt with form context
+      const userPrompt = formContext
+        ? `用户需求：${currentInput}\n\n${formContext}`
+        : `用户需求：${currentInput}`;
 
-      const reader = await conversationService.runAgent(
+      await createSimpleSkillStream(
+        { user_request: userPrompt },
         {
-          query: currentInput,
-          conversation_id: 0,
-          history,
-          agent_id: agentId,
-          is_debug: true,
-        },
-        undefined as unknown as AbortSignal
-      );
-
-      await processSkillStream(
-        reader,
-        (step, description) => {
-          setThinkingStep(step);
-          setThinkingDescription(description);
-        },
-        setIsThinkingVisible,
-        async (finalAnswer) => {
-          if (!isMountedRef.current) return;
-
-          setChatMessages((prev) =>
-            prev.map((msg) =>
-              msg.id === assistantId ? { ...msg, content: finalAnswer } : msg
-            )
-          );
-
-          const { parseSkillDraft } = await import("@/lib/skillFileUtils");
-          const skillDraft = parseSkillDraft(finalAnswer);
-
-          if (skillDraft) {
-            form.setFieldValue("name", skillDraft.name);
-            form.setFieldValue("description", skillDraft.description);
-            form.setFieldValue("tags", skillDraft.tags);
-            form.setFieldValue("content", skillDraft.content);
-            setInteractiveSkillName(skillDraft.name);
-            const existingSkill = allSkills.find(
-              (s) => s.name.toLowerCase() === skillDraft.name.toLowerCase()
-            );
-            setIsCreateMode(!existingSkill);
-            message.success(t("skillManagement.message.skillReadyForSave"));
-          } else {
-            // Fallback: read from temp file
-            try {
-              const { fetchSkillConfig, fetchSkillFileContent } = await import("@/services/agentConfigService");
-              const config = await fetchSkillConfig("simple-skill-creator");
-
-              if (config && config.temp_filename) {
-                const tempFilename = config.temp_filename as string;
-                const tempContent = await fetchSkillFileContent("simple-skill-creator", tempFilename);
-
-                if (tempContent) {
-                  const { extractSkillInfoFromContent } = await import("@/lib/skillFileUtils");
-                  const skillInfo = extractSkillInfoFromContent(tempContent);
-
-                  if (skillInfo && skillInfo.name) {
-                    form.setFieldValue("name", skillInfo.name);
-                    setInteractiveSkillName(skillInfo.name);
-                    const existingSkill = allSkills.find(
-                      (s) => s.name.toLowerCase() === skillInfo.name.toLowerCase()
-                    );
-                    setIsCreateMode(!existingSkill);
-                  }
-                  if (skillInfo && skillInfo.description) {
-                    form.setFieldValue("description", skillInfo.description);
-                  }
-                  if (skillInfo && skillInfo.tags && skillInfo.tags.length > 0) {
-                    form.setFieldValue("tags", skillInfo.tags);
-                  }
-                  // Use content without frontmatter
-                  if (skillInfo.contentWithoutFrontmatter) {
-                    form.setFieldValue("content", skillInfo.contentWithoutFrontmatter);
-                  }
-                }
+          onThinkingUpdate: (step, desc) => {
+            setThinkingStep(step);
+            setThinkingDescription(desc || THINKING_STEPS_ZH.find((s) => s.step === step)?.description || "");
+          },
+          onThinkingVisible: (visible) => {
+            setIsThinkingVisible(visible);
+          },
+          onStepCount: (step) => {
+            setThinkingStep(step);
+            setThinkingDescription(THINKING_STEPS_ZH.find((s) => s.step === step)?.description || "生成技能内容中 ...");
+          },
+          onFormContent: (content) => {
+            if (isStreamingCompleteRef.current) return;
+            setFormStreamingContent((prev) => prev + content);
+          },
+          onSummaryContent: (content) => {
+            setSummaryStreamingContent((prev) => prev + content);
+            setIsSummaryVisible(true);
+          },
+          onDone: (finalResult) => {
+            if (!isMountedRef.current) return;
+            setIsThinkingVisible(false);
+            setIsContentStreaming(false);
+            currentAssistantIdRef.current = "";
+            isStreamingCompleteRef.current = true;
+
+            const finalFormContent = finalResult.formContent;
+            if (finalFormContent) {
+              const skillInfo = extractSkillInfoFromContent(finalFormContent);
+
+              if (skillInfo && skillInfo.name) {
+                form.setFieldsValue({ name: skillInfo.name });
+                setInteractiveSkillName(skillInfo.name);
+                const existingSkill = allSkills.find(
+                  (s) => s.name.toLowerCase() === skillInfo.name?.toLowerCase()
+                );
+                setIsCreateMode(!existingSkill);
+              }
+              if (skillInfo && skillInfo.description) {
+                form.setFieldsValue({ description: skillInfo.description });
+              }
+              if (skillInfo && skillInfo.tags && skillInfo.tags.length > 0) {
+                form.setFieldsValue({ tags: skillInfo.tags });
               }
-            } catch (error) {
-              log.warn("Failed to load temp file content:", error);
+              if (skillInfo && skillInfo.contentWithoutFrontmatter) {
+                form.setFieldsValue({ content: skillInfo.contentWithoutFrontmatter });
+                setFormStreamingContent(skillInfo.contentWithoutFrontmatter);
+              }
+              message.success(t("skillManagement.message.skillReadyForSave"));
             }
-          }
-        },
-        "zh"
+          },
+          onError: (errorMsg) => {
+            log.error("Interactive skill creation error:", errorMsg);
+            message.error(t("skillManagement.message.chatError"));
+            setChatMessages((prev) => prev.filter((m) => m.id !== assistantId));
+            setIsContentStreaming(false);
+            currentAssistantIdRef.current = "";
+          },
+        }
       );
     } catch (error) {
       log.error("Interactive skill creation error:", error);
       message.error(t("skillManagement.message.chatError"));
       setChatMessages((prev) => prev.filter((m) => m.id !== assistantId));
+      setIsContentStreaming(false);
     } finally {
       setIsChatLoading(false);
     }
   };
 
-  // Handle chat clear
+  // Handle chat clear - reset all form fields
   const handleChatClear = async () => {
-    const { clearChatAndTempFile } = await import("@/services/skillService");
     await clearChatAndTempFile();
     setChatMessages([]);
+    form.resetFields(["name", "description", "source", "tags", "content"]);
+    setInteractiveSkillName("");
+    setFormStreamingContent("");
+    setThinkingStreamingContent("");
+    setSummaryStreamingContent("");
+    setIsSummaryVisible(false);
   };
 
   // Scroll to bottom of chat when new messages arrive
@@ -468,14 +479,15 @@ export default function SkillBuildModal({
     }
   }, [chatMessages]);
 
-  // Import extractSkillGenerationResult
-  const extractSkillGenerationResult = (content: string): string => {
-    const skillTagIndex = content.indexOf("</SKILL>");
-    if (skillTagIndex !== -1) {
-      return content.substring(skillTagIndex + 8).trim();
+  // Scroll to bottom of content textarea when streaming content updates
+  useEffect(() => {
+    if (formStreamingContent) {
+      const textarea = document.getElementById(contentTextAreaId.current);
+      if (textarea) {
+        textarea.scrollTop = textarea.scrollHeight;
+      }
     }
-    return content;
-  };
+  }, [formStreamingContent]);
 
   const renderInteractiveTab = () => {
     return (
@@ -523,25 +535,21 @@ export default function SkillBuildModal({
                       : "bg-gray-100 text-gray-800"
                   }`}
                 >
-                  {msg.role === "assistant" && isThinkingVisible && msg.content === "" ? (
-                    <div className="min-w-[200px]">
-                      <Progress
-                        percent={thinkingStep * 20}
-                        status="active"
-                        strokeColor="#52c41a"
-                        railColor="#e8e8e8"
-                      />
+                  {msg.role === "assistant" && isThinkingVisible && !isSummaryVisible ? (
+                    <div className="min-w-[200px] flex flex-col items-center">
+                      <Loader2 size={24} className="animate-spin text-blue-500" />
                       {thinkingDescription && (
-                        <span className="text-xs text-gray-500 mt-1 block">
+                        <span className="text-xs text-gray-500 mt-2">
                           {thinkingDescription}
                         </span>
                       )}
                     </div>
                   ) : msg.role === "assistant" ? (
-                    <div className="markdown-body">
-                      <ReactMarkdown>
-                        {extractSkillGenerationResult(msg.content)}
-                      </ReactMarkdown>
+                    <div className="markdown-content">
+                      <MarkdownRenderer
+                        content={isSummaryVisible ? summaryStreamingContent : msg.content}
+                        className="text-sm"
+                      />
                     </div>
                   ) : (
                     <div className="whitespace-pre-wrap">{msg.content}</div>
@@ -667,8 +675,16 @@ export default function SkillBuildModal({
               label={t("skillManagement.form.content")}
             >
               <TextArea
+                id={contentTextAreaId.current}
                 rows={6}
                 placeholder={t("skillManagement.form.contentPlaceholder")}
+                value={formStreamingContent}
+                onChange={(e) => {
+                  if (isContentStreaming) return;
+                  form.setFieldValue("content", e.target.value);
+                  setFormStreamingContent(e.target.value);
+                }}
+                disabled={isContentStreaming}
               />
             </Form.Item>
           </Form>
@@ -834,19 +850,17 @@ export default function SkillBuildModal({
     );
   };
 
-  // TODO: [FEATURE] Re-enable interactive skill creation tab
-  // See comment above for re-enablement criteria
   const tabItems = [
-    // {
-    //   key: "interactive",
-    //   label: (
-    //     <Flex gap={6} align="center">
-    //       <MessagesSquare size={14} />
-    //       <span>{t("skillManagement.tabs.interactive")}</span>
-    //     </Flex>
-    //   ),
-    //   children: renderInteractiveTab(),
-    // },
+    {
+      key: "interactive",
+      label: (
+        <Flex gap={6} align="center">
+          <MessagesSquare size={14} />
+          <span>{t("skillManagement.tabs.interactive")}</span>
+        </Flex>
+      ),
+      children: renderInteractiveTab(),
+    },
     {
       key: "upload",
       label: (
diff --git a/frontend/lib/skillFileUtils.tsx b/frontend/lib/skillFileUtils.tsx
index 0b290cf35..8682b870b 100644
--- a/frontend/lib/skillFileUtils.tsx
+++ b/frontend/lib/skillFileUtils.tsx
@@ -22,13 +22,15 @@ const extractFrontmatter = (content: string): { name: string | null; description
   const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
   const frontmatterMatch = normalized.match(/^---\n([\s\S]*?)\n---/);
 
-  if (!frontmatterMatch) return { name: null, description: null };
+  if (!frontmatterMatch) {
+    return { name: null, description: null };
+  }
 
   const frontmatter = frontmatterMatch[1];
 
-  // Try yaml.load first
+  // Try yaml.load first with JSON schema (safest, no type coercion issues)
   try {
-    const parsed = yaml.load(frontmatter) as Record<string, unknown> | null;
+    const parsed = yaml.load(frontmatter, { schema: yaml.JSON_SCHEMA }) as Record<string, unknown> | null;
 
     // Check if yaml.load returned a valid object with the required fields
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -42,7 +44,7 @@ const extractFrontmatter = (content: string): { name: string | null; description
         return { name, description };
       }
     }
-  } catch {
+  } catch (e) {
     // yaml.load failed, fall through to regex extraction
   }
 
@@ -53,7 +55,7 @@ const extractFrontmatter = (content: string): { name: string | null; description
 
 /**
  * Fallback regex-based extraction when yaml.load fails.
- * Handles simple YAML key: value pairs including multi-line values.
+ * Handles simple YAML key: value pairs including multi-line values and block scalars.
  */
 const extractFrontmatterByRegex = (frontmatter: string): { name: string | null; description: string | null } => {
   let name: string | null = null;
@@ -65,37 +67,55 @@ const extractFrontmatterByRegex = (frontmatter: string): { name: string | null;
     name = nameMatch[1].trim();
   }
 
-  // Extract description field - handles multi-line values with proper indentation
-  // Look for "description:" followed by content until next top-level key
+  // Extract description field - need to handle block scalars (">" and "|")
+  // The key insight: "description:" line may be followed by ">" on the same line,
+  // and then all indented lines are the value
+  const descStartMatch = frontmatter.match(/^description:\s*/m);
+  if (!descStartMatch) {
+    return { name, description };
+  }
+
+  // Find the line number where description starts
   const lines = frontmatter.split('\n');
-  let descLines: string[] = [];
-  let inDescription = false;
-
-  for (const line of lines) {
-    // Skip empty lines at start
-    if (!inDescription && line.match(/^description:\s*$/)) {
-      inDescription = true;
-      continue;
+  let descLineIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/^description:\s*/)) {
+      descLineIndex = i;
+      break;
     }
+  }
+
+  if (descLineIndex === -1) {
+    return { name, description };
+  }
 
-    if (inDescription) {
-      // Check if this line is a new top-level key (no leading whitespace)
-      if (line.match(/^[a-z_]+:/)) {
-        // End of description
+  const descStartLine = lines[descLineIndex];
+  const remainingLines = lines.slice(descLineIndex + 1);
+
+  // Check if description uses block scalar (">" or "|")
+  const hasBlockScalar = /^(description:\s*)>|^(description:\s*)\|/.test(descStartLine);
+
+  if (hasBlockScalar) {
+    // Block scalar: collect all lines that have at least one leading space
+    const contentLines: string[] = [];
+    for (const line of remainingLines) {
+      // Non-empty line without leading space ends the block
+      if (line.length > 0 && !line.startsWith(' ') && !line.startsWith('\t')) {
         break;
       }
-      // Collect description lines
-      descLines.push(line.replace(/^[ \t]+/, ''));
+      // Collect the line, removing the leading space (YAML block scalars use 1 space indent)
+      if (line.trim() !== '') {
+        contentLines.push(line.replace(/^ /, ''));
+      }
+    }
+    if (contentLines.length > 0) {
+      description = contentLines.join('\n').trim();
     }
-  }
-
-  if (descLines.length > 0) {
-    description = descLines.join(' ').trim();
   } else {
-    // Fallback: try single-line description
-    const singleLineDescMatch = frontmatter.match(/^description:\s*(.+?)\s*$/m);
-    if (singleLineDescMatch && singleLineDescMatch[1]) {
-      description = singleLineDescMatch[1].trim();
+    // Single-line value: capture everything after "description:"
+    const inlineMatch = descStartLine.match(/^description:\s*(.+?)\s*$/);
+    if (inlineMatch && inlineMatch[1]) {
+      description = inlineMatch[1].trim();
     }
   }
 
@@ -188,26 +208,67 @@ export const extractSkillInfoFromContent = (content: string): { name: string; de
 
   if (!content) return result;
 
-  const skillBlockMatch = content.match(/<SKILL>([\s\S]*?)<\/SKILL>/);
+  // Content may or may not have <SKILL> wrapper tags depending on source.
+  // Try to extract the block content first.
+  const skillBlockMatch = content.match(/<SKILL>([\s\S]*?)<\/SKILL>/i);
   const blockContent = skillBlockMatch ? skillBlockMatch[1] : content;
 
-  const frontmatterMatch = blockContent.match(/^---\n([\s\S]*?)\n---/);
-  if (frontmatterMatch) {
-    const frontmatter = frontmatterMatch[1];
-    const parsed = yaml.load(frontmatter) as Record<string, unknown>;
-    if (parsed && typeof parsed === "object") {
+  // Normalize line endings so regex patterns work with CRLF (Windows) input
+  const normalizedBlock = blockContent.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+
+  // Try to match the frontmatter block. The content may have a leading newline
+  // before the opening --- (e.g. "\n---\n..."), so we use indexOf-based approach
+  // for more reliable matching than regex with non-greedy quantifiers.
+  let frontmatter: string | null = null;
+  let frontmatterStart = -1;
+  let frontmatterEnd = -1;
+
+  // Find opening --- (must be at start of line: position 0 or after \n)
+  const firstDash = normalizedBlock.indexOf("---");
+  if (firstDash !== -1) {
+    const isAtLineStart = firstDash === 0 || normalizedBlock[firstDash - 1] === "\n";
+    if (isAtLineStart) {
+      frontmatterStart = firstDash;
+      // Find closing --- (must be on its own line, after opening)
+      const searchStart = frontmatterStart + 3;
+      // First try "\n---" format
+      let secondDash = normalizedBlock.indexOf("\n---", searchStart);
+      if (secondDash !== -1) {
+        frontmatterEnd = secondDash + 1; // Include the \n in the boundary
+      } else {
+        // Try to find "---" at line start
+        let i = searchStart;
+        while (i < normalizedBlock.length) {
+          const nextDash = normalizedBlock.indexOf("---", i);
+          if (nextDash === -1) break;
+          const isClosingDash = nextDash === 0 || normalizedBlock[nextDash - 1] === "\n";
+          if (isClosingDash) {
+            frontmatterEnd = nextDash;
+            break;
+          }
+          i = nextDash + 3;
+        }
+      }
+      if (frontmatterEnd !== -1) {
+        frontmatter = normalizedBlock.substring(frontmatterStart, frontmatterEnd + 3);
+      }
+    }
+  }
+
+  if (frontmatter) {
+    // Extract YAML content between the opening --- and closing ---
+    const yamlContent = frontmatter
+      .replace(/^---/, "")
+      .replace(/---$/, "")
+      .trim();
+    const parsed = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA }) as Record<string, unknown> | null;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       result.name = typeof parsed.name === "string" ? parsed.name.trim() : "";
       result.description = typeof parsed.description === "string" ? parsed.description.trim() : "";
       result.tags = Array.isArray(parsed.tags) ? parsed.tags.filter((t): t is string => typeof t === "string") : [];
     }
-    // Extract content after frontmatter
-    const frontmatterEnd = blockContent.indexOf("---");
-    const secondDash = blockContent.indexOf("---", frontmatterEnd + 3);
-    if (secondDash !== -1) {
-      result.contentWithoutFrontmatter = blockContent.substring(secondDash + 3).trim();
-    } else {
-      result.contentWithoutFrontmatter = blockContent.substring(frontmatterEnd + 3).trim();
-    }
+    // Extract content after frontmatter (everything after the closing ---)
+    result.contentWithoutFrontmatter = normalizedBlock.substring(frontmatterEnd + 3).trim();
   } else {
     result.contentWithoutFrontmatter = blockContent;
   }
@@ -261,18 +322,6 @@ export const parseSkillDraft = (content: string): {
   return { name, description, tags, content: contentWithoutFrontmatter };
 };
 
-/**
- * Extract content after </SKILL> tag for display.
- * @param content The full content string
- * @returns Content after </SKILL> tag
- */
-export const extractSkillGenerationResult = (content: string): string => {
-  const skillTagIndex = content.indexOf("</SKILL>");
-  if (skillTagIndex !== -1) {
-    return content.substring(skillTagIndex + 8).trim();
-  }
-  return content;
-};
 
 // ========== Skill Detail Modal Methods ==========
 
diff --git a/frontend/services/api.ts b/frontend/services/api.ts
index ba7c3a230..1a0b55c71 100644
--- a/frontend/services/api.ts
+++ b/frontend/services/api.ts
@@ -237,6 +237,8 @@ export const API_ENDPOINTS = {
       `${API_BASE_URL}/skills/${skillName}/files/${filePath}`,
     instanceList: `${API_BASE_URL}/skills/instance/list`,
     instanceUpdate: `${API_BASE_URL}/skills/instance/update`,
+    createSimple: `${API_BASE_URL}/skills/create-simple`,
+    creatorCache: `${API_BASE_URL}/skills/creator/cache`,
   },
   memory: {
     // ---------------- Memory configuration ----------------
diff --git a/frontend/services/skillService.ts b/frontend/services/skillService.ts
index bad0651ce..fbd9902bd 100644
--- a/frontend/services/skillService.ts
+++ b/frontend/services/skillService.ts
@@ -1,23 +1,15 @@
 import { message } from "antd";
 import log from "@/lib/logger";
-import { conversationService } from "@/services/conversationService";
 import {
   createSkill,
   updateSkill,
   createSkillFromFile,
   searchSkillsByName as searchSkillsByNameApi,
-  fetchSkillConfig,
-  deleteSkillTempFile,
   fetchSkills,
 } from "@/services/agentConfigService";
-import {
-  extractSkillInfoFromContent,
-  parseSkillDraft,
-} from "@/lib/skillFileUtils";
 import {
   THINKING_STEPS_ZH,
-  THINKING_STEPS_EN,
-  type SkillDraftResult,
+  type CreateSimpleSkillRequest,
 } from "@/types/skill";
 
 // ========== Type Definitions ==========
@@ -78,7 +70,7 @@ export interface ThinkingStep {
  * Get thinking steps based on language
  */
 export const getThinkingSteps = (lang: string): ThinkingStep[] => {
-  return lang === "zh" ? THINKING_STEPS_ZH : THINKING_STEPS_EN;
+  return lang === "zh" ? THINKING_STEPS_ZH : THINKING_STEPS_ZH;
 };
 
 
@@ -150,20 +142,6 @@ export const processSkillStream = async (
   return finalAnswer;
 };
 
-/**
- * Delete temp file from skill creator directory
- */
-export const deleteSkillCreatorTempFile = async (): Promise<void> => {
-  try {
-    const config = await fetchSkillConfig("simple-skill-creator");
-    if (config && typeof config === "object" && config.temp_filename) {
-      await deleteSkillTempFile("simple-skill-creator", config.temp_filename as string);
-    }
-  } catch (error) {
-    log.warn("Failed to delete temp file:", error);
-  }
-};
-
 // ========== Skill Operation Functions ==========
 
 /**
@@ -244,7 +222,6 @@ export const submitSkillForm = async (
     }
 
     if (result.success) {
-      await deleteSkillCreatorTempFile();
       message.success(
         existingSkill
           ? t("skillManagement.message.updateSuccess")
@@ -304,113 +281,10 @@ export const submitSkillFromFile = async (
 };
 
 /**
- * Interactive skill creation via chat with agent
- */
-export const runInteractiveSkillCreation = async (
-  input: string,
-  history: { role: "user" | "assistant"; content: string }[],
-  skillCreatorAgentId: number,
-  onThinkingUpdate: (step: number, description: string) => void,
-  onThinkingVisible: (visible: boolean) => void,
-  onMessageUpdate: (messages: { id: string; role: "user" | "assistant"; content: string; timestamp: Date }[]) => void,
-  onLoadingChange: (loading: boolean) => void,
-  allSkills: SkillListItem[],
-  form: { setFieldValue: (name: string, value: unknown) => void },
-  t: (key: string) => string,
-  isMountedRef: React.MutableRefObject<boolean>
-): Promise<{ success: boolean; skillDraft: SkillDraftResult | null }> => {
-  try {
-    const reader = await conversationService.runAgent(
-      {
-        query: input,
-        conversation_id: 0,
-        history,
-        agent_id: skillCreatorAgentId,
-        is_debug: true,
-      },
-      undefined as unknown as AbortSignal
-    );
-
-    let finalAnswer = "";
-
-    await processSkillStream(
-      reader,
-      onThinkingUpdate,
-      onThinkingVisible,
-      (answer) => {
-        finalAnswer = answer;
-      },
-      "zh"
-    );
-
-    if (!isMountedRef.current) {
-      return { success: false, skillDraft: null };
-    }
-
-    const skillDraft = parseSkillDraft(finalAnswer);
-    if (skillDraft) {
-      form.setFieldValue("name", skillDraft.name);
-      form.setFieldValue("description", skillDraft.description);
-      form.setFieldValue("tags", skillDraft.tags);
-      form.setFieldValue("content", skillDraft.content);
-
-      message.success(t("skillManagement.message.skillReadyForSave"));
-      return { success: true, skillDraft };
-    } else {
-      // Fallback: read temp file if no skill draft parsed
-      if (!isMountedRef.current) {
-        return { success: false, skillDraft: null };
-      }
-
-      try {
-        const config = await fetchSkillConfig("simple-skill-creator");
-        if (config && config.temp_filename && isMountedRef.current) {
-          const { fetchSkillFileContent } = await import("@/services/agentConfigService");
-          const tempFilename = config.temp_filename as string;
-          const tempContent = await fetchSkillFileContent("simple-skill-creator", tempFilename);
-
-          if (tempContent && isMountedRef.current) {
-            const skillInfo = extractSkillInfoFromContent(tempContent);
-
-            if (skillInfo && skillInfo.name) {
-              form.setFieldValue("name", skillInfo.name);
-            }
-            if (skillInfo && skillInfo.description) {
-              form.setFieldValue("description", skillInfo.description);
-            }
-            if (skillInfo && skillInfo.tags && skillInfo.tags.length > 0) {
-              form.setFieldValue("tags", skillInfo.tags);
-            }
-            if (skillInfo.contentWithoutFrontmatter) {
-              form.setFieldValue("content", skillInfo.contentWithoutFrontmatter);
-            }
-          }
-        }
-      } catch (error) {
-        log.warn("Failed to load temp file content:", error);
-      }
-
-      return { success: false, skillDraft: null };
-    }
-  } catch (error) {
-    log.error("Interactive skill creation error:", error);
-    message.error(t("skillManagement.message.chatError"));
-    return { success: false, skillDraft: null };
-  }
-};
-
-/**
- * Clear chat and delete temp file
+ * Clear chat state (no backend call needed)
  */
 export const clearChatAndTempFile = async (): Promise<void> => {
-  try {
-    const config = await fetchSkillConfig("simple-skill-creator");
-    if (config && typeof config === "object" && config.temp_filename) {
-      await deleteSkillTempFile("simple-skill-creator", config.temp_filename as string);
-    }
-  } catch (error) {
-    log.warn("Failed to delete temp file on clear:", error);
-  }
+  // No backend call needed - just clear local state
 };
 
 /**
@@ -444,3 +318,363 @@ export const skillNameExists = (
 };
 
 export { updateSkill };
+
+/**
+ * Call the /skills/create-simple backend API to generate a skill.
+ */
+import { API_ENDPOINTS, fetchWithErrorHandling } from "@/services/api";
+
+export interface CreateSimpleSkillResponse {
+  skill_name: string;
+  skill_description: string;
+  tags: string[];
+  skill_content: string;
+}
+
+/**
+ * Interactive skill creation via backend API (SDK-backed).
+ */
+export const createSimpleSkill = async (
+  request: CreateSimpleSkillRequest
+): Promise<CreateSimpleSkillResponse> => {
+  const response = await fetchWithErrorHandling(API_ENDPOINTS.skills.createSimple, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+  return response.json();
+};
+
+/**
+ * Parse streaming content with <SKILL> delimiters.
+ * Content inside <SKILL></SKILL> goes to form content.
+ * Content outside <SKILL></SKILL> that appears BEFORE the <SKILL> tag is ignored (preceding noise).
+ * Content outside that appears AFTER the </SKILL> tag is the summary.
+ */
+export interface SkillDelimiterParseResult {
+  formContent: string;
+  summaryContent: string;
+  newFormContent: string;
+  newSummaryContent: string;
+  summaryStarted: boolean;
+}
+
+/**
+ * Extract summary content from final_answer.
+ * final_answer contains the FULL response including <SKILL> block.
+ * The SKILL content was already streamed via skill_content events,
+ * so we only need the summary (content AFTER </SKILL>).
+ */
+function extractSummaryFromFinalAnswer(fullContent: string): string {
+  const SKILL_CLOSE = "</SKILL>";
+  const closeIndex = fullContent.indexOf(SKILL_CLOSE);
+  if (closeIndex === -1) {
+    return fullContent;
+  }
+  return fullContent.substring(closeIndex + SKILL_CLOSE.length).trim();
+}
+
+/**
+ * Initialize a skill delimiter parser state.
+ * Matches uppercase <SKILL></SKILL> XML delimiters from the backend.
+ */
+export function createSkillDelimiterParser(): {
+  update: (chunk: string) => SkillDelimiterParseResult;
+  getFullResult: () => SkillDelimiterParseResult;
+} {
+  let formContent = "";
+  let summaryContent = "";
+  let buffer = "";
+  let isInsideSkillTag = false;
+  let summaryStarted = false;
+  // Tracks potential partial </SKILL> prefix across chunks
+  let pendingClose = "";
+  const SKILL_OPEN = "<SKILL>";
+  const SKILL_CLOSE = "</SKILL>";
+  const CLOSE_LEN = SKILL_CLOSE.length; // 8
+
+  return {
+    update(chunk: string): SkillDelimiterParseResult {
+      buffer += chunk;
+      let newFormContent = "";
+      let newSummaryContent = "";
+
+      while (buffer.length > 0) {
+        if (isInsideSkillTag) {
+          // Check if pendingClose + buffer contains </SKILL>
+          const combined = pendingClose + buffer;
+          const closeIdx = combined.indexOf(SKILL_CLOSE);
+          if (closeIdx !== -1) {
+            // Found </SKILL>!
+            // Content before it (minus pendingClose) is safe to output as form content.
+            const content = combined.substring(0, closeIdx);
+            const safeContent = content.substring(pendingClose.length);
+            if (safeContent.length > 0) {
+              formContent += safeContent;
+              newFormContent += safeContent;
+            }
+            // Everything after </SKILL> is summary.
+            const afterClose = combined.substring(closeIdx + CLOSE_LEN);
+            if (afterClose.length > 0) {
+              summaryContent += afterClose;
+              newSummaryContent += afterClose;
+            }
+            buffer = "";
+            pendingClose = "";
+            isInsideSkillTag = false;
+            summaryStarted = true;
+            break;
+          }
+
+          // No full </SKILL> in combined. Decide what to save as pendingClose.
+          if (combined.length <= CLOSE_LEN - 1) {
+            // Too short to contain </SKILL>. Hold all as pending, output nothing.
+            pendingClose = combined;
+            buffer = "";
+            break;
+          }
+
+          // Buffer is long enough. Check if combined ends with potential partial </SKILL.
+          const lastPossible = combined.slice(-(CLOSE_LEN - 1)); // Last 7 chars
+          if (lastPossible.startsWith("</SK")) {
+            // Looks like partial </SKILL. Hold last 7 chars, output rest.
+            const safeLen = combined.length - (CLOSE_LEN - 1);
+            const safe = combined.substring(0, safeLen);
+            formContent += safe;
+            newFormContent += safe;
+            pendingClose = lastPossible;
+            buffer = "";
+            break;
+          }
+
+          // Does not look like partial </SKILL>. Output all as content.
+          formContent += combined;
+          newFormContent += combined;
+          buffer = "";
+          pendingClose = "";
+          break;
+        } else {
+          const openIdx = buffer.indexOf(SKILL_OPEN);
+          if (openIdx !== -1) {
+            buffer = buffer.substring(openIdx + SKILL_OPEN.length);
+            isInsideSkillTag = true;
+            pendingClose = "";
+          } else {
+            if (buffer.includes("<")) {
+              break;
+            } else {
+              buffer = "";
+              break;
+            }
+          }
+        }
+      }
+
+      return {
+        formContent,
+        summaryContent,
+        newFormContent,
+        newSummaryContent,
+        summaryStarted,
+      };
+    },
+
+    getFullResult(): SkillDelimiterParseResult {
+      if (isInsideSkillTag) {
+        // Any remaining buffer or pendingClose is form content
+        if (buffer.length > 0) {
+          formContent += buffer;
+        }
+        if (pendingClose.length > 0) {
+          formContent += pendingClose;
+        }
+      }
+      isInsideSkillTag = false;
+      return {
+        formContent,
+        summaryContent,
+        newFormContent: "",
+        newSummaryContent: "",
+        summaryStarted: true,
+      };
+    },
+  };
+}
+
+/**
+ * SSE event types for streaming skill creation
+ */
+export interface SkillCreationStreamEvent {
+  type: "step_count" | "final_answer" | "skill_content" | "skill_result" | "done" | "error";
+  content?: string;
+  skill_name?: string;
+  skill_description?: string;
+  tags?: string[];
+  message?: string;
+}
+
+/**
+ * Interactive skill creation via SSE stream with progress updates.
+ * Uses <SKILL></SKILL> delimiters to separate form content from summary.
+ */
+export const createSimpleSkillStream = async (
+  request: CreateSimpleSkillRequest,
+  callbacks: {
+    onStepCount: (step: number, description: string) => void;
+    onThinkingVisible: (visible: boolean) => void;
+    onThinkingUpdate: (step: number, description: string) => void;
+    onSkillContent?: (content: string) => void;
+    onSkillResult?: (result: { skill_name: string; skill_description: string; tags: string[] }) => void;
+    onFormContent?: (content: string) => void;
+    onSummaryContent?: (content: string) => void;
+    onDone: (finalResult: SkillDelimiterParseResult) => void;
+    onError: (message: string) => void;
+  }
+): Promise<SkillDelimiterParseResult> => {
+  const response = await fetch(API_ENDPOINTS.skills.createSimple, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+
+  if (!response.ok) {
+    callbacks.onError(`HTTP error: ${response.status}`);
+    return { formContent: "", summaryContent: "", newFormContent: "", newSummaryContent: "", summaryStarted: false };
+  }
+
+  if (!response.body) {
+    callbacks.onError("No response body");
+    return { formContent: "", summaryContent: "", newFormContent: "", newSummaryContent: "", summaryStarted: false };
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const delimiterParser = createSkillDelimiterParser();
+  // Track pending stream promises so 'done' case can await them
+  const pendingStreamPromises: Promise<void>[] = [];
+
+  callbacks.onThinkingVisible(true);
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      // Strip any stray \r so the buffer uses only \n internally.
+      // This handles Windows CRLF line endings in the SSE stream.
+      const cleanChunk = decoder.decode(value, { stream: true }).replace(/\r/g, "");
+      buffer += cleanChunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data:")) continue;
+        const jsonStr = line.substring(5).trim();
+        if (!jsonStr) continue;
+
+        try {
+          const event: SkillCreationStreamEvent = JSON.parse(jsonStr);
+
+          switch (event.type) {
+            case "step_count": {
+              const stepMatch = String(event.content).match(/\d+/);
+              const stepNum = stepMatch ? parseInt(stepMatch[0], 10) : NaN;
+              if (!isNaN(stepNum)) {
+                callbacks.onThinkingUpdate(stepNum, "");
+                callbacks.onStepCount(stepNum, "");
+              }
+              break;
+            }
+            case "skill_content":
+              if (event.content) {
+                const parsed = delimiterParser.update(event.content);
+                // Only send to form when still inside <SKILL> tags (summaryStarted=false).
+                // Once summaryStarted=true, all content is summary text, not form content.
+                if (parsed.newFormContent && !parsed.summaryStarted && callbacks.onFormContent) {
+                  callbacks.onFormContent(parsed.newFormContent);
+                }
+                if (parsed.newSummaryContent && callbacks.onSummaryContent) {
+                  callbacks.onSummaryContent(parsed.newSummaryContent);
+                }
+                if (callbacks.onSkillContent) {
+                  callbacks.onSkillContent(event.content);
+                }
+              }
+              break;
+            case "final_answer":
+              if (event.content) {
+                // final_answer contains the FULL response including <SKILL> block.
+                // The SKILL content was already streamed via skill_content events.
+                // Only extract the summary (content after </SKILL>) from final_answer.
+                const summary = extractSummaryFromFinalAnswer(event.content);
+                if (summary && callbacks.onSummaryContent) {
+                  // Use async loop with setTimeout to allow React to render each chunk.
+                  // Without the delay, all state updates batch into one render.
+                  const CHUNK_SIZE = 3; // characters per chunk
+                  const CHUNK_DELAY = 15; // ms between chunks
+                  // Wrap streaming in a promise so we can await it before onDone
+                  const streamPromise = new Promise<void>((resolve) => {
+                    const streamChunk = (index: number): void => {
+                      if (index >= summary.length) {
+                        resolve();
+                        return;
+                      }
+                      const chunk = summary.substring(index, index + CHUNK_SIZE);
+                      callbacks.onSummaryContent!(chunk);
+                      setTimeout(() => streamChunk(index + CHUNK_SIZE), CHUNK_DELAY);
+                    };
+                    streamChunk(0);
+                  });
+                  // Store promise to be awaited in 'done' case
+                  pendingStreamPromises.push(streamPromise);
+                }
+              }
+              break;
+            case "skill_result":
+              if (callbacks.onSkillResult) {
+                callbacks.onSkillResult({
+                  skill_name: event.skill_name || "",
+                  skill_description: event.skill_description || "",
+                  tags: event.tags || [],
+                });
+              }
+              break;
+            case "done":
+              callbacks.onThinkingVisible(false);
+              {
+                const finalResult = delimiterParser.getFullResult();
+                // Await all pending stream promises before calling onDone
+                Promise.all(pendingStreamPromises)
+                  .then(() => {
+                    try {
+                      callbacks.onDone(finalResult);
+                    } catch {
+                      // Ignore callback errors
+                    }
+                  })
+                  .catch(() => {
+                    // Ignore promise errors
+                    try {
+                      callbacks.onDone(finalResult);
+                    } catch {
+                      // Ignore callback errors
+                    }
+                  });
+              }
+              break;
+            case "error":
+              callbacks.onThinkingVisible(false);
+              callbacks.onError(event.message || "Unknown error");
+              break;
+          }
+        } catch {
+          // Ignore parse errors
+        }
+      }
+    }
+  } finally {
+    callbacks.onThinkingVisible(false);
+  }
+  return delimiterParser.getFullResult();
+};
diff --git a/frontend/types/skill.ts b/frontend/types/skill.ts
index 8d3a14451..64b43c3c8 100644
--- a/frontend/types/skill.ts
+++ b/frontend/types/skill.ts
@@ -13,24 +13,16 @@ export const MAX_RECENT_SKILLS = 5;
  * Interactive skill creation steps (Chinese)
  */
 export const THINKING_STEPS_ZH = [
-  { step: 0, description: "等待大模型响应..." },
-  { step: 1, description: "加载内置技能提示词..." },
-  { step: 2, description: "加载技能配置..." },
-  { step: 3, description: "生成技能 SKILL.md ..." },
-  { step: 4, description: "保存中..." },
-  { step: 5, description: "已完成, 正在总结..." },
+  { step: 1, description: "生成技能内容中 ..." },
+  { step: 2, description: "总结中 ..." },
 ];
 
 /**
  * Interactive skill creation steps (English)
  */
 export const THINKING_STEPS_EN = [
-  { step: 0, description: "Waiting for model response..." },
-  { step: 1, description: "Loading built-in skills..." },
-  { step: 2, description: "Loading dynamic config..." },
-  { step: 3, description: "Generating skill SKILL.md ..." },
-  { step: 4, description: "Saving skill..." },
-  { step: 5, description: "Done, summarizing..." },
+  { step: 1, description: "Generating skill content..." },
+  { step: 2, description: "Summarizing..." },
 ];
 
 /**
@@ -61,6 +53,13 @@ export interface ChatMessage {
   timestamp: Date;
 }
 
+/**
+ * Result of parsing a skill draft from AI response
+ */
+export interface CreateSimpleSkillRequest {
+  user_request: string;
+}
+
 /**
  * Result of parsing a skill draft from AI response
  */
diff --git a/sdk/nexent/core/agents/agent_model.py b/sdk/nexent/core/agents/agent_model.py
index 4311f88fa..f7533f5b5 100644
--- a/sdk/nexent/core/agents/agent_model.py
+++ b/sdk/nexent/core/agents/agent_model.py
@@ -42,6 +42,7 @@ class AgentConfig(BaseModel):
     model_name: str = Field(description="Model alias from ModelConfig")
     provide_run_summary: Optional[bool] = Field(description="Whether to provide run summary to upper-level Agent", default=False)
     managed_agents: List[AgentConfig] = Field(description="Managed Agents", default=[])
+    instructions: Optional[str] = Field(description="Additional instructions to prepend to system prompt", default=None)
 
 
 class AgentHistory(BaseModel):
diff --git a/sdk/nexent/core/agents/nexent_agent.py b/sdk/nexent/core/agents/nexent_agent.py
index 20407bd9d..3878e05dd 100644
--- a/sdk/nexent/core/agents/nexent_agent.py
+++ b/sdk/nexent/core/agents/nexent_agent.py
@@ -239,6 +239,7 @@ def create_single_agent(self, agent_config: AgentConfig):
                 provide_run_summary=agent_config.provide_run_summary,
                 managed_agents=managed_agents_list,
                 additional_authorized_imports=["*"],
+                instructions=agent_config.instructions,
             )
             agent.stop_event = self.stop_event
 
diff --git a/sdk/nexent/core/tools/read_skill_config_tool.py b/sdk/nexent/core/tools/read_skill_config_tool.py
index 85e84a7e3..5f535bdc3 100644
--- a/sdk/nexent/core/tools/read_skill_config_tool.py
+++ b/sdk/nexent/core/tools/read_skill_config_tool.py
@@ -36,7 +36,7 @@ def execute(self, skill_name: str) -> str:
         """Read the config.yaml file from a skill directory.
 
         Args:
-            skill_name: Name of the skill (e.g., "simple-skill-creator")
+            skill_name: Name of the skill (e.g., "skill-creator")
 
         Returns:
             JSON-serialized dict of the config file, or an error message.
@@ -109,14 +109,14 @@ def read_skill_config(skill_name: str) -> str:
     needed for skill creation workflows.
 
     Args:
-        skill_name: Name of the skill whose config.yaml to read (e.g., "simple-skill-creator")
+        skill_name: Name of the skill whose config.yaml to read (e.g., "skill-creator")
 
     Returns:
         JSON string containing the parsed config.yaml contents as a dictionary.
 
     Examples:
-        # Read the config for simple-skill-creator to get temp_skill path
-        read_skill_config("simple-skill-creator")
+        # Read the config for skill-creator to get temp_skill path
+        read_skill_config("skill-creator")
         # Returns: {"path": {"temp_skill": "/mnt/nexent/skills/tmp/"}}
     """
     tool_instance = get_read_skill_config_tool()
diff --git a/sdk/nexent/core/tools/read_skill_md_tool.py b/sdk/nexent/core/tools/read_skill_md_tool.py
index a70a37699..858bfb5e9 100644
--- a/sdk/nexent/core/tools/read_skill_md_tool.py
+++ b/sdk/nexent/core/tools/read_skill_md_tool.py
@@ -94,9 +94,11 @@ def execute(self, skill_name: str, *additional_files: str) -> str:
         """Read skill markdown files.
 
         Args:
-            skill_name: Name of the skill
-            *additional_files: Optional additional files to read. If empty, reads SKILL.md.
-                If non-empty, only reads specified files (SKILL.md is NOT read by default
+            skill_name: Name of the skill. If empty, reads directly from local_skills_dir.
+            *additional_files: Optional additional files to read. If skill_name is empty,
+                this is treated as the file path directly. If skill_name is non-empty:
+                - If empty, reads SKILL.md by default.
+                - If non-empty, only reads specified files (SKILL.md is NOT read by default
                 unless explicitly included in the list).
 
         Returns:
@@ -104,6 +106,11 @@ def execute(self, skill_name: str, *additional_files: str) -> str:
         """
         try:
             manager = self._get_skill_manager()
+
+            # If skill_name is empty, read directly from local_skills_dir
+            if not skill_name:
+                return self._read_direct_file(additional_files)
+
             skill = manager.load_skill(skill_name)
 
             if not skill:
@@ -138,6 +145,39 @@ def execute(self, skill_name: str, *additional_files: str) -> str:
             logger.error(f"Failed to read skill markdown: {e}")
             return f"Error reading skill: {str(e)}"
 
+    def _read_direct_file(self, path_parts: tuple) -> str:
+        """Read a file directly from local_skills_dir.
+
+        Args:
+            path_parts: Tuple of path components. If empty, reads SKILL.md from root.
+
+        Returns:
+            File content or error message
+        """
+        if not self.local_skills_dir:
+            return "[Error] local_skills_dir is not configured"
+
+        if not path_parts:
+            # No path specified, try to read SKILL.md from root
+            file_path = "SKILL.md"
+        else:
+            file_path = "/".join(path_parts)
+
+        full_path = os.path.join(self.local_skills_dir, file_path)
+        if not os.path.exists(full_path):
+            return f"File not found: {file_path}"
+
+        try:
+            with open(full_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            # Strip frontmatter if it's a markdown file
+            if full_path.endswith('.md'):
+                content = self._strip_frontmatter(content)
+            return content
+        except Exception as e:
+            logger.error(f"Failed to read file {full_path}: {e}")
+            return f"[Error] Failed to read '{file_path}': {e}"
+
 
 # Global instance for tool execution
 _skill_md_tool = None
@@ -170,15 +210,18 @@ def read_skill_md(skill_name: str, additional_files: Optional[list[str]] = None)
     Reads skill files from the skill root directory. Behavior depends on whether
     additional_files is provided:
 
-    - If additional_files is empty/not provided: reads SKILL.md by default
-    - If additional_files is provided: only reads the specified files (SKILL.md is NOT
-      included by default unless explicitly listed in additional_files)
+    - If skill_name is empty: reads directly from local_skills_dir root.
+      additional_files is treated as the file path. If empty, reads SKILL.md from root.
+    - If skill_name is non-empty and additional_files is empty: reads SKILL.md by default
+    - If skill_name is non-empty and additional_files is provided: only reads the specified
+      files (SKILL.md is NOT included by default unless explicitly listed)
 
     Use this tool to load the execution guide for a skill when you need to understand
     how to handle a specific task that matches the skill's purpose.
 
     Args:
-        skill_name: Name of the skill (e.g., "code-reviewer")
+        skill_name: Name of the skill (e.g., "code-reviewer"). If empty, reads directly
+            from local_skills_dir root.
         additional_files: Optional list of specific files to read. When provided, only
             reads these files (SKILL.md is not automatically included). Examples:
             - ["examples.md"] - reads only examples.md
@@ -195,6 +238,10 @@ def read_skill_md(skill_name: str, additional_files: Optional[list[str]] = None)
         # Only reads specified files (SKILL.md NOT included by default)
         read_skill_md("code-reviewer", ["examples.md"])
         read_skill_md("code-reviewer", ["SKILL.md", "examples.md"])
+
+        # Read directly from local_skills_dir (skill_name is empty)
+        read_skill_md("")  # reads SKILL.md from root
+        read_skill_md("", ["my-file.txt"])  # reads my-file.txt from root
     """
     tool_instance = get_read_skill_md_tool()
     files = additional_files or []
diff --git a/sdk/nexent/core/tools/write_skill_file_tool.py b/sdk/nexent/core/tools/write_skill_file_tool.py
index 71861fe9c..0ba54c080 100644
--- a/sdk/nexent/core/tools/write_skill_file_tool.py
+++ b/sdk/nexent/core/tools/write_skill_file_tool.py
@@ -1,7 +1,7 @@
 """Skill file writing tool."""
 import logging
 import os
-from typing import Any, Dict, Optional
+from typing import Optional
 from smolagents import tool
 
 logger = logging.getLogger(__name__)
@@ -52,7 +52,8 @@ def execute(
         """Write a file to a skill directory in local storage.
 
         Args:
-            skill_name: Name of the skill (e.g., "code-reviewer")
+            skill_name: Name of the skill (e.g., "code-reviewer").
+                If empty, writes directly to local_skills_dir.
             file_path: Relative path within the skill directory. Use forward slashes.
                 Examples: "SKILL.md", "scripts/analyze.py", "examples.md"
             content: File content to write
@@ -60,8 +61,6 @@ def execute(
         Returns:
             Success or error message
         """
-        if not skill_name:
-            return "[Error] skill_name is required"
         if not file_path:
             return "[Error] file_path is required"
 
@@ -70,6 +69,10 @@ def execute(
             pass
         normalized_path = normalized_path.lstrip("/")
 
+        # If skill_name is empty, write directly to local_skills_dir
+        if not skill_name:
+            return self._write_direct_file(normalized_path, content)
+
         try:
             manager = self._get_skill_manager()
         except Exception as e:
@@ -84,6 +87,29 @@ def execute(
             logger.error(f"Failed to write skill file: {e}")
             return f"[Error] Failed to write file: {type(e).__name__}: {str(e)}"
 
+    def _write_direct_file(self, relative_path: str, content: str) -> str:
+        """Write a file directly to local_skills_dir.
+
+        Args:
+            relative_path: Path relative to local_skills_dir
+            content: File content
+
+        Returns:
+            Success or error message
+        """
+        if not self.local_skills_dir:
+            return "[Error] local_skills_dir is not configured"
+
+        file_path = os.path.join(self.local_skills_dir, *relative_path.split("/"))
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            return f"Successfully wrote '{relative_path}' to local_skills_dir"
+        except Exception as e:
+            return f"[Error] Failed to write '{relative_path}': {e}"
+
     def _write_skill_md(self, manager, skill_name: str, content: str) -> str:
         """Write SKILL.md using SkillManager.save_skill().
 
@@ -179,7 +205,8 @@ def write_skill_file(skill_name: str, file_path: str, content: str) -> str:
     agent's local_skills_dir configuration.
 
     Args:
-        skill_name: Name of the skill (e.g., "code-reviewer", "my-new-skill")
+        skill_name: Name of the skill (e.g., "code-reviewer", "my-new-skill").
+            If empty, writes directly to local_skills_dir.
         file_path: Relative path within the skill directory. Use forward slashes.
             - "SKILL.md" for the main skill file
             - "scripts/analyze.py" for Python scripts
@@ -199,6 +226,9 @@ def write_skill_file(skill_name: str, file_path: str, content: str) -> str:
 
         # Write supporting documentation
         write_skill_file("code-reviewer", "examples.md", "# Examples\\n...")
+
+        # Write directly to local_skills_dir (when skill_name is empty)
+        write_skill_file("", "my-file.txt", "file content")
     """
     tool_instance = get_write_skill_file_tool()
     return tool_instance.execute(skill_name, file_path, content)
diff --git a/sdk/nexent/skills/skill_loader.py b/sdk/nexent/skills/skill_loader.py
index b6aa5f6a0..734b83c24 100644
--- a/sdk/nexent/skills/skill_loader.py
+++ b/sdk/nexent/skills/skill_loader.py
@@ -40,13 +40,18 @@ def parse(cls, content: str, source_path: str = "") -> Dict[str, Any]:
         if not frontmatter:
             raise ValueError("SKILL.md must have YAML frontmatter")
 
-        # Fix YAML parsing to handle special characters in values
-        # Wrap unquoted values that may contain colons
-        frontmatter = cls._fix_yaml_frontmatter(frontmatter)
-
-        meta = yaml.safe_load(frontmatter)
+        # Try to parse with yaml.safe_load first
+        meta = None
+        try:
+            # Fix YAML parsing to handle special characters in values
+            frontmatter = cls._fix_yaml_frontmatter(frontmatter)
+            meta = yaml.safe_load(frontmatter)
+        except yaml.YAMLError as e:
+            logger.warning(f"YAML parse error, falling back to regex extraction: {e}")
+
+        # If yaml.safe_load failed or returned invalid result, use regex fallback
         if not isinstance(meta, dict):
-            raise ValueError("Invalid YAML frontmatter")
+            meta = cls._extract_frontmatter_by_regex(frontmatter)
 
         if "name" not in meta:
             raise ValueError("Skill must have 'name' field")
@@ -82,6 +87,12 @@ def _fix_yaml_frontmatter(cls, frontmatter: str) -> str:
                 fixed_lines.append(line)
                 continue
 
+            # Skip indented lines - these are content of multi-line values (block scalars)
+            # They should NOT be modified as they're part of block scalar values
+            if line.startswith(' ') or line.startswith('\t'):
+                fixed_lines.append(line)
+                continue
+
             # Check if this is a key-value line (contains ':' but not in quotes)
             if ':' in line:
                 # Find the first colon to identify the key
@@ -96,6 +107,11 @@ def _fix_yaml_frontmatter(cls, frontmatter: str) -> str:
                     fixed_lines.append(line)
                     continue
 
+                # Skip YAML list items (lines starting with '-')
+                if key == '' or line.strip().startswith('-'):
+                    fixed_lines.append(line)
+                    continue
+
                 # If value exists and is not quoted, we need to handle it
                 if value_part and not value_part.startswith('"') and not value_part.startswith("'"):
                     # Check if value contains unescaped colons that would break YAML
@@ -108,6 +124,70 @@ def _fix_yaml_frontmatter(cls, frontmatter: str) -> str:
 
         return '\n'.join(fixed_lines)
 
+    @classmethod
+    def _extract_frontmatter_by_regex(cls, frontmatter: str) -> Dict[str, Any]:
+        """Extract frontmatter fields using regex when YAML parsing fails.
+
+        This handles cases where YAML contains unexpected metadata or
+        formatting issues that break the parser.
+        """
+        result: Dict[str, Any] = {}
+
+        # Extract name field
+        name_match = re.search(r"^name:\s*(.+?)\s*$", frontmatter, re.MULTILINE)
+        if name_match:
+            result["name"] = name_match.group(1).strip().strip('"').strip("'")
+
+        # Extract description field
+        # Using non-greedy (.+?) will capture minimum, so "description: >" captures ">"
+        # Need to check if this is a block scalar first
+        desc_start_match = re.search(r"^description:\s*", frontmatter, re.MULTILINE)
+        if desc_start_match:
+            # Find the actual description line
+            lines = frontmatter.split('\n')
+            desc_line_idx = -1
+            for i, line in enumerate(lines):
+                if re.match(r"^description:\s*", line):
+                    desc_line_idx = i
+                    break
+
+            if desc_line_idx >= 0:
+                desc_line = lines[desc_line_idx]
+
+                # Check if it's a block scalar
+                has_block_scalar = re.match(r"^description:\s*[>|]", desc_line)
+                if has_block_scalar:
+                    # Collect all indented lines
+                    content_lines = []
+                    for line in lines[desc_line_idx + 1:]:
+                        # Empty line or non-indented line ends block
+                        if line.strip() == "":
+                            continue
+                        if not line.startswith(" ") and not line.startswith("\t"):
+                            break
+                        content_lines.append(line)
+                    description_text = " ".join([l.lstrip() for l in content_lines]).strip()
+                    result["description"] = description_text
+                else:
+                    # Single line value
+                    desc_match = re.search(r"^description:\s*(.+?)\s*$", desc_line)
+                    if desc_match:
+                        result["description"] = desc_match.group(1).strip().strip('"').strip("'")
+
+        # Extract tags field (YAML list format)
+        tags_match = re.search(r"^tags:\s*\[(.*?)\]\s*$", frontmatter, re.MULTILINE | re.DOTALL)
+        if tags_match:
+            tags_str = tags_match.group(1)
+            result["tags"] = [t.strip().strip('"').strip("'") for t in tags_str.split(",") if t.strip()]
+
+        # Extract allowed-tools field (YAML list format)
+        tools_match = re.search(r"^allowed-tools:\s*\[(.*?)\]\s*$", frontmatter, re.MULTILINE | re.DOTALL)
+        if tools_match:
+            tools_str = tools_match.group(1)
+            result["allowed-tools"] = [t.strip().strip('"').strip("'") for t in tools_str.split(",") if t.strip()]
+
+        return result
+
     @classmethod
     def _split_frontmatter(cls, content: str) -> Tuple[Optional[str], str]:
         """Split frontmatter and body."""
diff --git a/sdk/nexent/skills/skill_manager.py b/sdk/nexent/skills/skill_manager.py
index 08a69b98c..0cb2c9fdc 100644
--- a/sdk/nexent/skills/skill_manager.py
+++ b/sdk/nexent/skills/skill_manager.py
@@ -629,7 +629,7 @@ def escape_xml(s: str) -> str:
         lines.append("</skills>")
 
         return "\n".join(lines)
-    
+
 
     def load_skill_directory(self, name: str) -> Optional[Dict[str, Any]]:
         """Load entire skill directory including scripts.
diff --git a/test/backend/app/test_skill_app.py b/test/backend/app/test_skill_app.py
index 3dbe643a0..4e14923c8 100644
--- a/test/backend/app/test_skill_app.py
+++ b/test/backend/app/test_skill_app.py
@@ -51,6 +51,31 @@ class SkillInstanceInfoRequest(BaseModel):
 # Mock ToolConfig from agent_model
 nexent_core_agents_agent_model_mock.ToolConfig = type('ToolConfig', (), {})
 
+# ModelConfig mock that accepts kwargs
+class MockModelConfig:
+    def __init__(
+        self,
+        cite_name: str = None,
+        api_key: str = None,
+        model_name: str = None,
+        url: str = None,
+        temperature: float = None,
+        top_p: float = None,
+        ssl_verify: bool = None,
+        model_factory: str = None,
+        **kwargs
+    ):
+        self.cite_name = cite_name
+        self.api_key = api_key
+        self.model_name = model_name
+        self.url = url
+        self.temperature = temperature
+        self.top_p = top_p
+        self.ssl_verify = ssl_verify
+        self.model_factory = model_factory
+
+nexent_core_agents_agent_model_mock.ModelConfig = MockModelConfig
+
 # Set up storage mocks
 storage_client_mock = MagicMock()
 nexent_storage_storage_client_factory_mock.create_storage_client_from_config = MagicMock(return_value=storage_client_mock)
@@ -71,9 +96,12 @@ def __init__(self, local_skills_dir=None, **kwargs):
 consts_mock = types.ModuleType('consts')
 consts_exceptions_mock = types.ModuleType('consts.exceptions')
 consts_model_mock = types.ModuleType('consts.model')
+consts_const_mock = types.ModuleType('consts.const')
 sys.modules['consts'] = consts_mock
 sys.modules['consts.exceptions'] = consts_exceptions_mock
 sys.modules['consts.model'] = consts_model_mock
+sys.modules['consts.const'] = consts_const_mock
+consts_const_mock.MODEL_CONFIG_MAPPING = {"llm": "llm_model"}
 
 class SkillException(Exception):
     pass
@@ -100,9 +128,36 @@ def __init__(self):
 # Mock utils
 utils_mock = types.ModuleType('utils')
 utils_auth_utils_mock = types.ModuleType('utils.auth_utils')
+utils_config_utils_mock = types.ModuleType('utils.config_utils')
 sys.modules['utils'] = utils_mock
 sys.modules['utils.auth_utils'] = utils_auth_utils_mock
+sys.modules['utils.config_utils'] = utils_config_utils_mock
 utils_auth_utils_mock.get_current_user_id = MagicMock(return_value=("user123", "tenant123"))
+utils_auth_utils_mock.get_current_user_info = MagicMock(return_value=("user123", "tenant123", "zh"))
+utils_config_utils_mock.tenant_config_manager = MagicMock()
+utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+# Mock utils.prompt_template_utils
+utils_prompt_template_utils_mock = types.ModuleType('utils.prompt_template_utils')
+sys.modules['utils.prompt_template_utils'] = utils_prompt_template_utils_mock
+utils_prompt_template_utils_mock.get_skill_creation_simple_prompt_template = MagicMock(return_value={
+    "system_prompt": "You are a skill creator",
+    "user_prompt": "Create a skill"
+})
+
+# Mock agents module
+agents_mock = types.ModuleType('agents')
+agents_skill_creation_agent_mock = types.ModuleType('agents.skill_creation_agent')
+sys.modules['agents'] = agents_mock
+sys.modules['agents.skill_creation_agent'] = agents_skill_creation_agent_mock
+agents_skill_creation_agent_mock.create_simple_skill_from_request = MagicMock()
+
+# Mock nexent.core.utils
+nexent_core_utils_mock = types.ModuleType('nexent.core.utils')
+nexent_core_utils_observer_mock = types.ModuleType('nexent.core.utils.observer')
+sys.modules['nexent.core.utils'] = nexent_core_utils_mock
+sys.modules['nexent.core.utils.observer'] = nexent_core_utils_observer_mock
+nexent_core_utils_observer_mock.MessageObserver = type('MessageObserver', (), {})
 
 # Mock database
 database_mock = types.ModuleType('database')
@@ -1791,203 +1846,6 @@ def test_create_skill_unexpected_error(self, mocker):
                 assert response.status_code == 500
 
 
-# ===== Delete Skill File Endpoint Tests =====
-class TestDeleteSkillFileEndpoint:
-    """Test DELETE /skills/{skill_name}/files/{file_path} endpoint."""
-
-    def test_delete_skill_file_success(self, mocker):
-        """Test successful deletion of skill file."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                with patch('os.path.exists', return_value=True):
-                    with patch('os.remove'):
-                        mock_auth.return_value = ("user123", "tenant123")
-                        mock_service = MagicMock()
-                        mock_service_class.return_value = mock_service
-                        mock_service.get_skill_file_content.return_value = "temp_filename: temp.yaml"
-                        mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                        app = FastAPI()
-                        app.include_router(skill_app.router)
-                        client = TestClient(app)
-
-                        response = client.delete(
-                            "/skills/test_skill/files/temp.yaml",
-                            headers={"Authorization": "Bearer token123"}
-                        )
-
-                        assert response.status_code == 200
-                        assert "deleted successfully" in response.json()["message"]
-
-    def test_delete_skill_file_config_not_found(self, mocker):
-        """Test delete file when config.yaml not found."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.return_value = None
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/temp.yaml",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 404
-
-    def test_delete_skill_file_invalid_filename(self, mocker):
-        """Test delete file with filename not matching temp_filename."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.return_value = "temp_filename: actual_temp.yaml"
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/wrong_file.yaml",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 400
-
-    def test_delete_skill_file_not_exists(self, mocker):
-        """Test delete file that doesn't exist on disk."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                with patch('os.path.exists', return_value=False):
-                    mock_auth.return_value = ("user123", "tenant123")
-                    mock_service = MagicMock()
-                    mock_service_class.return_value = mock_service
-                    mock_service.get_skill_file_content.return_value = "temp_filename: temp.yaml"
-                    mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                    app = FastAPI()
-                    app.include_router(skill_app.router)
-                    client = TestClient(app)
-
-                    response = client.delete(
-                        "/skills/test_skill/files/temp.yaml",
-                        headers={"Authorization": "Bearer token123"}
-                    )
-
-                    assert response.status_code == 404
-
-    def test_delete_skill_file_unauthorized(self, mocker):
-        """Test delete file without authorization."""
-        from backend.apps.skill_app import UnauthorizedError
-        with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-            mock_auth.side_effect = UnauthorizedError("No token")
-
-            app = FastAPI()
-            app.include_router(skill_app.router)
-            client = TestClient(app)
-
-            response = client.delete(
-                "/skills/test_skill/files/temp.yaml",
-                headers={"Authorization": "Bearer invalid"}
-            )
-
-            assert response.status_code == 401
-
-    def test_delete_skill_file_unexpected_error(self, mocker):
-        """Test delete file with unexpected error."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.side_effect = Exception("Unexpected error")
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/temp.yaml",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 500
-
-    def test_delete_skill_file_path_traversal_dotdot(self, mocker):
-        """Test path traversal with ../ is blocked."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.return_value = "temp_filename: ../../etc/passwd"
-                mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/..%2F..%2Fetc%2Fpasswd",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 400
-                assert "path traversal" in response.json()["detail"].lower()
-
-    def test_delete_skill_file_path_traversal_absolute(self, mocker):
-        """Test path traversal with absolute path is blocked."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.return_value = "temp_filename: /etc/passwd"
-                mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/%2Fetc%2Fpasswd",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 400
-                assert "path traversal" in response.json()["detail"].lower()
-
-    def test_delete_skill_file_path_traversal_with_encoded_separators(self, mocker):
-        """Test path traversal with encoded path separators is blocked."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                # The temp_filename must match what comes after /files/ in the URL
-                # FastAPI decodes %2F to /, so the actual file_path will be ../../windows/system32
-                mock_service.get_skill_file_content.return_value = "temp_filename: ../../windows/system32"
-                mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                # URL encoded ../../
-                response = client.delete(
-                    "/skills/test_skill/files/..%252F..%252Fwindows%252Fsystem32",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 400
-                assert "path traversal" in response.json()["detail"].lower()
-
-
 # ===== Update Skill Instance Endpoint Error Handling Tests =====
 class TestUpdateSkillInstanceEndpointErrorHandling:
     """Error handling tests for POST /skills/instance/update endpoint."""
@@ -2167,5 +2025,1303 @@ def test_update_skill_with_tool_ids_only(self, mocker):
                 assert response.status_code == 200
 
 
+# ===== Create Simple Skill Endpoint Tests =====
+class TestCreateSimpleSkillEndpoint:
+    """Test POST /skills/create-simple endpoint (SSE streaming)."""
+
+    def test_create_simple_skill_success(self, mocker):
+        """Test successful simple skill creation with streaming response."""
+        # Mock dependencies
+        mock_user_info = patch('backend.apps.skill_app.get_current_user_info')
+        mock_user_info.return_value = ("user123", "tenant123", "zh")
+        mock_user_info.start()
+
+        mock_template = patch('backend.apps.skill_app.get_skill_creation_simple_prompt_template')
+        mock_template.return_value = {
+            "system_prompt": "You are a skill creator",
+            "user_prompt": "Create a skill"
+        }
+        mock_template.start()
+
+        mock_observer = patch('backend.apps.skill_app.MessageObserver')
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message.return_value = []
+        mock_observer_instance.get_final_answer.return_value = "<SKILL>\n# Test Skill\n</SKILL>"
+        mock_observer.return_value = mock_observer_instance
+        mock_observer.start()
+
+        mock_service = patch('backend.apps.skill_app.SkillService')
+        mock_service_instance = MagicMock()
+        mock_service_instance.skill_manager = MagicMock()
+        mock_service_instance.skill_manager.local_skills_dir = "/tmp/skills"
+        mock_service.return_value = mock_service_instance
+        mock_service.start()
+
+        mock_create = patch('backend.apps.skill_app.create_simple_skill_from_request')
+        mock_create.start()
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a greeting skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+
+        mock_user_info.stop()
+        mock_template.stop()
+        mock_observer.stop()
+        mock_service.stop()
+        mock_create.stop()
+
+    def test_create_simple_skill_with_streaming_messages(self, mocker):
+        """Test streaming messages are properly sent."""
+        # Mock dependencies
+        mock_user_info = patch('backend.apps.skill_app.get_current_user_info')
+        mock_user_info.return_value = ("user123", "tenant123", "zh")
+        mock_user_info.start()
+
+        mock_template = patch('backend.apps.skill_app.get_skill_creation_simple_prompt_template')
+        mock_template.return_value = {
+            "system_prompt": "You are a skill creator",
+            "user_prompt": "Create a skill"
+        }
+        mock_template.start()
+
+        mock_observer = patch('backend.apps.skill_app.MessageObserver')
+        mock_observer_instance = MagicMock()
+        # Return cached messages that will be streamed
+        cached_messages = [
+            '{"type": "step_count", "content": "1"}',
+            '{"type": "model_output_thinking", "content": "Thinking..."}',
+            '{"type": "tool", "content": "Tool executed"}',
+            '{"type": "final_answer", "content": "<SKILL>Content</SKILL>"}'
+        ]
+        mock_observer_instance.get_cached_message.side_effect = [
+            cached_messages[:2],
+            cached_messages[2:],
+            []
+        ]
+        mock_observer_instance.get_final_answer.return_value = "<SKILL>Final Content</SKILL>"
+        mock_observer.return_value = mock_observer_instance
+        mock_observer.start()
+
+        mock_service = patch('backend.apps.skill_app.SkillService')
+        mock_service_instance = MagicMock()
+        mock_service_instance.skill_manager = MagicMock()
+        mock_service_instance.skill_manager.local_skills_dir = "/tmp/skills"
+        mock_service.return_value = mock_service_instance
+        mock_service.start()
+
+        mock_create = patch('backend.apps.skill_app.create_simple_skill_from_request')
+        mock_create.start()
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a test skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+
+        mock_user_info.stop()
+        mock_template.stop()
+        mock_observer.stop()
+        mock_service.stop()
+        mock_create.stop()
+
+    def test_create_simple_skill_unauthorized(self, mocker):
+        """Test create simple skill without authorization - error is sent via SSE stream."""
+        from backend.apps.skill_app import UnauthorizedError
+
+        mocker.patch(
+            'backend.apps.skill_app.get_current_user_info',
+            side_effect=UnauthorizedError("No token")
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a skill"},
+            headers={"Authorization": "Bearer invalid"}
+        )
+
+        # Exception is caught in generate() and returned as 200 with SSE error event
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+        # SSE stream contains error event
+        assert b'"type": "error"' in response.content
+        assert b'No token' in response.content
+
+
+# ===== Build Model Config Tests =====
+class TestBuildModelConfigFromTenant:
+    """Test _build_model_config_from_tenant function."""
+
+    def test_build_model_config_success(self, mocker):
+        """Test successful ModelConfig building."""
+        # Set up mocks for the config utilities
+        mock_config_manager_instance = MagicMock()
+        mock_config_manager_instance.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+
+        utils_config_utils_mock.tenant_config_manager = mock_config_manager_instance
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4-0613")
+
+        mocker.patch.object(
+            utils_config_utils_mock,
+            'tenant_config_manager',
+            mock_config_manager_instance
+        )
+        mocker.patch.object(
+            utils_config_utils_mock,
+            'get_model_name_from_config',
+            return_value="gpt-4-0613"
+        )
+
+        result = skill_app._build_model_config_from_tenant("tenant123")
+
+        assert result.cite_name == "gpt-4"
+        assert result.api_key == "test-key"
+        assert result.url == "https://api.openai.com"
+        assert result.model_factory == "openai"
+
+    def test_build_model_config_no_llm_config(self, mocker):
+        """Test ValueError when no LLM model configured for tenant."""
+        mock_config_manager_instance = MagicMock()
+        mock_config_manager_instance.get_model_config.return_value = None
+
+        mocker.patch.object(
+            utils_config_utils_mock,
+            'tenant_config_manager',
+            mock_config_manager_instance
+        )
+
+        with pytest.raises(ValueError, match="No LLM model configured for tenant"):
+            skill_app._build_model_config_from_tenant("tenant123")
+
+
+# ===== Stream Content Types Tests =====
+class TestStreamContentTypes:
+    """Test different content types in streaming response."""
+
+    def test_stream_model_output_code(self, mocker):
+        """Test streaming model_output_code content."""
+        mock_user_info = patch('backend.apps.skill_app.get_current_user_info')
+        mock_user_info.return_value = ("user123", "tenant123", "zh")
+        mock_user_info.start()
+
+        mock_template = patch('backend.apps.skill_app.get_skill_creation_simple_prompt_template')
+        mock_template.return_value = {
+            "system_prompt": "You are a skill creator",
+            "user_prompt": "Create a skill"
+        }
+        mock_template.start()
+
+        mock_observer = patch('backend.apps.skill_app.MessageObserver')
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message.side_effect = [
+            ['{"type": "model_output_code", "content": "def hello(): pass"}'],
+            []
+        ]
+        mock_observer_instance.get_final_answer.return_value = None
+        mock_observer.return_value = mock_observer_instance
+        mock_observer.start()
+
+        mock_service = patch('backend.apps.skill_app.SkillService')
+        mock_service_instance = MagicMock()
+        mock_service_instance.skill_manager = MagicMock()
+        mock_service_instance.skill_manager.local_skills_dir = "/tmp/skills"
+        mock_service.return_value = mock_service_instance
+        mock_service.start()
+
+        mock_create = patch('backend.apps.skill_app.create_simple_skill_from_request')
+        mock_create.start()
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a code skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+
+        mock_user_info.stop()
+        mock_template.stop()
+        mock_observer.stop()
+        mock_service.stop()
+        mock_create.stop()
+
+    def test_stream_deep_thinking(self, mocker):
+        """Test streaming model_output_deep_thinking content."""
+        mock_user_info = patch('backend.apps.skill_app.get_current_user_info')
+        mock_user_info.return_value = ("user123", "tenant123", "zh")
+        mock_user_info.start()
+
+        mock_template = patch('backend.apps.skill_app.get_skill_creation_simple_prompt_template')
+        mock_template.return_value = {
+            "system_prompt": "You are a skill creator",
+            "user_prompt": "Create a skill"
+        }
+        mock_template.start()
+
+        mock_observer = patch('backend.apps.skill_app.MessageObserver')
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message.side_effect = [
+            ['{"type": "model_output_deep_thinking", "content": "Deep thought process"}'],
+            []
+        ]
+        mock_observer_instance.get_final_answer.return_value = None
+        mock_observer.return_value = mock_observer_instance
+        mock_observer.start()
+
+        mock_service = patch('backend.apps.skill_app.SkillService')
+        mock_service_instance = MagicMock()
+        mock_service_instance.skill_manager = MagicMock()
+        mock_service_instance.skill_manager.local_skills_dir = "/tmp/skills"
+        mock_service.return_value = mock_service_instance
+        mock_service.start()
+
+        mock_create = patch('backend.apps.skill_app.create_simple_skill_from_request')
+        mock_create.start()
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a thinking skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+
+        mock_user_info.stop()
+        mock_template.stop()
+        mock_observer.stop()
+        mock_service.stop()
+        mock_create.stop()
+
+    def test_stream_execution_logs(self, mocker):
+        """Test streaming execution_logs content."""
+        # Rely on module-level mocks for basic test
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a logging skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+
+
+# ===== Streaming Flow Tests =====
+class TestStreamingFlow:
+    """Test the complete streaming flow including thread polling and final results."""
+
+    def _setup_streaming_mocks(self, mocker, cached_messages_list, final_answer, skill_service_local_dir=None):
+        """Helper to set up comprehensive mocks for streaming tests."""
+        # Set up config utils mocks
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        # Create mock observer that returns messages on each call
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=cached_messages_list)
+        mock_observer_instance.get_final_answer = MagicMock(return_value=final_answer)
+
+        # Create mock MessageObserver class
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        # Create mock SkillService
+        mock_skill_service_instance = MagicMock()
+        mock_skill_manager = MagicMock()
+        mock_skill_manager.local_skills_dir = skill_service_local_dir
+        mock_skill_service_instance.skill_manager = mock_skill_manager
+        mocker.patch(
+            'backend.apps.skill_app.SkillService',
+            return_value=mock_skill_service_instance
+        )
+
+        # Mock create_simple_skill_from_request to be a no-op (background task)
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        return mock_observer_instance, mock_skill_service_instance
+
+    def test_streaming_with_step_count_messages(self, mocker):
+        """Test streaming step_count messages during polling (lines 557-558, 580-581)."""
+        cached_messages = [
+            ['{"type": "step_count", "content": "1"}'],
+            ['{"type": "step_count", "content": "2"}'],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer=None,
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with steps"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+        assert mock_observer.get_cached_message.call_count >= 1
+
+    def test_streaming_with_skill_content_messages(self, mocker):
+        """Test streaming skill_content messages (thinking, code, etc.) during polling (lines 560-561, 582-583)."""
+        cached_messages = [
+            ['{"type": "model_output_thinking", "content": "Thinking about the skill..."}'],
+            ['{"type": "model_output_code", "content": "# SKILL.md\\ncontent"}'],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer=None,
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with content"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "skill_content"' in response.content
+        assert b'Thinking about the skill' in response.content
+
+    def test_streaming_with_final_answer_during_polling(self, mocker):
+        """Test streaming final_answer during polling phase (lines 563-564, 584-585)."""
+        cached_messages = [
+            [],
+            ['{"type": "final_answer", "content": "Partial answer during poll"}'],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>\nFinal Answer</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with final answer"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "final_answer"' in response.content
+        assert b'Final Answer' in response.content
+
+    def test_streaming_remaining_messages_after_thread(self, mocker):
+        """Test streaming remaining messages after thread completes (lines 572-587)."""
+        # Note: Due to mock behavior, thread completes immediately without producing messages.
+        # This test verifies the streaming endpoint works correctly even without messages.
+        cached_messages = [
+            [],  # During polling
+            [],  # After thread
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>Final Skill</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with remaining"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        # Should still work and send done signal
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_final_result_from_observer(self, mocker):
+        """Test streaming final result from observer after thread completes (lines 590-592)."""
+        cached_messages = [
+            [],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>\n# Complete Skill Content\nThis is the final result.</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create complete skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'Complete Skill Content' in response.content
+        assert b'"type": "final_answer"' in response.content
+
+    def test_streaming_done_signal(self, mocker):
+        """Test streaming done signal at the end (line 595)."""
+        cached_messages = [
+            [],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer=None,
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill and finish"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_with_empty_final_answer(self, mocker):
+        """Test streaming when final_answer is None/empty (lines 591-592)."""
+        cached_messages = [
+            [],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer=None,
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with no final answer"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+        assert response.content.count(b'"type": "final_answer"') <= 1
+
+    def test_streaming_with_empty_local_skills_dir(self, mocker):
+        """Test streaming with None local_skills_dir (line 530)."""
+        cached_messages = [
+            [],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>Skill</SKILL>",
+            skill_service_local_dir=None
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with no skills dir"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_with_tool_messages(self, mocker):
+        """Test streaming tool messages (lines 560-561, 582-583)."""
+        cached_messages = [
+            ['{"type": "tool", "content": "Writing file: SKILL.md"}'],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>\n# Tool Result</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill using tools"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "skill_content"' in response.content
+        assert b'Writing file' in response.content
+
+    def test_streaming_with_mixed_message_types(self, mocker):
+        """Test streaming with mixed message types across polling and remaining phases."""
+        cached_messages = [
+            ['{"type": "step_count", "content": "1"}', '{"type": "model_output_thinking", "content": "Thinking"}'],
+            ['{"type": "tool", "content": "Tool executed"}', '{"type": "final_answer", "content": "Partial"}'],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>\nFinal Complete Skill</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create complex skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+        assert b'"type": "skill_content"' in response.content
+        assert b'"type": "final_answer"' in response.content
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_with_json_decode_error_in_message(self, mocker):
+        """Test handling of invalid JSON in cached messages (lines 565-566, 586-587)."""
+        cached_messages = [
+            ['{"type": "step_count", "content": "1"}', 'invalid json {{{', '{"type": "model_output_thinking", "content": "Valid"}'],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>Skill</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with bad json"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_with_non_string_message(self, mocker):
+        """Test handling of non-string messages in cached messages (lines 550, 574)."""
+        cached_messages = [
+            ['{"type": "step_count", "content": "1"}', 123, None, '{"type": "model_output_thinking", "content": "Valid"}'],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>Skill</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with weird messages"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+
+
+# ===== Thread Polling Tests =====
+class TestThreadPolling:
+    """Test thread polling behavior and message streaming during polling phase."""
+
+    def _setup_thread_polling_mocks(self, mocker, observer_messages_per_poll, skill_service_local_dir="/tmp/skills"):
+        """Set up mocks for thread polling tests.
+
+        Args:
+            observer_messages_per_poll: List of message lists, each returned on successive calls to get_cached_message
+        """
+        # Set up config utils mocks
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        # Track which call we're on
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages_per_poll):
+                return observer_messages_per_poll[idx]
+            return []
+
+        # Create mock observer
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value=None)
+
+        # Track thread state to control polling behavior
+        thread_polled = [False]
+
+        def create_mock_thread():
+            """Create a mock thread that stays alive for multiple polls."""
+            import time
+            poll_count = [0]
+            max_polls = len(observer_messages_per_poll)
+
+            class MockThread:
+                def is_alive(self):
+                    poll_count[0] += 1
+                    # Stay alive for the first few polls, then die
+                    if poll_count[0] < max_polls:
+                        thread_polled[0] = True
+                        return True
+                    return False
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        return mock_observer_instance, thread_polled, create_mock_thread
+
+    def test_polling_loop_executes_multiple_times(self, mocker):
+        """Test that the polling loop executes multiple times while thread is alive (lines 547-567)."""
+        # Set up 3 polls worth of messages
+        observer_messages = [
+            ['{"type": "step_count", "content": "1"}'],
+            ['{"type": "model_output_thinking", "content": "Thinking..."}'],
+            [],  # Thread dies after this poll
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value=None)
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with polling"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        # Verify observer was polled multiple times
+        assert mock_observer_instance.get_cached_message.call_count >= 2
+        assert b'"type": "step_count"' in response.content
+
+    def test_polling_with_step_count_streaming(self, mocker):
+        """Test step_count messages are streamed during polling (lines 557-558)."""
+        observer_messages = [
+            ['{"type": "step_count", "content": "1"}', '{"type": "step_count", "content": "2"}'],
+            [],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value=None)
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with steps"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+
+    def test_polling_with_skill_content_streaming(self, mocker):
+        """Test skill_content messages are streamed during polling (lines 560-561)."""
+        observer_messages = [
+            ['{"type": "model_output_thinking", "content": "Thinking step 1"}', '{"type": "model_output_code", "content": "Code block"}'],
+            [],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Final</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with content"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "skill_content"' in response.content
+        assert b'Thinking step 1' in response.content
+
+    def test_polling_with_final_answer_during_polling(self, mocker):
+        """Test final_answer messages during polling are streamed (lines 563-564)."""
+        # final_answer must arrive while thread is still alive (not in remaining messages)
+        observer_messages = [
+            ['{"type": "final_answer", "content": "Partial answer in poll"}'],  # Thread is alive
+            [],  # Thread dies after this poll
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Final</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        # Thread stays alive for max_polls-1 polls, dies on the last one
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    # Stay alive while we have more polls to do
+                    if poll_count[0] <= max_polls - 1:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with partial answer"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        # Verify final_answer was streamed during polling
+        assert b'"type": "final_answer"' in response.content
+        assert b'Partial answer in poll' in response.content
+
+    def test_polling_skips_non_string_messages(self, mocker):
+        """Test that non-string messages are skipped (line 550)."""
+        observer_messages = [
+            [123, None, '{"type": "step_count", "content": "1"}'],
+            [],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Skill</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with mixed messages"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        # Should handle gracefully and only stream the valid string message
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+
+    def test_polling_handles_json_decode_error(self, mocker):
+        """Test that JSON decode errors are caught and ignored (lines 565-566)."""
+        observer_messages = [
+            ['{"invalid json', '{"type": "step_count", "content": "1"}'],
+            [],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Skill</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with bad json"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        # Should handle gracefully and continue streaming valid messages
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+
+    def test_remaining_messages_after_thread_with_step_count(self, mocker):
+        """Test remaining messages with step_count after thread completes (lines 580-581, 584-585)."""
+        observer_messages = [
+            [],
+            ['{"type": "step_count", "content": "Final step"}', '{"type": "final_answer", "content": "Partial"}'],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Final Complete</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with remaining"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        # Should have streamed step_count from remaining messages
+        assert b'"type": "step_count"' in response.content
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])
diff --git a/test/backend/utils/test_prompt_template_utils.py b/test/backend/utils/test_prompt_template_utils.py
index e657b3a06..c89c41f42 100644
--- a/test/backend/utils/test_prompt_template_utils.py
+++ b/test/backend/utils/test_prompt_template_utils.py
@@ -1,7 +1,15 @@
 import pytest
 from unittest.mock import mock_open
 
-from utils.prompt_template_utils import get_agent_prompt_template, get_prompt_generate_prompt_template
+from utils.prompt_template_utils import (
+    get_agent_prompt_template,
+    get_prompt_generate_prompt_template,
+    get_generate_title_prompt_template,
+    get_document_summary_prompt_template,
+    get_cluster_summary_reduce_prompt_template,
+    get_skill_creation_simple_prompt_template,
+    get_prompt_template,
+)
 
 
 class TestPromptTemplateUtils:
@@ -127,5 +135,323 @@ def test_get_prompt_generate_prompt_template_default_language(self, mocker):
         assert result == {"test": "data"}
 
 
-if __name__ == '__main__':
-    pytest.main()
+class TestGetPromptTemplate:
+    """Test cases for get_prompt_template function"""
+
+    def test_get_prompt_template_unsupported_type(self, mocker):
+        """Test get_prompt_template with unsupported template type raises ValueError"""
+        with pytest.raises(ValueError) as excinfo:
+            get_prompt_template(template_type='unsupported_type', language='zh')
+
+        assert "Unsupported template type" in str(excinfo.value)
+
+    def test_get_prompt_template_file_not_found(self, mocker):
+        """Test get_prompt_template raises FileNotFoundError when file is missing"""
+        mocker.patch('builtins.open', side_effect=FileNotFoundError("File not found"))
+
+        with pytest.raises(FileNotFoundError):
+            get_prompt_template(template_type='prompt_generate', language='zh')
+
+    def test_get_prompt_template_prompt_generate_zh(self, mocker):
+        """Test get_prompt_template for prompt_generate in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system: "test"'))
+
+        mock_yaml_load.return_value = {"system": "test"}
+        result = get_prompt_template(template_type='prompt_generate', language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/prompt_generate_zh.yaml' in call_args[0].replace('\\', '/')
+        mock_yaml_load.assert_called_once()
+        assert result == {"system": "test"}
+
+    def test_get_prompt_template_prompt_generate_en(self, mocker):
+        """Test get_prompt_template for prompt_generate in English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system: "test"'))
+
+        mock_yaml_load.return_value = {"system": "test"}
+        result = get_prompt_template(template_type='prompt_generate', language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/prompt_generate_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system": "test"}
+
+    def test_get_prompt_template_agent_manager_zh(self, mocker):
+        """Test get_prompt_template for agent with is_manager=True in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system: "manager"'))
+
+        mock_yaml_load.return_value = {"system": "manager"}
+        result = get_prompt_template(template_type='agent', language='zh', is_manager=True)
+
+        call_args = mock_file.call_args[0]
+        assert 'manager_system_prompt_template_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system": "manager"}
+
+    def test_get_prompt_template_agent_managed_zh(self, mocker):
+        """Test get_prompt_template for agent with is_manager=False in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system: "managed"'))
+
+        mock_yaml_load.return_value = {"system": "managed"}
+        result = get_prompt_template(template_type='agent', language='zh', is_manager=False)
+
+        call_args = mock_file.call_args[0]
+        assert 'managed_system_prompt_template_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system": "managed"}
+
+    def test_get_prompt_template_generate_title_zh(self, mocker):
+        """Test get_prompt_template for generate_title in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='title: "test"'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_prompt_template(template_type='generate_title', language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_prompt_template_generate_title_en(self, mocker):
+        """Test get_prompt_template for generate_title in English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='title: "test"'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_prompt_template(template_type='generate_title', language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_prompt_template_document_summary_zh(self, mocker):
+        """Test get_prompt_template for document_summary in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='summary: "test"'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_prompt_template(template_type='document_summary', language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_prompt_template_document_summary_en(self, mocker):
+        """Test get_prompt_template for document_summary in English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='summary: "test"'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_prompt_template(template_type='document_summary', language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_prompt_template_cluster_summary_reduce_zh(self, mocker):
+        """Test get_prompt_template for cluster_summary_reduce in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='reduce: "test"'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_prompt_template(template_type='cluster_summary_reduce', language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+    def test_get_prompt_template_cluster_summary_reduce_en(self, mocker):
+        """Test get_prompt_template for cluster_summary_reduce in English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='reduce: "test"'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_prompt_template(template_type='cluster_summary_reduce', language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+
+class TestWrapperFunctions:
+    """Test cases for wrapper functions"""
+
+    def test_get_generate_title_prompt_template_zh(self, mocker):
+        """Test get_generate_title_prompt_template for Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"title": "test"}'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_generate_title_prompt_template(language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_generate_title_prompt_template_en(self, mocker):
+        """Test get_generate_title_prompt_template for English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"title": "test"}'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_generate_title_prompt_template(language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_generate_title_prompt_template_default(self, mocker):
+        """Test get_generate_title_prompt_template with default language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"title": "test"}'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_generate_title_prompt_template()
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_document_summary_prompt_template_zh(self, mocker):
+        """Test get_document_summary_prompt_template for Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"summary": "test"}'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_document_summary_prompt_template(language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_document_summary_prompt_template_en(self, mocker):
+        """Test get_document_summary_prompt_template for English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"summary": "test"}'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_document_summary_prompt_template(language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_document_summary_prompt_template_default(self, mocker):
+        """Test get_document_summary_prompt_template with default language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"summary": "test"}'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_document_summary_prompt_template()
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_cluster_summary_reduce_prompt_template_zh(self, mocker):
+        """Test get_cluster_summary_reduce_prompt_template for Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"reduce": "test"}'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_cluster_summary_reduce_prompt_template(language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+    def test_get_cluster_summary_reduce_prompt_template_en(self, mocker):
+        """Test get_cluster_summary_reduce_prompt_template for English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"reduce": "test"}'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_cluster_summary_reduce_prompt_template(language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+    def test_get_cluster_summary_reduce_prompt_template_default(self, mocker):
+        """Test get_cluster_summary_reduce_prompt_template with default language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"reduce": "test"}'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_cluster_summary_reduce_prompt_template()
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+
+class TestSkillCreationSimplePromptTemplate:
+    """Test cases for get_skill_creation_simple_prompt_template function"""
+
+    def test_get_skill_creation_simple_prompt_template_zh(self, mocker):
+        """Test get_skill_creation_simple_prompt_template for Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system_prompt: "sys"\nuser_prompt: "user"'))
+
+        mock_yaml_load.return_value = {"system_prompt": "sys", "user_prompt": "user"}
+        result = get_skill_creation_simple_prompt_template(language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'skill_creation_simple_zh.yaml' in call_args[0].replace('\\', '/')
+        mock_yaml_load.assert_called_once()
+        assert result == {"system_prompt": "sys", "user_prompt": "user"}
+
+    def test_get_skill_creation_simple_prompt_template_en(self, mocker):
+        """Test get_skill_creation_simple_prompt_template for English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system_prompt: "sys"\nuser_prompt: "user"'))
+
+        mock_yaml_load.return_value = {"system_prompt": "sys", "user_prompt": "user"}
+        result = get_skill_creation_simple_prompt_template(language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'skill_creation_simple_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system_prompt": "sys", "user_prompt": "user"}
+
+    def test_get_skill_creation_simple_prompt_template_default(self, mocker):
+        """Test get_skill_creation_simple_prompt_template with default language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system_prompt: "sys"\nuser_prompt: "user"'))
+
+        mock_yaml_load.return_value = {"system_prompt": "sys", "user_prompt": "user"}
+        result = get_skill_creation_simple_prompt_template()
+
+        call_args = mock_file.call_args[0]
+        assert 'skill_creation_simple_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system_prompt": "sys", "user_prompt": "user"}
+
+    def test_get_skill_creation_simple_prompt_template_fallback(self, mocker):
+        """Test get_skill_creation_simple_prompt_template falls back to Chinese for unknown language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system_prompt: "sys"\nuser_prompt: "user"'))
+
+        mock_yaml_load.return_value = {"system_prompt": "sys", "user_prompt": "user"}
+        result = get_skill_creation_simple_prompt_template(language='unknown')
+
+        call_args = mock_file.call_args[0]
+        assert 'skill_creation_simple_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system_prompt": "sys", "user_prompt": "user"}
+
+    def test_get_skill_creation_simple_prompt_template_missing_keys(self, mocker):
+        """Test get_skill_creation_simple_prompt_template handles missing keys in YAML"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='other: "data"'))
+
+        mock_yaml_load.return_value = {"other": "data"}
+        result = get_skill_creation_simple_prompt_template(language='zh')
+
+        # Missing keys should default to empty strings
+        assert result == {"system_prompt": "", "user_prompt": ""}
+
+    def test_get_skill_creation_simple_prompt_template_file_not_found(self, mocker):
+        """Test get_skill_creation_simple_prompt_template raises FileNotFoundError when file is missing"""
+        mocker.patch('builtins.open', side_effect=FileNotFoundError("File not found"))
+
+        with pytest.raises(FileNotFoundError):
+            get_skill_creation_simple_prompt_template(language='zh')
diff --git a/test/sdk/core/tools/test_read_skill_md_tool.py b/test/sdk/core/tools/test_read_skill_md_tool.py
index 9a49b861c..bdffa0e69 100644
--- a/test/sdk/core/tools/test_read_skill_md_tool.py
+++ b/test/sdk/core/tools/test_read_skill_md_tool.py
@@ -497,3 +497,124 @@ def test_get_tool_reuses_with_different_params(self):
         # Should have the original params from first call
         assert tool1.local_skills_dir == "/path/one"
         assert tool1.agent_id == 1
+
+
+class TestReadDirectFile:
+    """Test _read_direct_file method for empty skill_name."""
+
+    def test_read_direct_file_no_local_dir(self, read_skill_md_tool):
+        """Test _read_direct_file without local_skills_dir returns error."""
+        read_skill_md_tool.local_skills_dir = None
+        result = read_skill_md_tool._read_direct_file(())
+        assert "[Error]" in result
+        assert "local_skills_dir" in result.lower()
+
+    def test_read_direct_file_default_skill_md(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file reads SKILL.md when no path specified."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create SKILL.md in root
+        skill_md = """---
+name: root-skill
+description: Root skill
+---
+# Root Content
+"""
+        with open(os.path.join(temp_skills_dir, "SKILL.md"), 'w', encoding='utf-8') as f:
+            f.write(skill_md)
+
+        result = read_skill_md_tool._read_direct_file(())
+
+        assert "Root Content" in result
+        assert "name:" not in result  # frontmatter stripped
+
+    def test_read_direct_file_with_path(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file reads specified file."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create a file in root
+        test_file = os.path.join(temp_skills_dir, "test-file.txt")
+        with open(test_file, 'w', encoding='utf-8') as f:
+            f.write("test content")
+
+        result = read_skill_md_tool._read_direct_file(("test-file.txt",))
+
+        assert "test content" in result
+
+    def test_read_direct_file_nested_path(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file reads nested file path."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create nested file
+        nested_dir = os.path.join(temp_skills_dir, "subdir")
+        os.makedirs(nested_dir)
+        nested_file = os.path.join(nested_dir, "nested.md")
+        with open(nested_file, 'w', encoding='utf-8') as f:
+            f.write("""---
+title: Nested
+---
+# Nested Content
+""")
+
+        result = read_skill_md_tool._read_direct_file(("subdir", "nested.md"))
+
+        assert "Nested Content" in result
+        assert "title:" not in result  # frontmatter stripped
+
+    def test_read_direct_file_not_found(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file returns error for missing file."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        result = read_skill_md_tool._read_direct_file(("missing.txt",))
+        assert "not found" in result.lower()
+
+    def test_read_direct_file_exception(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file handles read exceptions."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create file but mock open to raise error
+        test_file = os.path.join(temp_skills_dir, "error.md")
+        with open(test_file, 'w') as f:
+            f.write("content")
+
+        with patch('builtins.open', side_effect=OSError("Read error")):
+            result = read_skill_md_tool._read_direct_file(("error.md",))
+        assert "[Error]" in result
+
+
+class TestExecuteEmptySkillName:
+    """Test execute with empty skill_name (reads directly from local_skills_dir)."""
+
+    def test_execute_empty_skill_name_reads_root(self, read_skill_md_tool, temp_skills_dir):
+        """Test execute with empty skill_name reads from local_skills_dir root."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create SKILL.md in root
+        skill_md = """---
+name: root
+description: Root skill
+---
+# Root Skill Content
+"""
+        with open(os.path.join(temp_skills_dir, "SKILL.md"), 'w', encoding='utf-8') as f:
+            f.write(skill_md)
+
+        result = read_skill_md_tool.execute("")
+
+        assert "Root Skill Content" in result
+
+    def test_execute_empty_skill_name_with_file(self, read_skill_md_tool, temp_skills_dir):
+        """Test execute with empty skill_name and additional_files parameter."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create a file
+        test_file = os.path.join(temp_skills_dir, "readme.md")
+        with open(test_file, 'w', encoding='utf-8') as f:
+            f.write("""---
+title: Readme
+---
+# Readme Content
+""")
+
+        result = read_skill_md_tool.execute("", "readme.md")
+
+        assert "Readme Content" in result
+
+    def test_execute_empty_skill_name_file_not_found(self, read_skill_md_tool, temp_skills_dir):
+        """Test execute with empty skill_name returns error for missing file."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        result = read_skill_md_tool.execute("", "nonexistent.txt")
+        assert "not found" in result.lower()
diff --git a/test/sdk/core/tools/test_write_skill_file_tool.py b/test/sdk/core/tools/test_write_skill_file_tool.py
index e8591a119..964c66ce9 100644
--- a/test/sdk/core/tools/test_write_skill_file_tool.py
+++ b/test/sdk/core/tools/test_write_skill_file_tool.py
@@ -188,12 +188,6 @@ def test_lazy_load_reuses_manager(self, write_skill_file_tool):
 class TestExecute:
     """Test execute method."""
 
-    def test_execute_empty_skill_name(self, write_skill_file_tool):
-        """Test execute with empty skill_name."""
-        result = write_skill_file_tool.execute("", "file.txt", "content")
-        assert "[Error]" in result
-        assert "skill_name" in result.lower()
-
     def test_execute_empty_file_path(self, write_skill_file_tool):
         """Test execute with empty file_path."""
         result = write_skill_file_tool.execute("skill", "", "content")
@@ -301,14 +295,17 @@ def test_execute_writes_skill_md(self, write_skill_file_tool, temp_skills_dir):
 
     def test_execute_handles_manager_init_error(self, write_skill_file_tool, temp_skills_dir):
         """Test execute handles errors during skill manager initialization."""
-        # Force an error during _get_skill_manager
-        write_skill_file_tool.skill_manager = None
+        # When skill_name is empty and local_skills_dir is None, it returns direct error
+        # So we test with a non-empty skill_name to trigger manager init error
         write_skill_file_tool.local_skills_dir = None
+        write_skill_file_tool.skill_manager = None
 
-        result = write_skill_file_tool.execute("skill", "file.txt", "content")
+        # Mock _get_skill_manager to raise exception
+        with patch.object(write_skill_file_tool, '_get_skill_manager', side_effect=ImportError("Import failed")):
+            result = write_skill_file_tool.execute("skill", "file.txt", "content")
 
         assert "[Error]" in result
-        assert "Failed to initialize" in result or "skill manager" in result.lower()
+        assert "Failed to initialize" in result
 
     def test_execute_handles_write_error(self, write_skill_file_tool, temp_skills_dir):
         """Test execute handles errors during file write."""
@@ -681,3 +678,88 @@ def test_execute_with_leading_slash(self, write_skill_file_tool, temp_skills_dir
         # File should be created without leading slash
         expected_path = os.path.join(temp_skills_dir, skill_name, "file.txt")
         assert os.path.exists(expected_path)
+
+
+class TestWriteDirectFile:
+    """Test _write_direct_file method for empty skill_name."""
+
+    def test_write_direct_file_no_local_dir(self, write_skill_file_tool):
+        """Test _write_direct_file without local_skills_dir returns error."""
+        write_skill_file_tool.local_skills_dir = None
+        result = write_skill_file_tool._write_direct_file("file.txt", "content")
+        assert "[Error]" in result
+        assert "local_skills_dir" in result.lower()
+
+    def test_write_direct_file_creates_file(self, write_skill_file_tool, temp_skills_dir):
+        """Test _write_direct_file creates file directly in local_skills_dir."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        result = write_skill_file_tool._write_direct_file("direct-file.txt", "direct content")
+
+        assert "Successfully" in result
+        file_path = os.path.join(temp_skills_dir, "direct-file.txt")
+        assert os.path.exists(file_path)
+        with open(file_path, 'r', encoding='utf-8') as f:
+            assert f.read() == "direct content"
+
+    def test_write_direct_file_nested_path(self, write_skill_file_tool, temp_skills_dir):
+        """Test _write_direct_file creates nested directories."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        result = write_skill_file_tool._write_direct_file("subdir/nested/file.py", "print('hello')")
+
+        assert "Successfully" in result
+        file_path = os.path.join(temp_skills_dir, "subdir", "nested", "file.py")
+        assert os.path.exists(file_path)
+
+    def test_write_direct_file_overwrites(self, write_skill_file_tool, temp_skills_dir):
+        """Test _write_direct_file overwrites existing file."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        file_path = os.path.join(temp_skills_dir, "overwrite.txt")
+
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write("old content")
+
+        result = write_skill_file_tool._write_direct_file("overwrite.txt", "new content")
+
+        with open(file_path, 'r', encoding='utf-8') as f:
+            assert f.read() == "new content"
+
+    def test_write_direct_file_error(self, write_skill_file_tool, temp_skills_dir):
+        """Test _write_direct_file handles write errors."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+
+        with patch('builtins.open', side_effect=PermissionError("Permission denied")):
+            result = write_skill_file_tool._write_direct_file("error.txt", "content")
+
+        assert "[Error]" in result or "Permission denied" in result
+
+
+class TestExecuteEmptySkillName:
+    """Test execute with empty skill_name (writes directly to local_skills_dir)."""
+
+    def test_execute_empty_skill_name_direct_write(self, write_skill_file_tool, temp_skills_dir):
+        """Test execute with empty skill_name writes directly to local_skills_dir."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        result = write_skill_file_tool.execute("", "root-file.txt", "root content")
+
+        assert "Successfully" in result
+        file_path = os.path.join(temp_skills_dir, "root-file.txt")
+        assert os.path.exists(file_path)
+        with open(file_path, 'r', encoding='utf-8') as f:
+            assert f.read() == "root content"
+
+    def test_execute_empty_skill_name_nested_path(self, write_skill_file_tool, temp_skills_dir):
+        """Test execute with empty skill_name and nested path."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        result = write_skill_file_tool.execute("", "dir1/dir2/file.md", "# Markdown")
+
+        assert "Successfully" in result
+        file_path = os.path.join(temp_skills_dir, "dir1", "dir2", "file.md")
+        assert os.path.exists(file_path)
+
+    def test_execute_empty_skill_name_no_local_dir(self, write_skill_file_tool):
+        """Test execute with empty skill_name but no local_skills_dir."""
+        write_skill_file_tool.local_skills_dir = None
+        result = write_skill_file_tool.execute("", "file.txt", "content")
+
+        assert "[Error]" in result
+        assert "local_skills_dir" in result.lower()
diff --git a/test/sdk/skills/test_skill_loader.py b/test/sdk/skills/test_skill_loader.py
index 7212d838e..ee0718672 100644
--- a/test/sdk/skills/test_skill_loader.py
+++ b/test/sdk/skills/test_skill_loader.py
@@ -218,6 +218,18 @@ def test_escape_value_with_quotes(self):
         fixed = SkillLoader._fix_yaml_frontmatter(frontmatter)
         assert 'description: Say "hello" to YAML' in fixed
 
+    def test_skip_yaml_list_item_lines(self):
+        """Test that YAML list item lines (starting with '-') are preserved."""
+        frontmatter = """name: test
+allowed-tools:
+  - tool1
+  - tool2
+description: Test
+"""
+        fixed = SkillLoader._fix_yaml_frontmatter(frontmatter)
+        assert "- tool1" in fixed
+        assert "- tool2" in fixed
+
     def test_fix_value_with_multiple_special_chars(self):
         """Test fixing values with multiple special characters."""
         frontmatter = """name: test
@@ -341,8 +353,8 @@ def test_load_success(self, tmp_path):
 class TestSkillLoaderEdgeCases:
     """Test edge cases for SkillLoader."""
 
-    def test_parse_with_invalid_yaml_raises(self):
-        """Test parsing with invalid YAML structure."""
+    def test_parse_with_invalid_yaml_falls_back_to_regex(self):
+        """Test parsing with invalid YAML falls back to regex extraction."""
         content = """---
 name: test
 description: Test
@@ -350,8 +362,10 @@ def test_parse_with_invalid_yaml_raises(self):
 ---
 # Body
 """
-        with pytest.raises(Exception):
-            SkillLoader.parse(content)
+        # YAML parsing fails, but regex extraction succeeds since name/description are valid
+        result = SkillLoader.parse(content)
+        assert result["name"] == "test"
+        assert result["description"] == "Test"
 
     def test_parse_empty_content(self):
         """Test parsing empty content."""
@@ -380,7 +394,9 @@ def test_parse_with_yaml_list_frontmatter_raises(self):
 ---
 # Body
 """
-        with pytest.raises(ValueError, match="Invalid YAML frontmatter"):
+        # Frontmatter is a YAML list (not a dict), so regex fallback extracts nothing
+        # and raises because 'name' field is missing
+        with pytest.raises(ValueError, match="'name' field"):
             SkillLoader.parse(content)
 
     def test_parse_with_block_sequence_frontmatter_raises(self):
@@ -391,9 +407,71 @@ def test_parse_with_block_sequence_frontmatter_raises(self):
 ---
 # Body
 """
-        with pytest.raises(ValueError, match="Invalid YAML frontmatter"):
+        # Frontmatter is a YAML list (block sequence), so regex fallback extracts nothing
+        # and raises because 'name' field is missing
+        with pytest.raises(ValueError, match="'name' field"):
             SkillLoader.parse(content)
 
+    def test_regex_extract_block_scalar_description(self):
+        """Test regex extraction when description uses block scalar (>)."""
+        content = """---
+name: test
+description: >
+  This is a
+  multiline
+  description
+---
+# Body
+"""
+        # This triggers the regex fallback path because yaml.safe_load might fail
+        result = SkillLoader._extract_frontmatter_by_regex("name: test\ndescription: >\n  This is a\n  multiline\n  description")
+        assert "description" in result
+        assert "multiline" in result["description"]
+
+    def test_regex_extract_block_scalar_with_empty_lines(self):
+        """Test regex extraction with empty lines in block scalar content."""
+        frontmatter = """name: test
+description: >
+  Line 1
+
+  Line 2
+"""
+        result = SkillLoader._extract_frontmatter_by_regex(frontmatter)
+        assert "description" in result
+        assert "Line 1" in result["description"]
+        assert "Line 2" in result["description"]
+
+    def test_regex_extract_block_scalar_stops_at_unindented(self):
+        """Test regex extraction stops at unindented line."""
+        frontmatter = """name: test
+description: >
+  Line 1
+unindented_line
+  Line 2
+"""
+        result = SkillLoader._extract_frontmatter_by_regex(frontmatter)
+        assert "description" in result
+        assert "Line 1" in result["description"]
+        assert "unindented_line" not in result["description"]
+
+    def test_regex_extract_tags_inline(self):
+        """Test regex extraction of tags from inline list format."""
+        frontmatter = """name: test
+description: Test skill
+tags: [python, ml, data]
+"""
+        result = SkillLoader._extract_frontmatter_by_regex(frontmatter)
+        assert result["tags"] == ["python", "ml", "data"]
+
+    def test_regex_extract_allowed_tools_inline(self):
+        """Test regex extraction of allowed-tools from inline list format."""
+        frontmatter = """name: test
+description: Test skill
+allowed-tools: [tool1, tool2, tool3]
+"""
+        result = SkillLoader._extract_frontmatter_by_regex(frontmatter)
+        assert result["allowed-tools"] == ["tool1", "tool2", "tool3"]
+
     def test_parse_with_inline_yaml_list(self):
         """Test parsing with inline YAML list at top level."""
         content = """---
diff --git a/test/sdk/skills/test_skill_manager.py b/test/sdk/skills/test_skill_manager.py
index 625bc36b4..769ba7c0a 100644
--- a/test/sdk/skills/test_skill_manager.py
+++ b/test/sdk/skills/test_skill_manager.py
@@ -1180,5 +1180,770 @@ def test_upload_md_with_explicit_file_type(self):
             assert result["name"] == "explicit-type"
 
 
+    def test_upload_md_with_explicit_file_type(self):
+        """Test uploading MD with explicit file_type parameter."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            md_content = """---
+name: explicit-type
+description: Explicit type test
+---
+# Content
+"""
+
+            result = manager.upload_skill_from_file(
+                md_content, file_type="md"
+            )
+
+            assert result is not None
+            assert result["name"] == "explicit-type"
+
+    def test_upload_from_md_missing_name_raises(self):
+        """Test that MD without name raises ValueError."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            md_content = """---
+description: No name here
+---
+# Content
+"""
+            with pytest.raises(ValueError, match="Invalid SKILL.md format"):
+                manager.upload_skill_from_file(md_content)
+
+    def test_upload_zip_with_name_ending_in_zip(self):
+        """Test ZIP detection when skill_name ends with .zip."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("detected-skill/SKILL.md", """---
+name: detected-skill
+description: ZIP detected
+---
+# Content
+""")
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(
+                zip_bytes, skill_name="my-skill.zip"
+            )
+
+            assert result is not None
+            assert result["name"] == "my-skill.zip"
+
+    def test_upload_zip_unknown_skill_name_none_raises(self):
+        """Test that ZIP with None skill_name raises ValueError."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            # Create ZIP without any folder name hint
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("SKILL.md", """---
+name: SKILL
+description: No folder
+---
+# Content
+""")
+
+            zip_bytes = zip_buffer.getvalue()
+
+            with pytest.raises(ValueError, match="Skill name is required"):
+                manager.upload_skill_from_file(zip_bytes, skill_name=None)
+
+    def test_upload_zip_with_backslash_paths(self):
+        """Test ZIP extraction with backslash paths (Windows)."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("backslash-skill\\SKILL.md", """---
+name: backslash-skill
+description: Backslash paths
+---
+# Content
+""")
+                zf.writestr("backslash-skill\\scripts\\test.py", "# Test script\n")
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            assert result["name"] == "backslash-skill"
+
+    def test_upload_zip_with_nested_structure(self):
+        """Test ZIP extraction with deeply nested structure."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("nested-skill/SKILL.md", """---
+name: nested-skill
+description: Nested
+---
+# Content
+""")
+                zf.writestr("nested-skill/data/configs/app.json", '{"key": "value"}')
+                zf.writestr("nested-skill/data/configs/dev.json", '{"env": "dev"}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            skill_dir = os.path.join(temp.skills_dir, "nested-skill")
+            assert os.path.exists(os.path.join(skill_dir, "data", "configs", "app.json"))
+
+    def test_update_skill_md_auto_detect(self):
+        """Test updating skill with auto-detect file type."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            temp.create_skill(
+                "auto-update",
+                """---
+name: auto-update
+description: Original
+---
+# Original
+""",
+            )
+
+            new_md = """---
+name: auto-update
+description: Auto updated
+---
+# Updated
+"""
+            result = manager.update_skill_from_file(new_md, "auto-update")
+
+            assert result is not None
+            assert result["description"] == "Auto updated"
+
+    def test_update_skill_zip_with_backslash_paths(self):
+        """Test updating skill from ZIP with backslash paths."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            temp.create_skill(
+                "zip-update-bs",
+                """---
+name: zip-update-bs
+description: Original
+---
+# Original
+""",
+            )
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("zip-update-bs\\SKILL.md", """---
+name: zip-update-bs
+description: BS Updated
+---
+# BS Updated
+""")
+                zf.writestr("zip-update-bs\\scripts\\helper.py", "# Helper\n")
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.update_skill_from_file(zip_bytes, "zip-update-bs")
+
+            assert result is not None
+            assert result["description"] == "BS Updated"
+
+
+class TestSkillManagerAddToTree:
+    """Test SkillManager._add_to_tree method."""
+
+    def test_add_to_tree_single_file(self):
+        """Test adding single file to tree."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": []}
+
+        manager._add_to_tree(node, ["file.txt"], is_directory=False)
+
+        assert len(node["children"]) == 1
+        assert node["children"][0]["name"] == "file.txt"
+        assert node["children"][0]["type"] == "file"
+
+    def test_add_to_tree_single_directory(self):
+        """Test adding single directory to tree."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": []}
+
+        manager._add_to_tree(node, ["subdir"], is_directory=True)
+
+        assert len(node["children"]) == 1
+        assert node["children"][0]["name"] == "subdir"
+        assert node["children"][0]["type"] == "directory"
+
+    def test_add_to_tree_nested_path(self):
+        """Test adding nested path to tree."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": []}
+
+        manager._add_to_tree(node, ["dir1", "dir2", "file.txt"], is_directory=False)
+
+        assert node["children"][0]["name"] == "dir1"
+        assert node["children"][0]["type"] == "directory"
+        assert node["children"][0]["children"][0]["name"] == "dir2"
+        assert node["children"][0]["children"][0]["type"] == "directory"
+        assert node["children"][0]["children"][0]["children"][0]["name"] == "file.txt"
+
+    def test_add_to_tree_skips_duplicate_same_type(self):
+        """Test that duplicate entries with same type are skipped."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": [{"name": "dup", "type": "file", "children": []}]}
+
+        manager._add_to_tree(node, ["dup"], is_directory=False)
+
+        assert len(node["children"]) == 1
+
+    def test_add_to_tree_empty_parts(self):
+        """Test that empty parts list does nothing."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": []}
+
+        manager._add_to_tree(node, [], is_directory=False)
+
+        assert len(node["children"]) == 0
+
+
+class TestSkillManagerDeleteSkill:
+    """Test SkillManager.delete_skill error handling."""
+
+    def test_delete_skill_with_os_error(self, mocker):
+        """Test deleting skill when os.error occurs."""
+        import shutil
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "delete-error",
+                """---
+name: delete-error
+description: Delete error test
+---
+# Content
+""",
+            )
+
+            skill_dir = os.path.join(temp.skills_dir, "delete-error")
+
+            # Mock at module level where skill_manager imports it
+            original_rmtree = shutil.rmtree
+            def mock_rmtree(path, **kwargs):
+                if path == skill_dir:
+                    raise OSError("Permission denied")
+                original_rmtree(path, **kwargs)
+
+            mocker.patch("shutil.rmtree", side_effect=mock_rmtree)
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.delete_skill("delete-error")
+
+            # Should still return True (idempotent behavior)
+            assert result is True
+
+
+class TestSkillManagerBuildSkillsSummary:
+    """Test SkillManager.build_skills_summary edge cases."""
+
+    def test_build_summary_with_empty_description(self):
+        """Test building summary when skill has empty description."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            # Create a skill with empty description
+            skill_dir = os.path.join(temp.skills_dir, "empty-desc")
+            os.makedirs(skill_dir)
+            with open(os.path.join(skill_dir, "SKILL.md"), "w", encoding="utf-8") as f:
+                f.write("""---
+name: empty-desc
+description: 
+---
+# Content
+""")
+
+            result = manager.build_skills_summary()
+
+            assert "<skills>" in result
+            assert "<name>empty-desc</name>" in result
+
+
+class TestSkillManagerCleanupSkillDirectory:
+    """Test SkillManager.cleanup_skill_directory error handling."""
+
+    def test_cleanup_with_os_error(self, mocker):
+        """Test cleanup when os.remove fails."""
+        mocker.patch("os.listdir", return_value=[f"skill_test_fakeid"])
+        mocker.patch("os.path.isdir", return_value=False)
+        mocker.patch("os.remove", side_effect=OSError("Access denied"))
+        mocker.patch("os.path.join", side_effect=lambda *args: "\\".join(str(a) for a in args))
+
+        manager = SkillManager(local_skills_dir="/fake")
+        # Should not raise, just log warning
+        manager.cleanup_skill_directory("test")
+
+
+class TestSkillManagerRunSkillScript:
+    """Test SkillManager.run_skill_script error handling."""
+
+    def test_run_python_script_timeout(self, mocker):
+        """Test running Python script that times out."""
+        import subprocess
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "timeout-skill",
+                """---
+name: timeout-skill
+description: Timeout test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "slow.py", "content": "import time; time.sleep(1000)"}],
+                },
+            )
+
+            mocker.patch("subprocess.run", side_effect=subprocess.TimeoutExpired("cmd", 300))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            with pytest.raises(TimeoutError, match="timed out"):
+                manager.run_skill_script("timeout-skill", "scripts/slow.py")
+
+    def test_run_python_script_other_exception(self, mocker):
+        """Test running Python script with unexpected exception."""
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "except-skill",
+                """---
+name: except-skill
+description: Exception test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "crash.py", "content": "raise RuntimeError"}],
+                },
+            )
+
+            mocker.patch("subprocess.run", side_effect=RuntimeError("Unexpected"))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            with pytest.raises(RuntimeError, match="Unexpected"):
+                manager.run_skill_script("except-skill", "scripts/crash.py")
+
+    def test_run_shell_script_timeout(self, mocker):
+        """Test running shell script that times out."""
+        import subprocess
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "sh-timeout-skill",
+                """---
+name: sh-timeout-skill
+description: Shell timeout test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "slow.sh", "content": "#!/bin/bash\nsleep 1000"}],
+                },
+            )
+
+            mocker.patch("subprocess.run", side_effect=subprocess.TimeoutExpired("cmd", 300))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            with pytest.raises(TimeoutError, match="timed out"):
+                manager.run_skill_script("sh-timeout-skill", "scripts/slow.sh")
+
+    def test_run_shell_script_error_returns_json(self, mocker):
+        """Test running shell script that returns error code."""
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "sh-error-skill",
+                """---
+name: sh-error-skill
+description: Shell error test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "fail.sh", "content": "#!/bin/bash\nexit 1"}],
+                },
+            )
+
+            mock_result = MagicMock()
+            mock_result.returncode = 1
+            mock_result.stdout = "partial output"
+            mock_result.stderr = "Shell error"
+
+            mocker.patch("subprocess.run", return_value=mock_result)
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.run_skill_script("sh-error-skill", "scripts/fail.sh")
+
+            parsed = json.loads(result)
+            assert "error" in parsed
+
+
+class TestSkillManagerGetSkillFileTree:
+    """Test SkillManager.get_skill_file_tree edge cases."""
+
+    def test_get_file_tree_ignores_skill_md_in_subdirs(self):
+        """Test that SKILL.md in subdirectories is ignored."""
+        with TempSkillDir() as temp:
+            skill_dir = os.path.join(temp.skills_dir, "md-subdir-skill")
+            os.makedirs(skill_dir)
+
+            with open(os.path.join(skill_dir, "SKILL.md"), "w") as f:
+                f.write("---\nname: md-subdir-skill\ndescription: Test\n---\n# Content\n")
+
+            subdir = os.path.join(skill_dir, "data")
+            os.makedirs(subdir)
+            with open(os.path.join(subdir, "SKILL.md"), "w") as f:
+                f.write("# This should be ignored\n")
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.get_skill_file_tree("md-subdir-skill")
+
+            assert result is not None
+
+            def count_skill_md(node):
+                count = 0
+                for child in node.get("children", []):
+                    if child["name"] == "SKILL.md":
+                        count += 1
+                    if child["type"] == "directory":
+                        count += count_skill_md(child)
+                return count
+
+            # Should only have one SKILL.md at root
+            assert count_skill_md(result) == 1
+
+
+class TestSkillManagerListSkills:
+    """Test SkillManager.list_skills error handling."""
+
+    def test_list_skills_with_os_error(self, mocker):
+        """Test listing skills when os.listdir raises OSError."""
+        with TempSkillDir() as temp:
+            mocker.patch("os.listdir", side_effect=OSError("Permission denied"))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.list_skills()
+
+            # Should return empty list and log error
+            assert result == []
+
+    def test_list_skills_with_load_error(self, mocker):
+        """Test listing skills when loading a skill raises exception."""
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "load-error-skill",
+                """---
+name: load-error-skill
+description: Test
+---
+# Content
+""",
+            )
+
+            mocker.patch.object(
+                module_manager.SkillManager,
+                "load_skill",
+                side_effect=Exception("Load failed")
+            )
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.list_skills()
+
+            # Should skip the failing skill
+            assert result == []
+
+
+class TestSkillManagerUploadSkillEnhanced:
+    """Enhanced tests for SkillManager.upload_skill_from_file."""
+
+    def test_upload_zip_with_directory_entries_skipped(self):
+        """Test ZIP directory entries (ending with '/') are skipped."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("dir-skill/SKILL.md", """---
+name: dir-skill
+description: With directories
+---
+# Content
+""")
+                zf.writestr("dir-skill/data/config.json", '{"key": "value"}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            assert result["name"] == "dir-skill"
+            skill_dir = os.path.join(temp.skills_dir, "dir-skill")
+            assert os.path.exists(os.path.join(skill_dir, "data", "config.json"))
+
+    def test_upload_zip_nested_skill_md_fallback(self):
+        """Test ZIP with deeply nested SKILL.md triggers fallback search."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("nested-skill/SKILL.md", """---
+name: nested-skill
+description: Nested path
+---
+# Content
+""")
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            assert result["name"] == "nested-skill"
+
+    def test_upload_zip_parse_exception_raised(self):
+        """Test ZIP with invalid SKILL.md content raises ValueError."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("bad-skill/SKILL.md", """---
+name: bad-skill
+---
+invalid: !!python/object/apply:os.system
+""")
+
+            zip_bytes = zip_buffer.getvalue()
+
+            with pytest.raises(ValueError, match="Failed to parse SKILL.md"):
+                manager.upload_skill_from_file(zip_bytes)
+
+    def test_upload_zip_extracts_different_prefix_files(self):
+        """Test ZIP files without skill name prefix are extracted as-is."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("prefix-skill/SKILL.md", """---
+name: prefix-skill
+description: Prefix test
+---
+# Content
+""")
+                zf.writestr("other-prefix/data.json", '{"other": true}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            skill_dir = os.path.join(temp.skills_dir, "prefix-skill")
+            assert os.path.exists(os.path.join(skill_dir, "other-prefix", "data.json"))
+
+
+class TestSkillManagerUpdateSkillEnhanced:
+    """Enhanced tests for SkillManager.update_skill_from_file."""
+
+    def test_update_zip_skips_skill_md_when_not_found(self):
+        """Test ZIP update skips SKILL.md when not present in ZIP."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            temp.create_skill(
+                "no-md-update",
+                """---
+name: no-md-update
+description: Original
+---
+# Original
+""",
+            )
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("no-md-update/config.json", '{"updated": true}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.update_skill_from_file(zip_bytes, "no-md-update")
+
+            assert result is not None
+
+    def test_update_zip_extracts_different_prefix_files(self):
+        """Test ZIP update extracts files with different folder prefix."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            temp.create_skill(
+                "prefix-update",
+                """---
+name: prefix-update
+description: Original
+---
+# Original
+""",
+            )
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("prefix-update/SKILL.md", """---
+name: prefix-update
+description: Updated
+---
+# Updated
+""")
+                zf.writestr("other-prefix/data.json", '{"key": "value"}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.update_skill_from_file(zip_bytes, "prefix-update")
+
+            assert result is not None
+
+
+class TestSkillManagerAddToTreeEnhanced:
+    """Enhanced tests for SkillManager._add_to_tree method."""
+
+    def test_add_to_tree_reuses_existing_directory(self):
+        """Test adding path reuses existing directory node."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": [{"name": "dir1", "type": "directory", "children": []}]}
+
+        manager._add_to_tree(node, ["dir1", "file.txt"], is_directory=False)
+
+        assert len(node["children"]) == 1
+        assert node["children"][0]["children"][0]["name"] == "file.txt"
+
+    def test_add_to_tree_skips_type_conflict(self):
+        """Test type conflict skips adding the entry."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": [{"name": "conflict", "type": "directory", "children": []}]}
+
+        manager._add_to_tree(node, ["conflict"], is_directory=False)
+
+        assert len(node["children"]) == 1
+
+
+class TestSkillManagerErrorHandlingEnhanced:
+    """Enhanced error handling tests for SkillManager."""
+
+    def test_cleanup_handles_rmtree_exception(self, mocker):
+        """Test cleanup logs warning when rmtree fails."""
+        mocker.patch("os.listdir", return_value=[f"skill_test_cleanup"])
+        mocker.patch("os.path.isdir", return_value=True)
+        mocker.patch("shutil.rmtree", side_effect=OSError("Access denied"))
+
+        manager = SkillManager(local_skills_dir="/fake")
+        manager.cleanup_skill_directory("test-cleanup")
+
+    def test_run_python_script_with_list_params(self, mocker):
+        """Test running Python script with list parameter."""
+        import subprocess
+        from unittest.mock import ANY
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "list-param-skill",
+                """---
+name: list-param-skill
+description: List param test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "multi.py", "content": "print('ok')"}],
+                },
+            )
+
+            mock_result = MagicMock()
+            mock_result.returncode = 0
+            mock_result.stdout = "ok"
+            mock_result.stderr = ""
+
+            mocker.patch("subprocess.run", return_value=mock_result)
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.run_skill_script(
+                "list-param-skill",
+                "scripts/multi.py",
+                params={"-i": ["a", "b", "c"]}
+            )
+
+            assert result == "ok"
+            args = subprocess.run.call_args[0][0]
+            assert args == ["python", ANY, "-i", "a", "-i", "b", "-i", "c"]
+
+    def test_run_python_script_boolean_false_excluded(self, mocker):
+        """Test boolean False params are excluded from args."""
+        import subprocess
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "bool-false-skill",
+                """---
+name: bool-false-skill
+description: Bool false test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "bool.py", "content": "print('ok')"}],
+                },
+            )
+
+            mock_result = MagicMock()
+            mock_result.returncode = 0
+            mock_result.stdout = "ok"
+            mock_result.stderr = ""
+
+            mocker.patch("subprocess.run", return_value=mock_result)
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.run_skill_script(
+                "bool-false-skill",
+                "scripts/bool.py",
+                params={"--quiet": False, "--verbose": True}
+            )
+
+            args = subprocess.run.call_args[0][0]
+            assert "--quiet" not in args
+            assert "--verbose" in args
+
+    def test_run_shell_script_other_exception(self, mocker):
+        """Test shell script with unexpected exception propagates."""
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "sh-except-skill",
+                """---
+name: sh-except-skill
+description: Shell exception test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "except.sh", "content": "#!/bin/bash\nthrow"}],
+                },
+            )
+
+            mocker.patch("subprocess.run", side_effect=RuntimeError("Unexpected shell error"))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            with pytest.raises(RuntimeError, match="Unexpected shell error"):
+                manager.run_skill_script("sh-except-skill", "scripts/except.sh")
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])