From e9eed2e854f37aea6f0b3321cd0ef6109782c261 Mon Sep 17 00:00:00 2001
From: Toray Altas <toray.altas@gmail.com>
Date: Fri, 17 Jul 2026 22:51:43 -0400
Subject: [PATCH 01/26] fix(skills): safely serialize skill frontmatter

---
 packages/types/src/skills.ts                  |  9 +++
 packages/types/src/vscode-extension-host.ts   |  3 +-
 .../__tests__/skillsMessageHandler.spec.ts    | 62 ++++++++++++--
 src/core/webview/skillsMessageHandler.ts      | 19 +++--
 src/services/skills/SkillsManager.ts          | 54 +++++++++----
 .../skills/__tests__/SkillsManager.spec.ts    | 81 +++++++++++++++++++
 src/shared/skills.ts                          |  9 +++
 .../components/settings/SkillsSettings.tsx    | 32 +++++++-
 .../__tests__/SkillsSettings.spec.tsx         | 28 ++++++-
 .../src/context/ExtensionStateContext.tsx     |  9 ++-
 webview-ui/src/i18n/locales/en/settings.json  |  4 +
 11 files changed, 273 insertions(+), 37 deletions(-)

diff --git a/packages/types/src/skills.ts b/packages/types/src/skills.ts
index 2f13b822eb..65768f7f29 100644
--- a/packages/types/src/skills.ts
+++ b/packages/types/src/skills.ts
@@ -20,6 +20,15 @@ export interface SkillMetadata {
 	modeSlugs?: string[]
 }
 
+/** A user-actionable problem found while loading a SKILL.md file. */
+export interface SkillDiagnostic {
+	path: string
+	source: "global" | "project"
+	message: string
+	line?: number
+	column?: number
+}
+
 /**
  * Skill name validation constants per agentskills.io specification:
  * https://agentskills.io/specification
diff --git a/packages/types/src/vscode-extension-host.ts b/packages/types/src/vscode-extension-host.ts
index 75a72accde..6b391db0fa 100644
--- a/packages/types/src/vscode-extension-host.ts
+++ b/packages/types/src/vscode-extension-host.ts
@@ -14,7 +14,7 @@ import type { GitCommit } from "./git.js"
 import type { McpServer } from "./mcp.js"
 import type { ModelRecord, RouterModels } from "./model.js"
 import type { OpenAiCodexRateLimitInfo } from "./providers/openai-codex-rate-limits.js"
-import type { SkillMetadata } from "./skills.js"
+import type { SkillDiagnostic, SkillMetadata } from "./skills.js"
 import type { RuleMetadata } from "./rules.js"
 import type { TelemetrySetting } from "./telemetry.js"
 import type { WorktreeIncludeStatus } from "./worktree.js"
@@ -180,6 +180,7 @@ export interface ExtensionMessage {
 	list?: string[] // For dismissedUpsells
 	tools?: SerializedCustomToolDefinition[] // For customToolsResult
 	skills?: SkillMetadata[] // For skills response
+	skillDiagnostics?: SkillDiagnostic[] // For malformed skills omitted from the skills response
 	rules?: RuleMetadata[] // For rules response
 	modes?: { slug: string; name: string }[] // For modes response
 	rooHistoryImportProgress?: {
diff --git a/src/core/webview/__tests__/skillsMessageHandler.spec.ts b/src/core/webview/__tests__/skillsMessageHandler.spec.ts
index 5d03b95a27..25e1b2b48c 100644
--- a/src/core/webview/__tests__/skillsMessageHandler.spec.ts
+++ b/src/core/webview/__tests__/skillsMessageHandler.spec.ts
@@ -47,6 +47,7 @@ describe("skillsMessageHandler", () => {
 	const mockLog = vi.fn()
 	const mockPostMessageToWebview = vi.fn()
 	const mockGetSkillsMetadata = vi.fn()
+	const mockGetSkillDiagnostics = vi.fn()
 	const mockCreateSkill = vi.fn()
 	const mockDeleteSkill = vi.fn()
 	const mockMoveSkill = vi.fn()
@@ -57,6 +58,7 @@ describe("skillsMessageHandler", () => {
 		const skillsManager = hasSkillsManager
 			? {
 					getSkillsMetadata: mockGetSkillsMetadata,
+					getSkillDiagnostics: mockGetSkillDiagnostics,
 					createSkill: mockCreateSkill,
 					deleteSkill: mockDeleteSkill,
 					moveSkill: mockMoveSkill,
@@ -90,6 +92,7 @@ describe("skillsMessageHandler", () => {
 
 	beforeEach(() => {
 		vi.clearAllMocks()
+		mockGetSkillDiagnostics.mockReturnValue([])
 	})
 
 	describe("handleRequestSkills", () => {
@@ -100,7 +103,34 @@ describe("skillsMessageHandler", () => {
 			const result = await handleRequestSkills(provider)
 
 			expect(result).toEqual(mockSkills)
-			expect(mockPostMessageToWebview).toHaveBeenCalledWith({ type: "skills", skills: mockSkills })
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: mockSkills,
+				skillDiagnostics: [],
+			})
+		})
+
+		it("sends structured malformed-skill diagnostics without hiding valid skills", async () => {
+			const provider = createMockProvider(true)
+			const diagnostics = [
+				{
+					path: "/workspace/.roo/skills/broken/SKILL.md",
+					source: "project" as const,
+					message: "bad indentation of a mapping entry",
+					line: 3,
+					column: 20,
+				},
+			]
+			mockGetSkillsMetadata.mockReturnValue(mockSkills)
+			mockGetSkillDiagnostics.mockReturnValue(diagnostics)
+
+			await handleRequestSkills(provider)
+
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: mockSkills,
+				skillDiagnostics: diagnostics,
+			})
 		})
 
 		it("returns empty skills when skills manager is not available", async () => {
@@ -109,7 +139,11 @@ describe("skillsMessageHandler", () => {
 			const result = await handleRequestSkills(provider)
 
 			expect(result).toEqual([])
-			expect(mockPostMessageToWebview).toHaveBeenCalledWith({ type: "skills", skills: [] })
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: [],
+				skillDiagnostics: [],
+			})
 		})
 
 		it("handles errors and returns empty skills", async () => {
@@ -122,7 +156,11 @@ describe("skillsMessageHandler", () => {
 
 			expect(result).toEqual([])
 			expect(mockLog).toHaveBeenCalled()
-			expect(mockPostMessageToWebview).toHaveBeenCalledWith({ type: "skills", skills: [] })
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: [],
+				skillDiagnostics: [],
+			})
 		})
 	})
 
@@ -142,7 +180,11 @@ describe("skillsMessageHandler", () => {
 			expect(result).toEqual(mockSkills)
 			expect(mockCreateSkill).toHaveBeenCalledWith("new-skill", "global", "New skill description", undefined)
 			expect(openFile).toHaveBeenCalledWith("/path/to/new-skill/SKILL.md")
-			expect(mockPostMessageToWebview).toHaveBeenCalledWith({ type: "skills", skills: mockSkills })
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: mockSkills,
+				skillDiagnostics: [],
+			})
 		})
 
 		it("creates a skill with mode restriction", async () => {
@@ -212,7 +254,11 @@ describe("skillsMessageHandler", () => {
 
 			expect(result).toEqual([mockSkills[1]])
 			expect(mockDeleteSkill).toHaveBeenCalledWith("test-skill", "global", undefined)
-			expect(mockPostMessageToWebview).toHaveBeenCalledWith({ type: "skills", skills: [mockSkills[1]] })
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: [mockSkills[1]],
+				skillDiagnostics: [],
+			})
 		})
 
 		it("deletes a skill with mode restriction", async () => {
@@ -280,7 +326,11 @@ describe("skillsMessageHandler", () => {
 
 			expect(result).toEqual([mockSkills[0]])
 			expect(mockMoveSkill).toHaveBeenCalledWith("test-skill", "global", undefined, "code")
-			expect(mockPostMessageToWebview).toHaveBeenCalledWith({ type: "skills", skills: [mockSkills[0]] })
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: [mockSkills[0]],
+				skillDiagnostics: [],
+			})
 		})
 
 		it("moves a skill from one mode to another", async () => {
diff --git a/src/core/webview/skillsMessageHandler.ts b/src/core/webview/skillsMessageHandler.ts
index 496ff70c24..6781082933 100644
--- a/src/core/webview/skillsMessageHandler.ts
+++ b/src/core/webview/skillsMessageHandler.ts
@@ -16,15 +16,16 @@ export async function handleRequestSkills(provider: ClineProvider): Promise<Skil
 		const skillsManager = provider.getSkillsManager()
 		if (skillsManager) {
 			const skills = skillsManager.getSkillsMetadata()
-			await provider.postMessageToWebview({ type: "skills", skills })
+			const skillDiagnostics = skillsManager.getSkillDiagnostics()
+			await provider.postMessageToWebview({ type: "skills", skills, skillDiagnostics })
 			return skills
 		} else {
-			await provider.postMessageToWebview({ type: "skills", skills: [] })
+			await provider.postMessageToWebview({ type: "skills", skills: [], skillDiagnostics: [] })
 			return []
 		}
 	} catch (error) {
 		provider.log(`Error fetching skills: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`)
-		await provider.postMessageToWebview({ type: "skills", skills: [] })
+		await provider.postMessageToWebview({ type: "skills", skills: [], skillDiagnostics: [] })
 		return []
 	}
 }
@@ -59,7 +60,8 @@ export async function handleCreateSkill(
 
 		// Send updated skills list
 		const skills = skillsManager.getSkillsMetadata()
-		await provider.postMessageToWebview({ type: "skills", skills })
+		const skillDiagnostics = skillsManager.getSkillDiagnostics()
+		await provider.postMessageToWebview({ type: "skills", skills, skillDiagnostics })
 		return skills
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : String(error)
@@ -95,7 +97,8 @@ export async function handleDeleteSkill(
 
 		// Send updated skills list
 		const skills = skillsManager.getSkillsMetadata()
-		await provider.postMessageToWebview({ type: "skills", skills })
+		const skillDiagnostics = skillsManager.getSkillDiagnostics()
+		await provider.postMessageToWebview({ type: "skills", skills, skillDiagnostics })
 		return skills
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : String(error)
@@ -131,7 +134,8 @@ export async function handleMoveSkill(
 
 		// Send updated skills list
 		const skills = skillsManager.getSkillsMetadata()
-		await provider.postMessageToWebview({ type: "skills", skills })
+		const skillDiagnostics = skillsManager.getSkillDiagnostics()
+		await provider.postMessageToWebview({ type: "skills", skills, skillDiagnostics })
 		return skills
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : String(error)
@@ -166,7 +170,8 @@ export async function handleUpdateSkillModes(
 
 		// Send updated skills list
 		const skills = skillsManager.getSkillsMetadata()
-		await provider.postMessageToWebview({ type: "skills", skills })
+		const skillDiagnostics = skillsManager.getSkillDiagnostics()
+		await provider.postMessageToWebview({ type: "skills", skills, skillDiagnostics })
 		return skills
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : String(error)
diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 0959b977c9..733ac9ae92 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -6,7 +6,7 @@ import matter from "gray-matter"
 import type { ClineProvider } from "../../core/webview/ClineProvider"
 import { getGlobalRooDirectory, getGlobalAgentsDirectory, getProjectAgentsDirectoryForCwd } from "../roo-config"
 import { directoryExists, fileExists } from "../roo-config"
-import { SkillMetadata, SkillContent } from "../../shared/skills"
+import { SkillMetadata, SkillContent, SkillDiagnostic } from "../../shared/skills"
 import { modes, getAllModes } from "../../shared/modes"
 import {
 	validateSkillName as validateSkillNameShared,
@@ -16,10 +16,11 @@ import {
 import { t } from "../../i18n"
 
 // Re-export for convenience
-export type { SkillMetadata, SkillContent }
+export type { SkillMetadata, SkillContent, SkillDiagnostic }
 
 export class SkillsManager {
 	private skills: Map<string, SkillMetadata> = new Map()
+	private diagnostics: SkillDiagnostic[] = []
 	private providerRef: WeakRef<ClineProvider>
 	private disposables: vscode.Disposable[] = []
 	private isDisposed = false
@@ -42,6 +43,7 @@ export class SkillsManager {
 	 */
 	async discoverSkills(): Promise<void> {
 		this.skills.clear()
+		this.diagnostics = []
 		const skillsDirs = await this.getSkillsDirectories()
 
 		for (const { dir, source, mode } of skillsDirs) {
@@ -100,9 +102,17 @@ export class SkillsManager {
 
 		try {
 			const fileContent = await fs.readFile(skillMdPath, "utf-8")
+			let parsed: ReturnType<typeof matter>
 
-			// Use gray-matter to parse frontmatter
-			const { data: frontmatter, content: body } = matter(fileContent)
+			try {
+				parsed = matter(fileContent)
+			} catch (error) {
+				this.recordDiagnostic(skillMdPath, source, error)
+				console.error(`Failed to parse skill at ${skillDir}:`, error)
+				return
+			}
+
+			const { data: frontmatter } = parsed
 
 			// Validate required fields (only name and description for now)
 			if (!frontmatter.name || typeof frontmatter.name !== "string") {
@@ -175,6 +185,20 @@ export class SkillsManager {
 		}
 	}
 
+	private recordDiagnostic(path: string, source: "global" | "project", error: unknown): void {
+		const yamlError = error as {
+			reason?: unknown
+			message?: unknown
+			mark?: { line?: unknown; column?: unknown }
+		}
+		const reason = typeof yamlError.reason === "string" ? yamlError.reason : undefined
+		const errorMessage = error instanceof Error ? error.message.split("\n", 1)[0] : String(error)
+		const line = typeof yamlError.mark?.line === "number" ? yamlError.mark.line + 1 : undefined
+		const column = typeof yamlError.mark?.column === "number" ? yamlError.mark.column + 1 : undefined
+
+		this.diagnostics.push({ path, source, message: reason ?? errorMessage, line, column })
+	}
+
 	/**
 	 * Get skills available for the current mode.
 	 * Resolves overrides: project > global, mode-specific > generic.
@@ -290,6 +314,10 @@ export class SkillsManager {
 		return this.getAllSkills()
 	}
 
+	getSkillDiagnostics(): SkillDiagnostic[] {
+		return [...this.diagnostics]
+	}
+
 	/**
 	 * Get a skill by name, source, and optionally mode
 	 */
@@ -394,25 +422,19 @@ export class SkillsManager {
 			.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
 			.join(" ")
 
-		// Build frontmatter with optional modeSlugs
-		const frontmatterLines = [`name: ${name}`, `description: ${trimmedDescription}`]
-		if (modeSlugs && modeSlugs.length > 0) {
-			frontmatterLines.push(`modeSlugs:`)
-			for (const slug of modeSlugs) {
-				frontmatterLines.push(`  - ${slug}`)
-			}
+		const frontmatter = {
+			name,
+			description: trimmedDescription,
+			...(modeSlugs && modeSlugs.length > 0 ? { modeSlugs } : {}),
 		}
-
-		const skillContent = `---
-${frontmatterLines.join("\n")}
----
-
+		const body = `
 # ${titleName}
 
 ## Instructions
 
 Add your skill instructions here.
 `
+		const skillContent = matter.stringify(body, frontmatter)
 
 		// Write the SKILL.md file
 		await fs.writeFile(skillMdPath, skillContent, "utf-8")
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index d36582d893..5dbedff8fa 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -1,4 +1,5 @@
 import * as path from "path"
+import matter from "gray-matter"
 
 // Use vi.hoisted to ensure mocks are available during hoisting
 const {
@@ -1233,6 +1234,47 @@ Instructions`)
 			expect(writeCall[1]).toContain("- code")
 		})
 
+		it("round-trips the issue description and mode slugs through YAML frontmatter", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			mockMkdir.mockResolvedValue(undefined)
+			mockWriteFile.mockResolvedValue(undefined)
+			const description = 'Triggers on: "TDD", "test-driven development"'
+
+			await skillsManager.createSkill("tdd-skill", "global", description, ["code", "debug"])
+
+			const generatedContent = mockWriteFile.mock.calls[0][1] as string
+			const parsed = matter(generatedContent)
+			expect(parsed.data).toEqual({
+				name: "tdd-skill",
+				description,
+				modeSlugs: ["code", "debug"],
+			})
+			expect(parsed.content).toBe("\n# Tdd Skill\n\n## Instructions\n\nAdd your skill instructions here.\n")
+		})
+
+		it.each([
+			["colon-space", "Use when: tests fail"],
+			["quotes", "Use \"red-green-refactor\" and 'small steps'"],
+			["hash", "Use tests # not comments"],
+			["leading punctuation", "- Start from a failing test"],
+			["multiline", "First line\nSecond line: with # and quotes"],
+		])("preserves YAML-sensitive %s descriptions", async (_caseName, description) => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			mockMkdir.mockResolvedValue(undefined)
+			mockWriteFile.mockResolvedValue(undefined)
+
+			await skillsManager.createSkill("yaml-sensitive", "global", description)
+
+			const generatedContent = mockWriteFile.mock.calls[0][1] as string
+			expect(matter(generatedContent).data.description).toBe(description)
+		})
+
 		it("should create a project skill", async () => {
 			mockDirectoryExists.mockResolvedValue(false)
 			mockRealpath.mockImplementation(async (p: string) => p)
@@ -1299,6 +1341,45 @@ Instructions`)
 		})
 	})
 
+	describe("skill diagnostics", () => {
+		it("reports malformed YAML with location while retaining valid skills", async () => {
+			const validSkillDir = p(globalSkillsDir, "valid-skill")
+			const malformedSkillDir = p(globalSkillsDir, "malformed-skill")
+			const validSkillPath = p(validSkillDir, "SKILL.md")
+			const malformedSkillPath = p(malformedSkillDir, "SKILL.md")
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockReaddir.mockImplementation(async (dir: string) =>
+				dir === globalSkillsDir ? ["valid-skill", "malformed-skill"] : [],
+			)
+			mockStat.mockResolvedValue({ isDirectory: () => true })
+			mockFileExists.mockImplementation(async (file: string) =>
+				[validSkillPath, malformedSkillPath].includes(file),
+			)
+			mockReadFile.mockImplementation(async (file: string) => {
+				if (file === validSkillPath) {
+					return "---\nname: valid-skill\ndescription: Still visible\n---\nValid instructions"
+				}
+				return '---\nname: malformed-skill\ndescription: Triggers on: "TDD"\n---\nBroken instructions'
+			})
+
+			await skillsManager.discoverSkills()
+
+			expect(skillsManager.getSkillsMetadata()).toEqual([
+				expect.objectContaining({ name: "valid-skill", description: "Still visible" }),
+			])
+			expect(skillsManager.getSkillDiagnostics()).toEqual([
+				expect.objectContaining({
+					path: malformedSkillPath,
+					source: "global",
+					message: expect.any(String),
+					line: 3,
+					column: expect.any(Number),
+				}),
+			])
+		})
+	})
+
 	describe("deleteSkill", () => {
 		it("should delete an existing skill", async () => {
 			const testSkillDir = p(globalSkillsDir, "test-skill")
diff --git a/src/shared/skills.ts b/src/shared/skills.ts
index f5151181f6..6dc2cbf8ad 100644
--- a/src/shared/skills.ts
+++ b/src/shared/skills.ts
@@ -20,6 +20,15 @@ export interface SkillMetadata {
 	modeSlugs?: string[]
 }
 
+/** A user-actionable problem found while loading a SKILL.md file. */
+export interface SkillDiagnostic {
+	path: string
+	source: "global" | "project"
+	message: string
+	line?: number
+	column?: number
+}
+
 /**
  * Full skill content (loaded on activation)
  */
diff --git a/webview-ui/src/components/settings/SkillsSettings.tsx b/webview-ui/src/components/settings/SkillsSettings.tsx
index bf81d0c6c7..e6480ba61d 100644
--- a/webview-ui/src/components/settings/SkillsSettings.tsx
+++ b/webview-ui/src/components/settings/SkillsSettings.tsx
@@ -1,5 +1,5 @@
 import React, { useState, useEffect, useMemo, useCallback } from "react"
-import { Plus, Globe, Folder, Edit, Trash2, Settings } from "lucide-react"
+import { Plus, Globe, Folder, Edit, Trash2, Settings, TriangleAlert } from "lucide-react"
 import { Trans } from "react-i18next"
 
 import type { SkillMetadata } from "@roo-code/types"
@@ -35,7 +35,7 @@ import { CreateSkillDialog } from "./CreateSkillDialog"
 
 export const SkillsSettings: React.FC = () => {
 	const { t } = useAppTranslation()
-	const { cwd, skills: rawSkills, customModes } = useExtensionState()
+	const { cwd, skills: rawSkills, skillDiagnostics, customModes } = useExtensionState()
 	const skills = useMemo(() => rawSkills ?? [], [rawSkills])
 
 	const [deleteDialogOpen, setDeleteDialogOpen] = useState(false)
@@ -232,6 +232,34 @@ export const SkillsSettings: React.FC = () => {
 							}}
 						/>
 					</p>
+					{skillDiagnostics.length > 0 && (
+						<div
+							role="alert"
+							className="flex gap-2 rounded-md border border-vscode-inputValidation-warningBorder bg-vscode-inputValidation-warningBackground p-3 text-sm">
+							<TriangleAlert className="mt-0.5 size-4 shrink-0" />
+							<div className="min-w-0">
+								<div className="font-medium">{t("settings:skills.diagnostics.title")}</div>
+								<div className="text-vscode-descriptionForeground">
+									{t("settings:skills.diagnostics.description")}
+								</div>
+								<ul className="mb-0 mt-2 space-y-1 pl-4">
+									{skillDiagnostics.map((diagnostic) => {
+										const location = diagnostic.line
+											? `:${diagnostic.line}${diagnostic.column ? `:${diagnostic.column}` : ""}`
+											: ""
+										return (
+											<li key={`${diagnostic.path}-${diagnostic.line}-${diagnostic.column}`}>
+												<span className="break-all font-mono">
+													{diagnostic.path + location}
+												</span>
+												<span>: {diagnostic.message}</span>
+											</li>
+										)
+									})}
+								</ul>
+							</div>
+						</div>
+					)}
 
 					{/* Add Skill button */}
 					<Button variant="secondary" className="py-1" onClick={() => setCreateDialogOpen(true)}>
diff --git a/webview-ui/src/components/settings/__tests__/SkillsSettings.spec.tsx b/webview-ui/src/components/settings/__tests__/SkillsSettings.spec.tsx
index 5c42a2dc51..e5816a16c1 100644
--- a/webview-ui/src/components/settings/__tests__/SkillsSettings.spec.tsx
+++ b/webview-ui/src/components/settings/__tests__/SkillsSettings.spec.tsx
@@ -1,7 +1,7 @@
 import { render, screen, fireEvent, waitFor } from "@/utils/test-utils"
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
 
-import type { SkillMetadata } from "@roo-code/types"
+import type { SkillDiagnostic, SkillMetadata } from "@roo-code/types"
 
 import { ExtensionStateContextProvider } from "@/context/ExtensionStateContext"
 import { vscode } from "@/utils/vscode"
@@ -166,7 +166,11 @@ vi.mock("@/context/ExtensionStateContext", () => ({
 	useExtensionState: () => mockExtensionState,
 }))
 
-const renderSkillsSettings = (skills: SkillMetadata[] = mockSkills, cwd?: string) => {
+const renderSkillsSettings = (
+	skills: SkillMetadata[] = mockSkills,
+	cwd?: string,
+	skillDiagnostics: SkillDiagnostic[] = [],
+) => {
 	const queryClient = new QueryClient({
 		defaultOptions: {
 			queries: { retry: false },
@@ -177,6 +181,7 @@ const renderSkillsSettings = (skills: SkillMetadata[] = mockSkills, cwd?: string
 	// Update the mock state before rendering
 	mockExtensionState = {
 		skills,
+		skillDiagnostics,
 		cwd: cwd !== undefined ? cwd : "/workspace",
 		customModes: [],
 	}
@@ -208,6 +213,25 @@ describe("SkillsSettings", () => {
 		expect(vscode.postMessage).toHaveBeenCalledWith({ type: "requestSkills" })
 	})
 
+	it("displays an actionable malformed-skill warning with file location and message", () => {
+		renderSkillsSettings(mockSkills, undefined, [
+			{
+				path: "/workspace/.roo/skills/broken/SKILL.md",
+				source: "project",
+				message: "bad indentation of a mapping entry",
+				line: 3,
+				column: 20,
+			},
+		])
+
+		const warning = screen.getByRole("alert")
+		expect(warning).toHaveTextContent("settings:skills.diagnostics.title")
+		expect(warning).toHaveTextContent("settings:skills.diagnostics.description")
+		expect(warning).toHaveTextContent("/workspace/.roo/skills/broken/SKILL.md:3:20")
+		expect(warning).toHaveTextContent("bad indentation of a mapping entry")
+		expect(screen.getByText("global-skill")).toBeInTheDocument()
+	})
+
 	it("displays project skills section when in a workspace", () => {
 		renderSkillsSettings()
 
diff --git a/webview-ui/src/context/ExtensionStateContext.tsx b/webview-ui/src/context/ExtensionStateContext.tsx
index 29b958319c..9ca2c00d5a 100644
--- a/webview-ui/src/context/ExtensionStateContext.tsx
+++ b/webview-ui/src/context/ExtensionStateContext.tsx
@@ -14,6 +14,7 @@ import {
 	type ExtensionState,
 	type MarketplaceInstalledMetadata,
 	type SkillMetadata,
+	type SkillDiagnostic,
 	type RuleMetadata,
 	type Command,
 	type McpServer,
@@ -149,6 +150,7 @@ export interface ExtensionStateContextType extends ExtensionState {
 	showWorktreesInHomeScreen: boolean
 	setShowWorktreesInHomeScreen: (value: boolean) => void
 	skills?: SkillMetadata[]
+	skillDiagnostics: SkillDiagnostic[]
 	rules: RuleMetadata[]
 }
 
@@ -290,6 +292,7 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode
 		global: {},
 	})
 	const [skills, setSkills] = useState<SkillMetadata[]>([])
+	const [skillDiagnostics, setSkillDiagnostics] = useState<SkillDiagnostic[]>([])
 	const [rules, setRules] = useState<RuleMetadata[]>([])
 	const [includeTaskHistoryInEnhance, setIncludeTaskHistoryInEnhance] = useState(true)
 	const [includeCurrentTime, setIncludeCurrentTime] = useState(true)
@@ -401,9 +404,8 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode
 					break
 				}
 				case "skills": {
-					if (message.skills) {
-						setSkills(message.skills)
-					}
+					setSkills(message.skills ?? [])
+					setSkillDiagnostics(message.skillDiagnostics ?? [])
 					break
 				}
 				case "rules": {
@@ -628,6 +630,7 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode
 		includeCurrentCost,
 		setIncludeCurrentCost,
 		skills,
+		skillDiagnostics,
 		rules,
 		showWorktreesInHomeScreen: state.showWorktreesInHomeScreen ?? true,
 		setShowWorktreesInHomeScreen: (value) =>
diff --git a/webview-ui/src/i18n/locales/en/settings.json b/webview-ui/src/i18n/locales/en/settings.json
index 9ef634f866..cdb6487da7 100644
--- a/webview-ui/src/i18n/locales/en/settings.json
+++ b/webview-ui/src/i18n/locales/en/settings.json
@@ -176,6 +176,10 @@
 		"configureModes": "Mode availability",
 		"modeAny": "Any mode",
 		"modeCount": "{{count}} modes",
+		"diagnostics": {
+			"title": "Some skills could not be loaded",
+			"description": "Fix the YAML frontmatter in the listed SKILL.md files, then reopen or refresh this page."
+		},
 		"deleteDialog": {
 			"title": "Delete Skill",
 			"description": "Are you sure you want to delete the skill \"{{name}}\"? This action cannot be undone.",

From d4f2ca3bed24f2c6e4e64c83b673e4fb8e454661 Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Fri, 21 Aug 2026 13:09:44 +0800
Subject: [PATCH 02/26] fix(skills): report YAML frontmatter parse errors and
 serialize SKILL.md safely

SKILL.md files whose description contains unescaped double quotes failed to parse silently: gray-matter's YAMLException was swallowed by the outer catch and users only saw a misleading "missing required 'name' field" log (issue #859).

- Catch gray-matter parse errors separately in loadSkillMetadata and log the actual YAML syntax error, with a hint pointing at unescaped double quotes in the description line
- Build createSkill frontmatter as data and serialize via matter.stringify so special characters (double quotes, YAML booleans such as "yes", etc.) are quoted automatically and created skills always load
- Pass lineWidth: -1 to the dump options (with a typed alias for gray-matter's outdated options typings) to keep long plain scalars on one line and prevent updateSkillModes rewrites from reflowing values into folded block scalars
- Add regression tests covering both the load path (invalid YAML is skipped with the real cause logged, no misleading field error) and the create path (quoted frontmatter round-trips and loads on re-discovery)
---
 .../__tests__/skillsMessageHandler.spec.ts    |  95 ++++++++
 src/services/skills/SkillsManager.ts          |  54 ++++-
 .../skills/__tests__/SkillsManager.spec.ts    | 215 ++++++++++++++++++
 3 files changed, 361 insertions(+), 3 deletions(-)

diff --git a/src/core/webview/__tests__/skillsMessageHandler.spec.ts b/src/core/webview/__tests__/skillsMessageHandler.spec.ts
index 25e1b2b48c..e4d368c9b1 100644
--- a/src/core/webview/__tests__/skillsMessageHandler.spec.ts
+++ b/src/core/webview/__tests__/skillsMessageHandler.spec.ts
@@ -27,6 +27,7 @@ vi.mock("../../../i18n", () => ({
 			"skills:errors.manager_unavailable": "Skills manager not available",
 			"skills:errors.missing_delete_fields": "Missing required fields: skillName or source",
 			"skills:errors.missing_move_fields": "Missing required fields: skillName or source",
+			"skills:errors.missing_update_modes_fields": "Missing required fields: skillName or source",
 			"skills:errors.skill_not_found": `Skill "${params?.name}" not found`,
 		}
 		return translations[key] || key
@@ -41,6 +42,7 @@ import {
 	handleDeleteSkill,
 	handleMoveSkill,
 	handleOpenSkillFile,
+	handleUpdateSkillModes,
 } from "../skillsMessageHandler"
 
 describe("skillsMessageHandler", () => {
@@ -51,6 +53,7 @@ describe("skillsMessageHandler", () => {
 	const mockCreateSkill = vi.fn()
 	const mockDeleteSkill = vi.fn()
 	const mockMoveSkill = vi.fn()
+	const mockUpdateSkillModes = vi.fn()
 	const mockGetSkill = vi.fn()
 	const mockFindSkillByNameAndSource = vi.fn()
 
@@ -62,6 +65,7 @@ describe("skillsMessageHandler", () => {
 					createSkill: mockCreateSkill,
 					deleteSkill: mockDeleteSkill,
 					moveSkill: mockMoveSkill,
+					updateSkillModes: mockUpdateSkillModes,
 					getSkill: mockGetSkill,
 					findSkillByNameAndSource: mockFindSkillByNameAndSource,
 				}
@@ -384,6 +388,97 @@ describe("skillsMessageHandler", () => {
 		})
 	})
 
+	describe("handleUpdateSkillModes", () => {
+		it("updates a skill's mode slugs successfully", async () => {
+			const provider = createMockProvider(true)
+			mockUpdateSkillModes.mockResolvedValue(undefined)
+			mockGetSkillsMetadata.mockReturnValue([mockSkills[0]])
+
+			const result = await handleUpdateSkillModes(provider, {
+				type: "updateSkillModes",
+				skillName: "test-skill",
+				source: "global",
+				newSkillModeSlugs: ["code"],
+			} as WebviewMessage)
+
+			expect(result).toEqual([mockSkills[0]])
+			expect(mockUpdateSkillModes).toHaveBeenCalledWith("test-skill", "global", ["code"])
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: [mockSkills[0]],
+				skillDiagnostics: [],
+			})
+		})
+
+		it("clears a skill's mode restriction with empty slugs", async () => {
+			const provider = createMockProvider(true)
+			mockUpdateSkillModes.mockResolvedValue(undefined)
+			mockGetSkillsMetadata.mockReturnValue([mockSkills[1]])
+
+			const result = await handleUpdateSkillModes(provider, {
+				type: "updateSkillModes",
+				skillName: "project-skill",
+				source: "project",
+				newSkillModeSlugs: [],
+			} as WebviewMessage)
+
+			expect(result).toEqual([mockSkills[1]])
+			expect(mockUpdateSkillModes).toHaveBeenCalledWith("project-skill", "project", [])
+		})
+
+		it("returns undefined when required fields are missing", async () => {
+			const provider = createMockProvider(true)
+
+			const result = await handleUpdateSkillModes(provider, {
+				type: "updateSkillModes",
+				skillName: "test-skill",
+				// missing source
+			} as WebviewMessage)
+
+			expect(result).toBeUndefined()
+			expect(mockUpdateSkillModes).not.toHaveBeenCalled()
+			expect(mockLog).toHaveBeenCalledWith(
+				"Error updating skill modes: Missing required fields: skillName or source",
+			)
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(
+				"Failed to update skill modes: Missing required fields: skillName or source",
+			)
+		})
+
+		it("returns undefined when skills manager is not available", async () => {
+			const provider = createMockProvider(false)
+
+			const result = await handleUpdateSkillModes(provider, {
+				type: "updateSkillModes",
+				skillName: "test-skill",
+				source: "global",
+				newSkillModeSlugs: ["code"],
+			} as WebviewMessage)
+
+			expect(result).toBeUndefined()
+			expect(mockLog).toHaveBeenCalledWith("Error updating skill modes: Skills manager not available")
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(
+				"Failed to update skill modes: Skills manager not available",
+			)
+		})
+
+		it("returns undefined and reports the error when updateSkillModes rejects", async () => {
+			const provider = createMockProvider(true)
+			mockUpdateSkillModes.mockRejectedValue(new Error("boom"))
+
+			const result = await handleUpdateSkillModes(provider, {
+				type: "updateSkillModes",
+				skillName: "test-skill",
+				source: "global",
+				newSkillModeSlugs: ["code"],
+			} as WebviewMessage)
+
+			expect(result).toBeUndefined()
+			expect(mockLog).toHaveBeenCalledWith("Error updating skill modes: boom")
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to update skill modes: boom")
+		})
+	})
+
 	describe("handleOpenSkillFile", () => {
 		it("opens a skill file successfully", async () => {
 			const provider = createMockProvider(true)
diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 733ac9ae92..91f732e40f 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -18,6 +18,33 @@ import { t } from "../../i18n"
 // Re-export for convenience
 export type { SkillMetadata, SkillContent, SkillDiagnostic }
 
+/**
+ * Extract the raw top-level `key: ...` line from the frontmatter block of a
+ * SKILL.md file. Used to point users at the exact line when YAML parsing
+ * fails (see issue #859). Returns undefined when the file has no
+ * frontmatter block or no matching top-level line.
+ */
+function getRawFrontmatterLine(fileContent: string, key: string): string | undefined {
+	const match = fileContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+	if (!match) {
+		return undefined
+	}
+	const linePattern = new RegExp(`^${key}\\s*:`)
+	return match[1].split(/\r?\n/).find((line) => linePattern.test(line))
+}
+
+// gray-matter's bundled typings predate its options passthrough: `stringify`
+// forwards its options object to js-yaml's safeDump, so js-yaml dump options
+// such as `lineWidth` are honored at runtime even though the declared
+// `GrayMatterOption` interface does not list them. This type names the
+// supported subset explicitly (see issue #859).
+type SkillYamlDumpOptions = matter.GrayMatterOption<string, SkillYamlDumpOptions> & { lineWidth: number }
+
+// `lineWidth: -1` keeps long plain scalars (e.g. descriptions) on a single
+// line instead of reflowing them into folded block scalars, keeping SKILL.md
+// files stable across edits.
+const SKILL_YAML_DUMP_OPTIONS: SkillYamlDumpOptions = { lineWidth: -1 }
+
 export class SkillsManager {
 	private skills: Map<string, SkillMetadata> = new Map()
 	private diagnostics: SkillDiagnostic[] = []
@@ -104,11 +131,24 @@ export class SkillsManager {
 			const fileContent = await fs.readFile(skillMdPath, "utf-8")
 			let parsed: ReturnType<typeof matter>
 
+			// Parse errors are handled separately from field validation so that
+			// YAML syntax problems (e.g. unescaped double quotes in the
+			// description) report the actual cause instead of a misleading
+			// "missing required field" message (see issue #859).
 			try {
 				parsed = matter(fileContent)
 			} catch (error) {
 				this.recordDiagnostic(skillMdPath, source, error)
 				console.error(`Failed to parse skill at ${skillDir}:`, error)
+				// The most common cause is unescaped double quotes in the
+				// description value - point the user at the exact line.
+				const descriptionLine = getRawFrontmatterLine(fileContent, "description")
+				if (descriptionLine?.includes('"')) {
+					console.error(
+						`Hint: the "description" value in ${skillMdPath} contains unescaped double quotes. ` +
+							"Wrap the value in single quotes (or escape the double quotes) and save.",
+					)
+				}
 				return
 			}
 
@@ -422,6 +462,12 @@ export class SkillsManager {
 			.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
 			.join(" ")
 
+		// Build the frontmatter as data and serialize it with gray-matter so
+		// values containing YAML special characters (e.g. double quotes in the
+		// description) are quoted/escaped automatically. Hand-built frontmatter
+		// produced unparseable SKILL.md files that silently failed to load
+		// (see issue #859). lineWidth: -1 keeps plain values on a single line,
+		// matching the previous output format.
 		const frontmatter = {
 			name,
 			description: trimmedDescription,
@@ -434,7 +480,7 @@ export class SkillsManager {
 
 Add your skill instructions here.
 `
-		const skillContent = matter.stringify(body, frontmatter)
+		const skillContent = matter.stringify(body, frontmatter, SKILL_YAML_DUMP_OPTIONS)
 
 		// Write the SKILL.md file
 		await fs.writeFile(skillMdPath, skillContent, "utf-8")
@@ -575,8 +621,10 @@ Add your skill instructions here.
 			delete frontmatter.mode
 		}
 
-		// Serialize back to SKILL.md format
-		const newContent = matter.stringify(body, frontmatter)
+		// Serialize back to SKILL.md format. lineWidth: -1 prevents long
+		// values from being reflowed into folded block scalars, keeping the
+		// file stable (see issue #859).
+		const newContent = matter.stringify(body, frontmatter, SKILL_YAML_DUMP_OPTIONS)
 		await fs.writeFile(skill.path, newContent, "utf-8")
 
 		// Refresh skills list
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index 5dbedff8fa..0d92c5b29a 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -392,6 +392,162 @@ description: Name doesn't match directory
 			expect(skills).toHaveLength(0)
 		})
 
