@omnidev-ai/cli 0.13.4 → 0.14.0

package/dist/index.js

@@ -64,18 +64,25 @@ function parseFrontmatterWithMarkdown(content) {
 // ../core/src/capability/commands.ts
 import { existsSync, readdirSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { basename, join } from "node:path";
 async function loadCommands(capabilityPath, capabilityId) {
-  const commandsDir = join2(capabilityPath, "commands");
-  if (!existsSync(commandsDir)) {
-    return [];
-  }
   const commands = [];
-  const entries = readdirSync(commandsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const commandPath = join2(commandsDir, entry.name, "COMMAND.md");
-      if (existsSync(commandPath)) {
+  const possibleDirNames = ["commands", "command"];
+  for (const dirName of possibleDirNames) {
+    const dir = join(capabilityPath, dirName);
+    if (!existsSync(dir)) {
+      continue;
+    }
+    const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const commandPath = join(dir, entry.name, "COMMAND.md");
+        if (existsSync(commandPath)) {
+          const command = await parseCommandFile(commandPath, capabilityId);
+          commands.push(command);
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const commandPath = join(dir, entry.name);
         const command = await parseCommandFile(commandPath, capabilityId);
         commands.push(command);
       }
@@ -91,11 +98,13 @@ async function parseCommandFile(filePath, capabilityId) {
   }
   const frontmatter = parsed.frontmatter;
   const prompt = parsed.markdown;
-  if (!frontmatter.name || !frontmatter.description) {
+  const inferredName = basename(filePath, ".md").replace(/^COMMAND$/i, "");
+  const name = frontmatter.name || inferredName;
+  if (!name || !frontmatter.description) {
     throw new Error(`Invalid COMMAND.md at ${filePath}: name and description required`);
   }
   const result = {
-    name: frontmatter.name,
+    name,
     description: frontmatter.description,
     prompt: prompt.trim(),
     capabilityId
@@ -110,10 +119,10 @@ var init_commands = () => {};
 // ../core/src/capability/docs.ts
 import { existsSync as existsSync2, readdirSync as readdirSync2 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { basename, join as join3 } from "node:path";
+import { basename as basename2, join as join2 } from "node:path";
 async function loadDocs(capabilityPath, capabilityId) {
   const docs = [];
-  const definitionPath = join3(capabilityPath, "definition.md");
+  const definitionPath = join2(capabilityPath, "definition.md");
   if (existsSync2(definitionPath)) {
     const content = await readFile2(definitionPath, "utf-8");
     docs.push({
@@ -122,15 +131,15 @@ async function loadDocs(capabilityPath, capabilityId) {
       capabilityId
     });
   }
-  const docsDir = join3(capabilityPath, "docs");
+  const docsDir = join2(capabilityPath, "docs");
   if (existsSync2(docsDir)) {
     const entries = readdirSync2(docsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
-        const docPath = join3(docsDir, entry.name);
+        const docPath = join2(docsDir, entry.name);
         const content = await readFile2(docPath, "utf-8");
         docs.push({
-          name: basename(entry.name, ".md"),
+          name: basename2(entry.name, ".md"),
           content: content.trim(),
           capabilityId
         });
@@ -1057,6 +1066,151 @@ var init_parse = __esm(() => {
 });
 
 // ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/stringify.js
+function extendedTypeOf(obj) {
+  let type = typeof obj;
+  if (type === "object") {
+    if (Array.isArray(obj))
+      return "array";
+    if (obj instanceof Date)
+      return "date";
+  }
+  return type;
+}
+function isArrayOfTables(obj) {
+  for (let i = 0;i < obj.length; i++) {
+    if (extendedTypeOf(obj[i]) !== "object")
+      return false;
+  }
+  return obj.length != 0;
+}
+function formatString(s) {
+  return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+function stringifyValue(val, type, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  if (type === "number") {
+    if (isNaN(val))
+      return "nan";
+    if (val === Infinity)
+      return "inf";
+    if (val === -Infinity)
+      return "-inf";
+    if (numberAsFloat && Number.isInteger(val))
+      return val.toFixed(1);
+    return val.toString();
+  }
+  if (type === "bigint" || type === "boolean") {
+    return val.toString();
+  }
+  if (type === "string") {
+    return formatString(val);
+  }
+  if (type === "date") {
+    if (isNaN(val.getTime())) {
+      throw new TypeError("cannot serialize invalid date");
+    }
+    return val.toISOString();
+  }
+  if (type === "object") {
+    return stringifyInlineTable(val, depth, numberAsFloat);
+  }
+  if (type === "array") {
+    return stringifyArray(val, depth, numberAsFloat);
+  }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0)
+    return "{}";
+  let res = "{ ";
+  for (let i = 0;i < keys.length; i++) {
+    let k = keys[i];
+    if (i)
+      res += ", ";
+    res += BARE_KEY.test(k) ? k : formatString(k);
+    res += " = ";
+    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+  }
+  return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat) {
+  if (array.length === 0)
+    return "[]";
+  let res = "[ ";
+  for (let i = 0;i < array.length; i++) {
+    if (i)
+      res += ", ";
+    if (array[i] === null || array[i] === undefined) {
+      throw new TypeError("arrays cannot contain null or undefined values");
+    }
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+  }
+  return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let res = "";
+  for (let i = 0;i < array.length; i++) {
+    res += `${res && `
+`}[[${key}]]
+`;
+    res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+  }
+  return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i = 0;i < keys.length; i++) {
+    let k = keys[i];
+    if (obj[k] !== null && obj[k] !== undefined) {
+      let type = extendedTypeOf(obj[k]);
+      if (type === "symbol" || type === "function") {
+        throw new TypeError(`cannot serialize values of type '${type}'`);
+      }
+      let key = BARE_KEY.test(k) ? k : formatString(k);
+      if (type === "array" && isArrayOfTables(obj[k])) {
+        tables += (tables && `
+`) + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+      } else if (type === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && `
+`) + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+        preamble += `
+`;
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables))
+    preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1000, numbersAsFloat = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") {
+    throw new TypeError("stringify can only be called with an object");
+  }
+  let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+  if (str[str.length - 1] !== `
+`)
+    return str + `
+`;
+  return str;
+}
+var BARE_KEY;
 var init_stringify = __esm(() => {
   /*!
    * Copyright (c) Squirrel Chat et al., All rights reserved.
@@ -1085,6 +1239,7 @@ var init_stringify = __esm(() => {
    * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    */
+  BARE_KEY = /^[a-z0-9-_]+$/i;
 });
 
 // ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/index.js
@@ -1162,7 +1317,7 @@ var init_parser = __esm(() => {
 });
 
 // ../core/src/hooks/constants.ts
-var HOOK_EVENTS, MATCHER_EVENTS, PROMPT_HOOK_EVENTS, HOOK_TYPES, COMMON_TOOL_MATCHERS, NOTIFICATION_MATCHERS, SESSION_START_MATCHERS, PRE_COMPACT_MATCHERS, DEFAULT_COMMAND_TIMEOUT = 60, DEFAULT_PROMPT_TIMEOUT = 30, VARIABLE_MAPPINGS, HOOKS_CONFIG_FILENAME = "hooks.toml", HOOKS_DIRECTORY = "hooks";
+var HOOK_EVENTS, MATCHER_EVENTS, PROMPT_HOOK_EVENTS, HOOK_TYPES, COMMON_TOOL_MATCHERS, NOTIFICATION_MATCHERS, SESSION_START_MATCHERS, PRE_COMPACT_MATCHERS, DEFAULT_COMMAND_TIMEOUT = 60, DEFAULT_PROMPT_TIMEOUT = 30, VARIABLE_MAPPINGS, HOOKS_CONFIG_FILENAME = "hooks.toml", CLAUDE_HOOKS_CONFIG_FILENAME = "hooks.json", HOOKS_DIRECTORY = "hooks";
 var init_constants = __esm(() => {
   HOOK_EVENTS = [
     "PreToolUse",
@@ -1698,34 +1853,369 @@ function containsOmnidevVariables(content) {
   }
   return false;
 }
+function resolveCapabilityRoot(content, capabilityPath) {
+  let result = content;
+  const variables = ["OMNIDEV_CAPABILITY_ROOT", "CLAUDE_PLUGIN_ROOT"];
+  for (const varName of variables) {
+    result = result.replace(new RegExp(`\\$\\{${varName}\\}`, "g"), capabilityPath);
+    result = result.replace(new RegExp(`\\$${varName}(?![A-Za-z0-9_])`, "g"), capabilityPath);
+  }
+  return result;
+}
+function resolveCapabilityRootInConfig(config, capabilityPath) {
+  const result = {};
+  if (config.description !== undefined) {
+    result.description = config.description;
+  }
+  const events = [
+    "PreToolUse",
+    "PostToolUse",
+    "PermissionRequest",
+    "UserPromptSubmit",
+    "Stop",
+    "SubagentStop",
+    "Notification",
+    "SessionStart",
+    "SessionEnd",
+    "PreCompact"
+  ];
+  for (const event of events) {
+    const matchers = config[event];
+    if (matchers) {
+      result[event] = matchers.map((matcher) => ({
+        ...matcher,
+        hooks: matcher.hooks.map((hook) => {
+          if (hook.type === "command") {
+            return {
+              ...hook,
+              command: resolveCapabilityRoot(hook.command, capabilityPath)
+            };
+          }
+          if (hook.type === "prompt") {
+            return {
+              ...hook,
+              prompt: resolveCapabilityRoot(hook.prompt, capabilityPath)
+            };
+          }
+          return hook;
+        })
+      }));
+    }
+  }
+  return result;
+}
 var REVERSE_MAPPINGS;
 var init_variables = __esm(() => {
   init_constants();
   REVERSE_MAPPINGS = Object.fromEntries(Object.entries(VARIABLE_MAPPINGS).map(([omni, claude]) => [claude, omni]));
 });
 
-// ../core/src/hooks/loader.ts
+// ../core/src/hooks/json-loader.ts
 import { existsSync as existsSync4, readFileSync } from "node:fs";
-import { join as join4 } from "node:path";
+function loadHooksJson(configPath) {
+  const unknownFieldWarnings = [];
+  if (!existsSync4(configPath)) {
+    return {
+      config: createEmptyHooksConfig(),
+      validation: createEmptyValidationResult(),
+      found: false,
+      configPath,
+      unknownFieldWarnings: []
+    };
+  }
+  let rawContent;
+  try {
+    rawContent = readFileSync(configPath, "utf-8");
+  } catch (error) {
+    return {
+      config: createEmptyHooksConfig(),
+      validation: {
+        valid: false,
+        errors: [
+          {
+            severity: "error",
+            code: "HOOKS_INVALID_TOML",
+            message: `Failed to read hooks.json: ${error instanceof Error ? error.message : String(error)}`,
+            path: configPath
+          }
+        ],
+        warnings: []
+      },
+      found: true,
+      configPath,
+      loadError: `Failed to read: ${error instanceof Error ? error.message : String(error)}`,
+      unknownFieldWarnings: []
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawContent);
+  } catch (error) {
+    return {
+      config: createEmptyHooksConfig(),
+      validation: {
+        valid: false,
+        errors: [
+          {
+            severity: "error",
+            code: "HOOKS_INVALID_TOML",
+            message: `Invalid JSON syntax: ${error instanceof Error ? error.message : String(error)}`,
+            path: configPath
+          }
+        ],
+        warnings: []
+      },
+      found: true,
+      configPath,
+      loadError: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      unknownFieldWarnings: []
+    };
+  }
+  const result = convertClaudeHooksToConfig(parsed, unknownFieldWarnings);
+  return {
+    config: result.config,
+    validation: result.validation,
+    found: true,
+    configPath,
+    unknownFieldWarnings
+  };
+}
+function convertClaudeHooksToConfig(claudeHooks, unknownFieldWarnings) {
+  const config = {};
+  const errors = [];
+  const warnings = [];
+  if (typeof claudeHooks !== "object" || claudeHooks === null || Array.isArray(claudeHooks)) {
+    errors.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TOML",
+      message: "hooks.json must be an object"
+    });
+    return { config: createEmptyHooksConfig(), validation: { valid: false, errors, warnings } };
+  }
+  for (const [eventName, matchers] of Object.entries(claudeHooks)) {
+    if (!isHookEvent(eventName)) {
+      unknownFieldWarnings.push(`Unknown event "${eventName}" in hooks.json. Valid events: ${HOOK_EVENTS.join(", ")}`);
+      continue;
+    }
+    const event = eventName;
+    if (!Array.isArray(matchers)) {
+      errors.push({
+        severity: "error",
+        code: "HOOKS_INVALID_TOML",
+        event,
+        message: `${event} must be an array of matchers`
+      });
+      continue;
+    }
+    const convertedMatchers = [];
+    for (let i = 0;i < matchers.length; i++) {
+      const matcher = matchers[i];
+      if (!matcher)
+        continue;
+      if (typeof matcher === "object" && matcher !== null) {
+        for (const key of Object.keys(matcher)) {
+          if (!KNOWN_MATCHER_FIELDS.has(key)) {
+            unknownFieldWarnings.push(`Unknown field "${key}" in ${event}[${i}]. Known fields: ${[...KNOWN_MATCHER_FIELDS].join(", ")}`);
+          }
+        }
+      }
+      const convertedMatcher = convertMatcher(matcher, event, i, errors, unknownFieldWarnings);
+      if (convertedMatcher) {
+        convertedMatchers.push(convertedMatcher);
+      }
+    }
+    if (convertedMatchers.length > 0) {
+      config[event] = convertedMatchers;
+    }
+  }
+  return {
+    config,
+    validation: {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    }
+  };
+}
+function convertMatcher(matcher, event, matcherIndex, errors, unknownFieldWarnings) {
+  if (typeof matcher !== "object" || matcher === null || Array.isArray(matcher)) {
+    errors.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TOML",
+      event,
+      matcherIndex,
+      message: `Matcher at index ${matcherIndex} must be an object`
+    });
+    return null;
+  }
+  const hooks = [];
+  const hooksArray = matcher.hooks;
+  if (!hooksArray) {
+    errors.push({
+      severity: "error",
+      code: "HOOKS_INVALID_HOOKS_ARRAY",
+      event,
+      matcherIndex,
+      message: "Matcher must have a 'hooks' array"
+    });
+    return null;
+  }
+  if (!Array.isArray(hooksArray)) {
+    errors.push({
+      severity: "error",
+      code: "HOOKS_INVALID_HOOKS_ARRAY",
+      event,
+      matcherIndex,
+      message: "'hooks' must be an array"
+    });
+    return null;
+  }
+  for (let i = 0;i < hooksArray.length; i++) {
+    const hookEntry = hooksArray[i];
+    if (!hookEntry)
+      continue;
+    if (typeof hookEntry === "object" && hookEntry !== null) {
+      for (const key of Object.keys(hookEntry)) {
+        if (!KNOWN_HOOK_FIELDS.has(key)) {
+          unknownFieldWarnings.push(`Unknown field "${key}" in ${event}[${matcherIndex}].hooks[${i}]. Known fields: ${[...KNOWN_HOOK_FIELDS].join(", ")}`);
+        }
+      }
+    }
+    const hook = convertHook(hookEntry, event, matcherIndex, i, errors);
+    if (hook) {
+      hooks.push(hook);
+    }
+  }
+  if (hooks.length === 0) {
+    return null;
+  }
+  const result = { hooks };
+  if (matcher.matcher !== undefined) {
+    result.matcher = matcher.matcher;
+  }
+  return result;
+}
+function convertHook(hookEntry, event, matcherIndex, hookIndex, errors) {
+  if (typeof hookEntry !== "object" || hookEntry === null || Array.isArray(hookEntry)) {
+    errors.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TOML",
+      event,
+      matcherIndex,
+      hookIndex,
+      message: "Hook must be an object"
+    });
+    return null;
+  }
+  const hookType = hookEntry.type;
+  if (!hookType) {
+    errors.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TYPE",
+      event,
+      matcherIndex,
+      hookIndex,
+      message: "Hook must have a 'type' field"
+    });
+    return null;
+  }
+  if (!isHookType(hookType)) {
+    errors.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TYPE",
+      event,
+      matcherIndex,
+      hookIndex,
+      message: `Invalid hook type: "${hookType}". Must be "command" or "prompt"`
+    });
+    return null;
+  }
+  if (hookType === "command") {
+    if (typeof hookEntry.command !== "string") {
+      errors.push({
+        severity: "error",
+        code: "HOOKS_MISSING_COMMAND",
+        event,
+        matcherIndex,
+        hookIndex,
+        message: "Command hook must have a 'command' string field"
+      });
+      return null;
+    }
+    const hook = {
+      type: "command",
+      command: hookEntry.command
+    };
+    if (typeof hookEntry.timeout === "number") {
+      hook.timeout = hookEntry.timeout;
+    }
+    return hook;
+  }
+  if (hookType === "prompt") {
+    if (typeof hookEntry.prompt !== "string") {
+      errors.push({
+        severity: "error",
+        code: "HOOKS_MISSING_PROMPT",
+        event,
+        matcherIndex,
+        hookIndex,
+        message: "Prompt hook must have a 'prompt' string field"
+      });
+      return null;
+    }
+    const hook = {
+      type: "prompt",
+      prompt: hookEntry.prompt
+    };
+    if (typeof hookEntry.timeout === "number") {
+      hook.timeout = hookEntry.timeout;
+    }
+    return hook;
+  }
+  return null;
+}
+var KNOWN_HOOK_FIELDS, KNOWN_MATCHER_FIELDS;
+var init_json_loader = __esm(() => {
+  init_constants();
+  init_types();
+  init_validation();
+  KNOWN_HOOK_FIELDS = new Set(["type", "command", "prompt", "timeout"]);
+  KNOWN_MATCHER_FIELDS = new Set(["matcher", "hooks"]);
+});
+
+// ../core/src/hooks/loader.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
 function loadHooksFromCapability(capabilityPath, options) {
   const opts = {
     transformVariables: true,
     validate: true,
     checkScripts: false,
+    resolveCapabilityRoot: false,
     ...options
   };
-  const hooksDir = join4(capabilityPath, HOOKS_DIRECTORY);
-  const configPath = join4(hooksDir, HOOKS_CONFIG_FILENAME);
-  if (!existsSync4(configPath)) {
+  const hooksDir = join3(capabilityPath, HOOKS_DIRECTORY);
+  const tomlConfigPath = join3(hooksDir, HOOKS_CONFIG_FILENAME);
+  if (existsSync5(tomlConfigPath)) {
+    return loadTomlHooks(capabilityPath, tomlConfigPath, hooksDir, opts);
+  }
+  const hooksJsonInDir = join3(hooksDir, CLAUDE_HOOKS_CONFIG_FILENAME);
+  const hooksJsonAtRoot = join3(capabilityPath, CLAUDE_HOOKS_CONFIG_FILENAME);
+  const hooksJsonDirExists = existsSync5(hooksJsonInDir);
+  const hooksJsonRootExists = existsSync5(hooksJsonAtRoot);
+  if (!hooksJsonDirExists && !hooksJsonRootExists) {
     return {
       config: createEmptyHooksConfig(),
       validation: createEmptyValidationResult(),
       found: false
     };
   }
+  return loadJsonHooksFiles(capabilityPath, hooksJsonInDir, hooksJsonAtRoot, hooksDir, opts);
+}
+function loadTomlHooks(capabilityPath, configPath, hooksDir, opts) {
   let rawContent;
   try {
-    rawContent = readFileSync(configPath, "utf-8");
+    rawContent = readFileSync2(configPath, "utf-8");
   } catch (error) {
     return {
       config: createEmptyHooksConfig(),
@@ -1782,13 +2272,102 @@ function loadHooksFromCapability(capabilityPath, options) {
   } else {
     validation = createEmptyValidationResult();
   }
+  let config = validation.valid ? parsed : createEmptyHooksConfig();
+  if (opts.resolveCapabilityRoot && validation.valid) {
+    config = resolveCapabilityRootInConfig(config, capabilityPath);
+  }
   return {
-    config: validation.valid ? parsed : createEmptyHooksConfig(),
+    config,
     validation,
     found: true,
     configPath
   };
 }
+function loadJsonHooksFiles(capabilityPath, hooksJsonInDir, hooksJsonAtRoot, hooksDir, opts) {
+  const configs = [];
+  const allErrors = [];
+  const allWarnings = [];
+  const unknownFieldWarnings = [];
+  let foundPath;
+  if (existsSync5(hooksJsonInDir)) {
+    const result2 = loadHooksJson(hooksJsonInDir);
+    if (result2.found) {
+      foundPath = result2.configPath;
+      if (result2.loadError) {
+        allErrors.push(...result2.validation.errors);
+      } else {
+        configs.push(result2.config);
+        allErrors.push(...result2.validation.errors);
+        allWarnings.push(...result2.validation.warnings);
+      }
+      unknownFieldWarnings.push(...result2.unknownFieldWarnings);
+    }
+  }
+  if (existsSync5(hooksJsonAtRoot)) {
+    const result2 = loadHooksJson(hooksJsonAtRoot);
+    if (result2.found) {
+      if (!foundPath) {
+        foundPath = result2.configPath;
+      }
+      if (result2.loadError) {
+        allErrors.push(...result2.validation.errors);
+      } else {
+        configs.push(result2.config);
+        allErrors.push(...result2.validation.errors);
+        allWarnings.push(...result2.validation.warnings);
+      }
+      unknownFieldWarnings.push(...result2.unknownFieldWarnings);
+    }
+  }
+  for (const warning of unknownFieldWarnings) {
+    console.warn(`[hooks] Warning: ${warning}`);
+  }
+  let mergedConfig = createEmptyHooksConfig();
+  if (configs.length > 0) {
+    mergedConfig = mergeRawHooksConfigs(configs);
+  }
+  let validation;
+  if (opts.validate && allErrors.length === 0) {
+    validation = validateHooksConfig(mergedConfig, {
+      basePath: hooksDir,
+      checkScripts: opts.checkScripts ?? false
+    });
+  } else {
+    validation = {
+      valid: allErrors.length === 0,
+      errors: allErrors,
+      warnings: allWarnings
+    };
+  }
+  if (opts.resolveCapabilityRoot && validation.valid) {
+    mergedConfig = resolveCapabilityRootInConfig(mergedConfig, capabilityPath);
+  }
+  const result = {
+    config: validation.valid ? mergedConfig : createEmptyHooksConfig(),
+    validation,
+    found: true
+  };
+  if (foundPath) {
+    result.configPath = foundPath;
+  }
+  return result;
+}
+function mergeRawHooksConfigs(configs) {
+  const result = {};
+  for (const event of HOOK_EVENTS) {
+    const allMatchers = [];
+    for (const config of configs) {
+      const matchers = config[event];
+      if (matchers && matchers.length > 0) {
+        allMatchers.push(...matchers);
+      }
+    }
+    if (allMatchers.length > 0) {
+      result[event] = allMatchers;
+    }
+  }
+  return result;
+}
 function loadCapabilityHooks(capabilityName, capabilityPath, options) {
   const result = loadHooksFromCapability(capabilityPath, options);
   if (!result.found) {
@@ -1802,39 +2381,43 @@ function loadCapabilityHooks(capabilityName, capabilityPath, options) {
   };
 }
 function hasHooks(capabilityPath) {
-  const configPath = join4(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
-  return existsSync4(configPath);
+  const tomlPath = join3(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
+  const jsonInDir = join3(capabilityPath, HOOKS_DIRECTORY, CLAUDE_HOOKS_CONFIG_FILENAME);
+  const jsonAtRoot = join3(capabilityPath, CLAUDE_HOOKS_CONFIG_FILENAME);
+  return existsSync5(tomlPath) || existsSync5(jsonInDir) || existsSync5(jsonAtRoot);
 }
 function getHooksDirectory(capabilityPath) {
-  return join4(capabilityPath, HOOKS_DIRECTORY);
+  return join3(capabilityPath, HOOKS_DIRECTORY);
 }
 function getHooksConfigPath(capabilityPath) {
-  return join4(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
+  return join3(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
 }
 var init_loader = __esm(() => {
   init_dist();
   init_constants();
   init_validation();
   init_variables();
+  init_json_loader();
+  init_constants();
 });
 
 // ../core/src/capability/rules.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "node:fs";
 import { readFile as readFile3 } from "node:fs/promises";
-import { basename as basename2, join as join5 } from "node:path";
+import { basename as basename3, join as join4 } from "node:path";
 async function loadRules(capabilityPath, capabilityId) {
-  const rulesDir = join5(capabilityPath, "rules");
-  if (!existsSync5(rulesDir)) {
+  const rulesDir = join4(capabilityPath, "rules");
+  if (!existsSync6(rulesDir)) {
     return [];
   }
   const rules = [];
   const entries = readdirSync3(rulesDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".md")) {
-      const rulePath = join5(rulesDir, entry.name);
+      const rulePath = join4(rulesDir, entry.name);
       const content = await readFile3(rulePath, "utf-8");
       rules.push({
-        name: basename2(entry.name, ".md"),
+        name: basename3(entry.name, ".md"),
         content: content.trim(),
         capabilityId
       });
@@ -1845,22 +2428,25 @@ async function loadRules(capabilityPath, capabilityId) {
 var init_rules = () => {};
 
 // ../core/src/capability/skills.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { join as join5 } from "node:path";
 async function loadSkills(capabilityPath, capabilityId) {
-  const skillsDir = join6(capabilityPath, "skills");
-  if (!existsSync6(skillsDir)) {
-    return [];
-  }
   const skills = [];
-  const entries = readdirSync4(skillsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const skillPath = join6(skillsDir, entry.name, "SKILL.md");
-      if (existsSync6(skillPath)) {
-        const skill = await parseSkillFile(skillPath, capabilityId);
-        skills.push(skill);
+  const possibleDirNames = ["skills", "skill"];
+  for (const dirName of possibleDirNames) {
+    const dir = join5(capabilityPath, dirName);
+    if (!existsSync7(dir)) {
+      continue;
+    }
+    const entries = readdirSync4(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillPath = join5(dir, entry.name, "SKILL.md");
+        if (existsSync7(skillPath)) {
+          const skill = await parseSkillFile(skillPath, capabilityId);
+          skills.push(skill);
+        }
       }
     }
   }
@@ -1875,7 +2461,7 @@ async function parseSkillFile(filePath, capabilityId) {
   const frontmatter = parsed.frontmatter;
   const instructions = parsed.markdown;
   if (!frontmatter.name || !frontmatter.description) {
-    throw new Error(`Invalid SKILL.md at ${filePath}: name and description required`);
+    throw new Error(`Invalid SKILL.md at ${filePath}: name and description required in frontmatter`);
   }
   return {
     name: frontmatter.name,
@@ -1887,20 +2473,30 @@ async function parseSkillFile(filePath, capabilityId) {
 var init_skills = () => {};
 
 // ../core/src/capability/subagents.ts
-import { existsSync as existsSync7, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync5 } from "node:fs";
 import { readFile as readFile5 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { basename as basename4, join as join6 } from "node:path";
 async function loadSubagents(capabilityPath, capabilityId) {
-  const subagentsDir = join7(capabilityPath, "subagents");
-  if (!existsSync7(subagentsDir)) {
-    return [];
-  }
   const subagents = [];
-  const entries = readdirSync5(subagentsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const subagentPath = join7(subagentsDir, entry.name, "SUBAGENT.md");
-      if (existsSync7(subagentPath)) {
+  const possibleDirNames = ["subagents", "agents", "agent", "subagent"];
+  for (const dirName of possibleDirNames) {
+    const dir = join6(capabilityPath, dirName);
+    if (!existsSync8(dir)) {
+      continue;
+    }
+    const entries = readdirSync5(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        let subagentPath = join6(dir, entry.name, "SUBAGENT.md");
+        if (!existsSync8(subagentPath)) {
+          subagentPath = join6(dir, entry.name, "AGENT.md");
+        }
+        if (existsSync8(subagentPath)) {
+          const subagent = await parseSubagentFile(subagentPath, capabilityId);
+          subagents.push(subagent);
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const subagentPath = join6(dir, entry.name);
         const subagent = await parseSubagentFile(subagentPath, capabilityId);
         subagents.push(subagent);
       }
@@ -1916,11 +2512,13 @@ async function parseSubagentFile(filePath, capabilityId) {
   }
   const frontmatter = parsed.frontmatter;
   const systemPrompt = parsed.markdown;
-  if (!frontmatter.name || !frontmatter.description) {
+  const inferredName = basename4(filePath, ".md").replace(/^SUBAGENT$/i, "").replace(/^AGENT$/i, "");
+  const name = frontmatter.name || inferredName;
+  if (!name || !frontmatter.description) {
     throw new Error(`Invalid SUBAGENT.md at ${filePath}: name and description required`);
   }
   const result = {
-    name: frontmatter.name,
+    name,
     description: frontmatter.description,
     systemPrompt: systemPrompt.trim(),
     capabilityId
@@ -1951,18 +2549,18 @@ function parseCommaSeparatedList(value) {
 var init_subagents = () => {};
 
 // ../core/src/capability/loader.ts
-import { existsSync as existsSync8, readdirSync as readdirSync6 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync6 } from "node:fs";
 import { readFile as readFile6 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { join as join7 } from "node:path";
 async function discoverCapabilities() {
   const capabilities = [];
-  if (existsSync8(CAPABILITIES_DIR)) {
+  if (existsSync9(CAPABILITIES_DIR)) {
     const entries = readdirSync6(CAPABILITIES_DIR, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const entryPath = join8(CAPABILITIES_DIR, entry.name);
-        const configPath = join8(entryPath, "capability.toml");
-        if (existsSync8(configPath)) {
+        const entryPath = join7(CAPABILITIES_DIR, entry.name);
+        const configPath = join7(entryPath, "capability.toml");
+        if (existsSync9(configPath)) {
           capabilities.push(entryPath);
         }
       }
@@ -1971,28 +2569,28 @@ async function discoverCapabilities() {
   return capabilities;
 }
 async function loadCapabilityConfig(capabilityPath) {
-  const configPath = join8(capabilityPath, "capability.toml");
+  const configPath = join7(capabilityPath, "capability.toml");
   const content = await readFile6(configPath, "utf-8");
   const config = parseCapabilityConfig(content);
   return config;
 }
 async function importCapabilityExports(capabilityPath) {
-  const builtIndexPath = join8(capabilityPath, "dist", "index.js");
-  const jsIndexPath = join8(capabilityPath, "index.js");
-  const tsIndexPath = join8(capabilityPath, "index.ts");
+  const builtIndexPath = join7(capabilityPath, "dist", "index.js");
+  const jsIndexPath = join7(capabilityPath, "index.js");
+  const tsIndexPath = join7(capabilityPath, "index.ts");
   let indexPath = null;
-  if (existsSync8(builtIndexPath)) {
+  if (existsSync9(builtIndexPath)) {
     indexPath = builtIndexPath;
-  } else if (existsSync8(jsIndexPath)) {
+  } else if (existsSync9(jsIndexPath)) {
     indexPath = jsIndexPath;
-  } else if (existsSync8(tsIndexPath)) {
+  } else if (existsSync9(tsIndexPath)) {
     indexPath = tsIndexPath;
   }
   if (!indexPath) {
     return {};
   }
   try {
-    const absolutePath = join8(process.cwd(), indexPath);
+    const absolutePath = join7(process.cwd(), indexPath);
     const module = await import(absolutePath);
     return module;
   } catch (error) {
@@ -2012,8 +2610,8 @@ If this is a project-specific capability, install dependencies or remove it from
   }
 }
 async function loadTypeDefinitions(capabilityPath) {
-  const typesPath = join8(capabilityPath, "types.d.ts");
-  if (!existsSync8(typesPath)) {
+  const typesPath = join7(capabilityPath, "types.d.ts");
+  if (!existsSync9(typesPath)) {
     return;
   }
   return readFile6(typesPath, "utf-8");
@@ -2206,7 +2804,7 @@ async function loadCapability(capabilityPath) {
   const typeDefinitionsFromExports = "typeDefinitions" in exports && typeof exportsAny.typeDefinitions === "string" ? exportsAny.typeDefinitions : undefined;
   const typeDefinitions = typeDefinitionsFromExports !== undefined ? typeDefinitionsFromExports : await loadTypeDefinitions(capabilityPath);
   const gitignore = "gitignore" in exports && Array.isArray(exportsAny.gitignore) ? exportsAny.gitignore : undefined;
-  const hooks = loadCapabilityHooks(id, capabilityPath);
+  const hooks = loadCapabilityHooks(id, capabilityPath, { resolveCapabilityRoot: true });
   const result = {
     id,
     path: capabilityPath,
@@ -2241,8 +2839,8 @@ var init_loader2 = __esm(() => {
 });
 
 // ../core/src/config/config.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { readFile as readFile7, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync10 } from "node:fs";
+import { readFile as readFile7, writeFile } from "node:fs/promises";
 function mergeConfigs(base, override) {
   const merged = { ...base, ...override };
   merged.profiles = { ...base.profiles };
@@ -2255,10 +2853,36 @@ function mergeConfigs(base, override) {
   if (base.mcps || override.mcps) {
     merged.mcps = { ...base.mcps, ...override.mcps };
   }
+  if (base.capabilities || override.capabilities) {
+    merged.capabilities = {
+      ...base.capabilities,
+      ...override.capabilities,
+      sources: { ...base.capabilities?.sources, ...override.capabilities?.sources },
+      groups: { ...base.capabilities?.groups, ...override.capabilities?.groups },
+      always_enabled: [
+        ...new Set([
+          ...base.capabilities?.always_enabled ?? [],
+          ...override.capabilities?.always_enabled ?? []
+        ])
+      ],
+      always_disabled: [
+        ...new Set([
+          ...base.capabilities?.always_disabled ?? [],
+          ...override.capabilities?.always_disabled ?? []
+        ])
+      ]
+    };
+    if (merged.capabilities.always_enabled?.length === 0) {
+      delete merged.capabilities.always_enabled;
+    }
+    if (merged.capabilities.always_disabled?.length === 0) {
+      delete merged.capabilities.always_disabled;
+    }
+  }
   return merged;
 }
 async function loadBaseConfig() {
-  if (existsSync9(CONFIG_PATH)) {
+  if (existsSync10(CONFIG_PATH)) {
     const content = await readFile7(CONFIG_PATH, "utf-8");
     return parseOmniConfig(content);
   }
@@ -2267,7 +2891,7 @@ async function loadBaseConfig() {
 async function loadConfig() {
   const baseConfig = await loadBaseConfig();
   let localConfig = {};
-  if (existsSync9(LOCAL_CONFIG)) {
+  if (existsSync10(LOCAL_CONFIG)) {
     const content = await readFile7(LOCAL_CONFIG, "utf-8");
     localConfig = parseOmniConfig(content);
   }
@@ -2275,7 +2899,7 @@ async function loadConfig() {
 }
 async function writeConfig(config) {
   const content = generateConfigToml(config);
-  await writeFile2(CONFIG_PATH, content, "utf-8");
+  await writeFile(CONFIG_PATH, content, "utf-8");
 }
 function generateConfigToml(config) {
   const lines = [];
@@ -2432,10 +3056,10 @@ var init_config = __esm(() => {
 });
 
 // ../core/src/state/active-profile.ts
-import { existsSync as existsSync10, mkdirSync } from "node:fs";
-import { readFile as readFile8, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync11, mkdirSync } from "node:fs";
+import { readFile as readFile8, unlink, writeFile as writeFile2 } from "node:fs/promises";
 async function readActiveProfileState() {
-  if (!existsSync10(ACTIVE_PROFILE_PATH)) {
+  if (!existsSync11(ACTIVE_PROFILE_PATH)) {
     return null;
   }
   try {
@@ -2448,10 +3072,10 @@ async function readActiveProfileState() {
 }
 async function writeActiveProfileState(profileName) {
   mkdirSync(STATE_DIR, { recursive: true });
-  await writeFile3(ACTIVE_PROFILE_PATH, profileName, "utf-8");
+  await writeFile2(ACTIVE_PROFILE_PATH, profileName, "utf-8");
 }
 async function clearActiveProfileState() {
-  if (existsSync10(ACTIVE_PROFILE_PATH)) {
+  if (existsSync11(ACTIVE_PROFILE_PATH)) {
     await unlink(ACTIVE_PROFILE_PATH);
   }
 }
@@ -2471,6 +3095,7 @@ function resolveEnabledCapabilities(config, profileName) {
   const profile = profileName ? config.profiles?.[profileName] : config.profiles?.["default"];
   const profileCapabilities = profile?.capabilities ?? [];
   const alwaysEnabled = config.capabilities?.always_enabled ?? [];
+  const alwaysDisabled = config.capabilities?.always_disabled ?? [];
   const groups = config.capabilities?.groups ?? {};
   const expandCapabilities = (caps) => {
     return caps.flatMap((cap) => {
@@ -2488,7 +3113,9 @@ function resolveEnabledCapabilities(config, profileName) {
   };
   const expandedAlways = expandCapabilities(alwaysEnabled);
   const expandedProfile = expandCapabilities(profileCapabilities);
-  return [...new Set([...expandedAlways, ...expandedProfile])];
+  const expandedDisabled = new Set(expandCapabilities(alwaysDisabled));
+  const allEnabled = [...new Set([...expandedAlways, ...expandedProfile])];
+  return allEnabled.filter((cap) => !expandedDisabled.has(cap));
 }
 async function loadProfileConfig(profileName) {
   const config = await loadConfig();
@@ -2692,10 +3319,10 @@ function getActiveProviders(config) {
 var init_types2 = () => {};
 
 // ../core/src/capability/sources.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { spawn } from "node:child_process";
-import { cp, mkdir as mkdir2, readdir, readFile as readFile9, rename, rm, stat, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { cp, mkdir, readdir, readFile as readFile9, rename, rm, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 import { createHash } from "node:crypto";
 async function spawnCapture(command, args, options) {
   const timeout = options?.timeout ?? 60000;
@@ -2752,8 +3379,8 @@ function parseFileSourcePath(source) {
   return source.slice(7);
 }
 async function readCapabilityIdFromPath(capabilityPath) {
-  const tomlPath = join9(capabilityPath, "capability.toml");
-  if (existsSync11(tomlPath)) {
+  const tomlPath = join8(capabilityPath, "capability.toml");
+  if (existsSync12(tomlPath)) {
     try {
       const content = await readFile9(tomlPath, "utf-8");
       const parsed = parse(content);
@@ -2808,14 +3435,14 @@ function sourceToGitUrl(source) {
   return source;
 }
 function getSourceCapabilityPath(id) {
-  return join9(OMNI_LOCAL, "capabilities", id);
+  return join8(OMNI_LOCAL, "capabilities", id);
 }
 function getLockFilePath() {
   return "omni.lock.toml";
 }
 async function loadLockFile() {
   const lockPath = getLockFilePath();
-  if (!existsSync11(lockPath)) {
+  if (!existsSync12(lockPath)) {
     return { capabilities: {} };
   }
   try {
@@ -2877,14 +3504,14 @@ function stringifyLockFile(lockFile) {
 }
 async function saveLockFile(lockFile) {
   const lockPath = getLockFilePath();
-  await mkdir2(join9(OMNI_LOCAL, "capabilities"), { recursive: true });
+  await mkdir(join8(OMNI_LOCAL, "capabilities"), { recursive: true });
   const header = `# Auto-generated by OmniDev - DO NOT EDIT
 # Records installed capability versions for reproducibility
 # Last updated: ${new Date().toISOString()}
 
 `;
   const content = header + stringifyLockFile(lockFile);
-  await writeFile4(lockPath, content, "utf-8");
+  await writeFile3(lockPath, content, "utf-8");
 }
 async function getRepoCommit(repoPath) {
   const { exitCode, stdout, stderr } = await spawnCapture("git", ["rev-parse", "HEAD"], {
@@ -2908,7 +3535,7 @@ async function computeContentHash(dirPath, excludePatterns = CONTENT_HASH_EXCLUD
     const entries = await readdir(currentPath, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const fullPath = join9(currentPath, entry.name);
+      const fullPath = join8(currentPath, entry.name);
       const relativePath = fullPath.slice(relativeTo.length + 1);
       if (excludePatterns.some((pattern) => entry.name === pattern || relativePath.startsWith(`${pattern}/`))) {
         continue;
@@ -2930,8 +3557,8 @@ async function computeContentHash(dirPath, excludePatterns = CONTENT_HASH_EXCLUD
   return hash.digest("hex");
 }
 async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
-  const capTomlPath = join9(dirPath, "capability.toml");
-  if (existsSync11(capTomlPath)) {
+  const capTomlPath = join8(dirPath, "capability.toml");
+  if (existsSync12(capTomlPath)) {
     try {
       const content = await readFile9(capTomlPath, "utf-8");
       const parsed = parse(content);
@@ -2941,8 +3568,8 @@ async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
       }
     } catch {}
   }
-  const pluginJsonPath = join9(dirPath, ".claude-plugin", "plugin.json");
-  if (existsSync11(pluginJsonPath)) {
+  const pluginJsonPath = join8(dirPath, ".claude-plugin", "plugin.json");
+  if (existsSync12(pluginJsonPath)) {
     try {
       const content = await readFile9(pluginJsonPath, "utf-8");
       const parsed = JSON.parse(content);
@@ -2951,8 +3578,8 @@ async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
       }
     } catch {}
   }
-  const pkgJsonPath = join9(dirPath, "package.json");
-  if (existsSync11(pkgJsonPath)) {
+  const pkgJsonPath = join8(dirPath, "package.json");
+  if (existsSync12(pkgJsonPath)) {
     try {
       const content = await readFile9(pkgJsonPath, "utf-8");
       const parsed = JSON.parse(content);
@@ -2963,20 +3590,111 @@ async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
   }
   return { version: fallback, source: fallbackSource };
 }
+async function validateGitCapability(sourceUrl, subPath) {
+  const gitUrl = sourceToGitUrl(sourceUrl);
+  const tempPath = join8(OMNI_LOCAL, "_temp", `_validate-${Date.now()}`);
+  try {
+    await mkdir(join8(tempPath, ".."), { recursive: true });
+    const args = ["clone", "--depth", "1", gitUrl, tempPath];
+    const { exitCode, stderr } = await spawnCapture("git", args, { timeout: 30000 });
+    if (exitCode !== 0) {
+      const stderrLower = stderr.toLowerCase();
+      if (stderrLower.includes("not found") || stderrLower.includes("repository not found") || stderrLower.includes("does not exist")) {
+        return {
+          valid: false,
+          hasCapabilityToml: false,
+          canBeWrapped: false,
+          error: "Repository not found"
+        };
+      }
+      if (stderrLower.includes("could not resolve host")) {
+        return {
+          valid: false,
+          hasCapabilityToml: false,
+          canBeWrapped: false,
+          error: "Could not resolve host - check your network connection"
+        };
+      }
+      if (stderrLower.includes("authentication") || stderrLower.includes("permission denied")) {
+        return {
+          valid: false,
+          hasCapabilityToml: false,
+          canBeWrapped: false,
+          error: "Authentication failed - repository may be private"
+        };
+      }
+      return {
+        valid: false,
+        hasCapabilityToml: false,
+        canBeWrapped: false,
+        error: `Failed to clone repository: ${stderr.trim()}`
+      };
+    }
+    const checkPath = subPath ? join8(tempPath, subPath) : tempPath;
+    if (subPath && !existsSync12(checkPath)) {
+      return {
+        valid: false,
+        hasCapabilityToml: false,
+        canBeWrapped: false,
+        error: `Path '${subPath}' not found in repository`
+      };
+    }
+    const hasCapToml = hasCapabilityToml(checkPath);
+    let capabilityId;
+    if (hasCapToml) {
+      const tomlPath = join8(checkPath, "capability.toml");
+      try {
+        const content = await readFile9(tomlPath, "utf-8");
+        const parsed = parse(content);
+        const capability = parsed["capability"];
+        if (capability?.["id"] && typeof capability["id"] === "string") {
+          capabilityId = capability["id"];
+        }
+      } catch {}
+      const result = {
+        valid: true,
+        hasCapabilityToml: true,
+        canBeWrapped: true
+      };
+      if (capabilityId) {
+        result.capabilityId = capabilityId;
+      }
+      return result;
+    }
+    const canWrap = await shouldWrapDirectory(checkPath);
+    if (!canWrap) {
+      return {
+        valid: false,
+        hasCapabilityToml: false,
+        canBeWrapped: false,
+        error: "Repository does not contain a capability.toml and cannot be auto-wrapped (no skills, agents, commands, rules, docs, or .claude-plugin found)"
+      };
+    }
+    return {
+      valid: true,
+      hasCapabilityToml: false,
+      canBeWrapped: true
+    };
+  } finally {
+    if (existsSync12(tempPath)) {
+      await rm(tempPath, { recursive: true });
+    }
+  }
+}
 async function detectPinVersion(sourceUrl, subPath) {
   const gitUrl = sourceToGitUrl(sourceUrl);
-  const tempPath = join9(OMNI_LOCAL, "_temp", `_pin-detect-${Date.now()}`);
+  const tempPath = join8(OMNI_LOCAL, "_temp", `_pin-detect-${Date.now()}`);
   try {
-    await mkdir2(join9(tempPath, ".."), { recursive: true });
+    await mkdir(join8(tempPath, ".."), { recursive: true });
     const args = ["clone", "--depth", "1", gitUrl, tempPath];
     const { exitCode, stderr } = await spawnCapture("git", args);
     if (exitCode !== 0) {
       throw new Error(`Failed to clone ${gitUrl}: ${stderr.trim()}`);
     }
     const commit = await getRepoCommit(tempPath);
-    const checkPath = subPath ? join9(tempPath, subPath) : tempPath;
-    const capTomlPath = join9(checkPath, "capability.toml");
-    if (existsSync11(capTomlPath)) {
+    const checkPath = subPath ? join8(tempPath, subPath) : tempPath;
+    const capTomlPath = join8(checkPath, "capability.toml");
+    if (existsSync12(capTomlPath)) {
       try {
         const content = await readFile9(capTomlPath, "utf-8");
         const parsed = parse(content);
@@ -2986,8 +3704,8 @@ async function detectPinVersion(sourceUrl, subPath) {
         }
       } catch {}
     }
-    const pluginJsonPath = join9(checkPath, ".claude-plugin", "plugin.json");
-    if (existsSync11(pluginJsonPath)) {
+    const pluginJsonPath = join8(checkPath, ".claude-plugin", "plugin.json");
+    if (existsSync12(pluginJsonPath)) {
       try {
         const content = await readFile9(pluginJsonPath, "utf-8");
         const parsed = JSON.parse(content);
@@ -2998,13 +3716,13 @@ async function detectPinVersion(sourceUrl, subPath) {
     }
     return commit;
   } finally {
-    if (existsSync11(tempPath)) {
+    if (existsSync12(tempPath)) {
       await rm(tempPath, { recursive: true });
     }
   }
 }
 async function cloneRepo(gitUrl, targetPath, ref) {
-  await mkdir2(join9(targetPath, ".."), { recursive: true });
+  await mkdir(join8(targetPath, ".."), { recursive: true });
   const args = ["clone", "--depth", "1"];
   if (ref) {
     args.push("--branch", ref);
@@ -3041,16 +3759,16 @@ async function fetchRepo(repoPath, ref) {
   return true;
 }
 function hasCapabilityToml(dirPath) {
-  return existsSync11(join9(dirPath, "capability.toml"));
+  return existsSync12(join8(dirPath, "capability.toml"));
 }
 async function shouldWrapDirectory(dirPath) {
-  if (existsSync11(join9(dirPath, ".claude-plugin", "plugin.json"))) {
+  if (existsSync12(join8(dirPath, ".claude-plugin", "plugin.json"))) {
     return true;
   }
   const allDirs = [...SKILL_DIRS, ...AGENT_DIRS, ...COMMAND_DIRS, ...RULE_DIRS, ...DOC_DIRS];
   for (const dirName of allDirs) {
-    const checkPath = join9(dirPath, dirName);
-    if (existsSync11(checkPath)) {
+    const checkPath = join8(dirPath, dirName);
+    if (existsSync12(checkPath)) {
       const stats = await stat(checkPath);
       if (stats.isDirectory()) {
         return true;
@@ -3061,8 +3779,8 @@ async function shouldWrapDirectory(dirPath) {
 }
 async function findMatchingDirs(basePath, names) {
   for (const name of names) {
-    const dirPath = join9(basePath, name);
-    if (existsSync11(dirPath)) {
+    const dirPath = join8(basePath, name);
+    if (existsSync12(dirPath)) {
       const stats = await stat(dirPath);
       if (stats.isDirectory()) {
         return dirPath;
@@ -3073,15 +3791,15 @@ async function findMatchingDirs(basePath, names) {
 }
 async function findContentItems(dirPath, filePatterns) {
   const items = [];
-  if (!existsSync11(dirPath)) {
+  if (!existsSync12(dirPath)) {
     return items;
   }
   const entries = (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const entryPath = join9(dirPath, entry.name);
+    const entryPath = join8(dirPath, entry.name);
     if (entry.isDirectory()) {
       for (const pattern of filePatterns) {
-        if (existsSync11(join9(entryPath, pattern))) {
+        if (existsSync12(join8(entryPath, pattern))) {
           items.push({
             name: entry.name,
             path: entryPath,
@@ -3102,8 +3820,8 @@ async function findContentItems(dirPath, filePatterns) {
   return items;
 }
 async function parsePluginJson(dirPath) {
-  const pluginJsonPath = join9(dirPath, ".claude-plugin", "plugin.json");
-  if (!existsSync11(pluginJsonPath)) {
+  const pluginJsonPath = join8(dirPath, ".claude-plugin", "plugin.json");
+  if (!existsSync12(pluginJsonPath)) {
     return null;
   }
   try {
@@ -3127,8 +3845,8 @@ async function parsePluginJson(dirPath) {
   }
 }
 async function readReadmeDescription(dirPath) {
-  const readmePath = join9(dirPath, "README.md");
-  if (!existsSync11(readmePath)) {
+  const readmePath = join8(dirPath, "README.md");
+  if (!existsSync12(readmePath)) {
     return null;
   }
   try {
@@ -3164,14 +3882,12 @@ async function normalizeFolderNames(repoPath) {
   const renameMappings = [
     { from: "skill", to: "skills" },
     { from: "command", to: "commands" },
-    { from: "rule", to: "rules" },
-    { from: "agent", to: "agents" },
-    { from: "subagent", to: "subagents" }
+    { from: "rule", to: "rules" }
   ];
   for (const { from, to } of renameMappings) {
-    const fromPath = join9(repoPath, from);
-    const toPath = join9(repoPath, to);
-    if (existsSync11(fromPath) && !existsSync11(toPath)) {
+    const fromPath = join8(repoPath, from);
+    const toPath = join8(repoPath, to);
+    if (existsSync12(fromPath) && !existsSync12(toPath)) {
       try {
         const stats = await stat(fromPath);
         if (stats.isDirectory()) {
@@ -3260,7 +3976,7 @@ repository = "${repoUrl}"
 wrapped = true
 commit = "${commit}"
 `;
-  await writeFile4(join9(repoPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile3(join8(repoPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function fetchGitCapabilitySource(id, config, options) {
   const gitUrl = sourceToGitUrl(config.source);
@@ -3270,29 +3986,29 @@ async function fetchGitCapabilitySource(id, config, options) {
   let repoPath;
   const gitRef = config.version && config.version !== "latest" ? config.version : undefined;
   if (config.path) {
-    const tempPath = join9(OMNI_LOCAL, "_temp", `${id}-repo`);
-    if (existsSync11(join9(tempPath, ".git"))) {
+    const tempPath = join8(OMNI_LOCAL, "_temp", `${id}-repo`);
+    if (existsSync12(join8(tempPath, ".git"))) {
       updated = await fetchRepo(tempPath, gitRef);
       commit = await getRepoCommit(tempPath);
     } else {
-      await mkdir2(join9(tempPath, ".."), { recursive: true });
+      await mkdir(join8(tempPath, ".."), { recursive: true });
       await cloneRepo(gitUrl, tempPath, gitRef);
       commit = await getRepoCommit(tempPath);
       updated = true;
     }
-    const sourcePath = join9(tempPath, config.path);
-    if (!existsSync11(sourcePath)) {
+    const sourcePath = join8(tempPath, config.path);
+    if (!existsSync12(sourcePath)) {
       throw new Error(`Path not found in repository: ${config.path}`);
     }
-    if (existsSync11(targetPath)) {
+    if (existsSync12(targetPath)) {
       await rm(targetPath, { recursive: true });
     }
-    await mkdir2(join9(targetPath, ".."), { recursive: true });
+    await mkdir(join8(targetPath, ".."), { recursive: true });
     await cp(sourcePath, targetPath, { recursive: true });
     await rm(tempPath, { recursive: true });
     repoPath = targetPath;
   } else {
-    if (existsSync11(join9(targetPath, ".git"))) {
+    if (existsSync12(join8(targetPath, ".git"))) {
       if (!options?.silent) {
         console.log(`  Checking ${id}...`);
       }
@@ -3343,7 +4059,7 @@ async function fetchGitCapabilitySource(id, config, options) {
 async function fetchFileCapabilitySource(id, config, options) {
   const sourcePath = parseFileSourcePath(config.source);
   const targetPath = getSourceCapabilityPath(id);
-  if (!existsSync11(sourcePath)) {
+  if (!existsSync12(sourcePath)) {
     throw new Error(`File source not found: ${sourcePath}`);
   }
   const sourceStats = await stat(sourcePath);
@@ -3351,7 +4067,7 @@ async function fetchFileCapabilitySource(id, config, options) {
     throw new Error(`File source must be a directory: ${sourcePath}`);
   }
   const contentHash = await computeContentHash(sourcePath);
-  const hasCapToml = existsSync11(join9(sourcePath, "capability.toml"));
+  const hasCapToml = existsSync12(join8(sourcePath, "capability.toml"));
   let needsWrap = false;
   if (!hasCapToml) {
     needsWrap = await shouldWrapDirectory(sourcePath);
@@ -3362,10 +4078,10 @@ async function fetchFileCapabilitySource(id, config, options) {
   if (!options?.silent) {
     console.log(`  Copying ${id} from ${sourcePath}...`);
   }
-  if (existsSync11(targetPath)) {
+  if (existsSync12(targetPath)) {
     await rm(targetPath, { recursive: true });
   }
-  await mkdir2(join9(targetPath, ".."), { recursive: true });
+  await mkdir(join8(targetPath, ".."), { recursive: true });
   await cp(sourcePath, targetPath, { recursive: true });
   if (needsWrap) {
     await normalizeFolderNames(targetPath);
@@ -3445,7 +4161,7 @@ description = "${description}"
 wrapped = true
 source = "${source}"
 `;
-  await writeFile4(join9(targetPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile3(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function fetchCapabilitySource(id, sourceConfig, options) {
   const config = parseSourceConfig(sourceConfig);
@@ -3518,11 +4234,11 @@ generated_from_omni_toml = true
 }
 async function generateMcpCapabilityToml(id, mcpConfig, targetPath) {
   const tomlContent = generateMcpCapabilityTomlContent(id, mcpConfig);
-  await writeFile4(join9(targetPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile3(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function isGeneratedMcpCapability(capabilityDir) {
-  const tomlPath = join9(capabilityDir, "capability.toml");
-  if (!existsSync11(tomlPath)) {
+  const tomlPath = join8(capabilityDir, "capability.toml");
+  if (!existsSync12(tomlPath)) {
     console.warn("no capability.toml found in", capabilityDir);
     return false;
   }
@@ -3537,14 +4253,14 @@ async function isGeneratedMcpCapability(capabilityDir) {
   }
 }
 async function cleanupStaleMcpCapabilities(currentMcpIds) {
-  const capabilitiesDir = join9(OMNI_LOCAL, "capabilities");
-  if (!existsSync11(capabilitiesDir)) {
+  const capabilitiesDir = join8(OMNI_LOCAL, "capabilities");
+  if (!existsSync12(capabilitiesDir)) {
     return;
   }
   const entries = await readdir(capabilitiesDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const capDir = join9(capabilitiesDir, entry.name);
+      const capDir = join8(capabilitiesDir, entry.name);
       const isGenerated = await isGeneratedMcpCapability(capDir);
       if (isGenerated && !currentMcpIds.has(entry.name)) {
         await rm(capDir, { recursive: true });
@@ -3557,20 +4273,20 @@ async function generateMcpCapabilities(config) {
     await cleanupStaleMcpCapabilities(new Set);
     return;
   }
-  const mcpCapabilitiesDir = join9(OMNI_LOCAL, "capabilities");
+  const mcpCapabilitiesDir = join8(OMNI_LOCAL, "capabilities");
   const currentMcpIds = new Set;
   for (const [id, mcpConfig] of Object.entries(config.mcps)) {
-    const targetPath = join9(mcpCapabilitiesDir, id);
+    const targetPath = join8(mcpCapabilitiesDir, id);
     currentMcpIds.add(id);
-    await mkdir2(targetPath, { recursive: true });
+    await mkdir(targetPath, { recursive: true });
     await generateMcpCapabilityToml(id, mcpConfig, targetPath);
   }
   await cleanupStaleMcpCapabilities(currentMcpIds);
 }
 async function fetchAllCapabilitySources(config, options) {
   await generateMcpCapabilities(config);
-  const tempDir = join9(OMNI_LOCAL, "_temp");
-  if (existsSync11(tempDir)) {
+  const tempDir = join8(OMNI_LOCAL, "_temp");
+  if (existsSync12(tempDir)) {
     await rm(tempDir, { recursive: true });
   }
   const sources = config.capabilities?.sources;
@@ -3656,7 +4372,7 @@ async function checkForUpdates(config) {
       continue;
     }
     const gitConfig = sourceConfig;
-    if (!existsSync11(join9(targetPath, ".git"))) {
+    if (!existsSync12(join8(targetPath, ".git"))) {
       updates.push({
         id,
         source: gitConfig.source,
@@ -3699,12 +4415,12 @@ function checkVersionMismatch(lockEntry, currentCommit, currentVersion) {
 }
 async function verifyIntegrity(id, lockEntry) {
   const capabilityPath = getSourceCapabilityPath(id);
-  if (!existsSync11(capabilityPath)) {
+  if (!existsSync12(capabilityPath)) {
     return "capability directory missing";
   }
   if (lockEntry.commit) {
-    const gitDir = join9(capabilityPath, ".git");
-    if (existsSync11(gitDir)) {
+    const gitDir = join8(capabilityPath, ".git");
+    if (existsSync12(gitDir)) {
       try {
         const currentCommit = await getRepoCommit(capabilityPath);
         if (currentCommit !== lockEntry.commit) {
@@ -3769,13 +4485,14 @@ var init_hooks = __esm(() => {
   init_variables();
   init_loader();
   init_merger();
+  init_json_loader();
 });
 
 // ../core/src/config/provider.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { readFile as readFile10, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync13 } from "node:fs";
+import { readFile as readFile10, writeFile as writeFile4 } from "node:fs/promises";
 async function loadProviderConfig() {
-  if (!existsSync12(PROVIDER_CONFIG_PATH)) {
+  if (!existsSync13(PROVIDER_CONFIG_PATH)) {
     return { provider: "claude" };
   }
   const content = await readFile10(PROVIDER_CONFIG_PATH, "utf-8");
@@ -3805,7 +4522,7 @@ async function writeProviderConfig(config) {
     lines.push("# Default: Claude");
     lines.push('provider = "claude"');
   }
-  await writeFile5(PROVIDER_CONFIG_PATH, `${lines.join(`
+  await writeFile4(PROVIDER_CONFIG_PATH, `${lines.join(`
 `)}
 `, "utf-8");
 }
@@ -3825,16 +4542,16 @@ var init_provider = __esm(() => {
 });
 
 // ../core/src/config/toml-patcher.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { readFile as readFile11, writeFile as writeFile6 } from "node:fs/promises";
+import { existsSync as existsSync14 } from "node:fs";
+import { readFile as readFile11, writeFile as writeFile5 } from "node:fs/promises";
 async function readConfigFile() {
-  if (!existsSync13(CONFIG_PATH2)) {
+  if (!existsSync14(CONFIG_PATH2)) {
     return "";
   }
   return readFile11(CONFIG_PATH2, "utf-8");
 }
 async function writeConfigFile(content) {
-  await writeFile6(CONFIG_PATH2, content, "utf-8");
+  await writeFile5(CONFIG_PATH2, content, "utf-8");
 }
 function findSection(lines, sectionPattern) {
   return lines.findIndex((line) => sectionPattern.test(line.trim()));
@@ -4053,10 +4770,10 @@ var init_config2 = __esm(() => {
 });
 
 // ../core/src/mcp-json/manager.ts
-import { existsSync as existsSync14 } from "node:fs";
-import { readFile as readFile12, writeFile as writeFile7 } from "node:fs/promises";
+import { existsSync as existsSync15 } from "node:fs";
+import { readFile as readFile12, writeFile as writeFile6 } from "node:fs/promises";
 async function readMcpJson() {
-  if (!existsSync14(MCP_JSON_PATH)) {
+  if (!existsSync15(MCP_JSON_PATH)) {
     return { mcpServers: {} };
   }
   try {
@@ -4070,7 +4787,7 @@ async function readMcpJson() {
   }
 }
 async function writeMcpJson(config2) {
-  await writeFile7(MCP_JSON_PATH, `${JSON.stringify(config2, null, 2)}
+  await writeFile6(MCP_JSON_PATH, `${JSON.stringify(config2, null, 2)}
 `, "utf-8");
 }
 function buildMcpServerConfig(mcp) {
@@ -4142,10 +4859,10 @@ var init_mcp_json = __esm(() => {
 });
 
 // ../core/src/state/manifest.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync2, rmSync } from "node:fs";
-import { readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
+import { existsSync as existsSync16, mkdirSync as mkdirSync2, rmSync } from "node:fs";
+import { readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
 async function loadManifest() {
-  if (!existsSync15(MANIFEST_PATH)) {
+  if (!existsSync16(MANIFEST_PATH)) {
     return {
       version: CURRENT_VERSION,
       syncedAt: new Date().toISOString(),
@@ -4157,7 +4874,7 @@ async function loadManifest() {
 }
 async function saveManifest(manifest) {
   mkdirSync2(".omni/state", { recursive: true });
-  await writeFile8(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
+  await writeFile7(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
 function buildManifestFromCapabilities(capabilities2) {
@@ -4192,14 +4909,14 @@ async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
     }
     for (const skillName of resources.skills) {
       const skillDir = `.claude/skills/${skillName}`;
-      if (existsSync15(skillDir)) {
+      if (existsSync16(skillDir)) {
         rmSync(skillDir, { recursive: true });
         result.deletedSkills.push(skillName);
       }
     }
     for (const ruleName of resources.rules) {
       const rulePath = `.cursor/rules/omnidev-${ruleName}.mdc`;
-      if (existsSync15(rulePath)) {
+      if (existsSync16(rulePath)) {
         rmSync(rulePath);
         result.deletedRules.push(ruleName);
       }
@@ -4211,10 +4928,10 @@ var MANIFEST_PATH = ".omni/state/manifest.json", CURRENT_VERSION = 1;
 var init_manifest = () => {};
 
 // ../core/src/state/providers.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync3 } from "node:fs";
-import { readFile as readFile14, writeFile as writeFile9 } from "node:fs/promises";
+import { existsSync as existsSync17, mkdirSync as mkdirSync3 } from "node:fs";
+import { readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
 async function readEnabledProviders() {
-  if (!existsSync16(PROVIDERS_PATH)) {
+  if (!existsSync17(PROVIDERS_PATH)) {
     return DEFAULT_PROVIDERS;
   }
   try {
@@ -4228,7 +4945,7 @@ async function readEnabledProviders() {
 async function writeEnabledProviders(providers) {
   mkdirSync3(STATE_DIR2, { recursive: true });
   const state = { enabled: providers };
-  await writeFile9(PROVIDERS_PATH, `${JSON.stringify(state, null, 2)}
+  await writeFile8(PROVIDERS_PATH, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 async function enableProvider(providerId) {
@@ -4253,10 +4970,10 @@ var init_providers = __esm(() => {
 });
 
 // ../core/src/state/security-allows.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync4 } from "node:fs";
-import { readFile as readFile15, writeFile as writeFile10 } from "node:fs/promises";
+import { existsSync as existsSync18, mkdirSync as mkdirSync4 } from "node:fs";
+import { readFile as readFile15, writeFile as writeFile9 } from "node:fs/promises";
 async function readSecurityAllows() {
-  if (!existsSync17(SECURITY_PATH)) {
+  if (!existsSync18(SECURITY_PATH)) {
     return { ...DEFAULT_STATE };
   }
   try {
@@ -4270,7 +4987,7 @@ async function readSecurityAllows() {
 async function writeSecurityAllows(state) {
   mkdirSync4(OMNI_DIR, { recursive: true });
   state.modifiedAt = new Date().toISOString();
-  await writeFile10(SECURITY_PATH, `${JSON.stringify(state, null, 2)}
+  await writeFile9(SECURITY_PATH, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 async function addSecurityAllow(capabilityId, findingType) {
@@ -4357,10 +5074,10 @@ var init_state = __esm(() => {
 import { spawn as spawn2 } from "node:child_process";
 import { mkdirSync as mkdirSync5 } from "node:fs";
 async function installCapabilityDependencies(silent) {
-  const { existsSync: existsSync18, readdirSync: readdirSync7, readFileSync: readFileSync2 } = await import("node:fs");
-  const { join: join10 } = await import("node:path");
+  const { existsSync: existsSync19, readdirSync: readdirSync7, readFileSync: readFileSync3 } = await import("node:fs");
+  const { join: join9 } = await import("node:path");
   const capabilitiesDir = ".omni/capabilities";
-  if (!existsSync18(capabilitiesDir)) {
+  if (!existsSync19(capabilitiesDir)) {
     return;
   }
   const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
@@ -4380,13 +5097,13 @@ async function installCapabilityDependencies(silent) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const capabilityPath = join10(capabilitiesDir, entry.name);
-    const packageJsonPath = join10(capabilityPath, "package.json");
-    if (!existsSync18(packageJsonPath)) {
+    const capabilityPath = join9(capabilitiesDir, entry.name);
+    const packageJsonPath = join9(capabilityPath, "package.json");
+    if (!existsSync19(packageJsonPath)) {
       continue;
     }
     await new Promise((resolve2, reject) => {
-      const useNpmCi = hasNpm && existsSync18(join10(capabilityPath, "package-lock.json"));
+      const useNpmCi = hasNpm && existsSync19(join9(capabilityPath, "package-lock.json"));
       const cmd = hasBun ? "bun" : "npm";
       const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
       const proc = spawn2(cmd, args, {
@@ -4409,39 +5126,39 @@ ${stderr}`));
         reject(error);
       });
     });
-    const hasIndexTs = existsSync18(join10(capabilityPath, "index.ts"));
-    const hasBuiltIndex = existsSync18(join10(capabilityPath, "dist", "index.js"));
-    if (hasIndexTs && !hasBuiltIndex) {
-      let hasBuildScript = false;
-      try {
-        const pkgJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
-        hasBuildScript = Boolean(pkgJson.scripts?.build);
-      } catch {}
-      if (hasBuildScript) {
-        await new Promise((resolve2, reject) => {
-          const cmd = hasBun ? "bun" : "npm";
-          const args = ["run", "build"];
-          const proc = spawn2(cmd, args, {
-            cwd: capabilityPath,
-            stdio: "pipe"
-          });
-          let stderr = "";
-          proc.stderr?.on("data", (data) => {
-            stderr += data.toString();
-          });
-          proc.on("close", (code) => {
-            if (code === 0) {
-              resolve2();
-            } else {
-              reject(new Error(`Failed to build capability ${capabilityPath}:
+    const hasIndexTs = existsSync19(join9(capabilityPath, "index.ts"));
+    let hasBuildScript = false;
+    try {
+      const pkgJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+      hasBuildScript = Boolean(pkgJson.scripts?.build);
+    } catch {}
+    if (hasBuildScript) {
+      await new Promise((resolve2, reject) => {
+        const cmd = hasBun ? "bun" : "npm";
+        const args = ["run", "build"];
+        const proc = spawn2(cmd, args, {
+          cwd: capabilityPath,
+          stdio: "pipe"
+        });
+        let stderr = "";
+        proc.stderr?.on("data", (data) => {
+          stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+          if (code === 0) {
+            resolve2();
+          } else {
+            reject(new Error(`Failed to build capability ${capabilityPath}:
 ${stderr}`));
-            }
-          });
-          proc.on("error", (error) => {
-            reject(error);
-          });
+          }
+        });
+        proc.on("error", (error) => {
+          reject(error);
         });
-      } else if (!silent) {
+      });
+    } else if (hasIndexTs && !silent) {
+      const hasBuiltIndex = existsSync19(join9(capabilityPath, "dist", "index.js"));
+      if (!hasBuiltIndex) {
         console.warn(`Warning: Capability at ${capabilityPath} has index.ts but no build script.
   Add a "build" script to package.json (e.g., "build": "tsc") to compile TypeScript.`);
       }
@@ -4579,9 +5296,9 @@ var init_types3 = __esm(() => {
 });
 
 // ../core/src/security/scanner.ts
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 import { lstat, readdir as readdir2, readFile as readFile16, readlink, realpath } from "node:fs/promises";
-import { join as join10, relative, resolve as resolve2 } from "node:path";
+import { join as join9, relative, resolve as resolve2 } from "node:path";
 async function scanFileForUnicode(filePath, relativePath) {
   const findings = [];
   try {
@@ -4665,7 +5382,7 @@ async function scanFileForScripts(filePath, relativePath) {
 async function checkSymlink(symlinkPath, relativePath, capabilityRoot) {
   try {
     const linkTarget = await readlink(symlinkPath);
-    const resolvedTarget = resolve2(join10(symlinkPath, "..", linkTarget));
+    const resolvedTarget = resolve2(join9(symlinkPath, "..", linkTarget));
     const normalizedRoot = await realpath(capabilityRoot);
     if (linkTarget.startsWith("/")) {
       return {
@@ -4700,7 +5417,7 @@ function isTextFile(filePath) {
 async function scanCapability(capabilityId, capabilityPath, settings = DEFAULT_SCAN_SETTINGS) {
   const startTime = Date.now();
   const findings = [];
-  if (!existsSync18(capabilityPath)) {
+  if (!existsSync19(capabilityPath)) {
     return {
       capabilityId,
       path: capabilityPath,
@@ -4712,7 +5429,7 @@ async function scanCapability(capabilityId, capabilityPath, settings = DEFAULT_S
   async function scanDirectory(dirPath) {
     const entries = await readdir2(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join10(dirPath, entry.name);
+      const fullPath = join9(dirPath, entry.name);
       const relativePath = relative(capabilityPath, fullPath);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "__pycache__") {
         continue;
@@ -5172,6 +5889,7 @@ __export(exports_src, {
   verifyIntegrity: () => verifyIntegrity,
   validateHooksConfig: () => validateHooksConfig,
   validateHook: () => validateHook,
+  validateGitCapability: () => validateGitCapability,
   transformToOmnidev: () => transformToOmnidev,
   transformToClaude: () => transformToClaude,
   transformHooksConfig: () => transformHooksConfig,
@@ -5185,6 +5903,8 @@ __export(exports_src, {
   saveManifest: () => saveManifest,
   saveLockFile: () => saveLockFile,
   resolveEnabledCapabilities: () => resolveEnabledCapabilities,
+  resolveCapabilityRootInConfig: () => resolveCapabilityRootInConfig,
+  resolveCapabilityRoot: () => resolveCapabilityRoot,
   removeSecurityAllow: () => removeSecurityAllow,
   readSecurityAllows: () => readSecurityAllows,
   readMcpJson: () => readMcpJson,
@@ -5208,6 +5928,7 @@ __export(exports_src, {
   loadProfileConfig: () => loadProfileConfig,
   loadManifest: () => loadManifest,
   loadLockFile: () => loadLockFile,
+  loadHooksJson: () => loadHooksJson,
   loadHooksFromCapability: () => loadHooksFromCapability,
   loadDocs: () => loadDocs,
   loadConfig: () => loadConfig,
@@ -5290,7 +6011,8 @@ __export(exports_src, {
   DEFAULT_SCAN_SETTINGS: () => DEFAULT_SCAN_SETTINGS,
   DEFAULT_PROMPT_TIMEOUT: () => DEFAULT_PROMPT_TIMEOUT,
   DEFAULT_COMMAND_TIMEOUT: () => DEFAULT_COMMAND_TIMEOUT,
-  COMMON_TOOL_MATCHERS: () => COMMON_TOOL_MATCHERS
+  COMMON_TOOL_MATCHERS: () => COMMON_TOOL_MATCHERS,
+  CLAUDE_HOOKS_CONFIG_FILENAME: () => CLAUDE_HOOKS_CONFIG_FILENAME
 });
 function getVersion() {
   return version;
@@ -5311,51 +6033,59 @@ var init_src = __esm(() => {
 import { run } from "@stricli/core";
 
 // src/lib/dynamic-app.ts
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join18 } from "node:path";
+import { join as join26 } from "node:path";
 import { buildApplication, buildRouteMap as buildRouteMap7 } from "@stricli/core";
 
 // src/commands/add.ts
-import { existsSync as existsSync21 } from "node:fs";
-import { basename as basename3, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { basename as basename5, resolve as resolve3 } from "node:path";
 
-// ../adapters/src/writers/cursor-rules.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-var CursorRulesWriter = {
-  id: "cursor-rules",
-  async write(bundle, ctx) {
-    const rulesDir = join(ctx.projectRoot, ctx.outputPath);
-    await mkdir(rulesDir, { recursive: true });
-    const filesWritten = [];
-    for (const rule of bundle.rules) {
-      const rulePath = join(rulesDir, `omnidev-${rule.name}.mdc`);
-      await writeFile(rulePath, rule.content, "utf-8");
-      filesWritten.push(join(ctx.outputPath, `omnidev-${rule.name}.mdc`));
+// ../adapters/src/writers/generic/executor.ts
+async function executeWriters(writerConfigs, bundle, projectRoot) {
+  const seen = new Set;
+  const uniqueConfigs = [];
+  let deduplicatedCount = 0;
+  for (const config of writerConfigs) {
+    const key = `${config.writer.id}:${config.outputPath}`;
+    if (seen.has(key)) {
+      deduplicatedCount++;
+      continue;
     }
-    return {
-      filesWritten
-    };
+    seen.add(key);
+    uniqueConfigs.push(config);
   }
-};
-// ../adapters/src/writers/hooks.ts
+  const allFilesWritten = [];
+  for (const config of uniqueConfigs) {
+    const result = await config.writer.write(bundle, {
+      outputPath: config.outputPath,
+      projectRoot
+    });
+    allFilesWritten.push(...result.filesWritten);
+  }
+  return {
+    filesWritten: allFilesWritten,
+    deduplicatedCount
+  };
+}
+// ../adapters/src/writers/generic/hooks.ts
 init_src();
-import { existsSync as existsSync19 } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile17, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname, join as join11 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { mkdir as mkdir2, readFile as readFile17, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname, join as join10 } from "node:path";
 var HooksWriter = {
   id: "hooks",
   async write(bundle, ctx) {
     if (!bundle.hooks) {
       return { filesWritten: [] };
     }
-    const settingsPath = join11(ctx.projectRoot, ctx.outputPath);
+    const settingsPath = join10(ctx.projectRoot, ctx.outputPath);
     const parentDir = dirname(settingsPath);
-    await mkdir3(parentDir, { recursive: true });
+    await mkdir2(parentDir, { recursive: true });
     const claudeHooks = transformHooksConfig(bundle.hooks, "toClaude");
     let existingSettings = {};
-    if (existsSync19(settingsPath)) {
+    if (existsSync20(settingsPath)) {
       try {
         const content = await readFile17(settingsPath, "utf-8");
         existingSettings = JSON.parse(content);
@@ -5367,28 +6097,28 @@ var HooksWriter = {
       ...existingSettings,
       hooks: claudeHooks
     };
-    await writeFile11(settingsPath, `${JSON.stringify(newSettings, null, 2)}
+    await writeFile10(settingsPath, `${JSON.stringify(newSettings, null, 2)}
 `, "utf-8");
     return {
       filesWritten: [ctx.outputPath]
     };
   }
 };
-// ../adapters/src/writers/instructions-md.ts
-import { existsSync as existsSync20 } from "node:fs";
-import { mkdir as mkdir4, readFile as readFile18, writeFile as writeFile12 } from "node:fs/promises";
-import { dirname as dirname2, join as join12 } from "node:path";
+// ../adapters/src/writers/generic/instructions-md.ts
+import { existsSync as existsSync21 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile18, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname2, join as join11 } from "node:path";
 var InstructionsMdWriter = {
   id: "instructions-md",
   async write(bundle, ctx) {
-    const outputFullPath = join12(ctx.projectRoot, ctx.outputPath);
+    const outputFullPath = join11(ctx.projectRoot, ctx.outputPath);
     const parentDir = dirname2(outputFullPath);
     if (parentDir !== ctx.projectRoot) {
-      await mkdir4(parentDir, { recursive: true });
+      await mkdir3(parentDir, { recursive: true });
     }
-    const omniMdPath = join12(ctx.projectRoot, "OMNI.md");
+    const omniMdPath = join11(ctx.projectRoot, "OMNI.md");
     let omniMdContent = "";
-    if (existsSync20(omniMdPath)) {
+    if (existsSync21(omniMdPath)) {
       omniMdContent = await readFile18(omniMdPath, "utf-8");
     }
     let content = omniMdContent;
@@ -5398,66 +6128,121 @@ var InstructionsMdWriter = {
 ${bundle.instructionsContent}
 `;
     }
-    await writeFile12(outputFullPath, content, "utf-8");
+    await writeFile11(outputFullPath, content, "utf-8");
     return {
       filesWritten: [ctx.outputPath]
     };
   }
 };
-// ../adapters/src/writers/skills.ts
-import { mkdir as mkdir5, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+// ../adapters/src/writers/generic/skills.ts
+import { mkdir as mkdir4, writeFile as writeFile12 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 var SkillsWriter = {
   id: "skills",
   async write(bundle, ctx) {
-    const skillsDir = join13(ctx.projectRoot, ctx.outputPath);
-    await mkdir5(skillsDir, { recursive: true });
+    const skillsDir = join12(ctx.projectRoot, ctx.outputPath);
+    await mkdir4(skillsDir, { recursive: true });
     const filesWritten = [];
     for (const skill of bundle.skills) {
-      const skillDir = join13(skillsDir, skill.name);
-      await mkdir5(skillDir, { recursive: true });
-      const skillPath = join13(skillDir, "SKILL.md");
+      const skillDir = join12(skillsDir, skill.name);
+      await mkdir4(skillDir, { recursive: true });
+      const skillPath = join12(skillDir, "SKILL.md");
       const content = `---
 name: ${skill.name}
 description: "${skill.description}"
 ---
 
 ${skill.instructions}`;
-      await writeFile13(skillPath, content, "utf-8");
-      filesWritten.push(join13(ctx.outputPath, skill.name, "SKILL.md"));
+      await writeFile12(skillPath, content, "utf-8");
+      filesWritten.push(join12(ctx.outputPath, skill.name, "SKILL.md"));
     }
     return {
       filesWritten
     };
   }
 };
-// ../adapters/src/writers/executor.ts
-async function executeWriters(writerConfigs, bundle, projectRoot) {
-  const seen = new Set;
-  const uniqueConfigs = [];
-  let deduplicatedCount = 0;
-  for (const config3 of writerConfigs) {
-    const key = `${config3.writer.id}:${config3.outputPath}`;
-    if (seen.has(key)) {
-      deduplicatedCount++;
-      continue;
+// ../adapters/src/writers/generic/commands-as-skills.ts
+import { mkdir as mkdir5, writeFile as writeFile13 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+function generateSkillFrontmatter(command) {
+  const lines = ["---"];
+  lines.push(`name: ${command.name}`);
+  lines.push(`description: "${command.description.replace(/"/g, "\\\"")}"`);
+  if (command.allowedTools) {
+    lines.push(`allowed_tools: "${command.allowedTools}"`);
+  }
+  lines.push("---");
+  return lines.join(`
+`);
+}
+var CommandsAsSkillsWriter = {
+  id: "commands-as-skills",
+  async write(bundle, ctx) {
+    const skillsDir = join13(ctx.projectRoot, ctx.outputPath);
+    await mkdir5(skillsDir, { recursive: true });
+    const filesWritten = [];
+    for (const command of bundle.commands) {
+      const commandSkillDir = join13(skillsDir, command.name);
+      await mkdir5(commandSkillDir, { recursive: true });
+      const frontmatter = generateSkillFrontmatter(command);
+      const content = `${frontmatter}
+
+${command.prompt}`;
+      const skillPath = join13(commandSkillDir, "SKILL.md");
+      await writeFile13(skillPath, content, "utf-8");
+      filesWritten.push(join13(ctx.outputPath, command.name, "SKILL.md"));
     }
-    seen.add(key);
-    uniqueConfigs.push(config3);
+    return {
+      filesWritten
+    };
   }
-  const allFilesWritten = [];
-  for (const config3 of uniqueConfigs) {
-    const result = await config3.writer.write(bundle, {
-      outputPath: config3.outputPath,
-      projectRoot
-    });
-    allFilesWritten.push(...result.filesWritten);
+};
+// ../adapters/src/writers/claude/agents.ts
+import { mkdir as mkdir6, writeFile as writeFile14 } from "node:fs/promises";
+import { join as join14 } from "node:path";
+function generateFrontmatter(agent) {
+  const lines = ["---"];
+  lines.push(`name: ${agent.name}`);
+  lines.push(`description: "${agent.description.replace(/"/g, "\\\"")}"`);
+  if (agent.tools && agent.tools.length > 0) {
+    lines.push(`tools: ${agent.tools.join(", ")}`);
   }
-  return {
-    filesWritten: allFilesWritten,
-    deduplicatedCount
-  };
+  if (agent.disallowedTools && agent.disallowedTools.length > 0) {
+    lines.push(`disallowedTools: ${agent.disallowedTools.join(", ")}`);
+  }
+  if (agent.model && agent.model !== "inherit") {
+    lines.push(`model: ${agent.model}`);
+  }
+  if (agent.permissionMode && agent.permissionMode !== "default") {
+    lines.push(`permissionMode: ${agent.permissionMode}`);
+  }
+  if (agent.skills && agent.skills.length > 0) {
+    lines.push(`skills: ${agent.skills.join(", ")}`);
+  }
+  lines.push("---");
+  return lines.join(`
+`);
 }
+var ClaudeAgentsWriter = {
+  id: "claude-agents",
+  async write(bundle, ctx) {
+    const agentsDir = join14(ctx.projectRoot, ctx.outputPath);
+    await mkdir6(agentsDir, { recursive: true });
+    const filesWritten = [];
+    for (const agent of bundle.subagents) {
+      const frontmatter = generateFrontmatter(agent);
+      const content = `${frontmatter}
+
+${agent.systemPrompt}`;
+      const agentPath = join14(agentsDir, `${agent.name}.md`);
+      await writeFile14(agentPath, content, "utf-8");
+      filesWritten.push(join14(ctx.outputPath, `${agent.name}.md`));
+    }
+    return {
+      filesWritten
+    };
+  }
+};
 // ../adapters/src/claude-code/index.ts
 var claudeCodeAdapter = {
   id: "claude-code",
@@ -5465,6 +6250,8 @@ var claudeCodeAdapter = {
   writers: [
     { writer: InstructionsMdWriter, outputPath: "CLAUDE.md" },
     { writer: SkillsWriter, outputPath: ".claude/skills/" },
+    { writer: ClaudeAgentsWriter, outputPath: ".claude/agents/" },
+    { writer: CommandsAsSkillsWriter, outputPath: ".claude/skills/" },
     { writer: HooksWriter, outputPath: ".claude/settings.json" }
   ],
   async init(_ctx) {
@@ -5483,16 +6270,97 @@ var claudeCodeAdapter = {
 };
 // ../adapters/src/codex/index.ts
 import { mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
+
+// ../adapters/src/writers/codex/toml.ts
+init_dist();
+import { mkdir as mkdir7, writeFile as writeFile15 } from "node:fs/promises";
+import { dirname as dirname3, join as join15 } from "node:path";
+var FILE_HEADER = `# Generated by OmniDev - DO NOT EDIT
+# Run \`omnidev sync\` to regenerate
+
+`;
+function buildCodexMcpConfig(id, mcp) {
+  const transport = mcp.transport ?? "stdio";
+  if (transport === "sse") {
+    console.warn(`  Warning: Skipping MCP "${id}" - SSE transport is not supported by Codex`);
+    return null;
+  }
+  const config3 = {};
+  if (transport === "http") {
+    if (mcp.url) {
+      config3.url = mcp.url;
+    }
+    if (mcp.headers && Object.keys(mcp.headers).length > 0) {
+      config3.http_headers = mcp.headers;
+    }
+  } else {
+    if (mcp.command) {
+      config3.command = mcp.command;
+    }
+    if (mcp.args && mcp.args.length > 0) {
+      config3.args = mcp.args;
+    }
+    if (mcp.env && Object.keys(mcp.env).length > 0) {
+      config3.env = mcp.env;
+    }
+    if (mcp.cwd) {
+      config3.cwd = mcp.cwd;
+    }
+  }
+  return config3;
+}
+function collectMcps(bundle) {
+  const mcps = new Map;
+  for (const capability3 of bundle.capabilities) {
+    if (capability3.config.mcp) {
+      mcps.set(capability3.id, capability3.config.mcp);
+    }
+  }
+  return mcps;
+}
+var CodexTomlWriter = {
+  id: "codex-toml",
+  async write(bundle, ctx) {
+    const mcps = collectMcps(bundle);
+    if (mcps.size === 0) {
+      return { filesWritten: [] };
+    }
+    const configPath = join15(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname3(configPath);
+    await mkdir7(parentDir, { recursive: true });
+    const mcpServers = {};
+    for (const [id, mcp] of mcps) {
+      const converted = buildCodexMcpConfig(id, mcp);
+      if (converted) {
+        mcpServers[id] = converted;
+      }
+    }
+    if (Object.keys(mcpServers).length === 0) {
+      return { filesWritten: [] };
+    }
+    const codexConfig = {
+      mcp_servers: mcpServers
+    };
+    const tomlContent = FILE_HEADER + stringify(codexConfig);
+    await writeFile15(configPath, tomlContent, "utf-8");
+    return {
+      filesWritten: [ctx.outputPath]
+    };
+  }
+};
+// ../adapters/src/codex/index.ts
 var codexAdapter = {
   id: "codex",
   displayName: "Codex",
   writers: [
     { writer: InstructionsMdWriter, outputPath: "AGENTS.md" },
-    { writer: SkillsWriter, outputPath: ".codex/skills/" }
+    { writer: SkillsWriter, outputPath: ".codex/skills/" },
+    { writer: CommandsAsSkillsWriter, outputPath: ".codex/skills/" },
+    { writer: CodexTomlWriter, outputPath: ".codex/config.toml" }
   ],
   async init(ctx) {
-    const codexDir = join14(ctx.projectRoot, ".codex");
+    const codexDir = join16(ctx.projectRoot, ".codex");
     mkdirSync6(codexDir, { recursive: true });
     return {
       filesCreated: [".codex/"],
@@ -5509,17 +6377,186 @@ var codexAdapter = {
 };
 // ../adapters/src/cursor/index.ts
 import { mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join21 } from "node:path";
+
+// ../adapters/src/writers/cursor/agents.ts
+import { mkdir as mkdir8, writeFile as writeFile16 } from "node:fs/promises";
+import { join as join17 } from "node:path";
+function mapModelToCursor(model) {
+  if (!model || model === "inherit")
+    return "inherit";
+  const modelMap = {
+    haiku: "fast",
+    sonnet: "inherit",
+    opus: "inherit"
+  };
+  return modelMap[model] ?? "inherit";
+}
+function generateFrontmatter2(agent) {
+  const lines = ["---"];
+  lines.push(`name: ${agent.name}`);
+  lines.push(`description: "${agent.description.replace(/"/g, "\\\"")}"`);
+  const model = mapModelToCursor(agent.model);
+  if (model) {
+    lines.push(`model: ${model}`);
+  }
+  if (agent.permissionMode === "plan") {
+    lines.push("readonly: true");
+  }
+  if (agent.isBackground) {
+    lines.push("is_background: true");
+  }
+  lines.push("---");
+  return lines.join(`
+`);
+}
+var CursorAgentsWriter = {
+  id: "cursor-agents",
+  async write(bundle, ctx) {
+    const agentsDir = join17(ctx.projectRoot, ctx.outputPath);
+    await mkdir8(agentsDir, { recursive: true });
+    const filesWritten = [];
+    for (const agent of bundle.subagents) {
+      const frontmatter = generateFrontmatter2(agent);
+      const content = `${frontmatter}
+
+${agent.systemPrompt}`;
+      const agentPath = join17(agentsDir, `${agent.name}.md`);
+      await writeFile16(agentPath, content, "utf-8");
+      filesWritten.push(join17(ctx.outputPath, `${agent.name}.md`));
+    }
+    return {
+      filesWritten
+    };
+  }
+};
+// ../adapters/src/writers/cursor/commands.ts
+import { mkdir as mkdir9, writeFile as writeFile17 } from "node:fs/promises";
+import { join as join18 } from "node:path";
+var CursorCommandsWriter = {
+  id: "cursor-commands",
+  async write(bundle, ctx) {
+    const commandsDir = join18(ctx.projectRoot, ctx.outputPath);
+    await mkdir9(commandsDir, { recursive: true });
+    const filesWritten = [];
+    for (const command of bundle.commands) {
+      const content = `# ${command.name}
+
+${command.description}
+
+${command.prompt}`;
+      const commandPath = join18(commandsDir, `${command.name}.md`);
+      await writeFile17(commandPath, content, "utf-8");
+      filesWritten.push(join18(ctx.outputPath, `${command.name}.md`));
+    }
+    return {
+      filesWritten
+    };
+  }
+};
+// ../adapters/src/writers/cursor/mcp-json.ts
+import { mkdir as mkdir10, writeFile as writeFile18 } from "node:fs/promises";
+import { dirname as dirname4, join as join19 } from "node:path";
+function buildCursorMcpConfig(mcp) {
+  const transport = mcp.transport ?? "stdio";
+  if (transport === "http" || transport === "sse") {
+    if (!mcp.url) {
+      return null;
+    }
+    const config4 = {
+      url: mcp.url
+    };
+    if (mcp.headers && Object.keys(mcp.headers).length > 0) {
+      config4.headers = mcp.headers;
+    }
+    return config4;
+  }
+  if (!mcp.command) {
+    return null;
+  }
+  const config3 = {
+    command: mcp.command
+  };
+  if (mcp.args && mcp.args.length > 0) {
+    config3.args = mcp.args;
+  }
+  if (mcp.env && Object.keys(mcp.env).length > 0) {
+    config3.env = mcp.env;
+  }
+  return config3;
+}
+function collectMcps2(bundle) {
+  const mcps = new Map;
+  for (const capability3 of bundle.capabilities) {
+    if (capability3.config.mcp) {
+      mcps.set(capability3.id, capability3.config.mcp);
+    }
+  }
+  return mcps;
+}
+var CursorMcpJsonWriter = {
+  id: "cursor-mcp-json",
+  async write(bundle, ctx) {
+    const mcps = collectMcps2(bundle);
+    if (mcps.size === 0) {
+      return { filesWritten: [] };
+    }
+    const configPath = join19(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname4(configPath);
+    await mkdir10(parentDir, { recursive: true });
+    const mcpServers = {};
+    for (const [id, mcp] of mcps) {
+      const converted = buildCursorMcpConfig(mcp);
+      if (converted) {
+        mcpServers[id] = converted;
+      }
+    }
+    if (Object.keys(mcpServers).length === 0) {
+      return { filesWritten: [] };
+    }
+    const cursorMcpJson = {
+      mcpServers
+    };
+    await writeFile18(configPath, `${JSON.stringify(cursorMcpJson, null, 2)}
+`, "utf-8");
+    return {
+      filesWritten: [ctx.outputPath]
+    };
+  }
+};
+// ../adapters/src/writers/cursor/rules.ts
+import { mkdir as mkdir11, writeFile as writeFile19 } from "node:fs/promises";
+import { join as join20 } from "node:path";
+var CursorRulesWriter = {
+  id: "cursor-rules",
+  async write(bundle, ctx) {
+    const rulesDir = join20(ctx.projectRoot, ctx.outputPath);
+    await mkdir11(rulesDir, { recursive: true });
+    const filesWritten = [];
+    for (const rule of bundle.rules) {
+      const rulePath = join20(rulesDir, `omnidev-${rule.name}.mdc`);
+      await writeFile19(rulePath, rule.content, "utf-8");
+      filesWritten.push(join20(ctx.outputPath, `omnidev-${rule.name}.mdc`));
+    }
+    return {
+      filesWritten
+    };
+  }
+};
+// ../adapters/src/cursor/index.ts
 var cursorAdapter = {
   id: "cursor",
   displayName: "Cursor",
   writers: [
     { writer: InstructionsMdWriter, outputPath: "CLAUDE.md" },
-    { writer: SkillsWriter, outputPath: ".claude/skills/" },
-    { writer: CursorRulesWriter, outputPath: ".cursor/rules/" }
+    { writer: SkillsWriter, outputPath: ".cursor/skills/" },
+    { writer: CursorRulesWriter, outputPath: ".cursor/rules/" },
+    { writer: CursorAgentsWriter, outputPath: ".cursor/agents/" },
+    { writer: CursorCommandsWriter, outputPath: ".cursor/commands/" },
+    { writer: CursorMcpJsonWriter, outputPath: ".cursor/mcp.json" }
   ],
   async init(ctx) {
-    const rulesDir = join15(ctx.projectRoot, ".cursor", "rules");
+    const rulesDir = join21(ctx.projectRoot, ".cursor", "rules");
     mkdirSync7(rulesDir, { recursive: true });
     return {
       filesCreated: [".cursor/rules/"],
@@ -5536,16 +6573,153 @@ var cursorAdapter = {
 };
 // ../adapters/src/opencode/index.ts
 import { mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join24 } from "node:path";
+
+// ../adapters/src/writers/opencode/agents.ts
+import { mkdir as mkdir12, writeFile as writeFile20 } from "node:fs/promises";
+import { join as join22 } from "node:path";
+function mapModelToOpenCode(model) {
+  if (!model || model === "inherit")
+    return;
+  const modelMap = {
+    sonnet: "anthropic/claude-sonnet-4",
+    opus: "anthropic/claude-opus-4",
+    haiku: "anthropic/claude-haiku-3-5"
+  };
+  return modelMap[model];
+}
+function mapPermissionsToOpenCode(permissionMode) {
+  if (!permissionMode || permissionMode === "default")
+    return;
+  const permissionMap = {
+    acceptEdits: { edit: "allow", bash: { "*": "ask" } },
+    dontAsk: { edit: "allow", bash: { "*": "allow" } },
+    bypassPermissions: { edit: "allow", bash: { "*": "allow" }, webfetch: "allow" },
+    plan: { edit: "deny", bash: { "*": "deny" } }
+  };
+  return permissionMap[permissionMode];
+}
+function mapToolsToOpenCode(tools) {
+  if (!tools || tools.length === 0)
+    return;
+  const toolsObject = {};
+  for (const tool of tools) {
+    toolsObject[tool.toLowerCase()] = true;
+  }
+  return toolsObject;
+}
+function generateFrontmatter3(agent) {
+  const lines = ["---"];
+  lines.push(`description: "${agent.description.replace(/"/g, "\\\"")}"`);
+  const modelId = agent.modelId ?? mapModelToOpenCode(agent.model);
+  if (modelId) {
+    lines.push(`model: ${modelId}`);
+  }
+  if (agent.mode) {
+    lines.push(`mode: ${agent.mode}`);
+  }
+  if (agent.temperature !== undefined) {
+    lines.push(`temperature: ${agent.temperature}`);
+  }
+  if (agent.maxSteps !== undefined) {
+    lines.push(`maxSteps: ${agent.maxSteps}`);
+  }
+  if (agent.hidden !== undefined) {
+    lines.push(`hidden: ${agent.hidden}`);
+  }
+  const toolsObj = agent.toolPermissions ?? mapToolsToOpenCode(agent.tools);
+  if (toolsObj) {
+    lines.push("tools:");
+    for (const [tool, enabled] of Object.entries(toolsObj)) {
+      lines.push(`  ${tool}: ${enabled}`);
+    }
+  }
+  const permissions = agent.permissions ?? mapPermissionsToOpenCode(agent.permissionMode);
+  if (permissions) {
+    lines.push("permissions:");
+    for (const [key, value] of Object.entries(permissions)) {
+      if (typeof value === "object") {
+        lines.push(`  ${key}:`);
+        for (const [subKey, subValue] of Object.entries(value)) {
+          lines.push(`    ${subKey}: ${subValue}`);
+        }
+      } else {
+        lines.push(`  ${key}: ${value}`);
+      }
+    }
+  }
+  lines.push("---");
+  return lines.join(`
+`);
+}
+var OpenCodeAgentsWriter = {
+  id: "opencode-agents",
+  async write(bundle, ctx) {
+    const agentsDir = join22(ctx.projectRoot, ctx.outputPath);
+    await mkdir12(agentsDir, { recursive: true });
+    const filesWritten = [];
+    for (const agent of bundle.subagents) {
+      const frontmatter = generateFrontmatter3(agent);
+      const content = `${frontmatter}
+
+${agent.systemPrompt}`;
+      const agentPath = join22(agentsDir, `${agent.name}.md`);
+      await writeFile20(agentPath, content, "utf-8");
+      filesWritten.push(join22(ctx.outputPath, `${agent.name}.md`));
+    }
+    return {
+      filesWritten
+    };
+  }
+};
+// ../adapters/src/writers/opencode/commands.ts
+import { mkdir as mkdir13, writeFile as writeFile21 } from "node:fs/promises";
+import { join as join23 } from "node:path";
+function generateFrontmatter4(command) {
+  const lines = ["---"];
+  lines.push(`description: "${command.description.replace(/"/g, "\\\"")}"`);
+  if (command.modelId) {
+    lines.push(`model: ${command.modelId}`);
+  }
+  if (command.agent) {
+    lines.push(`agent: ${command.agent}`);
+  }
+  lines.push("---");
+  return lines.join(`
+`);
+}
+var OpenCodeCommandsWriter = {
+  id: "opencode-commands",
+  async write(bundle, ctx) {
+    const commandsDir = join23(ctx.projectRoot, ctx.outputPath);
+    await mkdir13(commandsDir, { recursive: true });
+    const filesWritten = [];
+    for (const command of bundle.commands) {
+      const frontmatter = generateFrontmatter4(command);
+      const content = `${frontmatter}
+
+${command.prompt}`;
+      const commandPath = join23(commandsDir, `${command.name}.md`);
+      await writeFile21(commandPath, content, "utf-8");
+      filesWritten.push(join23(ctx.outputPath, `${command.name}.md`));
+    }
+    return {
+      filesWritten
+    };
+  }
+};
+// ../adapters/src/opencode/index.ts
 var opencodeAdapter = {
   id: "opencode",
   displayName: "OpenCode",
   writers: [
     { writer: InstructionsMdWriter, outputPath: "AGENTS.md" },
-    { writer: SkillsWriter, outputPath: ".opencode/skills/" }
+    { writer: SkillsWriter, outputPath: ".opencode/skills/" },
+    { writer: OpenCodeAgentsWriter, outputPath: ".opencode/agents/" },
+    { writer: OpenCodeCommandsWriter, outputPath: ".opencode/commands/" }
   ],
   async init(ctx) {
-    const opencodeDir = join16(ctx.projectRoot, ".opencode");
+    const opencodeDir = join24(ctx.projectRoot, ".opencode");
     mkdirSync8(opencodeDir, { recursive: true });
     return {
       filesCreated: [".opencode/"],
@@ -5587,7 +6761,7 @@ async function inferCapabilityId(source, sourceType) {
     if (id) {
       return id;
     }
-    return basename3(resolvedPath);
+    return basename5(resolvedPath);
   }
   const parts = source.replace("github:", "").split("/");
   if (parts.length >= 2) {
@@ -5597,7 +6771,7 @@ async function inferCapabilityId(source, sourceType) {
 }
 async function runAddCap(flags, name) {
   try {
-    if (!existsSync21("omni.toml")) {
+    if (!existsSync22("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -5620,7 +6794,7 @@ async function runAddCap(flags, name) {
       sourceType = "local";
       const localPath = flags.local.startsWith("file://") ? flags.local.slice(7) : flags.local;
       source = `file://${localPath}`;
-      if (!existsSync21(localPath)) {
+      if (!existsSync22(localPath)) {
         console.error(`✗ Local path not found: ${localPath}`);
         process.exit(1);
       }
@@ -5633,6 +6807,17 @@ async function runAddCap(flags, name) {
         process.exit(1);
       }
       source = `github:${flags.github}`;
+      console.log(`  Validating repository ${flags.github}...`);
+      const validation = await validateGitCapability(source, flags.path);
+      if (!validation.valid) {
+        console.error(`✗ ${validation.error}`);
+        process.exit(1);
+      }
+      if (validation.hasCapabilityToml) {
+        console.log(`  Found capability.toml`);
+      } else {
+        console.log(`  Repository can be auto-wrapped as capability`);
+      }
     } else {
       throw new Error("Unreachable: no source specified");
     }
@@ -5701,7 +6886,7 @@ async function runAddCap(flags, name) {
 }
 async function runAddMcp(flags, name) {
   try {
-    if (!existsSync21("omni.toml")) {
+    if (!existsSync22("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -5832,12 +7017,16 @@ If the capability name is omitted, it will be inferred from:
 - For local sources: the ID in capability.toml or directory name
 - For GitHub sources: the repository name or last path segment
 
+Claude plugins (.claude-plugin/plugin.json) are automatically wrapped as OmniDev capabilities.
+Hooks defined in hooks.json are also supported and will be synced to .claude/settings.json.
+
 Examples:
   omnidev add cap my-cap --github expo/skills              # Uses version = "latest"
   omnidev add cap --github expo/skills                     # Infers name as "skills"
   omnidev add cap --github expo/skills --pin               # Pins to detected version
   omnidev add cap --local ./capabilities/my-cap            # Infers name from capability.toml
-  omnidev add cap custom-name --local ./capabilities/my-cap`
+  omnidev add cap custom-name --local ./capabilities/my-cap
+  omnidev add cap --github user/claude-plugin              # Auto-wraps Claude plugins`
   },
   parameters: {
     flags: {
@@ -5984,9 +7173,9 @@ var addRoutes = buildRouteMap({
 });
 
 // src/commands/capability.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync9 } from "node:fs";
-import { writeFile as writeFile14 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync9 } from "node:fs";
+import { writeFile as writeFile22 } from "node:fs/promises";
+import { join as join25 } from "node:path";
 import { input } from "@inquirer/prompts";
 init_src();
 import { buildCommand as buildCommand2, buildRouteMap as buildRouteMap2 } from "@stricli/core";
@@ -6171,7 +7360,7 @@ node_modules/
 }
 async function runCapabilityNew(flags, capabilityId) {
   try {
-    if (!existsSync22(".omni")) {
+    if (!existsSync23(".omni")) {
       console.error("✗ OmniDev is not initialized in this directory.");
       console.log("");
       console.log("  Run: omnidev init");
@@ -6195,28 +7384,28 @@ async function runCapabilityNew(flags, capabilityId) {
         default: defaultPath
       });
     }
-    if (existsSync22(capabilityDir)) {
+    if (existsSync23(capabilityDir)) {
       console.error(`✗ Directory already exists at ${capabilityDir}`);
       process.exit(1);
     }
     const name = toTitleCase(id);
     mkdirSync9(capabilityDir, { recursive: true });
     const capabilityToml = generateCapabilityToml2({ id, name });
-    await writeFile14(join17(capabilityDir, "capability.toml"), capabilityToml, "utf-8");
-    const skillDir = join17(capabilityDir, "skills", "getting-started");
+    await writeFile22(join25(capabilityDir, "capability.toml"), capabilityToml, "utf-8");
+    const skillDir = join25(capabilityDir, "skills", "getting-started");
     mkdirSync9(skillDir, { recursive: true });
-    await writeFile14(join17(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
-    const rulesDir = join17(capabilityDir, "rules");
+    await writeFile22(join25(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
+    const rulesDir = join25(capabilityDir, "rules");
     mkdirSync9(rulesDir, { recursive: true });
-    await writeFile14(join17(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
-    const hooksDir = join17(capabilityDir, "hooks");
+    await writeFile22(join25(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
+    const hooksDir = join25(capabilityDir, "hooks");
     mkdirSync9(hooksDir, { recursive: true });
-    await writeFile14(join17(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
-    await writeFile14(join17(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
+    await writeFile22(join25(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
+    await writeFile22(join25(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
     if (flags.programmatic) {
-      await writeFile14(join17(capabilityDir, "package.json"), generatePackageJson(id), "utf-8");
-      await writeFile14(join17(capabilityDir, "index.ts"), generateIndexTs(id, name), "utf-8");
-      await writeFile14(join17(capabilityDir, ".gitignore"), generateGitignore(), "utf-8");
+      await writeFile22(join25(capabilityDir, "package.json"), generatePackageJson(id), "utf-8");
+      await writeFile22(join25(capabilityDir, "index.ts"), generateIndexTs(id, name), "utf-8");
+      await writeFile22(join25(capabilityDir, ".gitignore"), generateGitignore(), "utf-8");
     }
     console.log(`✓ Created capability: ${name}`);
     console.log(`  Location: ${capabilityDir}`);
@@ -6372,7 +7561,7 @@ var capabilityRoutes = buildRouteMap2({
 });
 
 // src/commands/doctor.ts
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync24 } from "node:fs";
 import { execFile } from "node:child_process";
 import { readFile as readFile19 } from "node:fs/promises";
 import { promisify } from "node:util";
@@ -6462,7 +7651,7 @@ async function checkPackageManager() {
   }
 }
 async function checkOmniLocalDir() {
-  const exists = existsSync23(".omni");
+  const exists = existsSync24(".omni");
   if (!exists) {
     return {
       name: ".omni/ directory",
@@ -6479,7 +7668,7 @@ async function checkOmniLocalDir() {
 }
 async function checkConfig() {
   const configPath = "omni.toml";
-  if (!existsSync23(configPath)) {
+  if (!existsSync24(configPath)) {
     return {
       name: "Configuration",
       passed: false,
@@ -6506,7 +7695,7 @@ async function checkConfig() {
 }
 async function checkRootGitignore() {
   const gitignorePath = ".gitignore";
-  if (!existsSync23(gitignorePath)) {
+  if (!existsSync24(gitignorePath)) {
     return {
       name: "Root .gitignore",
       passed: false,
@@ -6540,7 +7729,7 @@ async function checkRootGitignore() {
 }
 async function checkCapabilitiesDir() {
   const capabilitiesDirPath = ".omni/capabilities";
-  if (!existsSync23(capabilitiesDirPath)) {
+  if (!existsSync24(capabilitiesDirPath)) {
     return {
       name: "Capabilities Directory",
       passed: true,
@@ -6556,8 +7745,8 @@ async function checkCapabilitiesDir() {
 
 // src/commands/init.ts
 import { exec } from "node:child_process";
-import { existsSync as existsSync24, mkdirSync as mkdirSync10 } from "node:fs";
-import { readFile as readFile20, writeFile as writeFile15 } from "node:fs/promises";
+import { existsSync as existsSync25, mkdirSync as mkdirSync10 } from "node:fs";
+import { readFile as readFile20, writeFile as writeFile23 } from "node:fs/promises";
 import { promisify as promisify2 } from "node:util";
 init_src();
 import { buildCommand as buildCommand4 } from "@stricli/core";
@@ -6626,7 +7815,7 @@ async function runInit(_flags, providerArg) {
     }
   }
   await writeEnabledProviders(providerIds);
-  if (!existsSync24("omni.toml")) {
+  if (!existsSync25("omni.toml")) {
     await writeConfig({
       profiles: {
         default: {
@@ -6642,8 +7831,8 @@ async function runInit(_flags, providerArg) {
     });
     await setActiveProfile("default");
   }
-  if (!existsSync24("OMNI.md")) {
-    await writeFile15("OMNI.md", generateOmniMdTemplate(), "utf-8");
+  if (!existsSync25("OMNI.md")) {
+    await writeFile23("OMNI.md", generateOmniMdTemplate(), "utf-8");
   }
   const config3 = await loadConfig();
   const ctx = {
@@ -6720,7 +7909,7 @@ async function addProviderFilesToGitignore(entries) {
 async function addToGitignore(entriesToAdd, sectionHeader) {
   const gitignorePath = ".gitignore";
   let content = "";
-  if (existsSync24(gitignorePath)) {
+  if (existsSync25(gitignorePath)) {
     content = await readFile20(gitignorePath, "utf-8");
   }
   const lines = content.split(`
@@ -6736,7 +7925,7 @@ async function addToGitignore(entriesToAdd, sectionHeader) {
 ${missingEntries.join(`
 `)}
 `;
-  await writeFile15(gitignorePath, content + section, "utf-8");
+  await writeFile23(gitignorePath, content + section, "utf-8");
 }
 async function getTrackedProviderFiles(files) {
   const tracked = [];
@@ -6752,7 +7941,7 @@ async function getTrackedProviderFiles(files) {
 }
 
 // src/commands/profile.ts
-import { existsSync as existsSync25 } from "node:fs";
+import { existsSync as existsSync26 } from "node:fs";
 init_src();
 import { buildCommand as buildCommand5, buildRouteMap as buildRouteMap3 } from "@stricli/core";
 var listCommand2 = buildCommand5({
@@ -6796,7 +7985,7 @@ var profileRoutes = buildRouteMap3({
 });
 async function runProfileList() {
   try {
-    if (!existsSync25("omni.toml")) {
+    if (!existsSync26("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -6836,7 +8025,7 @@ async function runProfileList() {
 }
 async function runProfileSet(profileName) {
   try {
-    if (!existsSync25("omni.toml")) {
+    if (!existsSync26("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -6985,7 +8174,7 @@ var providerRoutes = buildRouteMap4({
 
 // src/commands/security.ts
 init_src();
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { buildCommand as buildCommand7, buildRouteMap as buildRouteMap5 } from "@stricli/core";
 var VALID_FINDING_TYPES = [
   "unicode_bidi",
@@ -7102,7 +8291,7 @@ function formatFindingsWithHints(summary) {
 }
 async function runSecurityIssues(flags = {}) {
   try {
-    if (!existsSync26("omni.toml")) {
+    if (!existsSync27("omni.toml")) {
       console.log("No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -7357,7 +8546,7 @@ var securityRoutes = buildRouteMap5({
 });
 
 // src/commands/sync.ts
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 init_src();
 import { buildCommand as buildCommand8 } from "@stricli/core";
 var PROVIDERS_STATE_PATH = ".omni/state/providers.json";
@@ -7375,7 +8564,7 @@ async function runSync() {
     const config3 = await loadConfig();
     const activeProfile = await getActiveProfile() ?? "default";
     let adapters = await getEnabledAdapters();
-    if (!existsSync27(PROVIDERS_STATE_PATH) || adapters.length === 0) {
+    if (!existsSync28(PROVIDERS_STATE_PATH) || adapters.length === 0) {
       console.log("No providers configured yet. Select your provider(s):");
       const providerIds = await promptForProviders();
       await writeEnabledProviders(providerIds);
@@ -7585,9 +8774,9 @@ async function buildDynamicApp() {
     security: securityRoutes
   };
   debug("Core routes registered", Object.keys(routes));
-  const configPath = join18(process.cwd(), "omni.toml");
-  debug("Checking for config", { configPath, exists: existsSync28(configPath), cwd: process.cwd() });
-  if (existsSync28(configPath)) {
+  const configPath = join26(process.cwd(), "omni.toml");
+  debug("Checking for config", { configPath, exists: existsSync29(configPath), cwd: process.cwd() });
+  if (existsSync29(configPath)) {
     try {
       debug("Loading capability commands...");
       const capabilityCommands = await loadCapabilityCommands();
@@ -7662,25 +8851,25 @@ async function loadCapabilityCommands() {
   return commands;
 }
 async function loadCapabilityExport(capability3) {
-  const capabilityPath = join18(process.cwd(), capability3.path);
-  const builtIndexPath = join18(capabilityPath, "dist", "index.js");
-  const jsIndexPath = join18(capabilityPath, "index.js");
-  const tsIndexPath = join18(capabilityPath, "index.ts");
+  const capabilityPath = join26(process.cwd(), capability3.path);
+  const builtIndexPath = join26(capabilityPath, "dist", "index.js");
+  const jsIndexPath = join26(capabilityPath, "index.js");
+  const tsIndexPath = join26(capabilityPath, "index.ts");
   debug(`Checking entry points for '${capability3.id}'`, {
     capabilityPath,
     builtIndexPath,
-    builtExists: existsSync28(builtIndexPath),
+    builtExists: existsSync29(builtIndexPath),
     jsIndexPath,
-    jsExists: existsSync28(jsIndexPath),
+    jsExists: existsSync29(jsIndexPath),
     tsIndexPath,
-    tsExists: existsSync28(tsIndexPath)
+    tsExists: existsSync29(tsIndexPath)
   });
   let indexPath = null;
-  if (existsSync28(builtIndexPath)) {
+  if (existsSync29(builtIndexPath)) {
     indexPath = builtIndexPath;
-  } else if (existsSync28(jsIndexPath)) {
+  } else if (existsSync29(jsIndexPath)) {
     indexPath = jsIndexPath;
-  } else if (existsSync28(tsIndexPath)) {
+  } else if (existsSync29(tsIndexPath)) {
     indexPath = tsIndexPath;
   }
   if (!indexPath) {