@nano-step/skill-manager 4.0.0 → 5.0.0

package/dist/registry.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCatalog = loadCatalog;
+exports.getSkillManifest = getSkillManifest;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const chalk_1 = __importDefault(require("chalk"));
+function isValidManifest(data) {
+    if (typeof data !== "object" || data === null)
+        return false;
+    const obj = data;
+    return (typeof obj.name === "string" &&
+        typeof obj.version === "string" &&
+        typeof obj.description === "string");
+}
+async function loadCatalog(packageSkillsDir) {
+    const exists = await fs_extra_1.default.pathExists(packageSkillsDir);
+    if (!exists) {
+        return [];
+    }
+    const entries = await fs_extra_1.default.readdir(packageSkillsDir, { withFileTypes: true });
+    const catalog = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const manifestPath = path_1.default.join(packageSkillsDir, entry.name, "skill.json");
+        const manifestExists = await fs_extra_1.default.pathExists(manifestPath);
+        if (!manifestExists)
+            continue;
+        try {
+            const raw = await fs_extra_1.default.readFile(manifestPath, "utf8");
+            const data = JSON.parse(raw);
+            if (!isValidManifest(data)) {
+                console.error(chalk_1.default.yellow(`Warning: Skipping ${entry.name} — skill.json missing required fields (name, version, description)`));
+                continue;
+            }
+            catalog.push(data);
+        }
+        catch {
+            console.error(chalk_1.default.yellow(`Warning: Skipping ${entry.name} — failed to parse skill.json`));
+        }
+    }
+    return catalog.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function getSkillManifest(packageSkillsDir, name) {
+    const manifestPath = path_1.default.join(packageSkillsDir, name, "skill.json");
+    const exists = await fs_extra_1.default.pathExists(manifestPath);
+    if (!exists)
+        return null;
+    try {
+        const raw = await fs_extra_1.default.readFile(manifestPath, "utf8");
+        const data = JSON.parse(raw);
+        if (!isValidManifest(data))
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/state.d.ts

@@ -0,0 +1,4 @@
+import { ManagerState } from "./utils";
+export declare function loadState(stateFilePath: string): Promise<ManagerState>;
+export declare function saveState(stateFilePath: string, state: ManagerState): Promise<void>;
+export declare function migrateV4State(configDir: string, stateFilePath: string, skillsDir: string): Promise<void>;

package/dist/state.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.migrateV4State = migrateV4State;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("./utils");
+function createEmptyState() {
+    return { version: 1, managerVersion: utils_1.MANAGER_VERSION, skills: {} };
+}
+async function loadState(stateFilePath) {
+    const exists = await fs_extra_1.default.pathExists(stateFilePath);
+    if (!exists) {
+        return createEmptyState();
+    }
+    const data = await (0, utils_1.readJsonFile)(stateFilePath, createEmptyState());
+    return data;
+}
+async function saveState(stateFilePath, state) {
+    state.managerVersion = utils_1.MANAGER_VERSION;
+    await (0, utils_1.writeJsonFile)(stateFilePath, state);
+}
+async function migrateV4State(configDir, stateFilePath, skillsDir) {
+    const oldVersionFile = path_1.default.join(configDir, ".agent-skill-version.json");
+    const [oldExists, newExists] = await Promise.all([
+        fs_extra_1.default.pathExists(oldVersionFile),
+        fs_extra_1.default.pathExists(stateFilePath),
+    ]);
+    if (!oldExists || newExists) {
+        return;
+    }
+    console.log(chalk_1.default.cyan("Migrating from v4 state format..."));
+    const state = createEmptyState();
+    const skillPath = path_1.default.join(skillsDir, "skill-management", "SKILL.md");
+    const mcpSkillPath = path_1.default.join(skillsDir, "mcp-management", "SKILL.md");
+    const skillInstalled = await fs_extra_1.default.pathExists(skillPath) || await fs_extra_1.default.pathExists(mcpSkillPath);
+    if (skillInstalled) {
+        state.skills["skill-management"] = {
+            version: "1.0.0",
+            installedAt: new Date().toISOString(),
+            location: configDir.includes(".config/opencode") ? "global" : "project",
+        };
+    }
+    await (0, utils_1.writeJsonFile)(stateFilePath, state);
+    await fs_extra_1.default.remove(oldVersionFile);
+    console.log(chalk_1.default.green("Migration complete. State saved to .skill-manager.json"));
+}

package/dist/utils.d.ts

@@ -1,22 +1,33 @@
-export declare const PACKAGE_VERSION = "4.0.0";
-export declare const AGENT_ID = "mcp-manager";
-export declare const SKILL_DIR_NAME = "mcp-management";
+export declare const MANAGER_VERSION = "5.0.0";
+export interface SkillManifest {
+    name: string;
+    version: string;
+    description: string;
+    compatibility?: string;
+    agent?: {
+        id: string;
+        config: Record<string, unknown>;
+    } | null;
+    commands?: string[];
+    tags?: string[];
+}
+export interface InstalledSkillInfo {
+    version: string;
+    installedAt: string;
+    location: "global" | "project";
+}
+export interface ManagerState {
+    version: number;
+    managerVersion: string;
+    skills: Record<string, InstalledSkillInfo>;
+}
 export interface OpenCodePaths {
     configDir: string;
-    projectDir: string;
     commandDir: string;
     skillsDir: string;
     agentConfigPath: string;
-    versionFilePath: string;
-    templateSkillDir: string;
-    templateCommandPath: string;
-    templateAgentPath: string;
-}
-export interface InstallationState {
-    installedVersion: string | null;
-    skillInstalled: boolean;
-    commandInstalled: boolean;
-    agentInstalled: boolean;
+    stateFilePath: string;
+    packageSkillsDir: string;
 }
 export declare function detectOpenCodePaths(): Promise<OpenCodePaths>;
 export declare function ensureDirExists(dirPath: string): Promise<void>;
@@ -24,7 +35,3 @@ export declare function readJsonFile<T>(filePath: string, fallback: T): Promise<
 export declare function writeJsonFile(filePath: string, data: unknown): Promise<void>;
 export declare function readText(filePath: string): Promise<string>;
 export declare function writeText(filePath: string, data: string): Promise<void>;
-export declare function backupFile(filePath: string, suffix: string): Promise<string>;
-export declare function fileDiffersFromTemplate(filePath: string, templatePath: string): Promise<boolean>;
-export declare function directoryDiffersFromTemplate(dirPath: string, templateDir: string): Promise<boolean>;
-export declare function getInstallationState(paths: OpenCodePaths): Promise<InstallationState>;

package/dist/utils.js

@@ -3,23 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SKILL_DIR_NAME = exports.AGENT_ID = exports.PACKAGE_VERSION = void 0;
+exports.MANAGER_VERSION = void 0;
 exports.detectOpenCodePaths = detectOpenCodePaths;
 exports.ensureDirExists = ensureDirExists;
 exports.readJsonFile = readJsonFile;
 exports.writeJsonFile = writeJsonFile;
 exports.readText = readText;
 exports.writeText = writeText;
-exports.backupFile = backupFile;
-exports.fileDiffersFromTemplate = fileDiffersFromTemplate;
-exports.directoryDiffersFromTemplate = directoryDiffersFromTemplate;
-exports.getInstallationState = getInstallationState;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-exports.PACKAGE_VERSION = "4.0.0";
-exports.AGENT_ID = "mcp-manager";
-exports.SKILL_DIR_NAME = "mcp-management";
+exports.MANAGER_VERSION = "5.0.0";
 async function detectOpenCodePaths() {
     const homeConfig = path_1.default.join(os_1.default.homedir(), ".config", "opencode");
     const cwd = process.cwd();
@@ -30,24 +24,13 @@ async function detectOpenCodePaths() {
         throw new Error("OpenCode config not found. Expected ~/.config/opencode or .opencode in project.");
     }
     const configDir = hasProjectConfig ? projectConfig : homeConfig;
-    const commandDir = path_1.default.join(configDir, "command");
-    const skillsDir = path_1.default.join(configDir, "skills");
-    const agentConfigPath = path_1.default.join(configDir, "oh-my-opencode.json");
-    const packageRoot = path_1.default.join(__dirname, "..");
-    const templateSkillDir = path_1.default.join(packageRoot, "templates", "skill");
-    const templateCommandPath = path_1.default.join(packageRoot, "templates", "command-refresh.md");
-    const templateAgentPath = path_1.default.join(packageRoot, "templates", "agent.json");
-    const versionFilePath = path_1.default.join(configDir, ".agent-skill-version.json");
     return {
         configDir,
-        projectDir: cwd,
-        commandDir,
-        skillsDir,
-        agentConfigPath,
-        versionFilePath,
-        templateSkillDir,
-        templateCommandPath,
-        templateAgentPath,
+        commandDir: path_1.default.join(configDir, "command"),
+        skillsDir: path_1.default.join(configDir, "skills"),
+        agentConfigPath: path_1.default.join(configDir, "oh-my-opencode.json"),
+        stateFilePath: path_1.default.join(configDir, ".skill-manager.json"),
+        packageSkillsDir: path_1.default.join(__dirname, "..", "skills"),
     };
 }
 async function ensureDirExists(dirPath) {
@@ -70,85 +53,3 @@ async function readText(filePath) {
 async function writeText(filePath, data) {
     await fs_extra_1.default.writeFile(filePath, data, "utf8");
 }
-async function backupFile(filePath, suffix) {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const backupPath = `${filePath}.${suffix}-${timestamp}.bak`;
-    await fs_extra_1.default.copy(filePath, backupPath);
-    return backupPath;
-}
-async function fileDiffersFromTemplate(filePath, templatePath) {
-    const exists = await fs_extra_1.default.pathExists(filePath);
-    if (!exists) {
-        return false;
-    }
-    const [current, template] = await Promise.all([readText(filePath), readText(templatePath)]);
-    return current.trim() !== template.trim();
-}
-async function listFilesRecursively(dirPath, baseDir) {
-    const entries = await fs_extra_1.default.readdir(dirPath, { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-        const fullPath = path_1.default.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...(await listFilesRecursively(fullPath, baseDir)));
-        }
-        else if (entry.isFile()) {
-            files.push(path_1.default.relative(baseDir, fullPath));
-        }
-    }
-    return files;
-}
-async function directoryDiffersFromTemplate(dirPath, templateDir) {
-    const [dirExists, templateExists] = await Promise.all([
-        fs_extra_1.default.pathExists(dirPath),
-        fs_extra_1.default.pathExists(templateDir),
-    ]);
-    if (!dirExists) {
-        return false;
-    }
-    if (!templateExists) {
-        return true;
-    }
-    const [currentFiles, templateFiles] = await Promise.all([
-        listFilesRecursively(dirPath, dirPath),
-        listFilesRecursively(templateDir, templateDir),
-    ]);
-    currentFiles.sort();
-    templateFiles.sort();
-    if (currentFiles.length !== templateFiles.length) {
-        return true;
-    }
-    for (let index = 0; index < currentFiles.length; index += 1) {
-        if (currentFiles[index] !== templateFiles[index]) {
-            return true;
-        }
-    }
-    for (const relativePath of currentFiles) {
-        const [currentBuffer, templateBuffer] = await Promise.all([
-            fs_extra_1.default.readFile(path_1.default.join(dirPath, relativePath)),
-            fs_extra_1.default.readFile(path_1.default.join(templateDir, relativePath)),
-        ]);
-        if (!currentBuffer.equals(templateBuffer)) {
-            return true;
-        }
-    }
-    return false;
-}
-async function getInstallationState(paths) {
-    const skillPath = path_1.default.join(paths.skillsDir, exports.SKILL_DIR_NAME, "SKILL.md");
-    const commandPath = path_1.default.join(paths.commandDir, "agent-skill-refresh.md");
-    const [versionData, skillInstalled, commandInstalled] = await Promise.all([
-        readJsonFile(paths.versionFilePath, {}),
-        fs_extra_1.default.pathExists(skillPath),
-        fs_extra_1.default.pathExists(commandPath),
-    ]);
-    const agentConfig = await readJsonFile(paths.agentConfigPath, {});
-    const agents = agentConfig.agents;
-    const agentInstalled = agents ? Object.prototype.hasOwnProperty.call(agents, exports.AGENT_ID) : false;
-    return {
-        installedVersion: typeof versionData.version === "string" ? versionData.version : null,
-        skillInstalled,
-        commandInstalled,
-        agentInstalled,
-    };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nano-step/skill-manager",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "description": "CLI tool that installs and manages AI agent skills, MCP tool routing, and workflow configurations.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
   "files": [
     "bin",
     "dist",
-    "templates"
+    "skills"
   ],
   "scripts": {
     "build": "tsc",

package/skills/graphql-inspector/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: graphql-inspector
+description: >-
+  GraphQL schema inspection and query execution skill. Guides AI agents through
+  progressive schema discovery — scan first, drill down second, execute last.
+  Enforces read-only by default with token-efficient workflows.
+compatibility: "OpenCode with graphql-tools MCP server"
+metadata:
+  author: kokorolx
+  version: "1.0.0"
+---
+
+# GraphQL Inspector Skill
+
+**Version**: 1.0.0 | **MCP Server**: `graphql-tools` | **Default Mode**: Read-Only
+
+## Overview
+
+This skill teaches AI agents the optimal workflow for exploring and querying GraphQL APIs via the `graphql-tools` MCP server. The core principle is **progressive disclosure** — start cheap, drill down only when needed.
+
+## When to Use This Skill
+
+| Trigger | Action |
+|---------|--------|
+| "What queries/mutations are available?" | `filter_queries` / `filter_mutations` with `detailed=false` |
+| "How do I call X query?" | `get_field_details` for args + return type |
+| "What fields does Type Y have?" | `get_type_details` |
+| "Run this query" | `execute_query` (read-only) |
+| "What does the schema look like?" | `filter_queries` + `filter_mutations` + `filter_types` (NOT `get_graphql_schema`) |
+
+## Golden Rule: Progressive Disclosure
+
+**NEVER start with `get_graphql_schema`.** It dumps the entire schema and wastes tokens.
+
+Follow this flow instead:
+
+```
+Step 1: SCAN (cheap, small payload)
+  filter_queries(detailed=false)    → list query names + descriptions
+  filter_mutations(detailed=false)  → list mutation names + descriptions
+
+Step 2: DRILL DOWN (only for fields you need)
+  get_field_details(field_name="targetField", operation_type="query")
+  → get arguments, return type, deprecation info
+
+Step 3: UNDERSTAND TYPES (only if return/input types are complex)
+  get_type_details(type_name="ComplexType")
+  → get fields, enums, interfaces
+  filter_types(kind="INPUT_OBJECT", search="CreateInput")
+  → find input types for mutations
+
+Step 4: EXECUTE (only after understanding the schema)
+  execute_query(query="query { ... }")
+  → run read-only query with known structure
+```
+
+## Available Tools
+
+### Inspection Tools (always available, all read-only)
+
+| Tool | Purpose | When to Use |
+|------|---------|-------------|
+| `filter_queries` | List available queries | **First step** — scan what's available |
+| `filter_mutations` | List available mutations | **First step** — scan what's available |
+| `filter_types` | List types by kind/search | Find INPUT_OBJECT types for mutation args |
+| `get_field_details` | Deep dive into one field | **Second step** — get args + return type |
+| `get_type_details` | Deep dive into one type | Understand complex return/input types |
+| `get_graphql_schema` | Full schema dump (SDL) | **Last resort only** — very large payload |
+
+### Execution Tools
+
+| Tool | Purpose | Availability |
+|------|---------|-------------|
+| `execute_query` | Run read-only GraphQL query | Always available |
+| `execute_mutation` | Run GraphQL mutation | Only when `ALLOW_MUTATIONS=true` |
+
+## Workflow Examples
+
+### Example 1: "What can I query?"
+
+```
+1. filter_queries(detailed=false)
+   → Returns: [{ name: "getUser", description: "Fetch user by ID" }, ...]
+
+2. Found interesting query "getUser", need args:
+   get_field_details(field_name="getUser", operation_type="query")
+   → Returns: args=[{name: "id", type: "ID!"}], return_type="User"
+
+3. Need to know User fields:
+   get_type_details(type_name="User")
+   → Returns: fields=[{name: "id"}, {name: "email"}, {name: "name"}, ...]
+
+4. Now execute with confidence:
+   execute_query(query="query { getUser(id: \"123\") { id name email } }")
+```
+
+### Example 2: "Find queries related to orders"
+
+```
+1. filter_queries(search="order", detailed=false)
+   → Returns matching queries with names + descriptions
+
+2. If need more detail on a specific one:
+   get_field_details(field_name="getOrderById", operation_type="query")
+```
+
+### Example 3: "What input does createUser mutation need?"
+
+```
+1. get_field_details(field_name="createUser", operation_type="mutation")
+   → Returns: args=[{name: "input", type: "CreateUserInput!"}]
+
+2. filter_types(kind="INPUT_OBJECT", search="CreateUserInput")
+   → Returns input type with all fields and their types
+```
+
+### Example 4: "Show me all enum types"
+
+```
+1. filter_types(kind="ENUM", detailed=true)
+   → Returns all enums with their values
+```
+
+## Common Parameters
+
+All tools accept these optional auth parameters:
+
+| Parameter | Description |
+|-----------|-------------|
+| `endpoint` | GraphQL endpoint URL (default from server config) |
+| `username` | Basic auth username |
+| `password` | Basic auth password |
+| `bearer_token` | Bearer token for auth |
+
+## Anti-Patterns (DO NOT)
+
+| Bad Practice | Why | Do Instead |
+|-------------|-----|------------|
+| Start with `get_graphql_schema` | Dumps entire schema, wastes tokens | `filter_queries(detailed=false)` |
+| Use `detailed=true` on first call | Returns args/types for ALL fields | `detailed=false` first, then `get_field_details` for specific fields |
+| Execute query without understanding schema | Likely wrong field names or args | Scan → drill down → execute |
+| Call `execute_mutation` without checking availability | Will error if mutations disabled | Check if tool is listed first |
+| Guess field names in queries | Will get GraphQL errors | Always inspect schema first |
+
+## Safety Model
+
+The server enforces 3 layers of protection:
+
+1. **Tool Listing**: `execute_mutation` is hidden when `ALLOW_MUTATIONS` is not set
+2. **Execution Guard**: `execute_mutation` rejects at runtime even if called directly
+3. **AST Validation**: GraphQL documents are parsed — operation type verified at AST level
+
+**Default is read-only.** Mutations require explicit `ALLOW_MUTATIONS=true` env var on the server.
+
+## Token Efficiency Tips
+
+- `filter_queries(detailed=false)` returns ~50 bytes per field vs ~500 bytes with `detailed=true`
+- Use `search` parameter to narrow results before drilling down
+- `get_field_details` for ONE field is cheaper than `filter_queries(detailed=true)` for ALL fields
+- Cache awareness: repeated calls to same endpoint use 5-minute server cache
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| "Unknown tool: execute_mutation" | Mutations disabled (default). Set `ALLOW_MUTATIONS=true` on server |
+| "Mutations are not allowed in read-only mode" | Query sent to `execute_query` contains a mutation. Use `execute_mutation` instead |
+| "Subscriptions are not supported" | Subscriptions are intentionally blocked |
+| Empty results from filter | Check endpoint is correct and accessible |
+| Auth errors | Verify credentials — try `get_graphql_schema` with auth params first |

package/skills/graphql-inspector/skill.json

@@ -0,0 +1,9 @@
+{
+  "name": "graphql-inspector",
+  "version": "1.0.0",
+  "description": "GraphQL schema inspection and query execution — progressive discovery workflow for token-efficient schema exploration",
+  "compatibility": "OpenCode with graphql-tools MCP server",
+  "agent": null,
+  "commands": [],
+  "tags": ["graphql", "schema", "inspection", "query"]
+}

package/{templates/skill → skills/skill-management}/SKILL.md

@@ -1,22 +1,22 @@
 ---
-name: agent-skill-management
+name: skill-management
 description: >-
-  Agent skill routing and execution. Enables efficient routing of MCP tools
+  Skill routing and execution. Enables efficient routing of tools
   with token-saving isolation. Uses semantic AI categorization to support ANY
-  MCP configuration. Cache at .opencode/agent-skill-tools.json for fast tool discovery.
+  tool configuration. Cache at .opencode/skill-tools.json for fast tool discovery.
 compatibility: "OpenCode with any MCP server"
 metadata:
-  author: Sisyphus
-  version: "4.0.0"
+  author: nano-step
+  version: "5.0.0"
 ---
 
-# Agent Skill Management Skill
+# Skill Management
 
-**Version**: 4.0.0 | **Architecture**: 3-Tier Progressive Disclosure | **Categorization**: Semantic AI
+**Version**: 5.0.0 | **Architecture**: 3-Tier Progressive Disclosure | **Categorization**: Semantic AI
 
 ## Overview
 
-This skill enables the agent-skill-manager agent to efficiently route and execute MCP (Model Context Protocol) tools. By isolating MCP tool definitions in a dedicated subagent context, we reduce main agent token usage by 80-95%.
+This skill enables the skill-manager agent to efficiently route and execute tools. By isolating tool definitions in a dedicated subagent context, we reduce main agent token usage by 80-95%.
 
 ## When to Use This Skill
 
@@ -32,7 +32,7 @@ This skill enables the agent-skill-manager agent to efficiently route and execut
 
 ### Tool Categories (AI-Generated)
 
-Categories are generated by `/agent-skill-refresh` using semantic AI analysis. Common categories include:
+Categories are generated by `/skill-refresh` using semantic AI analysis. Common categories include:
 
 | Category | Description | Example Tools |
 |----------|-------------|---------------|
@@ -42,7 +42,7 @@ Categories are generated by `/agent-skill-refresh` using semantic AI analysis. C
 | communication | Messaging, notifications | post_message, list_channels |
 | database | SQL queries, data operations | query, insert, update |
 
-**Note**: Your actual categories depend on your MCP configuration. Run `/agent-skill-refresh` to generate.
+**Note**: Your actual categories depend on your tool configuration. Run `/skill-refresh` to generate.
 
 ### Most Common Tools
 
@@ -79,7 +79,7 @@ Task received
 ├─ Explicit tool name mentioned?
 │  └─ YES → Use that tool directly
 │
-├─ Read .opencode/agent-skill-tools.json cache
+├─ Read .opencode/skill-tools.json cache
 │  └─ Match task keywords against category keywords
 │
 ├─ Multiple categories match?
@@ -156,13 +156,13 @@ Workflows enforce best practices by requiring prerequisite steps before tool exe
 
 ```bash
 # Add a workflow from template
-/agent-skill-workflow add --template database
+/skill-workflow add --template database
 
 # List active workflows
-/agent-skill-workflow list
+/skill-workflow list
 
 # Disable temporarily
-/agent-skill-workflow disable database-safe-query
+/skill-workflow disable database-safe-query
 ```
 
 ### Built-in Templates
@@ -185,16 +185,16 @@ Workflows enforce best practices by requiring prerequisite steps before tool exe
 
 ## Cache Usage
 
-**Location**: `.opencode/agent-skill-tools.json`
+**Location**: `.opencode/skill-tools.json`
 
 ### If Cache Exists
 1. Read and parse JSON (v2.0.0 schema)
 2. Use `categories` for keyword-based routing
 3. Use `tools` map for O(1) tool lookup
-4. Check `generated_at` - if >24h old, suggest `/agent-skill-refresh`
+4. Check `generated_at` - if >24h old, suggest `/skill-refresh`
 
 ### If Cache Missing
-1. Inform user: "Run `/agent-skill-refresh` to create tool cache"
+1. Inform user: "Run `/skill-refresh` to create tool cache"
 2. Fall back to dynamic tool discovery (slower)
 
 **Full cache schema**: [tool-execution.md](references/tool-execution.md#cache-schema)
@@ -237,7 +237,7 @@ Workflows enforce best practices by requiring prerequisite steps before tool exe
 | Tool not found | Suggest similar tools |
 | Execution failed | Include context + retry suggestions |
 | Timeout | Report partial result + suggestions |
-| Cache missing | Prompt `/agent-skill-refresh` |
+| Cache missing | Prompt `/skill-refresh` |
 
 **Full recovery procedures**: [error-handling.md](references/error-handling.md)
 

package/{templates/command-refresh.md → skills/skill-management/skill-refresh.md}

@@ -1,10 +1,10 @@
-# /agent-skill-refresh
+# /skill-refresh
 
-Re-index and categorize all available MCP tools for intelligent routing.
+Re-index and categorize all available tools for intelligent routing.
 
 ## Purpose
 
-Create a semantic tool index in `.opencode/agent-skill-tools.json` by analyzing **all available tools** in the current agent context. Categorization is AI-only and based on tool names + descriptions (no prefixes).
+Create a semantic tool index in `.opencode/skill-tools.json` by analyzing **all available tools** in the current agent context. Categorization is AI-only and based on tool names + descriptions (no prefixes).
 
 ## When to Run
 
@@ -15,10 +15,10 @@ Create a semantic tool index in `.opencode/agent-skill-tools.json` by analyzing
 
 ## Auto-Refresh Triggers
 
-The agent-skill-manager will suggest running `/agent-skill-refresh` automatically when:
+The skill-manager will suggest running `/skill-refresh` automatically when:
 
 - **Tool not found**: A requested tool doesn't exist in the cache
-- **Cache missing**: The `.opencode/agent-skill-tools.json` file doesn't exist
+- **Cache missing**: The `.opencode/skill-tools.json` file doesn't exist
 - **Cache stale**: The cache is older than 24 hours
 - **Tool count mismatch**: Available tools differ from cached count
 
@@ -59,7 +59,7 @@ Output as JSON.
 
 ### Step 3: Write Cache File (v2.0.0)
 
-Write `.opencode/agent-skill-tools.json` with this schema:
+Write `.opencode/skill-tools.json` with this schema:
 
 ```json
 {
@@ -86,7 +86,7 @@ Write `.opencode/agent-skill-tools.json` with this schema:
 ### Step 4: Report Summary
 
 ```
-Agent Skill Tools Index Refreshed:
+Skill Tools Index Refreshed:
 
 Categories:
   - browser-automation: 25 tools
@@ -96,5 +96,5 @@ Categories:
 Summary:
   - Total tools: 75
   - Categories: 3
-  - Cache: .opencode/agent-skill-tools.json
+  - Cache: .opencode/skill-tools.json
 ```