fix(server): recover skill frontmatter Claude Code itself accepts

apps/server/src/provider/Drivers/ClaudeSkills.test.ts

@@ -181,6 +181,127 @@ it.layer(NodeServices.layer)("discoverClaudeSkills", (it) => {
     }),
   );
 
+  it.effect(
+    "recovers a description containing an unquoted colon that Claude Code itself accepts",
+    () =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-skills-" });
+        const configDir = path.join(tempDir, "claude-home");
+
+        yield* writeSkill(
+          path.join(configDir, "skills"),
+          "kane-cli",
+          [
+            "---",
+            "name: kane-cli",
+            "description: Browser automation + AI test authoring via kane-cli: run browser objectives, ...",
+            "---",
+          ].join("\n"),
+        );
+
+        const skills = yield* discoverClaudeSkills({ homePath: configDir }, undefined);
+
+        assert.deepEqual(skills, [
+          {
+            name: "kane-cli",
+            path: path.join(configDir, "skills", "kane-cli", "SKILL.md"),
+            enabled: true,
+            scope: "user",
+            description:
+              "Browser automation + AI test authoring via kane-cli: run browser objectives, ...",
+          },
+        ]);
+      }),
+  );
+
+  it.effect("strips a trailing comment from a recovered value instead of keeping it verbatim", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-skills-" });
+      const configDir = path.join(tempDir, "claude-home");
+
+      yield* writeSkill(
+        path.join(configDir, "skills"),
+        "commented",
+        [
+          "---",
+          "name: demo # display label",
+          "allowed-tools: [Read, Write]",
+          "disable-model-invocation: yes",
+          "user-invocable: no",
+          // The colon-containing description is what forces the lenient
+          // fallback to run at all — a comment alone wouldn't fail strict
+          // parsing, so this is needed to actually exercise the fallback's
+          // value parsing rather than the strict-YAML path.
+          "description: Browser automation + AI test authoring via kane-cli: run browser objectives, ...",
+          "---",
+        ].join("\n"),
+      );
+
+      const skills = yield* discoverClaudeSkills({ homePath: configDir }, undefined);
+
+      assert.deepEqual(skills, [
+        {
+          name: "commented",
+          path: path.join(configDir, "skills", "commented", "SKILL.md"),
+          enabled: true,
+          scope: "user",
+          description:
+            "Browser automation + AI test authoring via kane-cli: run browser objectives, ...",
+          userInvocationOnly: true,
+          userInvocable: false,
+        },
+      ]);
+    }),
+  );
+
+  it.effect("skips the whole skill when a broken field survives alongside a recoverable one", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-skills-" });
+      const configDir = path.join(tempDir, "claude-home");
+
+      yield* writeSkill(
+        path.join(configDir, "skills"),
+        "broken-name",
+        ["---", "name: [unclosed", "description: Broken skill.", "---"].join("\n"),
+      );
+
+      const skills = yield* discoverClaudeSkills({ homePath: configDir }, undefined);
+
+      // A broken `name` must not surface the skill under its directory name
+      // with only the description recovered — Claude Code wouldn't load
+      // this file at all.
+      assert.deepEqual(skills, []);
+    }),
+  );
+
+  it.effect("skips the whole skill when an unread field has broken YAML syntax", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-skills-" });
+      const configDir = path.join(tempDir, "claude-home");
+
+      yield* writeSkill(
+        path.join(configDir, "skills"),
+        "broken-other-field",
+        ["---", "name: demo", "allowed-tools: [unclosed", "---"].join("\n"),
+      );
+
+      const skills = yield* discoverClaudeSkills({ homePath: configDir }, undefined);
+
+      // The broken field isn't one this scanner reads, but it still means
+      // the document has a real YAML syntax error Claude Code would reject
+      // outright — recovering `name` in isolation would be wrong.
+      assert.deepEqual(skills, []);
+    }),
+  );
+
   it.effect("honors CLAUDE_CONFIG_DIR from the environment when homePath is unset", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;

apps/server/src/provider/Drivers/ClaudeSkills.ts

@@ -69,18 +69,38 @@ function parseFrontmatterBoolean(value: unknown): boolean | undefined {
   }
 }
 
-function parseSkillFrontmatter(contents: string): SkillFrontmatter {
-  const match = FRONTMATTER_PATTERN.exec(contents);
-  if (!match) {
-    return { kind: "missing" };
-  }
+/**
+ * Repairs the one YAML dialect difference observed in Claude Code: it accepts
+ * an unquoted scalar containing a `: ` sequence where the YAML parser rejects
+ * the whole document as an ambiguous nested mapping. Re-run the real parser
+ * after quoting only those top-level scalar values so all other fields keep
+ * normal YAML validation and parsed metadata.
+ */
+function parseSkillFrontmatterLeniently(yamlSource: string): SkillFrontmatter {
+  const repairedSource = yamlSource
+    .split(/\r?\n/)
+    .map((line) => {
+      const match = /^(\s*[A-Za-z0-9_-]+:\s+)(.*)$/.exec(line);
+      const value = match?.[2];
+      if (!match || value === undefined || !value.includes(": ")) {
+        return line;
+      }
+      if (value.startsWith('"') || value.startsWith("'")) {
+        return line;
+      }
+      const escaped = value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+      return `${match[1]}"${escaped}"`;
+    })
+    .join("\n");
 
-  let parsed: unknown;
   try {
-    parsed = parseYamlDocument(match[1] ?? "");
+    return parseParsedSkillFrontmatter(parseYamlDocument(repairedSource));
   } catch {
     return { kind: "malformed" };
   }
+}
+
+function parseParsedSkillFrontmatter(parsed: unknown): SkillFrontmatter {
   if (typeof parsed !== "object" || parsed === null) {
     return { kind: "malformed" };
   }
@@ -99,6 +119,22 @@ function parseSkillFrontmatter(contents: string): SkillFrontmatter {
   };
 }
 
+function parseSkillFrontmatter(contents: string): SkillFrontmatter {
+  const match = FRONTMATTER_PATTERN.exec(contents);
+  if (!match) {
+    return { kind: "missing" };
+  }
+  const yamlSource = match[1] ?? "";
+
+  let parsed: unknown;
+  try {
+    parsed = parseYamlDocument(yamlSource);
+  } catch {
+    return parseSkillFrontmatterLeniently(yamlSource);
+  }
+  return parseParsedSkillFrontmatter(parsed);
+}
+
 /**
  * Where an administrator installs the policy file whose settings outrank every
  * user and project one. Absent on almost every machine, which is why a missing