@omnidev-ai/cli 0.13.1 → 0.13.3

package/dist/index.js

@@ -28,9 +28,118 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// ../core/dist/shared/chunk-1dqs11h6.js
-import { createRequire as createRequire2 } from "node:module";
-var init_chunk_1dqs11h6 = () => {};
+// ../core/src/capability/yaml-parser.ts
+function parseSimpleYamlFrontmatter(yaml) {
+  const result = {};
+  for (const line of yaml.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const rawKey = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    const key = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    result[key] = value;
+  }
+  return result;
+}
+function parseFrontmatterWithMarkdown(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/s);
+  if (!match?.[1] || match[2] === undefined) {
+    return null;
+  }
+  const frontmatter = parseSimpleYamlFrontmatter(match[1]);
+  const markdown = match[2];
+  return { frontmatter, markdown };
+}
+
+// ../core/src/capability/commands.ts
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join as join2 } 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 command = await parseCommandFile(commandPath, capabilityId);
+        commands.push(command);
+      }
+    }
+  }
+  return commands;
+}
+async function parseCommandFile(filePath, capabilityId) {
+  const content = await readFile(filePath, "utf-8");
+  const parsed = parseFrontmatterWithMarkdown(content);
+  if (!parsed) {
+    throw new Error(`Invalid COMMAND.md format at ${filePath}: missing YAML frontmatter`);
+  }
+  const frontmatter = parsed.frontmatter;
+  const prompt = parsed.markdown;
+  if (!frontmatter.name || !frontmatter.description) {
+    throw new Error(`Invalid COMMAND.md at ${filePath}: name and description required`);
+  }
+  const result = {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    prompt: prompt.trim(),
+    capabilityId
+  };
+  if (frontmatter.allowedTools) {
+    result.allowedTools = frontmatter.allowedTools;
+  }
+  return result;
+}
+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";
+async function loadDocs(capabilityPath, capabilityId) {
+  const docs = [];
+  const definitionPath = join3(capabilityPath, "definition.md");
+  if (existsSync2(definitionPath)) {
+    const content = await readFile2(definitionPath, "utf-8");
+    docs.push({
+      name: "definition",
+      content: content.trim(),
+      capabilityId
+    });
+  }
+  const docsDir = join3(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 content = await readFile2(docPath, "utf-8");
+        docs.push({
+          name: basename(entry.name, ".md"),
+          content: content.trim(),
+          capabilityId
+        });
+      }
+    }
+  }
+  return docs;
+}
+var init_docs = () => {};
 
 // ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -1013,286 +1122,7 @@ var init_dist = __esm(() => {
    */
 });
 
-// ../core/dist/index.js
-var exports_dist = {};
-__export(exports_dist, {
-  writeSecurityAllows: () => writeSecurityAllows,
-  writeProviderConfig: () => writeProviderConfig,
-  writeMcpJson: () => writeMcpJson,
-  writeEnabledProviders: () => writeEnabledProviders,
-  writeConfig: () => writeConfig,
-  writeActiveProfileState: () => writeActiveProfileState,
-  version: () => version,
-  verifyIntegrity: () => verifyIntegrity,
-  validateHooksConfig: () => validateHooksConfig,
-  validateHook: () => validateHook,
-  transformToOmnidev: () => transformToOmnidev,
-  transformToClaude: () => transformToClaude,
-  transformHooksConfig: () => transformHooksConfig,
-  syncMcpJson: () => syncMcpJson,
-  syncAgentConfiguration: () => syncAgentConfiguration,
-  sourceToGitUrl: () => sourceToGitUrl,
-  setProfile: () => setProfile,
-  setActiveProfile: () => setActiveProfile,
-  scanCapability: () => scanCapability,
-  scanCapabilities: () => scanCapabilities,
-  saveManifest: () => saveManifest,
-  saveLockFile: () => saveLockFile,
-  resolveEnabledCapabilities: () => resolveEnabledCapabilities,
-  removeSecurityAllow: () => removeSecurityAllow,
-  readSecurityAllows: () => readSecurityAllows,
-  readMcpJson: () => readMcpJson,
-  readEnabledProviders: () => readEnabledProviders,
-  readCapabilityIdFromPath: () => readCapabilityIdFromPath,
-  readActiveProfileState: () => readActiveProfileState,
-  patchAddToProfile: () => patchAddToProfile,
-  patchAddMcp: () => patchAddMcp,
-  patchAddCapabilitySource: () => patchAddCapabilitySource,
-  parseSourceConfig: () => parseSourceConfig,
-  parseProviderFlag: () => parseProviderFlag,
-  parseOmniConfig: () => parseOmniConfig,
-  parseFileSourcePath: () => parseFileSourcePath,
-  parseCapabilityConfig: () => parseCapabilityConfig,
-  mergeHooksConfigs: () => mergeHooksConfigs,
-  mergeAndDeduplicateHooks: () => mergeAndDeduplicateHooks,
-  loadSubagents: () => loadSubagents,
-  loadSkills: () => loadSkills,
-  loadRules: () => loadRules,
-  loadProviderConfig: () => loadProviderConfig,
-  loadProfileConfig: () => loadProfileConfig,
-  loadManifest: () => loadManifest,
-  loadLockFile: () => loadLockFile,
-  loadHooksFromCapability: () => loadHooksFromCapability,
-  loadDocs: () => loadDocs,
-  loadConfig: () => loadConfig,
-  loadCommands: () => loadCommands,
-  loadCapabilityHooks: () => loadCapabilityHooks,
-  loadCapabilityConfig: () => loadCapabilityConfig,
-  loadCapability: () => loadCapability,
-  loadBaseConfig: () => loadBaseConfig,
-  isValidMatcherPattern: () => isValidMatcherPattern,
-  isSecurityAllowed: () => isSecurityAllowed,
-  isProviderEnabled: () => isProviderEnabled,
-  isPromptHookEvent: () => isPromptHookEvent,
-  isMatcherEvent: () => isMatcherEvent,
-  isHookType: () => isHookType,
-  isHookPrompt: () => isHookPrompt,
-  isHookEvent: () => isHookEvent,
-  isHookCommand: () => isHookCommand,
-  isGitSource: () => isGitSource,
-  isFileSourceConfig: () => isFileSourceConfig,
-  isFileSource: () => isFileSource,
-  installCapabilityDependencies: () => installCapabilityDependencies,
-  hasHooks: () => hasHooks,
-  hasAnyHooks: () => hasAnyHooks,
-  getVersion: () => getVersion,
-  getSourceCapabilityPath: () => getSourceCapabilityPath,
-  getLockFilePath: () => getLockFilePath,
-  getHooksDirectory: () => getHooksDirectory,
-  getHooksConfigPath: () => getHooksConfigPath,
-  getEventsWithHooks: () => getEventsWithHooks,
-  getEnabledCapabilities: () => getEnabledCapabilities,
-  getCapabilityAllows: () => getCapabilityAllows,
-  getAllSecurityAllows: () => getAllSecurityAllows,
-  getActiveProviders: () => getActiveProviders,
-  getActiveProfile: () => getActiveProfile,
-  generateSkillTemplate: () => generateSkillTemplate,
-  generateRuleTemplate: () => generateRuleTemplate,
-  generateOmniMdTemplate: () => generateOmniMdTemplate,
-  generateHooksTemplate: () => generateHooksTemplate,
-  generateHookScript: () => generateHookScript,
-  generateClaudeTemplate: () => generateClaudeTemplate,
-  generateCapabilityToml: () => generateCapabilityToml2,
-  generateAgentsTemplate: () => generateAgentsTemplate,
-  formatScanResults: () => formatScanResults,
-  findDuplicateCommands: () => findDuplicateCommands,
-  fetchCapabilitySource: () => fetchCapabilitySource,
-  fetchAllCapabilitySources: () => fetchAllCapabilitySources,
-  enableProvider: () => enableProvider,
-  enableCapability: () => enableCapability,
-  discoverCapabilities: () => discoverCapabilities,
-  disableProvider: () => disableProvider,
-  disableCapability: () => disableCapability,
-  detectPinVersion: () => detectPinVersion,
-  debug: () => debug,
-  createEmptyValidationResult: () => createEmptyValidationResult,
-  createEmptyHooksConfig: () => createEmptyHooksConfig,
-  countHooks: () => countHooks,
-  containsOmnidevVariables: () => containsOmnidevVariables,
-  containsClaudeVariables: () => containsClaudeVariables,
-  clearCapabilityAllows: () => clearCapabilityAllows,
-  clearAllSecurityAllows: () => clearAllSecurityAllows,
-  clearActiveProfileState: () => clearActiveProfileState,
-  cleanupStaleResources: () => cleanupStaleResources,
-  checkVersionMismatch: () => checkVersionMismatch,
-  checkForUpdates: () => checkForUpdates,
-  buildSyncBundle: () => buildSyncBundle,
-  buildManifestFromCapabilities: () => buildManifestFromCapabilities,
-  buildCapabilityRegistry: () => buildCapabilityRegistry,
-  addSecurityAllow: () => addSecurityAllow,
-  VARIABLE_MAPPINGS: () => VARIABLE_MAPPINGS,
-  SESSION_START_MATCHERS: () => SESSION_START_MATCHERS,
-  PROMPT_HOOK_EVENTS: () => PROMPT_HOOK_EVENTS,
-  PRE_COMPACT_MATCHERS: () => PRE_COMPACT_MATCHERS,
-  NOTIFICATION_MATCHERS: () => NOTIFICATION_MATCHERS,
-  MATCHER_EVENTS: () => MATCHER_EVENTS,
-  HOOK_TYPES: () => HOOK_TYPES,
-  HOOK_EVENTS: () => HOOK_EVENTS,
-  HOOKS_DIRECTORY: () => HOOKS_DIRECTORY,
-  HOOKS_CONFIG_FILENAME: () => HOOKS_CONFIG_FILENAME,
-  DEFAULT_SECURITY_CONFIG: () => DEFAULT_SECURITY_CONFIG,
-  DEFAULT_SCAN_SETTINGS: () => DEFAULT_SCAN_SETTINGS,
-  DEFAULT_PROMPT_TIMEOUT: () => DEFAULT_PROMPT_TIMEOUT,
-  DEFAULT_COMMAND_TIMEOUT: () => DEFAULT_COMMAND_TIMEOUT,
-  COMMON_TOOL_MATCHERS: () => COMMON_TOOL_MATCHERS
-});
-import { existsSync, readdirSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
-import { existsSync as existsSync2, readdirSync as readdirSync2 } from "node:fs";
-import { readFile as readFile2 } from "node:fs/promises";
-import { basename, join as join22 } from "node:path";
-import { existsSync as existsSync8, readdirSync as readdirSync6 } from "node:fs";
-import { readFile as readFile6 } from "node:fs/promises";
-import { join as join7 } from "node:path";
-import { existsSync as existsSync4, readFileSync } from "node:fs";
-import { join as join3 } from "node:path";
-import { existsSync as existsSync3, statSync } from "node:fs";
-import { resolve } from "node:path";
-import { existsSync as existsSync5, readdirSync as readdirSync3 } from "node:fs";
-import { readFile as readFile3 } from "node:fs/promises";
-import { basename as basename2, join as join4 } from "node:path";
-import { existsSync as existsSync6, readdirSync as readdirSync4 } from "node:fs";
-import { readFile as readFile4 } from "node:fs/promises";
-import { join as join5 } from "node:path";
-import { existsSync as existsSync7, readdirSync as readdirSync5 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
-import { join as join6 } from "node:path";
-import { existsSync as existsSync9 } from "node:fs";
-import { readFile as readFile7, writeFile as writeFile2 } from "node:fs/promises";
-import { existsSync as existsSync10, mkdirSync } from "node:fs";
-import { readFile as readFile8, unlink, writeFile as writeFile22 } from "node:fs/promises";
-import { existsSync as existsSync11 } from "node:fs";
-import { spawn } from "node:child_process";
-import { cp, mkdir as mkdir2, 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";
-import { existsSync as existsSync12 } from "node:fs";
-import { readFile as readFile10, writeFile as writeFile4 } from "node:fs/promises";
-import { existsSync as existsSync13 } from "node:fs";
-import { readFile as readFile11, writeFile as writeFile5 } from "node:fs/promises";
-import { existsSync as existsSync14 } from "node:fs";
-import { readFile as readFile12, writeFile as writeFile6 } from "node:fs/promises";
-import { existsSync as existsSync15, mkdirSync as mkdirSync2, rmSync } from "node:fs";
-import { readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
-import { existsSync as existsSync16, mkdirSync as mkdirSync3 } from "node:fs";
-import { readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
-import { existsSync as existsSync17, mkdirSync as mkdirSync4 } from "node:fs";
-import { readFile as readFile15, writeFile as writeFile9 } from "node:fs/promises";
-import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync5 } from "node:fs";
-import { existsSync as existsSync18 } from "node:fs";
-import { lstat, readdir as readdir2, readFile as readFile16, readlink, realpath } from "node:fs/promises";
-import { join as join9, relative, resolve as resolve2 } from "node:path";
-function parseSimpleYamlFrontmatter(yaml) {
-  const result = {};
-  for (const line of yaml.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-    const colonIndex = trimmed.indexOf(":");
-    if (colonIndex === -1) {
-      continue;
-    }
-    const rawKey = trimmed.slice(0, colonIndex).trim();
-    let value = trimmed.slice(colonIndex + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    const key = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-    result[key] = value;
-  }
-  return result;
-}
-function parseFrontmatterWithMarkdown(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/s);
-  if (!match?.[1] || match[2] === undefined) {
-    return null;
-  }
-  const frontmatter = parseSimpleYamlFrontmatter(match[1]);
-  const markdown = match[2];
-  return { frontmatter, markdown };
-}
-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 command = await parseCommandFile(commandPath, capabilityId);
-        commands.push(command);
-      }
-    }
-  }
-  return commands;
-}
-async function parseCommandFile(filePath, capabilityId) {
-  const content = await readFile(filePath, "utf-8");
-  const parsed = parseFrontmatterWithMarkdown(content);
-  if (!parsed) {
-    throw new Error(`Invalid COMMAND.md format at ${filePath}: missing YAML frontmatter`);
-  }
-  const frontmatter = parsed.frontmatter;
-  const prompt = parsed.markdown;
-  if (!frontmatter.name || !frontmatter.description) {
-    throw new Error(`Invalid COMMAND.md at ${filePath}: name and description required`);
-  }
-  const result = {
-    name: frontmatter.name,
-    description: frontmatter.description,
-    prompt: prompt.trim(),
-    capabilityId
-  };
-  if (frontmatter.allowedTools) {
-    result.allowedTools = frontmatter.allowedTools;
-  }
-  return result;
-}
-async function loadDocs(capabilityPath, capabilityId) {
-  const docs = [];
-  const definitionPath = join22(capabilityPath, "definition.md");
-  if (existsSync2(definitionPath)) {
-    const content = await readFile2(definitionPath, "utf-8");
-    docs.push({
-      name: "definition",
-      content: content.trim(),
-      capabilityId
-    });
-  }
-  const docsDir = join22(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 = join22(docsDir, entry.name);
-        const content = await readFile2(docPath, "utf-8");
-        docs.push({
-          name: basename(entry.name, ".md"),
-          content: content.trim(),
-          capabilityId
-        });
-      }
-    }
-  }
-  return docs;
-}
+// ../core/src/config/parser.ts
 function parseOmniConfig(tomlContent) {
   try {
     return parse(tomlContent);
@@ -1327,6 +1157,71 @@ function parseCapabilityConfig(tomlContent) {
     throw new Error(`Invalid capability.toml: ${message}`);
   }
 }
+var init_parser = __esm(() => {
+  init_dist();
+});
+
+// ../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 init_constants = __esm(() => {
+  HOOK_EVENTS = [
+    "PreToolUse",
+    "PostToolUse",
+    "PermissionRequest",
+    "UserPromptSubmit",
+    "Stop",
+    "SubagentStop",
+    "Notification",
+    "SessionStart",
+    "SessionEnd",
+    "PreCompact"
+  ];
+  MATCHER_EVENTS = [
+    "PreToolUse",
+    "PostToolUse",
+    "PermissionRequest",
+    "Notification",
+    "SessionStart",
+    "PreCompact"
+  ];
+  PROMPT_HOOK_EVENTS = [
+    "Stop",
+    "SubagentStop",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest"
+  ];
+  HOOK_TYPES = ["command", "prompt"];
+  COMMON_TOOL_MATCHERS = [
+    "Bash",
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "Task",
+    "WebFetch",
+    "WebSearch",
+    "NotebookEdit",
+    "LSP",
+    "TodoWrite",
+    "AskUserQuestion"
+  ];
+  NOTIFICATION_MATCHERS = [
+    "permission_prompt",
+    "idle_prompt",
+    "auth_success",
+    "elicitation_dialog"
+  ];
+  SESSION_START_MATCHERS = ["startup", "resume", "clear", "compact"];
+  PRE_COMPACT_MATCHERS = ["manual", "auto"];
+  VARIABLE_MAPPINGS = {
+    OMNIDEV_CAPABILITY_ROOT: "CLAUDE_PLUGIN_ROOT",
+    OMNIDEV_PROJECT_DIR: "CLAUDE_PROJECT_DIR"
+  };
+});
+
+// ../core/src/hooks/types.ts
 function isHookCommand(hook) {
   return hook.type === "command";
 }