+		it("should skip skills with invalid YAML frontmatter and log the real cause (issue #859)", async () => {
+			const badSkillDir = p(globalSkillsDir, "test-skill")
+			const badSkillMd = p(badSkillDir, "SKILL.md")
+
+			mockDirectoryExists.mockImplementation(async (dir: string) => {
+				return dir === globalSkillsDir
+			})
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockReaddir.mockImplementation(async (dir: string) => {
+				return dir === globalSkillsDir ? ["test-skill"] : []
+			})
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === badSkillDir) {
+					return { isDirectory: () => true }
+				}
+				throw new Error("Not found")
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === badSkillMd)
+			mockReadFile.mockImplementation(async (file: string) => {
+				if (file === badSkillMd) {
+					return `---
+name: test-skill
+description: Use when implementing features. Triggers on: "TDD", "test-driven development"
+---
+
+# Test Skill
+
+Instructions here.`
+				}
+				throw new Error("File not found")
+			})
+
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+
+			try {
+				await skillsManager.discoverSkills()
+
+				// The skill is skipped...
+				expect(skillsManager.getAllSkills()).toHaveLength(0)
+
+				// ...and the real cause (a YAML syntax error) is reported instead
+				// of the misleading "missing required 'name' field" message.
+				const logged = consoleErrorSpy.mock.calls.map((call) => call.join(" "))
+				expect(logged.some((line) => line.includes("YAMLException"))).toBe(true)
+				expect(logged.some((line) => line.includes("missing required 'name' field"))).toBe(false)
+				// The unescaped-double-quotes hint points at the exact problem.
+				expect(logged.some((line) => line.includes("unescaped double quotes"))).toBe(true)
+
+				// The structured diagnostic captures the parse failure location.
+				const diagnostics = skillsManager.getSkillDiagnostics()
+				expect(diagnostics).toHaveLength(1)
+				expect(diagnostics[0].path).toBe(badSkillMd)
+				expect(diagnostics[0].source).toBe("global")
+				expect(typeof diagnostics[0].message).toBe("string")
+				expect(diagnostics[0].line).toBe(3)
+			} finally {
+				consoleErrorSpy.mockRestore()
+			}
+		})
+
+		it("should log a distinct YAML error for other malformed frontmatter (no quote hint)", async () => {
+			const badSkillDir = p(globalSkillsDir, "broken-skill")
+			const badSkillMd = p(badSkillDir, "SKILL.md")
+
+			mockDirectoryExists.mockImplementation(async (dir: string) => {
+				return dir === globalSkillsDir
+			})
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockReaddir.mockImplementation(async (dir: string) => {
+				return dir === globalSkillsDir ? ["broken-skill"] : []
+			})
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === badSkillDir) {
+					return { isDirectory: () => true }
+				}
+				throw new Error("Not found")
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === badSkillMd)
+			mockReadFile.mockImplementation(async (file: string) => {
+				if (file === badSkillMd) {
+					return `---
+name broken-skill
+description: Missing colon makes this invalid YAML
+---
+
+# Broken skill`
+				}
+				throw new Error("File not found")
+			})
+
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+
+			try {
+				await skillsManager.discoverSkills()
+
+				expect(skillsManager.getAllSkills()).toHaveLength(0)
+
+				const logged = consoleErrorSpy.mock.calls.map((call) => call.join(" "))
+				expect(logged.some((line) => line.includes("YAMLException"))).toBe(true)
+				expect(skillsManager.getSkillDiagnostics()).toHaveLength(1)
+				// The unescaped-quotes hint only applies when the description line
+				// actually contains double quotes.
+				expect(logged.some((line) => line.includes("unescaped double quotes"))).toBe(false)
+			} finally {
+				consoleErrorSpy.mockRestore()
+			}
+		})
+
+		it("should skip skills with unterminated frontmatter and a dangling quote (no line hint)", async () => {
+			const badSkillDir = p(globalSkillsDir, "unclosed-skill")
+			const badSkillMd = p(badSkillDir, "SKILL.md")
+
+			mockDirectoryExists.mockImplementation(async (dir: string) => {
+				return dir === globalSkillsDir
+			})
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockReaddir.mockImplementation(async (dir: string) => {
+				return dir === globalSkillsDir ? ["unclosed-skill"] : []
+			})
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === badSkillDir) {
+					return { isDirectory: () => true }
+				}
+				throw new Error("Not found")
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === badSkillMd)
+			mockReadFile.mockImplementation(async (file: string) => {
+				if (file === badSkillMd) {
+					// Unterminated frontmatter: the opening --- is never closed, and the
+					// dangling double quote makes gray-matter throw. The raw-line lookup
+					// cannot find a closing delimiter, so no quote hint is possible.
+					return `---
+name: unclosed-skill
+description: "unclosed quote
+rest of the file`
+				}
+				throw new Error("File not found")
+			})
+
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+
+			try {
+				await skillsManager.discoverSkills()
+
+				expect(skillsManager.getAllSkills()).toHaveLength(0)
+
+				const logged = consoleErrorSpy.mock.calls.map((call) => call.join(" "))
+				expect(logged.some((line) => line.includes("YAMLException"))).toBe(true)
+				expect(skillsManager.getSkillDiagnostics()).toHaveLength(1)
+				// Without a closing frontmatter delimiter there is no line to hint at.
+				expect(logged.some((line) => line.includes("unescaped double quotes"))).toBe(false)
+			} finally {
+				consoleErrorSpy.mockRestore()
+			}
+		})
+
 		it("should skip skills with invalid name formats (spec compliance)", async () => {
 			const invalidNames = [
 				"PDF-processing", // uppercase
@@ -1288,6 +1444,65 @@ Instructions`)
 			expect(createdPath).toBe(p(PROJECT_DIR, ".roo", "skills", "project-skill", "SKILL.md"))
 		})
 
+		it("should escape double quotes in the description so the created skill loads (issue #859)", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			mockMkdir.mockResolvedValue(undefined)
+			mockWriteFile.mockResolvedValue(undefined)
+
+			const description = 'Use when implementing features. Triggers on: "TDD", "test-driven development"'
+			const createdPath = await skillsManager.createSkill("test-skill", "global", description)
+
+			// The written frontmatter must be valid YAML that round-trips the
+			// description, with the raw value quoted instead of unescaped.
+			const writtenContent = String(mockWriteFile.mock.calls[0][1])
+			const parsed = matter(writtenContent)
+			expect(parsed.data.name).toBe("test-skill")
+			expect(parsed.data.description).toBe(description)
+			expect(writtenContent).toContain(`description: '${description}'`)
+
+			// Re-discovery loads the created skill instead of silently skipping it.
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["test-skill"] : []))
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === p(globalSkillsDir, "test-skill")) {
+					return { isDirectory: () => true }
+				}
+				throw new Error("Not found")
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === createdPath)
+			mockReadFile.mockImplementation(async (file: string) =>
+				file === createdPath ? writtenContent : Promise.reject(new Error("File not found")),
+			)
+
+			await skillsManager.discoverSkills()
+
+			const skills = skillsManager.getAllSkills()
+			expect(skills).toHaveLength(1)
+			expect(skills[0].name).toBe("test-skill")
+			expect(skills[0].description).toBe(description)
+		})
+
+		it("should quote descriptions that would otherwise parse as YAML non-strings", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			mockMkdir.mockResolvedValue(undefined)
+			mockWriteFile.mockResolvedValue(undefined)
+
+			await skillsManager.createSkill("flag-skill", "global", "yes")
+
+			const writtenContent = String(mockWriteFile.mock.calls[0][1])
+			const parsed = matter(writtenContent)
+			// Without quoting, js-yaml resolves "yes" to a boolean and the skill
+			// is rejected with a misleading "missing required 'description' field".
+			expect(typeof parsed.data.description).toBe("string")
+			expect(parsed.data.description).toBe("yes")
+		})
+
 		it("should throw error for invalid skill name", async () => {
 			await expect(skillsManager.createSkill("Invalid-Name", "global", "Description")).rejects.toThrow(
 				"Skill name must be lowercase letters/numbers/hyphens only",

From 6c2e44ec30811eccb32dd6aef8f6b34c59c8a70b Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Fri, 21 Aug 2026 14:36:54 +0800
Subject: [PATCH 03/26] fix(i18n): add skill diagnostics translations and cover
 updateSkillModes

- Add settings:skills.diagnostics.title/description to all 17 non-English
  locales; the diagnostics panel keys from #934 were only in en, which
  failed the check-translations CI job (scripts/find-missing-translations.js).
- Add an updateSkillModes unit test (modeSlugs written, then cleared;
  description survives the gray-matter round-trip un-reflowed), closing the
  last patch-coverage gap on the SKILL.md serialization lines.
---
 .../skills/__tests__/SkillsManager.spec.ts    | 55 +++++++++++++++++++
 webview-ui/src/i18n/locales/ca/settings.json  |  4 ++
 webview-ui/src/i18n/locales/de/settings.json  |  4 ++
 webview-ui/src/i18n/locales/es/settings.json  |  4 ++
 webview-ui/src/i18n/locales/fr/settings.json  |  4 ++
 webview-ui/src/i18n/locales/hi/settings.json  |  4 ++
 webview-ui/src/i18n/locales/id/settings.json  |  4 ++
 webview-ui/src/i18n/locales/it/settings.json  |  4 ++
 webview-ui/src/i18n/locales/ja/settings.json  |  4 ++
 webview-ui/src/i18n/locales/ko/settings.json  |  4 ++
 webview-ui/src/i18n/locales/nl/settings.json  |  4 ++
 webview-ui/src/i18n/locales/pl/settings.json  |  4 ++
 .../src/i18n/locales/pt-BR/settings.json      |  4 ++
 webview-ui/src/i18n/locales/ru/settings.json  |  4 ++
 webview-ui/src/i18n/locales/tr/settings.json  |  4 ++
 webview-ui/src/i18n/locales/vi/settings.json  |  4 ++
 .../src/i18n/locales/zh-CN/settings.json      |  4 ++
 .../src/i18n/locales/zh-TW/settings.json      |  4 ++
 18 files changed, 123 insertions(+)

diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index 0d92c5b29a..be059dc884 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -1503,6 +1503,61 @@ Instructions`)
 			expect(parsed.data.description).toBe("yes")
 		})
 
