@fro.bot/systematic 2.14.0 → 2.14.2

package/README.md

@@ -402,7 +402,7 @@ The plugin exposes one tool to OpenCode:
 |------|-------------|
 | `systematic_skill` | Load Systematic bundled skills by name. Lists available skills in its description and returns formatted skill content when invoked. |
 
-For non-Systematic skills (project or user-level), use OpenCode's native `skill` tool.
+For non-Systematic skills (project or user-level), use OpenCode's `skill` tool.
 
 ## How It Works
 

package/dist/index.js

@@ -188,22 +188,15 @@ var applyBootstrapContent = (output, content) => {
 
 ${content}` : content;
 };
-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
-
-**Skills naming:**
-- Bundled skills use the \`systematic:\` prefix (e.g., \`systematic:brainstorming\`)
+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\`.`;
@@ -224,7 +217,7 @@ function getBootstrapContent(config, deps) {
   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
@@ -233,13 +226,13 @@ function getBootstrapContent(config, deps) {
 
 ${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}${catalogSection}
+${skillUsage}${catalogSection}
 </SYSTEMATIC_WORKFLOWS>`;
 }
 
@@ -781,6 +774,28 @@ async function getAvailableModels(client, options = {}) {
 }
 
 // src/lib/config-handler.ts
+function isSystematicAgentConfig(agent) {
+  const description = agent?.description;
+  return typeof description === "string" && /\(.* - Systematic\)$/.test(description);
+}
+function isSystematicCommandConfig(command) {
+  const description = command?.description;
+  return typeof description === "string" && (description.startsWith("(Systematic) ") || description.startsWith("(Systematic - Skill) "));
+}
+function mergeSystematicEntries(existing, emitted, shouldDropExisting) {
+  const merged = { ...existing ?? {} };
+  for (const [key, value] of Object.entries(existing ?? {})) {
+    if (shouldDropExisting(key, value)) {
+      delete merged[key];
+    }
+  }
+  for (const [key, value] of Object.entries(emitted)) {
+    if (Object.hasOwn(merged, key))
+      continue;
+    merged[key] = value;
+  }
+  return merged;
+}
 function toTitleCase(name) {
   return name.split("-").map((segment) => segment.length > 0 ? segment.charAt(0).toUpperCase() + segment.slice(1) : segment).join("-");
 }
@@ -919,30 +934,37 @@ function applyAgentOverlays(config, agentInfo, overlays, availabilitySet) {
     addPermissionRules(permissionRules, config.permission);
   }
   result.temperature = inferBuiltInTemperature(agentInfo.name, result.description);
-  if (agentInfo.category && availabilitySet !== undefined) {
-    const resolved = resolveSourceModel(agentInfo.category, availabilitySet);
-    result.model = `${resolved.provider}/${resolved.model}`;
-    if (resolved.variant !== undefined) {
-      result.variant = resolved.variant;
-    } else {
-      delete result.variant;
-    }
-  }
-  if (categoryOverlay) {
-    applyOverlayObjectWithVariantClearing(result, categoryOverlay.value, permissionRules);
-  }
-  if (exactOverlay) {
-    applyOverlayObjectWithVariantClearing(result, exactOverlay.value, permissionRules);
+  applySourceModelDefault(result, agentInfo, availabilitySet);
+  applyAgentOverlay(result, categoryOverlay?.value, permissionRules);
+  applyAgentOverlay(result, exactOverlay?.value, permissionRules);
+  applyPermissionOverlay(result, permissionRules, hasPermissionOverlay);
+  return result;
+}
+function applySourceModelDefault(target, agentInfo, availabilitySet) {
+  if (!agentInfo.category || availabilitySet === undefined)
+    return;
+  const resolved = resolveSourceModel(agentInfo.category, availabilitySet);
+  target.model = `${resolved.provider}/${resolved.model}`;
+  if (resolved.variant !== undefined) {
+    target.variant = resolved.variant;
+  } else {
+    delete target.variant;
   }
-  if (hasPermissionOverlay) {
-    const permission = permissionFromRules(permissionRules);
-    if (permission) {
-      result.permission = permission;
-    } else {
-      delete result.permission;
-    }
+}
+function applyAgentOverlay(target, overlay, permissionRules) {
+  if (overlay === undefined)
+    return;
+  applyOverlayObjectWithVariantClearing(target, overlay, permissionRules);
+}
+function applyPermissionOverlay(target, permissionRules, hasPermissionOverlay) {
+  if (!hasPermissionOverlay)
+    return;
+  const permission = permissionFromRules(permissionRules);
+  if (permission) {
+    target.permission = permission;
+  } else {
+    delete target.permission;
   }
-  return result;
 }
 function overlayControlsPermission(overlay) {
   return overlay !== undefined && (Object.hasOwn(overlay, "permission") || Object.hasOwn(overlay, "skills"));
@@ -1062,6 +1084,7 @@ function createConfigHandler(deps) {
     const { config: systematicConfig, overlays } = loadConfigWithSources(directory);
     const existingAgents = { ...config.agent ?? {} };
     const existingCommands = { ...config.command ?? {} };
+    const nativeAgents = Object.fromEntries(Object.entries(existingAgents).filter(([, agent]) => !isSystematicAgentConfig(agent)));
     const bundledSkills = collectSkillsAsCommands(bundledSkillsDir, systematicConfig.disabled_skills);
     const enabledSkillNames = collectEnabledSkillNames(bundledSkillsDir, systematicConfig.disabled_skills);
     const inventory = buildBundledAgentInventory(bundledAgentsDir2, systematicConfig.disabled_agents);
@@ -1069,35 +1092,46 @@ function createConfigHandler(deps) {
     const validatedOverlays = validateAgentOverlays({
       inventory,
       overlays,
-      nativeAgents: existingAgents,
+      nativeAgents,
       enabledSkills: enabledSkillNames
     });
     const resolvedOverlays = resolveAgentOverlaySet(validatedOverlays);
     const availability = deps.client ? await getAvailableModels(deps.client) : undefined;
     const availabilitySet = availability && availability.status !== "unknown" ? availability.models : undefined;
-    const bundledAgents = collectAgents(bundledAgentsDir2, systematicConfig.disabled_agents, existingAgents, resolvedOverlays, availabilitySet);
+    const bundledAgents = collectAgents(bundledAgentsDir2, systematicConfig.disabled_agents, nativeAgents, resolvedOverlays, availabilitySet);
     const bundledCommands = collectCommands(bundledCommandsDir, systematicConfig.disabled_commands);
-    config.agent = {
-      ...bundledAgents,
-      ...existingAgents
-    };
-    config.command = {
-      ...bundledCommands,
-      ...bundledSkills,
-      ...existingCommands
-    };
+    const bundledAgentKeys = new Set(Object.keys(bundledAgents));
+    config.agent = mergeSystematicEntries(existingAgents, bundledAgents, (key, agent) => bundledAgentKeys.has(key) && isSystematicAgentConfig(agent));
+    const emittedCommands = { ...bundledCommands, ...bundledSkills };
+    const emittedCommandKeys = new Set(Object.keys(emittedCommands));
+    config.command = mergeSystematicEntries(existingCommands, emittedCommands, (key, command) => isSystematicCommandConfig(command) && (emittedCommandKeys.has(key) || isSystematicOwnedCommandKey(key)));
     registerSkillsPaths(config, bundledSkillsDir);
   };
 }
 function registerSkillsPaths(config, skillsDir) {
   const extended = config;
   const paths = extended.skills?.paths ?? [];
-  const nextPaths = paths.includes(skillsDir) ? [...paths] : [...paths, skillsDir];
+  const nextPaths = removeSystematicSkillPaths(paths);
+  if (!nextPaths.includes(skillsDir))
+    nextPaths.push(skillsDir);
   extended.skills = {
     ...extended.skills,
     paths: nextPaths
   };
 }
+function removeSystematicSkillPaths(paths) {
+  return paths.filter((path6) => !isSystematicSkillPath(path6));
+}
+function isSystematicSkillPath(path6) {
+  const normalizedPath = normalizePath(path6);
+  return normalizedPath.endsWith("/.config/opencode/systematic/skills") || normalizedPath.endsWith("/.cache/opencode/systematic/skills") || normalizedPath.endsWith("/.local/share/opencode/systematic/skills") || normalizedPath.endsWith("/.opencode/systematic/skills") || /(?:^|\/)\.cache\/opencode\/packages\/@fro\.bot\/systematic@[^/]+\/node_modules\/@fro\.bot\/systematic\/skills(?:$|\/)/u.test(normalizedPath);
+}
+function normalizePath(path6) {
+  return path6.replaceAll("\\", "/").replace(/\/+$/u, "");
+}
+function isSystematicOwnedCommandKey(key) {
+  return key.startsWith("systematic:") || key.startsWith("ce:");
+}
 
 // src/lib/skill-tool.ts
 import fs4 from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "2.14.0",
+  "version": "2.14.2",
   "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.47",
-    "@opencode-ai/sdk": "1.14.47",
+    "@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.