@@ -1345,6 +1240,13 @@ function isHookEvent(event) {
 function isHookType(type) {
   return HOOK_TYPES.includes(type);
 }
+var init_types = __esm(() => {
+  init_constants();
+});
+
+// ../core/src/hooks/validation.ts
+import { existsSync as existsSync3, statSync } from "node:fs";
+import { resolve } from "node:path";
 function validateHooksConfig(config, options) {
   const errors = [];
   const warnings = [];
@@ -1711,6 +1613,12 @@ function createEmptyValidationResult() {
     warnings: []
   };
 }
+var init_validation = __esm(() => {
+  init_constants();
+  init_types();
+});
+
+// ../core/src/hooks/variables.ts
 function transformToOmnidev(content) {
   let result = content;
   for (const [claude, omni] of Object.entries(REVERSE_MAPPINGS)) {
@@ -1790,6 +1698,15 @@ function containsOmnidevVariables(content) {
   }
   return false;
 }
+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
+import { existsSync as existsSync4, readFileSync } from "node:fs";
+import { join as join4 } from "node:path";
 function loadHooksFromCapability(capabilityPath, options) {
   const opts = {
     transformVariables: true,
@@ -1797,8 +1714,8 @@ function loadHooksFromCapability(capabilityPath, options) {
     checkScripts: false,
     ...options
   };
-  const hooksDir = join3(capabilityPath, HOOKS_DIRECTORY);
-  const configPath = join3(hooksDir, HOOKS_CONFIG_FILENAME);
+  const hooksDir = join4(capabilityPath, HOOKS_DIRECTORY);
+  const configPath = join4(hooksDir, HOOKS_CONFIG_FILENAME);
   if (!existsSync4(configPath)) {
     return {
       config: createEmptyHooksConfig(),
@@ -1885,17 +1802,28 @@ function loadCapabilityHooks(capabilityName, capabilityPath, options) {
   };
 }
 function hasHooks(capabilityPath) {
-  const configPath = join3(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
+  const configPath = join4(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
   return existsSync4(configPath);
 }
 function getHooksDirectory(capabilityPath) {
-  return join3(capabilityPath, HOOKS_DIRECTORY);
+  return join4(capabilityPath, HOOKS_DIRECTORY);
 }
 function getHooksConfigPath(capabilityPath) {
-  return join3(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
+  return join4(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
 }
+var init_loader = __esm(() => {
+  init_dist();
+  init_constants();
+  init_validation();
+  init_variables();
+});
+
+// ../core/src/capability/rules.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { basename as basename2, join as join5 } from "node:path";
 async function loadRules(capabilityPath, capabilityId) {
-  const rulesDir = join4(capabilityPath, "rules");
+  const rulesDir = join5(capabilityPath, "rules");
   if (!existsSync5(rulesDir)) {
     return [];
   }
@@ -1903,7 +1831,7 @@ async function loadRules(capabilityPath, capabilityId) {
   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 = join4(rulesDir, entry.name);
+      const rulePath = join5(rulesDir, entry.name);
       const content = await readFile3(rulePath, "utf-8");
       rules.push({
         name: basename2(entry.name, ".md"),
@@ -1914,8 +1842,14 @@ async function loadRules(capabilityPath, capabilityId) {
   }
   return rules;
 }
+var init_rules = () => {};
+
+// ../core/src/capability/skills.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 async function loadSkills(capabilityPath, capabilityId) {
-  const skillsDir = join5(capabilityPath, "skills");
+  const skillsDir = join6(capabilityPath, "skills");
   if (!existsSync6(skillsDir)) {
     return [];
   }
@@ -1923,7 +1857,7 @@ async function loadSkills(capabilityPath, capabilityId) {
   const entries = readdirSync4(skillsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const skillPath = join5(skillsDir, entry.name, "SKILL.md");
+      const skillPath = join6(skillsDir, entry.name, "SKILL.md");
       if (existsSync6(skillPath)) {
         const skill = await parseSkillFile(skillPath, capabilityId);
         skills.push(skill);
@@ -1950,8 +1884,14 @@ async function parseSkillFile(filePath, capabilityId) {
     capabilityId
   };
 }
+var init_skills = () => {};
+
+// ../core/src/capability/subagents.ts
+import { existsSync as existsSync7, readdirSync as readdirSync5 } from "node:fs";
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 async function loadSubagents(capabilityPath, capabilityId) {
-  const subagentsDir = join6(capabilityPath, "subagents");
+  const subagentsDir = join7(capabilityPath, "subagents");
   if (!existsSync7(subagentsDir)) {
     return [];
   }
@@ -1959,7 +1899,7 @@ async function loadSubagents(capabilityPath, capabilityId) {
   const entries = readdirSync5(subagentsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const subagentPath = join6(subagentsDir, entry.name, "SUBAGENT.md");
+      const subagentPath = join7(subagentsDir, entry.name, "SUBAGENT.md");
       if (existsSync7(subagentPath)) {
         const subagent = await parseSubagentFile(subagentPath, capabilityId);
         subagents.push(subagent);
@@ -2008,14 +1948,20 @@ async function parseSubagentFile(filePath, capabilityId) {
 function parseCommaSeparatedList(value) {
   return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
+var init_subagents = () => {};
+
+// ../core/src/capability/loader.ts
+import { existsSync as existsSync8, readdirSync as readdirSync6 } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 async function discoverCapabilities() {
   const capabilities = [];
   if (existsSync8(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 = join7(CAPABILITIES_DIR, entry.name);
-        const configPath = join7(entryPath, "capability.toml");
+        const entryPath = join8(CAPABILITIES_DIR, entry.name);
+        const configPath = join8(entryPath, "capability.toml");
         if (existsSync8(configPath)) {
           capabilities.push(entryPath);
         }
@@ -2025,15 +1971,15 @@ async function discoverCapabilities() {
   return capabilities;
 }
 async function loadCapabilityConfig(capabilityPath) {
-  const configPath = join7(capabilityPath, "capability.toml");
+  const configPath = join8(capabilityPath, "capability.toml");
   const content = await readFile6(configPath, "utf-8");
   const config = parseCapabilityConfig(content);
   return config;
 }
 async function importCapabilityExports(capabilityPath) {
-  const builtIndexPath = join7(capabilityPath, "dist", "index.js");
-  const jsIndexPath = join7(capabilityPath, "index.js");
-  const tsIndexPath = join7(capabilityPath, "index.ts");
+  const builtIndexPath = join8(capabilityPath, "dist", "index.js");
+  const jsIndexPath = join8(capabilityPath, "index.js");
+  const tsIndexPath = join8(capabilityPath, "index.ts");
   let indexPath = null;
   if (existsSync8(builtIndexPath)) {
     indexPath = builtIndexPath;
@@ -2046,7 +1992,7 @@ async function importCapabilityExports(capabilityPath) {
     return {};
   }
   try {
-    const absolutePath = join7(process.cwd(), indexPath);
+    const absolutePath = join8(process.cwd(), indexPath);
     const module = await import(absolutePath);
     return module;
   } catch (error) {
@@ -2066,7 +2012,7 @@ If this is a project-specific capability, install dependencies or remove it from
   }
 }
 async function loadTypeDefinitions(capabilityPath) {
-  const typesPath = join7(capabilityPath, "types.d.ts");
+  const typesPath = join8(capabilityPath, "types.d.ts");
   if (!existsSync8(typesPath)) {
     return;
   }
@@ -2283,6 +2229,20 @@ async function loadCapability(capabilityPath) {
   }
   return result;
 }
+var CAPABILITIES_DIR = ".omni/capabilities";
+var init_loader2 = __esm(() => {
+  init_parser();
+  init_loader();
+  init_commands();
+  init_docs();
+  init_rules();
+  init_skills();
+  init_subagents();
+});
+
+// ../core/src/config/config.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { readFile as readFile7, writeFile as writeFile2 } from "node:fs/promises";
 function mergeConfigs(base, override) {
   const merged = { ...base, ...override };
   merged.profiles = { ...base.profiles };
@@ -2466,6 +2426,14 @@ function generateConfigToml(config) {
   return lines.join(`
 `);
 }
+var CONFIG_PATH = "omni.toml", LOCAL_CONFIG = "omni.local.toml";
+var init_config = __esm(() => {
+  init_parser();
+});
+
+// ../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";
 async function readActiveProfileState() {
   if (!existsSync10(ACTIVE_PROFILE_PATH)) {
     return null;
@@ -2480,13 +2448,19 @@ async function readActiveProfileState() {
 }
 async function writeActiveProfileState(profileName) {
   mkdirSync(STATE_DIR, { recursive: true });
-  await writeFile22(ACTIVE_PROFILE_PATH, profileName, "utf-8");
+  await writeFile3(ACTIVE_PROFILE_PATH, profileName, "utf-8");
 }
 async function clearActiveProfileState() {
   if (existsSync10(ACTIVE_PROFILE_PATH)) {
     await unlink(ACTIVE_PROFILE_PATH);
   }
 }
+var STATE_DIR = ".omni/state", ACTIVE_PROFILE_PATH;
+var init_active_profile = __esm(() => {
+  ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
+});
+
+// ../core/src/config/profiles.ts
 async function getActiveProfile() {
   return await readActiveProfileState();
 }
@@ -2528,6 +2502,12 @@ async function setProfile(profileName, profileConfig) {
   config.profiles[profileName] = profileConfig;
   await writeConfig(config);
 }
+var init_profiles = __esm(() => {
+  init_active_profile();
+  init_config();
+});
+
+// ../core/src/config/capabilities.ts
 async function getEnabledCapabilities() {
   const config = await loadConfig();
   const activeProfile = await getActiveProfile() ?? "default";
@@ -2558,6 +2538,12 @@ async function disableCapability(capabilityId) {
   config.profiles[activeProfile].capabilities = Array.from(capabilities);
   await writeConfig(config);
 }
+var init_capabilities = __esm(() => {
+  init_config();
+  init_profiles();
+});
+
+// ../core/src/hooks/merger.ts
 function mergeHooksConfigs(capabilityHooks) {
   const result = {};
   for (const event of HOOK_EVENTS) {
@@ -2643,6 +2629,11 @@ function getEventsWithHooks(config) {
   }
   return events;
 }
+var init_merger = __esm(() => {
+  init_constants();
+});
+
+// ../core/src/capability/registry.ts
 async function buildCapabilityRegistry() {
   const enabledIds = await getEnabledCapabilities();
   const capabilityPaths = await discoverCapabilities();
@@ -2679,6 +2670,12 @@ async function buildCapabilityRegistry() {
     getMergedHooks: () => mergeHooksConfigs(getAllCapabilityHooks())
   };
 }
+var init_registry = __esm(() => {
+  init_capabilities();
+  init_merger();
+  init_loader2();
+});
+// ../core/src/types/index.ts
 function isFileSourceConfig(config) {
   if (typeof config === "string") {
     return config.startsWith("file://");
@@ -2692,14 +2689,29 @@ function getActiveProviders(config) {
     return [config.provider];
   return ["claude"];
 }
+var init_types2 = () => {};
+
+// ../core/src/capability/sources.ts
+import { existsSync as existsSync11 } 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 { createHash } from "node:crypto";
 async function spawnCapture(command, args, options) {
-  return await new Promise((resolve22, reject) => {
+  const timeout = options?.timeout ?? 60000;
+  return await new Promise((resolve2, reject) => {
     const child = spawn(command, args, {
       cwd: options?.cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
     let stderr = "";
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 5000);
+    }, timeout);
     child.stdout?.setEncoding("utf-8");
     child.stderr?.setEncoding("utf-8");
     child.stdout?.on("data", (chunk) => {
@@ -2708,9 +2720,22 @@ async function spawnCapture(command, args, options) {
     child.stderr?.on("data", (chunk) => {
       stderr += chunk;
     });
-    child.on("error", (error) => reject(error));
+    child.on("error", (error) => {
+      clearTimeout(timeoutId);
+      reject(error);
+    });
     child.on("close", (exitCode) => {
-      resolve22({ exitCode: exitCode ?? 0, stdout, stderr });
+      clearTimeout(timeoutId);
+      if (timedOut) {
+        resolve2({
+          exitCode: 124,
+          stdout,
+          stderr: `${stderr}
+Process timed out after ${timeout}ms`
+        });
+      } else {
+        resolve2({ exitCode: exitCode ?? 0, stdout, stderr });
+      }
     });
   });
 }
@@ -2727,7 +2752,7 @@ function parseFileSourcePath(source) {
   return source.slice(7);
 }
 async function readCapabilityIdFromPath(capabilityPath) {
-  const tomlPath = join8(capabilityPath, "capability.toml");
+  const tomlPath = join9(capabilityPath, "capability.toml");
   if (existsSync11(tomlPath)) {
     try {
       const content = await readFile9(tomlPath, "utf-8");
@@ -2783,7 +2808,7 @@ function sourceToGitUrl(source) {
   return source;
 }
 function getSourceCapabilityPath(id) {
-  return join8(OMNI_LOCAL, "capabilities", id);
+  return join9(OMNI_LOCAL, "capabilities", id);
 }
 function getLockFilePath() {
   return "omni.lock.toml";
@@ -2852,14 +2877,14 @@ function stringifyLockFile(lockFile) {
 }
 async function saveLockFile(lockFile) {
   const lockPath = getLockFilePath();
-  await mkdir2(join8(OMNI_LOCAL, "capabilities"), { recursive: true });
+  await mkdir2(join9(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 writeFile3(lockPath, content, "utf-8");
+  await writeFile4(lockPath, content, "utf-8");
 }
 async function getRepoCommit(repoPath) {
   const { exitCode, stdout, stderr } = await spawnCapture("git", ["rev-parse", "HEAD"], {
@@ -2883,7 +2908,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 = join8(currentPath, entry.name);
+      const fullPath = join9(currentPath, entry.name);
       const relativePath = fullPath.slice(relativeTo.length + 1);
       if (excludePatterns.some((pattern) => entry.name === pattern || relativePath.startsWith(`${pattern}/`))) {
         continue;
@@ -2905,7 +2930,7 @@ async function computeContentHash(dirPath, excludePatterns = CONTENT_HASH_EXCLUD
   return hash.digest("hex");
 }
 async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
-  const capTomlPath = join8(dirPath, "capability.toml");
+  const capTomlPath = join9(dirPath, "capability.toml");
   if (existsSync11(capTomlPath)) {
     try {
       const content = await readFile9(capTomlPath, "utf-8");
@@ -2916,7 +2941,7 @@ async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
       }
     } catch {}
   }
-  const pluginJsonPath = join8(dirPath, ".claude-plugin", "plugin.json");
+  const pluginJsonPath = join9(dirPath, ".claude-plugin", "plugin.json");
   if (existsSync11(pluginJsonPath)) {
     try {
       const content = await readFile9(pluginJsonPath, "utf-8");
@@ -2926,7 +2951,7 @@ async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
       }
     } catch {}
   }
-  const pkgJsonPath = join8(dirPath, "package.json");
+  const pkgJsonPath = join9(dirPath, "package.json");
   if (existsSync11(pkgJsonPath)) {
     try {
       const content = await readFile9(pkgJsonPath, "utf-8");
@@ -2940,17 +2965,17 @@ async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
 }
 async function detectPinVersion(sourceUrl, subPath) {
   const gitUrl = sourceToGitUrl(sourceUrl);
-  const tempPath = join8(OMNI_LOCAL, "_temp", `_pin-detect-${Date.now()}`);
+  const tempPath = join9(OMNI_LOCAL, "_temp", `_pin-detect-${Date.now()}`);
   try {
-    await mkdir2(join8(tempPath, ".."), { recursive: true });
+    await mkdir2(join9(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 ? join8(tempPath, subPath) : tempPath;
-    const capTomlPath = join8(checkPath, "capability.toml");
+    const checkPath = subPath ? join9(tempPath, subPath) : tempPath;
+    const capTomlPath = join9(checkPath, "capability.toml");
     if (existsSync11(capTomlPath)) {
       try {
         const content = await readFile9(capTomlPath, "utf-8");
@@ -2961,7 +2986,7 @@ async function detectPinVersion(sourceUrl, subPath) {
         }
       } catch {}
     }
-    const pluginJsonPath = join8(checkPath, ".claude-plugin", "plugin.json");
+    const pluginJsonPath = join9(checkPath, ".claude-plugin", "plugin.json");
     if (existsSync11(pluginJsonPath)) {
       try {
         const content = await readFile9(pluginJsonPath, "utf-8");
@@ -2979,7 +3004,7 @@ async function detectPinVersion(sourceUrl, subPath) {
   }
 }
 async function cloneRepo(gitUrl, targetPath, ref) {
-  await mkdir2(join8(targetPath, ".."), { recursive: true });
+  await mkdir2(join9(targetPath, ".."), { recursive: true });
   const args = ["clone", "--depth", "1"];
   if (ref) {
     args.push("--branch", ref);
@@ -3016,15 +3041,15 @@ async function fetchRepo(repoPath, ref) {
   return true;
 }
 function hasCapabilityToml(dirPath) {
-  return existsSync11(join8(dirPath, "capability.toml"));
+  return existsSync11(join9(dirPath, "capability.toml"));
 }
 async function shouldWrapDirectory(dirPath) {
-  if (existsSync11(join8(dirPath, ".claude-plugin", "plugin.json"))) {
+  if (existsSync11(join9(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 = join8(dirPath, dirName);
+    const checkPath = join9(dirPath, dirName);
     if (existsSync11(checkPath)) {
       const stats = await stat(checkPath);
       if (stats.isDirectory()) {
@@ -3036,7 +3061,7 @@ async function shouldWrapDirectory(dirPath) {
 }
 async function findMatchingDirs(basePath, names) {
   for (const name of names) {
-    const dirPath = join8(basePath, name);
+    const dirPath = join9(basePath, name);
     if (existsSync11(dirPath)) {
       const stats = await stat(dirPath);
       if (stats.isDirectory()) {
@@ -3053,10 +3078,10 @@ async function findContentItems(dirPath, filePatterns) {
   }
   const entries = (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const entryPath = join8(dirPath, entry.name);
+    const entryPath = join9(dirPath, entry.name);
     if (entry.isDirectory()) {
       for (const pattern of filePatterns) {
-        if (existsSync11(join8(entryPath, pattern))) {
+        if (existsSync11(join9(entryPath, pattern))) {
           items.push({
             name: entry.name,
             path: entryPath,
@@ -3077,7 +3102,7 @@ async function findContentItems(dirPath, filePatterns) {
   return items;
 }
 async function parsePluginJson(dirPath) {
-  const pluginJsonPath = join8(dirPath, ".claude-plugin", "plugin.json");
+  const pluginJsonPath = join9(dirPath, ".claude-plugin", "plugin.json");
   if (!existsSync11(pluginJsonPath)) {
     return null;
   }
@@ -3102,7 +3127,7 @@ async function parsePluginJson(dirPath) {
   }
 }
 async function readReadmeDescription(dirPath) {
-  const readmePath = join8(dirPath, "README.md");
+  const readmePath = join9(dirPath, "README.md");
   if (!existsSync11(readmePath)) {
     return null;
   }
@@ -3144,8 +3169,8 @@ async function normalizeFolderNames(repoPath) {
     { from: "subagent", to: "subagents" }
   ];
   for (const { from, to } of renameMappings) {
-    const fromPath = join8(repoPath, from);
-    const toPath = join8(repoPath, to);
+    const fromPath = join9(repoPath, from);
+    const toPath = join9(repoPath, to);
     if (existsSync11(fromPath) && !existsSync11(toPath)) {
       try {
         const stats = await stat(fromPath);
@@ -3235,7 +3260,7 @@ repository = "${repoUrl}"
 wrapped = true
 commit = "${commit}"
 `;
-  await writeFile3(join8(repoPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile4(join9(repoPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function fetchGitCapabilitySource(id, config, options) {
   const gitUrl = sourceToGitUrl(config.source);
@@ -3245,29 +3270,29 @@ async function fetchGitCapabilitySource(id, config, options) {
   let repoPath;
   const gitRef = config.version && config.version !== "latest" ? config.version : undefined;
   if (config.path) {
-    const tempPath = join8(OMNI_LOCAL, "_temp", `${id}-repo`);
-    if (existsSync11(join8(tempPath, ".git"))) {
+    const tempPath = join9(OMNI_LOCAL, "_temp", `${id}-repo`);
+    if (existsSync11(join9(tempPath, ".git"))) {
       updated = await fetchRepo(tempPath, gitRef);
       commit = await getRepoCommit(tempPath);
     } else {
-      await mkdir2(join8(tempPath, ".."), { recursive: true });
+      await mkdir2(join9(tempPath, ".."), { recursive: true });
       await cloneRepo(gitUrl, tempPath, gitRef);
       commit = await getRepoCommit(tempPath);
       updated = true;
     }
-    const sourcePath = join8(tempPath, config.path);
+    const sourcePath = join9(tempPath, config.path);
     if (!existsSync11(sourcePath)) {
       throw new Error(`Path not found in repository: ${config.path}`);
     }
     if (existsSync11(targetPath)) {
       await rm(targetPath, { recursive: true });
     }
-    await mkdir2(join8(targetPath, ".."), { recursive: true });
+    await mkdir2(join9(targetPath, ".."), { recursive: true });
     await cp(sourcePath, targetPath, { recursive: true });
     await rm(tempPath, { recursive: true });
     repoPath = targetPath;
   } else {
-    if (existsSync11(join8(targetPath, ".git"))) {
+    if (existsSync11(join9(targetPath, ".git"))) {
       if (!options?.silent) {
         console.log(`  Checking ${id}...`);
       }
@@ -3326,7 +3351,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(join8(sourcePath, "capability.toml"));
+  const hasCapToml = existsSync11(join9(sourcePath, "capability.toml"));
   let needsWrap = false;
   if (!hasCapToml) {
     needsWrap = await shouldWrapDirectory(sourcePath);
@@ -3340,7 +3365,7 @@ async function fetchFileCapabilitySource(id, config, options) {
   if (existsSync11(targetPath)) {
     await rm(targetPath, { recursive: true });
   }
-  await mkdir2(join8(targetPath, ".."), { recursive: true });
+  await mkdir2(join9(targetPath, ".."), { recursive: true });
   await cp(sourcePath, targetPath, { recursive: true });
   if (needsWrap) {
     await normalizeFolderNames(targetPath);
@@ -3420,7 +3445,7 @@ description = "${description}"
 wrapped = true
 source = "${source}"
 `;
-  await writeFile3(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile4(join9(targetPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function fetchCapabilitySource(id, sourceConfig, options) {
   const config = parseSourceConfig(sourceConfig);
@@ -3493,10 +3518,10 @@ generated_from_omni_toml = true
 }
 async function generateMcpCapabilityToml(id, mcpConfig, targetPath) {
   const tomlContent = generateMcpCapabilityTomlContent(id, mcpConfig);
-  await writeFile3(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile4(join9(targetPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function isGeneratedMcpCapability(capabilityDir) {
-  const tomlPath = join8(capabilityDir, "capability.toml");
+  const tomlPath = join9(capabilityDir, "capability.toml");
   if (!existsSync11(tomlPath)) {
     console.warn("no capability.toml found in", capabilityDir);
     return false;
@@ -3512,14 +3537,14 @@ async function isGeneratedMcpCapability(capabilityDir) {
   }
 }
 async function cleanupStaleMcpCapabilities(currentMcpIds) {
-  const capabilitiesDir = join8(OMNI_LOCAL, "capabilities");
+  const capabilitiesDir = join9(OMNI_LOCAL, "capabilities");
   if (!existsSync11(capabilitiesDir)) {
     return;
   }
   const entries = await readdir(capabilitiesDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const capDir = join8(capabilitiesDir, entry.name);
+      const capDir = join9(capabilitiesDir, entry.name);
       const isGenerated = await isGeneratedMcpCapability(capDir);
       if (isGenerated && !currentMcpIds.has(entry.name)) {
         await rm(capDir, { recursive: true });
@@ -3532,10 +3557,10 @@ async function generateMcpCapabilities(config) {
     await cleanupStaleMcpCapabilities(new Set);
     return;
   }
-  const mcpCapabilitiesDir = join8(OMNI_LOCAL, "capabilities");
+  const mcpCapabilitiesDir = join9(OMNI_LOCAL, "capabilities");
   const currentMcpIds = new Set;
   for (const [id, mcpConfig] of Object.entries(config.mcps)) {
-    const targetPath = join8(mcpCapabilitiesDir, id);
+    const targetPath = join9(mcpCapabilitiesDir, id);
     currentMcpIds.add(id);
     await mkdir2(targetPath, { recursive: true });
     await generateMcpCapabilityToml(id, mcpConfig, targetPath);
@@ -3544,7 +3569,7 @@ async function generateMcpCapabilities(config) {
 }
 async function fetchAllCapabilitySources(config, options) {
   await generateMcpCapabilities(config);
-  const tempDir = join8(OMNI_LOCAL, "_temp");
+  const tempDir = join9(OMNI_LOCAL, "_temp");
   if (existsSync11(tempDir)) {
     await rm(tempDir, { recursive: true });
   }
@@ -3631,7 +3656,7 @@ async function checkForUpdates(config) {
       continue;
     }
     const gitConfig = sourceConfig;
-    if (!existsSync11(join8(targetPath, ".git"))) {
+    if (!existsSync11(join9(targetPath, ".git"))) {
       updates.push({
         id,
         source: gitConfig.source,
@@ -3678,7 +3703,7 @@ async function verifyIntegrity(id, lockEntry) {
     return "capability directory missing";
   }
   if (lockEntry.commit) {
-    const gitDir = join8(capabilityPath, ".git");
+    const gitDir = join9(capabilityPath, ".git");
     if (existsSync11(gitDir)) {
       try {
         const currentCommit = await getRepoCommit(capabilityPath);
@@ -3698,6 +3723,57 @@ async function verifyIntegrity(id, lockEntry) {
   }
   return null;
 }
+var OMNI_LOCAL = ".omni", SKILL_DIRS, AGENT_DIRS, COMMAND_DIRS, RULE_DIRS, DOC_DIRS, SKILL_FILES, AGENT_FILES, COMMAND_FILES, CONTENT_HASH_EXCLUDES;
+var init_sources = __esm(() => {
+  init_dist();
+  init_types2();
+  SKILL_DIRS = ["skills", "skill"];
+  AGENT_DIRS = ["agents", "agent", "subagents", "subagent"];
+  COMMAND_DIRS = ["commands", "command"];
+  RULE_DIRS = ["rules", "rule"];
+  DOC_DIRS = ["docs", "doc", "documentation"];
+  SKILL_FILES = ["SKILL.md", "skill.md", "Skill.md"];
+  AGENT_FILES = ["AGENT.md", "agent.md", "Agent.md", "SUBAGENT.md", "subagent.md"];
+  COMMAND_FILES = ["COMMAND.md", "command.md", "Command.md"];
+  CONTENT_HASH_EXCLUDES = [
+    ".git",
+    "node_modules",
+    ".omni",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    "dist",
+    "build",
+    ".DS_Store",
+    "Thumbs.db"
+  ];
+});
+
+// ../core/src/capability/index.ts
+var init_capability = __esm(() => {
+  init_commands();
+  init_docs();
+  init_loader2();
+  init_registry();
+  init_rules();
+  init_skills();
+  init_sources();
+  init_subagents();
+});
+
+// ../core/src/hooks/index.ts
+var init_hooks = __esm(() => {
+  init_constants();
+  init_types();
+  init_validation();
+  init_variables();
+  init_loader();
+  init_merger();
+});
+
+// ../core/src/config/provider.ts
+import { existsSync as existsSync12 } from "node:fs";
+import { readFile as readFile10, writeFile as writeFile5 } from "node:fs/promises";
 async function loadProviderConfig() {
   if (!existsSync12(PROVIDER_CONFIG_PATH)) {
     return { provider: "claude" };
@@ -3729,7 +3805,7 @@ async function writeProviderConfig(config) {
     lines.push("# Default: Claude");
     lines.push('provider = "claude"');
   }
-  await writeFile4(PROVIDER_CONFIG_PATH, `${lines.join(`
+  await writeFile5(PROVIDER_CONFIG_PATH, `${lines.join(`
 `)}
 `, "utf-8");
 }
@@ -3743,6 +3819,14 @@ function parseProviderFlag(flag) {
   }
   throw new Error(`Invalid provider: ${flag}. Must be 'claude', 'codex', or 'both'.`);
 }
+var PROVIDER_CONFIG_PATH = ".omni/provider.toml";
+var init_provider = __esm(() => {
+  init_dist();
+});
+
+// ../core/src/config/toml-patcher.ts
+import { existsSync as existsSync13 } from "node:fs";
+import { readFile as readFile11, writeFile as writeFile6 } from "node:fs/promises";
 async function readConfigFile() {
   if (!existsSync13(CONFIG_PATH2)) {
     return "";
@@ -3750,7 +3834,7 @@ async function readConfigFile() {
   return readFile11(CONFIG_PATH2, "utf-8");
 }
 async function writeConfigFile(content) {
-  await writeFile5(CONFIG_PATH2, content, "utf-8");
+  await writeFile6(CONFIG_PATH2, content, "utf-8");
 }
 function findSection(lines, sectionPattern) {
   return lines.findIndex((line) => sectionPattern.test(line.trim()));
@@ -3955,9 +4039,25 @@ async function patchAddToProfile(profileName, capabilityName) {
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-async function readMcpJson() {
-  if (!existsSync14(MCP_JSON_PATH)) {
-    return { mcpServers: {} };
+var CONFIG_PATH2 = "omni.toml";
+var init_toml_patcher = () => {};
+
+// ../core/src/config/index.ts
+var init_config2 = __esm(() => {
+  init_capabilities();
+  init_config();
+  init_parser();
+  init_profiles();
+  init_provider();
+  init_toml_patcher();
+});
+
+// ../core/src/mcp-json/manager.ts
+import { existsSync as existsSync14 } from "node:fs";
+import { readFile as readFile12, writeFile as writeFile7 } from "node:fs/promises";
+async function readMcpJson() {
+  if (!existsSync14(MCP_JSON_PATH)) {
+    return { mcpServers: {} };
   }
   try {
     const content = await readFile12(MCP_JSON_PATH, "utf-8");
@@ -3970,7 +4070,7 @@ async function readMcpJson() {
   }
 }
 async function writeMcpJson(config2) {
-  await writeFile6(MCP_JSON_PATH, `${JSON.stringify(config2, null, 2)}
+  await writeFile7(MCP_JSON_PATH, `${JSON.stringify(config2, null, 2)}
 `, "utf-8");
 }
 function buildMcpServerConfig(mcp) {
@@ -4033,6 +4133,17 @@ async function syncMcpJson(capabilities2, previousManifest) {
   }
   await writeMcpJson(mcpJson);
 }
+var MCP_JSON_PATH = ".mcp.json";
+var init_manager = () => {};
+
+// ../core/src/mcp-json/index.ts
+var init_mcp_json = __esm(() => {
+  init_manager();
+});
+
+// ../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";
 async function loadManifest() {
   if (!existsSync15(MANIFEST_PATH)) {
     return {
@@ -4046,7 +4157,7 @@ async function loadManifest() {
 }
 async function saveManifest(manifest) {
   mkdirSync2(".omni/state", { recursive: true });
-  await writeFile7(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
+  await writeFile8(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
 function buildManifestFromCapabilities(capabilities2) {
@@ -4096,6 +4207,12 @@ async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
   }
   return result;
 }
+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";
 async function readEnabledProviders() {
   if (!existsSync16(PROVIDERS_PATH)) {
     return DEFAULT_PROVIDERS;
@@ -4111,7 +4228,7 @@ async function readEnabledProviders() {
 async function writeEnabledProviders(providers) {
   mkdirSync3(STATE_DIR2, { recursive: true });
   const state = { enabled: providers };
-  await writeFile8(PROVIDERS_PATH, `${JSON.stringify(state, null, 2)}
+  await writeFile9(PROVIDERS_PATH, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 async function enableProvider(providerId) {
@@ -4129,6 +4246,15 @@ async function isProviderEnabled(providerId) {
   const current = await readEnabledProviders();
   return current.includes(providerId);
 }
+var STATE_DIR2 = ".omni/state", PROVIDERS_PATH, DEFAULT_PROVIDERS;
+var init_providers = __esm(() => {
+  PROVIDERS_PATH = `${STATE_DIR2}/providers.json`;
+  DEFAULT_PROVIDERS = ["claude-code"];
+});
+
+// ../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";
 async function readSecurityAllows() {
   if (!existsSync17(SECURITY_PATH)) {
     return { ...DEFAULT_STATE };
@@ -4144,7 +4270,7 @@ async function readSecurityAllows() {
 async function writeSecurityAllows(state) {
   mkdirSync4(OMNI_DIR, { recursive: true });
   state.modifiedAt = new Date().toISOString();
-  await writeFile9(SECURITY_PATH, `${JSON.stringify(state, null, 2)}
+  await writeFile10(SECURITY_PATH, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 async function addSecurityAllow(capabilityId, findingType) {
@@ -4209,19 +4335,40 @@ async function clearAllSecurityAllows() {
   const state = { ...DEFAULT_STATE };
   await writeSecurityAllows(state);
 }
+var OMNI_DIR = ".omni", SECURITY_PATH, DEFAULT_STATE;
+var init_security_allows = __esm(() => {
+  SECURITY_PATH = `${OMNI_DIR}/security.json`;
+  DEFAULT_STATE = {
+    version: 1,
+    modifiedAt: new Date().toISOString(),
+    allows: {}
+  };
+});
+
+// ../core/src/state/index.ts
+var init_state = __esm(() => {
+  init_active_profile();
+  init_manifest();
+  init_providers();
+  init_security_allows();
+});
+
+// ../core/src/sync.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdirSync as mkdirSync5 } from "node:fs";
 async function installCapabilityDependencies(silent) {
-  const { existsSync: existsSync182, readdirSync: readdirSync7, readFileSync: readFileSync2 } = await import("node:fs");
-  const { join: join92 } = await import("node:path");
+  const { existsSync: existsSync18, readdirSync: readdirSync7, readFileSync: readFileSync2 } = await import("node:fs");
+  const { join: join10 } = await import("node:path");
   const capabilitiesDir = ".omni/capabilities";
-  if (!existsSync182(capabilitiesDir)) {
+  if (!existsSync18(capabilitiesDir)) {
     return;
   }
   const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
   async function commandExists(cmd) {
-    return await new Promise((resolve22) => {
+    return await new Promise((resolve2) => {
       const proc = spawn2(cmd, ["--version"], { stdio: "ignore" });
-      proc.on("error", () => resolve22(false));
-      proc.on("close", (code) => resolve22(code === 0));
+      proc.on("error", () => resolve2(false));
+      proc.on("close", (code) => resolve2(code === 0));
     });
   }
   const hasBun = await commandExists("bun");
@@ -4233,13 +4380,13 @@ async function installCapabilityDependencies(silent) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const capabilityPath = join92(capabilitiesDir, entry.name);
-    const packageJsonPath = join92(capabilityPath, "package.json");
-    if (!existsSync182(packageJsonPath)) {
+    const capabilityPath = join10(capabilitiesDir, entry.name);
+    const packageJsonPath = join10(capabilityPath, "package.json");
+    if (!existsSync18(packageJsonPath)) {
       continue;
     }
-    await new Promise((resolve22, reject) => {
-      const useNpmCi = hasNpm && existsSync182(join92(capabilityPath, "package-lock.json"));
+    await new Promise((resolve2, reject) => {
+      const useNpmCi = hasNpm && existsSync18(join10(capabilityPath, "package-lock.json"));
       const cmd = hasBun ? "bun" : "npm";
       const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
       const proc = spawn2(cmd, args, {
@@ -4252,7 +4399,7 @@ async function installCapabilityDependencies(silent) {
       });
       proc.on("close", (code) => {
         if (code === 0) {
-          resolve22();
+          resolve2();
         } else {
           reject(new Error(`Failed to install dependencies for ${capabilityPath}:
 ${stderr}`));
@@ -4262,8 +4409,8 @@ ${stderr}`));
         reject(error);
       });
     });
-    const hasIndexTs = existsSync182(join92(capabilityPath, "index.ts"));
-    const hasBuiltIndex = existsSync182(join92(capabilityPath, "dist", "index.js"));
+    const hasIndexTs = existsSync18(join10(capabilityPath, "index.ts"));
+    const hasBuiltIndex = existsSync18(join10(capabilityPath, "dist", "index.js"));
     if (hasIndexTs && !hasBuiltIndex) {
       let hasBuildScript = false;
       try {
@@ -4271,7 +4418,7 @@ ${stderr}`));
         hasBuildScript = Boolean(pkgJson.scripts?.build);
       } catch {}
       if (hasBuildScript) {
-        await new Promise((resolve22, reject) => {
+        await new Promise((resolve2, reject) => {
           const cmd = hasBun ? "bun" : "npm";
           const args = ["run", "build"];
           const proc = spawn2(cmd, args, {
@@ -4284,7 +4431,7 @@ ${stderr}`));
           });
           proc.on("close", (code) => {
             if (code === 0) {
-              resolve22();
+              resolve2();
             } else {
               reject(new Error(`Failed to build capability ${capabilityPath}:
 ${stderr}`));
@@ -4401,6 +4548,40 @@ function generateInstructionsContent(rules, _docs) {
   }
   return content.trim();
 }
+var init_sync = __esm(() => {
+  init_registry();
+  init_sources();
+  init_config();
+  init_merger();
+  init_manager();
+  init_manifest();
+});
+
+// ../core/src/security/types.ts
+var DEFAULT_SECURITY_CONFIG, DEFAULT_SCAN_SETTINGS;
+var init_types3 = __esm(() => {
+  DEFAULT_SECURITY_CONFIG = {
+    mode: "off",
+    trusted_sources: [],
+    scan: {
+      unicode: true,
+      symlinks: true,
+      scripts: true,
+      binaries: false
+    }
+  };
+  DEFAULT_SCAN_SETTINGS = {
+    unicode: true,
+    symlinks: true,
+    scripts: true,
+    binaries: false
+  };
+});
+
+// ../core/src/security/scanner.ts
+import { existsSync as existsSync18 } 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";
 async function scanFileForUnicode(filePath, relativePath) {
   const findings = [];
   try {
@@ -4484,7 +4665,7 @@ async function scanFileForScripts(filePath, relativePath) {
 async function checkSymlink(symlinkPath, relativePath, capabilityRoot) {
   try {
     const linkTarget = await readlink(symlinkPath);
-    const resolvedTarget = resolve2(join9(symlinkPath, "..", linkTarget));
+    const resolvedTarget = resolve2(join10(symlinkPath, "..", linkTarget));
     const normalizedRoot = await realpath(capabilityRoot);
     if (linkTarget.startsWith("/")) {
       return {
@@ -4531,7 +4712,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 = join9(dirPath, entry.name);
+      const fullPath = join10(dirPath, entry.name);
       const relativePath = relative(capabilityPath, fullPath);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "__pycache__") {
         continue;
@@ -4675,6 +4856,141 @@ function formatScanResults(summary, verbose = false) {
   return lines.join(`
 `);
 }
+var UNICODE_PATTERNS, SUSPICIOUS_SCRIPT_PATTERNS, BINARY_EXTENSIONS, TEXT_EXTENSIONS;
+var init_scanner = __esm(() => {
+  init_types3();
+  UNICODE_PATTERNS = {
+    bidi: [
+      8234,
+      8235,
+      8236,
+      8237,
+      8238,
+      8294,
+      8295,
+      8296,
+      8297
+    ],
+    zeroWidth: [
+      8203,
+      8204,
+      8205,
+      8288,
+      65279
+    ],
+    control: [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      11,
+      12,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      28,
+      29,
+      30,
+      31,
+      127
+    ]
+  };
+  SUSPICIOUS_SCRIPT_PATTERNS = [
+    {
+      pattern: /curl\s+.*\|\s*(ba)?sh/i,
+      message: "Piping curl to shell can execute arbitrary remote code",
+      severity: "high"
+    },
+    {
+      pattern: /wget\s+.*\|\s*(ba)?sh/i,
+      message: "Piping wget to shell can execute arbitrary remote code",
+      severity: "high"
+    },
+    {
+      pattern: /eval\s*\(\s*\$\(/,
+      message: "eval with command substitution can be dangerous",
+      severity: "medium"
+    },
+    {
+      pattern: /rm\s+-rf\s+\/($|\s)|rm\s+-rf\s+~($|\s)/,
+      message: "Recursive deletion from root or home directory",
+      severity: "critical"
+    },
+    {
+      pattern: /chmod\s+777/,
+      message: "Setting world-writable permissions",
+      severity: "medium"
+    },
+    {
+      pattern: /\bsudo\b.*>/,
+      message: "Using sudo with output redirection",
+      severity: "medium"
+    },
+    {
+      pattern: /base64\s+-d.*\|\s*(ba)?sh/i,
+      message: "Decoding and executing base64 content",
+      severity: "high"
+    }
+  ];
+  BINARY_EXTENSIONS = new Set([
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".bin",
+    ".o",
+    ".a",
+    ".lib",
+    ".pyc",
+    ".pyo",
+    ".class",
+    ".jar",
+    ".war",
+    ".ear",
+    ".wasm",
+    ".node"
+  ]);
+  TEXT_EXTENSIONS = new Set([
+    ".md",
+    ".txt",
+    ".toml",
+    ".yaml",
+    ".yml",
+    ".json",
+    ".js",
+    ".ts",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".fish",
+    ".py",
+    ".rb"
+  ]);
+});
+
+// ../core/src/security/index.ts
+var init_security = __esm(() => {
+  init_scanner();
+  init_types3();
+});
+
+// ../core/src/templates/agents.ts
 function generateAgentsTemplate() {
   return `# Project Instructions
 
@@ -4685,6 +5001,8 @@ function generateAgentsTemplate() {
 <!-- This section is populated during sync with capability rules and docs -->
 `;
 }
+
+// ../core/src/templates/capability.ts
 function generateCapabilityToml2(options) {
   const description = options.description || "TODO: Add a description for your capability";
   return `[capability]
@@ -4795,12 +5113,16 @@ exit 0
 function formatDisplayName(kebabCase) {
   return kebabCase.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
+
+// ../core/src/templates/claude.ts
 function generateClaudeTemplate() {
   return `# Project Instructions
 
 <!-- Add your project-specific instructions here -->
 `;
 }
+
+// ../core/src/templates/omni.ts
 function generateOmniMdTemplate() {
   return `# Project Instructions
 
@@ -4821,6 +5143,8 @@ function generateOmniMdTemplate() {
 <!-- Describe your project's architecture and key components -->
 `;
 }
+
+// ../core/src/debug.ts
 function debug(message, data) {
   if (process.env["OMNIDEV_DEBUG"] !== "1") {
     return;
@@ -4834,253 +5158,166 @@ function debug(message, data) {
   }
   console.log(logLine);
 }
+
+// ../core/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  writeSecurityAllows: () => writeSecurityAllows,
+  writeProviderConfig: () => writeProviderConfig,
+  writeMcpJson: () => writeMcpJson,
+  writeEnabledProviders: () => writeEnabledProviders,
+  writeConfig: () => writeConfig,
+  writeActiveProfileState: () => writeActiveProfileState,
+  version: () => version,
+  verifyIntegrity: () => verifyIntegrity,
+  validateHooksConfig: () => validateHooksConfig,
+  validateHook: () => validateHook,
+  transformToOmnidev: () => transformToOmnidev,
+  transformToClaude: () => transformToClaude,
+  transformHooksConfig: () => transformHooksConfig,
+  syncMcpJson: () => syncMcpJson,
+  syncAgentConfiguration: () => syncAgentConfiguration,
+  sourceToGitUrl: () => sourceToGitUrl,
+  setProfile: () => setProfile,
+  setActiveProfile: () => setActiveProfile,
+  scanCapability: () => scanCapability,
+  scanCapabilities: () => scanCapabilities,
+  saveManifest: () => saveManifest,
+  saveLockFile: () => saveLockFile,
+  resolveEnabledCapabilities: () => resolveEnabledCapabilities,
+  removeSecurityAllow: () => removeSecurityAllow,
+  readSecurityAllows: () => readSecurityAllows,
+  readMcpJson: () => readMcpJson,
+  readEnabledProviders: () => readEnabledProviders,
+  readCapabilityIdFromPath: () => readCapabilityIdFromPath,
+  readActiveProfileState: () => readActiveProfileState,
+  patchAddToProfile: () => patchAddToProfile,
+  patchAddMcp: () => patchAddMcp,
+  patchAddCapabilitySource: () => patchAddCapabilitySource,
+  parseSourceConfig: () => parseSourceConfig,
+  parseProviderFlag: () => parseProviderFlag,
+  parseOmniConfig: () => parseOmniConfig,
+  parseFileSourcePath: () => parseFileSourcePath,
+  parseCapabilityConfig: () => parseCapabilityConfig,
+  mergeHooksConfigs: () => mergeHooksConfigs,
+  mergeAndDeduplicateHooks: () => mergeAndDeduplicateHooks,
+  loadSubagents: () => loadSubagents,
+  loadSkills: () => loadSkills,
+  loadRules: () => loadRules,
+  loadProviderConfig: () => loadProviderConfig,
+  loadProfileConfig: () => loadProfileConfig,
+  loadManifest: () => loadManifest,
+  loadLockFile: () => loadLockFile,
+  loadHooksFromCapability: () => loadHooksFromCapability,
+  loadDocs: () => loadDocs,
+  loadConfig: () => loadConfig,
+  loadCommands: () => loadCommands,
+  loadCapabilityHooks: () => loadCapabilityHooks,
+  loadCapabilityConfig: () => loadCapabilityConfig,
+  loadCapability: () => loadCapability,
+  loadBaseConfig: () => loadBaseConfig,
+  isValidMatcherPattern: () => isValidMatcherPattern,
+  isSecurityAllowed: () => isSecurityAllowed,
+  isProviderEnabled: () => isProviderEnabled,
+  isPromptHookEvent: () => isPromptHookEvent,
+  isMatcherEvent: () => isMatcherEvent,
+  isHookType: () => isHookType,
+  isHookPrompt: () => isHookPrompt,
+  isHookEvent: () => isHookEvent,
+  isHookCommand: () => isHookCommand,
+  isGitSource: () => isGitSource,
+  isFileSourceConfig: () => isFileSourceConfig,
+  isFileSource: () => isFileSource,
+  installCapabilityDependencies: () => installCapabilityDependencies,
+  hasHooks: () => hasHooks,
+  hasAnyHooks: () => hasAnyHooks,
+  getVersion: () => getVersion,
+  getSourceCapabilityPath: () => getSourceCapabilityPath,
+  getLockFilePath: () => getLockFilePath,
+  getHooksDirectory: () => getHooksDirectory,
+  getHooksConfigPath: () => getHooksConfigPath,
+  getEventsWithHooks: () => getEventsWithHooks,
+  getEnabledCapabilities: () => getEnabledCapabilities,
+  getCapabilityAllows: () => getCapabilityAllows,
+  getAllSecurityAllows: () => getAllSecurityAllows,
+  getActiveProviders: () => getActiveProviders,
+  getActiveProfile: () => getActiveProfile,
+  generateSkillTemplate: () => generateSkillTemplate,
+  generateRuleTemplate: () => generateRuleTemplate,
+  generateOmniMdTemplate: () => generateOmniMdTemplate,
+  generateHooksTemplate: () => generateHooksTemplate,
+  generateHookScript: () => generateHookScript,
+  generateClaudeTemplate: () => generateClaudeTemplate,
+  generateCapabilityToml: () => generateCapabilityToml2,
+  generateAgentsTemplate: () => generateAgentsTemplate,
+  formatScanResults: () => formatScanResults,
+  findDuplicateCommands: () => findDuplicateCommands,
+  fetchCapabilitySource: () => fetchCapabilitySource,
+  fetchAllCapabilitySources: () => fetchAllCapabilitySources,
+  enableProvider: () => enableProvider,
+  enableCapability: () => enableCapability,
+  discoverCapabilities: () => discoverCapabilities,
+  disableProvider: () => disableProvider,
+  disableCapability: () => disableCapability,
+  detectPinVersion: () => detectPinVersion,
+  debug: () => debug,
+  createEmptyValidationResult: () => createEmptyValidationResult,
+  createEmptyHooksConfig: () => createEmptyHooksConfig,
+  countHooks: () => countHooks,
+  containsOmnidevVariables: () => containsOmnidevVariables,
+  containsClaudeVariables: () => containsClaudeVariables,
+  clearCapabilityAllows: () => clearCapabilityAllows,
+  clearAllSecurityAllows: () => clearAllSecurityAllows,
+  clearActiveProfileState: () => clearActiveProfileState,
+  cleanupStaleResources: () => cleanupStaleResources,
+  checkVersionMismatch: () => checkVersionMismatch,
+  checkForUpdates: () => checkForUpdates,
+  buildSyncBundle: () => buildSyncBundle,
+  buildManifestFromCapabilities: () => buildManifestFromCapabilities,
+  buildCapabilityRegistry: () => buildCapabilityRegistry,
+  addSecurityAllow: () => addSecurityAllow,
+  VARIABLE_MAPPINGS: () => VARIABLE_MAPPINGS,
+  SESSION_START_MATCHERS: () => SESSION_START_MATCHERS,
+  PROMPT_HOOK_EVENTS: () => PROMPT_HOOK_EVENTS,
+  PRE_COMPACT_MATCHERS: () => PRE_COMPACT_MATCHERS,
+  NOTIFICATION_MATCHERS: () => NOTIFICATION_MATCHERS,
+  MATCHER_EVENTS: () => MATCHER_EVENTS,
+  HOOK_TYPES: () => HOOK_TYPES,
+  HOOK_EVENTS: () => HOOK_EVENTS,
+  HOOKS_DIRECTORY: () => HOOKS_DIRECTORY,
+  HOOKS_CONFIG_FILENAME: () => HOOKS_CONFIG_FILENAME,
+  DEFAULT_SECURITY_CONFIG: () => DEFAULT_SECURITY_CONFIG,
+  DEFAULT_SCAN_SETTINGS: () => DEFAULT_SCAN_SETTINGS,
+  DEFAULT_PROMPT_TIMEOUT: () => DEFAULT_PROMPT_TIMEOUT,
+  DEFAULT_COMMAND_TIMEOUT: () => DEFAULT_COMMAND_TIMEOUT,
+  COMMON_TOOL_MATCHERS: () => COMMON_TOOL_MATCHERS
+});
 function getVersion() {
   return version;
 }
-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", REVERSE_MAPPINGS, CAPABILITIES_DIR = ".omni/capabilities", CONFIG_PATH = "omni.toml", LOCAL_CONFIG = "omni.local.toml", STATE_DIR = ".omni/state", ACTIVE_PROFILE_PATH, OMNI_LOCAL = ".omni", SKILL_DIRS, AGENT_DIRS, COMMAND_DIRS, RULE_DIRS, DOC_DIRS, SKILL_FILES, AGENT_FILES, COMMAND_FILES, CONTENT_HASH_EXCLUDES, PROVIDER_CONFIG_PATH = ".omni/provider.toml", CONFIG_PATH2 = "omni.toml", MCP_JSON_PATH = ".mcp.json", MANIFEST_PATH = ".omni/state/manifest.json", CURRENT_VERSION = 1, STATE_DIR2 = ".omni/state", PROVIDERS_PATH, DEFAULT_PROVIDERS, OMNI_DIR = ".omni", SECURITY_PATH, DEFAULT_STATE, DEFAULT_SECURITY_CONFIG, DEFAULT_SCAN_SETTINGS, UNICODE_PATTERNS, SUSPICIOUS_SCRIPT_PATTERNS, BINARY_EXTENSIONS, TEXT_EXTENSIONS, version = "0.1.0";
-var init_dist2 = __esm(() => {
-  init_chunk_1dqs11h6();
-  init_dist();
-  init_dist();
-  init_dist();
-  init_dist();
-  HOOK_EVENTS = [
-    "PreToolUse",
-    "PostToolUse",
-    "PermissionRequest",
-    "UserPromptSubmit",
-    "Stop",
-    "SubagentStop",
-    "Notification",
-    "SessionStart",
-    "SessionEnd",
-    "PreCompact"
-  ];
-  MATCHER_EVENTS = [
-    "PreToolUse",
-    "PostToolUse",
-    "PermissionRequest",
-    "Notification",
-    "SessionStart",
-    "PreCompact"
-  ];
-  PROMPT_HOOK_EVENTS = [
-    "Stop",
-    "SubagentStop",
-    "UserPromptSubmit",
-    "PreToolUse",
-    "PermissionRequest"
-  ];
-  HOOK_TYPES = ["command", "prompt"];
-  COMMON_TOOL_MATCHERS = [
-    "Bash",
-    "Read",
-    "Write",
-    "Edit",
-    "Glob",
-    "Grep",
-    "Task",
-    "WebFetch",
-    "WebSearch",
-    "NotebookEdit",
-    "LSP",
-    "TodoWrite",
-    "AskUserQuestion"
-  ];
-  NOTIFICATION_MATCHERS = [
-    "permission_prompt",
-    "idle_prompt",
-    "auth_success",
-    "elicitation_dialog"
-  ];
-  SESSION_START_MATCHERS = ["startup", "resume", "clear", "compact"];
-  PRE_COMPACT_MATCHERS = ["manual", "auto"];
-  VARIABLE_MAPPINGS = {
-    OMNIDEV_CAPABILITY_ROOT: "CLAUDE_PLUGIN_ROOT",
-    OMNIDEV_PROJECT_DIR: "CLAUDE_PROJECT_DIR"
-  };
-  REVERSE_MAPPINGS = Object.fromEntries(Object.entries(VARIABLE_MAPPINGS).map(([omni, claude]) => [claude, omni]));
-  ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
-  SKILL_DIRS = ["skills", "skill"];
-  AGENT_DIRS = ["agents", "agent", "subagents", "subagent"];
-  COMMAND_DIRS = ["commands", "command"];
-  RULE_DIRS = ["rules", "rule"];
-  DOC_DIRS = ["docs", "doc", "documentation"];
-  SKILL_FILES = ["SKILL.md", "skill.md", "Skill.md"];
-  AGENT_FILES = ["AGENT.md", "agent.md", "Agent.md", "SUBAGENT.md", "subagent.md"];
-  COMMAND_FILES = ["COMMAND.md", "command.md", "Command.md"];
-  CONTENT_HASH_EXCLUDES = [
-    ".git",
-    "node_modules",
-    ".omni",
-    "__pycache__",
-    ".pytest_cache",
-    ".mypy_cache",
-    "dist",
-    "build",
-    ".DS_Store",
-    "Thumbs.db"
-  ];
-  PROVIDERS_PATH = `${STATE_DIR2}/providers.json`;
-  DEFAULT_PROVIDERS = ["claude-code"];
-  SECURITY_PATH = `${OMNI_DIR}/security.json`;
-  DEFAULT_STATE = {
-    version: 1,
-    modifiedAt: new Date().toISOString(),
-    allows: {}
-  };
-  DEFAULT_SECURITY_CONFIG = {
-    mode: "off",
-    trusted_sources: [],
-    scan: {
-      unicode: true,
-      symlinks: true,
-      scripts: true,
-      binaries: false
-    }
-  };
-  DEFAULT_SCAN_SETTINGS = {
-    unicode: true,
-    symlinks: true,
-    scripts: true,
-    binaries: false
-  };
-  UNICODE_PATTERNS = {
-    bidi: [
-      8234,
-      8235,
-      8236,
-      8237,
-      8238,
-      8294,
-      8295,
-      8296,
-      8297
-    ],
-    zeroWidth: [
-      8203,
-      8204,
-      8205,
-      8288,
-      65279
-    ],
-    control: [
-      0,
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      11,
-      12,
-      14,
-      15,
-      16,
-      17,
-      18,
-      19,
-      20,
-      21,
-      22,
-      23,
-      24,
-      25,
-      26,
-      27,
-      28,
-      29,
-      30,
-      31,
-      127
-    ]
-  };
-  SUSPICIOUS_SCRIPT_PATTERNS = [
-    {
-      pattern: /curl\s+.*\|\s*(ba)?sh/i,
-      message: "Piping curl to shell can execute arbitrary remote code",
-      severity: "high"
-    },
-    {
-      pattern: /wget\s+.*\|\s*(ba)?sh/i,
-      message: "Piping wget to shell can execute arbitrary remote code",
-      severity: "high"
-    },
-    {
-      pattern: /eval\s*\(\s*\$\(/,
-      message: "eval with command substitution can be dangerous",
-      severity: "medium"
-    },
-    {
-      pattern: /rm\s+-rf\s+\/($|\s)|rm\s+-rf\s+~($|\s)/,
-      message: "Recursive deletion from root or home directory",
-      severity: "critical"
-    },
-    {
-      pattern: /chmod\s+777/,
-      message: "Setting world-writable permissions",
-      severity: "medium"
-    },
-    {
-      pattern: /\bsudo\b.*>/,
-      message: "Using sudo with output redirection",
-      severity: "medium"
-    },
-    {
-      pattern: /base64\s+-d.*\|\s*(ba)?sh/i,
-      message: "Decoding and executing base64 content",
-      severity: "high"
-    }
-  ];
-  BINARY_EXTENSIONS = new Set([
-    ".exe",
-    ".dll",
-    ".so",
-    ".dylib",
-    ".bin",
-    ".o",
-    ".a",
-    ".lib",
-    ".pyc",
-    ".pyo",
-    ".class",
-    ".jar",
-    ".war",
-    ".ear",
-    ".wasm",
-    ".node"
-  ]);
-  TEXT_EXTENSIONS = new Set([
-    ".md",
-    ".txt",
-    ".toml",
-    ".yaml",
-    ".yml",
-    ".json",
-    ".js",
-    ".ts",
-    ".sh",
-    ".bash",
-    ".zsh",
-    ".fish",
-    ".py",
-    ".rb"
-  ]);
+var version = "0.1.0";
+var init_src = __esm(() => {
+  init_capability();
+  init_hooks();
+  init_config2();
+  init_mcp_json();
+  init_state();
+  init_sync();
+  init_security();
+  init_types2();
 });
 
 // src/index.ts
 import { run } from "@stricli/core";
 
 // src/lib/dynamic-app.ts
-import { existsSync as existsSync29 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
+import { existsSync as existsSync28 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
 import { join as join18 } from "node:path";
 import { buildApplication, buildRouteMap as buildRouteMap7 } from "@stricli/core";
 
 // src/commands/add.ts
-import { existsSync as existsSync22 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import { basename as basename3, resolve as resolve3 } from "node:path";
 
 // ../adapters/src/writers/cursor-rules.ts
@@ -5103,17 +5340,17 @@ var CursorRulesWriter = {
   }
 };
 // ../adapters/src/writers/hooks.ts
-init_dist2();
+init_src();
 import { existsSync as existsSync19 } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile17, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname, join as join10 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile17, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname, join as join11 } from "node:path";
 var HooksWriter = {
   id: "hooks",
   async write(bundle, ctx) {
     if (!bundle.hooks) {
       return { filesWritten: [] };
     }
-    const settingsPath = join10(ctx.projectRoot, ctx.outputPath);
+    const settingsPath = join11(ctx.projectRoot, ctx.outputPath);
     const parentDir = dirname(settingsPath);
     await mkdir3(parentDir, { recursive: true });
     const claudeHooks = transformHooksConfig(bundle.hooks, "toClaude");
@@ -5130,7 +5367,7 @@ var HooksWriter = {
       ...existingSettings,
       hooks: claudeHooks
     };
-    await writeFile10(settingsPath, `${JSON.stringify(newSettings, null, 2)}
+    await writeFile11(settingsPath, `${JSON.stringify(newSettings, null, 2)}
 `, "utf-8");
     return {
       filesWritten: [ctx.outputPath]
@@ -5138,8 +5375,8 @@ var HooksWriter = {
   }
 };
 // ../adapters/src/writers/instructions-md.ts
-import { existsSync as existsSync21 } from "node:fs";
-import { mkdir as mkdir4, readFile as readFile19, writeFile as writeFile12 } from "node:fs/promises";
+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";
 var InstructionsMdWriter = {
   id: "instructions-md",
@@ -5151,8 +5388,8 @@ var InstructionsMdWriter = {
     }
     const omniMdPath = join12(ctx.projectRoot, "OMNI.md");
     let omniMdContent = "";
-    if (existsSync21(omniMdPath)) {
-      omniMdContent = await readFile19(omniMdPath, "utf-8");
+    if (existsSync20(omniMdPath)) {
+      omniMdContent = await readFile18(omniMdPath, "utf-8");
     }
     let content = omniMdContent;
     if (bundle.instructionsContent) {
@@ -5199,19 +5436,19 @@ 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}`;
+  for (const config3 of writerConfigs) {
+    const key = `${config3.writer.id}:${config3.outputPath}`;
     if (seen.has(key)) {
       deduplicatedCount++;
       continue;
     }
     seen.add(key);
-    uniqueConfigs.push(config);
+    uniqueConfigs.push(config3);
   }
   const allFilesWritten = [];
-  for (const config of uniqueConfigs) {
-    const result = await config.writer.write(bundle, {
-      outputPath: config.outputPath,
+  for (const config3 of uniqueConfigs) {
+    const result = await config3.writer.write(bundle, {
+      outputPath: config3.outputPath,
       projectRoot
     });
     allFilesWritten.push(...result.filesWritten);
@@ -5271,7 +5508,7 @@ var codexAdapter = {
   }
 };
 // ../adapters/src/cursor/index.ts
-import { mkdirSync as mkdirSync8 } from "node:fs";
+import { mkdirSync as mkdirSync7 } from "node:fs";
 import { join as join15 } from "node:path";
 var cursorAdapter = {
   id: "cursor",
@@ -5283,7 +5520,7 @@ var cursorAdapter = {
   ],
   async init(ctx) {
     const rulesDir = join15(ctx.projectRoot, ".cursor", "rules");
-    mkdirSync8(rulesDir, { recursive: true });
+    mkdirSync7(rulesDir, { recursive: true });
     return {
       filesCreated: [".cursor/rules/"],
       message: "Created .cursor/rules/ directory"
@@ -5298,7 +5535,7 @@ var cursorAdapter = {
   }
 };
 // ../adapters/src/opencode/index.ts
-import { mkdirSync as mkdirSync9 } from "node:fs";
+import { mkdirSync as mkdirSync8 } from "node:fs";
 import { join as join16 } from "node:path";
 var opencodeAdapter = {
   id: "opencode",
@@ -5309,7 +5546,7 @@ var opencodeAdapter = {
   ],
   async init(ctx) {
     const opencodeDir = join16(ctx.projectRoot, ".opencode");
-    mkdirSync9(opencodeDir, { recursive: true });
+    mkdirSync8(opencodeDir, { recursive: true });
     return {
       filesCreated: [".opencode/"],
       message: "OpenCode adapter initialized"
@@ -5324,7 +5561,7 @@ var opencodeAdapter = {
   }
 };
 // ../adapters/src/registry.ts
-init_dist2();
+init_src();
 var builtInAdapters = [
   claudeCodeAdapter,
   codexAdapter,
@@ -5340,7 +5577,7 @@ async function getEnabledAdapters() {
   return enabledIds.map((id) => adapterMap.get(id)).filter((a) => a != null);
 }
 // src/commands/add.ts
-init_dist2();
+init_src();
 import { buildCommand, buildRouteMap } from "@stricli/core";
 async function inferCapabilityId(source, sourceType) {
   if (sourceType === "local") {
@@ -5360,7 +5597,7 @@ async function inferCapabilityId(source, sourceType) {
 }
 async function runAddCap(flags, name) {
   try {
-    if (!existsSync22("omni.toml")) {
+    if (!existsSync21("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -5383,7 +5620,7 @@ async function runAddCap(flags, name) {
       sourceType = "local";
       const localPath = flags.local.startsWith("file://") ? flags.local.slice(7) : flags.local;
       source = `file://${localPath}`;
-      if (!existsSync22(localPath)) {
+      if (!existsSync21(localPath)) {
         console.error(`✗ Local path not found: ${localPath}`);
         process.exit(1);
       }
@@ -5416,9 +5653,9 @@ async function runAddCap(flags, name) {
       }
       console.log(`  Inferred capability ID: ${capabilityId}`);
     }
-    const config = await loadBaseConfig();
+    const config3 = await loadBaseConfig();
     const activeProfile = await getActiveProfile() ?? "default";
-    if (config.capabilities?.sources?.[capabilityId]) {
+    if (config3.capabilities?.sources?.[capabilityId]) {
       console.error(`✗ Capability source "${capabilityId}" already exists`);
       console.log("  Use a different name or remove the existing source first");
       process.exit(1);
@@ -5464,14 +5701,14 @@ async function runAddCap(flags, name) {
 }
 async function runAddMcp(flags, name) {
   try {
-    if (!existsSync22("omni.toml")) {
+    if (!existsSync21("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
     }
-    const config = await loadBaseConfig();
+    const config3 = await loadBaseConfig();
     const activeProfile = await getActiveProfile() ?? "default";
-    if (config.mcps?.[name]) {
+    if (config3.mcps?.[name]) {
       console.error(`✗ MCP "${name}" already exists`);
       console.log("  Use a different name or remove the existing MCP first");
       process.exit(1);
@@ -5747,11 +5984,11 @@ var addRoutes = buildRouteMap({
 });
 
 // src/commands/capability.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync10 } from "node:fs";
+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 { input } from "@inquirer/prompts";
-init_dist2();
+init_src();
 import { buildCommand as buildCommand2, buildRouteMap as buildRouteMap2 } from "@stricli/core";
 
 // src/prompts/capability.ts
@@ -5768,15 +6005,14 @@ async function runCapabilityList(flags = {}) {
     if (capabilityPaths.length === 0) {
       console.log("No capabilities found.");
       console.log("");
-      console.log("To add capabilities, create directories in omni/capabilities/");
-      console.log("Each capability must have a capability.toml file.");
+      console.log("To add capabilities, use the 'omnidev add cap' command.");
       return;
     }
     let updates;
     if (flags.verbose) {
       try {
-        const config = await loadBaseConfig();
-        const updateInfo = await checkForUpdates(config);
+        const config3 = await loadBaseConfig();
+        const updateInfo = await checkForUpdates(config3);
         updates = new Map(updateInfo.map((u) => [u.id, { hasUpdate: u.hasUpdate, latestVersion: u.latestVersion }]));
       } catch {}
     }
@@ -5831,8 +6067,8 @@ async function runCapabilityEnable(_flags, name) {
   try {
     const capabilityPaths = await discoverCapabilities();
     const capabilityExists = capabilityPaths.some(async (path) => {
-      const config = await loadCapabilityConfig(path);
-      return config.capability.id === name;
+      const config3 = await loadCapabilityConfig(path);
+      return config3.capability.id === name;
     });
     if (!capabilityExists) {
       console.error(`Error: Capability '${name}' not found`);
@@ -5935,7 +6171,7 @@ node_modules/
 }
 async function runCapabilityNew(flags, capabilityId) {
   try {
-    if (!existsSync23(".omni")) {
+    if (!existsSync22(".omni")) {
       console.error("✗ OmniDev is not initialized in this directory.");
       console.log("");
       console.log("  Run: omnidev init");
@@ -5959,22 +6195,22 @@ async function runCapabilityNew(flags, capabilityId) {
         default: defaultPath
       });
     }
-    if (existsSync23(capabilityDir)) {
+    if (existsSync22(capabilityDir)) {
       console.error(`✗ Directory already exists at ${capabilityDir}`);
       process.exit(1);
     }
     const name = toTitleCase(id);
-    mkdirSync10(capabilityDir, { recursive: true });
+    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");
-    mkdirSync10(skillDir, { recursive: true });
+    mkdirSync9(skillDir, { recursive: true });
     await writeFile14(join17(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
     const rulesDir = join17(capabilityDir, "rules");
-    mkdirSync10(rulesDir, { recursive: true });
+    mkdirSync9(rulesDir, { recursive: true });
     await writeFile14(join17(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
     const hooksDir = join17(capabilityDir, "hooks");
-    mkdirSync10(hooksDir, { recursive: true });
+    mkdirSync9(hooksDir, { recursive: true });
     await writeFile14(join17(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
     await writeFile14(join17(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
     if (flags.programmatic) {
@@ -6136,9 +6372,9 @@ var capabilityRoutes = buildRouteMap2({
 });
 
 // src/commands/doctor.ts
-import { existsSync as existsSync24 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { execFile } from "node:child_process";
-import { readFile as readFile20 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 import { promisify } from "node:util";
 import { buildCommand as buildCommand3 } from "@stricli/core";
 var doctorCommand = buildCommand3({
@@ -6226,7 +6462,7 @@ async function checkPackageManager() {
   }
 }
 async function checkOmniLocalDir() {
-  const exists = existsSync24(".omni");
+  const exists = existsSync23(".omni");
   if (!exists) {
     return {
       name: ".omni/ directory",
@@ -6243,7 +6479,7 @@ async function checkOmniLocalDir() {
 }
 async function checkConfig() {
   const configPath = "omni.toml";
-  if (!existsSync24(configPath)) {
+  if (!existsSync23(configPath)) {
     return {
       name: "Configuration",
       passed: false,
@@ -6252,7 +6488,7 @@ async function checkConfig() {
     };
   }
   try {
-    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
+    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_src(), exports_src));
     await loadConfig2();
     return {
       name: "Configuration",
@@ -6270,7 +6506,7 @@ async function checkConfig() {
 }
 async function checkRootGitignore() {
   const gitignorePath = ".gitignore";
-  if (!existsSync24(gitignorePath)) {
+  if (!existsSync23(gitignorePath)) {
     return {
       name: "Root .gitignore",
       passed: false,
@@ -6278,7 +6514,7 @@ async function checkRootGitignore() {
       fix: "Run: omnidev init"
     };
   }
-  const content = await readFile20(gitignorePath, "utf-8");
+  const content = await readFile19(gitignorePath, "utf-8");
   const lines = content.split(`
 `).map((line) => line.trim());
   const hasOmniDir = lines.includes(".omni/");
@@ -6304,7 +6540,7 @@ async function checkRootGitignore() {
 }
 async function checkCapabilitiesDir() {
   const capabilitiesDirPath = ".omni/capabilities";
-  if (!existsSync24(capabilitiesDirPath)) {
+  if (!existsSync23(capabilitiesDirPath)) {
     return {
       name: "Capabilities Directory",
       passed: true,
@@ -6320,10 +6556,10 @@ async function checkCapabilitiesDir() {
 
 // src/commands/init.ts
 import { exec } from "node:child_process";
-import { existsSync as existsSync25, mkdirSync as mkdirSync11 } from "node:fs";
-import { readFile as readFile21, writeFile as writeFile15 } from "node:fs/promises";
+import { existsSync as existsSync24, mkdirSync as mkdirSync10 } from "node:fs";
+import { readFile as readFile20, writeFile as writeFile15 } from "node:fs/promises";
 import { promisify as promisify2 } from "node:util";
-init_dist2();
+init_src();
 import { buildCommand as buildCommand4 } from "@stricli/core";
 
 // src/prompts/provider.ts
@@ -6334,8 +6570,8 @@ var PROVIDER_GITIGNORE_FILES = {
   codex: ["AGENTS.md", ".codex/"],
   opencode: [".opencode/"]
 };
-function getProviderGitignoreFiles(providers) {
-  return providers.flatMap((p) => PROVIDER_GITIGNORE_FILES[p] ?? []);
+function getProviderGitignoreFiles(providers2) {
+  return providers2.flatMap((p) => PROVIDER_GITIGNORE_FILES[p] ?? []);
 }
 async function promptForProviders() {
   const answers = await checkbox({
@@ -6362,9 +6598,9 @@ async function promptForGitignoreProviderFiles(selectedProviders) {
 var execAsync = promisify2(exec);
 async function runInit(_flags, providerArg) {
   console.log("Initializing OmniDev...");
-  mkdirSync11(".omni", { recursive: true });
-  mkdirSync11(".omni/capabilities", { recursive: true });
-  mkdirSync11(".omni/state", { recursive: true });
+  mkdirSync10(".omni", { recursive: true });
+  mkdirSync10(".omni/capabilities", { recursive: true });
+  mkdirSync10(".omni/state", { recursive: true });
   await updateRootGitignore();
   let providerIds;
   const isInteractive = !providerArg;
@@ -6390,7 +6626,7 @@ async function runInit(_flags, providerArg) {
     }
   }
   await writeEnabledProviders(providerIds);
-  if (!existsSync25("omni.toml")) {
+  if (!existsSync24("omni.toml")) {
     await writeConfig({
       profiles: {
         default: {
@@ -6406,13 +6642,13 @@ async function runInit(_flags, providerArg) {
     });
     await setActiveProfile("default");
   }
-  if (!existsSync25("OMNI.md")) {
+  if (!existsSync24("OMNI.md")) {
     await writeFile15("OMNI.md", generateOmniMdTemplate(), "utf-8");
   }
-  const config = await loadConfig();
+  const config3 = await loadConfig();
   const ctx = {
     projectRoot: process.cwd(),
-    config
+    config: config3
   };
   const selectedAdapters = await initializeAdaptersForProviders(providerIds, ctx);
   const enabledAdapters = await getEnabledAdapters();
@@ -6484,8 +6720,8 @@ async function addProviderFilesToGitignore(entries) {
 async function addToGitignore(entriesToAdd, sectionHeader) {
   const gitignorePath = ".gitignore";
   let content = "";
-  if (existsSync25(gitignorePath)) {
-    content = await readFile21(gitignorePath, "utf-8");
+  if (existsSync24(gitignorePath)) {
+    content = await readFile20(gitignorePath, "utf-8");
   }
   const lines = content.split(`
 `);
@@ -6516,8 +6752,8 @@ async function getTrackedProviderFiles(files) {
 }
 
 // src/commands/profile.ts
-import { existsSync as existsSync26 } from "node:fs";
-init_dist2();
+import { existsSync as existsSync25 } from "node:fs";
+init_src();
 import { buildCommand as buildCommand5, buildRouteMap as buildRouteMap3 } from "@stricli/core";
 var listCommand2 = buildCommand5({
   docs: {
@@ -6560,15 +6796,15 @@ var profileRoutes = buildRouteMap3({
 });
 async function runProfileList() {
   try {
-    if (!existsSync26("omni.toml")) {
+    if (!existsSync25("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
     }
-    const config = await loadConfig();
+    const config3 = await loadConfig();
     const activeProfile = await getActiveProfile() ?? "default";
-    const profiles = config.profiles ?? {};
-    const profileNames = Object.keys(profiles);
+    const profiles2 = config3.profiles ?? {};
+    const profileNames = Object.keys(profiles2);
     if (profileNames.length === 0) {
       console.log("No profiles defined in omni.toml");
       console.log("");
@@ -6580,14 +6816,14 @@ async function runProfileList() {
     for (const name of profileNames) {
       const isActive = name === activeProfile;
       const icon = isActive ? "●" : "○";
-      const profile = profiles[name];
+      const profile = profiles2[name];
       if (profile === undefined) {
         continue;
       }
       console.log(`${icon} ${name}${isActive ? " (active)" : ""}`);
-      const capabilities = resolveEnabledCapabilities(config, name);
-      if (capabilities.length > 0) {
-        console.log(`  Capabilities: ${capabilities.join(", ")}`);
+      const capabilities2 = resolveEnabledCapabilities(config3, name);
+      if (capabilities2.length > 0) {
+        console.log(`  Capabilities: ${capabilities2.join(", ")}`);
       } else {
         console.log("  Capabilities: none");
       }
@@ -6600,18 +6836,18 @@ async function runProfileList() {
 }
 async function runProfileSet(profileName) {
   try {
-    if (!existsSync26("omni.toml")) {
+    if (!existsSync25("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
     }
-    const config = await loadConfig();
-    const profiles = config.profiles ?? {};
-    if (!(profileName in profiles)) {
+    const config3 = await loadConfig();
+    const profiles2 = config3.profiles ?? {};
+    if (!(profileName in profiles2)) {
       console.log(`✗ Profile "${profileName}" not found in omni.toml`);
       console.log("");
       console.log("Available profiles:");
-      const profileNames = Object.keys(profiles);
+      const profileNames = Object.keys(profiles2);
       if (profileNames.length === 0) {
         console.log("  (none defined)");
       } else {
@@ -6633,7 +6869,7 @@ async function runProfileSet(profileName) {
 }
 
 // src/commands/provider.ts
-init_dist2();
+init_src();
 import { buildCommand as buildCommand6, buildRouteMap as buildRouteMap4 } from "@stricli/core";
 async function runProviderList() {
   const enabled = await readEnabledProviders();
@@ -6748,8 +6984,8 @@ var providerRoutes = buildRouteMap4({
 });
 
 // src/commands/security.ts
-init_dist2();
-import { existsSync as existsSync27 } from "node:fs";
+init_src();
+import { existsSync as existsSync26 } from "node:fs";
 import { buildCommand as buildCommand7, buildRouteMap as buildRouteMap5 } from "@stricli/core";
 var VALID_FINDING_TYPES = [
   "unicode_bidi",
@@ -6764,10 +7000,10 @@ function isValidFindingType(type) {
   return VALID_FINDING_TYPES.includes(type);
 }
 async function filterAllowedFindings(summary, options = {}) {
-  const state = await readSecurityAllows();
+  const state2 = await readSecurityAllows();
   const { includeLow = false } = options;
   const filteredResults = summary.results.map((result) => {
-    const allows = state.allows[result.capabilityId] ?? [];
+    const allows = state2.allows[result.capabilityId] ?? [];
     const filteredFindings = result.findings.filter((finding) => {
       if (allows.includes(finding.type))
         return false;
@@ -6866,7 +7102,7 @@ function formatFindingsWithHints(summary) {
 }
 async function runSecurityIssues(flags = {}) {
   try {
-    if (!existsSync27("omni.toml")) {
+    if (!existsSync26("omni.toml")) {
       console.log("No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -6874,12 +7110,12 @@ async function runSecurityIssues(flags = {}) {
     console.log("Scanning capabilities for security issues...");
     console.log("");
     const registry = await buildCapabilityRegistry();
-    const capabilities = registry.getAllCapabilities();
-    if (capabilities.length === 0) {
+    const capabilities2 = registry.getAllCapabilities();
+    if (capabilities2.length === 0) {
       console.log("No capabilities found to scan.");
       return;
     }
-    const capabilityInfos = capabilities.map((cap) => ({
+    const capabilityInfos = capabilities2.map((cap) => ({
       id: cap.id,
       path: cap.path
     }));
@@ -6979,9 +7215,9 @@ async function runSecurityListAllows() {
         byCapability[allow.capabilityId] = [allow.findingType];
       }
     }
-    for (const [capId, types] of Object.entries(byCapability)) {
+    for (const [capId, types3] of Object.entries(byCapability)) {
       console.log(`  ${capId}:`);
-      for (const type of types) {
+      for (const type of types3) {
         console.log(`    - ${type}`);
       }
       console.log("");
@@ -7121,8 +7357,8 @@ var securityRoutes = buildRouteMap5({
 });
 
 // src/commands/sync.ts
-import { existsSync as existsSync28 } from "node:fs";
-init_dist2();
+import { existsSync as existsSync27 } from "node:fs";
+init_src();
 import { buildCommand as buildCommand8 } from "@stricli/core";
 var PROVIDERS_STATE_PATH = ".omni/state/providers.json";
 var syncCommand = buildCommand8({
@@ -7136,16 +7372,16 @@ var syncCommand = buildCommand8({
 });
 async function runSync() {
   try {
-    const config = await loadConfig();
+    const config3 = await loadConfig();
     const activeProfile = await getActiveProfile() ?? "default";
     let adapters = await getEnabledAdapters();
-    if (!existsSync28(PROVIDERS_STATE_PATH) || adapters.length === 0) {
+    if (!existsSync27(PROVIDERS_STATE_PATH) || adapters.length === 0) {
       console.log("No providers configured yet. Select your provider(s):");
       const providerIds = await promptForProviders();
       await writeEnabledProviders(providerIds);
       const ctx = {
         projectRoot: process.cwd(),
-        config
+        config: config3
       };
       adapters = await initializeAdaptersForProviders(providerIds, ctx);
       console.log("");
@@ -7175,7 +7411,7 @@ async function runSync() {
 }
 
 // src/lib/dynamic-app.ts
-init_dist2();
+init_src();
 
 // src/lib/command-transformer.ts
 import { buildCommand as buildCommand9, buildRouteMap as buildRouteMap6 } from "@stricli/core";
@@ -7327,7 +7563,7 @@ function transformCapabilityCommands(cliCommands) {
 }
 
 // src/lib/dynamic-app.ts
-var require2 = createRequire3(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 function readCliVersion() {
   try {
     const pkg = require2("../package.json");
@@ -7350,8 +7586,8 @@ async function buildDynamicApp() {
   };
   debug("Core routes registered", Object.keys(routes));
   const configPath = join18(process.cwd(), "omni.toml");
-  debug("Checking for config", { configPath, exists: existsSync29(configPath), cwd: process.cwd() });
-  if (existsSync29(configPath)) {
+  debug("Checking for config", { configPath, exists: existsSync28(configPath), cwd: process.cwd() });
+  if (existsSync28(configPath)) {
     try {
       debug("Loading capability commands...");
       const capabilityCommands = await loadCapabilityCommands();
@@ -7388,20 +7624,20 @@ async function buildDynamicApp() {
   return app;
 }
 async function loadCapabilityCommands() {
-  const { buildCapabilityRegistry: buildCapabilityRegistry2, installCapabilityDependencies: installCapabilityDependencies2 } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
+  const { buildCapabilityRegistry: buildCapabilityRegistry2, installCapabilityDependencies: installCapabilityDependencies2 } = await Promise.resolve().then(() => (init_src(), exports_src));
   await installCapabilityDependencies2(true);
   const registry = await buildCapabilityRegistry2();
-  const capabilities = registry.getAllCapabilities();
+  const capabilities2 = registry.getAllCapabilities();
   debug("Registry built", {
-    capabilityCount: capabilities.length,
-    capabilities: capabilities.map((c) => ({ id: c.id, path: c.path }))
+    capabilityCount: capabilities2.length,
+    capabilities: capabilities2.map((c) => ({ id: c.id, path: c.path }))
   });
   const commands = {};
-  for (const capability of capabilities) {
+  for (const capability3 of capabilities2) {
     try {
-      debug(`Loading capability '${capability.id}'`, { path: capability.path });
-      const capabilityExport = await loadCapabilityExport(capability);
-      debug(`Capability '${capability.id}' export`, {
+      debug(`Loading capability '${capability3.id}'`, { path: capability3.path });
+      const capabilityExport = await loadCapabilityExport(capability3);
+      debug(`Capability '${capability3.id}' export`, {
         found: !!capabilityExport,
         hasCLICommands: !!capabilityExport?.cliCommands,
         cliCommands: capabilityExport?.cliCommands ? Object.keys(capabilityExport.cliCommands) : []
@@ -7410,57 +7646,57 @@ async function loadCapabilityCommands() {
         const transformedCommands = transformCapabilityCommands(capabilityExport.cliCommands);
         for (const [commandName, command] of Object.entries(transformedCommands)) {
           if (commands[commandName]) {
-            console.warn(`Command '${commandName}' from capability '${capability.id}' conflicts with existing command. Using '${capability.id}' version.`);
+            console.warn(`Command '${commandName}' from capability '${capability3.id}' conflicts with existing command. Using '${capability3.id}' version.`);
           }
           commands[commandName] = command;
-          debug(`Registered command '${commandName}' from '${capability.id}'`, {
+          debug(`Registered command '${commandName}' from '${capability3.id}'`, {
             type: typeof command,
             constructor: command?.constructor?.name
           });
         }
       }
     } catch (error) {
-      console.error(`Failed to load capability '${capability.id}':`, error);
+      console.error(`Failed to load capability '${capability3.id}':`, error);
     }
   }
   return commands;
 }
-async function loadCapabilityExport(capability) {
-  const capabilityPath = join18(process.cwd(), capability.path);
+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");
-  debug(`Checking entry points for '${capability.id}'`, {
+  debug(`Checking entry points for '${capability3.id}'`, {
     capabilityPath,
     builtIndexPath,
-    builtExists: existsSync29(builtIndexPath),
+    builtExists: existsSync28(builtIndexPath),
     jsIndexPath,
-    jsExists: existsSync29(jsIndexPath),
+    jsExists: existsSync28(jsIndexPath),
     tsIndexPath,
-    tsExists: existsSync29(tsIndexPath)
+    tsExists: existsSync28(tsIndexPath)
   });
   let indexPath = null;
-  if (existsSync29(builtIndexPath)) {
+  if (existsSync28(builtIndexPath)) {
     indexPath = builtIndexPath;
-  } else if (existsSync29(jsIndexPath)) {
+  } else if (existsSync28(jsIndexPath)) {
     indexPath = jsIndexPath;
-  } else if (existsSync29(tsIndexPath)) {
+  } else if (existsSync28(tsIndexPath)) {
     indexPath = tsIndexPath;
   }
   if (!indexPath) {
-    debug(`No entry point found for '${capability.id}'`);
+    debug(`No entry point found for '${capability3.id}'`);
     return null;
   }
-  debug(`Using entry point for '${capability.id}'`, { indexPath });
+  debug(`Using entry point for '${capability3.id}'`, { indexPath });
   const module = await import(indexPath);
-  debug(`Module loaded for '${capability.id}'`, {
+  debug(`Module loaded for '${capability3.id}'`, {
     hasDefault: !!module.default,
     moduleKeys: Object.keys(module),
     defaultType: typeof module.default,
     defaultKeys: module.default ? Object.keys(module.default) : []
   });
   if (!module.default) {
-    debug(`No default export for '${capability.id}'`);
+    debug(`No default export for '${capability3.id}'`);
     return null;
   }
   const capExport = module.default;
@@ -7479,7 +7715,7 @@ async function loadCapabilityExport(capability) {
 }
 
 // src/index.ts
-init_dist2();
+init_src();
 
 // src/lib/version-check.ts
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/@omnidev-ai/cli/latest";