@fro.bot/systematic 2.13.3 → 2.14.1

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   loadConfig,
   loadConfigWithSources,
   parseFrontmatter
-} from "./index-3xnyeknn.js";
+} from "./index-7100fhg3.js";
 
 // src/index.ts
 import fs5 from "fs";
@@ -23,7 +23,115 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 // src/lib/bootstrap.ts
 import fs from "fs";
 import os from "os";
+import path2 from "path";
+
+// src/lib/skill-catalog.ts
+import { pathToFileURL } from "url";
+
+// src/lib/skill-loader.ts
 import path from "path";
+var SKILL_PREFIX = "systematic:";
+var SKILL_DESCRIPTION_PREFIX = "(Systematic - Skill) ";
+function formatSkillCommandName(name) {
+  if (name.includes(":")) {
+    return name;
+  }
+  return `${SKILL_PREFIX}${name}`;
+}
+function formatSkillDescription(description, fallbackName) {
+  const desc = description || `${fallbackName} skill`;
+  if (desc.startsWith(SKILL_DESCRIPTION_PREFIX)) {
+    return desc;
+  }
+  return `${SKILL_DESCRIPTION_PREFIX}${desc}`;
+}
+function wrapSkillTemplate(skillPath, body) {
+  const skillDir = path.dirname(skillPath);
+  return `<skill-instruction>
+Base directory for this skill: ${skillDir}/
+File references (@path) in this skill are relative to this directory.
+
+${body.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+}
+function extractSkillBody(wrappedTemplate) {
+  const match = wrappedTemplate.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
+  return match ? match[1].trim() : wrappedTemplate;
+}
+function loadSkill(skillInfo) {
+  try {
+    const converted = convertFileWithCache(skillInfo.skillFile, "skill", {
+      source: "bundled"
+    });
+    const { body } = parseFrontmatter(converted);
+    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body);
+    return {
+      name: skillInfo.name,
+      prefixedName: formatSkillCommandName(skillInfo.name),
+      description: formatSkillDescription(skillInfo.description, skillInfo.name),
+      path: skillInfo.path,
+      skillFile: skillInfo.skillFile,
+      wrappedTemplate,
+      disableModelInvocation: skillInfo.disableModelInvocation,
+      userInvocable: skillInfo.userInvocable,
+      subtask: skillInfo.subtask,
+      agent: skillInfo.agent,
+      model: skillInfo.model,
+      argumentHint: skillInfo.argumentHint
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/skill-catalog.ts
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildCatalogEntries(options) {
+  const { bundledSkillsDir, disabledSkills } = options;
+  return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).filter((s) => s.disableModelInvocation !== true).sort((a, b) => a.name.localeCompare(b.name)).map((s) => ({
+    name: s.name,
+    prefixedName: formatSkillCommandName(s.name),
+    description: s.description,
+    path: s.path,
+    skillFile: s.skillFile
+  }));
+}
+function renderCatalogVerbose(options) {
+  const entries = buildCatalogEntries(options);
+  if (entries.length === 0)
+    return "";
+  const skillLines = entries.flatMap((entry) => [
+    "  <skill>",
+    `    <name>${escapeXml(entry.prefixedName)}</name>`,
+    `    <description>${escapeXml(entry.description)}</description>`,
+    `    <location>${pathToFileURL(entry.path).href}</location>`,
+    "  </skill>"
+  ]);
+  return ["<available_skills>", ...skillLines, "</available_skills>"].join(`
+`);
+}
+function renderCatalogCompact(options) {
+  const entries = buildCatalogEntries(options);
+  const heading = "## Available Systematic Skills";
+  if (entries.length === 0) {
+    return `${heading}
+
+No Systematic skills are currently available.`;
+  }
+  const bullets = entries.map((entry) => `- ${entry.prefixedName}: ${entry.description}`).join(`
+`);
+  return `${heading}
+
+${bullets}`;
+}
+
+// src/lib/bootstrap.ts
 var INTERNAL_AGENT_SIGNATURES = [
   "You are a title generator",
   "You are a helpful AI assistant tasked with summarizing conversations",
@@ -31,48 +139,64 @@ var INTERNAL_AGENT_SIGNATURES = [
 ];
 var BOOTSTRAP_MARKER_OPEN = "<SYSTEMATIC_WORKFLOWS>";
 var BOOTSTRAP_MARKER_CLOSE = "</SYSTEMATIC_WORKFLOWS>";
-var findBootstrapMarkerBlock = (entry) => {
-  const start = entry.indexOf(BOOTSTRAP_MARKER_OPEN);
+var findBootstrapMarkerBlock = (entry, fromIndex = 0) => {
+  const start = entry.indexOf(BOOTSTRAP_MARKER_OPEN, fromIndex);
   if (start === -1)
     return null;
   const closeStart = entry.indexOf(BOOTSTRAP_MARKER_CLOSE, start + BOOTSTRAP_MARKER_OPEN.length);
   if (closeStart === -1)
     return null;
-  return { start, end: closeStart + BOOTSTRAP_MARKER_CLOSE.length };
+  return { start, closeStart, end: closeStart + BOOTSTRAP_MARKER_CLOSE.length };
+};
+var removeCompleteBootstrapBlocks = (entry) => {
+  const segments = [];
+  let cursor = 0;
+  let block = findBootstrapMarkerBlock(entry, cursor);
+  let hadNestedBlock = false;
+  while (block !== null) {
+    const nestedStart = entry.indexOf(BOOTSTRAP_MARKER_OPEN, block.start + BOOTSTRAP_MARKER_OPEN.length);
+    if (nestedStart !== -1 && nestedStart < block.closeStart) {
+      hadNestedBlock = true;
+      segments.push(entry.slice(cursor, nestedStart));
+      cursor = nestedStart;
+      block = findBootstrapMarkerBlock(entry, cursor);
+      continue;
+    }
+    segments.push(entry.slice(cursor, block.start));
+    cursor = block.end;
+    block = findBootstrapMarkerBlock(entry, cursor);
+  }
+  if (cursor === 0)
+    return entry;
+  segments.push(entry.slice(cursor));
+  const result = segments.join("");
+  if (hadNestedBlock) {
+    return removeCompleteBootstrapBlocks(result);
+  }
+  return result;
 };
 var applyBootstrapContent = (output, content) => {
   for (let i = 0;i < output.system.length; i++) {
-    const entry = output.system[i];
-    const block = findBootstrapMarkerBlock(entry);
-    if (block !== null) {
-      output.system[i] = entry.slice(0, block.start) + content + entry.slice(block.end);
-      return;
-    }
+    output.system[i] = removeCompleteBootstrapBlocks(output.system[i]);
   }
-  if (output.system.length > 0) {
-    output.system[output.system.length - 1] += `
-
-${content}`;
-  } else {
+  if (output.system.length === 0) {
     output.system.push(content);
+    return;
   }
-};
-function getToolMappingTemplate() {
-  return `**Tool Mapping for OpenCode:**
-When skills reference tools you don't have, substitute OpenCode equivalents:
-- \`TodoWrite\` \u2192 \`todowrite\`
-- \`Task\` tool with subagents \u2192 Use OpenCode's subagent system (@mention)
-- \`Skill\` tool \u2192 OpenCode's native \`skill\` tool
-- \`SystematicSkill\` tool \u2192 \`systematic_skill\` (Systematic plugin skills)
-- \`Read\`, \`Write\`, \`Edit\`, \`Bash\` \u2192 Your native tools
+  const first = output.system[0];
+  output.system[0] = first.length > 0 ? `${first}
 
-**Skills naming:**
-- Bundled skills use the \`systematic:\` prefix (e.g., \`systematic:brainstorming\`)
+${content}` : content;
+};
+function getSkillUsageTemplate() {
+  return `**Skills naming:**
+- Systematic bundled skills use the \`systematic:\` prefix (e.g., \`systematic:setup\`)
+- Workflow skills with their own namespace keep it (e.g., \`ce:brainstorm\`)
 - Skills can also be invoked without prefix if unambiguous
 
 **Skills usage:**
 - Use \`systematic_skill\` to load Systematic bundled skills
-- Use the native \`skill\` tool for non-Systematic skills
+- Use the \`skill\` tool for non-Systematic skills
 
 **Skills location:**
 Bundled skills ship with the Systematic plugin and are discoverable via \`systematic_skill\`.`;
@@ -82,40 +206,47 @@ function getBootstrapContent(config, deps) {
   if (!config.bootstrap.enabled)
     return null;
   if (config.bootstrap.file) {
-    const customPath = config.bootstrap.file.startsWith("~/") ? path.join(os.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
+    const customPath = config.bootstrap.file.startsWith("~/") ? path2.join(os.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
     if (fs.existsSync(customPath)) {
       return fs.readFileSync(customPath, "utf8");
     }
   }
-  const usingSystematicPath = path.join(bundledSkillsDir, "using-systematic/SKILL.md");
+  const usingSystematicPath = path2.join(bundledSkillsDir, "using-systematic/SKILL.md");
   if (!fs.existsSync(usingSystematicPath))
     return null;
   const fullContent = fs.readFileSync(usingSystematicPath, "utf8");
   const { body } = parseFrontmatter(fullContent);
   const content = body.trim();
-  const toolMapping = getToolMappingTemplate();
+  const skillUsage = getSkillUsageTemplate();
+  const catalog = renderCatalogVerbose({
+    bundledSkillsDir,
+    disabledSkills: config.disabled_skills
+  });
+  const catalogSection = catalog.length > 0 ? `
+
+${catalog}` : "";
   return `<SYSTEMATIC_WORKFLOWS>
-You have access to structured engineering workflows via the systematic plugin.
+You have access to structured engineering workflows via the Systematic plugin.
 
 **IMPORTANT: The using-systematic skill content is included below. It is ALREADY LOADED - you are currently following it. Do NOT use the systematic_skill tool to load "using-systematic" again - that would be redundant.**
 
 ${content}
 
-${toolMapping}
+${skillUsage}${catalogSection}
 </SYSTEMATIC_WORKFLOWS>`;
 }
 
 // src/lib/agent-overlays.ts
 import fs2 from "fs";
-import path3 from "path";
+import path4 from "path";
 
 // src/lib/source-model-defaults.ts
-import * as path2 from "path";
+import * as path3 from "path";
 import { fileURLToPath } from "url";
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var packageRoot = path2.resolve(__dirname2, "..", "..");
-var bundledAgentsDir = path2.join(packageRoot, "agents");
+var __dirname2 = path3.dirname(__filename2);
+var packageRoot = path3.resolve(__dirname2, "..", "..");
+var bundledAgentsDir = path3.join(packageRoot, "agents");
 var ProviderID = exports_external.union([
   exports_external.literal("vercel"),
   exports_external.literal("opencode"),
@@ -325,14 +456,14 @@ function buildBundledAgentInventory(agentsDir, disabledAgents) {
   const stemCategories = new Map;
   const disabledSet = new Set(disabledAgents);
   for (const category of categories) {
-    for (const fileName of readMarkdownFiles(path3.join(agentsDir, category))) {
+    for (const fileName of readMarkdownFiles(path4.join(agentsDir, category))) {
       const key = fileName.replace(/\.md$/, "");
       const id = `${category}/${key}`;
       agentsByQualifiedId[id] = {
         id,
         key,
         category,
-        file: path3.join(agentsDir, category, fileName),
+        file: path4.join(agentsDir, category, fileName),
         disabled: disabledSet.has(key) || disabledSet.has(id)
       };
       const existing = stemCategories.get(key) ?? [];
@@ -496,7 +627,7 @@ function throwConfigError(sourcePath, keyPath, message) {
 import { createHash } from "crypto";
 import fs3 from "fs";
 import os2 from "os";
-import path4 from "path";
+import path5 from "path";
 function emptyAvailability() {
   return { status: "unknown", models: new Set };
 }
@@ -505,8 +636,8 @@ var DEFAULT_API_TIMEOUT_MS = 1500;
 var MODELS_JSON_FILENAME = "models.json";
 function resolveCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME?.trim();
-  const cacheBase = xdgCacheHome && path4.isAbsolute(xdgCacheHome) ? xdgCacheHome : path4.join(os2.homedir(), ".cache");
-  return path4.join(cacheBase, "opencode");
+  const cacheBase = xdgCacheHome && path5.isAbsolute(xdgCacheHome) ? xdgCacheHome : path5.join(os2.homedir(), ".cache");
+  return path5.join(cacheBase, "opencode");
 }
 function fastHash(input) {
   return createHash("sha1").update(input).digest("hex");
@@ -584,14 +715,14 @@ function readFallbackCache() {
   const cacheDir = resolveCacheDir();
   const openCodeModelsUrl = process.env.OPENCODE_MODELS_URL?.trim();
   if (openCodeModelsUrl) {
-    const urlDerivedPath = path4.join(cacheDir, `models-${fastHash(openCodeModelsUrl)}.json`);
+    const urlDerivedPath = path5.join(cacheDir, `models-${fastHash(openCodeModelsUrl)}.json`);
     const urlResult = readModelsFromCache(urlDerivedPath);
     if (urlResult !== null) {
       return { status: "cache", models: urlResult };
     }
     return emptyAvailability();
   }
-  const defaultPath = path4.join(cacheDir, MODELS_JSON_FILENAME);
+  const defaultPath = path5.join(cacheDir, MODELS_JSON_FILENAME);
   const defaultResult = readModelsFromCache(defaultPath);
   if (defaultResult !== null) {
     return { status: "cache", models: defaultResult };
@@ -642,66 +773,6 @@ async function getAvailableModels(client, options = {}) {
   };
 }
 
-// src/lib/skill-loader.ts
-import path5 from "path";
-var SKILL_PREFIX = "systematic:";
-var SKILL_DESCRIPTION_PREFIX = "(Systematic - Skill) ";
-function formatSkillCommandName(name) {
-  if (name.includes(":")) {
-    return name;
-  }
-  return `${SKILL_PREFIX}${name}`;
-}
-function formatSkillDescription(description, fallbackName) {
-  const desc = description || `${fallbackName} skill`;
-  if (desc.startsWith(SKILL_DESCRIPTION_PREFIX)) {
-    return desc;
-  }
-  return `${SKILL_DESCRIPTION_PREFIX}${desc}`;
-}
-function wrapSkillTemplate(skillPath, body) {
-  const skillDir = path5.dirname(skillPath);
-  return `<skill-instruction>
-Base directory for this skill: ${skillDir}/
-File references (@path) in this skill are relative to this directory.
-
-${body.trim()}
-</skill-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`;
-}
-function extractSkillBody(wrappedTemplate) {
-  const match = wrappedTemplate.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
-  return match ? match[1].trim() : wrappedTemplate;
-}
-function loadSkill(skillInfo) {
-  try {
-    const converted = convertFileWithCache(skillInfo.skillFile, "skill", {
-      source: "bundled"
-    });
-    const { body } = parseFrontmatter(converted);
-    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body);
-    return {
-      name: skillInfo.name,
-      prefixedName: formatSkillCommandName(skillInfo.name),
-      description: formatSkillDescription(skillInfo.description, skillInfo.name),
-      path: skillInfo.path,
-      skillFile: skillInfo.skillFile,
-      wrappedTemplate,
-      disableModelInvocation: skillInfo.disableModelInvocation,
-      userInvocable: skillInfo.userInvocable,
-      subtask: skillInfo.subtask,
-      agent: skillInfo.agent,
-      model: skillInfo.model,
-      argumentHint: skillInfo.argumentHint
-    };
-  } catch {
-    return null;
-  }
-}
-
 // src/lib/config-handler.ts
 function toTitleCase(name) {
   return name.split("-").map((segment) => segment.length > 0 ? segment.charAt(0).toUpperCase() + segment.slice(1) : segment).join("-");
@@ -1024,20 +1095,8 @@ function registerSkillsPaths(config, skillsDir) {
 // src/lib/skill-tool.ts
 import fs4 from "fs";
 import path6 from "path";
-import { pathToFileURL } from "url";
+import { pathToFileURL as pathToFileURL2 } from "url";
 import { tool } from "@opencode-ai/plugin/tool";
-function formatSkillsXml(skills) {
-  if (skills.length === 0)
-    return "";
-  const skillLines = skills.flatMap((skill) => [
-    "  <skill>",
-    `    <name>${formatSkillCommandName(skill.name)}</name>`,
-    `    <description>${skill.description}</description>`,
-    `    <location>${pathToFileURL(skill.path).href}</location>`,
-    "  </skill>"
-  ]);
-  return ["<available_skills>", ...skillLines, "</available_skills>"].join(" ");
-}
 function discoverSkillFiles(dir, limit = 10) {
   const files = [];
   function shouldSkipDirectory(name) {
@@ -1076,40 +1135,21 @@ function createSkillTool(options) {
   const getAllSkills = () => {
     return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).map((skillInfo) => loadSkill(skillInfo)).filter((s) => s !== null).sort((a, b) => a.name.localeCompare(b.name));
   };
-  const getDiscoverableSkills = () => {
-    return getAllSkills().filter((s) => s.disableModelInvocation !== true);
-  };
   const buildDescription = () => {
-    const skills = getDiscoverableSkills();
-    if (skills.length === 0) {
-      return "Load a skill to get detailed instructions for a specific task. No skills are currently available.";
-    }
-    const skillInfos = skills.map((s) => ({
-      name: s.name,
-      description: s.description,
-      path: s.path,
-      skillFile: s.skillFile
-    }));
-    const systematicXml = formatSkillsXml(skillInfos);
-    return [
-      "Load a specialized skill that provides domain-specific instructions and workflows.",
-      "",
-      "When you recognize that a task matches one of the available skills listed below, use this tool to load the full skill instructions.",
-      "",
-      "The skill will inject detailed instructions, workflows, and access to bundled resources (scripts, references, templates) into the conversation context.",
-      "",
-      'Tool output includes a `<skill_content name="...">` block with the loaded content.',
-      "",
-      "The following skills provide specialized sets of instructions for particular tasks.",
-      "Invoke this tool to load a skill when a task matches one of the available skills listed below:",
-      "",
-      systematicXml
-    ].join(`
-`);
+    const catalog = renderCatalogCompact({ bundledSkillsDir, disabledSkills });
+    return `Load a specialized skill that provides domain-specific instructions and workflows.
+
+When you recognize that a task matches one of the available skills listed below, use this tool to load the full skill instructions.
+
+The skill will inject detailed instructions, workflows, and access to bundled resources (scripts, references, templates) into the conversation context.
+
+Tool output includes a \`<skill_content name="...">\` block with the loaded content.
+
+${catalog}`;
   };
   const buildParameterHint = () => {
-    const skills = getDiscoverableSkills();
-    const examples = skills.slice(0, 3).map((s) => `'${s.prefixedName}'`).join(", ");
+    const entries = buildCatalogEntries({ bundledSkillsDir, disabledSkills });
+    const examples = entries.slice(0, 3).map((s) => `'${s.prefixedName}'`).join(", ");
     const hint = examples.length > 0 ? ` (e.g., ${examples}, ...)` : "";
     return `The name of the skill from available_skills${hint}`;
   };
@@ -1136,12 +1176,15 @@ function createSkillTool(options) {
       const skills = getAllSkills();
       const matchedSkill = skills.find((s) => s.name === normalizedName);
       if (!matchedSkill) {
-        const availableSystematic = getDiscoverableSkills().map((s) => s.prefixedName);
+        const availableSystematic = buildCatalogEntries({
+          bundledSkillsDir,
+          disabledSkills
+        }).map((s) => s.prefixedName);
         throw new Error(`Skill "${requestedName}" not found. Available systematic skills: ${availableSystematic.join(", ")}`);
       }
       const body = extractSkillBody(matchedSkill.wrappedTemplate);
       const dir = path6.dirname(matchedSkill.skillFile);
-      const base = pathToFileURL(dir).href;
+      const base = pathToFileURL2(dir).href;
       const files = discoverSkillFiles(dir);
       await context.ask({
         permission: "skill",

package/dist/lib/bootstrap.d.ts

@@ -1,9 +1,14 @@
 import type { SystematicConfig } from './config.js';
 export declare const INTERNAL_AGENT_SIGNATURES: string[];
 /**
- * Inject bootstrap content into the system prompt array, replacing any
- * existing `<SYSTEMATIC_WORKFLOWS>` block. Multi-load idempotency is via
- * the marker — most-recently-registered plugin wins under FIFO hook order.
+ * Inject bootstrap content into the system prompt array, placing exactly one
+ * canonical block at the end of `output.system[0]`.
+ *
+ * All complete `<SYSTEMATIC_WORKFLOWS>…</SYSTEMATIC_WORKFLOWS>` blocks are
+ * removed from every system entry first, then the current content is appended
+ * once to `output.system[0]`. Partial/malformed marker fragments are left
+ * untouched. This makes duplicate registration and prior last-entry placement
+ * converge to the new canonical location; later invocations win.
  *
  * Exported for test access — must NOT be re-exported from the plugin entry
  * point (src/index.ts) because OpenCode's plugin loader expects a single

package/dist/lib/skill-catalog.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Escape XML special characters (&, <, >) in text content.
+ * Quotes are not escaped because catalog names and descriptions are rendered
+ * as element text, not attribute values.
+ */
+export declare function escapeXml(text: string): string;
+export interface CatalogEntry {
+    name: string;
+    prefixedName: string;
+    description: string;
+    path: string;
+    skillFile: string;
+}
+export interface CatalogOptions {
+    bundledSkillsDir: string;
+    disabledSkills: string[];
+}
+/**
+ * Discovers and filters bundled Systematic skills into catalog entries.
+ * Excludes disabled skills and skills with disableModelInvocation === true.
+ * Returns entries sorted by name.
+ */
+export declare function buildCatalogEntries(options: CatalogOptions): CatalogEntry[];
+/**
+ * Renders discoverable skills as native-style verbose XML for bootstrap content.
+ * Returns empty string when no skills are available.
+ */
+export declare function renderCatalogVerbose(options: CatalogOptions): string;
+/**
+ * Renders discoverable skills as a compact markdown list for tool descriptions.
+ * Always includes the heading; renders an explicit no-skills message when empty.
+ */
+export declare function renderCatalogCompact(options: CatalogOptions): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "2.13.3",
+  "version": "2.14.1",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "homepage": "https://fro.bot/systematic",
@@ -64,8 +64,8 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.15",
-    "@opencode-ai/plugin": "1.14.46",
-    "@opencode-ai/sdk": "1.14.46",
+    "@opencode-ai/plugin": "1.14.48",
+    "@opencode-ai/sdk": "1.14.48",
     "@types/bun": "latest",
     "@types/js-yaml": "4.0.9",
     "@types/node": "24.12.3",

package/skills/using-systematic/SKILL.md

@@ -13,7 +13,7 @@ This is not negotiable. This is not optional. You cannot rationalize your way ou
 
 ## How to Access Skills
 
-Use the `systematic_skill` tool for Systematic bundled skills. Use the native `skill` tool for non-Systematic skills. When you invoke a skill, its content is loaded and presented to you—follow it directly.
+Use the `systematic_skill` tool for Systematic bundled skills. Use the `skill` tool for non-Systematic skills. When you invoke a skill, its content is loaded and presented to you—follow it directly.
 
 # Using Skills
 
@@ -94,4 +94,4 @@ Instructions say WHAT, not HOW. "Add X" or "Fix Y" doesn't mean skip workflows.
 
 ## Skill Resolution
 
-Systematic bundled skills are listed in the `systematic_skill` tool description. Use the native `skill` tool for skills outside the Systematic plugin.
+Systematic bundled skills are listed in the `systematic_skill` tool description. Use the `skill` tool for skills outside the Systematic plugin.