mrvn-cli 0.1.4 → 0.2.1

package/dist/index.js

@@ -14902,7 +14902,7 @@ import * as readline from "readline";
 import chalk from "chalk";
 import ora from "ora";
 import {
-  query as query3
+  query as query2
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/storage/session-store.ts
@@ -16863,7 +16863,9 @@ function getPluginPromptFragment(plugin, personaId) {
 // src/skills/registry.ts
 import * as fs7 from "fs";
 import * as path7 from "path";
+import { fileURLToPath } from "url";
 import * as YAML5 from "yaml";
+import matter2 from "gray-matter";
 
 // src/skills/builtin/governance-review.ts
 var governanceReviewSkill = {
@@ -16871,6 +16873,7 @@ var governanceReviewSkill = {
   name: "Governance Review",
   description: "Review open governance items and generate summaries",
   version: "1.0.0",
+  format: "builtin-ts",
   personas: ["delivery-manager", "product-owner"],
   promptFragments: {
     "delivery-manager": `You have the **Governance Review** skill. You can proactively review all open governance items (decisions, actions, questions) and produce structured summaries with recommendations. Use the \`governance-review__summarize\` tool to run a comprehensive review.`,
@@ -16905,11 +16908,98 @@ Be thorough but concise. Focus on actionable insights.`,
 var BUILTIN_SKILLS = {
   "governance-review": governanceReviewSkill
 };
+var GOVERNANCE_TOOL_NAMES = [
+  "mcp__marvin-governance__list_decisions",
+  "mcp__marvin-governance__get_decision",
+  "mcp__marvin-governance__create_decision",
+  "mcp__marvin-governance__update_decision",
+  "mcp__marvin-governance__list_actions",
+  "mcp__marvin-governance__get_action",
+  "mcp__marvin-governance__create_action",
+  "mcp__marvin-governance__update_action",
+  "mcp__marvin-governance__list_questions",
+  "mcp__marvin-governance__get_question",
+  "mcp__marvin-governance__create_question",
+  "mcp__marvin-governance__update_question",
+  "mcp__marvin-governance__search_documents",
+  "mcp__marvin-governance__read_document",
+  "mcp__marvin-governance__project_summary"
+];
+function getBuiltinSkillsDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  return path7.join(path7.dirname(thisFile), "builtin");
+}
+function loadSkillFromDirectory(dirPath) {
+  const skillMdPath = path7.join(dirPath, "SKILL.md");
+  if (!fs7.existsSync(skillMdPath)) return void 0;
+  try {
+    const raw = fs7.readFileSync(skillMdPath, "utf-8");
+    const { data, content } = matter2(raw);
+    if (!data.name || !data.description) return void 0;
+    const metadata = data.metadata ?? {};
+    const version2 = metadata.version ?? "1.0.0";
+    const personas = metadata.personas;
+    const promptFragments = {};
+    const wildcardPrompt = content.trim();
+    if (wildcardPrompt) {
+      promptFragments["*"] = wildcardPrompt;
+    }
+    const personasDir = path7.join(dirPath, "personas");
+    if (fs7.existsSync(personasDir)) {
+      try {
+        for (const file2 of fs7.readdirSync(personasDir)) {
+          if (!file2.endsWith(".md")) continue;
+          const personaId = file2.replace(/\.md$/, "");
+          const personaPrompt = fs7.readFileSync(path7.join(personasDir, file2), "utf-8").trim();
+          if (personaPrompt) {
+            promptFragments[personaId] = personaPrompt;
+          }
+        }
+      } catch {
+      }
+    }
+    let actions;
+    const actionsPath = path7.join(dirPath, "actions.yaml");
+    if (fs7.existsSync(actionsPath)) {
+      try {
+        const actionsRaw = fs7.readFileSync(actionsPath, "utf-8");
+        actions = YAML5.parse(actionsRaw);
+      } catch {
+      }
+    }
+    return {
+      id: data.name,
+      name: data.name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+      description: data.description,
+      version: version2,
+      format: "skill-md",
+      dirPath,
+      personas,
+      promptFragments: Object.keys(promptFragments).length > 0 ? promptFragments : void 0,
+      actions
+    };
+  } catch {
+    return void 0;
+  }
+}
 function loadAllSkills(marvinDir) {
   const skills = /* @__PURE__ */ new Map();
   for (const [id, skill] of Object.entries(BUILTIN_SKILLS)) {
     skills.set(id, skill);
   }
+  try {
+    const builtinDir = getBuiltinSkillsDir();
+    if (fs7.existsSync(builtinDir)) {
+      for (const entry of fs7.readdirSync(builtinDir)) {
+        const entryPath = path7.join(builtinDir, entry);
+        if (!fs7.statSync(entryPath).isDirectory()) continue;
+        if (skills.has(entry)) continue;
+        const skill = loadSkillFromDirectory(entryPath);
+        if (skill) skills.set(skill.id, skill);
+      }
+    }
+  } catch {
+  }
   if (marvinDir) {
     const skillsDir = path7.join(marvinDir, "skills");
     if (fs7.existsSync(skillsDir)) {
@@ -16919,10 +17009,20 @@ function loadAllSkills(marvinDir) {
       } catch {
         entries = [];
       }
-      for (const file2 of entries) {
-        if (!file2.endsWith(".yaml") && !file2.endsWith(".yml")) continue;
+      for (const entry of entries) {
+        const entryPath = path7.join(skillsDir, entry);
         try {
-          const raw = fs7.readFileSync(path7.join(skillsDir, file2), "utf-8");
+          if (fs7.statSync(entryPath).isDirectory()) {
+            const skill = loadSkillFromDirectory(entryPath);
+            if (skill) skills.set(skill.id, skill);
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        if (!entry.endsWith(".yaml") && !entry.endsWith(".yml")) continue;
+        try {
+          const raw = fs7.readFileSync(entryPath, "utf-8");
           const parsed = YAML5.parse(raw);
           if (!parsed?.id || !parsed?.name || !parsed?.version) continue;
           const skill = {
@@ -16930,6 +17030,7 @@ function loadAllSkills(marvinDir) {
             name: parsed.name,
             description: parsed.description ?? "",
             version: parsed.version,
+            format: "yaml",
             personas: parsed.personas,
             promptFragments: parsed.promptFragments,
             actions: parsed.actions
@@ -16992,91 +17093,73 @@ function listAllSkillInfo(allSkills, skillsConfig, personaIds) {
       name: skill.name,
       version: skill.version,
       description: skill.description,
+      format: skill.format,
       assignedPersonas
     });
   }
   return result;
 }
-
-// src/skills/action-tools.ts
-import { tool as tool16 } from "@anthropic-ai/claude-agent-sdk";
-
-// src/skills/action-runner.ts
-import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
-var GOVERNANCE_TOOL_NAMES = [
-  "mcp__marvin-governance__list_decisions",
-  "mcp__marvin-governance__get_decision",
-  "mcp__marvin-governance__create_decision",
-  "mcp__marvin-governance__update_decision",
-  "mcp__marvin-governance__list_actions",
-  "mcp__marvin-governance__get_action",
-  "mcp__marvin-governance__create_action",
-  "mcp__marvin-governance__update_action",
-  "mcp__marvin-governance__list_questions",
-  "mcp__marvin-governance__get_question",
-  "mcp__marvin-governance__create_question",
-  "mcp__marvin-governance__update_question",
-  "mcp__marvin-governance__search_documents",
-  "mcp__marvin-governance__read_document",
-  "mcp__marvin-governance__project_summary"
-];
-async function runSkillAction(action, userPrompt, context) {
-  try {
-    const mcpServer = createMarvinMcpServer(context.store);
-    const allowedTools = action.allowGovernanceTools !== false ? GOVERNANCE_TOOL_NAMES : [];
-    const conversation = query2({
-      prompt: userPrompt,
-      options: {
-        systemPrompt: action.systemPrompt,
-        mcpServers: { "marvin-governance": mcpServer },
+function getSkillAgentDefinitions(skillIds, allSkills) {
+  const agents = {};
+  for (const id of skillIds) {
+    const skill = allSkills.get(id);
+    if (!skill?.actions) continue;
+    for (const action of skill.actions) {
+      const agentKey = `${skill.id}__${action.id}`;
+      agents[agentKey] = {
+        description: action.description,
+        prompt: action.systemPrompt,
         maxTurns: action.maxTurns ?? 5,
-        allowedTools,
-        cwd: context.projectRoot,
-        tools: [],
-        permissionMode: "acceptEdits"
-      }
-    });
-    const textParts = [];
-    for await (const message of conversation) {
-      if (message.type === "assistant") {
-        const textBlocks = message.message.content.filter(
-          (b) => b.type === "text"
+        tools: action.allowGovernanceTools !== false ? GOVERNANCE_TOOL_NAMES : []
+      };
+    }
+  }
+  return agents;
+}
+function migrateYamlToSkillMd(yamlPath, outputDir) {
+  const raw = fs7.readFileSync(yamlPath, "utf-8");
+  const parsed = YAML5.parse(raw);
+  if (!parsed?.id || !parsed?.name) {
+    throw new Error(`Invalid skill YAML: missing required fields (id, name)`);
+  }
+  fs7.mkdirSync(outputDir, { recursive: true });
+  const frontmatter = {
+    name: parsed.id,
+    description: parsed.description ?? ""
+  };
+  const metadata = {};
+  if (parsed.version) metadata.version = parsed.version;
+  if (parsed.personas) metadata.personas = parsed.personas;
+  if (Object.keys(metadata).length > 0) frontmatter.metadata = metadata;
+  const promptFragments = parsed.promptFragments;
+  const wildcardPrompt = promptFragments?.["*"] ?? "";
+  const skillMd = matter2.stringify(wildcardPrompt ? `
+${wildcardPrompt}
+` : "\n", frontmatter);
+  fs7.writeFileSync(path7.join(outputDir, "SKILL.md"), skillMd, "utf-8");
+  if (promptFragments) {
+    const personaKeys = Object.keys(promptFragments).filter((k) => k !== "*");
+    if (personaKeys.length > 0) {
+      const personasDir = path7.join(outputDir, "personas");
+      fs7.mkdirSync(personasDir, { recursive: true });
+      for (const personaId of personaKeys) {
+        fs7.writeFileSync(
+          path7.join(personasDir, `${personaId}.md`),
+          `${promptFragments[personaId]}
+`,
+          "utf-8"
         );
-        for (const block of textBlocks) {
-          textParts.push(block.text);
-        }
       }
     }
-    return {
-      content: [{ type: "text", text: textParts.join("\n") || "Action completed with no output." }]
-    };
-  } catch (err) {
-    return {
-      content: [{ type: "text", text: `Skill action failed: ${err}` }],
-      isError: true
-    };
   }
-}
-
-// src/skills/action-tools.ts
-function createSkillActionTools(skills, context) {
-  const tools = [];
-  for (const skill of skills) {
-    if (!skill.actions) continue;
-    for (const action of skill.actions) {
-      tools.push(
-        tool16(
-          `${skill.id}__${action.id}`,
-          action.description,
-          {
-            prompt: external_exports.string().describe("What you want this action to do")
-          },
-          async (args) => runSkillAction(action, args.prompt, context)
-        )
-      );
-    }
+  const actions = parsed.actions;
+  if (actions && actions.length > 0) {
+    fs7.writeFileSync(
+      path7.join(outputDir, "actions.yaml"),
+      YAML5.stringify(actions),
+      "utf-8"
+    );
   }
-  return tools;
 }
 
 // src/agent/session.ts
@@ -17094,15 +17177,14 @@ async function startSession(options) {
   const allSkills = loadAllSkills(marvinDir);
   const skillIds = resolveSkillsForPersona(persona.id, config2.project.skills, allSkills);
   const codeSkillTools = getSkillTools(skillIds, allSkills, store);
-  const skillsWithActions = skillIds.map((id) => allSkills.get(id)).filter((s) => s.actions && s.actions.length > 0);
-  const actionTools = createSkillActionTools(skillsWithActions, { store, marvinDir, projectRoot });
+  const skillAgents = getSkillAgentDefinitions(skillIds, allSkills);
   const skillPromptFragment = getSkillPromptFragment(skillIds, allSkills, persona.id);
   const mcpServer = createMarvinMcpServer(store, {
     manifest,
     sourcesDir: hasSourcesDir ? sourcesDir : void 0,
     sessionStore,
     pluginTools,
-    skillTools: [...codeSkillTools, ...actionTools]
+    skillTools: codeSkillTools
   });
   const systemPrompt = buildSystemPrompt(persona, config2.project, pluginPromptFragment, skillPromptFragment);
   let existingSession;
@@ -17192,14 +17274,16 @@ Marvin \u2014 ${persona.name}
       "mcp__marvin-governance__get_session",
       "mcp__marvin-governance__analyze_meeting",
       ...pluginTools.map((t) => `mcp__marvin-governance__${t.name}`),
-      ...codeSkillTools.map((t) => `mcp__marvin-governance__${t.name}`),
-      ...actionTools.map((t) => `mcp__marvin-governance__${t.name}`)
+      ...codeSkillTools.map((t) => `mcp__marvin-governance__${t.name}`)
     ]
   };
+  if (Object.keys(skillAgents).length > 0) {
+    queryOptions.agents = skillAgents;
+  }
   if (existingSession) {
     queryOptions.resume = existingSession.id;
   }
-  const conversation = query3({
+  const conversation = query2({
     prompt,
     options: queryOptions
   });
@@ -17286,6 +17370,296 @@ import * as fs9 from "fs";
 import * as path9 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/skills/action-tools.ts
+import { tool as tool16 } from "@anthropic-ai/claude-agent-sdk";
+
+// src/skills/action-runner.ts
+import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
+var GOVERNANCE_TOOL_NAMES2 = [
+  "mcp__marvin-governance__list_decisions",
+  "mcp__marvin-governance__get_decision",
+  "mcp__marvin-governance__create_decision",
+  "mcp__marvin-governance__update_decision",
+  "mcp__marvin-governance__list_actions",
+  "mcp__marvin-governance__get_action",
+  "mcp__marvin-governance__create_action",
+  "mcp__marvin-governance__update_action",
+  "mcp__marvin-governance__list_questions",
+  "mcp__marvin-governance__get_question",
+  "mcp__marvin-governance__create_question",
+  "mcp__marvin-governance__update_question",
+  "mcp__marvin-governance__search_documents",
+  "mcp__marvin-governance__read_document",
+  "mcp__marvin-governance__project_summary"
+];
+async function runSkillAction(action, userPrompt, context) {
+  try {
+    const mcpServer = createMarvinMcpServer(context.store);
+    const allowedTools = action.allowGovernanceTools !== false ? GOVERNANCE_TOOL_NAMES2 : [];
+    const conversation = query3({
+      prompt: userPrompt,
+      options: {
+        systemPrompt: action.systemPrompt,
+        mcpServers: { "marvin-governance": mcpServer },
+        maxTurns: action.maxTurns ?? 5,
+        allowedTools,
+        cwd: context.projectRoot,
+        tools: [],
+        permissionMode: "acceptEdits"
+      }
+    });
+    const textParts = [];
+    for await (const message of conversation) {
+      if (message.type === "assistant") {
+        const textBlocks = message.message.content.filter(
+          (b) => b.type === "text"
+        );
+        for (const block of textBlocks) {
+          textParts.push(block.text);
+        }
+      }
+    }
+    return {
+      content: [{ type: "text", text: textParts.join("\n") || "Action completed with no output." }]
+    };
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: `Skill action failed: ${err}` }],
+      isError: true
+    };
+  }
+}
+
+// src/skills/action-tools.ts
+function createSkillActionTools(skills, context) {
+  const tools = [];
+  for (const skill of skills) {
+    if (!skill.actions) continue;
+    for (const action of skill.actions) {
+      tools.push(
+        tool16(
+          `${skill.id}__${action.id}`,
+          action.description,
+          {
+            prompt: external_exports.string().describe("What you want this action to do")
+          },
+          async (args) => runSkillAction(action, args.prompt, context)
+        )
+      );
+    }
+  }
+  return tools;
+}
+
+// src/mcp/persona-context.ts
+var PersonaContextManager = class {
+  activePersona = null;
+  setPersona(idOrShortName) {
+    const persona = getPersona(idOrShortName);
+    if (persona) {
+      this.activePersona = persona;
+    }
+    return persona;
+  }
+  getActivePersona() {
+    return this.activePersona;
+  }
+  clearPersona() {
+    this.activePersona = null;
+  }
+  isDocumentTypeAllowed(docType) {
+    if (!this.activePersona) return true;
+    return this.activePersona.documentTypes.includes(docType);
+  }
+};
+function buildMcpGuidance(persona, marvinDir) {
+  const parts = [];
+  parts.push(`# Active Persona: ${persona.name} (${persona.shortName})`);
+  parts.push(`
+${persona.description}`);
+  parts.push(`
+## Focus Areas`);
+  for (const area of persona.focusAreas) {
+    parts.push(`- ${area}`);
+  }
+  parts.push(`
+## Allowed Document Types`);
+  parts.push(persona.documentTypes.join(", "));
+  parts.push(`
+## Behavioral Instructions`);
+  parts.push(persona.systemPrompt);
+  try {
+    const config2 = loadProjectConfig(marvinDir);
+    const plugin = resolvePlugin(config2.methodology);
+    if (plugin) {
+      const fragment = getPluginPromptFragment(plugin, persona.id);
+      if (fragment) {
+        parts.push(`
+## Plugin Rules`);
+        parts.push(fragment);
+      }
+    }
+    const allSkills = loadAllSkills(marvinDir);
+    const skillIds = resolveSkillsForPersona(
+      persona.id,
+      config2.skills,
+      allSkills
+    );
+    if (skillIds.length > 0) {
+      const fragment = getSkillPromptFragment(skillIds, allSkills, persona.id);
+      if (fragment) {
+        parts.push(`
+## Skill Rules`);
+        parts.push(fragment);
+      }
+    }
+  } catch {
+  }
+  return parts.join("\n");
+}
+function buildPersonaSummaries() {
+  const personas = listPersonas();
+  const lines = personas.map(
+    (p) => `- **${p.name}** (${p.shortName}): ${p.description}
+  Document types: ${p.documentTypes.join(", ")}`
+  );
+  return `# Available Personas
+
+${lines.join("\n\n")}`;
+}
+
+// src/mcp/persona-tools.ts
+import { tool as tool17 } from "@anthropic-ai/claude-agent-sdk";
+function createPersonaTools(ctx, marvinDir) {
+  return [
+    tool17(
+      "set_persona",
+      "Set the active persona for this session. Returns full guidance for the selected persona including behavioral rules, allowed document types, and scope. Call this before working to ensure persona-appropriate behavior.",
+      {
+        persona: external_exports.string().describe(
+          'Persona ID or short name (e.g. "po", "product-owner", "dm", "delivery-manager", "tl", "tech-lead")'
+        )
+      },
+      async (args) => {
+        const resolved = ctx.setPersona(args.persona);
+        if (!resolved) {
+          const summaries = buildPersonaSummaries();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Unknown persona "${args.persona}".
+
+${summaries}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const guidance = buildMcpGuidance(resolved, marvinDir);
+        return {
+          content: [{ type: "text", text: guidance }]
+        };
+      }
+    ),
+    tool17(
+      "get_persona_guidance",
+      "Get guidance for a persona without changing the active persona. If no persona is specified, lists all available personas with summaries.",
+      {
+        persona: external_exports.string().optional().describe(
+          "Optional persona ID or short name. Omit to list all personas."
+        )
+      },
+      async (args) => {
+        if (!args.persona) {
+          const summaries = buildPersonaSummaries();
+          return {
+            content: [{ type: "text", text: summaries }]
+          };
+        }
+        const resolved = getPersona(args.persona);
+        if (!resolved) {
+          const summaries = buildPersonaSummaries();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Unknown persona "${args.persona}".
+
+${summaries}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const guidance = buildMcpGuidance(resolved, marvinDir);
+        return {
+          content: [{ type: "text", text: guidance }]
+        };
+      },
+      { annotations: { readOnly: true } }
+    )
+  ];
+}
+
+// src/mcp/tool-wrapper.ts
+function extractDocType(toolName) {
+  if (toolName === "save_report") return "report";
+  const match = toolName.match(/^(?:create|update)_(\w+)$/);
+  return match ? match[1] : void 0;
+}
+function wrapToolsWithPersonaValidation(tools, ctx) {
+  return tools.map((t) => {
+    const docType = extractDocType(t.name);
+    if (!docType) return t;
+    return {
+      ...t,
+      handler: async (args, extra) => {
+        const persona = ctx.getActivePersona();
+        if (!persona) {
+          const summaries = buildPersonaSummaries();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `[PERSONA REQUIRED] You must set an active persona before creating or updating documents. Call the set_persona tool first.
+
+${summaries}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = await t.handler(args, extra);
+        if (ctx.isDocumentTypeAllowed(docType)) {
+          return result;
+        }
+        const warning = [
+          `[PERSONA WARNING] You are acting as ${persona.name} (${persona.shortName}). Creating/updating "${docType}" documents is outside your typical scope.`,
+          "",
+          `Your allowed document types: ${persona.documentTypes.join(", ")}`,
+          "",
+          "Consider whether this is the right persona for this task, or switch with set_persona.",
+          "",
+          "---"
+        ].join("\n");
+        const content = Array.isArray(result.content) ? result.content.map(
+          (block, index) => {
+            if (index === 0 && block.type === "text" && block.text) {
+              return { ...block, text: `${warning}
+${block.text}` };
+            }
+            return block;
+          }
+        ) : result.content;
+        return { ...result, content };
+      }
+    };
+  });
+}
+
+// src/mcp/stdio-server.ts
 function collectTools(marvinDir) {
   const config2 = loadProjectConfig(marvinDir);
   const plugin = resolvePlugin(config2.methodology);
@@ -17347,8 +17721,11 @@ async function startStdioServer(options) {
     { name: "marvin-governance", version: "0.1.0" },
     { capabilities: { tools: {} } }
   );
-  const tools = collectTools(options.marvinDir);
-  registerSdkTools(server, tools);
+  const contextManager = new PersonaContextManager();
+  const governanceTools = collectTools(options.marvinDir);
+  const personaTools = createPersonaTools(contextManager, options.marvinDir);
+  const wrappedTools = wrapToolsWithPersonaValidation(governanceTools, contextManager);
+  registerSdkTools(server, [...personaTools, ...wrappedTools]);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
@@ -18064,8 +18441,8 @@ var MarvinGit = class {
       );
     }
     await this.git.init();
-    const { writeFileSync: writeFileSync8 } = await import("fs");
-    writeFileSync8(
+    const { writeFileSync: writeFileSync9 } = await import("fs");
+    writeFileSync9(
       path13.join(this.marvinDir, ".gitignore"),
       MARVIN_GITIGNORE,
       "utf-8"
@@ -18375,6 +18752,7 @@ async function serveCommand() {
 import * as fs13 from "fs";
 import * as path14 from "path";
 import * as YAML7 from "yaml";
+import matter3 from "gray-matter";
 import chalk10 from "chalk";
 async function skillsListCommand() {
   const project = loadProject();
@@ -18388,10 +18766,12 @@ async function skillsListCommand() {
   }
   console.log(chalk10.bold("\nAvailable Skills\n"));
   const idWidth = Math.max(5, ...infos.map((s) => s.id.length));
+  const fmtWidth = Math.max(6, ...infos.map((s) => s.format.length));
   const verWidth = Math.max(7, ...infos.map((s) => s.version.length));
   const descWidth = Math.max(11, ...infos.map((s) => s.description.length));
   const header = [
     "ID".padEnd(idWidth),
+    "Format".padEnd(fmtWidth),
     "Version".padEnd(verWidth),
     "Description".padEnd(descWidth),
     "Personas"
@@ -18403,6 +18783,7 @@ async function skillsListCommand() {
     console.log(
       [
         info.id.padEnd(idWidth),
+        info.format.padEnd(fmtWidth),
         info.version.padEnd(verWidth),
         info.description.padEnd(descWidth),
         personas
@@ -18471,33 +18852,82 @@ async function skillsCreateCommand(name) {
   const project = loadProject();
   const skillsDir = path14.join(project.marvinDir, "skills");
   fs13.mkdirSync(skillsDir, { recursive: true });
-  const filePath = path14.join(skillsDir, `${name}.yaml`);
-  if (fs13.existsSync(filePath)) {
-    console.log(chalk10.yellow(`Skill file already exists: ${filePath}`));
+  const skillDir = path14.join(skillsDir, name);
+  if (fs13.existsSync(skillDir)) {
+    console.log(chalk10.yellow(`Skill directory already exists: ${skillDir}`));
     return;
   }
-  const template = {
-    id: name,
-    name: name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+  fs13.mkdirSync(skillDir, { recursive: true });
+  const displayName = name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  const frontmatter = {
+    name,
     description: `Custom skill: ${name}`,
-    version: "1.0.0",
-    personas: ["product-owner"],
-    promptFragments: {
-      "*": `You have the **${name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())}** skill.`
-    },
-    actions: [
-      {
-        id: "run",
-        name: `Run ${name}`,
-        description: `Execute the ${name} skill`,
-        systemPrompt: "You are a helpful assistant. Complete the requested task using the available governance tools.",
-        maxTurns: 5
-      }
-    ]
+    metadata: {
+      version: "1.0.0",
+      personas: ["product-owner"]
+    }
   };
-  fs13.writeFileSync(filePath, YAML7.stringify(template), "utf-8");
-  console.log(chalk10.green(`Created skill template: ${filePath}`));
-  console.log(chalk10.dim("Edit the YAML file to customize your skill."));
+  const body = `
+You have the **${displayName}** skill.
+`;
+  const skillMd = matter3.stringify(body, frontmatter);
+  fs13.writeFileSync(path14.join(skillDir, "SKILL.md"), skillMd, "utf-8");
+  const actions = [
+    {
+      id: "run",
+      name: `Run ${name}`,
+      description: `Execute the ${name} skill`,
+      systemPrompt: "You are a helpful assistant. Complete the requested task using the available governance tools.",
+      maxTurns: 5
+    }
+  ];
+  fs13.writeFileSync(path14.join(skillDir, "actions.yaml"), YAML7.stringify(actions), "utf-8");
+  console.log(chalk10.green(`Created skill: ${skillDir}/`));
+  console.log(chalk10.dim("  SKILL.md      \u2014 skill definition and prompt"));
+  console.log(chalk10.dim("  actions.yaml  \u2014 action definitions"));
+  console.log(chalk10.dim("\nAdd persona-specific prompts in personas/<persona-id>.md"));
+}
+async function skillsMigrateCommand() {
+  const project = loadProject();
+  const skillsDir = path14.join(project.marvinDir, "skills");
+  if (!fs13.existsSync(skillsDir)) {
+    console.log(chalk10.dim("No skills directory found."));
+    return;
+  }
+  let entries;
+  try {
+    entries = fs13.readdirSync(skillsDir);
+  } catch {
+    console.log(chalk10.red("Could not read skills directory."));
+    return;
+  }
+  const yamlFiles = entries.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+  if (yamlFiles.length === 0) {
+    console.log(chalk10.dim("No YAML skill files to migrate."));
+    return;
+  }
+  let migrated = 0;
+  for (const file2 of yamlFiles) {
+    const yamlPath = path14.join(skillsDir, file2);
+    const baseName = file2.replace(/\.(yaml|yml)$/, "");
+    const outputDir = path14.join(skillsDir, baseName);
+    if (fs13.existsSync(outputDir)) {
+      console.log(chalk10.yellow(`Skipping "${file2}" \u2014 directory "${baseName}/" already exists.`));
+      continue;
+    }
+    try {
+      migrateYamlToSkillMd(yamlPath, outputDir);
+      fs13.renameSync(yamlPath, `${yamlPath}.bak`);
+      console.log(chalk10.green(`Migrated "${file2}" \u2192 "${baseName}/"`));
+      migrated++;
+    } catch (err) {
+      console.log(chalk10.red(`Failed to migrate "${file2}": ${err}`));
+    }
+  }
+  if (migrated > 0) {
+    console.log(chalk10.dim(`
+${migrated} skill(s) migrated. Original files renamed to *.bak`));
+  }
 }
 
 // src/cli/commands/import.ts
@@ -18508,12 +18938,12 @@ import chalk11 from "chalk";
 // src/import/engine.ts
 import * as fs15 from "fs";
 import * as path16 from "path";
-import matter3 from "gray-matter";
+import matter5 from "gray-matter";
 
 // src/import/classifier.ts
 import * as fs14 from "fs";
 import * as path15 from "path";
-import matter2 from "gray-matter";
+import matter4 from "gray-matter";
 var RAW_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".pdf", ".txt"]);
 var CORE_DIR_NAMES = /* @__PURE__ */ new Set(["decisions", "actions", "questions"]);
 var ID_PATTERN = /^[A-Z]+-\d{3,}$/;
@@ -18539,7 +18969,7 @@ function classifyPath(inputPath, knownTypes, knownDirNames) {
     const hasMarvinDocs = mdFiles.some((f) => {
       try {
         const raw = fs14.readFileSync(path15.join(resolved, f), "utf-8");
-        const { data } = matter2(raw);
+        const { data } = matter4(raw);
         return isValidMarvinDocument(data, knownTypes);
       } catch {
         return false;
@@ -18560,7 +18990,7 @@ function classifyFile(filePath, knownTypes) {
   if (ext === ".md") {
     try {
       const raw = fs14.readFileSync(resolved, "utf-8");
-      const { data } = matter2(raw);
+      const { data } = matter4(raw);
       if (isValidMarvinDocument(data, knownTypes)) {
         return { type: "marvin-document", inputPath: resolved };
       }
@@ -18771,7 +19201,7 @@ function collectMarvinDocs(dir, knownTypes) {
     const filePath = path16.join(dir, file2);
     try {
       const raw = fs15.readFileSync(filePath, "utf-8");
-      const { data, content } = matter3(raw);
+      const { data, content } = matter5(raw);
       if (isValidMarvinDocument(data, knownTypes)) {
         docs.push({
           frontmatter: data,
@@ -18865,7 +19295,7 @@ function planFromSingleDocument(classification, store, _marvinDir, options) {
   const filePath = classification.inputPath;
   const knownTypes = store.registeredTypes;
   const raw = fs15.readFileSync(filePath, "utf-8");
-  const { data, content } = matter3(raw);
+  const { data, content } = matter5(raw);
   if (!isValidMarvinDocument(data, knownTypes)) {
     return [];
   }
@@ -19262,7 +19692,7 @@ function createProgram() {
   const program = new Command();
   program.name("marvin").description(
     "AI-powered product development assistant with Product Owner, Delivery Manager, and Technical Lead personas"
-  ).version("0.1.4");
+  ).version("0.2.0");
   program.command("init").description("Initialize a new Marvin project in the current directory").action(async () => {
     await initCommand();
   });
@@ -19323,9 +19753,12 @@ function createProgram() {
   skillsCmd.command("remove <skill>").description("Unassign a skill from a persona").requiredOption("--as <persona>", "Persona to remove the skill from").action(async (skill, options) => {
     await skillsRemoveCommand(skill, options);
   });
-  skillsCmd.command("create <name>").description("Create a YAML skill template in .marvin/skills/").action(async (name) => {
+  skillsCmd.command("create <name>").description("Create a new skill in .marvin/skills/ (SKILL.md format)").action(async (name) => {
     await skillsCreateCommand(name);
   });
+  skillsCmd.command("migrate").description("Migrate YAML skill files to SKILL.md directory format").action(async () => {
+    await skillsMigrateCommand();
+  });
   return program;
 }
 export {
@@ -19348,13 +19781,16 @@ export {
   getPersona,
   getPluginPromptFragment,
   getPluginTools,
+  getSkillAgentDefinitions,
   getSkillPromptFragment,
   getSkillTools,
   isMarvinProject,
   listPersonas,
   loadAllSkills,
   loadProject,
+  loadSkillFromDirectory,
   loadUserConfig,
+  migrateYamlToSkillMd,
   parseDocument,
   registerSdkTools,
   resolvePersonaId,