bigpowers 2.60.0 → 2.61.1

package/bigpowers-mcp/src/lib/skill-parser.ts

@@ -0,0 +1,191 @@
+import fs from "node:fs";
+import path from "node:path";
+import yaml from "js-yaml";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import type { Root, Heading, Code, Link, Paragraph, Text } from "mdast";
+import { MAX_READ_SKILL_BYTES } from "../config.js";
+import { PathGuardError, resolveSkillPath } from "./paths.js";
+
+export interface SkillIndexEntry {
+  name: string;
+  path: string;
+  phase: string;
+}
+
+export interface ParsedSkill {
+  name: string;
+  path: string;
+  frontmatter: Record<string, unknown>;
+  headings: Array<{ depth: number; text: string }>;
+  codeBlocks: Array<{ lang: string | null; value: string }>;
+  sections: Array<{ heading: string | null; prose: string }>;
+  links: Array<{ text: string; url: string }>;
+  rawProse: string;
+  truncated?: boolean;
+}
+
+export function discoverSkills(repoRoot: string, phaseFn: (n: string) => string): SkillIndexEntry[] {
+  const skillsDir = path.join(repoRoot, "skills");
+  if (!fs.existsSync(skillsDir)) return [];
+
+  return fs
+    .readdirSync(skillsDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => {
+      const skillPath = path.join(skillsDir, d.name, "SKILL.md");
+      if (!fs.existsSync(skillPath)) return null;
+      return {
+        name: d.name,
+        path: path.relative(repoRoot, skillPath),
+        phase: phaseFn(d.name),
+      };
+    })
+    .filter((e): e is SkillIndexEntry => e !== null)
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function readSkillFile(
+  repoRoot: string,
+  skillName: string,
+  maxBytes = MAX_READ_SKILL_BYTES,
+): ParsedSkill {
+  let skillPath: string;
+  try {
+    skillPath = resolveSkillPath(repoRoot, skillName);
+  } catch (err) {
+    if (err instanceof PathGuardError) {
+      throw new Error(`Skill not found or invalid: ${skillName}`);
+    }
+    throw err;
+  }
+
+  if (!fs.existsSync(skillPath)) {
+    throw new Error(`Skill not found: ${skillName}`);
+  }
+
+  let raw = fs.readFileSync(skillPath, "utf8");
+  let truncated = false;
+  if (Buffer.byteLength(raw, "utf8") > maxBytes) {
+    raw = raw.slice(0, maxBytes);
+    truncated = true;
+  }
+
+  return { ...parseSkillMarkdown(raw, skillName, skillPath, repoRoot), truncated };
+}
+
+export function parseSkillMarkdown(
+  raw: string,
+  skillName: string,
+  skillPath: string,
+  repoRoot: string,
+): ParsedSkill {
+  const { yamlBlock, body } = extractFrontmatterBlock(raw);
+  const frontmatter = parseFrontmatterYaml(yamlBlock);
+
+  const tree = unified().use(remarkParse).parse(body) as Root;
+
+  const headings: ParsedSkill["headings"] = [];
+  const codeBlocks: ParsedSkill["codeBlocks"] = [];
+  const links: ParsedSkill["links"] = [];
+  const proseParts: string[] = [];
+
+  let currentHeading: string | null = null;
+  const sections: ParsedSkill["sections"] = [];
+  let currentSectionProse: string[] = [];
+
+  function flushSection() {
+    if (currentSectionProse.length > 0 || currentHeading !== null) {
+      sections.push({
+        heading: currentHeading,
+        prose: currentSectionProse.join("\n").trim(),
+      });
+      currentSectionProse = [];
+    }
+  }
+
+  function walk(node: Root["children"][number], inParagraph = false): void {
+    if (node.type === "heading") {
+      flushSection();
+      const h = node as Heading;
+      const text = extractText(h);
+      headings.push({ depth: h.depth, text });
+      currentHeading = text;
+      return;
+    }
+    if (node.type === "code") {
+      const c = node as Code;
+      codeBlocks.push({ lang: c.lang ?? null, value: c.value });
+      return;
+    }
+    if (node.type === "link") {
+      const l = node as Link;
+      links.push({ text: extractText(l), url: l.url });
+    }
+    if (node.type === "paragraph") {
+      const text = extractText(node as Paragraph);
+      if (text) {
+        proseParts.push(text);
+        currentSectionProse.push(text);
+      }
+    }
+    if ("children" in node && Array.isArray(node.children)) {
+      for (const child of node.children) {
+        walk(child as Root["children"][number], node.type === "paragraph");
+      }
+    }
+  }
+
+  for (const child of tree.children) {
+    walk(child);
+  }
+  flushSection();
+
+  return {
+    name: skillName,
+    path: path.relative(repoRoot, skillPath),
+    frontmatter,
+    headings,
+    codeBlocks,
+    sections,
+    links,
+    rawProse: proseParts.join("\n"),
+  };
+}
+
+function extractFrontmatterBlock(raw: string): { yamlBlock: string; body: string } {
+  const start = raw.indexOf("---");
+  if (start === -1) return { yamlBlock: "", body: raw };
+  const lineEnd = raw.indexOf("\n", start);
+  if (lineEnd === -1) return { yamlBlock: "", body: raw };
+  const close = raw.indexOf("\n---", lineEnd);
+  if (close === -1) return { yamlBlock: "", body: raw };
+  const yamlBlock = raw.slice(lineEnd + 1, close);
+  const body = raw.slice(close + 4).replace(/^\r?\n/, "");
+  return { yamlBlock, body };
+}
+
+function parseFrontmatterYaml(yamlBlock: string): Record<string, unknown> {
+  if (!yamlBlock.trim()) return {};
+  try {
+    return (yaml.load(yamlBlock) as Record<string, unknown>) ?? {};
+  } catch {
+    const result: Record<string, unknown> = {};
+    for (const line of yamlBlock.split("\n")) {
+      const m = /^([a-zA-Z0-9_-]+):\s*(.+)$/.exec(line.trim());
+      if (m) result[m[1]] = m[2].replace(/^["']|["']$/g, "");
+    }
+    return result;
+  }
+}
+
+function extractText(node: { children?: Array<{ type: string; value?: string; children?: unknown[] }> }): string {
+  if (!node.children) return "";
+  return node.children
+    .map((c) => {
+      if (c.type === "text") return (c as Text).value;
+      if ("children" in c && c.children) return extractText(c as typeof node);
+      return "";
+    })
+    .join("");
+}

package/bigpowers-mcp/src/lib/validate-skill.ts

@@ -0,0 +1,91 @@
+// story: e32s05
+import fs from "node:fs";
+import path from "node:path";
+import type { ParsedSkill } from "./skill-parser.js";
+import { resolveSkillPath } from "./paths.js";
+
+export interface ValidationCheck {
+  id: string;
+  pass: boolean;
+  message: string;
+  remediation?: string;
+}
+
+export interface ValidationReport {
+  skill: string;
+  pass: boolean;
+  checks: ValidationCheck[];
+}
+
+const VERB_NOUN = /^[a-z]+-[a-z]+(-[a-z]+)*$/;
+const CRITICAL_PATH_PHASES = new Set(["Build", "Verify", "Release"]);
+
+export function validateSkillConventions(
+  parsed: ParsedSkill,
+  repoRoot: string,
+): ValidationReport {
+  const checks: ValidationCheck[] = [];
+  const fm = parsed.frontmatter;
+  const name = parsed.name;
+
+  checks.push({
+    id: "verb-noun-naming",
+    pass: VERB_NOUN.test(name),
+    message: VERB_NOUN.test(name)
+      ? "Skill name is verb-noun kebab-case"
+      : `Skill name '${name}' is not verb-noun kebab-case`,
+    remediation: "Rename directory to two-word kebab-case (e.g. develop-tdd)",
+  });
+
+  for (const field of ["name", "description"]) {
+    checks.push({
+      id: `frontmatter-${field}`,
+      pass: Boolean(fm[field]),
+      message: fm[field] ? `Has frontmatter.${field}` : `Missing frontmatter.${field}`,
+      remediation: `Add ${field} to YAML frontmatter block`,
+    });
+  }
+
+  const hasVerify =
+    parsed.rawProse.includes("→ verify:") ||
+    parsed.rawProse.includes("verify:") ||
+    parsed.codeBlocks.some((b) => b.value.includes("verify:"));
+  checks.push({
+    id: "verify-command",
+    pass: hasVerify,
+    message: hasVerify ? "Has verify command reference" : "Missing verify command",
+    remediation: "Add a → verify: block with a runnable check",
+  });
+
+  const lineCount = fs.readFileSync(resolveSkillPath(repoRoot, name), "utf8").split("\n").length;
+  const isCritical = CRITICAL_PATH_PHASES.has(
+    String(fm.effort ?? "") === "heavy" ? "Build" : "Build",
+  );
+  const cap = isCritical ? 150 : 120;
+  checks.push({
+    id: "size-cap",
+    pass: lineCount <= cap,
+    message:
+      lineCount <= cap
+        ? `Within size cap (${lineCount}/${cap} lines)`
+        : `Exceeds size cap (${lineCount}/${cap} lines)`,
+    remediation: "Split content into REFERENCE.md or reduce prose",
+  });
+
+  for (const link of parsed.links) {
+    if (link.url.startsWith("skills/")) {
+      const target = link.url.replace(/^skills\//, "").replace(/\/SKILL\.md$/, "");
+      const targetPath = path.join(repoRoot, "skills", target, "SKILL.md");
+      const ok = fs.existsSync(targetPath);
+      checks.push({
+        id: `link-${target}`,
+        pass: ok,
+        message: ok ? `Link to ${link.url} resolves` : `Broken link: ${link.url}`,
+        remediation: ok ? undefined : `Create skills/${target}/SKILL.md or fix link`,
+      });
+    }
+  }
+
+  const pass = checks.every((c) => c.pass);
+  return { skill: name, pass, checks };
+}

package/bigpowers-mcp/src/tools/index.ts

@@ -0,0 +1,227 @@
+// story: e32s02
+// story: e32s03
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { getRepoRoot, getGraphPath } from "../config.js";
+import { discoverSkills, readSkillFile } from "../lib/skill-parser.js";
+import { phaseForSkill } from "../lib/phase-map.js";
+import { buildGraphFromSkills } from "../lib/graph/builder.js";
+import { loadGraph, saveGraph, searchNodes, openNodes, getForwardDeps, getReverseDeps, getHandoffChain, getConventions } from "../lib/graph/store.js";
+import type { SkillGraph } from "../lib/graph/types.js";
+import { getGitContext, isGitRepo } from "../lib/git-context.js";
+import { validateSkillConventions } from "../lib/validate-skill.js";
+import { z } from "zod";
+
+export interface ServerContext {
+  repoRoot: string;
+  graphPath: string;
+  graph: SkillGraph;
+}
+
+export function createContext(): ServerContext {
+  const repoRoot = getRepoRoot();
+  const graphPath = getGraphPath(repoRoot);
+  return { repoRoot, graphPath, graph: loadGraph(graphPath) };
+}
+
+function jsonResult(data: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+  };
+}
+
+function toolError(message: string) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify({ error: message }) }],
+    isError: true,
+  };
+}
+
+export function registerTools(server: McpServer, ctx: ServerContext): void {
+  server.registerTool(
+    "index_skills",
+    {
+      description: "Discover all skills/*/SKILL.md files with name, path, and lifecycle phase",
+      inputSchema: z.object({}).optional(),
+    },
+    async () => {
+      const skills = discoverSkills(ctx.repoRoot, phaseForSkill);
+      return jsonResult({ count: skills.length, skills });
+    },
+  );
+
+  server.registerTool(
+    "read_skill",
+    {
+      description: "Parse a SKILL.md via remark — returns frontmatter, headings, code blocks, sections, links",
+      inputSchema: z.object({
+        name: z.string().describe("Skill directory name (verb-noun, kebab-case)"),
+      }),
+    },
+    async ({ name }) => {
+      try {
+        const parsed = readSkillFile(ctx.repoRoot, name);
+        return jsonResult(parsed);
+      } catch (err) {
+        return toolError(err instanceof Error ? err.message : String(err));
+      }
+    },
+  );
+
+  server.registerTool(
+    "build_skill_graph",
+    {
+      description: "Build entity-relation graph from parsed SKILL.md data and persist to graph.jsonl",
+      inputSchema: z.object({
+        force: z.boolean().optional().describe("Rebuild even if graph exists"),
+      }),
+    },
+    async ({ force }) => {
+      const index = discoverSkills(ctx.repoRoot, phaseForSkill);
+      const parsed = index.map((s) => readSkillFile(ctx.repoRoot, s.name));
+      ctx.graph = buildGraphFromSkills(parsed);
+      saveGraph(ctx.graphPath, ctx.graph);
+      return jsonResult({
+        entities: ctx.graph.entities.size,
+        relations: ctx.graph.relations.length,
+        graphPath: ctx.graphPath,
+        force: force ?? false,
+      });
+    },
+  );
+
+  server.registerTool(
+    "read_graph",
+    {
+      description: "Return the full skill knowledge graph (entities + relations)",
+      inputSchema: z.object({}).optional(),
+    },
+    async () => {
+      if (ctx.graph.entities.size === 0) {
+        ctx.graph = loadGraph(ctx.graphPath);
+      }
+      return jsonResult({
+        entities: [...ctx.graph.entities.values()],
+        relations: ctx.graph.relations,
+      });
+    },
+  );
+
+  server.registerTool(
+    "search_nodes",
+    {
+      description: "Search graph entities by name, type, or observation text",
+      inputSchema: z.object({ query: z.string() }),
+    },
+    async ({ query }) => {
+      if (ctx.graph.entities.size === 0) ctx.graph = loadGraph(ctx.graphPath);
+      return jsonResult({ results: searchNodes(ctx.graph, query) });
+    },
+  );
+
+  server.registerTool(
+    "open_nodes",
+    {
+      description: "Open specific graph entities by name",
+      inputSchema: z.object({ names: z.array(z.string()) }),
+    },
+    async ({ names }) => {
+      if (ctx.graph.entities.size === 0) ctx.graph = loadGraph(ctx.graphPath);
+      return jsonResult({ entities: openNodes(ctx.graph, names) });
+    },
+  );
+
+  server.registerTool(
+    "search_skills",
+    {
+      description: "Search skills by name, description, model, or effort (case-insensitive substring)",
+      inputSchema: z.object({
+        query: z.string(),
+        exact: z.boolean().optional(),
+      }),
+    },
+    async ({ query, exact }) => {
+      const index = discoverSkills(ctx.repoRoot, phaseForSkill);
+      const q = query.toLowerCase();
+      const results = index
+        .map((entry) => {
+          let parsed;
+          try {
+            parsed = readSkillFile(ctx.repoRoot, entry.name);
+          } catch {
+            return null;
+          }
+          const fm = parsed.frontmatter;
+          const hay = [
+            entry.name,
+            entry.phase,
+            String(fm.description ?? ""),
+            String(fm.model ?? ""),
+            String(fm.effort ?? ""),
+          ]
+            .join(" ")
+            .toLowerCase();
+          const match = exact ? entry.name.toLowerCase() === q : hay.includes(q);
+          const score = exact ? (match ? 100 : 0) : (hay.match(new RegExp(q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) ?? []).length;
+          return match ? { ...entry, frontmatter: fm, score } : null;
+        })
+        .filter((r): r is NonNullable<typeof r> => r !== null)
+        .sort((a, b) => b.score - a.score);
+      return jsonResult({ count: results.length, results });
+    },
+  );
+
+  server.registerTool(
+    "get_dependencies",
+    {
+      description: "Forward/reverse deps, handoff chain, and conventions for a skill",
+      inputSchema: z.object({ name: z.string() }),
+    },
+    async ({ name }) => {
+      if (ctx.graph.entities.size === 0) ctx.graph = loadGraph(ctx.graphPath);
+      return jsonResult({
+        skill: name,
+        depends_on: getForwardDeps(ctx.graph, name),
+        depended_by: getReverseDeps(ctx.graph, name),
+        handoff_chain: getHandoffChain(ctx.graph, name),
+        conventions: getConventions(ctx.graph, name),
+      });
+    },
+  );
+
+  server.registerTool(
+    "get_git_context",
+    {
+      description: "Git change awareness scoped to skills/ and specs/ — status, log, or diff",
+      inputSchema: z.object({
+        action: z.enum(["status", "log", "diff"]).default("status"),
+      }),
+    },
+    async ({ action }) => {
+      if (!isGitRepo(ctx.repoRoot)) {
+        return toolError("Not a git repository");
+      }
+      try {
+        return jsonResult(getGitContext(ctx.repoRoot, action));
+      } catch (err) {
+        return toolError(err instanceof Error ? err.message : String(err));
+      }
+    },
+  );
+
+  server.registerTool(
+    "validate_skill",
+    {
+      description: "Check a SKILL.md against bigpowers conventions",
+      inputSchema: z.object({ name: z.string() }),
+    },
+    async ({ name }) => {
+      try {
+        const parsed = readSkillFile(ctx.repoRoot, name);
+        const report = validateSkillConventions(parsed, ctx.repoRoot);
+        return jsonResult(report);
+      } catch (err) {
+        return toolError(err instanceof Error ? err.message : String(err));
+      }
+    },
+  );
+}

package/bigpowers-mcp/test/catalog.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  discoverSkills,
+  readSkillFile,
+  parseSkillMarkdown,
+} from "../src/lib/skill-parser.js";
+import { phaseForSkill } from "../src/lib/phase-map.js";
+import { resolveSkillPath, PathGuardError } from "../src/lib/paths.js";
+import { buildGraphFromSkills } from "../src/lib/graph/builder.js";
+import { loadGraph, saveGraph } from "../src/lib/graph/store.js";
+import { validateSkillConventions } from "../src/lib/validate-skill.js";
+import { getGitContext, isGitRepo } from "../src/lib/git-context.js";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const fixtureRoot = path.join(repoRoot, "bigpowers-mcp/test/fixtures");
+
+// scenario: SC-e32s01-P0-01
+describe("index_skills / discoverSkills", () => {
+  it("discovers all skills in live catalog", () => {
+    const skills = discoverSkills(repoRoot, phaseForSkill);
+    expect(skills.length).toBeGreaterThanOrEqual(70);
+    for (const s of skills) {
+      expect(s.name).toMatch(/^[a-z]+(-[a-z]+)*$/);
+      expect(s.path).toMatch(/^skills\/.+\/SKILL\.md$/);
+      expect(s.phase).toBeTruthy();
+    }
+  });
+
+  it("discovers fixture skills", () => {
+    const skills = discoverSkills(fixtureRoot, phaseForSkill);
+    expect(skills.map((s) => s.name).sort()).toEqual([
+      "broken-link",
+      "missing-verify",
+      "valid-skill",
+    ]);
+  });
+});
+
+// scenario: SC-e32s01-P0-02
+describe("read_skill / parseSkillMarkdown", () => {
+  it("parses all catalog SKILL.md files with zero failures", () => {
+    const skills = discoverSkills(repoRoot, phaseForSkill);
+    const errors: string[] = [];
+    for (const s of skills) {
+      try {
+        const parsed = readSkillFile(repoRoot, s.name);
+        expect(parsed.frontmatter.name).toBeTruthy();
+        expect(parsed.headings.length).toBeGreaterThan(0);
+      } catch (err) {
+        errors.push(`${s.name}: ${err}`);
+      }
+    }
+    expect(errors, errors.join("\n")).toEqual([]);
+  });
+
+  it("extracts frontmatter and headings from fixture", () => {
+    const parsed = readSkillFile(fixtureRoot, "valid-skill");
+    expect(parsed.frontmatter.name).toBe("valid-skill");
+    expect(parsed.frontmatter.effort).toBe("light");
+    expect(parsed.headings[0].text).toBe("Valid Skill");
+    expect(parsed.rawProse.includes("other-skill")).toBe(true);
+  });
+
+  it("rejects path traversal on skill name", () => {
+    expect(() => readSkillFile(repoRoot, "../etc/passwd")).toThrow(/not found|invalid/i);
+    expect(() => resolveSkillPath(repoRoot, "..")).toThrow(PathGuardError);
+  });
+});
+
+// scenario: SC-e32s02-P0-01
+describe("build_skill_graph", () => {
+  it("emits entities and relations from prose patterns", () => {
+    const parsed = readSkillFile(fixtureRoot, "valid-skill");
+    const graph = buildGraphFromSkills([parsed]);
+    expect(graph.entities.has("valid-skill")).toBe(true);
+    expect(graph.relations.some((r) => r.relationType === "references")).toBe(true);
+    expect(graph.relations.some((r) => r.relationType === "depends_on")).toBe(true);
+  });
+});
+
+// scenario: SC-e32s02-P0-02
+describe("graph store", () => {
+  const tmpGraph = path.join(fixtureRoot, "graph/test-graph.jsonl");
+
+  beforeAll(() => {
+    const parsed = readSkillFile(fixtureRoot, "valid-skill");
+    const graph = buildGraphFromSkills([parsed]);
+    saveGraph(tmpGraph, graph);
+  });
+
+  it("persists and reloads graph.jsonl", () => {
+    const loaded = loadGraph(tmpGraph);
+    expect(loaded.entities.size).toBe(1);
+    expect(loaded.relations.length).toBeGreaterThan(0);
+  });
+});
+
+// scenario: SC-e32s03-P1-01
+describe("search_skills", () => {
+  it("ranks skills by substring query", () => {
+    const index = discoverSkills(fixtureRoot, phaseForSkill);
+    expect(index.length).toBeGreaterThan(0);
+  });
+});
+
+// scenario: SC-e32s03-P1-02
+describe("get_dependencies", () => {
+  it("returns graph relations for a skill", () => {
+    const parsed = readSkillFile(fixtureRoot, "valid-skill");
+    const graph = buildGraphFromSkills([parsed]);
+    expect(graph.relations.length).toBeGreaterThan(0);
+  });
+});
+
+// scenario: SC-e32s04-P2-01
+describe("get_git_context", () => {
+  it("scopes git status to skills and specs dirs", () => {
+    if (!isGitRepo(repoRoot)) return;
+    const result = getGitContext(repoRoot, "status");
+    expect(result.action).toBe("status");
+  });
+});
+
+// scenario: SC-e32s05-P1-01
+describe("validate_skill", () => {
+  it("flags missing verify on fixture", () => {
+    const parsed = readSkillFile(fixtureRoot, "missing-verify");
+    const report = validateSkillConventions(parsed, fixtureRoot);
+    expect(report.checks.find((c) => c.id === "verify-command")?.pass).toBe(false);
+  });
+
+  it("passes valid fixture checks except broken links", () => {
+    const parsed = readSkillFile(fixtureRoot, "valid-skill");
+    const report = validateSkillConventions(parsed, fixtureRoot);
+    expect(report.checks.find((c) => c.id === "verify-command")?.pass).toBe(true);
+  });
+});
+
+describe("parseSkillMarkdown unit", () => {
+  it("parses inline markdown without file IO", () => {
+    const md = `---\nname: x\n---\n\n# Title\n\nHello world.\n\n\`\`\`bash\necho hi\n\`\`\``;
+    const result = parseSkillMarkdown(md, "x", "/tmp/x/SKILL.md", "/tmp");
+    expect(result.frontmatter.name).toBe("x");
+    expect(result.codeBlocks[0].lang).toBe("bash");
+  });
+});

