@fro.bot/systematic 1.1.0 → 1.2.0

package/README.md

@@ -52,9 +52,9 @@ Quick shortcuts to invoke workflows:
 - `/deepen-plan` - Add detail to existing plans
 - `/lfg` - Let's go - start working immediately
 
-### Review Agents
+### Agents
 
-Specialized code review agents organized by category:
+Specialized agents organized by category:
 
 **Review:**
 
@@ -98,42 +98,6 @@ Create `~/.config/opencode/systematic.json` or `.opencode/systematic.json` to di
 }
 ```
 
-## Converting CEP Content
-
-The CLI includes a converter for adapting Claude Code agents, skills, and commands from Compound Engineering Plugin (CEP) to OpenCode.
-
-### Convert a Skill
-
-Skills are directories containing `SKILL.md` and supporting files:
-
-```bash
-npx @fro.bot/systematic convert skill /path/to/cep/skills/my-skill -o ./skills/my-skill
-```
-
-### Convert an Agent
-
-Agents are markdown files that get OpenCode-compatible YAML frontmatter:
-
-```bash
-npx @fro.bot/systematic convert agent /path/to/cep/agents/review/my-agent.md -o ./agents/review/my-agent.md
-```
-
-### Convert a Command
-
-Commands are markdown templates:
-
-```bash
-npx @fro.bot/systematic convert command /path/to/cep/commands/my-command.md -o ./commands/my-command.md
-```
-
-### Dry Run
-
-Preview conversion without writing files:
-
-```bash
-npx @fro.bot/systematic convert skill /path/to/skill --dry-run
-```
-
 ## Development
 
 ```bash

package/dist/cli.js

@@ -1,191 +1,14 @@
 #!/usr/bin/env node
 import {
+  convertContent,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir
-} from "./index-v8dhd5s2.js";
+} from "./index-33zyxync.js";
 
 // src/cli.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
-
-// src/lib/converter.ts
 import fs from "node:fs";
 import path from "node:path";