+		it("should rewrite modeSlugs via gray-matter serialization without reflowing the description", async () => {
+			const skillDir = p(globalSkillsDir, "modes-skill")
+			const skillMd = p(skillDir, "SKILL.md")
+			const description = 'Use when implementing features. Triggers on: "TDD", "test-driven development"'
+			const originalContent = `---
+name: modes-skill
+description: '${description}'
+---
+
+# Modes Skill
+
+## Instructions
+
+Body here.`
+
+			// Initial discovery so the skill is registered.
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["modes-skill"] : []))
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === skillDir) {
+					return { isDirectory: () => true }
+				}
+				throw new Error("Not found")
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === skillMd)
+			mockReadFile.mockResolvedValue(originalContent)
+			mockWriteFile.mockResolvedValue(undefined)
+
+			await skillsManager.discoverSkills()
+			expect(skillsManager.getAllSkills()).toHaveLength(1)
+
+			// Apply a mode restriction; the file is rewritten with the new slugs.
+			await skillsManager.updateSkillModes("modes-skill", "global", ["code"])
+
+			expect(mockWriteFile).toHaveBeenCalledTimes(1)
+			const rewritten = String(mockWriteFile.mock.calls[0][1])
+			const parsed = matter(rewritten)
+			// The description survives the round-trip exactly and stays quoted.
+			expect(parsed.data.description).toBe(description)
+			expect(rewritten).toContain(`description: '${description}'`)
+			// The new modeSlugs were written and the body is preserved.
+			expect(parsed.data.modeSlugs).toEqual(["code"])
+			expect(rewritten).toContain("Body here.")
+			// lineWidth: -1 keeps the value on a single line (no folded block scalar).
+			expect(rewritten).not.toContain("> ")
+
+			// Clearing the restriction removes modeSlugs from the frontmatter.
+			await skillsManager.updateSkillModes("modes-skill", "global", [])
+
+			const rewritten2 = String(mockWriteFile.mock.calls[1][1])
+			const parsed2 = matter(rewritten2)
+			expect(parsed2.data.modeSlugs).toBeUndefined()
+			expect(parsed2.data.description).toBe(description)
+		})
+
 		it("should throw error for invalid skill name", async () => {
 			await expect(skillsManager.createSkill("Invalid-Name", "global", "Description")).rejects.toThrow(
 				"Skill name must be lowercase letters/numbers/hyphens only",
diff --git a/webview-ui/src/i18n/locales/ca/settings.json b/webview-ui/src/i18n/locales/ca/settings.json
index fa5cc11d65..f233f0dcb0 100644
--- a/webview-ui/src/i18n/locales/ca/settings.json
+++ b/webview-ui/src/i18n/locales/ca/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Disponibilitat del mode",
 		"modeAny": "Qualsevol mode",
 		"modeCount": "{{count}} modes",
+		"diagnostics": {
+			"title": "No s'han pogut carregar algunes skills",
+			"description": "Corrigeu el frontmatter YAML dels fitxers SKILL.md esmentats i, a continuació, torneu a obrir o actualitzar aquesta pàgina."
+		},
 		"deleteDialog": {
 			"title": "Eliminar Skill",
 			"description": "Estàs segur que vols eliminar la skill \"{{name}}\"? Aquesta acció no es pot desfer.",
diff --git a/webview-ui/src/i18n/locales/de/settings.json b/webview-ui/src/i18n/locales/de/settings.json
index 2cb83f7893..cc49bb326b 100644
--- a/webview-ui/src/i18n/locales/de/settings.json
+++ b/webview-ui/src/i18n/locales/de/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Modverfügbarkeit",
 		"modeAny": "Beliebiger Modus",
 		"modeCount": "{{count}} Modi",
+		"diagnostics": {
+			"title": "Einige Skills konnten nicht geladen werden",
+			"description": "Korrigiere das YAML-Frontmatter in den aufgeführten SKILL.md-Dateien und öffne diese Seite anschließend erneut oder aktualisiere sie."
+		},
 		"deleteDialog": {
 			"title": "Skill löschen",
 			"description": "Bist du sicher, dass du den Skill \"{{name}}\" löschen möchtest? Diese Aktion kann nicht rückgängig gemacht werden.",
diff --git a/webview-ui/src/i18n/locales/es/settings.json b/webview-ui/src/i18n/locales/es/settings.json
index 305a8dd5d7..f7812503a2 100644
--- a/webview-ui/src/i18n/locales/es/settings.json
+++ b/webview-ui/src/i18n/locales/es/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Disponibilidad de modo",
 		"modeAny": "Cualquier modo",
 		"modeCount": "{{count}} modos",
+		"diagnostics": {
+			"title": "No se pudieron cargar algunas skills",
+			"description": "Corrige el frontmatter YAML en los archivos SKILL.md enumerados y luego vuelve a abrir o actualizar esta página."
+		},
 		"deleteDialog": {
 			"title": "Eliminar Skill",
 			"description": "¿Estás seguro de que quieres eliminar la skill \"{{name}}\"? Esta acción no se puede deshacer.",
diff --git a/webview-ui/src/i18n/locales/fr/settings.json b/webview-ui/src/i18n/locales/fr/settings.json
index d5728833dd..8de5e8bb67 100644
--- a/webview-ui/src/i18n/locales/fr/settings.json
+++ b/webview-ui/src/i18n/locales/fr/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Disponibilité du mode",
 		"modeAny": "N'importe quel mode",
 		"modeCount": "{{count}} modes",
+		"diagnostics": {
+			"title": "Certaines skills n'ont pas pu être chargées",
+			"description": "Corrigez le frontmatter YAML des fichiers SKILL.md listés, puis rouvrez ou actualisez cette page."
+		},
 		"deleteDialog": {
 			"title": "Supprimer la Skill",
 			"description": "Êtes-vous sûr de vouloir supprimer la skill \"{{name}}\" ? Cette action ne peut pas être annulée.",
diff --git a/webview-ui/src/i18n/locales/hi/settings.json b/webview-ui/src/i18n/locales/hi/settings.json
index 3fce97a378..e1a31002bf 100644
--- a/webview-ui/src/i18n/locales/hi/settings.json
+++ b/webview-ui/src/i18n/locales/hi/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "मोड उपलब्धता",
 		"modeAny": "कोई भी मोड",
 		"modeCount": "{{count}} मोड",
+		"diagnostics": {
+			"title": "कुछ skills लोड नहीं हो सके",
+			"description": "सूचीबद्ध SKILL.md फ़ाइलों में YAML frontmatter को ठीक करें, फिर इस पृष्ठ को फिर से खोलें या रिफ़्रेश करें।"
+		},
 		"deleteDialog": {
 			"title": "Skill हटाएं",
 			"description": "क्या आप वाकई skill \"{{name}}\" को हटाना चाहते हैं? यह क्रिया पूर्ववत नहीं की जा सकती।",
diff --git a/webview-ui/src/i18n/locales/id/settings.json b/webview-ui/src/i18n/locales/id/settings.json
index bcdd0ae76d..309b978994 100644
--- a/webview-ui/src/i18n/locales/id/settings.json
+++ b/webview-ui/src/i18n/locales/id/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Ketersediaan mode",
 		"modeAny": "Mode apa saja",
 		"modeCount": "{{count}} mode",
+		"diagnostics": {
+			"title": "Beberapa skill tidak dapat dimuat",
+			"description": "Perbaiki frontmatter YAML di file SKILL.md yang tercantum, lalu buka ulang atau muat ulang halaman ini."
+		},
 		"deleteDialog": {
 			"title": "Hapus Skill",
 			"description": "Apakah Anda yakin ingin menghapus skill \"{{name}}\"? Tindakan ini tidak dapat dibatalkan.",
diff --git a/webview-ui/src/i18n/locales/it/settings.json b/webview-ui/src/i18n/locales/it/settings.json
index b22fb4c652..07e7af6f4d 100644
--- a/webview-ui/src/i18n/locales/it/settings.json
+++ b/webview-ui/src/i18n/locales/it/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Disponibilità modalità",
 		"modeAny": "Qualsiasi modalità",
 		"modeCount": "{{count}} modalità",
+		"diagnostics": {
+			"title": "Impossibile caricare alcune skills",
+			"description": "Correggi il frontmatter YAML nei file SKILL.md elencati, quindi riapri o aggiorna questa pagina."
+		},
 		"deleteDialog": {
 			"title": "Elimina Skill",
 			"description": "Sei sicuro di voler eliminare la skill \"{{name}}\"? Questa azione non può essere annullata.",
diff --git a/webview-ui/src/i18n/locales/ja/settings.json b/webview-ui/src/i18n/locales/ja/settings.json
index bbdc5c8e8a..2bcbe8edef 100644
--- a/webview-ui/src/i18n/locales/ja/settings.json
+++ b/webview-ui/src/i18n/locales/ja/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "モード可用性",
 		"modeAny": "任意のモード",
 		"modeCount": "{{count}} モード",
+		"diagnostics": {
+			"title": "一部のスキルを読み込めませんでした",
+			"description": "該当する SKILL.md ファイルの YAML フロントマターを修正してから、このページを再表示してください。"
+		},
 		"deleteDialog": {
 			"title": "スキルを削除",
 			"description": "スキル「{{name}}」を削除してもよろしいですか？この操作は元に戻せません。",
diff --git a/webview-ui/src/i18n/locales/ko/settings.json b/webview-ui/src/i18n/locales/ko/settings.json
index c2062a5335..8c3d01973f 100644
--- a/webview-ui/src/i18n/locales/ko/settings.json
+++ b/webview-ui/src/i18n/locales/ko/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "모드 가용성",
 		"modeAny": "모든 모드",
 		"modeCount": "{{count}} 모드",
+		"diagnostics": {
+			"title": "일부 스킬을 불러오지 못했습니다",
+			"description": "열거된 SKILL.md 파일의 YAML frontmatter를 수정한 후, 이 페이지를 다시 열거나 새로고침해 주세요."
+		},
 		"deleteDialog": {
 			"title": "스킬 삭제",
 			"description": "스킬 \"{{name}}\"을(를) 삭제하시겠습니까? 이 작업은 취소할 수 없습니다.",
diff --git a/webview-ui/src/i18n/locales/nl/settings.json b/webview-ui/src/i18n/locales/nl/settings.json
index cf148f5617..28bd16cde9 100644
--- a/webview-ui/src/i18n/locales/nl/settings.json
+++ b/webview-ui/src/i18n/locales/nl/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Modebeschikbaarheid",
 		"modeAny": "Elke modus",
 		"modeCount": "{{count}} modus",
+		"diagnostics": {
+			"title": "Sommige skills konden niet worden geladen",
+			"description": "Corrigeer de YAML-frontmatter in de opgesomde SKILL.md-bestanden en open daarna deze pagina opnieuw of vernieuw deze."
+		},
 		"deleteDialog": {
 			"title": "Skill verwijderen",
 			"description": "Weet u zeker dat u de skill \"{{name}}\" wilt verwijderen? Deze actie kan niet ongedaan worden gemaakt.",
diff --git a/webview-ui/src/i18n/locales/pl/settings.json b/webview-ui/src/i18n/locales/pl/settings.json
index ace780f529..e86d18bfc7 100644
--- a/webview-ui/src/i18n/locales/pl/settings.json
+++ b/webview-ui/src/i18n/locales/pl/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Dostępność trybu",
 		"modeAny": "Dowolny tryb",
 		"modeCount": "{{count}} tryby",
+		"diagnostics": {
+			"title": "Nie udało się załadować niektórych skills",
+			"description": "Popraw frontmatter YAML w wymienionych plikach SKILL.md, a następnie otwórz ponownie lub odśwież tę stronę."
+		},
 		"deleteDialog": {
 			"title": "Usuń Umiejętność",
 			"description": "Czy na pewno chcesz usunąć umiejętność \"{{name}}\"? Tej akcji nie można cofnąć.",
diff --git a/webview-ui/src/i18n/locales/pt-BR/settings.json b/webview-ui/src/i18n/locales/pt-BR/settings.json
index 446aa8ac02..e9803fa23d 100644
--- a/webview-ui/src/i18n/locales/pt-BR/settings.json
+++ b/webview-ui/src/i18n/locales/pt-BR/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Disponibilidade de modo",
 		"modeAny": "Qualquer modo",
 		"modeCount": "{{count}} modos",
+		"diagnostics": {
+			"title": "Não foi possível carregar algumas skills",
+			"description": "Corrija o frontmatter YAML nos arquivos SKILL.md listados e, em seguida, reabra ou atualize esta página."
+		},
 		"deleteDialog": {
 			"title": "Excluir Skill",
 			"description": "Tem certeza de que deseja excluir a skill \"{{name}}\"? Esta ação não pode ser desfeita.",
diff --git a/webview-ui/src/i18n/locales/ru/settings.json b/webview-ui/src/i18n/locales/ru/settings.json
index f2719ad06e..acdd691e24 100644
--- a/webview-ui/src/i18n/locales/ru/settings.json
+++ b/webview-ui/src/i18n/locales/ru/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Доступность режима",
 		"modeAny": "Любой режим",
 		"modeCount": "{{count}} режимов",
+		"diagnostics": {
+			"title": "Не удалось загрузить некоторые skills",
+			"description": "Исправьте YAML frontmatter в перечисленных файлах SKILL.md, затем снова откройте или обновите эту страницу."
+		},
 		"deleteDialog": {
 			"title": "Удалить Навык",
 			"description": "Вы уверены, что хотите удалить навык \"{{name}}\"? Это действие нельзя отменить.",
diff --git a/webview-ui/src/i18n/locales/tr/settings.json b/webview-ui/src/i18n/locales/tr/settings.json
index 08374b6d20..bf77e04c74 100644
--- a/webview-ui/src/i18n/locales/tr/settings.json
+++ b/webview-ui/src/i18n/locales/tr/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Mod Kullanılabilirliği",
 		"modeAny": "Herhangi bir mod",
 		"modeCount": "{{count}} mod",
+		"diagnostics": {
+			"title": "Bazı skill'ler yüklenemedi",
+			"description": "Listelenen SKILL.md dosyalarındaki YAML frontmatter'ını düzeltin, ardından bu sayfayı yeniden açın veya yenileyin."
+		},
 		"deleteDialog": {
 			"title": "Beceriyi Sil",
 			"description": "\"{{name}}\" becerisini silmek istediğinizden emin misiniz? Bu işlem geri alınamaz.",
diff --git a/webview-ui/src/i18n/locales/vi/settings.json b/webview-ui/src/i18n/locales/vi/settings.json
index a8611ca687..5bbbad7d92 100644
--- a/webview-ui/src/i18n/locales/vi/settings.json
+++ b/webview-ui/src/i18n/locales/vi/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "Tính khả dụng của chế độ",
 		"modeAny": "Bất kỳ chế độ nào",
 		"modeCount": "{{count}} chế độ",
+		"diagnostics": {
+			"title": "Không thể tải một số skill",
+			"description": "Sửa frontmatter YAML trong các tệp SKILL.md được liệt kê, sau đó mở lại hoặc làm mới trang này."
+		},
 		"deleteDialog": {
 			"title": "Xóa Skill",
 			"description": "Bạn có chắc chắn muốn xóa skill \"{{name}}\" không? Hành động này không thể hoàn tác.",
diff --git a/webview-ui/src/i18n/locales/zh-CN/settings.json b/webview-ui/src/i18n/locales/zh-CN/settings.json
index 9f3913e872..587a3808ba 100644
--- a/webview-ui/src/i18n/locales/zh-CN/settings.json
+++ b/webview-ui/src/i18n/locales/zh-CN/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "模式可用性",
 		"modeAny": "任意模式",
 		"modeCount": "{{count}} 种模式",
+		"diagnostics": {
+			"title": "部分技能加载失败",
+			"description": "请修复所列 SKILL.md 文件中的 YAML frontmatter，然后重新打开或刷新此页面。"
+		},
 		"deleteDialog": {
 			"title": "删除技能",
 			"description": "您确定要删除技能\"{{name}}\"吗？此操作无法撤销。",
diff --git a/webview-ui/src/i18n/locales/zh-TW/settings.json b/webview-ui/src/i18n/locales/zh-TW/settings.json
index 80d0d18735..ee3e189814 100644
--- a/webview-ui/src/i18n/locales/zh-TW/settings.json
+++ b/webview-ui/src/i18n/locales/zh-TW/settings.json
@@ -1131,6 +1131,10 @@
 		"configureModes": "模式可用性",
 		"modeAny": "任意模式",
 		"modeCount": "{{count}} 種模式",
+		"diagnostics": {
+			"title": "部分技能無法載入",
+			"description": "請修正所列 SKILL.md 檔案中的 YAML frontmatter，然後重新開啟或重新整理此頁面。"
+		},
 		"deleteDialog": {
 			"title": "刪除技能",
 			"description": "您確定要刪除技能「{{name}}」嗎？此動作無法復原。",

From 928f3bff71c3f30ef85bd2dccd0abca7665f2c9c Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Fri, 21 Aug 2026 14:56:15 +0800
Subject: [PATCH 04/26] fix(webview): default skillDiagnostics to empty array
 in SkillsSettings

#934 added skillDiagnostics to ExtensionState as an optional field but
SkillsSettings read it without a fallback, so every SettingsView render
where the field is absent crashed with "Cannot read properties of
undefined (reading 'length')". This broke 14 webview tests in the
platform-unit-test CI job (SettingsView.change-detection and
SettingsView.unsaved-changes).

Mirror the existing skills handling: fall back to [] via useMemo.
---
 webview-ui/src/components/settings/SkillsSettings.tsx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/webview-ui/src/components/settings/SkillsSettings.tsx b/webview-ui/src/components/settings/SkillsSettings.tsx
index e6480ba61d..9c250e8514 100644
--- a/webview-ui/src/components/settings/SkillsSettings.tsx
+++ b/webview-ui/src/components/settings/SkillsSettings.tsx
@@ -35,8 +35,9 @@ import { CreateSkillDialog } from "./CreateSkillDialog"
 
 export const SkillsSettings: React.FC = () => {
 	const { t } = useAppTranslation()
-	const { cwd, skills: rawSkills, skillDiagnostics, customModes } = useExtensionState()
+	const { cwd, skills: rawSkills, skillDiagnostics: rawSkillDiagnostics, customModes } = useExtensionState()
 	const skills = useMemo(() => rawSkills ?? [], [rawSkills])
+	const skillDiagnostics = useMemo(() => rawSkillDiagnostics ?? [], [rawSkillDiagnostics])
 
 	const [deleteDialogOpen, setDeleteDialogOpen] = useState(false)
 	const [skillToDelete, setSkillToDelete] = useState<SkillMetadata | null>(null)

From 987fa9aa947eb6d7de8b2bb1b82451f6338b13ec Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Fri, 21 Aug 2026 14:56:38 +0800
Subject: [PATCH 05/26] test(e2e): smoke test skill diagnostics across the
 extension-host boundary

Add apps/vscode-e2e/src/suite/skills-diagnostics.test.ts covering the
real extension host -> SkillsManager -> file watcher flow that lower
layers cannot reach:

- Writes a healthy and a malformed (issue #859 content) SKILL.md into
  the workspace's .roo/skills directory on real disk.
- Waits for the extension host's file watcher to re-discover and asserts
  the malformed skill is omitted from getSkillsState().skills while a
  diagnostic points at it, and the healthy skill is unaffected.
- Repairs the frontmatter in place and asserts the watcher clears the
  diagnostic and loads the fixed skill.

Supports this with a test-only getSkillsState() on the exported
extension API (mirroring the existing getTaskHistoryItem pattern),
backed by ClineProvider.getSkillsManager().

Verified locally: bundle + webview build + USE_MOCK=true test:run with
TEST_FILE=skills-diagnostics.test.js -> 1 passing.
---
 .../src/suite/skills-diagnostics.test.ts      | 120 ++++++++++++++++++
 packages/types/src/api.ts                     |  10 ++
 src/extension/api.ts                          |  11 ++
 3 files changed, 141 insertions(+)
 create mode 100644 apps/vscode-e2e/src/suite/skills-diagnostics.test.ts

diff --git a/apps/vscode-e2e/src/suite/skills-diagnostics.test.ts b/apps/vscode-e2e/src/suite/skills-diagnostics.test.ts
new file mode 100644
index 0000000000..dca14cc515
--- /dev/null
+++ b/apps/vscode-e2e/src/suite/skills-diagnostics.test.ts
@@ -0,0 +1,120 @@
+import * as assert from "assert"
+import * as fs from "fs/promises"
+import * as path from "path"
+
+import * as vscode from "vscode"
+
+import { setDefaultSuiteTimeout } from "./test-utils"
+import { waitFor } from "./utils"
+
+const GOOD_SKILL = "e2e-skill-good"
+const BAD_SKILL = "e2e-skill-bad"
+
+// Issue #859 reproduction content: unescaped double quotes in the description
+// make the YAML frontmatter unparseable.
+const MALFORMED_SKILL_MD = `---
+name: ${BAD_SKILL}
+description: Use when implementing features. Triggers on: "TDD", "test-driven development"
+---
+
+# E2E Skill Bad
+
+Instructions here.
+`
+
+const FIXED_SKILL_MD = `---
+name: ${BAD_SKILL}
+description: 'Use when implementing features. Triggers on: "TDD", "test-driven development"'
+---
+
+# E2E Skill Bad
+
+Instructions here.
+`
+
+const GOOD_SKILL_MD = `---
+name: ${GOOD_SKILL}
+description: A healthy skill used by the skill diagnostics e2e smoke test.
+---
+
+# E2E Skill Good
+
+Instructions here.
+`
+
+suite("Roo Code Skill Diagnostics", function () {
+	setDefaultSuiteTimeout(this)
+
+	let skillsRoot: string
+
+	setup(async function () {
+		const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+		assert.ok(workspaceRoot, "e2e workspace folder must be open")
+		skillsRoot = path.join(workspaceRoot, ".roo", "skills")
+	})
+
+	teardown(async function () {
+		await fs.rm(skillsRoot, { recursive: true, force: true })
+	})
+
+	test("should surface a malformed SKILL.md as a diagnostic without hiding healthy skills", async function () {
+		this.timeout(180_000)
+
+		// Arrange: one healthy skill and one malformed skill on real disk in the
+		// workspace's .roo/skills directory.
+		await fs.mkdir(path.join(skillsRoot, GOOD_SKILL), { recursive: true })
+		await fs.writeFile(path.join(skillsRoot, GOOD_SKILL, "SKILL.md"), GOOD_SKILL_MD, "utf8")
+		await fs.mkdir(path.join(skillsRoot, BAD_SKILL), { recursive: true })
+		await fs.writeFile(path.join(skillsRoot, BAD_SKILL, "SKILL.md"), MALFORMED_SKILL_MD, "utf8")
+
+		// Act: the extension host's file watcher re-discovers skills; wait until
+		// the real SkillsManager reports the healthy skill and a diagnostic for
+		// the malformed one.
+		await waitFor(
+			async () => {
+				const state = globalThis.api.getSkillsState()
+				const goodVisible = state.skills.some((skill) => skill.name === GOOD_SKILL)
+				const badDiagnosed = state.skillDiagnostics.some((diagnostic) => diagnostic.path.includes(BAD_SKILL))
+				return goodVisible && badDiagnosed
+			},
+			{ timeout: 60_000, interval: 500 },
+		)
+
+		// Assert: the malformed skill is skipped with a diagnostic pointing at it,
+		// while the healthy skill is unaffected.
+		const state = globalThis.api.getSkillsState()
+		const diagnostic = state.skillDiagnostics.find((d) => d.path.includes(BAD_SKILL))
+		assert.ok(diagnostic, "malformed SKILL.md should produce a diagnostic")
+		assert.strictEqual(diagnostic.source, "project")
+		assert.ok(diagnostic.message.length > 0, "diagnostic should carry the parse error message")
+		assert.ok(
+			state.skills.some((skill) => skill.name === GOOD_SKILL),
+			"healthy skill should still be discovered",
+		)
+		assert.ok(
+			!state.skills.some((skill) => skill.name === BAD_SKILL),
+			"malformed skill should be omitted from skills",
+		)
+
+		// Act: repair the frontmatter in place; the watcher re-discovers and the
+		// diagnostic clears.
+		await fs.writeFile(path.join(skillsRoot, BAD_SKILL, "SKILL.md"), FIXED_SKILL_MD, "utf8")
+
+		await waitFor(
+			async () => {
+				const next = globalThis.api.getSkillsState()
+				const cleared = !next.skillDiagnostics.some((d) => d.path.includes(BAD_SKILL))
+				const loaded = next.skills.some((skill) => skill.name === BAD_SKILL)
+				return cleared && loaded
+			},
+			{ timeout: 60_000, interval: 500 },
+		)
+
+		const fixed = globalThis.api.getSkillsState()
+		assert.ok(
+			fixed.skills.some((skill) => skill.name === BAD_SKILL),
+			"fixed skill should load after repair",
+		)
+		assert.ok(fixed.skills.find((skill) => skill.name === BAD_SKILL)?.description.includes("TDD") === true)
+	})
+})
diff --git a/packages/types/src/api.ts b/packages/types/src/api.ts
index 89e9c8bc2b..b702f67b32 100644
--- a/packages/types/src/api.ts
+++ b/packages/types/src/api.ts
@@ -6,6 +6,7 @@ import type { RooCodeSettings } from "./global-settings.js"
 import type { HistoryItem } from "./history.js"
 import type { ProviderSettingsEntry, ProviderSettings } from "./provider-settings.js"
 import type { IpcMessage, IpcServerEvents } from "./ipc.js"
+import type { SkillDiagnostic, SkillMetadata } from "./skills.js"
 
 export type RooCodeAPIEvents = RooCodeEvents
 
@@ -51,6 +52,15 @@ export interface RooCodeAPI extends EventEmitter<RooCodeAPIEvents> {
 	 * @returns The number of persisted API conversation history entries, or 0 if unavailable.
 	 */
 	getTaskApiConversationHistoryLength(taskId: string): Promise<number>
+	/**
+	 * Returns the skill metadata and load diagnostics currently discovered by the
+	 * extension host. Intended for use in tests only.
+	 * @returns The discovered skills and any diagnostics for skills that failed to load.
+	 */
+	getSkillsState(): {
+		skills: SkillMetadata[]
+		skillDiagnostics: SkillDiagnostic[]
+	}
 	/**
 	 * Returns the current task stack.
 	 * @returns An array of task IDs.
diff --git a/src/extension/api.ts b/src/extension/api.ts
index b57dc89b74..80c2e90864 100644
--- a/src/extension/api.ts
+++ b/src/extension/api.ts
@@ -250,6 +250,17 @@ export class API extends EventEmitter<RooCodeEvents> implements RooCodeAPI {
 		}
 	}
 
+	public getSkillsState() {
+		const skillsManager = this.sidebarProvider.getSkillsManager()
+		if (!skillsManager) {
+			return { skills: [], skillDiagnostics: [] }
+		}
+		return {
+			skills: skillsManager.getSkillsMetadata(),
+			skillDiagnostics: skillsManager.getSkillDiagnostics(),
+		}
+	}
+
 	public getCurrentTaskStack() {
 		return this.sidebarProvider.getCurrentTaskStack()
 	}

From 65a0ff3f263e8cf274ca2e0192afe45527241c68 Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Fri, 21 Aug 2026 14:57:15 +0800
Subject: [PATCH 06/26] test(api): cover the test-only getSkillsState accessor

Unit coverage for the new extension API method used by the skill
diagnostics e2e smoke test: returns the skills manager's metadata and
diagnostics, and empty arrays when the manager is unavailable.
---
 .../__tests__/api-get-skills-state.spec.ts    | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 src/extension/__tests__/api-get-skills-state.spec.ts

diff --git a/src/extension/__tests__/api-get-skills-state.spec.ts b/src/extension/__tests__/api-get-skills-state.spec.ts
new file mode 100644
index 0000000000..32a0c57262
--- /dev/null
+++ b/src/extension/__tests__/api-get-skills-state.spec.ts
@@ -0,0 +1,57 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import * as vscode from "vscode"
+
+import { API } from "../api"
+import { ClineProvider } from "../../core/webview/ClineProvider"
+
+vi.mock("vscode")
+vi.mock("../../core/webview/ClineProvider")
+
+describe("API#getSkillsState", () => {
+	let api: API
+	let mockOutputChannel: vscode.OutputChannel
+	let mockProvider: ClineProvider
+	let mockGetSkillsManager: ReturnType<typeof vi.fn>
+
+	beforeEach(() => {
+		mockOutputChannel = {
+			appendLine: vi.fn(),
+		} as unknown as vscode.OutputChannel
+
+		mockGetSkillsManager = vi.fn()
+
+		mockProvider = {
+			context: {} as vscode.ExtensionContext,
+			getSkillsManager: mockGetSkillsManager,
+			on: vi.fn(),
+		} as unknown as ClineProvider
+
+		api = new API(mockOutputChannel, mockProvider, undefined, true)
+	})
+
+	it("returns the skills and diagnostics from the skills manager", () => {
+		const skills = [
+			{
+				name: "good-skill",
+				description: "A healthy skill.",
+				path: "/skills/good-skill/SKILL.md",
+				source: "project" as const,
+			},
+		]
+		const skillDiagnostics = [
+			{ path: "/skills/bad-skill/SKILL.md", source: "project" as const, message: "YAML syntax error", line: 3 },
+		]
+		mockGetSkillsManager.mockReturnValue({
+			getSkillsMetadata: vi.fn().mockReturnValue(skills),
+			getSkillDiagnostics: vi.fn().mockReturnValue(skillDiagnostics),
+		})
+
+		expect(api.getSkillsState()).toEqual({ skills, skillDiagnostics })
+	})
+
+	it("returns empty arrays when the skills manager is unavailable", () => {
+		mockGetSkillsManager.mockReturnValue(undefined)
+
+		expect(api.getSkillsState()).toEqual({ skills: [], skillDiagnostics: [] })
+	})
+})

From ae9b80aa9678d169c071e9676a40ab8e0fc91526 Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Fri, 21 Aug 2026 15:18:10 +0800
Subject: [PATCH 07/26] test(webview): cover the remaining skill diagnostics
 patch lines

Closes the codecov/patch/webview-patch gap (4 not-fully-covered lines):

- ExtensionStateContext.spec.tsx: dispatch real "skills" messages through
  the provider and assert skills/skillDiagnostics update, including the
  empty-array default when the message omits skillDiagnostics.
- SkillsSettings.spec.tsx: render without skillDiagnostics in state
  (the exact shape that used to crash) and render diagnostics with and
  without line/column locations so every branch of the location
  formatting is exercised.

Local: both specs 45/45 passing; lcov confirms all patch lines and
branches in both files are taken.
---
 .../__tests__/SkillsSettings.spec.tsx         | 36 +++++++++
 .../__tests__/ExtensionStateContext.spec.tsx  | 73 +++++++++++++++++++
 2 files changed, 109 insertions(+)

diff --git a/webview-ui/src/components/settings/__tests__/SkillsSettings.spec.tsx b/webview-ui/src/components/settings/__tests__/SkillsSettings.spec.tsx
index 236af693d5..787c7918e8 100644
--- a/webview-ui/src/components/settings/__tests__/SkillsSettings.spec.tsx
+++ b/webview-ui/src/components/settings/__tests__/SkillsSettings.spec.tsx
@@ -217,6 +217,42 @@ describe("SkillsSettings", () => {
 		expect(screen.getByText("global-skill")).toBeInTheDocument()
 	})
 
+	it("does not show the malformed-skill warning when skillDiagnostics is absent from state", () => {
+		mockExtensionState = {
+			skills: mockSkills,
+			cwd: "/workspace",
+			customModes: [],
+		}
+
+		renderWithExtensionState(<SkillsSettings />)
+
+		expect(screen.queryByRole("alert")).not.toBeInTheDocument()
+		expect(screen.getByText("settings:sections.skills")).toBeInTheDocument()
+		expect(screen.getByText("project-skill")).toBeInTheDocument()
+	})
+
+	it("renders diagnostics with and without line/column locations", () => {
+		renderSkillsSettings(mockSkills, undefined, [
+			{
+				path: "/workspace/.roo/skills/broken-2/SKILL.md",
+				source: "project",
+				message: "unexpected end of the stream",
+			},
+			{
+				path: "/workspace/.roo/skills/broken-3/SKILL.md",
+				source: "project",
+				message: "bad indentation of a mapping entry",
+				line: 7,
+			},
+		])
+
+		const warning = screen.getByRole("alert")
+		expect(warning).toHaveTextContent("/workspace/.roo/skills/broken-2/SKILL.md")
+		expect(warning).toHaveTextContent("unexpected end of the stream")
+		expect(warning).toHaveTextContent("/workspace/.roo/skills/broken-3/SKILL.md:7")
+		expect(warning).toHaveTextContent("bad indentation of a mapping entry")
+	})
+
 	it("displays project skills section when in a workspace", () => {
 		renderSkillsSettings()
 
diff --git a/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx b/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
index 23ac911585..2a799b981d 100644
--- a/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
+++ b/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
@@ -40,6 +40,17 @@ const RulesTestComponent = () => {
 	return <div data-testid="rules">{JSON.stringify(rules)}</div>
 }
 
+const SkillsTestComponent = () => {
+	const { skills, skillDiagnostics } = useExtensionState()
+
+	return (
+		<div>
+			<div data-testid="skills">{JSON.stringify(skills)}</div>
+			<div data-testid="skill-diagnostics">{JSON.stringify(skillDiagnostics)}</div>
+		</div>
+	)
+}
+
 const ChatFontSizeTestComponent = () => {
 	const { chatFontSize, setChatFontSize } = useExtensionState()
 
@@ -192,6 +203,68 @@ describe("ExtensionStateContext", () => {
 		expect(JSON.parse(screen.getByTestId("rules").textContent!)).toEqual([])
 	})
 
+	it("updates skills and skill diagnostics from incoming skills message", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SkillsTestComponent />
+			</ExtensionStateContextProvider>,
+		)
+
+		act(() => {
+			window.dispatchEvent(
+				new MessageEvent("message", {
+					data: {
+						type: "skills",
+						skills: [
+							{
+								name: "good-skill",
+								description: "A healthy skill",
+								path: "/workspace/.roo/skills/good-skill/SKILL.md",
+								source: "project",
+							},
+						],
+						skillDiagnostics: [
+							{
+								path: "/workspace/.roo/skills/bad-skill/SKILL.md",
+								source: "project",
+								message: "bad indentation of a mapping entry",
+								line: 3,
+							},
+						],
+					},
+				}),
+			)
+		})
+
+		expect(JSON.parse(screen.getByTestId("skills").textContent!)).toEqual([
+			expect.objectContaining({ name: "good-skill" }),
+		])
+		expect(JSON.parse(screen.getByTestId("skill-diagnostics").textContent!)).toEqual([
+			expect.objectContaining({ path: "/workspace/.roo/skills/bad-skill/SKILL.md", line: 3 }),
+		])
+	})
+
+	it("defaults skill diagnostics to an empty array when the skills message omits them", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SkillsTestComponent />
+			</ExtensionStateContextProvider>,
+		)
+
+		act(() => {
+			window.dispatchEvent(
+				new MessageEvent("message", {
+					data: {
+						type: "skills",
+						skills: [],
+					},
+				}),
+			)
+		})
+
+		expect(JSON.parse(screen.getByTestId("skill-diagnostics").textContent!)).toEqual([])
+	})
+
 	it("initializes with soundEnabled set to false", () => {
 		render(
 			<ExtensionStateContextProvider>

From 5153db60a6032cdb42551ee059e770805cc2f5eb Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Fri, 21 Aug 2026 17:01:40 +0800
Subject: [PATCH 08/26] fix(skills): serialize discovery scans, scope the quote
 hint, and parse frontmatter deterministically

Addresses the CodeRabbit review findings and completes the patch coverage:

- Serialize discoverSkills() runs through a promise chain so overlapping
  watcher-triggered scans never interleave; an older scan can no longer
  append a stale diagnostic after a newer scan has observed the repaired
  file.
- Only emit the unescaped-double-quotes hint when the parser error is
  located on the description line itself, so a valid quoted description
  plus an unrelated YAML error elsewhere no longer produces a misleading
  hint.
- Parse SKILL.md frontmatter with explicit empty options so gray-matter's
  global content-keyed cache is bypassed. The cache is populated before
  parsing, so a frontmatter that throws on first parse is cached with an
  empty data object and every later parse of the same content silently
  returns that object instead of re-throwing - which resurfaces the
  misleading "missing required 'name' field" symptom from issue #859.

Tests:

- SkillsManager.spec: regression test that a delayed older scan cannot
  append stale diagnostics (serialization), a regression test that a
  re-scan of unchanged malformed content keeps reporting the parse
  failure (gray-matter cache poisoning), a no-false-hint case with a
  valid quoted description and an error on another line, and a non-Error
  parse failure exercising recordDiagnostic's defensive fallbacks
  (gray-matter is now vi.mocked with the real parser as the default
  implementation).
- ExtensionStateContext.spec: the skills message test now asserts the
  transition that clears stored skills/diagnostics, including a message
  that omits skills entirely.
- skills-diagnostics e2e: the malformed fixture is now a double-quoted
  description with unescaped inner quotes (the exact #859 failure mode),
  skill files are written atomically (sidecar + rename) so the watcher
  only observes complete files, and teardown removes only the skill
  directories the suite created.
- api-get-skills-state.spec: document why the partial test doubles need
  as-unknown-as casts.
- skillsMessageHandler.spec: cover the omitted newSkillModeSlugs case
  (passes undefined, still refreshes the posted state).
---
 .../src/suite/skills-diagnostics.test.ts      |  38 ++--
 .../__tests__/skillsMessageHandler.spec.ts    |  35 ++++
 .../__tests__/api-get-skills-state.spec.ts    |   5 +
 src/services/skills/SkillsManager.ts          |  54 ++++--
 .../skills/__tests__/SkillsManager.spec.ts    | 166 ++++++++++++++++++
 .../__tests__/ExtensionStateContext.spec.tsx  |  43 ++++-
 6 files changed, 319 insertions(+), 22 deletions(-)

diff --git a/apps/vscode-e2e/src/suite/skills-diagnostics.test.ts b/apps/vscode-e2e/src/suite/skills-diagnostics.test.ts
index dca14cc515..71662e6cfe 100644
--- a/apps/vscode-e2e/src/suite/skills-diagnostics.test.ts
+++ b/apps/vscode-e2e/src/suite/skills-diagnostics.test.ts
@@ -10,11 +10,12 @@ import { waitFor } from "./utils"
 const GOOD_SKILL = "e2e-skill-good"
 const BAD_SKILL = "e2e-skill-bad"
 
-// Issue #859 reproduction content: unescaped double quotes in the description
-// make the YAML frontmatter unparseable.
+// Issue #859 reproduction content: the description is a double-quoted YAML
+// scalar whose inner double quotes are left unescaped, which makes the
+// frontmatter unparseable.
 const MALFORMED_SKILL_MD = `---
 name: ${BAD_SKILL}
-description: Use when implementing features. Triggers on: "TDD", "test-driven development"
+description: "Use when implementing features. Triggers on: "TDD", "test-driven development"
 ---
 
 # E2E Skill Bad
@@ -42,6 +43,17 @@ description: A healthy skill used by the skill diagnostics e2e smoke test.
 Instructions here.
 `
 
+// Write a skill file atomically (write to a sidecar, then rename over the
+// target) so the extension host's file watcher only ever observes complete
+// content. An in-place fs.writeFile is visible mid-write, the watcher can
+// fire for that moment, and - because discovery scans are serialized - a
+// mid-write event could be the last one, leaving a stale scan result.
+const writeSkillFileAtomic = async (finalPath: string, content: string): Promise<void> => {
+	const tmpPath = `${finalPath}.tmp`
+	await fs.writeFile(tmpPath, content, "utf8")
+	await fs.rename(tmpPath, finalPath)
+}
+
 suite("Roo Code Skill Diagnostics", function () {
 	setDefaultSuiteTimeout(this)
 
@@ -54,18 +66,24 @@ suite("Roo Code Skill Diagnostics", function () {
 	})
 
 	teardown(async function () {
-		await fs.rm(skillsRoot, { recursive: true, force: true })
+		// Remove only the skill directories this suite created so pre-existing
+		// or other suites' fixtures under .roo/skills are left intact.
+		await Promise.all(
+			[GOOD_SKILL, BAD_SKILL].map((name) => fs.rm(path.join(skillsRoot, name), { recursive: true, force: true })),
+		)
 	})
 
 	test("should surface a malformed SKILL.md as a diagnostic without hiding healthy skills", async function () {
 		this.timeout(180_000)
 
 		// Arrange: one healthy skill and one malformed skill on real disk in the
-		// workspace's .roo/skills directory.
+		// workspace's .roo/skills directory, written atomically so the watcher
+		// only observes complete files.
 		await fs.mkdir(path.join(skillsRoot, GOOD_SKILL), { recursive: true })
-		await fs.writeFile(path.join(skillsRoot, GOOD_SKILL, "SKILL.md"), GOOD_SKILL_MD, "utf8")
+		await writeSkillFileAtomic(path.join(skillsRoot, GOOD_SKILL, "SKILL.md"), GOOD_SKILL_MD)
 		await fs.mkdir(path.join(skillsRoot, BAD_SKILL), { recursive: true })
-		await fs.writeFile(path.join(skillsRoot, BAD_SKILL, "SKILL.md"), MALFORMED_SKILL_MD, "utf8")
+		const badSkillMd = path.join(skillsRoot, BAD_SKILL, "SKILL.md")
+		await writeSkillFileAtomic(badSkillMd, MALFORMED_SKILL_MD)
 
 		// Act: the extension host's file watcher re-discovers skills; wait until
 		// the real SkillsManager reports the healthy skill and a diagnostic for
@@ -96,9 +114,9 @@ suite("Roo Code Skill Diagnostics", function () {
 			"malformed skill should be omitted from skills",
 		)
 
-		// Act: repair the frontmatter in place; the watcher re-discovers and the
-		// diagnostic clears.
-		await fs.writeFile(path.join(skillsRoot, BAD_SKILL, "SKILL.md"), FIXED_SKILL_MD, "utf8")
+		// Act: repair the frontmatter in place (atomically); the watcher
+		// re-discovers and the diagnostic clears.
+		await writeSkillFileAtomic(badSkillMd, FIXED_SKILL_MD)
 
 		await waitFor(
 			async () => {
diff --git a/src/core/webview/__tests__/skillsMessageHandler.spec.ts b/src/core/webview/__tests__/skillsMessageHandler.spec.ts
index e4d368c9b1..f5fa7eec38 100644
--- a/src/core/webview/__tests__/skillsMessageHandler.spec.ts
+++ b/src/core/webview/__tests__/skillsMessageHandler.spec.ts
@@ -426,6 +426,41 @@ describe("skillsMessageHandler", () => {
 			expect(mockUpdateSkillModes).toHaveBeenCalledWith("project-skill", "project", [])
 		})
 
+		it("passes undefined mode slugs and refreshes state when newSkillModeSlugs is omitted", async () => {
+			const provider = createMockProvider(true)
+			mockUpdateSkillModes.mockResolvedValue(undefined)
+			mockGetSkillsMetadata.mockReturnValue([mockSkills[0]])
+			// Forward a concrete (non-empty) diagnostic so the assertion proves the
+			// handler relays the diagnostics list rather than always posting []
+			// (which would pass even if the field were dropped or hard-coded).
+			const diagnostics = [
+				{
+					path: "/global/.roo/skills/broken/SKILL.md",
+					source: "global" as const,
+					message: "can not read a block mapping entry",
+					line: 3,
+					column: 10,
+				},
+			]
+			mockGetSkillDiagnostics.mockReturnValue(diagnostics)
+
+			const message: WebviewMessage = {
+				type: "updateSkillModes",
+				skillName: "test-skill",
+				source: "global",
+				// newSkillModeSlugs omitted
+			}
+			const result = await handleUpdateSkillModes(provider, message)
+
+			expect(result).toEqual([mockSkills[0]])
+			expect(mockUpdateSkillModes).toHaveBeenCalledWith("test-skill", "global", undefined)
+			expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+				type: "skills",
+				skills: [mockSkills[0]],
+				skillDiagnostics: diagnostics,
+			})
+		})
+
 		it("returns undefined when required fields are missing", async () => {
 			const provider = createMockProvider(true)
 
diff --git a/src/extension/__tests__/api-get-skills-state.spec.ts b/src/extension/__tests__/api-get-skills-state.spec.ts
index 32a0c57262..adced29119 100644
--- a/src/extension/__tests__/api-get-skills-state.spec.ts
+++ b/src/extension/__tests__/api-get-skills-state.spec.ts
@@ -14,6 +14,11 @@ describe("API#getSkillsState", () => {
 	let mockGetSkillsManager: ReturnType<typeof vi.fn>
 
 	beforeEach(() => {
+		// mockOutputChannel and mockProvider are intentionally partial
+		// doubles: they implement only the members API touches (appendLine;
+		// context, getSkillsManager, on). The as-unknown-as casts are the
+		// last resort because the partial shapes are not subtypes of the full
+		// vscode.OutputChannel / ClineProvider types.
 		mockOutputChannel = {
 			appendLine: vi.fn(),
 		} as unknown as vscode.OutputChannel
diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 91f732e40f..bdf3ee5f93 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -20,17 +20,24 @@ export type { SkillMetadata, SkillContent, SkillDiagnostic }
 
 /**
  * Extract the raw top-level `key: ...` line from the frontmatter block of a
- * SKILL.md file. Used to point users at the exact line when YAML parsing
- * fails (see issue #859). Returns undefined when the file has no
- * frontmatter block or no matching top-level line.
+ * SKILL.md file, along with its 1-based line number in the file. Used to
+ * point users at the exact line when YAML parsing fails (see issue #859).
+ * Returns undefined when the file has no frontmatter block or no matching
+ * top-level line.
  */
-function getRawFrontmatterLine(fileContent: string, key: string): string | undefined {
+function getFrontmatterLine(fileContent: string, key: string): { line: string; lineNumber: number } | undefined {
 	const match = fileContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)
 	if (!match) {
 		return undefined
 	}
 	const linePattern = new RegExp(`^${key}\\s*:`)
-	return match[1].split(/\r?\n/).find((line) => linePattern.test(line))
+	const frontmatterLines = match[1].split(/\r?\n/)
+	const index = frontmatterLines.findIndex((line) => linePattern.test(line))
+	if (index === -1) {
+		return undefined
+	}
+	// The opening `---` occupies file line 1, so frontmatter index 0 is file line 2.
+	return { line: frontmatterLines[index], lineNumber: index + 2 }
 }
 
 // gray-matter's bundled typings predate its options passthrough: `stringify`
@@ -51,6 +58,7 @@ export class SkillsManager {
 	private providerRef: WeakRef<ClineProvider>
 	private disposables: vscode.Disposable[] = []
 	private isDisposed = false
+	private discoveryChain: Promise<void> = Promise.resolve()
 
 	constructor(provider: ClineProvider) {
 		this.providerRef = new WeakRef(provider)
@@ -67,8 +75,19 @@ export class SkillsManager {
 	 * Also supports symlinks:
 	 * - .roo/skills can be a symlink to a directory containing skill subdirectories
 	 * - .roo/skills/[dirname] can be a symlink to a skill directory
+	 *
+	 * Scans are serialized so overlapping watcher-triggered runs never
+	 * interleave: an older scan must not commit state after a newer scan has
+	 * already observed the (possibly repaired) files.
 	 */
-	async discoverSkills(): Promise<void> {
+	discoverSkills(): Promise<void> {
+		const run = this.discoveryChain.then(() => this.performDiscovery())
+		// Keep the chain alive even if a scan rejects so later scans still run.
+		this.discoveryChain = run.catch(() => undefined)
+		return run
+	}
+
+	private async performDiscovery(): Promise<void> {
 		this.skills.clear()
 		this.diagnostics = []
 		const skillsDirs = await this.getSkillsDirectories()
@@ -135,15 +154,30 @@ export class SkillsManager {
 			// YAML syntax problems (e.g. unescaped double quotes in the
 			// description) report the actual cause instead of a misleading
 			// "missing required field" message (see issue #859).
+			//
+			// The `{}` options argument is deliberate: gray-matter keeps a global
+			// content-keyed cache and populates it *before* parsing, so a
+			// frontmatter that throws on first parse is cached with an empty data
+			// object and every later parse of the same content silently returns
+			// that empty object instead of re-throwing. Passing options disables
+			// the cache for this call, keeping the parse deterministic.
 			try {
-				parsed = matter(fileContent)
+				parsed = matter(fileContent, {})
 			} catch (error) {
 				this.recordDiagnostic(skillMdPath, source, error)
 				console.error(`Failed to parse skill at ${skillDir}:`, error)
 				// The most common cause is unescaped double quotes in the
-				// description value - point the user at the exact line.
-				const descriptionLine = getRawFrontmatterLine(fileContent, "description")
-				if (descriptionLine?.includes('"')) {
+				// description value. Only hint at that when the parser error is
+				// located on the description line itself, so a valid quoted
+				// description plus an unrelated YAML error elsewhere does not
+				// produce a misleading hint (see issue #859).
+				const description = getFrontmatterLine(fileContent, "description")
+				const errorMark = (error as { mark?: { line?: unknown } }).mark
+				if (
+					description?.line.includes('"') &&
+					typeof errorMark?.line === "number" &&
+					errorMark.line + 1 === description.lineNumber
+				) {
 					console.error(
 						`Hint: the "description" value in ${skillMdPath} contains unescaped double quotes. ` +
 							"Wrap the value in single quotes (or escape the double quotes) and save.",
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index be059dc884..1aac22732f 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -68,6 +68,20 @@ vi.mock("os", () => ({
 	homedir: mockHomedir,
 }))
 
+// Keep the real gray-matter parser by default, but let individual tests script
+// the failure shape (e.g. a non-Error throw) to exercise recordDiagnostic's
+// defensive fallbacks (see issue #859). vi.importActual resolves the CJS module
+// to a namespace that exposes the parser as `default`, which the module's
+// declared `export =` type does not carry, so the namespace is bridged through
+// `unknown` once; the double assertion then bridges the mock back to the
+// module's declared type.
+vi.mock("gray-matter", async () => {
+	const actual = await vi.importActual("gray-matter")
+	const realParse = (actual as { default: typeof matter }).default
+	const parse = Object.assign(vi.fn(realParse), actual) as unknown as typeof matter
+	return { default: parse }
+})
+
 // Mock vscode
 vi.mock("vscode", () => ({
 	workspace: {
@@ -1648,6 +1662,158 @@ Body here.`
 				}),
 			])
 		})
+
+		it("serializes overlapping scans so an older scan cannot append stale diagnostics", async () => {
+			const skillDir = p(globalSkillsDir, "flaky-skill")
+			const skillPath = p(skillDir, "SKILL.md")
+			const staleContent = `---
+name: flaky-skill
+description: "Broken "quote" frontmatter
+---
+
+Body.`
+			const goodContent = `---
+name: flaky-skill
+description: Healthy after repair
+---
+
+Body.`
+
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["flaky-skill"] : []))
+			mockStat.mockResolvedValue({ isDirectory: () => true })
+			mockFileExists.mockImplementation(async (file: string) => file === skillPath)
+
+			// The first scan's read is delayed (as when a watcher fires while the
+			// file is still being written) and observes malformed content. A second
+			// scan started before that read resolves must run afterwards, and its
+			// result must win.
+			let resolveFirstRead!: (content: string) => void
+			const firstRead = new Promise<string>((resolve) => {
+				resolveFirstRead = resolve
+			})
+			let reads = 0
+			mockReadFile.mockImplementation(async () => {
+				reads += 1
+				return reads === 1 ? firstRead : goodContent
+			})
+
+			const first = skillsManager.discoverSkills()
+			const second = skillsManager.discoverSkills()
+			resolveFirstRead(staleContent)
+			await Promise.all([first, second])
+
+			expect(skillsManager.getSkillsMetadata()).toEqual([
+				expect.objectContaining({ name: "flaky-skill", description: "Healthy after repair" }),
+			])
+			expect(skillsManager.getSkillDiagnostics()).toEqual([])
+		})
+
+		it("does not hint at unescaped quotes when the parse error is on another line", async () => {
+			const skillDir = p(globalSkillsDir, "hint-skill")
+			const skillPath = p(skillDir, "SKILL.md")
+
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["hint-skill"] : []))
+			mockStat.mockResolvedValue({ isDirectory: () => true })
+			mockFileExists.mockImplementation(async (file: string) => file === skillPath)
+			// The description is a valid single-quoted value that itself contains
+			// double quotes; the YAML error is on the unclosed name line instead,
+			// so the unescaped-quotes hint must not fire.
+			mockReadFile.mockResolvedValue(`---
+name: "unclosed
+description: 'Triggers on "TDD" - valid quotes'
+---
+
+Body.`)
+
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+
+			try {
+				await skillsManager.discoverSkills()
+
+				const logged = consoleErrorSpy.mock.calls.map((call) => call.join(" "))
+				expect(logged.some((line) => line.includes("unescaped double quotes"))).toBe(false)
+				expect(skillsManager.getSkillDiagnostics()).toEqual([
+					expect.objectContaining({ path: skillPath, source: "global", line: 4 }),
+				])
+			} finally {
+				consoleErrorSpy.mockRestore()
+			}
+		})
+
+		it("keeps reporting the same malformed skill on a re-scan (gray-matter cache must not swallow the error)", async () => {
+			const skillDir = p(globalSkillsDir, "cached-bad-skill")
+			const skillPath = p(skillDir, "SKILL.md")
+
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["cached-bad-skill"] : []))
+			mockStat.mockResolvedValue({ isDirectory: () => true })
+			mockFileExists.mockImplementation(async (file: string) => file === skillPath)
+			mockReadFile.mockResolvedValue(`---
+name: cached-bad-skill
+description: "Broken "quote" description
+---
+
+Body.`)
+
+			await skillsManager.discoverSkills()
+			expect(skillsManager.getSkillsMetadata()).toEqual([])
+			expect(skillsManager.getSkillDiagnostics()).toHaveLength(1)
+
+			// A re-scan of the identical (unchanged) content must keep reporting the
+			// parse failure. gray-matter keeps a global content-keyed cache that it
+			// populates before parsing, so without bypassing it the first throw is
+			// cached with an empty data object and every later parse of the same
+			// content silently returns that object instead of re-throwing - which
+			// would resurface the misleading "missing required 'name' field" symptom
+			// from issue #859.
+			await skillsManager.discoverSkills()
+			expect(skillsManager.getSkillsMetadata()).toEqual([])
+			expect(skillsManager.getSkillDiagnostics()).toHaveLength(1)
+			expect(skillsManager.getSkillDiagnostics()[0]).toEqual(
+				expect.objectContaining({ path: skillPath, source: "global" }),
+			)
+		})
+
+		it("records a diagnostic from a non-Error parse failure without location details", async () => {
+			const skillDir = p(globalSkillsDir, "raw-error-skill")
+			const skillPath = p(skillDir, "SKILL.md")
+
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["raw-error-skill"] : []))
+			mockStat.mockResolvedValue({ isDirectory: () => true })
+			mockFileExists.mockImplementation(async (file: string) => file === skillPath)
+			mockReadFile.mockResolvedValue(`---
+name: raw-error-skill
+description: Healthy
+---
+
+Body.`)
+			// Script a parse failure that is a plain string (no YAML reason, no
+			// mark, not an Error) so every defensive fallback in recordDiagnostic
+			// is exercised.
+			vi.mocked(matter).mockImplementationOnce(() => {
+				throw "gray-matter exploded"
+			})
+
+			await skillsManager.discoverSkills()
+
+			expect(skillsManager.getSkillsMetadata()).toEqual([])
+			expect(skillsManager.getSkillDiagnostics()).toEqual([
+				{
+					path: skillPath,
+					source: "global",
+					message: "gray-matter exploded",
+					line: undefined,
+					column: undefined,
+				},
+			])
+		})
 	})
 
 	describe("deleteSkill", () => {
diff --git a/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx b/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
index 2a799b981d..382a7190e8 100644
--- a/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
+++ b/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
@@ -244,24 +244,63 @@ describe("ExtensionStateContext", () => {
 		])
 	})
 
-	it("defaults skill diagnostics to an empty array when the skills message omits them", () => {
+	it("clears stored skills and diagnostics when later skills messages omit them", () => {
 		render(
 			<ExtensionStateContextProvider>
 				<SkillsTestComponent />
 			</ExtensionStateContextProvider>,
 		)
 
+		// A message with both skills and a diagnostic populates the state...
 		act(() => {
 			window.dispatchEvent(
 				new MessageEvent("message", {
 					data: {
 						type: "skills",
-						skills: [],
+						skills: [
+							{
+								name: "good-skill",
+								description: "A healthy skill",
+								path: "/workspace/.roo/skills/good-skill/SKILL.md",
+								source: "project",
+							},
+						],
+						skillDiagnostics: [
+							{
+								path: "/workspace/.roo/skills/bad-skill/SKILL.md",
+								source: "project",
+								message: "bad indentation of a mapping entry",
+								line: 3,
+							},
+						],
 					},
 				}),
 			)
 		})
 
+		expect(JSON.parse(screen.getByTestId("skills").textContent!)).toEqual([
+			expect.objectContaining({ name: "good-skill" }),
+		])
+		expect(JSON.parse(screen.getByTestId("skill-diagnostics").textContent!)).toEqual([
+			expect.objectContaining({ path: "/workspace/.roo/skills/bad-skill/SKILL.md", line: 3 }),
+		])
+
+		// ...and a later message that omits skillDiagnostics must clear the
+		// stored diagnostics instead of leaving them stale.
+		act(() => {
+			window.dispatchEvent(new MessageEvent("message", { data: { type: "skills", skills: [] } }))
+		})
+
+		expect(JSON.parse(screen.getByTestId("skills").textContent!)).toEqual([])
+		expect(JSON.parse(screen.getByTestId("skill-diagnostics").textContent!)).toEqual([])
+
+		// A message that omits skills entirely defaults the skills state the
+		// same way.
+		act(() => {
+			window.dispatchEvent(new MessageEvent("message", { data: { type: "skills" } }))
+		})
+
+		expect(JSON.parse(screen.getByTestId("skills").textContent!)).toEqual([])
 		expect(JSON.parse(screen.getByTestId("skill-diagnostics").textContent!)).toEqual([])
 	})
 

From 6615cc4e863bd38ad837bc423679c4fad410ac74 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Sun, 4 Oct 2026 21:02:24 +0800
Subject: [PATCH 09/26] Assert the whole skill diagnostic, not just path and
 line

The fixture carries source and message but both assertions checked only path
and line, so either field being lost would still pass. Assert all four fields
in both the populate test and the clearing test.

23 tests green; prettier, eslint and tsc clean.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../__tests__/ExtensionStateContext.spec.tsx       | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx b/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
index f9be47ba09..ef627f8da9 100644
--- a/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
+++ b/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx
@@ -243,7 +243,12 @@ describe("ExtensionStateContext", () => {
 			expect.objectContaining({ name: "good-skill" }),
 		])
 		expect(JSON.parse(screen.getByTestId("skill-diagnostics").textContent!)).toEqual([
-			expect.objectContaining({ path: "/workspace/.roo/skills/bad-skill/SKILL.md", line: 3 }),
+			expect.objectContaining({
+				path: "/workspace/.roo/skills/bad-skill/SKILL.md",
+				source: "project",
+				message: "bad indentation of a mapping entry",
+				line: 3,
+			}),
 		])
 	})
 
@@ -285,7 +290,12 @@ describe("ExtensionStateContext", () => {
 			expect.objectContaining({ name: "good-skill" }),
 		])
 		expect(JSON.parse(screen.getByTestId("skill-diagnostics").textContent!)).toEqual([
-			expect.objectContaining({ path: "/workspace/.roo/skills/bad-skill/SKILL.md", line: 3 }),
+			expect.objectContaining({
+				path: "/workspace/.roo/skills/bad-skill/SKILL.md",
+				source: "project",
+				message: "bad indentation of a mapping entry",
+				line: 3,
+			}),
 		])
 
 		// ...and a later message that omits skillDiagnostics must clear the

From b4c059b5473c3254c5f727d520ac560a0898c5c2 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Sun, 4 Oct 2026 21:59:01 +0800
Subject: [PATCH 10/26] Re-trigger review at head: all required checks green
 and every review thread resolved.


From ea343e77a8f44edbae0435e2654b1c2e2ed50a0d Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Sun, 4 Oct 2026 23:22:32 +0800
Subject: [PATCH 11/26] Stage skill discovery before publishing it to readers

performDiscovery() cleared the live collections and filled them incrementally, so a
reader (requestSkills -> getSkillsMetadata/getSkillDiagnostics) that runs between
the awaits of a scan could observe a half-built snapshot. The scan now builds local
collections and commits them only after it completes.

Regression test parks one skill's read mid-scan and reads the snapshot while the
scan is in flight: it fails against the incremental commit and passes with the
staged commit.

The second half of the finding (posting a skills message from the watcher) is not
taken: the watcher has always updated state only, and the PR does not change that
contract.
---
 src/services/skills/SkillsManager.ts          | 42 +++++++++++-----
 .../skills/__tests__/SkillsManager.spec.ts    | 48 +++++++++++++++++++
 2 files changed, 79 insertions(+), 11 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index bdf3ee5f93..d5094875fb 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -88,13 +88,20 @@ export class SkillsManager {
 	}
 
 	private async performDiscovery(): Promise<void> {
-		this.skills.clear()
-		this.diagnostics = []
+		// Stage the scan into local collections and commit them only once the scan has
+		// completed. A reader (requestSkills -> getSkillsMetadata/getSkillDiagnostics)
+		// can run between the awaits of a scan, so committing incrementally would let it
+		// observe a half-built snapshot of a scan that is still in progress.
+		const skills = new Map<string, SkillMetadata>()
+		const diagnostics: SkillDiagnostic[] = []
 		const skillsDirs = await this.getSkillsDirectories()
 
 		for (const { dir, source, mode } of skillsDirs) {
-			await this.scanSkillsDirectory(dir, source, mode)
+			await this.scanSkillsDirectory(dir, source, mode, skills, diagnostics)
 		}
+
+		this.skills = skills
+		this.diagnostics = diagnostics
 	}
 
 	/**
@@ -103,7 +110,13 @@ export class SkillsManager {
 	 * 1. The skills directory itself is a symlink (resolved by directoryExists using realpath)
 	 * 2. Individual skill subdirectories are symlinks
 	 */
-	private async scanSkillsDirectory(dirPath: string, source: "global" | "project", mode?: string): Promise<void> {
+	private async scanSkillsDirectory(
+		dirPath: string,
+		source: "global" | "project",
+		mode: string | undefined,
+		skills: Map<string, SkillMetadata>,
+		diagnostics: SkillDiagnostic[],
+	): Promise<void> {
 		if (!(await directoryExists(dirPath))) {
 			return
 		}
@@ -123,7 +136,7 @@ export class SkillsManager {
 				if (!stats?.isDirectory()) continue
 
 				// Load skill metadata - the skill name comes from the entry name (symlink name if symlinked)
-				await this.loadSkillMetadata(entryPath, source, mode, entryName)
+				await this.loadSkillMetadata(entryPath, source, mode, entryName, skills, diagnostics)
 			}
 		} catch {
 			// Directory doesn't exist or can't be read - this is fine
@@ -140,8 +153,10 @@ export class SkillsManager {
 	private async loadSkillMetadata(
 		skillDir: string,
 		source: "global" | "project",
-		mode?: string,
-		skillName?: string,
+		mode: string | undefined,
+		skillName: string | undefined,
+		skills: Map<string, SkillMetadata>,
+		diagnostics: SkillDiagnostic[],
 	): Promise<void> {
 		const skillMdPath = path.join(skillDir, "SKILL.md")
 		if (!(await fileExists(skillMdPath))) return
@@ -164,7 +179,7 @@ export class SkillsManager {
 			try {
 				parsed = matter(fileContent, {})
 			} catch (error) {
-				this.recordDiagnostic(skillMdPath, source, error)
+				this.recordDiagnostic(skillMdPath, source, error, diagnostics)
 				console.error(`Failed to parse skill at ${skillDir}:`, error)
 				// The most common cause is unescaped double quotes in the
 				// description value. Only hint at that when the parser error is
@@ -246,7 +261,7 @@ export class SkillsManager {
 			const primaryMode = modeSlugs?.[0]
 			const skillKey = this.getSkillKey(effectiveSkillName, source, primaryMode)
 
-			this.skills.set(skillKey, {
+			skills.set(skillKey, {
 				name: effectiveSkillName,
 				description,
 				path: skillMdPath,
@@ -259,7 +274,12 @@ export class SkillsManager {
 		}
 	}
 
-	private recordDiagnostic(path: string, source: "global" | "project", error: unknown): void {
+	private recordDiagnostic(
+		path: string,
+		source: "global" | "project",
+		error: unknown,
+		diagnostics: SkillDiagnostic[],
+	): void {
 		const yamlError = error as {
 			reason?: unknown
 			message?: unknown
@@ -270,7 +290,7 @@ export class SkillsManager {
 		const line = typeof yamlError.mark?.line === "number" ? yamlError.mark.line + 1 : undefined
 		const column = typeof yamlError.mark?.column === "number" ? yamlError.mark.column + 1 : undefined
 
-		this.diagnostics.push({ path, source, message: reason ?? errorMessage, line, column })
+		diagnostics.push({ path, source, message: reason ?? errorMessage, line, column })
 	}
 
 	/**
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index 1aac22732f..f8a278e3ea 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -1710,6 +1710,54 @@ Body.`
 			expect(skillsManager.getSkillDiagnostics()).toEqual([])
 		})
 
+		it("does not expose a half-built snapshot to a reader while a scan is in progress", async () => {
+			const stablePath = p(globalSkillsDir, "stable-skill", "SKILL.md")
+			const slowPath = p(globalSkillsDir, "slow-skill", "SKILL.md")
+			const stableContent = `---
+name: stable-skill
+description: Stable before the scan
+---
+
+Body.`
+			const slowContent = `---
+name: slow-skill
+description: Loaded after the scan completes
+---
+
+Body.`
+
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			// The second scan sees an extra skill, and that skill's read is parked, so
+			// the reader runs while the scan is mid-flight. Committing incrementally
+			// would let the reader see the scan after the clear but before the slow
+			// skill was loaded.
+			let entries = ["stable-skill"]
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? entries : []))
+			mockStat.mockResolvedValue({ isDirectory: () => true })
+			mockFileExists.mockImplementation(async (file: string) => file === stablePath || file === slowPath)
+			let resolveSlowRead!: (content: string) => void
+			const slowRead = new Promise<string>((resolve) => {
+				resolveSlowRead = resolve
+			})
+			mockReadFile.mockImplementation(async (file: string) => (file === slowPath ? slowRead : stableContent))
+
+			await skillsManager.discoverSkills()
+			expect(skillsManager.getSkillsMetadata()).toHaveLength(1)
+
+			// Slow skill first: the reader runs after the scan started but before any of
+			// its own skills were added, so an incremental commit would show an empty list.
+			entries = ["slow-skill", "stable-skill"]
+			const scan = skillsManager.discoverSkills()
+			await vi.waitFor(() => expect(mockReadFile.mock.calls.map((c) => c[0])).toContain(slowPath))
+			expect(skillsManager.getSkillsMetadata()).toHaveLength(1)
+			expect(skillsManager.getSkillDiagnostics()).toEqual([])
+
+			resolveSlowRead(slowContent)
+			await scan
+
+			expect(skillsManager.getSkillsMetadata()).toHaveLength(2)
+		})
 		it("does not hint at unescaped quotes when the parse error is on another line", async () => {
 			const skillDir = p(globalSkillsDir, "hint-skill")
 			const skillPath = p(skillDir, "SKILL.md")

From c26661b4448f240e15c1859e01a740d4817acfca Mon Sep 17 00:00:00 2001
From: dsh-agent <dsh@local>
Date: Thu, 22 Oct 2026 02:43:19 +0800
Subject: [PATCH 12/26] test(skills): pin single-line descriptions through the
 yaml round-trip

The previous assertion (not.toContain('> ')) could not distinguish a folded scalar from a plain one, and the fixture description was shorter than js-yaml's default 80-column fold width, so removing lineWidth: -1 went unnoticed. Use a description over that width and assert the exact single description: line (quoted, since the value contains quotes) in both updateSkillModes and createSkill.
---
 .../skills/__tests__/SkillsManager.spec.ts    | 26 +++++++++++++++----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index ff9b5c106f..f3c1c01a08 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -2236,7 +2236,12 @@ Instructions`)
 			mockMkdir.mockResolvedValue(undefined)
 			mockWriteFile.mockResolvedValue(undefined)
 
-			const createdPath = await skillsManager.createSkill("new-skill", "global", "A new skill description")
+			// Longer than js-yaml's default 80-column fold width: createSkill must
+			// write it as a single description line, not a folded scalar.
+			const description =
+				'Use when implementing features. Triggers on: "TDD", "test-driven development" and "refactoring" workflows'
+
+			const createdPath = await skillsManager.createSkill("new-skill", "global", description)
 
 			expect(createdPath).toBe(p(GLOBAL_ROO_DIR, "skills", "new-skill", "SKILL.md"))
 			expect(mockMkdir).toHaveBeenCalledWith(p(GLOBAL_ROO_DIR, "skills", "new-skill"), { recursive: true })
@@ -2245,8 +2250,12 @@ Instructions`)
 			// Verify the content written
 			const writeCall = mockWriteFile.mock.calls[0]
 			expect(writeCall[0]).toBe(p(GLOBAL_ROO_DIR, "skills", "new-skill", "SKILL.md"))
-			expect(writeCall[1]).toContain("name: new-skill")
-			expect(writeCall[1]).toContain("description: A new skill description")
+			const written = String(writeCall[1])
+			expect(written).toContain("name: new-skill")
+			const descriptionLine = written.split("\n").find((line) => line.startsWith("description:"))
+			// Long descriptions are quoted (js-yaml quotes strings containing quotes).
+			expect(descriptionLine).toBe(`description: '${description}'`)
+			expect(written).not.toContain("> ")
 		})
 
 		it("should create a mode-specific skill with modeSlugs array", async () => {
@@ -2330,7 +2339,10 @@ Instructions`)
 			mockMkdir.mockResolvedValue(undefined)
 			mockWriteFile.mockResolvedValue(undefined)
 
-			const description = 'Use when implementing features. Triggers on: "TDD", "test-driven development"'
+			// Deliberately longer than js-yaml's default 80-column fold width: without
+			// lineWidth: -1 the serializer wraps this into a rolled scalar.
+			const description =
+				'Use when implementing features. Triggers on: "TDD", "test-driven development", "red-green-refactor" and "refactoring" workflows'
 			const createdPath = await skillsManager.createSkill("test-skill", "global", description)
 
 			// The written frontmatter must be valid YAML that round-trips the
@@ -2424,7 +2436,11 @@ Body here.`
 			// The new modeSlugs were written and the body is preserved.
 			expect(parsed.data.modeSlugs).toEqual(["code"])
 			expect(rewritten).toContain("Body here.")
-			// lineWidth: -1 keeps the value on a single line (no folded block scalar).
+			// lineWidth: -1 keeps the value on a single line: without it js-yaml folds
+			// a description this long across several lines, so pin the exact line and
+			// the absence of any continuation.
+			const descriptionLine = rewritten.split("\n").find((line) => line.startsWith("description:"))
+			expect(descriptionLine).toBe(`description: '${description}'`)
 			expect(rewritten).not.toContain("> ")
 
 			// Clearing the restriction removes modeSlugs from the frontmatter.

From ab15ab2794cdb2e6ccf8b893ec49bdc3267f3cb3 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:08:30 +0800
Subject: [PATCH 13/26] fix(skills): publish SKILL.md atomically and clean up
 failed creates

Review follow-up: createSkill and updateSkillModes now stage the serialized content in a same-directory temp file, await the write, and rename it over SKILL.md instead of writing the target in place. A failed write/rename removes the temp file, and createSkill removes only the skill directory mkdir reported creating this call; a pre-existing directory is left alone. Tests cover the temp+rename path for both writers, the failure cleanup and the pre-existing-directory case (114 passed).
---
 src/services/skills/SkillsManager.ts          | 42 +++++++++++++++--
 .../skills/__tests__/SkillsManager.spec.ts    | 46 ++++++++++++++++++-
 2 files changed, 81 insertions(+), 7 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index c48cd0d22b..895a06891d 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -663,6 +663,29 @@ export class SkillsManager {
 	 * @param modeSlugs - Optional mode restrictions (undefined/empty = any mode)
 	 * @returns Path to created SKILL.md file
 	 */
+	/**
+	 * Write one SKILL.md atomically: stage the content in a same-directory temp file,
+	 * await the complete write, then rename it over the target. A crash or failed write
+	 * must not leave a truncated SKILL.md that the loader would silently misparse.
+	 * The temp file is removed when the write or rename fails.
+	 */
+	private async writeSkillFileAtomically(filePath: string, content: string): Promise<void> {
+		const directory = path.dirname(filePath)
+		const temporaryPath = path.join(
+			directory,
+			`.${path.basename(filePath)}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
+		)
+		try {
+			await fs.writeFile(temporaryPath, content, "utf-8")
+			await fs.rename(temporaryPath, filePath)
+		} catch (error) {
+			// Best effort: a partial temp file must not be left behind. The original
+			// failure is the one the caller needs to see.
+			await fs.unlink(temporaryPath).catch(() => {})
+			throw error
+		}
+	}
+
 	async createSkill(
 		name: string,
 		source: "global" | "project",
@@ -703,8 +726,9 @@ export class SkillsManager {
 			throw new Error(t("skills:errors.already_exists", { name, path: skillMdPath }))
 		}
 
-		// Create the skill directory
-		await fs.mkdir(skillDir, { recursive: true })
+		// Create the skill directory. mkdir reports the path it created (when any), so a
+		// failed persistence can remove exactly the directory this call introduced.
+		const createdDir = await fs.mkdir(skillDir, { recursive: true })
 
 		// Generate SKILL.md content with frontmatter
 		const titleName = name
@@ -731,8 +755,16 @@ export class SkillsManager {
 Add your skill instructions here.
 `
 		const skillContent = matter.stringify(body, frontmatter, SKILL_YAML_DUMP_OPTIONS)
-		// Write the SKILL.md file
-		await fs.writeFile(skillMdPath, skillContent, "utf-8")
+		// Publish the SKILL.md atomically, and leave no half-created skill directory behind
+		// when persistence fails.
+		try {
+			await this.writeSkillFileAtomically(skillMdPath, skillContent)
+		} catch (error) {
+			if (createdDir) {
+				await fs.rm(createdDir, { recursive: true, force: true }).catch(() => {})
+			}
+			throw error
+		}
 
 		// Refresh skills list
 		await this.discoverSkills()
@@ -1063,7 +1095,7 @@ Add your skill instructions here.
 		// values from being reflowed into folded block scalars, keeping the
 		// file stable (see issue #859).
 		const newContent = matter.stringify(body, frontmatter, SKILL_YAML_DUMP_OPTIONS)
-		await fs.writeFile(skill.path, newContent, "utf-8")
+		await this.writeSkillFileAtomically(skill.path, newContent)
 
 		// Refresh skills list
 		await this.discoverSkills()
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index f3c1c01a08..ff76bba98b 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -2249,7 +2249,8 @@ Instructions`)
 
 			// Verify the content written
 			const writeCall = mockWriteFile.mock.calls[0]
-			expect(writeCall[0]).toBe(p(GLOBAL_ROO_DIR, "skills", "new-skill", "SKILL.md"))
+			expect(String(writeCall[0])).toMatch(/[/\\]new-skill[/\\]\.SKILL\.md\.[^/\\]+\.tmp$/)
+			expect(mockRename).toHaveBeenCalledWith(writeCall[0], p(GLOBAL_ROO_DIR, "skills", "new-skill", "SKILL.md"))
 			const written = String(writeCall[1])
 			expect(written).toContain("name: new-skill")
 			const descriptionLine = written.split("\n").find((line) => line.startsWith("description:"))
@@ -2318,6 +2319,42 @@ Instructions`)
 			expect(matter(generatedContent).data.description).toBe(description)
 		})
 
+		it("cleans the temp file and the newly created skill directory when persistence fails", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			const createdDir = p(GLOBAL_ROO_DIR, "skills", "failing-skill")
+			mockMkdir.mockResolvedValue(createdDir)
+			mockWriteFile.mockRejectedValueOnce(Object.assign(new Error("ENOSPC"), { code: "ENOSPC" }))
+			mockUnlink.mockResolvedValue(undefined)
+			mockRm.mockResolvedValue(undefined)
+
+			await expect(skillsManager.createSkill("failing-skill", "global", "Description")).rejects.toThrow("ENOSPC")
+
+			// The partially written temp file and the directory this call created are removed;
+			// the original persistence error is what the caller sees.
+			expect(mockUnlink).toHaveBeenCalledWith(expect.stringMatching(/\.SKILL\.md\.[^/\\]+\.tmp$/))
+			expect(mockRm).toHaveBeenCalledWith(createdDir, { recursive: true, force: true })
+		})
+
+		it("does not remove a pre-existing skill directory when persistence fails", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			// mkdir resolves undefined when the directory already existed: it is not ours to remove.
+			mockMkdir.mockResolvedValue(undefined)
+			mockWriteFile.mockRejectedValueOnce(new Error("EACCES"))
+			mockUnlink.mockResolvedValue(undefined)
+			mockRm.mockResolvedValue(undefined)
+
+			await expect(skillsManager.createSkill("owned-skill", "global", "Description")).rejects.toThrow("EACCES")
+
+			expect(mockRm).not.toHaveBeenCalled()
+			expect(mockUnlink).toHaveBeenCalledWith(expect.stringMatching(/\.SKILL\.md\.[^/\\]+\.tmp$/))
+		})
+
 		it("should create a project skill", async () => {
 			mockDirectoryExists.mockResolvedValue(false)
 			mockRealpath.mockImplementation(async (p: string) => p)
@@ -2429,6 +2466,9 @@ Body here.`
 
 			expect(mockWriteFile).toHaveBeenCalledTimes(1)
 			const rewritten = String(mockWriteFile.mock.calls[0][1])
+			// The rewrite lands through the same atomic temp+rename path as createSkill.
+			expect(String(mockWriteFile.mock.calls[0][0])).toMatch(/\.SKILL\.md\.[^/\\]+\.tmp$/)
+			expect(mockRename).toHaveBeenCalledWith(mockWriteFile.mock.calls[0][0], skillMd)
 			const parsed = matter(rewritten)
 			// The description survives the round-trip exactly and stays quoted.
 			expect(parsed.data.description).toBe(description)
@@ -2531,7 +2571,9 @@ Instructions`)
 			const created = await skillsManager.createSkill("my-skill", "global", "Description")
 
 			expect(created).toBe(rooSkillMd)
-			expect(mockWriteFile).toHaveBeenCalledWith(rooSkillMd, expect.any(String), "utf-8")
+			const staged = mockWriteFile.mock.calls[0][0]
+			expect(String(staged)).toMatch(/\.SKILL\.md\.[^/\\]+\.tmp$/)
+			expect(mockRename).toHaveBeenCalledWith(staged, rooSkillMd)
 		})
 	})
 

From 870efed8e5681ee31dbddf9eb9d2b58a74429e55 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:10:53 +0800
Subject: [PATCH 14/26] test(skills): add a gallery story and visual test for
 the diagnostics alert

Review follow-up: a deterministic skills-settings-diagnostics gallery story renders the warning alert with a project skill carrying a YAML line:column and a global skill without position data, next to a valid skill. The Playwright component test asserts the rendered paths/locations/messages, the valid row, a bounded layout and the committed baseline screenshot. Generated with the repository playwright-ct pipeline (chromium, dark theme fixture).
---
 webview-ui/playwright/gallery/stories.tsx     |  41 ++++++++++++++++++
 .../__tests__/SkillsSettings.visual.tsx       |  22 ++++++++++
 .../skills-settings-diagnostics.png           | Bin 0 -> 30182 bytes
 3 files changed, 63 insertions(+)
 create mode 100644 webview-ui/src/components/settings/__tests__/SkillsSettings.visual.tsx
 create mode 100644 webview-ui/src/components/settings/__tests__/__screenshots__/skills-settings-diagnostics.png

diff --git a/webview-ui/playwright/gallery/stories.tsx b/webview-ui/playwright/gallery/stories.tsx
index 85d6919db4..c44f2e2c66 100644
--- a/webview-ui/playwright/gallery/stories.tsx
+++ b/webview-ui/playwright/gallery/stories.tsx
@@ -438,4 +438,45 @@ export const stories: Record<string, Story> = {
 			</AppProviders>
 		)
 	},
+
+	"skills-settings-diagnostics": async () => {
+		const [{ AppProviders }, { SkillsSettings }] = await Promise.all([
+			import("../AppProviders"),
+			import("@/components/settings/SkillsSettings"),
+		])
+		// Deterministic diagnostics: one project skill with a YAML location, one global
+		// skill without position data, so the alert's path/location/message rendering is
+		// fully covered by the screenshot.
+		const skills = [
+			{
+				name: "diagnostics-demo",
+				description: "Demo skill that loads successfully next to the broken ones",
+				path: "/workspace/.roo/skills/diagnostics-demo/SKILL.md",
+				source: "project" as const,
+			},
+		]
+		const skillDiagnostics = [
+			{
+				path: "/workspace/.roo/skills/broken-skill/SKILL.md",
+				source: "project" as const,
+				message: "Invalid YAML frontmatter: unexpected end of the stream",
+				line: 3,
+				column: 12,
+			},
+			{
+				path: "/home/user/.roo/skills/legacy-mode/SKILL.md",
+				source: "global" as const,
+				message: "Missing required 'description' field",
+			},
+		]
+		return (
+			<AppProviders initialState={{ cwd: "/workspace", skills, skillDiagnostics }}>
+				<div
+					className="flex h-full w-full flex-col bg-vscode-editor-background p-4 text-vscode-foreground"
+					data-testid="skills-settings-story">
+					<SkillsSettings />
+				</div>
+			</AppProviders>
+		)
+	},
 }
diff --git a/webview-ui/src/components/settings/__tests__/SkillsSettings.visual.tsx b/webview-ui/src/components/settings/__tests__/SkillsSettings.visual.tsx
new file mode 100644
index 0000000000..b1eff02240
--- /dev/null
+++ b/webview-ui/src/components/settings/__tests__/SkillsSettings.visual.tsx
@@ -0,0 +1,22 @@
+import { expect, test } from "../../../../playwright/coverage-fixture"
+import { collectBoundedLayoutFailures } from "../../../../playwright/layout-contracts"
+import { mountedStory } from "../../../../playwright/mounted-story"
+
+test("shows skill load diagnostics with paths, locations and messages", async ({ mount, page }) => {
+	await page.setViewportSize({ width: 520, height: 480 })
+	const component = mountedStory(await mount("skills-settings-diagnostics"))
+	const story = component.getByTestId("skills-settings-story")
+	const alert = story.getByRole("alert")
+
+	await expect(alert).toBeVisible()
+	// The diagnostics are rendered verbatim: path, optional line:column, message.
+	await expect(alert).toContainText("/workspace/.roo/skills/broken-skill/SKILL.md:3:12")
+	await expect(alert).toContainText("Invalid YAML frontmatter: unexpected end of the stream")
+	await expect(alert).toContainText("/home/user/.roo/skills/legacy-mode/SKILL.md")
+	await expect(alert).toContainText("Missing required 'description' field")
+	// The valid skill next to the diagnostics still renders its own row.
+	await expect(story).toContainText("diagnostics-demo")
+
+	await expect(story).toHaveScreenshot("skills-settings-diagnostics.png")
+	await expect.poll(() => story.evaluate(collectBoundedLayoutFailures)).toEqual([])
+})
diff --git a/webview-ui/src/components/settings/__tests__/__screenshots__/skills-settings-diagnostics.png b/webview-ui/src/components/settings/__tests__/__screenshots__/skills-settings-diagnostics.png
new file mode 100644
index 0000000000000000000000000000000000000000..105d252b4bb6f87e0a1bb979a3518714f507f6c7
GIT binary patch
literal 30182
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
ZQ1(7c2Cc@s-2qonWF!<nm3}k|_#dwiq$L0V

literal 0
HcmV?d00001


From 8ba903ab3bfa4cd6ca3c106fee725107965cc56e Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:16:43 +0800
Subject: [PATCH 15/26] test(skills): keep the diagnostics story typed against
 the provider state

The gallery merges arbitrary context keys at runtime through its state shim, but the shared provider type only exposes ExtensionState fields, so passing skills/skillDiagnostics as initialState failed the webview type-check and the memoized webview build. Type the story state explicitly as the provider initialState with a comment explaining the gallery-only fields.
---
 webview-ui/playwright/gallery/stories.tsx | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/webview-ui/playwright/gallery/stories.tsx b/webview-ui/playwright/gallery/stories.tsx
index c44f2e2c66..70996c077f 100644
--- a/webview-ui/playwright/gallery/stories.tsx
+++ b/webview-ui/playwright/gallery/stories.tsx
@@ -469,8 +469,14 @@ export const stories: Record<string, Story> = {
 				message: "Missing required 'description' field",
 			},
 		]
+		// The gallery's ExtensionStateContext shim merges arbitrary keys, while the real
+		// provider's state type does not expose the skills diagnostics fields the settings
+		// panel reads; the cast keeps the story typed without changing production state.
+		const initialState = { cwd: "/workspace", skills, skillDiagnostics } as unknown as NonNullable<
+			React.ComponentProps<typeof AppProviders>["initialState"]
+		>
 		return (
-			<AppProviders initialState={{ cwd: "/workspace", skills, skillDiagnostics }}>
+			<AppProviders initialState={initialState}>
 				<div
 					className="flex h-full w-full flex-col bg-vscode-editor-background p-4 text-vscode-foreground"
 					data-testid="skills-settings-story">

From 691d79fcc716a1f013d114a41224502b20102e96 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:35:37 +0800
Subject: [PATCH 16/26] fix(skills): publish through a symlinked SKILL.md and
 remove only the empty new directory

Review follow-ups: updateSkillModes resolves the discovered path with fs.realpath before the temp+rename publish, so a symlinked SKILL.md is updated through the link instead of being replaced by a regular file (unresolvable paths fall back to the discovered path and surface the real write failure). createSkill failure cleanup no longer recursively removes the value mkdir(recursive) reports: it removes only this call own skill directory with rmdir while empty, so an ancestor (.roo / skills) can never take sibling skills with it. Tests cover the empty-only removal, a failed empty-only removal (original error surfaces), a pre-existing directory, and mkdir reporting an ancestor with a sibling skill preserved. SkillsManager.spec.ts 116 passed.
---
 src/services/skills/SkillsManager.ts          | 18 +++++--
 .../skills/__tests__/SkillsManager.spec.ts    | 48 +++++++++++++++++--
 2 files changed, 60 insertions(+), 6 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 895a06891d..44cdcad378 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -756,12 +756,15 @@ Add your skill instructions here.
 `
 		const skillContent = matter.stringify(body, frontmatter, SKILL_YAML_DUMP_OPTIONS)
 		// Publish the SKILL.md atomically, and leave no half-created skill directory behind
-		// when persistence fails.
+		// when persistence fails. mkdir(recursive) can report the first ancestor it created
+		// (.roo or skills), so a recursive removal of that value could delete unrelated
+		// skills: only this call's own skill directory is removed, and only while it is
+		// empty. Any created ancestor stays behind like the empty directory it is.
 		try {
 			await this.writeSkillFileAtomically(skillMdPath, skillContent)
 		} catch (error) {
 			if (createdDir) {
-				await fs.rm(createdDir, { recursive: true, force: true }).catch(() => {})
+				await fs.rmdir(skillDir).catch(() => {})
 			}
 			throw error
 		}
@@ -1095,7 +1098,16 @@ Add your skill instructions here.
 		// values from being reflowed into folded block scalars, keeping the
 		// file stable (see issue #859).
 		const newContent = matter.stringify(body, frontmatter, SKILL_YAML_DUMP_OPTIONS)
-		await this.writeSkillFileAtomically(skill.path, newContent)
+		// Resolve the link target first: publishing through the temp+rename must update the file
+		// the skill was discovered through, not replace a symlinked SKILL.md with a regular file.
+		let targetPath = skill.path
+		try {
+			targetPath = await fs.realpath(skill.path)
+		} catch {
+			// Unresolvable path (already missing, or a platform without realpath): keep the
+			// discovered path and let the write report the real failure.
+		}
+		await this.writeSkillFileAtomically(targetPath, newContent)
 
 		// Refresh skills list
 		await this.discoverSkills()
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index ff76bba98b..8c194871fc 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -2329,13 +2329,54 @@ Instructions`)
 			mockWriteFile.mockRejectedValueOnce(Object.assign(new Error("ENOSPC"), { code: "ENOSPC" }))
 			mockUnlink.mockResolvedValue(undefined)
 			mockRm.mockResolvedValue(undefined)
+			mockRmdir.mockResolvedValue(undefined)
 
 			await expect(skillsManager.createSkill("failing-skill", "global", "Description")).rejects.toThrow("ENOSPC")
 
-			// The partially written temp file and the directory this call created are removed;
-			// the original persistence error is what the caller sees.
+			// The partially written temp file is removed and the directory this call created is
+			// removed only while empty (rmdir, never a recursive rm that could take ancestors
+			// reported by mkdir(recursive) with unrelated skills); the original persistence
+			// error is what the caller sees.
 			expect(mockUnlink).toHaveBeenCalledWith(expect.stringMatching(/\.SKILL\.md\.[^/\\]+\.tmp$/))
-			expect(mockRm).toHaveBeenCalledWith(createdDir, { recursive: true, force: true })
+			expect(mockRmdir).toHaveBeenCalledWith(p(GLOBAL_ROO_DIR, "skills", "failing-skill"))
+			expect(mockRm).not.toHaveBeenCalled()
+		})
+
+		it("leaves a non-empty skill directory alone when the empty-only removal fails", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			mockMkdir.mockResolvedValue(p(GLOBAL_ROO_DIR, "skills", "busy-skill"))
+			mockWriteFile.mockRejectedValueOnce(Object.assign(new Error("ENOSPC"), { code: "ENOSPC" }))
+			mockUnlink.mockResolvedValue(undefined)
+			mockRmdir.mockRejectedValueOnce(Object.assign(new Error("ENOTEMPTY"), { code: "ENOTEMPTY" }))
+
+			// A failed cleanup (the temp file survived, another skill appeared, ...) must not
+			// mask or replace the persistence failure.
+			await expect(skillsManager.createSkill("busy-skill", "global", "Description")).rejects.toThrow("ENOSPC")
+			expect(mockRmdir).toHaveBeenCalledWith(p(GLOBAL_ROO_DIR, "skills", "busy-skill"))
+			expect(mockRm).not.toHaveBeenCalled()
+		})
+
+		it("never recursively removes an ancestor reported by recursive mkdir", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			// mkdir(recursive) reports the first ancestor it created; removing that value
+			// recursively could take the sibling skill directories under it with it.
+			mockMkdir.mockResolvedValue(p(GLOBAL_ROO_DIR, "skills"))
+			mockWriteFile.mockRejectedValueOnce(Object.assign(new Error("ENOSPC"), { code: "ENOSPC" }))
+			mockUnlink.mockResolvedValue(undefined)
+			mockRm.mockResolvedValue(undefined)
+			mockRmdir.mockResolvedValue(undefined)
+
+			await expect(skillsManager.createSkill("isolated-skill", "global", "Description")).rejects.toThrow("ENOSPC")
+
+			// Only this skill's directory is considered, and only for an empty-only removal.
+			expect(mockRmdir).toHaveBeenCalledWith(p(GLOBAL_ROO_DIR, "skills", "isolated-skill"))
+			expect(mockRm).not.toHaveBeenCalled()
 		})
 
 		it("does not remove a pre-existing skill directory when persistence fails", async () => {
@@ -2352,6 +2393,7 @@ Instructions`)
 			await expect(skillsManager.createSkill("owned-skill", "global", "Description")).rejects.toThrow("EACCES")
 
 			expect(mockRm).not.toHaveBeenCalled()
+			expect(mockRmdir).not.toHaveBeenCalled()
 			expect(mockUnlink).toHaveBeenCalledWith(expect.stringMatching(/\.SKILL\.md\.[^/\\]+\.tmp$/))
 		})
 

From 7163cfd89421ab344c58d2f7c02a650032f0e12d Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:35:37 +0800
Subject: [PATCH 17/26] test(webview): type the skills initial state and keep
 the visual test screenshot-only

Review follow-ups: the provider initial-state contract now types skills/skillDiagnostics and seeds both provider values from initialState (empty-array fallbacks), so the gallery story passes them without a double assertion. The behaviour assertions (diagnostic text, locations, valid skill row) already live in the SkillsSettings Vitest suite; the visual test now only mounts the deterministic story, checks bounded layout and pins the screenshot. SkillsSettings.spec.tsx 22 passed; the visual test passes with the unchanged baseline.
---
 webview-ui/playwright/gallery/stories.tsx          |  8 +-------
 .../settings/__tests__/SkillsSettings.visual.tsx   | 14 +++-----------
 webview-ui/src/context/ExtensionStateContext.tsx   | 10 ++++++++--
 3 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/webview-ui/playwright/gallery/stories.tsx b/webview-ui/playwright/gallery/stories.tsx
index 70996c077f..c44f2e2c66 100644
--- a/webview-ui/playwright/gallery/stories.tsx
+++ b/webview-ui/playwright/gallery/stories.tsx
@@ -469,14 +469,8 @@ export const stories: Record<string, Story> = {
 				message: "Missing required 'description' field",
 			},
 		]
-		// The gallery's ExtensionStateContext shim merges arbitrary keys, while the real
-		// provider's state type does not expose the skills diagnostics fields the settings
-		// panel reads; the cast keeps the story typed without changing production state.
-		const initialState = { cwd: "/workspace", skills, skillDiagnostics } as unknown as NonNullable<
-			React.ComponentProps<typeof AppProviders>["initialState"]
-		>
 		return (
-			<AppProviders initialState={initialState}>
+			<AppProviders initialState={{ cwd: "/workspace", skills, skillDiagnostics }}>
 				<div
 					className="flex h-full w-full flex-col bg-vscode-editor-background p-4 text-vscode-foreground"
 					data-testid="skills-settings-story">
diff --git a/webview-ui/src/components/settings/__tests__/SkillsSettings.visual.tsx b/webview-ui/src/components/settings/__tests__/SkillsSettings.visual.tsx
index b1eff02240..27330ab8d7 100644
--- a/webview-ui/src/components/settings/__tests__/SkillsSettings.visual.tsx
+++ b/webview-ui/src/components/settings/__tests__/SkillsSettings.visual.tsx
@@ -2,21 +2,13 @@ import { expect, test } from "../../../../playwright/coverage-fixture"
 import { collectBoundedLayoutFailures } from "../../../../playwright/layout-contracts"
 import { mountedStory } from "../../../../playwright/mounted-story"
 
-test("shows skill load diagnostics with paths, locations and messages", async ({ mount, page }) => {
+test("renders the diagnostics story deterministically", async ({ mount, page }) => {
 	await page.setViewportSize({ width: 520, height: 480 })
 	const component = mountedStory(await mount("skills-settings-diagnostics"))
 	const story = component.getByTestId("skills-settings-story")
-	const alert = story.getByRole("alert")
-
-	await expect(alert).toBeVisible()
-	// The diagnostics are rendered verbatim: path, optional line:column, message.
-	await expect(alert).toContainText("/workspace/.roo/skills/broken-skill/SKILL.md:3:12")
-	await expect(alert).toContainText("Invalid YAML frontmatter: unexpected end of the stream")
-	await expect(alert).toContainText("/home/user/.roo/skills/legacy-mode/SKILL.md")
-	await expect(alert).toContainText("Missing required 'description' field")
-	// The valid skill next to the diagnostics still renders its own row.
-	await expect(story).toContainText("diagnostics-demo")
 
+	// Behavioural assertions for the diagnostics alert live in the SkillsSettings Vitest
+	// suite; this test only pins the deterministic state and its screenshot.
 	await expect(story).toHaveScreenshot("skills-settings-diagnostics.png")
 	await expect.poll(() => story.evaluate(collectBoundedLayoutFailures)).toEqual([])
 })
diff --git a/webview-ui/src/context/ExtensionStateContext.tsx b/webview-ui/src/context/ExtensionStateContext.tsx
index ed7af1fd2d..1aef01e2d9 100644
--- a/webview-ui/src/context/ExtensionStateContext.tsx
+++ b/webview-ui/src/context/ExtensionStateContext.tsx
@@ -284,6 +284,10 @@ export const createInitialExtensionState = (): ExtensionState => ({
 
 type ExtensionStateProviderInitialState = Partial<ExtensionState> & {
 	routerModels?: RouterModels
+	// The skill state lives outside ExtensionState; the fixture and tests seed it here so the
+	// initial-state contract covers every value the provider exposes.
+	skills?: SkillMetadata[]
+	skillDiagnostics?: SkillDiagnostic[]
 }
 
 export const ExtensionStateContextProvider: React.FC<{
@@ -319,8 +323,10 @@ export const ExtensionStateContextProvider: React.FC<{
 				global: {},
 			},
 	)
-	const [skills, setSkills] = useState<SkillMetadata[]>([])
-	const [skillDiagnostics, setSkillDiagnostics] = useState<SkillDiagnostic[]>([])
+	const [skills, setSkills] = useState<SkillMetadata[]>(() => initialState?.skills ?? [])
+	const [skillDiagnostics, setSkillDiagnostics] = useState<SkillDiagnostic[]>(
+		() => initialState?.skillDiagnostics ?? [],
+	)
 	const [rules, setRules] = useState<RuleMetadata[]>([])
 	const [includeTaskHistoryInEnhance, setIncludeTaskHistoryInEnhance] = useState(
 		() => initialState?.includeTaskHistoryInEnhance ?? true,

From 304c647553b42700203d091e46c83c44a21922de Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:54:06 +0800
Subject: [PATCH 18/26] fix(skills): propagate a failed realpath resolution
 before the atomic publish

Review follow-up: updateSkillModes no longer falls back to the discovered path when realpath fails at publish time; publishing through the unresolved path could replace a symlink with a regular file or write somewhere other than the target the caller saw. Added a test where discovery succeeds but the resolution fails: the exact error propagates and no write/rename happens. SkillsManager.spec.ts 117 passed.
---
 src/services/skills/SkillsManager.ts          | 10 ++-----
 .../skills/__tests__/SkillsManager.spec.ts    | 29 +++++++++++++++++++
 2 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 44cdcad378..6dab743cca 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -1100,13 +1100,9 @@ Add your skill instructions here.
 		const newContent = matter.stringify(body, frontmatter, SKILL_YAML_DUMP_OPTIONS)
 		// Resolve the link target first: publishing through the temp+rename must update the file
 		// the skill was discovered through, not replace a symlinked SKILL.md with a regular file.
-		let targetPath = skill.path
-		try {
-			targetPath = await fs.realpath(skill.path)
-		} catch {
-			// Unresolvable path (already missing, or a platform without realpath): keep the
-			// discovered path and let the write report the real failure.
-		}
+		// A resolution failure propagates: publishing through the unresolved path could replace a
+		// symlink with a regular file (or write somewhere other than the target the caller saw).
+		const targetPath = await fs.realpath(skill.path)
 		await this.writeSkillFileAtomically(targetPath, newContent)
 
 		// Refresh skills list
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index 8c194871fc..d1b9d704ac 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -2534,6 +2534,35 @@ Body here.`
 			expect(parsed2.data.description).toBe(description)
 		})
 
+		it("propagates a realpath failure instead of writing through the unresolved path", async () => {
+			const skillDir = p(globalSkillsDir, "unresolvable-skill")
+			const skillMd = p(skillDir, "SKILL.md")
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockReaddir.mockImplementation(async (dir: string) =>
+				dir === globalSkillsDir ? ["unresolvable-skill"] : [],
+			)
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === skillDir) {
+					return { isDirectory: () => true }
+				}
+				throw enoent()
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === skillMd)
+			mockReadFile.mockResolvedValue("---\nname: unresolvable-skill\ndescription: A skill\n---\nInstructions")
+
+			await skillsManager.discoverSkills()
+			// The discovered path resolves, but the publish-time resolution fails: the write must
+			// not fall back to the unresolved (potentially symlinked) path.
+			const resolutionError = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" })
+			mockRealpath.mockRejectedValueOnce(resolutionError)
+
+			await expect(skillsManager.updateSkillModes("unresolvable-skill", "global", ["code"])).rejects.toBe(
+				resolutionError,
+			)
+			expect(mockWriteFile).not.toHaveBeenCalled()
+			expect(mockRename).not.toHaveBeenCalled()
+		})
+
 		it("should throw error for invalid skill name", async () => {
 			await expect(skillsManager.createSkill("Invalid-Name", "global", "Description")).rejects.toThrow(
 				"Skill name must be lowercase letters/numbers/hyphens only",

From 3f0010f21123a90799dd87342ff9f43be8c2dfdc Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:30:15 +0800
Subject: [PATCH 19/26] fix(skills): keep SKILL.md publishes inside the skills
 roots and track temp sidecars

Review follow-ups: updateSkillModes resolves the SKILL.md target and rejects it when the real path falls outside every configured skills root for the source, so a direct skill-directory symlink cannot publish outside the selected folder. Atomic writes track their temp sidecar in the manager while in flight, dispose() removes any still-tracked sidecar, and initialize() sweeps stale sidecars left by a previous host under the known skills roots. Added focused tests for createSkill/updateSkillModes rename rejection (temp removed, original error rethrown), outside-root refusal (no write/rename), and dispose sidecar cleanup. SkillsManager.spec.ts 121 passed; tsc clean.
---
 src/services/skills/SkillsManager.ts          | 75 ++++++++++++++++
 .../skills/__tests__/SkillsManager.spec.ts    | 87 +++++++++++++++++++
 2 files changed, 162 insertions(+)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 6dab743cca..578dfdaa8c 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -110,16 +110,62 @@ export class SkillsManager {
 	// Runs discovery passes one at a time, so an older pass can't finish after a newer one
 	private discoveryQueue: Promise<void> = Promise.resolve()
 	private isDisposed = false
+	// Atomic SKILL.md writes in flight, tracked so dispose() can remove temp sidecars if the
+	// extension host stops between the staged write and the rename.
+	private activeTempFiles: Set<string> = new Set()
 
 	constructor(provider: ClineProvider) {
 		this.providerRef = new WeakRef(provider)
 	}
 
 	async initialize(): Promise<void> {
+		// A previous extension-host stop can leave a staged SKILL.md temp sidecar behind; the
+		// in-memory tracking cannot survive that, so sweep the known skills directories once.
+		try {
+			await this.sweepStaleSkillTempFiles()
+		} catch {
+			// Stale-cleanup is best effort; discovery and watcher setup still run.
+		}
 		await this.discoverSkills()
 		await this.setupFileWatchers()
 	}
 
+	/**
+	 * Remove SKILL.md temp sidecars left by a previous host: the name pattern is the one
+	 * writeSkillFileAtomically generates, and only the skill directories under the known skills
+	 * roots are scanned.
+	 */
+	private async sweepStaleSkillTempFiles(): Promise<void> {
+		const tempPattern = /^\..*\.SKILL\.md\..*\.tmp$/
+		const roots = (await this.getSkillsDirectories()).map((entry) => entry.dir)
+		for (const root of roots) {
+			let entries: unknown[]
+			try {
+				entries = await fs.readdir(root, { withFileTypes: true })
+			} catch {
+				continue
+			}
+			const directories = [root]
+			for (const entry of entries) {
+				const dirent = entry as { name?: string; isDirectory?: () => boolean }
+				if (!dirent?.isDirectory?.()) continue
+				directories.push(path.join(root, String(dirent.name)))
+			}
+			for (const directory of directories) {
+				let files: string[]
+				try {
+					files = await fs.readdir(directory)
+				} catch {
+					continue
+				}
+				for (const file of files) {
+					if (!tempPattern.test(file)) continue
+					await fs.unlink(path.join(directory, file)).catch(() => {})
+				}
+			}
+		}
+	}
+
 	/**
 	 * Discover all skills from global and project directories.
 	 * Supports both generic skills (skills/) and mode-specific skills (skills-{mode}/).
@@ -675,6 +721,7 @@ export class SkillsManager {
 			directory,
 			`.${path.basename(filePath)}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
 		)
+		this.activeTempFiles.add(temporaryPath)
 		try {
 			await fs.writeFile(temporaryPath, content, "utf-8")
 			await fs.rename(temporaryPath, filePath)
@@ -683,6 +730,8 @@ export class SkillsManager {
 			// failure is the one the caller needs to see.
 			await fs.unlink(temporaryPath).catch(() => {})
 			throw error
+		} finally {
+			this.activeTempFiles.delete(temporaryPath)
 		}
 	}
 
@@ -1063,6 +1112,26 @@ Add your skill instructions here.
 	 * @param source - Where the skill is located ("global" or "project")
 	 * @param newModeSlugs - New mode slugs (undefined/empty = any mode)
 	 */
+	/**
+	 * The resolved SKILL.md target must stay inside one of the configured skills roots for the
+	 * source: a direct skill-directory symlink can point anywhere, and publishing through it
+	 * would write outside the user selected skills folder.
+	 */
+	private async assertTargetWithinSkillsRoots(targetPath: string, source: "global" | "project"): Promise<void> {
+		const roots = (await this.getSkillsDirectories())
+			.filter((entry) => entry.source === source)
+			.map((entry) => entry.dir)
+		const inside = async (root: string): Promise<boolean> => {
+			const resolvedRoot = await fs.realpath(root).catch(() => root)
+			const relative = path.relative(resolvedRoot, targetPath)
+			return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative)
+		}
+		for (const root of roots) {
+			if (await inside(root)) return
+		}
+		throw new Error(`Refusing to update SKILL.md outside the ${source} skills directories: ${targetPath}`)
+	}
+
 	async updateSkillModes(name: string, source: "global" | "project", newModeSlugs?: string[]): Promise<void> {
 		// Find any skill with this name and source (regardless of current mode)
 		let skill: SkillMetadata | undefined
@@ -1103,6 +1172,7 @@ Add your skill instructions here.
 		// A resolution failure propagates: publishing through the unresolved path could replace a
 		// symlink with a regular file (or write somewhere other than the target the caller saw).
 		const targetPath = await fs.realpath(skill.path)
+		await this.assertTargetWithinSkillsRoots(targetPath, source)
 		await this.writeSkillFileAtomically(targetPath, newContent)
 
 		// Refresh skills list
@@ -1284,6 +1354,11 @@ Add your skill instructions here.
 
 	async dispose(): Promise<void> {
 		this.isDisposed = true
+		// Any sidecar still tracked is a write that never reached its rename.
+		for (const temporaryPath of this.activeTempFiles) {
+			await fs.unlink(temporaryPath).catch(() => {})
+		}
+		this.activeTempFiles.clear()
 		this.disposables.forEach((d) => d.dispose())
 		this.disposables = []
 		this.containerWatchers.forEach((w) => w.dispose())
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index d1b9d704ac..02372f88b7 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -2379,6 +2379,26 @@ Instructions`)
 			expect(mockRm).not.toHaveBeenCalled()
 		})
 
+		it("removes the temp file and rethrows the original error when the create rename fails", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			mockMkdir.mockResolvedValue(p(GLOBAL_ROO_DIR, "skills", "rename-fails"))
+			mockWriteFile.mockResolvedValue(undefined)
+			const renameError = Object.assign(new Error("EEXIST: rename failed"), { code: "EEXIST" })
+			mockRename.mockRejectedValueOnce(renameError)
+			mockUnlink.mockResolvedValue(undefined)
+			mockRmdir.mockResolvedValue(undefined)
+
+			await expect(skillsManager.createSkill("rename-fails", "global", "Description")).rejects.toBe(renameError)
+
+			const temporaryPath = String(mockWriteFile.mock.calls[0][0])
+			expect(temporaryPath).toMatch(/\.SKILL\.md\.[^/\\]+\.tmp$/)
+			expect(mockUnlink).toHaveBeenCalledWith(temporaryPath)
+			expect(skillsManager["activeTempFiles"].size).toBe(0)
+		})
+
 		it("does not remove a pre-existing skill directory when persistence fails", async () => {
 			mockDirectoryExists.mockResolvedValue(false)
 			mockRealpath.mockImplementation(async (p: string) => p)
@@ -2563,6 +2583,64 @@ Body here.`
 			expect(mockRename).not.toHaveBeenCalled()
 		})
 
+		it("removes the temp file and rethrows the original error when the update rename fails", async () => {
+			const skillDir = p(globalSkillsDir, "rename-update")
+			const skillMd = p(skillDir, "SKILL.md")
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["rename-update"] : []))
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === skillDir) {
+					return { isDirectory: () => true }
+				}
+				throw enoent()
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === skillMd)
+			mockReadFile.mockResolvedValue("---\nname: rename-update\ndescription: A skill\n---\nInstructions")
+			mockRealpath.mockImplementation(async (pathArg: string) => pathArg)
+			mockWriteFile.mockResolvedValue(undefined)
+			const renameError = Object.assign(new Error("EIO: rename failed"), { code: "EIO" })
+			mockRename.mockRejectedValueOnce(renameError)
+			mockUnlink.mockResolvedValue(undefined)
+
+			await skillsManager.discoverSkills()
+
+			await expect(skillsManager.updateSkillModes("rename-update", "global", ["code"])).rejects.toBe(renameError)
+
+			const temporaryPath = String(mockWriteFile.mock.calls[0][0])
+			expect(temporaryPath).toMatch(/\.SKILL\.md\.[^/\\]+\.tmp$/)
+			expect(mockUnlink).toHaveBeenCalledWith(temporaryPath)
+			expect(skillsManager["activeTempFiles"].size).toBe(0)
+		})
+
+		it("refuses to update a SKILL.md that resolves outside the skills roots", async () => {
+			const skillDir = p(globalSkillsDir, "escaping")
+			const skillMd = p(skillDir, "SKILL.md")
+			const outsidePath = p("/outside/root", "SKILL.md")
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["escaping"] : []))
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === skillDir) {
+					return { isDirectory: () => true }
+				}
+				throw enoent()
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === skillMd)
+			mockReadFile.mockResolvedValue("---\nname: escaping\ndescription: A skill\n---\nInstructions")
+			// Discovery saw the root path, but the publish-time resolution points outside every
+			// configured skills root: a direct skill-dir symlink must not let the write escape.
+			mockRealpath.mockImplementation(async (pathArg: string) => (pathArg === skillMd ? outsidePath : pathArg))
+			mockWriteFile.mockResolvedValue(undefined)
+			mockRename.mockResolvedValue(undefined)
+
+			await skillsManager.discoverSkills()
+
+			await expect(skillsManager.updateSkillModes("escaping", "global", ["code"])).rejects.toThrow(
+				/Refusing to update SKILL\.md outside the global skills directories/,
+			)
+			expect(mockWriteFile).not.toHaveBeenCalled()
+			expect(mockRename).not.toHaveBeenCalled()
+		})
+
 		it("should throw error for invalid skill name", async () => {
 			await expect(skillsManager.createSkill("Invalid-Name", "global", "Description")).rejects.toThrow(
 				"Skill name must be lowercase letters/numbers/hyphens only",
@@ -3967,4 +4045,13 @@ Instructions`)
 			})
 		})
 	})
+	it("removes tracked temp sidecars on dispose", async () => {
+		mockUnlink.mockResolvedValue(undefined)
+		skillsManager["activeTempFiles"].add("/mock/skills/foo/.SKILL.md.123.abc.tmp")
+
+		await skillsManager.dispose()
+
+		expect(mockUnlink).toHaveBeenCalledWith("/mock/skills/foo/.SKILL.md.123.abc.tmp")
+		expect(skillsManager["activeTempFiles"].size).toBe(0)
+	})
 })

From 29019356f962e235222957138781b6b0543c93bf Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:54:43 +0800
Subject: [PATCH 20/26] fix(skills): exclusive staging, pre-rename
 revalidation, and cancellation-safe init

Review follow-ups: staged SKILL.md temp files are created with flag wx so a pre-created symlink at the generated name cannot be followed, and updateSkillModes re-resolves the target immediately before the rename and re-validates it against the source skills roots. The rename-rejection tests now also assert the wx flag, that create cleanup removes only its own directory (rmdir, no recursive rm), and that the existing SKILL.md is not replaced. initialize() is idempotent/cancellation-safe: it tracks the initialization promise and stops after the stale sweep or discovery if the manager was disposed, and setupFileWatchers/watchDirectory return early when disposed (test: initialize after dispose starts no watchers). SkillsManager.spec.ts 122 passed; tsc clean.
---
 src/services/skills/SkillsManager.ts          | 48 ++++++++++++++-----
 .../skills/__tests__/SkillsManager.spec.ts    | 15 ++++++
 2 files changed, 50 insertions(+), 13 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 578dfdaa8c..a15b8780ab 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -118,16 +118,25 @@ export class SkillsManager {
 		this.providerRef = new WeakRef(provider)
 	}
 
-	async initialize(): Promise<void> {
-		// A previous extension-host stop can leave a staged SKILL.md temp sidecar behind; the
-		// in-memory tracking cannot survive that, so sweep the known skills directories once.
-		try {
-			await this.sweepStaleSkillTempFiles()
-		} catch {
-			// Stale-cleanup is best effort; discovery and watcher setup still run.
-		}
-		await this.discoverSkills()
-		await this.setupFileWatchers()
+	private initialization: Promise<void> | null = null
+
+	initialize(): Promise<void> {
+		if (this.initialization) return this.initialization
+		this.initialization = (async () => {
+			// A previous extension-host stop can leave a staged SKILL.md temp sidecar behind; the
+			// in-memory tracking cannot survive that, so sweep the known skills directories once.
+			try {
+				await this.sweepStaleSkillTempFiles()
+			} catch {
+				// Stale-cleanup is best effort; discovery and watcher setup still run.
+			}
+			// Disposal can land during the sweep: stop before touching discovery or watchers.
+			if (this.isDisposed) return
+			await this.discoverSkills()
+			if (this.isDisposed) return
+			await this.setupFileWatchers()
+		})()
+		return this.initialization
 	}
 
 	/**
@@ -715,7 +724,11 @@ export class SkillsManager {
 	 * must not leave a truncated SKILL.md that the loader would silently misparse.
 	 * The temp file is removed when the write or rename fails.
 	 */
-	private async writeSkillFileAtomically(filePath: string, content: string): Promise<void> {
+	private async writeSkillFileAtomically(
+		filePath: string,
+		content: string,
+		validateTarget?: (targetPath: string) => Promise<void>,
+	): Promise<void> {
 		const directory = path.dirname(filePath)
 		const temporaryPath = path.join(
 			directory,
@@ -723,7 +736,11 @@ export class SkillsManager {
 		)
 		this.activeTempFiles.add(temporaryPath)
 		try {
-			await fs.writeFile(temporaryPath, content, "utf-8")
+			// Exclusive creation: a pre-created symlink at the generated name cannot be followed.
+			await fs.writeFile(temporaryPath, content, { encoding: "utf-8", flag: "wx" })
+			// Re-validate the final target immediately before the rename: the target (or an
+			// ancestor) can change between the caller's resolution and this publish.
+			await validateTarget?.(filePath)
 			await fs.rename(temporaryPath, filePath)
 		} catch (error) {
 			// Best effort: a partial temp file must not be left behind. The original
@@ -1173,7 +1190,10 @@ Add your skill instructions here.
 		// symlink with a regular file (or write somewhere other than the target the caller saw).
 		const targetPath = await fs.realpath(skill.path)
 		await this.assertTargetWithinSkillsRoots(targetPath, source)
-		await this.writeSkillFileAtomically(targetPath, newContent)
+		await this.writeSkillFileAtomically(targetPath, newContent, async (target) => {
+			const freshTarget = await fs.realpath(target).catch(() => target)
+			await this.assertTargetWithinSkillsRoots(freshTarget, source)
+		})
 
 		// Refresh skills list
 		await this.discoverSkills()
@@ -1264,6 +1284,7 @@ Add your skill instructions here.
 	}
 
 	private async setupFileWatchers(): Promise<void> {
+		if (this.isDisposed) return
 		// Skip if test environment is detected or VSCode APIs are not available
 		if (process.env.NODE_ENV === "test" || !vscode.workspace.createFileSystemWatcher) {
 			return
@@ -1303,6 +1324,7 @@ Add your skill instructions here.
 	}
 
 	private watchDirectory(dirPath: string): void {
+		if (this.isDisposed) return
 		const watcher = this.createSkillsWatcher(dirPath)
 		if (watcher) {
 			this.disposables.push(watcher)
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index 02372f88b7..b10edc903e 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -2608,7 +2608,12 @@ Body here.`
 
 			const temporaryPath = String(mockWriteFile.mock.calls[0][0])
 			expect(temporaryPath).toMatch(/\.SKILL\.md\.[^/\\]+\.tmp$/)
+			expect(mockWriteFile.mock.calls[0][2]).toEqual(expect.objectContaining({ flag: "wx" }))
 			expect(mockUnlink).toHaveBeenCalledWith(temporaryPath)
+			// The existing SKILL.md was never replaced: the only write went to the temp sidecar and
+			// the failed rename never committed.
+			expect(mockWriteFile).toHaveBeenCalledTimes(1)
+			expect(mockRename).toHaveBeenCalledWith(temporaryPath, skillMd)
 			expect(skillsManager["activeTempFiles"].size).toBe(0)
 		})
 
@@ -4045,6 +4050,16 @@ Instructions`)
 			})
 		})
 	})
+	it("does not start watchers when initialization runs after disposal", async () => {
+		const createWatcher = vi.mocked(vscode.workspace.createFileSystemWatcher)
+		await skillsManager.dispose()
+		createWatcher.mockClear()
+
+		await skillsManager.initialize()
+
+		expect(createWatcher).not.toHaveBeenCalled()
+	})
+
 	it("removes tracked temp sidecars on dispose", async () => {
 		mockUnlink.mockResolvedValue(undefined)
 		skillsManager["activeTempFiles"].add("/mock/skills/foo/.SKILL.md.123.abc.tmp")

From 30e0e01962f8c679c1359eea04f13f3eda4275ec Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:15:22 +0800
Subject: [PATCH 21/26] fix(skills): match the real sidecar name, guard watcher
 setup, and only clean staged files this write owns

Review follow-ups: the stale-sidecar sweep pattern now matches the generated name (.SKILL.md.<ts>.<rand>.tmp) with a restart-cleanup test; a focused watcher-guard test runs setupFileWatchers under NODE_ENV=development, then disposes and asserts no watcher is created again; the atomic writer cleans up a staged sidecar unless exclusive creation failed with EEXIST (an existing file at the generated name belongs to someone else), with a test that preserves it. SkillsManager.spec.ts 125 passed.
---
 src/services/skills/SkillsManager.ts          | 16 ++++--
 .../skills/__tests__/SkillsManager.spec.ts    | 51 +++++++++++++++++++
 2 files changed, 63 insertions(+), 4 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index a15b8780ab..761466def8 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -145,7 +145,7 @@ export class SkillsManager {
 	 * roots are scanned.
 	 */
 	private async sweepStaleSkillTempFiles(): Promise<void> {
-		const tempPattern = /^\..*\.SKILL\.md\..*\.tmp$/
+		const tempPattern = /^\.SKILL\.md\..*\.tmp$/
 		const roots = (await this.getSkillsDirectories()).map((entry) => entry.dir)
 		for (const root of roots) {
 			let entries: unknown[]
@@ -735,17 +735,25 @@ export class SkillsManager {
 			`.${path.basename(filePath)}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
 		)
 		this.activeTempFiles.add(temporaryPath)
+		// Only a write that actually created the sidecar through exclusive creation may remove it:
+		// when wx fails because the path already exists, that file belongs to someone else.
+		let ownsTemporaryPath = false
 		try {
 			// Exclusive creation: a pre-created symlink at the generated name cannot be followed.
 			await fs.writeFile(temporaryPath, content, { encoding: "utf-8", flag: "wx" })
+			ownsTemporaryPath = true
 			// Re-validate the final target immediately before the rename: the target (or an
 			// ancestor) can change between the caller's resolution and this publish.
 			await validateTarget?.(filePath)
 			await fs.rename(temporaryPath, filePath)
 		} catch (error) {
-			// Best effort: a partial temp file must not be left behind. The original
-			// failure is the one the caller needs to see.
-			await fs.unlink(temporaryPath).catch(() => {})
+			// Best effort: a partial temp file must not be left behind, but an EEXIST failure means
+			// exclusive creation never acquired the path and the existing file belongs to someone
+			// else. Any other failure may have created a partial sidecar and is cleaned up; the
+			// original failure is the one the caller needs to see.
+			if (ownsTemporaryPath || (error as { code?: string })?.code !== "EEXIST") {
+				await fs.unlink(temporaryPath).catch(() => {})
+			}
 			throw error
 		} finally {
 			this.activeTempFiles.delete(temporaryPath)
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index b10edc903e..d181a7e1f2 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -2379,6 +2379,24 @@ Instructions`)
 			expect(mockRm).not.toHaveBeenCalled()
 		})
 
+		it("preserves an existing file when exclusive staging fails because the name exists", async () => {
+			mockDirectoryExists.mockResolvedValue(false)
+			mockRealpath.mockImplementation(async (p: string) => p)
+			mockReaddir.mockResolvedValue([])
+			mockFileExists.mockResolvedValue(false)
+			mockMkdir.mockResolvedValue(p(GLOBAL_ROO_DIR, "skills", "exists"))
+			const existsError = Object.assign(new Error("EEXIST: file already exists"), { code: "EEXIST" })
+			mockWriteFile.mockRejectedValueOnce(existsError)
+			mockUnlink.mockResolvedValue(undefined)
+
+			await expect(skillsManager.createSkill("exists", "global", "Description")).rejects.toBe(existsError)
+
+			// wx failed before this write owned the path: the existing file must not be unlinked.
+			expect(mockUnlink).not.toHaveBeenCalled()
+			expect(mockRename).not.toHaveBeenCalled()
+			expect(skillsManager["activeTempFiles"].size).toBe(0)
+		})
+
 		it("removes the temp file and rethrows the original error when the create rename fails", async () => {
 			mockDirectoryExists.mockResolvedValue(false)
 			mockRealpath.mockImplementation(async (p: string) => p)
@@ -4050,6 +4068,39 @@ Instructions`)
 			})
 		})
 	})
+	it("stops creating watchers once the manager is disposed", async () => {
+		const createWatcher = vi.mocked(vscode.workspace.createFileSystemWatcher)
+		const originalNodeEnv = process.env.NODE_ENV
+		process.env.NODE_ENV = "development"
+		try {
+			createWatcher.mockClear()
+			await skillsManager["setupFileWatchers"]()
+			expect(createWatcher).toHaveBeenCalled()
+
+			createWatcher.mockClear()
+			await skillsManager.dispose()
+			await skillsManager["setupFileWatchers"]()
+			expect(createWatcher).not.toHaveBeenCalled()
+		} finally {
+			process.env.NODE_ENV = originalNodeEnv
+		}
+	})
+
+	it("sweeps a staged sidecar left by a previous host", async () => {
+		const staleName = ".SKILL.md.123.abc.tmp"
+		mockReaddir.mockImplementation(async (_dir: string, options?: { withFileTypes?: boolean }) => {
+			if (options?.withFileTypes) {
+				return []
+			}
+			return [staleName]
+		})
+		mockUnlink.mockResolvedValue(undefined)
+
+		await skillsManager["sweepStaleSkillTempFiles"]()
+
+		expect(mockUnlink).toHaveBeenCalledWith(p(globalSkillsDir, staleName))
+	})
+
 	it("does not start watchers when initialization runs after disposal", async () => {
 		const createWatcher = vi.mocked(vscode.workspace.createFileSystemWatcher)
 		await skillsManager.dispose()

From 08b2447db091aef6fcd81808231da95ea38f47b5 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:28:15 +0800
Subject: [PATCH 22/26] ci: retrigger platform tests after the vitest worker
 teardown flake

The previous run executed all 3934 tests successfully but vitest reported EnvironmentTeardownError (onUserConsoleLog pending) in grace-retry-errors.spec.ts during worker shutdown, failing the job. No source change.

From 1100ade9cf8c6c480fe08ba86873d62fb2d13648 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:50:05 +0800
Subject: [PATCH 23/26] fix(skills): narrow the sidecar pattern and serialize
 sweep/write per directory

Review follow-ups: the stale-sidecar sweep only matches the writer-generated name (dot, SKILL.md, numeric timestamp, base36 suffix, .tmp), and a static per-directory queue shared by every SkillsManager instance wraps both the sweep and the atomic write create/validate/rename path so cleanup cannot unlink a sidecar another instance is writing. SkillsManager.spec.ts 125 passed.
---
 src/services/skills/SkillsManager.ts | 102 +++++++++++++++++----------
 1 file changed, 64 insertions(+), 38 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 761466def8..1d9773e2a2 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -113,6 +113,10 @@ export class SkillsManager {
 	// Atomic SKILL.md writes in flight, tracked so dispose() can remove temp sidecars if the
 	// extension host stops between the staged write and the rename.
 	private activeTempFiles: Set<string> = new Set()
+	// Per-directory serialization for SKILL.md sidecar cleanup and writes. The queue is static so
+	// every SkillsManager instance in this process shares it: a sweep cannot unlink a sidecar that
+	// another instance is still writing, and writes cannot interleave their validate/rename steps.
+	private static directoryQueues: Map<string, Promise<void>> = new Map()
 
 	constructor(provider: ClineProvider) {
 		this.providerRef = new WeakRef(provider)
@@ -145,7 +149,7 @@ export class SkillsManager {
 	 * roots are scanned.
 	 */
 	private async sweepStaleSkillTempFiles(): Promise<void> {
-		const tempPattern = /^\.SKILL\.md\..*\.tmp$/
+		const tempPattern = /^\.SKILL\.md\.\d+\.[a-z0-9]+\.tmp$/
 		const roots = (await this.getSkillsDirectories()).map((entry) => entry.dir)
 		for (const root of roots) {
 			let entries: unknown[]
@@ -161,16 +165,18 @@ export class SkillsManager {
 				directories.push(path.join(root, String(dirent.name)))
 			}
 			for (const directory of directories) {
-				let files: string[]
-				try {
-					files = await fs.readdir(directory)
-				} catch {
-					continue
-				}
-				for (const file of files) {
-					if (!tempPattern.test(file)) continue
-					await fs.unlink(path.join(directory, file)).catch(() => {})
-				}
+				await this.withDirectoryLock(directory, async () => {
+					let files: string[]
+					try {
+						files = await fs.readdir(directory)
+					} catch {
+						return
+					}
+					for (const file of files) {
+						if (!tempPattern.test(file)) continue
+						await fs.unlink(path.join(directory, file)).catch(() => {})
+					}
+				})
 			}
 		}
 	}
@@ -724,40 +730,60 @@ export class SkillsManager {
 	 * must not leave a truncated SKILL.md that the loader would silently misparse.
 	 * The temp file is removed when the write or rename fails.
 	 */
+	private async withDirectoryLock<T>(directory: string, operation: () => Promise<T>): Promise<T> {
+		const key = path.resolve(directory)
+		const previous = SkillsManager.directoryQueues.get(key) ?? Promise.resolve()
+		const run = previous.then(operation)
+		const tracked = run.then(
+			() => undefined,
+			() => undefined,
+		)
+		SkillsManager.directoryQueues.set(key, tracked)
+		try {
+			return await run
+		} finally {
+			if (SkillsManager.directoryQueues.get(key) === tracked) {
+				SkillsManager.directoryQueues.delete(key)
+			}
+		}
+	}
+
 	private async writeSkillFileAtomically(
 		filePath: string,
 		content: string,
 		validateTarget?: (targetPath: string) => Promise<void>,
 	): Promise<void> {
 		const directory = path.dirname(filePath)
-		const temporaryPath = path.join(
-			directory,
-			`.${path.basename(filePath)}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
-		)
-		this.activeTempFiles.add(temporaryPath)
-		// Only a write that actually created the sidecar through exclusive creation may remove it:
-		// when wx fails because the path already exists, that file belongs to someone else.
-		let ownsTemporaryPath = false
-		try {
-			// Exclusive creation: a pre-created symlink at the generated name cannot be followed.
-			await fs.writeFile(temporaryPath, content, { encoding: "utf-8", flag: "wx" })
-			ownsTemporaryPath = true
-			// Re-validate the final target immediately before the rename: the target (or an
-			// ancestor) can change between the caller's resolution and this publish.
-			await validateTarget?.(filePath)
-			await fs.rename(temporaryPath, filePath)
-		} catch (error) {
-			// Best effort: a partial temp file must not be left behind, but an EEXIST failure means
-			// exclusive creation never acquired the path and the existing file belongs to someone
-			// else. Any other failure may have created a partial sidecar and is cleaned up; the
-			// original failure is the one the caller needs to see.
-			if (ownsTemporaryPath || (error as { code?: string })?.code !== "EEXIST") {
-				await fs.unlink(temporaryPath).catch(() => {})
+		await this.withDirectoryLock(directory, async () => {
+			const temporaryPath = path.join(
+				directory,
+				`.${path.basename(filePath)}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
+			)
+			this.activeTempFiles.add(temporaryPath)
+			// Only a write that actually created the sidecar through exclusive creation may remove
+			// it: when wx fails because the path already exists, that file belongs to someone else.
+			let ownsTemporaryPath = false
+			try {
+				// Exclusive creation: a pre-created symlink at the generated name cannot be followed.
+				await fs.writeFile(temporaryPath, content, { encoding: "utf-8", flag: "wx" })
+				ownsTemporaryPath = true
+				// Re-validate the final target immediately before the rename: the target (or an
+				// ancestor) can change between the caller's resolution and this publish.
+				await validateTarget?.(filePath)
+				await fs.rename(temporaryPath, filePath)
+			} catch (error) {
+				// Best effort: a partial temp file must not be left behind, but an EEXIST failure
+				// means exclusive creation never acquired the path and the existing file belongs to
+				// someone else. Any other failure may have created a partial sidecar and is cleaned
+				// up; the original failure is the one the caller needs to see.
+				if (ownsTemporaryPath || (error as { code?: string })?.code !== "EEXIST") {
+					await fs.unlink(temporaryPath).catch(() => {})
+				}
+				throw error
+			} finally {
+				this.activeTempFiles.delete(temporaryPath)
 			}
-			throw error
-		} finally {
-			this.activeTempFiles.delete(temporaryPath)
-		}
+		})
 	}
 
 	async createSkill(

From ca68406ec3becf7e8f4a3615d7c9af4048cc11a4 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:13:06 +0800
Subject: [PATCH 24/26] fix(skills): bound the stale sweep by age and key the
 directory queue by realpath

Review follow-ups: sweepStaleSkillTempFiles only removes matching sidecars older than ten minutes so a fresh file owned by a live write in another process is left alone; withDirectoryLock resolves the directory through fs.realpath before deriving its queue key (fallback path.resolve) so symlink aliases share one lock. Tests cover the fresh-sidecar survival and alias serialization. SkillsManager.spec.ts 126 passed; tsc clean.
---
 src/services/skills/SkillsManager.ts          | 14 ++++-
 .../skills/__tests__/SkillsManager.spec.ts    | 51 ++++++++++++++++++-
 2 files changed, 61 insertions(+), 4 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 1d9773e2a2..07d11159c9 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -93,6 +93,10 @@ function isHiddenEntry(name: string): boolean {
 	return name.startsWith(".")
 }
 
+// Stale-sidecar sweep: a matching temp file younger than this may belong to a live write in
+// another process, so only older sidecars are treated as abandoned by a previous host.
+const SKILL_TEMP_SIDECAR_STALE_MS = 10 * 60 * 1000
+
 export class SkillsManager {
 	private skills: Map<string, SkillMetadata> = new Map()
 	private diagnostics: SkillDiagnostic[] = []
@@ -174,7 +178,11 @@ export class SkillsManager {
 					}
 					for (const file of files) {
 						if (!tempPattern.test(file)) continue
-						await fs.unlink(path.join(directory, file)).catch(() => {})
+						const stalePath = path.join(directory, file)
+						const stats = await fs.stat(stalePath).catch(() => undefined)
+						// Leave fresh sidecars alone: they may belong to a write in another process.
+						if (!stats || Date.now() - stats.mtimeMs < SKILL_TEMP_SIDECAR_STALE_MS) continue
+						await fs.unlink(stalePath).catch(() => {})
 					}
 				})
 			}
@@ -731,7 +739,9 @@ export class SkillsManager {
 	 * The temp file is removed when the write or rename fails.
 	 */
 	private async withDirectoryLock<T>(directory: string, operation: () => Promise<T>): Promise<T> {
-		const key = path.resolve(directory)
+		// Normalize through realpath first so a symlinked alias shares the same queue key; fall
+		// back to the resolved path when the directory cannot be resolved (e.g. not created yet).
+		const key = await fs.realpath(directory).catch(() => path.resolve(directory))
 		const previous = SkillsManager.directoryQueues.get(key) ?? Promise.resolve()
 		const run = previous.then(operation)
 		const tracked = run.then(
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index d181a7e1f2..c86a4a080b 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -4086,19 +4086,66 @@ Instructions`)
 		}
 	})
 
-	it("sweeps a staged sidecar left by a previous host", async () => {
+	it("sweeps only a staged sidecar left by a previous host", async () => {
 		const staleName = ".SKILL.md.123.abc.tmp"
+		const freshName = ".SKILL.md.456.def.tmp"
 		mockReaddir.mockImplementation(async (_dir: string, options?: { withFileTypes?: boolean }) => {
 			if (options?.withFileTypes) {
 				return []
 			}
-			return [staleName]
+			return [staleName, freshName]
+		})
+		mockStat.mockImplementation(async (pathArg: string) => {
+			if (pathArg.endsWith(staleName)) {
+				// Older than the stale threshold: abandoned by a previous host.
+				return { mtimeMs: Date.now() - 60 * 60 * 1000 }
+			}
+			if (pathArg.endsWith(freshName)) {
+				return { mtimeMs: Date.now() }
+			}
+			throw enoent()
 		})
 		mockUnlink.mockResolvedValue(undefined)
 
 		await skillsManager["sweepStaleSkillTempFiles"]()
 
 		expect(mockUnlink).toHaveBeenCalledWith(p(globalSkillsDir, staleName))
+		// A fresh matching sidecar may belong to a live write and must survive.
+		expect(mockUnlink).not.toHaveBeenCalledWith(p(globalSkillsDir, freshName))
+	})
+
+	it("shares one directory queue across symlink aliases", async () => {
+		const order: string[] = []
+		let releaseFirst!: () => void
+		const firstGate = new Promise<void>((resolve) => {
+			releaseFirst = resolve
+		})
+		const alias = p("/alias", "skills")
+		mockRealpath.mockImplementation(async (pathArg: string) => (pathArg === alias ? globalSkillsDir : pathArg))
+
+		const first = skillsManager["withDirectoryLock"](alias, async () => {
+			order.push("first:start")
+			await firstGate
+			order.push("first:end")
+		})
+		try {
+			// The lock key is resolved through realpath asynchronously before the operation runs.
+			await vi.waitFor(() => expect(order).toEqual(["first:start"]))
+			const second = skillsManager["withDirectoryLock"](globalSkillsDir, async () => {
+				order.push("second")
+			})
+			await Promise.resolve()
+			// The alias resolves to the same real directory, so the second operation waits.
+			expect(order).toEqual(["first:start"])
+
+			releaseFirst()
+			await Promise.all([first, second])
+			expect(order).toEqual(["first:start", "first:end", "second"])
+		} finally {
+			// Never leave the shared queue holding a gate if an assertion above fails.
+			releaseFirst()
+			await first.catch(() => undefined)
+		}
 	})
 
 	it("does not start watchers when initialization runs after disposal", async () => {

From 741a280a0b2f1b822480e46f90e57c4ae04e726e Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:28:20 +0800
Subject: [PATCH 25/26] fix(skills): fail closed on pre-rename resolution and
 make queued writes disposal-aware

Review follow-ups: the pre-rename realpath has no fallback to the stale path (the error propagates, the owned sidecar is removed, and the rename is skipped), the update rename-rejection test asserts the existing SKILL.md and directory survive, and queued writes reject when the manager is disposed before the operation starts and re-check disposal after acquiring the directory lock and before staging/validation/rename. Descriptor-relative publication is tracked in #2203. SkillsManager.spec.ts 128 passed; tsc clean.
---
 src/services/skills/SkillsManager.ts          | 13 ++++-
 .../skills/__tests__/SkillsManager.spec.ts    | 56 +++++++++++++++++++
 2 files changed, 67 insertions(+), 2 deletions(-)

diff --git a/src/services/skills/SkillsManager.ts b/src/services/skills/SkillsManager.ts
index 07d11159c9..418a13e42e 100644
--- a/src/services/skills/SkillsManager.ts
+++ b/src/services/skills/SkillsManager.ts
@@ -743,7 +743,11 @@ export class SkillsManager {
 		// back to the resolved path when the directory cannot be resolved (e.g. not created yet).
 		const key = await fs.realpath(directory).catch(() => path.resolve(directory))
 		const previous = SkillsManager.directoryQueues.get(key) ?? Promise.resolve()
-		const run = previous.then(operation)
+		const run = previous.then(async () => {
+			// A manager disposed while this operation waited must not run at all.
+			if (this.isDisposed) throw new Error("SkillsManager is disposed")
+			return operation()
+		})
 		const tracked = run.then(
 			() => undefined,
 			() => undefined,
@@ -774,12 +778,15 @@ export class SkillsManager {
 			// it: when wx fails because the path already exists, that file belongs to someone else.
 			let ownsTemporaryPath = false
 			try {
+				if (this.isDisposed) throw new Error("SkillsManager is disposed")
 				// Exclusive creation: a pre-created symlink at the generated name cannot be followed.
 				await fs.writeFile(temporaryPath, content, { encoding: "utf-8", flag: "wx" })
 				ownsTemporaryPath = true
+				if (this.isDisposed) throw new Error("SkillsManager is disposed")
 				// Re-validate the final target immediately before the rename: the target (or an
 				// ancestor) can change between the caller's resolution and this publish.
 				await validateTarget?.(filePath)
+				if (this.isDisposed) throw new Error("SkillsManager is disposed")
 				await fs.rename(temporaryPath, filePath)
 			} catch (error) {
 				// Best effort: a partial temp file must not be left behind, but an EEXIST failure
@@ -1235,7 +1242,9 @@ Add your skill instructions here.
 		const targetPath = await fs.realpath(skill.path)
 		await this.assertTargetWithinSkillsRoots(targetPath, source)
 		await this.writeSkillFileAtomically(targetPath, newContent, async (target) => {
-			const freshTarget = await fs.realpath(target).catch(() => target)
+			// Fail closed: a resolution failure must propagate so the staged temp write is removed
+			// and the rename is skipped, rather than publishing through a stale path.
+			const freshTarget = await fs.realpath(target)
 			await this.assertTargetWithinSkillsRoots(freshTarget, source)
 		})
 
diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index c86a4a080b..ca2f33f4f0 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -2632,9 +2632,53 @@ Body here.`
 			// the failed rename never committed.
 			expect(mockWriteFile).toHaveBeenCalledTimes(1)
 			expect(mockRename).toHaveBeenCalledWith(temporaryPath, skillMd)
+			// The existing SKILL.md and its directory remain untouched.
+			expect(mockReadFile).toHaveBeenCalledWith(skillMd, "utf-8")
+			expect(mockWriteFile).not.toHaveBeenCalledWith(skillMd, expect.anything(), expect.anything())
+			expect(mockRmdir).not.toHaveBeenCalled()
+			expect(mockRm).not.toHaveBeenCalled()
 			expect(skillsManager["activeTempFiles"].size).toBe(0)
 		})
 
+		it("fails closed when the pre-rename target resolution fails", async () => {
+			const skillDir = p(globalSkillsDir, "resolution-fails")
+			const skillMd = p(skillDir, "SKILL.md")
+			mockDirectoryExists.mockImplementation(async (dir: string) => dir === globalSkillsDir)
+			mockReaddir.mockImplementation(async (dir: string) => (dir === globalSkillsDir ? ["resolution-fails"] : []))
+			mockStat.mockImplementation(async (pathArg: string) => {
+				if (pathArg === skillDir) {
+					return { isDirectory: () => true }
+				}
+				throw enoent()
+			})
+			mockFileExists.mockImplementation(async (file: string) => file === skillMd)
+			mockReadFile.mockResolvedValue("---\nname: resolution-fails\ndescription: A skill\n---\nInstructions")
+			// The first resolution succeeds; the immediate pre-rename resolution fails and must
+			// propagate instead of publishing through the stale path.
+			let resolutions = 0
+			mockRealpath.mockImplementation(async (pathArg: string) => {
+				if (pathArg === skillMd) {
+					resolutions += 1
+					if (resolutions === 1) {
+						return skillMd
+					}
+					throw Object.assign(new Error("EIO: resolution failed"), { code: "EIO" })
+				}
+				return pathArg
+			})
+			mockWriteFile.mockResolvedValue(undefined)
+			mockUnlink.mockResolvedValue(undefined)
+
+			await skillsManager.discoverSkills()
+
+			await expect(skillsManager.updateSkillModes("resolution-fails", "global", ["code"])).rejects.toThrow(
+				"EIO: resolution failed",
+			)
+			const temporaryPath = String(mockWriteFile.mock.calls[0][0])
+			expect(mockUnlink).toHaveBeenCalledWith(temporaryPath)
+			expect(mockRename).not.toHaveBeenCalled()
+		})
+
 		it("refuses to update a SKILL.md that resolves outside the skills roots", async () => {
 			const skillDir = p(globalSkillsDir, "escaping")
 			const skillMd = p(skillDir, "SKILL.md")
@@ -4158,6 +4202,18 @@ Instructions`)
 		expect(createWatcher).not.toHaveBeenCalled()
 	})
 
+	it("rejects a queued write once the manager is disposed", async () => {
+		await skillsManager.dispose()
+		mockWriteFile.mockResolvedValue(undefined)
+		mockUnlink.mockResolvedValue(undefined)
+
+		await expect(
+			skillsManager["writeSkillFileAtomically"](p(globalSkillsDir, "SKILL.md"), "content"),
+		).rejects.toThrow("SkillsManager is disposed")
+		expect(mockWriteFile).not.toHaveBeenCalled()
+		expect(mockRename).not.toHaveBeenCalled()
+	})
+
 	it("removes tracked temp sidecars on dispose", async () => {
 		mockUnlink.mockResolvedValue(undefined)
 		skillsManager["activeTempFiles"].add("/mock/skills/foo/.SKILL.md.123.abc.tmp")

From 38844c7d1a439c97dfe8249ea0c4f003e160c9c5 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:50:38 +0800
Subject: [PATCH 26/26] test(skills): pin the directory-queue disposal guard
 directly

Review follow-up: block one withDirectoryLock operation, queue a second, dispose the manager, then release the first; the queued operation rejects with SkillsManager is disposed and its callback never runs. The end-to-end writeSkillFileAtomically disposal test stays. SkillsManager.spec.ts 129 passed.
---
 .../skills/__tests__/SkillsManager.spec.ts    | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/src/services/skills/__tests__/SkillsManager.spec.ts b/src/services/skills/__tests__/SkillsManager.spec.ts
index ca2f33f4f0..15f5d3db47 100644
--- a/src/services/skills/__tests__/SkillsManager.spec.ts
+++ b/src/services/skills/__tests__/SkillsManager.spec.ts
@@ -4214,6 +4214,33 @@ Instructions`)
 		expect(mockRename).not.toHaveBeenCalled()
 	})
 
+	it("never runs a queued directory operation after the manager is disposed", async () => {
+		let releaseFirst!: () => void
+		const firstGate = new Promise<void>((resolve) => {
+			releaseFirst = resolve
+		})
+		let firstStarted = false
+		let secondRan = false
+
+		const first = skillsManager["withDirectoryLock"](globalSkillsDir, async () => {
+			firstStarted = true
+			await firstGate
+		})
+		await vi.waitFor(() => expect(firstStarted).toBe(true))
+
+		// The second operation is queued behind the first and must be rejected after disposal
+		// without running its callback.
+		const second = skillsManager["withDirectoryLock"](globalSkillsDir, async () => {
+			secondRan = true
+		})
+		await skillsManager.dispose()
+		releaseFirst()
+
+		await first
+		await expect(second).rejects.toThrow("SkillsManager is disposed")
+		expect(secondRan).toBe(false)
+	})
+
 	it("removes tracked temp sidecars on dispose", async () => {
 		mockUnlink.mockResolvedValue(undefined)
 		skillsManager["activeTempFiles"].add("/mock/skills/foo/.SKILL.md.123.abc.tmp")