package/bigpowers-mcp/test/fixtures/graph/test-graph.jsonl

@@ -0,0 +1,5 @@
+{"type":"entity","name":"valid-skill","entityType":"Skill","observations":["model: haiku","effort: light","description: A valid fixture skill for parser tests."]}
+{"type":"relation","from":"plan-work","to":"survey-context.","relationType":"depends_on"}
+{"type":"relation","from":"plan-work","to":"survey-context.","relationType":"depends_on"}
+{"type":"relation","from":"valid-skill","to":"other-skill","relationType":"references"}
+{"type":"relation","from":"valid-skill","to":"other-skill","relationType":"references"}

package/bigpowers-mcp/test/fixtures/skills/broken-link/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: broken-link
+model: haiku
+description: Fixture with broken skill link.
+---
+
+# Broken Link
+
+See skills/nonexistent-skill/SKILL.md
+
+→ verify: echo OK

package/bigpowers-mcp/test/fixtures/skills/missing-verify/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: missing-verify
+model: haiku
+description: Fixture missing verify command.
+---
+
+# Missing Verify
+
+No verify block here.

package/bigpowers-mcp/test/fixtures/skills/valid-skill/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: valid-skill
+model: haiku
+effort: light
+description: A valid fixture skill for parser tests.
+---
+
+# Valid Skill
+
+→ verify: echo OK
+
+See skills/other-skill/SKILL.md for handoff reference.
+
+Run plan-work after survey-context.