-function parseFrontmatter(raw) {
-  const lines = raw.split(/\r?\n/);
-  if (lines.length === 0 || lines[0].trim() !== "---") {
-    return { data: {}, body: raw };
-  }
-  let endIndex = -1;
-  for (let i = 1;i < lines.length; i++) {
-    if (lines[i].trim() === "---") {
-      endIndex = i;
-      break;
-    }
-  }
-  if (endIndex === -1) {
-    return { data: {}, body: raw };
-  }
-  const yamlLines = lines.slice(1, endIndex);
-  const body = lines.slice(endIndex + 1).join(`
-`);
-  const data = {};
-  for (const line of yamlLines) {
-    const match = line.match(/^(\w+):\s*(.*)$/);
-    if (match) {
-      const [, key, value] = match;
-      if (value === "true")
-        data[key] = true;
-      else if (value === "false")
-        data[key] = false;
-      else if (/^\d+(\.\d+)?$/.test(value))
-        data[key] = parseFloat(value);
-      else
-        data[key] = value;
-    }
-  }
-  return { data, body };
-}
-function formatFrontmatter(data, body) {
-  const lines = [];
-  if (data.description)
-    lines.push(`description: ${data.description}`);
-  if (data.mode)
-    lines.push(`mode: ${data.mode}`);
-  if (data.model)
-    lines.push(`model: ${data.model}`);
-  if (data.temperature !== undefined)
-    lines.push(`temperature: ${data.temperature}`);
-  if (lines.length === 0)
-    return body;
-  return ["---", ...lines, "---", "", body].join(`
-`);
-}
-function inferTemperature(name, description) {
-  const sample = `${name} ${description || ""}`.toLowerCase();
-  if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
-    return 0.1;
-  }
-  if (/(plan|planning|architecture|strategist|analysis|research)/.test(sample)) {
-    return 0.2;
-  }
-  if (/(doc|readme|changelog|editor|writer)/.test(sample)) {
-    return 0.3;
-  }
-  if (/(brainstorm|creative|ideate|design|concept)/.test(sample)) {
-    return 0.6;
-  }
-  return 0.3;
-}
-function normalizeModel(model) {
-  if (model.includes("/"))
-    return model;
-  if (/^claude-/.test(model))
-    return `anthropic/${model}`;
-  if (/^(gpt-|o1-|o3-)/.test(model))
-    return `openai/${model}`;
-  if (/^gemini-/.test(model))
-    return `google/${model}`;
-  return `anthropic/${model}`;
-}
-function convertAgent(sourcePath, options = {}) {
-  const content = fs.readFileSync(sourcePath, "utf-8");
-  const name = path.basename(sourcePath, ".md");
-  const { data, body } = parseFrontmatter(content);
-  const existingDescription = data.description;
-  const existingModel = data.model;
-  let description = existingDescription;
-  if (!description) {
-    const firstLine = body.split(`
-`).find((l) => l.trim() && !l.startsWith("#"));
-    description = firstLine?.slice(0, 100) || `${name} agent`;
-  }
-  const frontmatter = {
-    description,
-    mode: "subagent",
-    temperature: inferTemperature(name, description)
-  };
-  if (existingModel && existingModel !== "inherit") {
-    frontmatter.model = normalizeModel(existingModel);
-  }
-  const converted = formatFrontmatter(frontmatter, body.trim());
-  const outputPath = options.output || sourcePath;
-  if (!options.dryRun) {
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, converted);
-  }
-  return {
-    type: "agent",
-    sourcePath,
-    outputPath,
-    converted: true,
-    files: [path.basename(outputPath)]
-  };
-}
-function convertCommand(sourcePath, options = {}) {
-  const content = fs.readFileSync(sourcePath, "utf-8");
-  const outputPath = options.output || sourcePath;
-  if (!options.dryRun) {
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, content);
-  }
-  return {
-    type: "command",
-    sourcePath,
-    outputPath,
-    converted: true,
-    files: [path.basename(outputPath)]
-  };
-}
-function convertSkill(sourcePath, options = {}) {
-  const stats = fs.statSync(sourcePath);
-  if (!stats.isDirectory()) {
-    throw new Error(`Skill source must be a directory: ${sourcePath}`);
-  }
-  const skillName = path.basename(sourcePath);
-  const outputPath = options.output || sourcePath;
-  const files = [];
-  function copyDir(src, dest) {
-    if (!options.dryRun) {
-      fs.mkdirSync(dest, { recursive: true });
-    }
-    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-      if (entry.isDirectory()) {
-        copyDir(srcPath, destPath);
-      } else {
-        files.push(path.relative(outputPath, destPath));
-        if (!options.dryRun) {
-          fs.copyFileSync(srcPath, destPath);
-        }
-      }
-    }
-  }
-  copyDir(sourcePath, outputPath);
-  return {
-    type: "skill",
-    sourcePath,
-    outputPath,
-    converted: true,
-    files
-  };
-}
-function convert(type, sourcePath, options = {}) {
-  switch (type) {
-    case "agent":
-      return convertAgent(sourcePath, options);
-    case "command":
-      return convertCommand(sourcePath, options);
-    case "skill":
-      return convertSkill(sourcePath, options);
-    default:
-      throw new Error(`Unknown type: ${type}`);
-  }
-}
-
-// src/cli.ts
 var VERSION = "0.1.0";
 var HELP = `
 systematic - OpenCode plugin for systematic engineering workflows
@@ -195,32 +18,32 @@ Usage:
 
 Commands:
   list [type]          List available skills, agents, or commands
-  convert <type> <source> [--output <path>] [--dry-run]
-                       Convert Claude Code content to OpenCode format
-    Types: skill, agent, command
+  convert <type> <file> [--mode=primary|subagent]
+                       Convert and inspect a file (outputs to stdout)
   config [subcommand]  Configuration management
     show               Show configuration
     path               Print config file locations
 
 Options:
-  --output, -o         Output path for convert command
-  --dry-run            Preview conversion without writing files
   -h, --help           Show this help message
   -v, --version        Show version
 
 Examples:
   systematic list skills
-  systematic convert skill /path/to/cep/skills/agent-browser -o ./skills/agent-browser
-  systematic convert agent /path/to/agent.md --dry-run
+  systematic list agents
+  systematic convert agent ./agents/my-agent.md
+  systematic convert agent ./agents/my-agent.md --mode=primary
+  systematic convert skill ./skills/my-skill/SKILL.md
+  systematic config show
 `;
 function getUserConfigDir() {
-  return path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".config/opencode");
+  return path.join(process.env.HOME || process.env.USERPROFILE || ".", ".config/opencode");
 }
 function getProjectConfigDir() {
-  return path2.join(process.cwd(), ".opencode");
+  return path.join(process.cwd(), ".opencode");
 }
 function listItems(type) {
-  const packageRoot = path2.resolve(import.meta.dirname, "..");
+  const packageRoot = path.resolve(import.meta.dirname, "..");
   const bundledDir = packageRoot;
   let finder;
   let subdir;
@@ -241,7 +64,7 @@ function listItems(type) {
       console.error(`Unknown type: ${type}. Use: skills, agents, commands`);
       process.exit(1);
   }
-  const items = finder(path2.join(bundledDir, subdir), "bundled");
+  const items = finder(path.join(bundledDir, subdir), "bundled");
   if (items.length === 0) {
     console.log(`No ${type} found.`);
     return;
@@ -252,71 +75,57 @@ function listItems(type) {
     console.log(`  ${item.name} (${item.sourceType})`);
   }
 }
+function runConvert(type, filePath, modeArg) {
+  const validTypes = ["skill", "agent", "command"];
+  if (!validTypes.includes(type)) {
+    console.error(`Invalid type: ${type}. Must be one of: ${validTypes.join(", ")}`);
+    process.exit(1);
+  }
+  const resolvedPath = path.resolve(filePath);
+  if (!fs.existsSync(resolvedPath)) {
+    console.error(`File not found: ${resolvedPath}`);
+    process.exit(1);
+  }
+  let agentMode = "subagent";
+  if (modeArg) {
+    const modeMatch = modeArg.match(/^--mode=(primary|subagent)$/);
+    if (modeMatch) {
+      agentMode = modeMatch[1];
+    } else {
+      console.error("Invalid --mode flag. Use: --mode=primary or --mode=subagent");
+      process.exit(1);
+    }
+  }
+  const content = fs.readFileSync(resolvedPath, "utf8");
+  const converted = convertContent(content, type, { agentMode });
+  console.log(converted);
+}
 function configShow() {
   const userDir = getUserConfigDir();
   const projectDir = getProjectConfigDir();
   console.log(`Configuration locations:
 `);
-  console.log(`  User config:    ${path2.join(userDir, "systematic.json")}`);
-  console.log(`  Project config: ${path2.join(projectDir, "systematic.json")}`);
-  const projectConfig = path2.join(projectDir, "systematic.json");
-  if (fs2.existsSync(projectConfig)) {
+  console.log(`  User config:    ${path.join(userDir, "systematic.json")}`);
+  console.log(`  Project config: ${path.join(projectDir, "systematic.json")}`);
+  const projectConfig = path.join(projectDir, "systematic.json");
+  if (fs.existsSync(projectConfig)) {
     console.log(`
 Project configuration:`);
-    console.log(fs2.readFileSync(projectConfig, "utf-8"));
+    console.log(fs.readFileSync(projectConfig, "utf-8"));
   }
-  const userConfig = path2.join(userDir, "systematic.json");
-  if (fs2.existsSync(userConfig)) {
+  const userConfig = path.join(userDir, "systematic.json");
+  if (fs.existsSync(userConfig)) {
     console.log(`
 User configuration:`);
-    console.log(fs2.readFileSync(userConfig, "utf-8"));
+    console.log(fs.readFileSync(userConfig, "utf-8"));
   }
 }
 function configPath() {
   const userDir = getUserConfigDir();
   const projectDir = getProjectConfigDir();
   console.log("Config file paths:");
-  console.log(`  User:    ${path2.join(userDir, "systematic.json")}`);
-  console.log(`  Project: ${path2.join(projectDir, "systematic.json")}`);
-}
-function runConvert(args) {
-  const typeArg = args[1];
-  const sourceArg = args[2];
-  if (!typeArg || !sourceArg) {
-    console.error("Usage: systematic convert <type> <source> [--output <path>] [--dry-run]");
-    console.error("Types: skill, agent, command");
-    process.exit(1);
-  }
-  const validTypes = ["skill", "agent", "command"];
-  if (!validTypes.includes(typeArg)) {
-    console.error(`Invalid type: ${typeArg}. Must be one of: ${validTypes.join(", ")}`);
-    process.exit(1);
-  }
-  const sourcePath = path2.resolve(sourceArg);
-  if (!fs2.existsSync(sourcePath)) {
-    console.error(`Source not found: ${sourcePath}`);
-    process.exit(1);
-  }
-  const outputIndex = args.findIndex((a) => a === "--output" || a === "-o");
-  const outputPath = outputIndex !== -1 ? path2.resolve(args[outputIndex + 1]) : undefined;
-  const dryRun = args.includes("--dry-run");
-  try {
-    const result = convert(typeArg, sourcePath, { output: outputPath, dryRun });
-    if (dryRun) {
-      console.log(`[DRY RUN] Would convert ${result.type}:`);
-    } else {
-      console.log(`Converted ${result.type}:`);
-    }
-    console.log(`  Source: ${result.sourcePath}`);
-    console.log(`  Output: ${result.outputPath}`);
-    console.log("  Files:");
-    for (const file of result.files) {
-      console.log(`    - ${file}`);
-    }
-  } catch (err) {
-    console.error(`Conversion failed: ${err.message}`);
-    process.exit(1);
-  }
+  console.log(`  User:    ${path.join(userDir, "systematic.json")}`);
+  console.log(`  Project: ${path.join(projectDir, "systematic.json")}`);
 }
 var args = process.argv.slice(2);
 var command = args[0];
@@ -325,7 +134,12 @@ switch (command) {
     listItems(args[1] || "skills");
     break;
   case "convert":
-    runConvert(args);
+    if (!args[1] || !args[2]) {
+      console.error("Usage: systematic convert <type> <file> [--mode=primary|subagent]");
+      console.error("  type: skill, agent, or command");
+      process.exit(1);
+    }
+    runConvert(args[1], args[2], args[3]);
     break;
   case "config":
     switch (args[1]) {

package/dist/{index-v8dhd5s2.js → index-33zyxync.js}

@@ -1,9 +1,138 @@
-// src/lib/skills-core.ts
+// src/lib/converter.ts
 import fs from "node:fs";
+var cache = new Map;
+function parseFrontmatter(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines.length === 0 || lines[0].trim() !== "---") {
+    return { data: {}, body: content, raw: "" };
+  }
+  let endIndex = -1;
+  for (let i = 1;i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return { data: {}, body: content, raw: "" };
+  }
+  const yamlLines = lines.slice(1, endIndex);
+  const body = lines.slice(endIndex + 1).join(`
+`);
+  const raw = lines.slice(0, endIndex + 1).join(`
+`);
+  const data = {};
+  for (const line of yamlLines) {
+    const match = line.match(/^([\w-]+):\s*(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      if (value === "true")
+        data[key] = true;
+      else if (value === "false")
+        data[key] = false;
+      else if (/^\d+(\.\d+)?$/.test(value))
+        data[key] = parseFloat(value);
+      else
+        data[key] = value;
+    }
+  }
+  return { data, body, raw };
+}
+function formatFrontmatter(data) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(data)) {
+    lines.push(`${key}: ${value}`);
+  }
+  lines.push("---");
+  return lines.join(`
+`);
+}
+function inferTemperature(name, description) {
+  const sample = `${name} ${description ?? ""}`.toLowerCase();
+  if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
+    return 0.1;
+  }
+  if (/(plan|planning|architecture|strategist|analysis|research)/.test(sample)) {
+    return 0.2;
+  }
+  if (/(doc|readme|changelog|editor|writer)/.test(sample)) {
+    return 0.3;
+  }
+  if (/(brainstorm|creative|ideate|design|concept)/.test(sample)) {
+    return 0.6;
+  }
+  return 0.3;
+}
+function normalizeModel(model) {
+  if (model.includes("/"))
+    return model;
+  if (model === "inherit")
+    return model;
+  if (/^claude-/.test(model))
+    return `anthropic/${model}`;
+  if (/^(gpt-|o1-|o3-)/.test(model))
+    return `openai/${model}`;
+  if (/^gemini-/.test(model))
+    return `google/${model}`;
+  return `anthropic/${model}`;
+}
+function transformAgentFrontmatter(data, agentMode) {
+  const name = typeof data.name === "string" ? data.name : "";
+  const description = typeof data.description === "string" ? data.description : "";
+  const newData = {
+    description: description || `${name} agent`,
+    mode: agentMode
+  };
+  if (typeof data.model === "string" && data.model !== "inherit") {
+    newData.model = normalizeModel(data.model);
+  }
+  if (typeof data.temperature === "number") {
+    newData.temperature = data.temperature;
+  } else {
+    newData.temperature = inferTemperature(name, description);
+  }
+  return newData;
+}
+function convertContent(content, type, options = {}) {
+  if (content === "")
+    return "";
+  const { data, body, raw } = parseFrontmatter(content);
+  const hasFrontmatter = raw !== "";
+  if (!hasFrontmatter) {
+    return content;
+  }
+  if (type === "agent") {
+    const agentMode = options.agentMode ?? "subagent";
+    const transformedData = transformAgentFrontmatter(data, agentMode);
+    return `${formatFrontmatter(transformedData)}
+${body}`;
+  }
+  return content;
+}
+function convertFileWithCache(filePath, type, options = {}) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const stats = fs.fstatSync(fd);
+    const cacheKey = `${filePath}:${type}:${options.source ?? "bundled"}:${options.agentMode ?? "subagent"}`;
+    const cached = cache.get(cacheKey);
+    if (cached != null && cached.mtimeMs === stats.mtimeMs) {
+      return cached.converted;
+    }
+    const content = fs.readFileSync(fd, "utf8");
+    const converted = convertContent(content, type, options);
+    cache.set(cacheKey, { mtimeMs: stats.mtimeMs, converted });
+    return converted;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// src/lib/skills-core.ts
+import fs2 from "node:fs";
 import path from "node:path";
 function extractFrontmatter(filePath) {
   try {
-    const content = fs.readFileSync(filePath, "utf8");
+    const content = fs2.readFileSync(filePath, "utf8");
     const lines = content.split(`
 `);
     let inFrontmatter = false;
@@ -56,17 +185,17 @@ function stripFrontmatter(content) {
 }
 function findSkillsInDir(dir, sourceType, maxDepth = 3) {
   const skills = [];
-  if (!fs.existsSync(dir))
+  if (!fs2.existsSync(dir))
     return skills;
   function recurse(currentDir, depth) {
     if (depth > maxDepth)
       return;
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         const skillFile = path.join(fullPath, "SKILL.md");
-        if (fs.existsSync(skillFile)) {
+        if (fs2.existsSync(skillFile)) {
           const { name, description } = extractFrontmatter(skillFile);
           skills.push({
             path: fullPath,
@@ -85,12 +214,12 @@ function findSkillsInDir(dir, sourceType, maxDepth = 3) {
 }
 function findAgentsInDir(dir, sourceType, maxDepth = 2) {
   const agents = [];
-  if (!fs.existsSync(dir))
+  if (!fs2.existsSync(dir))
     return agents;
   function recurse(currentDir, depth, category) {
     if (depth > maxDepth)
       return;
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
       if (entry.isDirectory()) {
@@ -110,12 +239,12 @@ function findAgentsInDir(dir, sourceType, maxDepth = 2) {
 }
 function findCommandsInDir(dir, sourceType, maxDepth = 2) {
   const commands = [];
-  if (!fs.existsSync(dir))
+  if (!fs2.existsSync(dir))
     return commands;
   function recurse(currentDir, depth, category) {
     if (depth > maxDepth)
       return;
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
       if (entry.isDirectory()) {
@@ -191,4 +320,4 @@ function extractCommandFrontmatter(content) {
   return { name, description, argumentHint };
 }
 
-export { stripFrontmatter, findSkillsInDir, findAgentsInDir, findCommandsInDir, extractAgentFrontmatter, extractCommandFrontmatter };
+export { convertContent, convertFileWithCache, stripFrontmatter, findSkillsInDir, findAgentsInDir, findCommandsInDir, extractAgentFrontmatter, extractCommandFrontmatter };

package/dist/index.js

@@ -1,14 +1,16 @@
 import {
+  convertContent,
+  convertFileWithCache,
   extractAgentFrontmatter,
   extractCommandFrontmatter,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
   stripFrontmatter
-} from "./index-v8dhd5s2.js";
+} from "./index-33zyxync.js";
 
 // src/index.ts
-import fs4 from "node:fs";
+import fs3 from "node:fs";
 import os2 from "node:os";
 import path3 from "node:path";
 import { fileURLToPath } from "node:url";
@@ -64,14 +66,16 @@ function loadConfig(projectDir) {
 }
 
 // src/lib/config-handler.ts
-import fs2 from "node:fs";
 function loadAgentAsConfig(agentInfo) {
   try {
-    const content = fs2.readFileSync(agentInfo.file, "utf8");
-    const { name, description, prompt } = extractAgentFrontmatter(content);
+    const converted = convertFileWithCache(agentInfo.file, "agent", {
+      source: "bundled",
+      agentMode: "subagent"
+    });
+    const { description, prompt } = extractAgentFrontmatter(converted);
     return {
-      description: description || `${name || agentInfo.name} agent`,
-      prompt: prompt || stripFrontmatter(content)
+      description: description || `${agentInfo.name} agent`,
+      prompt: prompt || stripFrontmatter(converted)
     };
   } catch {
     return null;
@@ -79,11 +83,11 @@ function loadAgentAsConfig(agentInfo) {
 }
 function loadCommandAsConfig(commandInfo) {
   try {
-    const content = fs2.readFileSync(commandInfo.file, "utf8");
-    const { name, description } = extractCommandFrontmatter(content);
+    const converted = convertFileWithCache(commandInfo.file, "command", { source: "bundled" });
+    const { name, description } = extractCommandFrontmatter(converted);
     const cleanName = commandInfo.name.replace(/^\//, "");
     return {
-      template: stripFrontmatter(content),
+      template: stripFrontmatter(converted),
       description: description || `${name || cleanName} command`
     };
   } catch {
@@ -92,9 +96,9 @@ function loadCommandAsConfig(commandInfo) {
 }
 function loadSkillAsCommand(skillInfo) {
   try {
-    const content = fs2.readFileSync(skillInfo.skillFile, "utf8");
+    const converted = convertFileWithCache(skillInfo.skillFile, "skill", { source: "bundled" });
     return {
-      template: stripFrontmatter(content),
+      template: stripFrontmatter(converted),
       description: skillInfo.description || `${skillInfo.name} skill`
     };
   } catch {
@@ -163,7 +167,7 @@ function createConfigHandler(deps) {
 }
 
 // src/lib/skill-tool.ts
-import fs3 from "node:fs";
+import fs2 from "node:fs";
 import path2 from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
 var HOOK_KEY = "systematic_skill_tool_hooked";
@@ -223,13 +227,14 @@ ${systematicSkillsXml}`;
 }
 function wrapSkillContent(skillPath, content) {
   const skillDir = path2.dirname(skillPath);
-  const body = stripFrontmatter(content);
-  return `<skill_instruction>
+  const converted = convertContent(content, "skill", { source: "bundled" });
+  const body = stripFrontmatter(converted);
+  return `<skill-instruction>
 Base directory for this skill: ${skillDir}/
 File references (@path) in this skill are relative to this directory.
 
 ${body.trim()}
-</skill_instruction>`;
+</skill-instruction>`;
 }
 function createSkillTool(options) {
   const { bundledSkillsDir, disabledSkills } = options;
@@ -264,7 +269,7 @@ Use this when a task matches an available skill's description.`;
       const matchedSkill = skills.find((s) => s.name === normalizedName);
       if (matchedSkill) {
         try {
-          const content = fs3.readFileSync(matchedSkill.skillFile, "utf8");
+          const content = fs2.readFileSync(matchedSkill.skillFile, "utf8");
           const wrapped = wrapSkillContent(matchedSkill.skillFile, content);
           return `## Skill: systematic:${matchedSkill.name}
 
@@ -304,9 +309,9 @@ var packageJsonPath = path3.join(packageRoot, "package.json");
 var hasLoggedInit = false;
 var getPackageVersion = () => {
   try {
-    if (!fs4.existsSync(packageJsonPath))
+    if (!fs3.existsSync(packageJsonPath))
       return "unknown";
-    const content = fs4.readFileSync(packageJsonPath, "utf8");
+    const content = fs3.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(content);
     return parsed.version ?? "unknown";
   } catch {
@@ -318,14 +323,14 @@ var getBootstrapContent = (config) => {
     return null;
   if (config.bootstrap.file) {
     const customPath = config.bootstrap.file.startsWith("~/") ? path3.join(os2.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
-    if (fs4.existsSync(customPath)) {
-      return fs4.readFileSync(customPath, "utf8");
+    if (fs3.existsSync(customPath)) {
+      return fs3.readFileSync(customPath, "utf8");
     }
   }
   const usingSystematicPath = path3.join(bundledSkillsDir, "using-systematic/SKILL.md");
-  if (!fs4.existsSync(usingSystematicPath))
+  if (!fs3.existsSync(usingSystematicPath))
     return null;
-  const fullContent = fs4.readFileSync(usingSystematicPath, "utf8");
+  const fullContent = fs3.readFileSync(usingSystematicPath, "utf8");
   const content = stripFrontmatter(fullContent);
   const toolMapping = `**Tool Mapping for OpenCode:**
 When skills reference tools you don't have, substitute OpenCode equivalents:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "main": "./dist/index.js",