@omnidev-ai/core 0.8.0 → 0.10.0

package/dist/index.js

@@ -118,9 +118,9 @@ async function loadDocs(capabilityPath, capabilityId) {
   return docs;
 }
 // src/capability/loader.ts
-import { existsSync as existsSync7, readdirSync as readdirSync6 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync6 } from "node:fs";
 import { readFile as readFile7 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // src/config/env.ts
 import { existsSync as existsSync3 } from "node:fs";
@@ -207,20 +207,666 @@ function parseCapabilityConfig(tomlContent) {
   }
 }
 
+// src/hooks/loader.ts
+import { existsSync as existsSync5, readFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { parse as parseToml } from "smol-toml";
+
+// src/hooks/constants.ts
+var HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "PermissionRequest",
+  "UserPromptSubmit",
+  "Stop",
+  "SubagentStop",
+  "Notification",
+  "SessionStart",
+  "SessionEnd",
+  "PreCompact"
+];
+var MATCHER_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "PermissionRequest",
+  "Notification",
+  "SessionStart",
+  "PreCompact"
+];
+var PROMPT_HOOK_EVENTS = [
+  "Stop",
+  "SubagentStop",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PermissionRequest"
+];
+var HOOK_TYPES = ["command", "prompt"];
+var COMMON_TOOL_MATCHERS = [
+  "Bash",
+  "Read",
+  "Write",
+  "Edit",
+  "Glob",
+  "Grep",
+  "Task",
+  "WebFetch",
+  "WebSearch",
+  "NotebookEdit",
+  "LSP",
+  "TodoWrite",
+  "AskUserQuestion"
+];
+var NOTIFICATION_MATCHERS = [
+  "permission_prompt",
+  "idle_prompt",
+  "auth_success",
+  "elicitation_dialog"
+];
+var SESSION_START_MATCHERS = ["startup", "resume", "clear", "compact"];
+var PRE_COMPACT_MATCHERS = ["manual", "auto"];
+var DEFAULT_COMMAND_TIMEOUT = 60;
+var DEFAULT_PROMPT_TIMEOUT = 30;
+var VARIABLE_MAPPINGS = {
+  OMNIDEV_CAPABILITY_ROOT: "CLAUDE_PLUGIN_ROOT",
+  OMNIDEV_PROJECT_DIR: "CLAUDE_PROJECT_DIR"
+};
+var HOOKS_CONFIG_FILENAME = "hooks.toml";
+var HOOKS_DIRECTORY = "hooks";
+
+// src/hooks/validation.ts
+import { existsSync as existsSync4, statSync } from "node:fs";
+import { resolve } from "node:path";
+
+// src/hooks/types.ts
+function isHookCommand(hook) {
+  return hook.type === "command";
+}
+function isHookPrompt(hook) {
+  return hook.type === "prompt";
+}
+function isMatcherEvent(event) {
+  return MATCHER_EVENTS.includes(event);
+}
+function isPromptHookEvent(event) {
+  return PROMPT_HOOK_EVENTS.includes(event);
+}
+function isHookEvent(event) {
+  return HOOK_EVENTS.includes(event);
+}
+function isHookType(type) {
+  return HOOK_TYPES.includes(type);
+}
+
+// src/hooks/validation.ts
+function validateHooksConfig(config, options) {
+  const errors = [];
+  const warnings = [];
+  const opts = { checkScripts: false, ...options };
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    errors.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TOML",
+      message: "Hooks configuration must be an object"
+    });
+    return { valid: false, errors, warnings };
+  }
+  const configObj = config;
+  for (const key of Object.keys(configObj)) {
+    if (key === "description") {
+      continue;
+    }
+    if (!isHookEvent(key)) {
+      errors.push({
+        severity: "error",
+        code: "HOOKS_UNKNOWN_EVENT",
+        message: `Unknown hook event: "${key}"`,
+        suggestion: `Valid events are: ${HOOK_EVENTS.join(", ")}`
+      });
+      continue;
+    }
+    const event = key;
+    const matchers = configObj[key];
+    if (!Array.isArray(matchers)) {
+      errors.push({
+        severity: "error",
+        code: "HOOKS_INVALID_TOML",
+        event,
+        message: `${event} must be an array of matchers`
+      });
+      continue;
+    }
+    matchers.forEach((matcher, matcherIndex) => {
+      const matcherIssues = validateMatcher(matcher, event, matcherIndex, opts);
+      for (const issue of matcherIssues) {
+        if (issue.severity === "error") {
+          errors.push(issue);
+        } else {
+          warnings.push(issue);
+        }
+      }
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateMatcher(matcher, event, matcherIndex, options) {
+  const issues = [];
+  if (typeof matcher !== "object" || matcher === null || Array.isArray(matcher)) {
+    issues.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TOML",
+      event,
+      matcherIndex,
+      message: `Matcher at index ${matcherIndex} must be an object`
+    });
+    return issues;
+  }
+  const matcherObj = matcher;
+  const matcherPattern = matcherObj["matcher"];
+  if (matcherPattern !== undefined) {
+    if (typeof matcherPattern !== "string") {
+      issues.push({
+        severity: "error",
+        code: "HOOKS_INVALID_MATCHER",
+        event,
+        matcherIndex,
+        message: "Matcher pattern must be a string"
+      });
+    } else {
+      if (!isMatcherEvent(event) && matcherPattern !== "" && matcherPattern !== "*") {
+        issues.push({
+          severity: "warning",
+          code: "HOOKS_INVALID_MATCHER",
+          event,
+          matcherIndex,
+          message: `Matcher pattern on ${event} will be ignored (this event doesn't support matchers)`
+        });
+      }
+      const patternIssue = validateMatcherPattern(matcherPattern, event, matcherIndex);
+      if (patternIssue) {
+        issues.push(patternIssue);
+      }
+    }
+  }
+  if (!("hooks" in matcherObj)) {
+    issues.push({
+      severity: "error",
+      code: "HOOKS_INVALID_HOOKS_ARRAY",
+      event,
+      matcherIndex,
+      message: "Matcher must have a 'hooks' array"
+    });
+    return issues;
+  }
+  const hooksArray = matcherObj["hooks"];
+  if (!Array.isArray(hooksArray)) {
+    issues.push({
+      severity: "error",
+      code: "HOOKS_INVALID_HOOKS_ARRAY",
+      event,
+      matcherIndex,
+      message: "'hooks' must be an array"
+    });
+    return issues;
+  }
+  if (hooksArray.length === 0) {
+    issues.push({
+      severity: "warning",
+      code: "HOOKS_EMPTY_ARRAY",
+      event,
+      matcherIndex,
+      message: "Empty hooks array"
+    });
+  }
+  hooksArray.forEach((hook, hookIndex) => {
+    const hookIssues = validateHook(hook, event, { matcherIndex, hookIndex }, options);
+    issues.push(...hookIssues);
+  });
+  return issues;
+}
+function validateHook(hook, event, context, options) {
+  const issues = [];
+  const { matcherIndex, hookIndex } = context;
+  if (typeof hook !== "object" || hook === null || Array.isArray(hook)) {
+    issues.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TOML",
+      event,
+      matcherIndex,
+      hookIndex,
+      message: "Hook must be an object"
+    });
+    return issues;
+  }
+  const hookObj = hook;
+  if (!("type" in hookObj)) {
+    issues.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TYPE",
+      event,
+      matcherIndex,
+      hookIndex,
+      message: "Hook must have a 'type' field"
+    });
+    return issues;
+  }
+  const hookType = hookObj["type"];
+  if (typeof hookType !== "string" || !isHookType(hookType)) {
+    issues.push({
+      severity: "error",
+      code: "HOOKS_INVALID_TYPE",
+      event,
+      matcherIndex,
+      hookIndex,
+      message: `Invalid hook type: "${String(hookType)}". Must be "command" or "prompt"`
+    });
+    return issues;
+  }
+  if (hookType === "prompt" && !isPromptHookEvent(event)) {
+    issues.push({
+      severity: "error",
+      code: "HOOKS_PROMPT_NOT_ALLOWED",
+      event,
+      matcherIndex,
+      hookIndex,
+      message: `Prompt-type hooks are not allowed for ${event}`,
+      suggestion: `Prompt hooks are only allowed for: Stop, SubagentStop, UserPromptSubmit, PreToolUse, PermissionRequest`
+    });
+  }
+  if (hookType === "command") {
+    const command = hookObj["command"];
+    if (typeof command !== "string") {
+      issues.push({
+        severity: "error",
+        code: "HOOKS_MISSING_COMMAND",
+        event,
+        matcherIndex,
+        hookIndex,
+        message: "Command hook must have a 'command' string field"
+      });
+    } else {
+      const claudeVarMatch = command.match(/\$\{?CLAUDE_[A-Z_]+\}?/);
+      if (claudeVarMatch) {
+        const matchedVar = claudeVarMatch[0];
+        if (matchedVar) {
+          const omnidevVar = Object.entries(VARIABLE_MAPPINGS).find(([, claude]) => matchedVar.includes(claude))?.[0];
+          const issue = {
+            severity: "warning",
+            code: "HOOKS_CLAUDE_VARIABLE",
+            event,
+            matcherIndex,
+            hookIndex,
+            message: `Using Claude variable "${matchedVar}" instead of OmniDev variable`
+          };
+          if (omnidevVar) {
+            issue.suggestion = `Use \${${omnidevVar}} instead`;
+          }
+          issues.push(issue);
+        }
+      }
+      if (options?.checkScripts && options.basePath) {
+        const scriptIssues = validateScriptInCommand(command, options.basePath, event, matcherIndex, hookIndex);
+        issues.push(...scriptIssues);
+      }
+    }
+  }
+  if (hookType === "prompt") {
+    const prompt = hookObj["prompt"];
+    if (typeof prompt !== "string") {
+      issues.push({
+        severity: "error",
+        code: "HOOKS_MISSING_PROMPT",
+        event,
+        matcherIndex,
+        hookIndex,
+        message: "Prompt hook must have a 'prompt' string field"
+      });
+    }
+  }
+  if ("timeout" in hookObj) {
+    const timeout = hookObj["timeout"];
+    if (typeof timeout !== "number") {
+      issues.push({
+        severity: "error",
+        code: "HOOKS_INVALID_TIMEOUT",
+        event,
+        matcherIndex,
+        hookIndex,
+        message: "Timeout must be a number"
+      });
+    } else if (timeout <= 0) {
+      issues.push({
+        severity: "error",
+        code: "HOOKS_INVALID_TIMEOUT",
+        event,
+        matcherIndex,
+        hookIndex,
+        message: "Timeout must be a positive number"
+      });
+    }
+  }
+  return issues;
+}
+function validateMatcherPattern(pattern, event, matcherIndex) {
+  if (pattern === "" || pattern === "*") {
+    return null;
+  }
+  try {
+    new RegExp(pattern);
+    return null;
+  } catch {
+    return {
+      severity: "error",
+      code: "HOOKS_INVALID_MATCHER",
+      event,
+      matcherIndex,
+      message: `Invalid regex pattern: "${pattern}"`
+    };
+  }
+}
+function isValidMatcherPattern(pattern) {
+  if (pattern === "" || pattern === "*") {
+    return true;
+  }
+  try {
+    new RegExp(pattern);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateScriptInCommand(command, basePath, event, matcherIndex, hookIndex) {
+  const issues = [];
+  const scriptPatterns = [
+    /"\$\{?OMNIDEV_CAPABILITY_ROOT\}?\/([^"]+)"/g,
+    /(?:^|\s)\.\/([^\s;|&]+)/g
+  ];
+  for (const pattern of scriptPatterns) {
+    let match = pattern.exec(command);
+    while (match !== null) {
+      const relativePath = match[1];
+      if (relativePath) {
+        const fullPath = resolve(basePath, relativePath);
+        if (!existsSync4(fullPath)) {
+          issues.push({
+            severity: "error",
+            code: "HOOKS_SCRIPT_NOT_FOUND",
+            event,
+            matcherIndex,
+            hookIndex,
+            path: fullPath,
+            message: `Script file not found: ${relativePath}`
+          });
+        } else {
+          try {
+            const stats = statSync(fullPath);
+            const isExecutable = !!(stats.mode & 73);
+            if (!isExecutable) {
+              issues.push({
+                severity: "warning",
+                code: "HOOKS_SCRIPT_NOT_EXECUTABLE",
+                event,
+                matcherIndex,
+                hookIndex,
+                path: fullPath,
+                message: `Script file is not executable: ${relativePath}`,
+                suggestion: `Run: chmod +x ${relativePath}`
+              });
+            }
+          } catch {}
+        }
+      }
+      match = pattern.exec(command);
+    }
+  }
+  return issues;
+}
+function findDuplicateCommands(config) {
+  const issues = [];
+  const seenCommands = new Map;
+  for (const eventName of HOOK_EVENTS) {
+    const matchers = config[eventName];
+    if (!matchers)
+      continue;
+    matchers.forEach((matcher, matcherIndex) => {
+      matcher.hooks.forEach((hook, hookIndex) => {
+        if (hook.type === "command") {
+          const command = hook.command;
+          const existing = seenCommands.get(command);
+          if (existing) {
+            issues.push({
+              severity: "warning",
+              code: "HOOKS_DUPLICATE_COMMAND",
+              event: eventName,
+              matcherIndex,
+              hookIndex,
+              message: `Duplicate command found (also at ${existing.event}[${existing.matcherIndex}].hooks[${existing.hookIndex}])`
+            });
+          } else {
+            seenCommands.set(command, { event: eventName, matcherIndex, hookIndex });
+          }
+        }
+      });
+    });
+  }
+  return issues;
+}
+function createEmptyHooksConfig() {
+  return {};
+}
+function createEmptyValidationResult() {
+  return {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+}
+
+// src/hooks/variables.ts
+var REVERSE_MAPPINGS = Object.fromEntries(Object.entries(VARIABLE_MAPPINGS).map(([omni, claude]) => [claude, omni]));
+function transformToOmnidev(content) {
+  let result = content;
+  for (const [claude, omni] of Object.entries(REVERSE_MAPPINGS)) {
+    result = result.replace(new RegExp(`\\$\\{${claude}\\}`, "g"), `\${${omni}}`);
+    result = result.replace(new RegExp(`\\$${claude}(?![A-Za-z0-9_])`, "g"), `$${omni}`);
+  }
+  return result;
+}
+function transformToClaude(content) {
+  let result = content;
+  for (const [omni, claude] of Object.entries(VARIABLE_MAPPINGS)) {
+    result = result.replace(new RegExp(`\\$\\{${omni}\\}`, "g"), `\${${claude}}`);
+    result = result.replace(new RegExp(`\\$${omni}(?![A-Za-z0-9_])`, "g"), `$${claude}`);
+  }
+  return result;
+}
+function transformHook(hook, direction) {
+  const transform = direction === "toOmnidev" ? transformToOmnidev : transformToClaude;
+  if (hook.type === "command") {
+    return {
+      ...hook,
+      command: transform(hook.command)
+    };
+  }
+  if (hook.type === "prompt") {
+    return {
+      ...hook,
+      prompt: transform(hook.prompt)
+    };
+  }
+  return hook;
+}
+function transformMatcher(matcher, direction) {
+  return {
+    ...matcher,
+    hooks: matcher.hooks.map((hook) => transformHook(hook, direction))
+  };
+}
+function transformHooksConfig(config, direction) {
+  const result = {};
+  if (config.description !== undefined) {
+    result.description = config.description;
+  }
+  const events = [
+    "PreToolUse",
+    "PostToolUse",
+    "PermissionRequest",
+    "UserPromptSubmit",
+    "Stop",
+    "SubagentStop",
+    "Notification",
+    "SessionStart",
+    "SessionEnd",
+    "PreCompact"
+  ];
+  for (const event of events) {
+    const matchers = config[event];
+    if (matchers) {
+      result[event] = matchers.map((m) => transformMatcher(m, direction));
+    }
+  }
+  return result;
+}
+function containsClaudeVariables(content) {
+  for (const claude of Object.values(VARIABLE_MAPPINGS)) {
+    if (content.includes(`\${${claude}}`) || content.includes(`$${claude}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function containsOmnidevVariables(content) {
+  for (const omni of Object.keys(VARIABLE_MAPPINGS)) {
+    if (content.includes(`\${${omni}}`) || content.includes(`$${omni}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/hooks/loader.ts
+function loadHooksFromCapability(capabilityPath, options) {
+  const opts = {
+    transformVariables: true,
+    validate: true,
+    checkScripts: false,
+    ...options
+  };
+  const hooksDir = join3(capabilityPath, HOOKS_DIRECTORY);
+  const configPath = join3(hooksDir, HOOKS_CONFIG_FILENAME);
+  if (!existsSync5(configPath)) {
+    return {
+      config: createEmptyHooksConfig(),
+      validation: createEmptyValidationResult(),
+      found: false
+    };
+  }
+  let rawContent;
+  try {
+    rawContent = readFileSync(configPath, "utf-8");
+  } catch (error) {
+    return {
+      config: createEmptyHooksConfig(),
+      validation: {
+        valid: false,
+        errors: [
+          {
+            severity: "error",
+            code: "HOOKS_INVALID_TOML",
+            message: `Failed to read hooks config: ${error instanceof Error ? error.message : String(error)}`,
+            path: configPath
+          }
+        ],
+        warnings: []
+      },
+      found: true,
+      configPath,
+      loadError: `Failed to read: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  let content = rawContent;
+  if (opts.transformVariables && containsClaudeVariables(rawContent)) {
+    content = transformToOmnidev(rawContent);
+  }
+  let parsed;
+  try {
+    parsed = parseToml(content);
+  } catch (error) {
+    return {
+      config: createEmptyHooksConfig(),
+      validation: {
+        valid: false,
+        errors: [
+          {
+            severity: "error",
+            code: "HOOKS_INVALID_TOML",
+            message: `Invalid TOML syntax: ${error instanceof Error ? error.message : String(error)}`,
+            path: configPath
+          }
+        ],
+        warnings: []
+      },
+      found: true,
+      configPath,
+      loadError: `Invalid TOML: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  let validation;
+  if (opts.validate) {
+    validation = validateHooksConfig(parsed, {
+      basePath: hooksDir,
+      checkScripts: opts.checkScripts ?? false
+    });
+  } else {
+    validation = createEmptyValidationResult();
+  }
+  return {
+    config: validation.valid ? parsed : createEmptyHooksConfig(),
+    validation,
+    found: true,
+    configPath
+  };
+}
+function loadCapabilityHooks(capabilityName, capabilityPath, options) {
+  const result = loadHooksFromCapability(capabilityPath, options);
+  if (!result.found) {
+    return null;
+  }
+  return {
+    capabilityName,
+    capabilityPath,
+    config: result.config,
+    validation: result.validation
+  };
+}
+function hasHooks(capabilityPath) {
+  const configPath = join3(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
+  return existsSync5(configPath);
+}
+function getHooksDirectory(capabilityPath) {
+  return join3(capabilityPath, HOOKS_DIRECTORY);
+}
+function getHooksConfigPath(capabilityPath) {
+  return join3(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
+}
+
 // src/capability/rules.ts
-import { existsSync as existsSync4, readdirSync as readdirSync3 } from "node:fs";
-import { readFile as readFile4, writeFile } from "node:fs/promises";
-import { basename as basename2, join as join3 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { basename as basename2, join as join4 } from "node:path";
 async function loadRules(capabilityPath, capabilityId) {
-  const rulesDir = join3(capabilityPath, "rules");
-  if (!existsSync4(rulesDir)) {
+  const rulesDir = join4(capabilityPath, "rules");
+  if (!existsSync6(rulesDir)) {
     return [];
   }
   const rules = [];
   const entries = readdirSync3(rulesDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".md")) {
-      const rulePath = join3(rulesDir, entry.name);
+      const rulePath = join4(rulesDir, entry.name);
       const content = await readFile4(rulePath, "utf-8");
       rules.push({
         name: basename2(entry.name, ".md"),
@@ -231,96 +877,22 @@ async function loadRules(capabilityPath, capabilityId) {
   }
   return rules;
 }
-async function writeRules(rules, docs = []) {
-  const instructionsPath = ".omni/instructions.md";
-  const rulesContent = generateRulesContent(rules, docs);
-  let content;
-  if (existsSync4(instructionsPath)) {
-    content = await readFile4(instructionsPath, "utf-8");
-  } else {
-    content = `# OmniDev Instructions
-
-## Project Description
-<!-- TODO: Add 2-3 sentences describing your project -->
-[Describe what this project does and its main purpose]
-
-<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
-<!-- END OMNIDEV GENERATED CONTENT -->
-`;
-  }
-  const beginMarker = "<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->";
-  const endMarker = "<!-- END OMNIDEV GENERATED CONTENT -->";
-  const beginIndex = content.indexOf(beginMarker);
-  const endIndex = content.indexOf(endMarker);
-  if (beginIndex === -1 || endIndex === -1) {
-    content += `
-
-${beginMarker}
-${rulesContent}
-${endMarker}
-`;
-  } else {
-    content = content.substring(0, beginIndex + beginMarker.length) + `
-` + rulesContent + `
-` + content.substring(endIndex);
-  }
-  await writeFile(instructionsPath, content, "utf-8");
-}
-function generateRulesContent(rules, docs = []) {
-  if (rules.length === 0 && docs.length === 0) {
-    return `<!-- This section is automatically updated when capabilities change -->
-
-## Capabilities
-
-No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.`;
-  }
-  let content = `<!-- This section is automatically updated when capabilities change -->
-
-## Capabilities
-
-`;
-  if (docs.length > 0) {
-    content += `### Documentation
-
-`;
-    for (const doc of docs) {
-      content += `#### ${doc.name} (from ${doc.capabilityId})
-
-${doc.content}
-
-`;
-    }
-  }
-  if (rules.length > 0) {
-    content += `### Rules
-
-`;
-    for (const rule of rules) {
-      content += `#### ${rule.name} (from ${rule.capabilityId})
-
-${rule.content}
-
-`;
-    }
-  }
-  return content.trim();
-}
 
 // src/capability/skills.ts
-import { existsSync as existsSync5, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4 } from "node:fs";
 import { readFile as readFile5 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 async function loadSkills(capabilityPath, capabilityId) {
-  const skillsDir = join4(capabilityPath, "skills");
-  if (!existsSync5(skillsDir)) {
+  const skillsDir = join5(capabilityPath, "skills");
+  if (!existsSync7(skillsDir)) {
     return [];
   }
   const skills = [];
   const entries = readdirSync4(skillsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const skillPath = join4(skillsDir, entry.name, "SKILL.md");
-      if (existsSync5(skillPath)) {
+      const skillPath = join5(skillsDir, entry.name, "SKILL.md");
+      if (existsSync7(skillPath)) {
         const skill = await parseSkillFile(skillPath, capabilityId);
         skills.push(skill);
       }
@@ -348,20 +920,20 @@ async function parseSkillFile(filePath, capabilityId) {
 }
 
 // src/capability/subagents.ts
-import { existsSync as existsSync6, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync5 } from "node:fs";
 import { readFile as readFile6 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function loadSubagents(capabilityPath, capabilityId) {
-  const subagentsDir = join5(capabilityPath, "subagents");
-  if (!existsSync6(subagentsDir)) {
+  const subagentsDir = join6(capabilityPath, "subagents");
+  if (!existsSync8(subagentsDir)) {
     return [];
   }
   const subagents = [];
   const entries = readdirSync5(subagentsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const subagentPath = join5(subagentsDir, entry.name, "SUBAGENT.md");
-      if (existsSync6(subagentPath)) {
+      const subagentPath = join6(subagentsDir, entry.name, "SUBAGENT.md");
+      if (existsSync8(subagentPath)) {
         const subagent = await parseSubagentFile(subagentPath, capabilityId);
         subagents.push(subagent);
       }
@@ -414,13 +986,13 @@ function parseCommaSeparatedList(value) {
 var CAPABILITIES_DIR = ".omni/capabilities";
 async function discoverCapabilities() {
   const capabilities = [];
-  if (existsSync7(CAPABILITIES_DIR)) {
+  if (existsSync9(CAPABILITIES_DIR)) {
     const entries = readdirSync6(CAPABILITIES_DIR, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const entryPath = join6(CAPABILITIES_DIR, entry.name);
-        const configPath = join6(entryPath, "capability.toml");
-        if (existsSync7(configPath)) {
+        const entryPath = join7(CAPABILITIES_DIR, entry.name);
+        const configPath = join7(entryPath, "capability.toml");
+        if (existsSync9(configPath)) {
           capabilities.push(entryPath);
         }
       }
@@ -429,18 +1001,18 @@ async function discoverCapabilities() {
   return capabilities;
 }
 async function loadCapabilityConfig(capabilityPath) {
-  const configPath = join6(capabilityPath, "capability.toml");
+  const configPath = join7(capabilityPath, "capability.toml");
   const content = await readFile7(configPath, "utf-8");
   const config = parseCapabilityConfig(content);
   return config;
 }
 async function importCapabilityExports(capabilityPath) {
-  const indexPath = join6(capabilityPath, "index.ts");
-  if (!existsSync7(indexPath)) {
+  const indexPath = join7(capabilityPath, "index.ts");
+  if (!existsSync9(indexPath)) {
     return {};
   }
   try {
-    const absolutePath = join6(process.cwd(), indexPath);
+    const absolutePath = join7(process.cwd(), indexPath);
     const module = await import(absolutePath);
     return module;
   } catch (error) {
@@ -455,8 +1027,8 @@ If this is a project-specific capability, install dependencies or remove it from
   }
 }
 async function loadTypeDefinitions(capabilityPath) {
-  const typesPath = join6(capabilityPath, "types.d.ts");
-  if (!existsSync7(typesPath)) {
+  const typesPath = join7(capabilityPath, "types.d.ts");
+  if (!existsSync9(typesPath)) {
     return;
   }
   return readFile7(typesPath, "utf-8");
@@ -652,6 +1224,7 @@ async function loadCapability(capabilityPath, env) {
   const typeDefinitionsFromExports = "typeDefinitions" in exports && typeof exportsAny.typeDefinitions === "string" ? exportsAny.typeDefinitions : undefined;
   const typeDefinitions = typeDefinitionsFromExports !== undefined ? typeDefinitionsFromExports : await loadTypeDefinitions(capabilityPath);
   const gitignore = "gitignore" in exports && Array.isArray(exportsAny.gitignore) ? exportsAny.gitignore : undefined;
+  const hooks = loadCapabilityHooks(id, capabilityPath);
   const result = {
     id,
     path: capabilityPath,
@@ -669,11 +1242,14 @@ async function loadCapability(capabilityPath, env) {
   if (gitignore !== undefined) {
     result.gitignore = gitignore;
   }
+  if (hooks !== null) {
+    result.hooks = hooks;
+  }
   return result;
 }
-// src/config/loader.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { readFile as readFile8, writeFile as writeFile2 } from "node:fs/promises";
+// src/config/config.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { readFile as readFile8, writeFile } from "node:fs/promises";
 var CONFIG_PATH = "omni.toml";
 var LOCAL_CONFIG = "omni.local.toml";
 function mergeConfigs(base, override) {
@@ -692,7 +1268,7 @@ function mergeConfigs(base, override) {
   return merged;
 }
 async function loadBaseConfig() {
-  if (existsSync8(CONFIG_PATH)) {
+  if (existsSync10(CONFIG_PATH)) {
     const content = await readFile8(CONFIG_PATH, "utf-8");
     return parseOmniConfig(content);
   }
@@ -701,7 +1277,7 @@ async function loadBaseConfig() {
 async function loadConfig() {
   const baseConfig = await loadBaseConfig();
   let localConfig = {};
-  if (existsSync8(LOCAL_CONFIG)) {
+  if (existsSync10(LOCAL_CONFIG)) {
     const content = await readFile8(LOCAL_CONFIG, "utf-8");
     localConfig = parseOmniConfig(content);
   }
@@ -709,7 +1285,7 @@ async function loadConfig() {
 }
 async function writeConfig(config) {
   const content = generateConfigToml(config);
-  await writeFile2(CONFIG_PATH, content, "utf-8");
+  await writeFile(CONFIG_PATH, content, "utf-8");
 }
 function generateConfigToml(config) {
   const lines = [];
@@ -764,7 +1340,7 @@ function generateConfigToml(config) {
     for (const [name, sourceConfig] of Object.entries(sources)) {
       if (typeof sourceConfig === "string") {
         lines.push(`${name} = "${sourceConfig}"`);
-      } else if (sourceConfig.path) {
+      } else if ("path" in sourceConfig && sourceConfig.path) {
         lines.push(`${name} = { source = "${sourceConfig.source}", path = "${sourceConfig.path}" }`);
       } else {
         lines.push(`${name} = "${sourceConfig.source}"`);
@@ -784,6 +1360,28 @@ function generateConfigToml(config) {
   }
   lines.push("");
   lines.push("# =============================================================================");
+  lines.push("# Capability Groups");
+  lines.push("# =============================================================================");
+  lines.push("# Bundle multiple capabilities under a single name for cleaner profiles.");
+  lines.push('# Reference groups in profiles with the "group:" prefix.');
+  lines.push("#");
+  const groups = config.capabilities?.groups;
+  if (groups && Object.keys(groups).length > 0) {
+    lines.push("[capabilities.groups]");
+    for (const [name, caps] of Object.entries(groups)) {
+      const capsStr = caps.map((c) => `"${c}"`).join(", ");
+      lines.push(`${name} = [${capsStr}]`);
+    }
+  } else {
+    lines.push("# [capabilities.groups]");
+    lines.push('# expo = ["expo-app-design", "expo-deployment", "upgrading-expo"]');
+    lines.push('# backend = ["cloudflare", "database-tools"]');
+    lines.push("#");
+    lines.push("# [profiles.mobile]");
+    lines.push('# capabilities = ["group:expo", "react-native-tools"]');
+  }
+  lines.push("");
+  lines.push("# =============================================================================");
   lines.push("# MCP Servers");
   lines.push("# =============================================================================");
   lines.push("# Define MCP servers that automatically become capabilities.");
@@ -873,12 +1471,12 @@ function generateConfigToml(config) {
 }
 
 // src/state/active-profile.ts
-import { existsSync as existsSync9, mkdirSync } from "node:fs";
-import { readFile as readFile9, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync11, mkdirSync } from "node:fs";
+import { readFile as readFile9, unlink, writeFile as writeFile2 } from "node:fs/promises";
 var STATE_DIR = ".omni/state";
 var ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
 async function readActiveProfileState() {
-  if (!existsSync9(ACTIVE_PROFILE_PATH)) {
+  if (!existsSync11(ACTIVE_PROFILE_PATH)) {
     return null;
   }
   try {
@@ -891,10 +1489,10 @@ async function readActiveProfileState() {
 }
 async function writeActiveProfileState(profileName) {
   mkdirSync(STATE_DIR, { recursive: true });
-  await writeFile3(ACTIVE_PROFILE_PATH, profileName, "utf-8");
+  await writeFile2(ACTIVE_PROFILE_PATH, profileName, "utf-8");
 }
 async function clearActiveProfileState() {
-  if (existsSync9(ACTIVE_PROFILE_PATH)) {
+  if (existsSync11(ACTIVE_PROFILE_PATH)) {
     await unlink(ACTIVE_PROFILE_PATH);
   }
 }
@@ -915,7 +1513,24 @@ function resolveEnabledCapabilities(config, profileName) {
   const profile = profileName ? config.profiles?.[profileName] : config.profiles?.[config.active_profile ?? "default"];
   const profileCapabilities = profile?.capabilities ?? [];
   const alwaysEnabled = config.always_enabled_capabilities ?? [];
-  return [...new Set([...alwaysEnabled, ...profileCapabilities])];
+  const groups = config.capabilities?.groups ?? {};
+  const expandCapabilities = (caps) => {
+    return caps.flatMap((cap) => {
+      if (cap.startsWith("group:")) {
+        const groupName = cap.slice(6);
+        const groupCaps = groups[groupName];
+        if (!groupCaps) {
+          console.warn(`Unknown capability group: ${groupName}`);
+          return [];
+        }
+        return groupCaps;
+      }
+      return cap;
+    });
+  };
+  const expandedAlways = expandCapabilities(alwaysEnabled);
+  const expandedProfile = expandCapabilities(profileCapabilities);
+  return [...new Set([...expandedAlways, ...expandedProfile])];
 }
 async function loadProfileConfig(profileName) {
   const config = await loadConfig();
@@ -962,6 +1577,93 @@ async function disableCapability(capabilityId) {
   await writeConfig(config);
 }
 
+// src/hooks/merger.ts
+function mergeHooksConfigs(capabilityHooks) {
+  const result = {};
+  for (const event of HOOK_EVENTS) {
+    const allMatchers = [];
+    for (const capHooks of capabilityHooks) {
+      const matchers = capHooks.config[event];
+      if (matchers && matchers.length > 0) {
+        allMatchers.push(...matchers);
+      }
+    }
+    if (allMatchers.length > 0) {
+      result[event] = allMatchers;
+    }
+  }
+  return result;
+}
+function mergeAndDeduplicateHooks(capabilityHooks, options) {
+  const merged = mergeHooksConfigs(capabilityHooks);
+  if (!options?.deduplicateCommands) {
+    return merged;
+  }
+  const result = {};
+  for (const event of HOOK_EVENTS) {
+    const matchers = merged[event];
+    if (!matchers || matchers.length === 0) {
+      continue;
+    }
+    const seenCommands = new Set;
+    const deduplicatedMatchers = [];
+    for (const matcher of matchers) {
+      const deduplicatedHooks = matcher.hooks.filter((hook) => {
+        if (hook.type !== "command") {
+          return true;
+        }
+        const key = hook.command;
+        if (seenCommands.has(key)) {
+          return false;
+        }
+        seenCommands.add(key);
+        return true;
+      });
+      if (deduplicatedHooks.length > 0) {
+        deduplicatedMatchers.push({
+          ...matcher,
+          hooks: deduplicatedHooks
+        });
+      }
+    }
+    if (deduplicatedMatchers.length > 0) {
+      result[event] = deduplicatedMatchers;
+    }
+  }
+  return result;
+}
+function hasAnyHooks(config) {
+  for (const event of HOOK_EVENTS) {
+    const matchers = config[event];
+    if (matchers && matchers.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function countHooks(config) {
+  let count = 0;
+  for (const event of HOOK_EVENTS) {
+    const matchers = config[event];
+    if (matchers) {
+      for (const matcher of matchers) {
+        count += matcher.hooks.length;
+      }
+    }
+  }
+  return count;
+}
+function getEventsWithHooks(config) {
+  const events = [];
+  for (const event of HOOK_EVENTS) {
+    const matchers = config[event];
+    if (matchers && matchers.length > 0) {
+      events.push(event);
+    }
+  }
+  return events;
+}
+
 // src/capability/registry.ts
 async function buildCapabilityRegistry() {
   const env = await loadEnvironment();
@@ -980,21 +1682,49 @@ async function buildCapabilityRegistry() {
       console.warn(`  ${errorMessage}`);
     }
   }
+  const getAllCapabilityHooks = () => {
+    const hooks = [];
+    for (const cap of capabilities.values()) {
+      if (cap.hooks) {
+        hooks.push(cap.hooks);
+      }
+    }
+    return hooks;
+  };
   return {
     capabilities,
     getCapability: (id) => capabilities.get(id),
     getAllCapabilities: () => [...capabilities.values()],
     getAllSkills: () => [...capabilities.values()].flatMap((c) => c.skills),
     getAllRules: () => [...capabilities.values()].flatMap((c) => c.rules),
-    getAllDocs: () => [...capabilities.values()].flatMap((c) => c.docs)
+    getAllDocs: () => [...capabilities.values()].flatMap((c) => c.docs),
+    getAllCapabilityHooks,
+    getMergedHooks: () => mergeHooksConfigs(getAllCapabilityHooks())
   };
 }
 // src/capability/sources.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { spawn } from "node:child_process";
-import { cp, mkdir, readdir, readFile as readFile10, rm, stat, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join7 } from "node:path";
-import { parse as parseToml } from "smol-toml";
+import { cp, mkdir, readdir, readFile as readFile10, rename, rm, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import { parse as parseToml2 } from "smol-toml";
+
+// src/types/index.ts
+function isFileSourceConfig(config) {
+  if (typeof config === "string") {
+    return config.startsWith("file://");
+  }
+  return config.source.startsWith("file://");
+}
+function getActiveProviders(config) {
+  if (config.providers)
+    return config.providers;
+  if (config.provider)
+    return [config.provider];
+  return ["claude"];
+}
+
+// src/capability/sources.ts
 var OMNI_LOCAL = ".omni";
 var SKILL_DIRS = ["skills", "skill"];
 var AGENT_DIRS = ["agents", "agent", "subagents", "subagent"];
@@ -1005,7 +1735,7 @@ var SKILL_FILES = ["SKILL.md", "skill.md", "Skill.md"];
 var AGENT_FILES = ["AGENT.md", "agent.md", "Agent.md", "SUBAGENT.md", "subagent.md"];
 var COMMAND_FILES = ["COMMAND.md", "command.md", "Command.md"];
 async function spawnCapture(command, args, options) {
-  return await new Promise((resolve, reject) => {
+  return await new Promise((resolve2, reject) => {
     const child = spawn(command, args, {
       cwd: options?.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1022,12 +1752,43 @@ async function spawnCapture(command, args, options) {
     });
     child.on("error", (error) => reject(error));
     child.on("close", (exitCode) => {
-      resolve({ exitCode: exitCode ?? 0, stdout, stderr });
+      resolve2({ exitCode: exitCode ?? 0, stdout, stderr });
     });
   });
 }
+function isGitSource(source) {
+  return source.startsWith("github:") || source.startsWith("git@") || source.startsWith("https://") || source.startsWith("http://");
+}
+function isFileSource(source) {
+  return source.startsWith("file://");
+}
+function parseFileSourcePath(source) {
+  if (!source.startsWith("file://")) {
+    throw new Error(`Invalid file source: ${source}`);
+  }
+  return source.slice(7);
+}
+async function readCapabilityIdFromPath(capabilityPath) {
+  const tomlPath = join8(capabilityPath, "capability.toml");
+  if (existsSync12(tomlPath)) {
+    try {
+      const content = await readFile10(tomlPath, "utf-8");
+      const parsed = parseToml2(content);
+      const capability = parsed["capability"];
+      if (capability?.["id"] && typeof capability["id"] === "string") {
+        return capability["id"];
+      }
+    } catch {}
+  }
+  const parts = capabilityPath.replace(/\\/g, "/").split("/");
+  const dirName = parts.pop() || parts.pop();
+  return dirName || null;
+}
 function parseSourceConfig(source) {
   if (typeof source === "string") {
+    if (isFileSource(source)) {
+      return { source };
+    }
     let sourceUrl = source;
     let ref;
     if (source.startsWith("github:") && source.includes("#")) {
@@ -1041,6 +1802,9 @@ function parseSourceConfig(source) {
     }
     return result;
   }
+  if (isFileSourceConfig(source)) {
+    return source;
+  }
   return source;
 }
 function sourceToGitUrl(source) {
@@ -1051,19 +1815,19 @@ function sourceToGitUrl(source) {
   return source;
 }
 function getSourceCapabilityPath(id) {
-  return join7(OMNI_LOCAL, "capabilities", id);
+  return join8(OMNI_LOCAL, "capabilities", id);
 }
 function getLockFilePath() {
   return "omni.lock.toml";
 }
 async function loadLockFile() {
   const lockPath = getLockFilePath();
-  if (!existsSync10(lockPath)) {
+  if (!existsSync12(lockPath)) {
     return { capabilities: {} };
   }
   try {
     const content = await readFile10(lockPath, "utf-8");
-    const parsed = parseToml(content);
+    const parsed = parseToml2(content);
     const capabilities = parsed["capabilities"];
     return {
       capabilities: capabilities || {}
@@ -1092,14 +1856,14 @@ function stringifyLockFile(lockFile) {
 }
 async function saveLockFile(lockFile) {
   const lockPath = getLockFilePath();
-  await mkdir(join7(OMNI_LOCAL, "capabilities"), { recursive: true });
+  await mkdir(join8(OMNI_LOCAL, "capabilities"), { recursive: true });
   const header = `# Auto-generated by OmniDev - DO NOT EDIT
 # Records installed capability versions for reproducibility
 # Last updated: ${new Date().toISOString()}
 
 `;
   const content = header + stringifyLockFile(lockFile);
-  await writeFile4(lockPath, content, "utf-8");
+  await writeFile3(lockPath, content, "utf-8");
 }
 async function getRepoCommit(repoPath) {
   const { exitCode, stdout, stderr } = await spawnCapture("git", ["rev-parse", "HEAD"], {
@@ -1114,7 +1878,7 @@ function shortCommit(commit) {
   return commit.substring(0, 7);
 }
 async function cloneRepo(gitUrl, targetPath, ref) {
-  await mkdir(join7(targetPath, ".."), { recursive: true });
+  await mkdir(join8(targetPath, ".."), { recursive: true });
   const args = ["clone", "--depth", "1"];
   if (ref) {
     args.push("--branch", ref);
@@ -1151,16 +1915,16 @@ async function fetchRepo(repoPath, ref) {
   return true;
 }
 function hasCapabilityToml(dirPath) {
-  return existsSync10(join7(dirPath, "capability.toml"));
+  return existsSync12(join8(dirPath, "capability.toml"));
 }
 async function shouldWrapDirectory(dirPath) {
-  if (existsSync10(join7(dirPath, ".claude-plugin", "plugin.json"))) {
+  if (existsSync12(join8(dirPath, ".claude-plugin", "plugin.json"))) {
     return true;
   }
   const allDirs = [...SKILL_DIRS, ...AGENT_DIRS, ...COMMAND_DIRS, ...RULE_DIRS, ...DOC_DIRS];
   for (const dirName of allDirs) {
-    const checkPath = join7(dirPath, dirName);
-    if (existsSync10(checkPath)) {
+    const checkPath = join8(dirPath, dirName);
+    if (existsSync12(checkPath)) {
       const stats = await stat(checkPath);
       if (stats.isDirectory()) {
         return true;
@@ -1171,8 +1935,8 @@ async function shouldWrapDirectory(dirPath) {
 }
 async function findMatchingDirs(basePath, names) {
   for (const name of names) {
-    const dirPath = join7(basePath, name);
-    if (existsSync10(dirPath)) {
+    const dirPath = join8(basePath, name);
+    if (existsSync12(dirPath)) {
       const stats = await stat(dirPath);
       if (stats.isDirectory()) {
         return dirPath;
@@ -1183,15 +1947,15 @@ async function findMatchingDirs(basePath, names) {
 }
 async function findContentItems(dirPath, filePatterns) {
   const items = [];
-  if (!existsSync10(dirPath)) {
+  if (!existsSync12(dirPath)) {
     return items;
   }
   const entries = (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const entryPath = join7(dirPath, entry.name);
+    const entryPath = join8(dirPath, entry.name);
     if (entry.isDirectory()) {
       for (const pattern of filePatterns) {
-        if (existsSync10(join7(entryPath, pattern))) {
+        if (existsSync12(join8(entryPath, pattern))) {
           items.push({
             name: entry.name,
             path: entryPath,
@@ -1212,8 +1976,8 @@ async function findContentItems(dirPath, filePatterns) {
   return items;
 }
 async function parsePluginJson(dirPath) {
-  const pluginJsonPath = join7(dirPath, ".claude-plugin", "plugin.json");
-  if (!existsSync10(pluginJsonPath)) {
+  const pluginJsonPath = join8(dirPath, ".claude-plugin", "plugin.json");
+  if (!existsSync12(pluginJsonPath)) {
     return null;
   }
   try {
@@ -1237,8 +2001,8 @@ async function parsePluginJson(dirPath) {
   }
 }
 async function readReadmeDescription(dirPath) {
-  const readmePath = join7(dirPath, "README.md");
-  if (!existsSync10(readmePath)) {
+  const readmePath = join8(dirPath, "README.md");
+  if (!existsSync12(readmePath)) {
     return null;
   }
   try {
@@ -1270,6 +2034,29 @@ async function readReadmeDescription(dirPath) {
     return null;
   }
 }
+async function normalizeFolderNames(repoPath) {
+  const renameMappings = [
+    { from: "skill", to: "skills" },
+    { from: "command", to: "commands" },
+    { from: "rule", to: "rules" },
+    { from: "agent", to: "agents" },
+    { from: "subagent", to: "subagents" }
+  ];
+  for (const { from, to } of renameMappings) {
+    const fromPath = join8(repoPath, from);
+    const toPath = join8(repoPath, to);
+    if (existsSync12(fromPath) && !existsSync12(toPath)) {
+      try {
+        const stats = await stat(fromPath);
+        if (stats.isDirectory()) {
+          await rename(fromPath, toPath);
+        }
+      } catch (error) {
+        console.warn(`Failed to rename ${from} to ${to}:`, error);
+      }
+    }
+  }
+}
 async function discoverContent(repoPath) {
   const result = {
     skills: [],
@@ -1347,7 +2134,7 @@ repository = "${repoUrl}"
 wrapped = true
 commit = "${commit}"
 `;
-  await writeFile4(join7(repoPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile3(join8(repoPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function fetchGitCapabilitySource(id, config, options) {
   const gitUrl = sourceToGitUrl(config.source);
@@ -1356,8 +2143,8 @@ async function fetchGitCapabilitySource(id, config, options) {
   let commit;
   let repoPath;
   if (config.path) {
-    const tempPath = join7(OMNI_LOCAL, "_temp", `${id}-repo`);
-    if (existsSync10(join7(tempPath, ".git"))) {
+    const tempPath = join8(OMNI_LOCAL, "_temp", `${id}-repo`);
+    if (existsSync12(join8(tempPath, ".git"))) {
       if (!options?.silent) {
         console.log(`  Checking ${id}...`);
       }
@@ -1367,23 +2154,23 @@ async function fetchGitCapabilitySource(id, config, options) {
       if (!options?.silent) {
         console.log(`  Cloning ${id} from ${config.source}...`);
       }
-      await mkdir(join7(tempPath, ".."), { recursive: true });
+      await mkdir(join8(tempPath, ".."), { recursive: true });
       await cloneRepo(gitUrl, tempPath, config.ref);
       commit = await getRepoCommit(tempPath);
       updated = true;
     }
-    const sourcePath = join7(tempPath, config.path);
-    if (!existsSync10(sourcePath)) {
+    const sourcePath = join8(tempPath, config.path);
+    if (!existsSync12(sourcePath)) {
       throw new Error(`Path not found in repository: ${config.path}`);
     }
-    if (existsSync10(targetPath)) {
+    if (existsSync12(targetPath)) {
       await rm(targetPath, { recursive: true });
     }
-    await mkdir(join7(targetPath, ".."), { recursive: true });
+    await mkdir(join8(targetPath, ".."), { recursive: true });
     await cp(sourcePath, targetPath, { recursive: true });
     repoPath = targetPath;
   } else {
-    if (existsSync10(join7(targetPath, ".git"))) {
+    if (existsSync12(join8(targetPath, ".git"))) {
       if (!options?.silent) {
         console.log(`  Checking ${id}...`);
       }
@@ -1404,6 +2191,7 @@ async function fetchGitCapabilitySource(id, config, options) {
     needsWrap = await shouldWrapDirectory(repoPath);
   }
   if (needsWrap) {
+    await normalizeFolderNames(repoPath);
     const content = await discoverContent(repoPath);
     await generateCapabilityToml(id, repoPath, config.source, commit, content);
     if (!options?.silent) {
@@ -1420,8 +2208,8 @@ async function fetchGitCapabilitySource(id, config, options) {
     }
   }
   let version = shortCommit(commit);
-  const pkgJsonPath = join7(repoPath, "package.json");
-  if (existsSync10(pkgJsonPath)) {
+  const pkgJsonPath = join8(repoPath, "package.json");
+  if (existsSync12(pkgJsonPath)) {
     try {
       const pkgJson = JSON.parse(await readFile10(pkgJsonPath, "utf-8"));
       if (pkgJson.version) {
@@ -1438,8 +2226,52 @@ async function fetchGitCapabilitySource(id, config, options) {
     wrapped: needsWrap
   };
 }
+async function fetchFileCapabilitySource(id, config, options) {
+  const sourcePath = parseFileSourcePath(config.source);
+  const targetPath = getSourceCapabilityPath(id);
+  if (!existsSync12(sourcePath)) {
+    throw new Error(`File source not found: ${sourcePath}`);
+  }
+  const sourceStats = await stat(sourcePath);
+  if (!sourceStats.isDirectory()) {
+    throw new Error(`File source must be a directory: ${sourcePath}`);
+  }
+  if (!existsSync12(join8(sourcePath, "capability.toml"))) {
+    throw new Error(`No capability.toml found in: ${sourcePath}`);
+  }
+  if (!options?.silent) {
+    console.log(`  Copying ${id} from ${sourcePath}...`);
+  }
+  if (existsSync12(targetPath)) {
+    await rm(targetPath, { recursive: true });
+  }
+  await mkdir(join8(targetPath, ".."), { recursive: true });
+  await cp(sourcePath, targetPath, { recursive: true });
+  let version = "local";
+  const capTomlPath = join8(targetPath, "capability.toml");
+  if (existsSync12(capTomlPath)) {
+    try {
+      const content = await readFile10(capTomlPath, "utf-8");
+      const parsed = parseToml2(content);
+      const capability = parsed["capability"];
+      if (capability?.["version"] && typeof capability["version"] === "string") {
+        version = capability["version"];
+      }
+    } catch {}
+  }
+  return {
+    id,
+    path: targetPath,
+    version,
+    updated: true,
+    wrapped: false
+  };
+}
 async function fetchCapabilitySource(id, sourceConfig, options) {
   const config = parseSourceConfig(sourceConfig);
+  if (isFileSourceConfig(sourceConfig) || isFileSource(config.source)) {
+    return fetchFileCapabilitySource(id, config, options);
+  }
   return fetchGitCapabilitySource(id, config, options);
 }
 function generateMcpCapabilityTomlContent(id, mcpConfig) {
@@ -1506,17 +2338,17 @@ generated_from_omni_toml = true
 }
 async function generateMcpCapabilityToml(id, mcpConfig, targetPath) {
   const tomlContent = generateMcpCapabilityTomlContent(id, mcpConfig);
-  await writeFile4(join7(targetPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile3(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function isGeneratedMcpCapability(capabilityDir) {
-  const tomlPath = join7(capabilityDir, "capability.toml");
-  if (!existsSync10(tomlPath)) {
+  const tomlPath = join8(capabilityDir, "capability.toml");
+  if (!existsSync12(tomlPath)) {
     console.warn("no capability.toml found in", capabilityDir);
     return false;
   }
   try {
     const content = await readFile10(tomlPath, "utf-8");
-    const parsed = parseToml(content);
+    const parsed = parseToml2(content);
     const capability = parsed["capability"];
     const metadata = capability?.["metadata"];
     return metadata?.["generated_from_omni_toml"] === true;
@@ -1525,14 +2357,14 @@ async function isGeneratedMcpCapability(capabilityDir) {
   }
 }
 async function cleanupStaleMcpCapabilities(currentMcpIds) {
-  const capabilitiesDir = join7(OMNI_LOCAL, "capabilities");
-  if (!existsSync10(capabilitiesDir)) {
+  const capabilitiesDir = join8(OMNI_LOCAL, "capabilities");
+  if (!existsSync12(capabilitiesDir)) {
     return;
   }
   const entries = await readdir(capabilitiesDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const capDir = join7(capabilitiesDir, entry.name);
+      const capDir = join8(capabilitiesDir, entry.name);
       const isGenerated = await isGeneratedMcpCapability(capDir);
       if (isGenerated && !currentMcpIds.has(entry.name)) {
         await rm(capDir, { recursive: true });
@@ -1545,10 +2377,10 @@ async function generateMcpCapabilities(config) {
     await cleanupStaleMcpCapabilities(new Set);
     return;
   }
-  const mcpCapabilitiesDir = join7(OMNI_LOCAL, "capabilities");
+  const mcpCapabilitiesDir = join8(OMNI_LOCAL, "capabilities");
   const currentMcpIds = new Set;
   for (const [id, mcpConfig] of Object.entries(config.mcps)) {
-    const targetPath = join7(mcpCapabilitiesDir, id);
+    const targetPath = join8(mcpCapabilitiesDir, id);
     currentMcpIds.add(id);
     await mkdir(targetPath, { recursive: true });
     await generateMcpCapabilityToml(id, mcpConfig, targetPath);
@@ -1576,12 +2408,14 @@ async function fetchAllCapabilitySources(config, options) {
         version: result.version,
         updated_at: new Date().toISOString()
       };
-      const gitConfig = parseSourceConfig(source);
       if (result.commit) {
         lockEntry.commit = result.commit;
       }
-      if (gitConfig.ref) {
-        lockEntry.ref = gitConfig.ref;
+      if (!isFileSourceConfig(source)) {
+        const gitConfig = parseSourceConfig(source);
+        if (gitConfig.ref) {
+          lockEntry.ref = gitConfig.ref;
+        }
       }
       const existing = lockFile.capabilities[id];
       const hasChanged = !existing || existing.commit !== result.commit;
@@ -1621,8 +2455,18 @@ async function checkForUpdates(config) {
     const sourceConfig = parseSourceConfig(source);
     const targetPath = getSourceCapabilityPath(id);
     const existing = lockFile.capabilities[id];
+    if (isFileSourceConfig(source) || isFileSource(sourceConfig.source)) {
+      updates.push({
+        id,
+        source: sourceConfig.source,
+        currentVersion: existing?.version || "local",
+        latestVersion: "local",
+        hasUpdate: false
+      });
+      continue;
+    }
     const gitConfig = sourceConfig;
-    if (!existsSync10(join7(targetPath, ".git"))) {
+    if (!existsSync12(join8(targetPath, ".git"))) {
       updates.push({
         id,
         source: gitConfig.source,
@@ -1658,12 +2502,12 @@ async function checkForUpdates(config) {
   return updates;
 }
 // src/config/provider.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { readFile as readFile11, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync13 } from "node:fs";
+import { readFile as readFile11, writeFile as writeFile4 } from "node:fs/promises";
 import { parse as parse2 } from "smol-toml";
 var PROVIDER_CONFIG_PATH = ".omni/provider.toml";
 async function loadProviderConfig() {
-  if (!existsSync11(PROVIDER_CONFIG_PATH)) {
+  if (!existsSync13(PROVIDER_CONFIG_PATH)) {
     return { provider: "claude" };
   }
   const content = await readFile11(PROVIDER_CONFIG_PATH, "utf-8");
@@ -1693,7 +2537,7 @@ async function writeProviderConfig(config) {
     lines.push("# Default: Claude");
     lines.push('provider = "claude"');
   }
-  await writeFile5(PROVIDER_CONFIG_PATH, `${lines.join(`
+  await writeFile4(PROVIDER_CONFIG_PATH, `${lines.join(`
 `)}
 `, "utf-8");
 }
@@ -1707,16 +2551,222 @@ function parseProviderFlag(flag) {
   }
   throw new Error(`Invalid provider: ${flag}. Must be 'claude', 'codex', or 'both'.`);
 }
+// src/config/toml-patcher.ts
+import { existsSync as existsSync14 } from "node:fs";
+import { readFile as readFile12, writeFile as writeFile5 } from "node:fs/promises";
+var CONFIG_PATH2 = "omni.toml";
+async function readConfigFile() {
+  if (!existsSync14(CONFIG_PATH2)) {
+    return "";
+  }
+  return readFile12(CONFIG_PATH2, "utf-8");
+}
+async function writeConfigFile(content) {
+  await writeFile5(CONFIG_PATH2, content, "utf-8");
+}
+function findSection(lines, sectionPattern) {
+  return lines.findIndex((line) => sectionPattern.test(line.trim()));
+}
+function findSectionEnd(lines, startIndex) {
+  for (let i = startIndex + 1;i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined)
+      continue;
+    const trimmed = line.trim();
+    if (/^\[(?!\[)/.test(trimmed) && !trimmed.startsWith("#")) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+function formatCapabilitySource(name, source) {
+  if (typeof source === "string") {
+    return `${name} = "${source}"`;
+  }
+  if ("path" in source && source.path) {
+    return `${name} = { source = "${source.source}", path = "${source.path}" }`;
+  }
+  return `${name} = "${source.source}"`;
+}
+async function patchAddCapabilitySource(name, source) {
+  let content = await readConfigFile();
+  const lines = content.split(`
+`);
+  const sectionIndex = findSection(lines, /^\[capabilities\.sources\]$/);
+  const newEntry = formatCapabilitySource(name, source);
+  if (sectionIndex !== -1) {
+    const sectionEnd = findSectionEnd(lines, sectionIndex);
+    let insertIndex = sectionEnd;
+    for (let i = sectionEnd - 1;i > sectionIndex; i--) {
+      const line = lines[i];
+      if (line === undefined)
+        continue;
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        insertIndex = i + 1;
+        break;
+      }
+    }
+    if (insertIndex === sectionEnd && sectionIndex + 1 < lines.length) {
+      insertIndex = sectionIndex + 1;
+    }
+    lines.splice(insertIndex, 0, newEntry);
+  } else {
+    const capabilitiesIndex = findSection(lines, /^\[capabilities\]$/);
+    if (capabilitiesIndex !== -1) {
+      const capEnd = findSectionEnd(lines, capabilitiesIndex);
+      lines.splice(capEnd, 0, "", "[capabilities.sources]", newEntry);
+    } else {
+      const mcpsIndex = findSection(lines, /^\[mcps/);
+      if (mcpsIndex !== -1) {
+        lines.splice(mcpsIndex, 0, "[capabilities.sources]", newEntry, "");
+      } else {
+        lines.push("", "[capabilities.sources]", newEntry);
+      }
+    }
+  }
+  content = lines.join(`
+`);
+  await writeConfigFile(content);
+}
+function formatMcpConfig(name, config) {
+  const lines = [];
+  lines.push(`[mcps.${name}]`);
+  if (config.transport && config.transport !== "stdio") {
+    lines.push(`transport = "${config.transport}"`);
+  }
+  if (config.command) {
+    lines.push(`command = "${config.command}"`);
+  }
+  if (config.args && config.args.length > 0) {
+    const argsStr = config.args.map((a) => `"${a}"`).join(", ");
+    lines.push(`args = [${argsStr}]`);
+  }
+  if (config.cwd) {
+    lines.push(`cwd = "${config.cwd}"`);
+  }
+  if (config.url) {
+    lines.push(`url = "${config.url}"`);
+  }
+  if (config.env && Object.keys(config.env).length > 0) {
+    lines.push(`[mcps.${name}.env]`);
+    for (const [key, value] of Object.entries(config.env)) {
+      lines.push(`${key} = "${value}"`);
+    }
+  }
+  if (config.headers && Object.keys(config.headers).length > 0) {
+    lines.push(`[mcps.${name}.headers]`);
+    for (const [key, value] of Object.entries(config.headers)) {
+      lines.push(`${key} = "${value}"`);
+    }
+  }
+  return lines;
+}
+async function patchAddMcp(name, config) {
+  let content = await readConfigFile();
+  const lines = content.split(`
+`);
+  const mcpLines = formatMcpConfig(name, config);
+  const existingMcpIndex = findSection(lines, /^\[mcps\./);
+  if (existingMcpIndex !== -1) {
+    let lastMcpEnd = existingMcpIndex;
+    for (let i = existingMcpIndex;i < lines.length; i++) {
+      const line = lines[i];
+      if (line === undefined)
+        continue;
+      const trimmed = line.trim();
+      if (/^\[mcps\./.test(trimmed)) {
+        lastMcpEnd = findSectionEnd(lines, i);
+      } else if (/^\[(?!mcps\.)/.test(trimmed) && !trimmed.startsWith("#")) {
+        break;
+      }
+    }
+    lines.splice(lastMcpEnd, 0, "", ...mcpLines);
+  } else {
+    const profilesIndex = findSection(lines, /^\[profiles\./);
+    if (profilesIndex !== -1) {
+      lines.splice(profilesIndex, 0, ...mcpLines, "");
+    } else {
+      lines.push("", ...mcpLines);
+    }
+  }
+  content = lines.join(`
+`);
+  await writeConfigFile(content);
+}
+async function patchAddToProfile(profileName, capabilityName) {
+  let content = await readConfigFile();
+  const lines = content.split(`
+`);
+  const profilePattern = new RegExp(`^\\[profiles\\.${escapeRegExp(profileName)}\\]$`);
+  const profileIndex = findSection(lines, profilePattern);
+  if (profileIndex !== -1) {
+    const profileEnd = findSectionEnd(lines, profileIndex);
+    let capabilitiesLineIndex = -1;
+    for (let i = profileIndex + 1;i < profileEnd; i++) {
+      const line = lines[i];
+      if (line === undefined)
+        continue;
+      const trimmed = line.trim();
+      if (trimmed.startsWith("capabilities")) {
+        capabilitiesLineIndex = i;
+        break;
+      }
+    }
+    if (capabilitiesLineIndex !== -1) {
+      const line = lines[capabilitiesLineIndex];
+      if (line !== undefined) {
+        const match = line.match(/capabilities\s*=\s*\[(.*)\]/);
+        if (match && match[1] !== undefined) {
+          const existingCaps = match[1].split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+          const quotedCap = `"${capabilityName}"`;
+          if (!existingCaps.includes(quotedCap)) {
+            existingCaps.push(quotedCap);
+            const indent = line.match(/^(\s*)/)?.[1] ?? "";
+            lines[capabilitiesLineIndex] = `${indent}capabilities = [${existingCaps.join(", ")}]`;
+          }
+        }
+      }
+    } else {
+      lines.splice(profileIndex + 1, 0, `capabilities = ["${capabilityName}"]`);
+    }
+  } else {
+    const anyProfileIndex = findSection(lines, /^\[profiles\./);
+    if (anyProfileIndex !== -1) {
+      let lastProfileEnd = anyProfileIndex;
+      for (let i = anyProfileIndex;i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined)
+          continue;
+        const trimmed = line.trim();
+        if (/^\[profiles\./.test(trimmed)) {
+          lastProfileEnd = findSectionEnd(lines, i);
+        } else if (/^\[(?!profiles\.)/.test(trimmed) && !trimmed.startsWith("#")) {
+          break;
+        }
+      }
+      lines.splice(lastProfileEnd, 0, "", `[profiles.${profileName}]`, `capabilities = ["${capabilityName}"]`);
+    } else {
+      lines.push("", `[profiles.${profileName}]`, `capabilities = ["${capabilityName}"]`);
+    }
+  }
+  content = lines.join(`
+`);
+  await writeConfigFile(content);
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 // src/mcp-json/manager.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { readFile as readFile12, writeFile as writeFile6 } from "node:fs/promises";
+import { existsSync as existsSync15 } from "node:fs";
+import { readFile as readFile13, writeFile as writeFile6 } from "node:fs/promises";
 var MCP_JSON_PATH = ".mcp.json";
 async function readMcpJson() {
-  if (!existsSync12(MCP_JSON_PATH)) {
+  if (!existsSync15(MCP_JSON_PATH)) {
     return { mcpServers: {} };
   }
   try {
-    const content = await readFile12(MCP_JSON_PATH, "utf-8");
+    const content = await readFile13(MCP_JSON_PATH, "utf-8");
     const parsed = JSON.parse(content);
     return {
       mcpServers: parsed.mcpServers || {}
@@ -1725,8 +2775,8 @@ async function readMcpJson() {
     return { mcpServers: {} };
   }
 }
-async function writeMcpJson(config) {
-  await writeFile6(MCP_JSON_PATH, `${JSON.stringify(config, null, 2)}
+async function writeMcpJson(config2) {
+  await writeFile6(MCP_JSON_PATH, `${JSON.stringify(config2, null, 2)}
 `, "utf-8");
 }
 function buildMcpServerConfig(mcp) {
@@ -1735,41 +2785,41 @@ function buildMcpServerConfig(mcp) {
     if (!mcp.url) {
       throw new Error("HTTP transport requires a URL");
     }
-    const config2 = {
+    const config3 = {
       type: "http",
       url: mcp.url
     };
     if (mcp.headers && Object.keys(mcp.headers).length > 0) {
-      config2.headers = mcp.headers;
+      config3.headers = mcp.headers;
     }
-    return config2;
+    return config3;
   }
   if (transport === "sse") {
     if (!mcp.url) {
       throw new Error("SSE transport requires a URL");
     }
-    const config2 = {
+    const config3 = {
       type: "sse",
       url: mcp.url
     };
     if (mcp.headers && Object.keys(mcp.headers).length > 0) {
-      config2.headers = mcp.headers;
+      config3.headers = mcp.headers;
     }
-    return config2;
+    return config3;
   }
   if (!mcp.command) {
     throw new Error("stdio transport requires a command");
   }
-  const config = {
+  const config2 = {
     command: mcp.command
   };
   if (mcp.args) {
-    config.args = mcp.args;
+    config2.args = mcp.args;
   }
   if (mcp.env) {
-    config.env = mcp.env;
+    config2.env = mcp.env;
   }
-  return config;
+  return config2;
 }
 async function syncMcpJson(capabilities2, previousManifest, options = {}) {
   const mcpJson = await readMcpJson();
@@ -1795,19 +2845,19 @@ async function syncMcpJson(capabilities2, previousManifest, options = {}) {
   }
 }
 // src/state/manifest.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync2, rmSync } from "node:fs";
-import { readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
+import { existsSync as existsSync16, mkdirSync as mkdirSync2, rmSync } from "node:fs";
+import { readFile as readFile14, writeFile as writeFile7 } from "node:fs/promises";
 var MANIFEST_PATH = ".omni/state/manifest.json";
 var CURRENT_VERSION = 1;
 async function loadManifest() {
-  if (!existsSync13(MANIFEST_PATH)) {
+  if (!existsSync16(MANIFEST_PATH)) {
     return {
       version: CURRENT_VERSION,
       syncedAt: new Date().toISOString(),
       capabilities: {}
     };
   }
-  const content = await readFile13(MANIFEST_PATH, "utf-8");
+  const content = await readFile14(MANIFEST_PATH, "utf-8");
   return JSON.parse(content);
 }
 async function saveManifest(manifest) {
@@ -1847,14 +2897,14 @@ async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
     }
     for (const skillName of resources.skills) {
       const skillDir = `.claude/skills/${skillName}`;
-      if (existsSync13(skillDir)) {
+      if (existsSync16(skillDir)) {
         rmSync(skillDir, { recursive: true });
         result.deletedSkills.push(skillName);
       }
     }
     for (const ruleName of resources.rules) {
       const rulePath = `.cursor/rules/omnidev-${ruleName}.mdc`;
-      if (existsSync13(rulePath)) {
+      if (existsSync16(rulePath)) {
         rmSync(rulePath);
         result.deletedRules.push(ruleName);
       }
@@ -1863,17 +2913,17 @@ async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
   return result;
 }
 // src/state/providers.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync3 } from "node:fs";
-import { readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
+import { existsSync as existsSync17, mkdirSync as mkdirSync3 } from "node:fs";
+import { readFile as readFile15, writeFile as writeFile8 } from "node:fs/promises";
 var STATE_DIR2 = ".omni/state";
 var PROVIDERS_PATH = `${STATE_DIR2}/providers.json`;
 var DEFAULT_PROVIDERS = ["claude-code"];
 async function readEnabledProviders() {
-  if (!existsSync14(PROVIDERS_PATH)) {
+  if (!existsSync17(PROVIDERS_PATH)) {
     return DEFAULT_PROVIDERS;
   }
   try {
-    const content = await readFile14(PROVIDERS_PATH, "utf-8");
+    const content = await readFile15(PROVIDERS_PATH, "utf-8");
     const state = JSON.parse(content);
     return state.enabled.length > 0 ? state.enabled : DEFAULT_PROVIDERS;
   } catch {
@@ -1905,18 +2955,18 @@ async function isProviderEnabled(providerId) {
 import { spawn as spawn2 } from "node:child_process";
 import { mkdirSync as mkdirSync4 } from "node:fs";
 async function installCapabilityDependencies(silent) {
-  const { existsSync: existsSync15, readdirSync: readdirSync7 } = await import("node:fs");
-  const { join: join8 } = await import("node:path");
+  const { existsSync: existsSync18, readdirSync: readdirSync7 } = await import("node:fs");
+  const { join: join9 } = await import("node:path");
   const capabilitiesDir = ".omni/capabilities";
-  if (!existsSync15(capabilitiesDir)) {
+  if (!existsSync18(capabilitiesDir)) {
     return;
   }
   const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
   async function commandExists(cmd) {
-    return await new Promise((resolve) => {
+    return await new Promise((resolve2) => {
       const proc = spawn2(cmd, ["--version"], { stdio: "ignore" });
-      proc.on("error", () => resolve(false));
-      proc.on("close", (code) => resolve(code === 0));
+      proc.on("error", () => resolve2(false));
+      proc.on("close", (code) => resolve2(code === 0));
     });
   }
   const hasBun = await commandExists("bun");
@@ -1928,16 +2978,16 @@ async function installCapabilityDependencies(silent) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const capabilityPath = join8(capabilitiesDir, entry.name);
-    const packageJsonPath = join8(capabilityPath, "package.json");
-    if (!existsSync15(packageJsonPath)) {
+    const capabilityPath = join9(capabilitiesDir, entry.name);
+    const packageJsonPath = join9(capabilityPath, "package.json");
+    if (!existsSync18(packageJsonPath)) {
       continue;
     }
     if (!silent) {
       console.log(`Installing dependencies for ${capabilityPath}...`);
     }
-    await new Promise((resolve, reject) => {
-      const useNpmCi = hasNpm && existsSync15(join8(capabilityPath, "package-lock.json"));
+    await new Promise((resolve2, reject) => {
+      const useNpmCi = hasNpm && existsSync18(join9(capabilityPath, "package-lock.json"));
       const cmd = hasBun ? "bun" : "npm";
       const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
       const proc = spawn2(cmd, args, {
@@ -1946,7 +2996,7 @@ async function installCapabilityDependencies(silent) {
       });
       proc.on("close", (code) => {
         if (code === 0) {
-          resolve();
+          resolve2();
         } else {
           reject(new Error(`Failed to install dependencies for ${capabilityPath}`));
         }
@@ -1959,8 +3009,8 @@ async function installCapabilityDependencies(silent) {
 }
 async function buildSyncBundle(options) {
   const silent = options?.silent ?? false;
-  const config = await loadConfig();
-  await fetchAllCapabilitySources(config, { silent });
+  const config2 = await loadConfig();
+  await fetchAllCapabilitySources(config2, { silent });
   await installCapabilityDependencies(silent);
   const registry = await buildCapabilityRegistry();
   const capabilities2 = registry.getAllCapabilities();
@@ -1969,6 +3019,7 @@ async function buildSyncBundle(options) {
   const docs = registry.getAllDocs();
   const commands = capabilities2.flatMap((c) => c.commands);
   const subagents = capabilities2.flatMap((c) => c.subagents);
+  const mergedHooks = registry.getMergedHooks();
   const instructionsContent = generateInstructionsContent(rules, docs);
   const bundle = {
     capabilities: capabilities2,
@@ -1977,9 +3028,11 @@ async function buildSyncBundle(options) {
     docs,
     commands,
     subagents,
-    instructionsPath: ".omni/instructions.md",
     instructionsContent
   };
+  if (hasAnyHooks(mergedHooks)) {
+    bundle.hooks = mergedHooks;
+  }
   return { bundle };
 }
 async function syncAgentConfiguration(options) {
@@ -2023,15 +3076,14 @@ async function syncAgentConfiguration(options) {
     }
   }
   mkdirSync4(".omni", { recursive: true });
-  await writeRules(bundle.rules, bundle.docs);
   await syncMcpJson(capabilities2, previousManifest, { silent });
   const newManifest = buildManifestFromCapabilities(capabilities2);
   await saveManifest(newManifest);
   if (adapters.length > 0) {
-    const config = await loadConfig();
+    const config2 = await loadConfig();
     const ctx = {
       projectRoot: process.cwd(),
-      config
+      config: config2
     };
     for (const adapter of adapters) {
       try {
@@ -2046,7 +3098,7 @@ async function syncAgentConfiguration(options) {
   }
   if (!silent) {
     console.log("✓ Synced:");
-    console.log(`  - .omni/instructions.md (${bundle.docs.length} docs, ${bundle.rules.length} rules)`);
+    console.log(`  - ${bundle.docs.length} docs, ${bundle.rules.length} rules`);
     if (adapters.length > 0) {
       console.log(`  - Provider adapters: ${adapters.map((a) => a.displayName).join(", ")}`);
     }
@@ -2101,56 +3153,150 @@ function generateAgentsTemplate() {
 
 ## OmniDev
 
-@import .omni/instructions.md
+<!-- This section is populated during sync with capability rules and docs -->
 `;
 }
-// src/templates/claude.ts
-function generateClaudeTemplate() {
-  return `# Project Instructions
+// src/templates/capability.ts
+function generateCapabilityToml2(options) {
+  const description = options.description || "TODO: Add a description for your capability";
+  return `[capability]
+id = "${options.id}"
+name = "${options.name}"
+version = "0.1.0"
+description = "${description}"
 
-<!-- Add your project-specific instructions here -->
+# Optional author information
+# [capability.author]
+# name = "Your Name"
+# email = "you@example.com"
 
-## OmniDev
+# Optional metadata
+# [capability.metadata]
+# repository = "https://github.com/user/repo"
+# license = "MIT"
+`;
+}
+function generateSkillTemplate(skillName) {
+  return `---
+name: ${skillName}
+description: TODO: Add a description for this skill
+---
+
+## What I do
+
+<!-- Describe what this skill helps the AI agent accomplish -->
+- TODO: List the main capabilities of this skill
+
+## When to use me
 
-@import .omni/instructions.md
+<!-- Describe scenarios when this skill should be invoked -->
+Use this skill when you need to:
+- TODO: Add trigger conditions
+
+## Implementation
+
+<!-- Add detailed instructions for the AI agent -->
+### Steps
+
+1. TODO: Add implementation steps
+2. Validate inputs and outputs
+3. Report results to the user
+
+## Examples
+
+<!-- Optional: Add examples of how this skill should be used -->
+\`\`\`
+TODO: Add example usage
+\`\`\`
 `;
 }
-function generateInstructionsTemplate() {
-  return `# OmniDev Instructions
+function generateRuleTemplate(ruleName) {
+  return `# ${formatDisplayName(ruleName)}
 
-## Project Description
-<!-- TODO: Add 2-3 sentences describing your project -->
-[Describe what this project does and its main purpose]
+<!-- Rules are guidelines that the AI agent should follow when working in this project -->
+
+## Overview
 
-## How OmniDev Works
+TODO: Describe what this rule enforces or guides.
 
-OmniDev manages capability content for your project. Capabilities can provide:
+## Guidelines
 
-- Skills (for agent workflows)
-- Rules (for guardrails and conventions)
-- Docs (reference material)
-- Commands and subagents (optional)
+- TODO: Add specific guidelines the AI should follow
+- Be specific and actionable
+- Include examples where helpful
 
-Enable capabilities with:
+## Examples
+
+### Good
 
 \`\`\`
-omnidev capability enable <capability-id>
+TODO: Add example of correct behavior
 \`\`\`
 
-OmniDev will automatically sync enabled capabilities into your workspace. If you want to force a refresh:
+### Bad
 
 \`\`\`
-omnidev sync
+TODO: Add example of incorrect behavior
 \`\`\`
+`;
+}
+function generateHooksTemplate() {
+  return `# Hook configuration for this capability
+# See: https://omnidev.dev/docs/advanced/hooks
+
+# Example: Validate bash commands before execution
+# [[PreToolUse]]
+# matcher = "Bash"
+# [[PreToolUse.hooks]]
+# type = "command"
+# command = "\${OMNIDEV_CAPABILITY_ROOT}/hooks/validate-bash.sh"
+# timeout = 30
+
+# Example: Run linter after file edits
+# [[PostToolUse]]
+# matcher = "Write|Edit"
+# [[PostToolUse.hooks]]
+# type = "command"
+# command = "\${OMNIDEV_CAPABILITY_ROOT}/hooks/run-linter.sh"
+
+# Example: Load context at session start
+# [[SessionStart]]
+# matcher = "startup|resume"
+# [[SessionStart.hooks]]
+# type = "command"
+# command = "\${OMNIDEV_CAPABILITY_ROOT}/hooks/load-context.sh"
+`;
+}
+function generateHookScript() {
+  return `#!/bin/bash
+# Sample hook script
+# This script receives JSON input via stdin
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Example: Extract tool information
+# TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name')
+# COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
 
-<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
-<!-- This section is automatically updated by 'omnidev agents sync' -->
+# Add your validation logic here
+# Exit 0 to allow, exit 2 to block
+
+exit 0
+`;
+}
+function formatDisplayName(kebabCase) {
+  return kebabCase.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+// src/templates/claude.ts
+function generateClaudeTemplate() {
+  return `# Project Instructions
 
-## Capabilities
+<!-- Add your project-specific instructions here -->
 
-No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.
+## OmniDev
 
-<!-- END OMNIDEV GENERATED CONTENT -->
+<!-- This section is populated during sync with capability rules and docs -->
 `;
 }
 // src/templates/omni.ts
@@ -2174,14 +3320,6 @@ function generateOmniMdTemplate() {
 <!-- Describe your project's architecture and key components -->
 `;
 }
-// src/types/index.ts
-function getActiveProviders(config) {
-  if (config.providers)
-    return config.providers;
-  if (config.provider)
-    return [config.provider];
-  return ["claude"];
-}
 // src/debug.ts
 function debug(message, data) {
   if (process.env["OMNIDEV_DEBUG"] !== "1") {
@@ -2203,14 +3341,18 @@ function getVersion() {
   return version;
 }
 export {
-  writeRules,
   writeProviderConfig,
   writeMcpJson,
   writeEnabledProviders,
   writeConfig,
   writeActiveProfileState,
   version,
+  validateHooksConfig,
+  validateHook,
   validateEnv,
+  transformToOmnidev,
+  transformToClaude,
+  transformHooksConfig,
   syncMcpJson,
   syncAgentConfiguration,
   sourceToGitUrl,
@@ -2221,11 +3363,18 @@ export {
   resolveEnabledCapabilities,
   readMcpJson,
   readEnabledProviders,
+  readCapabilityIdFromPath,
   readActiveProfileState,
+  patchAddToProfile,
+  patchAddMcp,
+  patchAddCapabilitySource,
   parseSourceConfig,
   parseProviderFlag,
   parseOmniConfig,
+  parseFileSourcePath,
   parseCapabilityConfig,
+  mergeHooksConfigs,
+  mergeAndDeduplicateHooks,
   loadSubagents,
   loadSkills,
   loadRules,
@@ -2233,26 +3382,48 @@ export {
   loadProfileConfig,
   loadManifest,
   loadLockFile,
+  loadHooksFromCapability,
   loadEnvironment,
   loadDocs,
   loadConfig,
   loadCommands,
+  loadCapabilityHooks,
   loadCapabilityConfig,
   loadCapability,
   loadBaseConfig,
+  isValidMatcherPattern,
   isSecretEnvVar,
   isProviderEnabled,
+  isPromptHookEvent,
+  isMatcherEvent,
+  isHookType,
+  isHookPrompt,
+  isHookEvent,
+  isHookCommand,
+  isGitSource,
+  isFileSourceConfig,
+  isFileSource,
   installCapabilityDependencies,
+  hasHooks,
+  hasAnyHooks,
   getVersion,
   getSourceCapabilityPath,
   getLockFilePath,
+  getHooksDirectory,
+  getHooksConfigPath,
+  getEventsWithHooks,
   getEnabledCapabilities,
   getActiveProviders,
   getActiveProfile,
+  generateSkillTemplate,
+  generateRuleTemplate,
   generateOmniMdTemplate,
-  generateInstructionsTemplate,
+  generateHooksTemplate,
+  generateHookScript,
   generateClaudeTemplate,
+  generateCapabilityToml2 as generateCapabilityToml,
   generateAgentsTemplate,
+  findDuplicateCommands,
   fetchCapabilitySource,
   fetchAllCapabilitySources,
   enableProvider,
@@ -2261,6 +3432,11 @@ export {
   disableProvider,
   disableCapability,
   debug,
+  createEmptyValidationResult,
+  createEmptyHooksConfig,
+  countHooks,
+  containsOmnidevVariables,
+  containsClaudeVariables,
   clearActiveProfileState,
   cleanupStaleResources,
   checkForUpdates,
@@ -2268,5 +3444,18 @@ export {
   buildRouteMap,
   buildManifestFromCapabilities,
   buildCommand,
-  buildCapabilityRegistry
+  buildCapabilityRegistry,
+  VARIABLE_MAPPINGS,
+  SESSION_START_MATCHERS,
+  PROMPT_HOOK_EVENTS,
+  PRE_COMPACT_MATCHERS,
+  NOTIFICATION_MATCHERS,
+  MATCHER_EVENTS,
+  HOOK_TYPES,
+  HOOK_EVENTS,
+  HOOKS_DIRECTORY,
+  HOOKS_CONFIG_FILENAME,
+  DEFAULT_PROMPT_TIMEOUT,
+  DEFAULT_COMMAND_TIMEOUT,
+  COMMON_TOOL_MATCHERS
 };