@omnidev-ai/cli 0.18.1 → 0.19.0

package/dist/index.js

@@ -1833,47 +1833,23 @@ function resolveCapabilityRoot(content, capabilityPath) {
   }
   return result;
 }
-function resolveCapabilityRootInConfig(config, capabilityPath) {
-  const result = {};
-  if (config.description !== undefined) {
-    result.description = config.description;
+function resolveCapabilityRootInValue(value, capabilityPath) {
+  if (typeof value === "string") {
+    return resolveCapabilityRoot(value, capabilityPath);
   }
-  const events = [
-    "PreToolUse",
-    "PostToolUse",
-    "PermissionRequest",
-    "UserPromptSubmit",
-    "Stop",
-    "SubagentStop",
-    "Notification",
-    "SessionStart",
-    "SessionEnd",
-    "PreCompact"
-  ];
-  for (const event of events) {
-    const matchers = config[event];
-    if (matchers) {
-      result[event] = matchers.map((matcher) => ({
-        ...matcher,
-        hooks: matcher.hooks.map((hook) => {
-          if (hook.type === "command") {
-            return {
-              ...hook,
-              command: resolveCapabilityRoot(hook.command, capabilityPath)
-            };
-          }
-          if (hook.type === "prompt") {
-            return {
-              ...hook,
-              prompt: resolveCapabilityRoot(hook.prompt, capabilityPath)
-            };
-          }
-          return hook;
-        })
-      }));
-    }
+  if (Array.isArray(value)) {
+    return value.map((entry) => resolveCapabilityRootInValue(entry, capabilityPath));
   }
-  return result;
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      resolveCapabilityRootInValue(entry, capabilityPath)
+    ]));
+  }
+  return value;
+}
+function resolveCapabilityRootInConfig(config, capabilityPath) {
+  return resolveCapabilityRootInValue(config, capabilityPath);
 }
 var REVERSE_MAPPINGS;
 var init_variables = __esm(() => {
@@ -2183,6 +2159,55 @@ function loadHooksFromCapability(capabilityPath, options) {
   }
   return loadJsonHooksFiles(capabilityPath, hooksJsonInDir, hooksJsonAtRoot, hooksDir, opts);
 }
+function splitHooksTomlConfig(parsed) {
+  const topLevelIssues = [];
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return {
+      sharedConfig: parsed,
+      providerConfigs: undefined,
+      topLevelIssues
+    };
+  }
+  const parsedObj = parsed;
+  const sharedConfig = {};
+  const providerConfigs = {};
+  for (const [key, value] of Object.entries(parsedObj)) {
+    if (key === "description" || HOOK_EVENTS.includes(key)) {
+      sharedConfig[key] = value;
+      continue;
+    }
+    if (PROVIDER_SECTION_KEYS.includes(key)) {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        providerConfigs[key] = value;
+      } else {
+        topLevelIssues.push({
+          severity: "error",
+          code: "HOOKS_INVALID_TOML",
+          message: `[${key}] must be a table`
+        });
+      }
+      continue;
+    }
+    topLevelIssues.push({
+      severity: "error",
+      code: "HOOKS_UNKNOWN_EVENT",
+      message: `Unknown hook event: "${key}"`,
+      suggestion: `Valid events are: ${HOOK_EVENTS.join(", ")}, plus [claude] and [codex] sections`
+    });
+  }
+  return {
+    sharedConfig,
+    providerConfigs: Object.keys(providerConfigs).length > 0 ? providerConfigs : undefined,
+    topLevelIssues
+  };
+}
+function prefixValidationIssues(issues, sectionLabel) {
+  return issues.map((issue) => ({
+    ...issue,
+    message: `[${sectionLabel}] ${issue.message}`,
+    ...issue.suggestion ? { suggestion: `[${sectionLabel}] ${issue.suggestion}` } : {}
+  }));
+}
 function loadTomlHooks(capabilityPath, configPath, hooksDir, opts) {
   let rawContent;
   try {
@@ -2234,25 +2259,56 @@ function loadTomlHooks(capabilityPath, configPath, hooksDir, opts) {
       loadError: `Invalid TOML: ${error instanceof Error ? error.message : String(error)}`
     };
   }
+  const {
+    sharedConfig,
+    providerConfigs: rawProviderConfigs,
+    topLevelIssues
+  } = splitHooksTomlConfig(parsed);
   let validation;
   if (opts.validate) {
-    validation = validateHooksConfig(parsed, {
+    const sharedValidation = validateHooksConfig(sharedConfig, {
       basePath: hooksDir,
       checkScripts: opts.checkScripts ?? false
     });
+    const providerErrors = [];
+    const providerWarnings = [];
+    for (const [provider, providerConfig] of Object.entries(rawProviderConfigs ?? {})) {
+      const providerValidation = validateHooksConfig(providerConfig, {
+        basePath: hooksDir,
+        checkScripts: opts.checkScripts ?? false
+      });
+      providerErrors.push(...prefixValidationIssues(providerValidation.errors, provider));
+      providerWarnings.push(...prefixValidationIssues(providerValidation.warnings, provider));
+    }
+    validation = {
+      valid: sharedValidation.valid && topLevelIssues.length === 0 && providerErrors.length === 0,
+      errors: [...topLevelIssues, ...sharedValidation.errors, ...providerErrors],
+      warnings: [...sharedValidation.warnings, ...providerWarnings]
+    };
   } else {
     validation = createEmptyValidationResult();
   }
-  let config = validation.valid ? parsed : createEmptyHooksConfig();
+  let config = validation.valid ? sharedConfig : createEmptyHooksConfig();
+  let providerConfigs = validation.valid ? rawProviderConfigs : undefined;
   if (opts.resolveCapabilityRoot && validation.valid) {
     config = resolveCapabilityRootInConfig(config, capabilityPath);
+    if (providerConfigs) {
+      providerConfigs = Object.fromEntries(Object.entries(providerConfigs).map(([provider, providerConfig]) => [
+        provider,
+        resolveCapabilityRootInValue(providerConfig, capabilityPath)
+      ]));
+    }
   }
-  return {
+  const result = {
     config,
     validation,
     found: true,
     configPath
   };
+  if (providerConfigs) {
+    result.providerConfigs = providerConfigs;
+  }
+  return result;
 }
 function loadJsonHooksFiles(capabilityPath, hooksJsonInDir, hooksJsonAtRoot, hooksDir, opts) {
   const configs = [];
@@ -2348,6 +2404,7 @@ function loadCapabilityHooks(capabilityName, capabilityPath, options) {
     capabilityName,
     capabilityPath,
     config: result.config,
+    ...result.providerConfigs ? { providerConfigs: result.providerConfigs } : {},
     validation: result.validation
   };
 }
@@ -2363,6 +2420,7 @@ function getHooksDirectory(capabilityPath) {
 function getHooksConfigPath(capabilityPath) {
   return join3(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
 }
+var PROVIDER_SECTION_KEYS;
 var init_loader = __esm(() => {
   init_dist();
   init_constants();
@@ -2370,6 +2428,7 @@ var init_loader = __esm(() => {
   init_variables();
   init_json_loader();
   init_constants();
+  PROVIDER_SECTION_KEYS = ["claude", "codex"];
 });
 
 // ../core/src/providers.ts
@@ -2668,75 +2727,235 @@ import { readFile as readFile6 } from "node:fs/promises";
 import { basename as basename4, join as join7 } from "node:path";
 async function loadSubagents(capabilityPath, capabilityId) {
   const subagents = [];
-  const possibleDirNames = ["subagents", "agents", "agent", "subagent"];
-  for (const dirName of possibleDirNames) {
+  for (const dirName of POSSIBLE_DIR_NAMES) {
     const dir = join7(capabilityPath, dirName);
     if (!existsSync9(dir)) {
       continue;
     }
+    const rootSubagent = await parseSubagentDirectory(dir, capabilityId);
+    if (rootSubagent) {
+      subagents.push(rootSubagent);
+    }
     const entries = readdirSync5(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        let subagentPath = join7(dir, entry.name, "SUBAGENT.md");
-        if (!existsSync9(subagentPath)) {
-          subagentPath = join7(dir, entry.name, "AGENT.md");
-        }
-        if (existsSync9(subagentPath)) {
-          const subagent = await parseSubagentFile(subagentPath, capabilityId);
+        const subagent = await parseSubagentDirectory(join7(dir, entry.name), capabilityId);
+        if (subagent) {
           subagents.push(subagent);
         }
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        if (PROMPT_FILE_NAMES.includes(entry.name) || LEGACY_AGENT_FILES.includes(entry.name)) {
+          continue;
+        }
         const subagentPath = join7(dir, entry.name);
-        const subagent = await parseSubagentFile(subagentPath, capabilityId);
-        subagents.push(subagent);
+        const content = await readFile6(subagentPath, "utf-8");
+        subagents.push(parseLegacySubagentMarkdown(content, capabilityId, subagentPath, basename4(subagentPath, ".md")));
       }
     }
   }
   return subagents;
 }
-async function parseSubagentFile(filePath, capabilityId) {
-  const content = await readFile6(filePath, "utf-8");
+function parseLegacySubagentMarkdown(content, capabilityId, sourceLabel, inferredName) {
   const parsed = parseFrontmatterWithMarkdown(content);
   if (!parsed) {
-    throw new Error(`Invalid SUBAGENT.md format at ${filePath}: missing YAML frontmatter`);
+    throw new Error(`Invalid SUBAGENT.md format at ${sourceLabel}: missing YAML frontmatter`);
   }
   const frontmatter = parsed.frontmatter;
-  const systemPrompt = parsed.markdown;
-  const inferredName = basename4(filePath, ".md").replace(/^SUBAGENT$/i, "").replace(/^AGENT$/i, "");
-  const name = frontmatter.name || inferredName;
+  const name = frontmatter.name || inferredName?.replace(/^SUBAGENT$/i, "").replace(/^AGENT$/i, "") || undefined;
   if (!name || !frontmatter.description) {
-    throw new Error(`Invalid SUBAGENT.md at ${filePath}: name and description required`);
+    throw new Error(`Invalid SUBAGENT.md at ${sourceLabel}: name and description required`);
   }
-  const result = {
-    name,
-    description: frontmatter.description,
-    systemPrompt: systemPrompt.trim(),
-    capabilityId
-  };
+  const claude = {};
   if (frontmatter.tools) {
-    result.tools = parseCommaSeparatedList(frontmatter.tools);
+    claude.tools = parseCommaSeparatedList(frontmatter.tools);
   }
   if (frontmatter.disallowedTools) {
-    result.disallowedTools = parseCommaSeparatedList(frontmatter.disallowedTools);
+    claude.disallowedTools = parseCommaSeparatedList(frontmatter.disallowedTools);
   }
   if (frontmatter.model) {
-    result.model = frontmatter.model;
+    claude.model = frontmatter.model;
   }
   if (frontmatter.permissionMode) {
-    result.permissionMode = frontmatter.permissionMode;
+    claude.permissionMode = frontmatter.permissionMode;
   }
   if (frontmatter.skills) {
-    result.skills = parseCommaSeparatedList(frontmatter.skills);
+    claude.skills = parseCommaSeparatedList(frontmatter.skills);
   }
   if (frontmatter.hooks) {
-    result.hooks = frontmatter.hooks;
+    claude.hooks = frontmatter.hooks;
   }
-  return result;
+  const subagent = {
+    name,
+    description: frontmatter.description,
+    systemPrompt: parsed.markdown.trim(),
+    capabilityId
+  };
+  if (hasClaudeConfig(claude)) {
+    subagent.claude = claude;
+  }
+  return withClaudeCompatibilityAliases(subagent);
+}
+function parseSubagentManifest(agentTomlContent, promptContent, capabilityId, sourceLabel) {
+  let parsed;
+  try {
+    parsed = parse(agentTomlContent);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid agent.toml at ${sourceLabel}: ${message}`);
+  }
+  if (typeof parsed.name !== "string" || parsed.name.trim().length === 0) {
+    throw new Error(`Invalid agent.toml at ${sourceLabel}: name is required`);
+  }
+  if (typeof parsed.description !== "string" || parsed.description.trim().length === 0) {
+    throw new Error(`Invalid agent.toml at ${sourceLabel}: description is required`);
+  }
+  const claude = parseClaudeConfig(parsed.claude, sourceLabel);
+  const codex = parseCodexConfig(parsed.codex, sourceLabel);
+  const subagent = {
+    name: parsed.name.trim(),
+    description: parsed.description.trim(),
+    systemPrompt: promptContent.trim(),
+    capabilityId
+  };
+  if (claude) {
+    subagent.claude = claude;
+  }
+  if (codex) {
+    subagent.codex = codex;
+  }
+  return withClaudeCompatibilityAliases(subagent);
+}
+async function parseSubagentDirectory(dirPath, capabilityId) {
+  const manifestPath = findFirstExisting(dirPath, MANIFEST_FILE_NAMES);
+  const promptPath = findFirstExisting(dirPath, PROMPT_FILE_NAMES);
+  if (manifestPath || promptPath) {
+    if (!manifestPath || !promptPath) {
+      throw new Error(`Invalid subagent directory at ${dirPath}: agent.toml and prompt.md must both be present`);
+    }
+    const [agentTomlContent, promptContent] = await Promise.all([
+      readFile6(manifestPath, "utf-8"),
+      readFile6(promptPath, "utf-8")
+    ]);
+    return parseSubagentManifest(agentTomlContent, promptContent, capabilityId, manifestPath);
+  }
+  const legacyPath = findFirstExisting(dirPath, LEGACY_AGENT_FILES);
+  if (!legacyPath) {
+    return null;
+  }
+  const content = await readFile6(legacyPath, "utf-8");
+  return parseLegacySubagentMarkdown(content, capabilityId, legacyPath);
+}
+function findFirstExisting(dirPath, fileNames) {
+  for (const fileName of fileNames) {
+    const filePath = join7(dirPath, fileName);
+    if (existsSync9(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function parseClaudeConfig(value, sourceLabel) {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  const claude = {};
+  if (value.tools !== undefined) {
+    claude.tools = readStringArray(value.tools, `${sourceLabel} [claude].tools`);
+  }
+  if (value.disallowed_tools !== undefined) {
+    claude.disallowedTools = readStringArray(value.disallowed_tools, `${sourceLabel} [claude].disallowed_tools`);
+  }
+  if (value.model !== undefined) {
+    claude.model = readEnum(value.model, ["sonnet", "opus", "haiku", "inherit"], `${sourceLabel} [claude].model`);
+  }
+  if (value.permission_mode !== undefined) {
+    claude.permissionMode = readEnum(value.permission_mode, ["default", "acceptEdits", "dontAsk", "bypassPermissions", "plan"], `${sourceLabel} [claude].permission_mode`);
+  }
+  if (value.skills !== undefined) {
+    claude.skills = readStringArray(value.skills, `${sourceLabel} [claude].skills`);
+  }
+  if (value.hooks !== undefined) {
+    if (typeof value.hooks !== "object" || value.hooks === null) {
+      throw new Error(`Invalid ${sourceLabel} [claude].hooks: expected a table`);
+    }
+    claude.hooks = value.hooks;
+  }
+  return hasClaudeConfig(claude) ? claude : undefined;
+}
+function parseCodexConfig(value, sourceLabel) {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  const codex = {};
+  if (value.model !== undefined) {
+    codex.model = readString(value.model, `${sourceLabel} [codex].model`);
+  }
+  if (value.model_reasoning_effort !== undefined) {
+    codex.modelReasoningEffort = readEnum(value.model_reasoning_effort, ["low", "medium", "high", "xhigh"], `${sourceLabel} [codex].model_reasoning_effort`);
+  }
+  if (value.sandbox_mode !== undefined) {
+    codex.sandboxMode = readEnum(value.sandbox_mode, ["read-only", "workspace-write", "danger-full-access"], `${sourceLabel} [codex].sandbox_mode`);
+  }
+  if (value.nickname_candidates !== undefined) {
+    codex.nicknameCandidates = readStringArray(value.nickname_candidates, `${sourceLabel} [codex].nickname_candidates`);
+  }
+  return Object.keys(codex).length > 0 ? codex : undefined;
+}
+function withClaudeCompatibilityAliases(subagent) {
+  if (subagent.claude) {
+    if (subagent.claude.tools) {
+      subagent.tools = subagent.claude.tools;
+    }
+    if (subagent.claude.disallowedTools) {
+      subagent.disallowedTools = subagent.claude.disallowedTools;
+    }
+    if (subagent.claude.model) {
+      subagent.model = subagent.claude.model;
+    }
+    if (subagent.claude.permissionMode) {
+      subagent.permissionMode = subagent.claude.permissionMode;
+    }
+    if (subagent.claude.skills) {
+      subagent.skills = subagent.claude.skills;
+    }
+    if (subagent.claude.hooks) {
+      subagent.hooks = subagent.claude.hooks;
+    }
+  }
+  return subagent;
+}
+function hasClaudeConfig(config) {
+  return Object.keys(config).length > 0;
+}
+function readString(value, fieldName) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Invalid ${fieldName}: expected a non-empty string`);
+  }
+  return value.trim();
+}
+function readStringArray(value, fieldName) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`Invalid ${fieldName}: expected an array of strings`);
+  }
+  return value.map((item) => item.trim()).filter(Boolean);
+}
+function readEnum(value, allowed, fieldName) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new Error(`Invalid ${fieldName}: expected one of ${allowed.join(", ")}`);
+  }
+  return value;
 }
 function parseCommaSeparatedList(value) {
   return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
-var init_subagents = () => {};
+var POSSIBLE_DIR_NAMES, LEGACY_AGENT_FILES, MANIFEST_FILE_NAMES, PROMPT_FILE_NAMES;
+var init_subagents = __esm(() => {
+  init_dist();
+  POSSIBLE_DIR_NAMES = ["subagents", "agents", "agent", "subagent"];
+  LEGACY_AGENT_FILES = ["SUBAGENT.md", "subagent.md", "AGENT.md", "agent.md", "Agent.md"];
+  MANIFEST_FILE_NAMES = ["agent.toml", "AGENT.toml"];
+  PROMPT_FILE_NAMES = ["prompt.md", "PROMPT.md"];
+});
 
 // ../core/src/capability/loader.ts
 import { existsSync as existsSync10, readdirSync as readdirSync6 } from "node:fs";
@@ -2835,75 +3054,19 @@ function convertDocExports(docExports, capabilityId) {
   });
 }
 function convertSubagentExports(subagentExports, capabilityId) {
-  return subagentExports.map((subagentExport) => {
+  return subagentExports.map((subagentExport, index) => {
     const exportObj = subagentExport;
-    const lines = exportObj.subagentMd.split(`
-`);
-    let name = "unnamed";
-    let description = "";
-    let systemPrompt = exportObj.subagentMd;
-    let tools;
-    let disallowedTools;
-    let model;
-    let permissionMode;
-    let skills;
-    if (lines[0]?.trim() === "---") {
-      const endIndex = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
-      if (endIndex > 0) {
-        const frontmatter = lines.slice(1, endIndex);
-        systemPrompt = lines.slice(endIndex + 1).join(`
-`).trim();
-        for (const line of frontmatter) {
-          const match = line.match(/^(\w+):\s*(.+)$/);
-          if (match?.[1] && match[2]) {
-            const key = match[1];
-            const value = match[2].replace(/^["']|["']$/g, "");
-            switch (key) {
-              case "name":
-                name = value;
-                break;
-              case "description":
-                description = value;
-                break;
-              case "tools":
-                tools = value.split(",").map((t) => t.trim());
-                break;
-              case "disallowedTools":
-                disallowedTools = value.split(",").map((t) => t.trim());
-                break;
-              case "model":
-                model = value;
-                break;
-              case "permissionMode":
-                permissionMode = value;
-                break;
-              case "skills":
-                skills = value.split(",").map((s) => s.trim());
-                break;
-            }
-          }
-        }
+    const sourceLabel = `programmatic subagent export[${index}]`;
+    if (typeof exportObj.agentToml === "string" || typeof exportObj.promptMd === "string") {
+      if (typeof exportObj.agentToml !== "string" || typeof exportObj.promptMd !== "string") {
+        throw new Error(`Invalid ${sourceLabel}: agentToml and promptMd must both be provided`);
       }
+      return parseSubagentManifest(exportObj.agentToml, exportObj.promptMd, capabilityId, sourceLabel);
     }
-    const result = {
-      name,
-      description,
-      systemPrompt,
-      capabilityId
-    };
-    if (tools)
-      result.tools = tools;
-    if (disallowedTools)
-      result.disallowedTools = disallowedTools;
-    if (model) {
-      result.model = model;
-    }
-    if (permissionMode) {
-      result.permissionMode = permissionMode;
-    }
-    if (skills)
-      result.skills = skills;
-    return result;
+    if (typeof exportObj.subagentMd === "string") {
+      return parseLegacySubagentMarkdown(exportObj.subagentMd, capabilityId, sourceLabel, `subagent-${index + 1}`);
+    }
+    throw new Error(`Invalid ${sourceLabel}: expected agentToml + promptMd or subagentMd`);
   });
 }
 function convertCommandExports(commandExports, capabilityId) {
@@ -4761,7 +4924,15 @@ var init_sources = __esm(() => {
     /^copying(?:\..+)?$/i
   ];
   SKILL_FILES = ["SKILL.md", "skill.md", "Skill.md"];
-  AGENT_FILES = ["AGENT.md", "agent.md", "Agent.md", "SUBAGENT.md", "subagent.md"];
+  AGENT_FILES = [
+    "AGENT.md",
+    "agent.md",
+    "Agent.md",
+    "SUBAGENT.md",
+    "subagent.md",
+    "agent.toml",
+    "AGENT.toml"
+  ];
   COMMAND_FILES = ["COMMAND.md", "command.md", "Command.md"];
   CONTENT_HASH_EXCLUDES = [
     ".git",
@@ -4789,6 +4960,211 @@ var init_capability = __esm(() => {
   init_subagents();
 });
 
+// ../core/src/hooks/provider-config.ts
+function getProviderDisplayName(providerId) {
+  switch (providerId) {
+    case "claude-code":
+      return "Claude Code";
+    case "codex":
+      return "Codex";
+    case "cursor":
+      return "Cursor";
+    case "opencode":
+      return "OpenCode";
+  }
+}
+function hasOwnKey(value, key) {
+  return Object.hasOwn(value, key);
+}
+function hasHooksInConfig(config) {
+  if (!config) {
+    return false;
+  }
+  for (const event of HOOK_EVENTS) {
+    const matchers = config[event];
+    if (Array.isArray(matchers) && matchers.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function matcherMatchesAny(matcher, values) {
+  if (matcher === undefined || matcher === "" || matcher === "*") {
+    return true;
+  }
+  try {
+    const regex = new RegExp(matcher);
+    return values.some((value) => regex.test(value));
+  } catch {
+    return false;
+  }
+}
+function cloneMatcher(matcher) {
+  return {
+    ...matcher.matcher !== undefined ? { matcher: matcher.matcher } : {},
+    hooks: matcher.hooks.map((hook) => ({ ...hook }))
+  };
+}
+function filterSharedHooksForCodex(config, capabilityName) {
+  const warnings = [];
+  if (process.platform === "win32") {
+    if (hasHooksInConfig(config)) {
+      warnings.push(`[hooks] Warning: Capability "${capabilityName}" has shared hooks, but Codex hooks are currently disabled on Windows. Skipping Codex hook output.`);
+    }
+    return { config: {}, warnings };
+  }
+  const filtered = {};
+  for (const event of HOOK_EVENTS) {
+    const matchers = config[event];
+    if (!matchers || matchers.length === 0) {
+      continue;
+    }
+    if (!CODEX_SUPPORTED_EVENTS.has(event)) {
+      warnings.push(`[hooks] Warning: Capability "${capabilityName}" shared event "${event}" is not supported by Codex and was skipped.`);
+      continue;
+    }
+    const filteredMatchers = [];
+    for (const matcher of matchers) {
+      const nextMatcher = cloneMatcher(matcher);
+      const originalHookCount = nextMatcher.hooks.length;
+      nextMatcher.hooks = nextMatcher.hooks.filter((hook, hookIndex) => {
+        if (hook.type === "command") {
+          return true;
+        }
+        warnings.push(`[hooks] Warning: Capability "${capabilityName}" shared ${event} hook ${hookIndex + 1} uses prompt hooks, which Codex does not support. It was skipped.`);
+        return false;
+      });
+      if (nextMatcher.hooks.length === 0) {
+        continue;
+      }
+      if (event === "UserPromptSubmit" || event === "Stop") {
+        if (nextMatcher.matcher !== undefined && nextMatcher.matcher !== "" && nextMatcher.matcher !== "*") {
+          warnings.push(`[hooks] Warning: Capability "${capabilityName}" shared ${event} matcher "${nextMatcher.matcher}" is ignored by Codex. The matcher was dropped.`);
+          delete nextMatcher.matcher;
+        }
+        filteredMatchers.push(nextMatcher);
+        continue;
+      }
+      if (event === "PreToolUse" || event === "PostToolUse") {
+        if (!matcherMatchesAny(nextMatcher.matcher, ["Bash"])) {
+          warnings.push(`[hooks] Warning: Capability "${capabilityName}" shared ${event} matcher "${nextMatcher.matcher ?? ""}" does not match Codex's current tool runtime ("Bash") and was skipped.`);
+          continue;
+        }
+        filteredMatchers.push(nextMatcher);
+        continue;
+      }
+      if (event === "SessionStart") {
+        if (!matcherMatchesAny(nextMatcher.matcher, ["startup", "resume"])) {
+          warnings.push(`[hooks] Warning: Capability "${capabilityName}" shared SessionStart matcher "${nextMatcher.matcher ?? ""}" does not match Codex's current sources ("startup" or "resume") and was skipped.`);
+          continue;
+        }
+      }
+      if (nextMatcher.hooks.length !== originalHookCount || nextMatcher.matcher !== matcher.matcher) {
+        filteredMatchers.push(nextMatcher);
+      } else {
+        filteredMatchers.push(matcher);
+      }
+    }
+    if (filteredMatchers.length > 0) {
+      filtered[event] = filteredMatchers;
+    }
+  }
+  return { config: filtered, warnings };
+}
+function getProviderOverrideWarnings(providerId, capabilityName, providerConfigs) {
+  if (!providerConfigs) {
+    return [];
+  }
+  if (providerId === "claude-code" && providerConfigs.codex) {
+    return [
+      `[hooks] Warning: Capability "${capabilityName}" defines [codex] hooks; they are not used by Claude Code.`
+    ];
+  }
+  if (providerId === "codex" && providerConfigs.claude) {
+    return [
+      `[hooks] Warning: Capability "${capabilityName}" defines [claude] hooks; they are not used by Codex.`
+    ];
+  }
+  return [];
+}
+function applyProviderOverrides(baseConfig, providerId, capabilityName, providerConfigs) {
+  const warnings = getProviderOverrideWarnings(providerId, capabilityName, providerConfigs);
+  const providerSection = PROVIDER_SECTION_BY_ID[providerId];
+  if (!providerSection) {
+    return { config: baseConfig, warnings };
+  }
+  const overrideConfig = providerConfigs?.[providerSection];
+  if (!overrideConfig) {
+    return { config: baseConfig, warnings };
+  }
+  const result = { ...baseConfig };
+  for (const event of HOOK_EVENTS) {
+    if (!hasOwnKey(overrideConfig, event)) {
+      continue;
+    }
+    const eventValue = overrideConfig[event];
+    if (!Array.isArray(eventValue)) {
+      warnings.push(`[hooks] Warning: Capability "${capabilityName}" [${providerSection}].${event} must be an array to be emitted for ${getProviderDisplayName(providerId)}. The override was skipped.`);
+      continue;
+    }
+    result[event] = eventValue;
+  }
+  return { config: result, warnings };
+}
+function mergeCapabilityHookConfig(target, capabilityConfig) {
+  for (const event of HOOK_EVENTS) {
+    const eventValue = capabilityConfig[event];
+    if (!Array.isArray(eventValue) || eventValue.length === 0) {
+      continue;
+    }
+    const existing = target[event];
+    target[event] = Array.isArray(existing) ? [...existing, ...eventValue] : [...eventValue];
+  }
+}
+function composeHooksForProvider(capabilityHooks, providerId) {
+  if (providerId !== "claude-code" && providerId !== "codex") {
+    return { config: {}, warnings: [] };
+  }
+  const warnings = [];
+  const mergedConfig = {};
+  for (const capHooks of capabilityHooks) {
+    if (providerId === "codex" && process.platform === "win32") {
+      if (hasHooksInConfig(capHooks.config) || hasHooksInConfig(capHooks.providerConfigs?.codex)) {
+        warnings.push(`[hooks] Warning: Capability "${capHooks.capabilityName}" has Codex hooks configured, but Codex hooks are currently disabled on Windows. Skipping Codex hook output.`);
+      }
+      continue;
+    }
+    let capabilityConfig = capHooks.config;
+    if (providerId === "codex") {
+      const filtered = filterSharedHooksForCodex(capabilityConfig, capHooks.capabilityName);
+      capabilityConfig = filtered.config;
+      warnings.push(...filtered.warnings);
+    }
+    const withOverrides = applyProviderOverrides(capabilityConfig, providerId, capHooks.capabilityName, capHooks.providerConfigs);
+    warnings.push(...withOverrides.warnings);
+    mergeCapabilityHookConfig(mergedConfig, withOverrides.config);
+  }
+  return {
+    config: mergedConfig,
+    warnings
+  };
+}
+var CODEX_SUPPORTED_EVENTS, PROVIDER_SECTION_BY_ID;
+var init_provider_config = __esm(() => {
+  init_constants();
+  CODEX_SUPPORTED_EVENTS = new Set([
+    "SessionStart",
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "Stop"
+  ]);
+  PROVIDER_SECTION_BY_ID = {
+    "claude-code": "claude",
+    codex: "codex"
+  };
+});
+
 // ../core/src/hooks/index.ts
 var init_hooks = __esm(() => {
   init_constants();
@@ -4797,6 +5173,7 @@ var init_hooks = __esm(() => {
   init_variables();
   init_loader();
   init_merger();
+  init_provider_config();
   init_json_loader();
 });
 
@@ -6569,6 +6946,7 @@ __export(exports_src, {
   saveManifest: () => saveManifest,
   saveLockFile: () => saveLockFile,
   resolveEnabledCapabilities: () => resolveEnabledCapabilities,
+  resolveCapabilityRootInValue: () => resolveCapabilityRootInValue,
   resolveCapabilityRootInConfig: () => resolveCapabilityRootInConfig,
   resolveCapabilityRoot: () => resolveCapabilityRoot,
   resolveCapabilityInstallCommand: () => resolveCapabilityInstallCommand,
@@ -6619,6 +6997,7 @@ __export(exports_src, {
   isFileSourceConfig: () => isFileSourceConfig,
   isFileSource: () => isFileSource,
   installCapabilityDependencies: () => installCapabilityDependencies,
+  hasHooksInConfig: () => hasHooksInConfig,
   hasHooks: () => hasHooks,
   hasAnyHooks: () => hasAnyHooks,
   getVersion: () => getVersion,
@@ -6657,6 +7036,7 @@ __export(exports_src, {
   countHooks: () => countHooks,
   containsOmnidevVariables: () => containsOmnidevVariables,
   containsClaudeVariables: () => containsClaudeVariables,
+  composeHooksForProvider: () => composeHooksForProvider,
   clearCapabilityAllows: () => clearCapabilityAllows,
   clearAllSecurityAllows: () => clearAllSecurityAllows,
   clearActiveProfileState: () => clearActiveProfileState,
@@ -6707,7 +7087,7 @@ import { run } from "@stricli/core";
 // src/lib/dynamic-app.ts
 import { existsSync as existsSync32 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join29 } from "node:path";
+import { join as join31 } from "node:path";
 import { buildApplication, buildRouteMap as buildRouteMap7 } from "@stricli/core";
 
 // src/commands/add.ts
@@ -6774,10 +7154,10 @@ var HooksWriter = {
     if (!bundle.hooks) {
       return { filesWritten: [] };
     }
+    const claudeHooks = transformHooksConfig(bundle.hooks, "toClaude");
     const settingsPath = join13(ctx.projectRoot, ctx.outputPath);
     const parentDir = dirname2(settingsPath);
     await mkdir2(parentDir, { recursive: true });
-    const claudeHooks = transformHooksConfig(bundle.hooks, "toClaude");
     let existingSettings = {};
     if (existsSync22(settingsPath)) {
       try {
@@ -7011,9 +7391,12 @@ function createProviderScopedBundle(bundle, providerId) {
     subagents,
     instructionsContent: generateInstructionsContent2(rules, docs)
   };
-  const mergedHooks = mergeHooksConfigs(capabilities2.flatMap((capability3) => capability3.hooks ? [capability3.hooks] : []));
-  if (hasAnyHooks(mergedHooks)) {
-    scopedBundle.hooks = mergedHooks;
+  const composedHooks = composeHooksForProvider(capabilities2.flatMap((capability3) => capability3.hooks ? [capability3.hooks] : []), providerId);
+  for (const warning of composedHooks.warnings) {
+    console.warn(warning);
+  }
+  if (hasHooksInConfig(composedHooks.config)) {
+    scopedBundle.hooks = composedHooks.config;
   }
   return scopedBundle;
 }
@@ -7021,24 +7404,34 @@ function createProviderScopedBundle(bundle, providerId) {
 // ../adapters/src/writers/claude/agents.ts
 import { mkdir as mkdir6, writeFile as writeFile14 } from "node:fs/promises";
 import { join as join17 } from "node:path";
+function getClaudeConfig(agent) {
+  return {
+    tools: agent.claude?.tools ?? agent.tools,
+    disallowedTools: agent.claude?.disallowedTools ?? agent.disallowedTools,
+    model: agent.claude?.model ?? agent.model,
+    permissionMode: agent.claude?.permissionMode ?? agent.permissionMode,
+    skills: agent.claude?.skills ?? agent.skills
+  };
+}
 function generateFrontmatter(agent) {
+  const claude2 = getClaudeConfig(agent);
   const lines = ["---"];
   lines.push(`name: ${agent.name}`);
   lines.push(`description: "${agent.description.replace(/"/g, "\\\"")}"`);
-  if (agent.tools && agent.tools.length > 0) {
-    lines.push(`tools: ${agent.tools.join(", ")}`);
+  if (claude2.tools && claude2.tools.length > 0) {
+    lines.push(`tools: ${claude2.tools.join(", ")}`);
   }
-  if (agent.disallowedTools && agent.disallowedTools.length > 0) {
-    lines.push(`disallowedTools: ${agent.disallowedTools.join(", ")}`);
+  if (claude2.disallowedTools && claude2.disallowedTools.length > 0) {
+    lines.push(`disallowedTools: ${claude2.disallowedTools.join(", ")}`);
   }
-  if (agent.model && agent.model !== "inherit") {
-    lines.push(`model: ${agent.model}`);
+  if (claude2.model && claude2.model !== "inherit") {
+    lines.push(`model: ${claude2.model}`);
   }
-  if (agent.permissionMode && agent.permissionMode !== "default") {
-    lines.push(`permissionMode: ${agent.permissionMode}`);
+  if (claude2.permissionMode && claude2.permissionMode !== "default") {
+    lines.push(`permissionMode: ${claude2.permissionMode}`);
   }
-  if (agent.skills && agent.skills.length > 0) {
-    lines.push(`skills: ${agent.skills.join(", ")}`);
+  if (claude2.skills && claude2.skills.length > 0) {
+    lines.push(`skills: ${claude2.skills.join(", ")}`);
   }
   lines.push("---");
   return lines.join(`
@@ -7098,12 +7491,82 @@ var claudeCodeAdapter = {
 };
 // ../adapters/src/codex/index.ts
 import { mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join21 } from "node:path";
 
-// ../adapters/src/writers/codex/toml.ts
+// ../adapters/src/writers/codex/agents.ts
 init_dist();
 import { mkdir as mkdir7, writeFile as writeFile15 } from "node:fs/promises";
-import { dirname as dirname4, join as join18 } from "node:path";
+import { join as join18 } from "node:path";
+function buildCodexAgentFile(agent) {
+  const codex = agent.codex ?? {};
+  const file = {
+    name: agent.name,
+    description: agent.description,
+    developer_instructions: agent.systemPrompt
+  };
+  if (codex.model) {
+    file.model = codex.model;
+  }
+  if (codex.modelReasoningEffort) {
+    file.model_reasoning_effort = codex.modelReasoningEffort;
+  }
+  if (codex.sandboxMode) {
+    file.sandbox_mode = codex.sandboxMode;
+  }
+  if (codex.nicknameCandidates && codex.nicknameCandidates.length > 0) {
+    file.nickname_candidates = codex.nicknameCandidates;
+  }
+  return file;
+}
+var CodexAgentsWriter = {
+  id: "codex-agents",
+  async write(bundle, ctx) {
+    if (bundle.subagents.length === 0) {
+      return { filesWritten: [] };
+    }
+    const agentsDir = join18(ctx.projectRoot, ctx.outputPath);
+    await mkdir7(agentsDir, { recursive: true });
+    const filesWritten = [];
+    const managedOutputs = [];
+    for (const agent of bundle.subagents) {
+      const content = stringify(buildCodexAgentFile(agent));
+      const relativePath = join18(ctx.outputPath, `${agent.name}.toml`);
+      const filePath = join18(ctx.projectRoot, relativePath);
+      await writeFile15(filePath, content, "utf-8");
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content));
+    }
+    return {
+      filesWritten,
+      managedOutputs
+    };
+  }
+};
+// ../adapters/src/writers/codex/hooks.ts
+import { mkdir as mkdir8, writeFile as writeFile16 } from "node:fs/promises";
+import { dirname as dirname4, join as join19 } from "node:path";
+var CodexHooksWriter = {
+  id: "codex-hooks",
+  async write(bundle, ctx) {
+    if (!bundle.hooks) {
+      return { filesWritten: [] };
+    }
+    const hooksPath = join19(ctx.projectRoot, ctx.outputPath);
+    await mkdir8(dirname4(hooksPath), { recursive: true });
+    const content = `${JSON.stringify({ hooks: bundle.hooks }, null, 2)}
+`;
+    await writeFile16(hooksPath, content, "utf-8");
+    return {
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [createManagedOutput(ctx.outputPath, this.id, content)]
+    };
+  }
+};
+// ../adapters/src/writers/codex/toml.ts
+init_src();
+init_dist();
+import { mkdir as mkdir9, writeFile as writeFile17 } from "node:fs/promises";
+import { dirname as dirname5, join as join20 } from "node:path";
 var FILE_HEADER = `# Generated by OmniDev - DO NOT EDIT
 # Run \`omnidev sync\` to regenerate
 
@@ -7151,12 +7614,13 @@ var CodexTomlWriter = {
   id: "codex-toml",
   async write(bundle, ctx) {
     const mcps = collectMcps(bundle);
-    if (mcps.size === 0) {
+    const hasHooks2 = hasHooksInConfig(bundle.hooks);
+    if (mcps.size === 0 && !hasHooks2) {
       return { filesWritten: [] };
     }
-    const configPath = join18(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname4(configPath);
-    await mkdir7(parentDir, { recursive: true });
+    const configPath = join20(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname5(configPath);
+    await mkdir9(parentDir, { recursive: true });
     const mcpServers = {};
     for (const [id, mcp] of mcps) {
       const converted = buildCodexMcpConfig(id, mcp);
@@ -7164,14 +7628,18 @@ var CodexTomlWriter = {
         mcpServers[id] = converted;
       }
     }
-    if (Object.keys(mcpServers).length === 0) {
+    if (Object.keys(mcpServers).length === 0 && !hasHooks2) {
       return { filesWritten: [] };
     }
-    const codexConfig = {
-      mcp_servers: mcpServers
-    };
+    const codexConfig = {};
+    if (hasHooks2) {
+      codexConfig.features = { codex_hooks: true };
+    }
+    if (Object.keys(mcpServers).length > 0) {
+      codexConfig.mcp_servers = mcpServers;
+    }
     const tomlContent = FILE_HEADER + stringify(codexConfig);
-    await writeFile15(configPath, tomlContent, "utf-8");
+    await writeFile17(configPath, tomlContent, "utf-8");
     return {
       filesWritten: [ctx.outputPath],
       managedOutputs: [createManagedOutput(ctx.outputPath, this.id, tomlContent)]
@@ -7186,10 +7654,12 @@ var codexAdapter = {
     { writer: InstructionsMdWriter, outputPath: "AGENTS.md" },
     { writer: SkillsWriter, outputPath: ".codex/skills/" },
     { writer: CommandsAsSkillsWriter, outputPath: ".codex/skills/" },
+    { writer: CodexAgentsWriter, outputPath: ".codex/agents/" },
+    { writer: CodexHooksWriter, outputPath: ".codex/hooks.json" },
     { writer: CodexTomlWriter, outputPath: ".codex/config.toml" }
   ],
   async init(ctx) {
-    const codexDir = join19(ctx.projectRoot, ".codex");
+    const codexDir = join21(ctx.projectRoot, ".codex");
     mkdirSync6(codexDir, { recursive: true });
     return {
       filesCreated: [".codex/"],
@@ -7209,11 +7679,17 @@ var codexAdapter = {
 };
 // ../adapters/src/cursor/index.ts
 import { mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join24 } from "node:path";
+import { join as join26 } from "node:path";
 
 // ../adapters/src/writers/cursor/agents.ts
-import { mkdir as mkdir8, writeFile as writeFile16 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { mkdir as mkdir10, writeFile as writeFile18 } from "node:fs/promises";
+import { join as join22 } from "node:path";
+function getClaudeConfig2(agent) {
+  return {
+    model: agent.claude?.model ?? agent.model,
+    permissionMode: agent.claude?.permissionMode ?? agent.permissionMode
+  };
+}
 function mapModelToCursor(model) {
   if (!model || model === "inherit")
     return "inherit";
@@ -7225,14 +7701,15 @@ function mapModelToCursor(model) {
   return modelMap[model] ?? "inherit";
 }
 function generateFrontmatter2(agent) {
+  const claude2 = getClaudeConfig2(agent);
   const lines = ["---"];
   lines.push(`name: ${agent.name}`);
   lines.push(`description: "${agent.description.replace(/"/g, "\\\"")}"`);
-  const model = mapModelToCursor(agent.model);
+  const model = mapModelToCursor(claude2.model);
   if (model) {
     lines.push(`model: ${model}`);
   }
-  if (agent.permissionMode === "plan") {
+  if (claude2.permissionMode === "plan") {
     lines.push("readonly: true");
   }
   if (agent.isBackground) {
@@ -7245,8 +7722,8 @@ function generateFrontmatter2(agent) {
 var CursorAgentsWriter = {
   id: "cursor-agents",
   async write(bundle, ctx) {
-    const agentsDir = join20(ctx.projectRoot, ctx.outputPath);
-    await mkdir8(agentsDir, { recursive: true });
+    const agentsDir = join22(ctx.projectRoot, ctx.outputPath);
+    await mkdir10(agentsDir, { recursive: true });
     const filesWritten = [];
     const managedOutputs = [];
     for (const agent of bundle.subagents) {
@@ -7254,9 +7731,9 @@ var CursorAgentsWriter = {
       const content = `${frontmatter}
 
 ${agent.systemPrompt}`;
-      const agentPath = join20(agentsDir, `${agent.name}.md`);
-      await writeFile16(agentPath, content, "utf-8");
-      const relativePath = join20(ctx.outputPath, `${agent.name}.md`);
+      const agentPath = join22(agentsDir, `${agent.name}.md`);
+      await writeFile18(agentPath, content, "utf-8");
+      const relativePath = join22(ctx.outputPath, `${agent.name}.md`);
       filesWritten.push(relativePath);
       managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
@@ -7267,13 +7744,13 @@ ${agent.systemPrompt}`;
   }
 };
 // ../adapters/src/writers/cursor/commands.ts
-import { mkdir as mkdir9, writeFile as writeFile17 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { mkdir as mkdir11, writeFile as writeFile19 } from "node:fs/promises";
+import { join as join23 } from "node:path";
 var CursorCommandsWriter = {
   id: "cursor-commands",
   async write(bundle, ctx) {
-    const commandsDir = join21(ctx.projectRoot, ctx.outputPath);
-    await mkdir9(commandsDir, { recursive: true });
+    const commandsDir = join23(ctx.projectRoot, ctx.outputPath);
+    await mkdir11(commandsDir, { recursive: true });
     const filesWritten = [];
     const managedOutputs = [];
     for (const command of bundle.commands) {
@@ -7282,9 +7759,9 @@ var CursorCommandsWriter = {
 ${command.description}
 
 ${command.prompt}`;
-      const commandPath = join21(commandsDir, `${command.name}.md`);
-      await writeFile17(commandPath, content, "utf-8");
-      const relativePath = join21(ctx.outputPath, `${command.name}.md`);
+      const commandPath = join23(commandsDir, `${command.name}.md`);
+      await writeFile19(commandPath, content, "utf-8");
+      const relativePath = join23(ctx.outputPath, `${command.name}.md`);
       filesWritten.push(relativePath);
       managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
@@ -7295,8 +7772,8 @@ ${command.prompt}`;
   }
 };
 // ../adapters/src/writers/cursor/mcp-json.ts
-import { mkdir as mkdir10, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname5, join as join22 } from "node:path";
+import { mkdir as mkdir12, writeFile as writeFile20 } from "node:fs/promises";
+import { dirname as dirname6, join as join24 } from "node:path";
 function buildCursorMcpConfig(mcp) {
   const transport = mcp.transport ?? "stdio";
   if (transport === "http" || transport === "sse") {
@@ -7341,9 +7818,9 @@ var CursorMcpJsonWriter = {
     if (mcps.size === 0) {
       return { filesWritten: [] };
     }
-    const configPath = join22(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname5(configPath);
-    await mkdir10(parentDir, { recursive: true });
+    const configPath = join24(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname6(configPath);
+    await mkdir12(parentDir, { recursive: true });
     const mcpServers = {};
     for (const [id, mcp] of mcps) {
       const converted = buildCursorMcpConfig(mcp);
@@ -7359,7 +7836,7 @@ var CursorMcpJsonWriter = {
     };
     const content = `${JSON.stringify(cursorMcpJson, null, 2)}
 `;
-    await writeFile18(configPath, content, "utf-8");
+    await writeFile20(configPath, content, "utf-8");
     return {
       filesWritten: [ctx.outputPath],
       managedOutputs: [createManagedOutput(ctx.outputPath, this.id, content)]
@@ -7367,19 +7844,19 @@ var CursorMcpJsonWriter = {
   }
 };
 // ../adapters/src/writers/cursor/rules.ts
-import { mkdir as mkdir11, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { mkdir as mkdir13, writeFile as writeFile21 } from "node:fs/promises";
+import { join as join25 } from "node:path";
 var CursorRulesWriter = {
   id: "cursor-rules",
   async write(bundle, ctx) {
-    const rulesDir = join23(ctx.projectRoot, ctx.outputPath);
-    await mkdir11(rulesDir, { recursive: true });
+    const rulesDir = join25(ctx.projectRoot, ctx.outputPath);
+    await mkdir13(rulesDir, { recursive: true });
     const filesWritten = [];
     const managedOutputs = [];
     for (const rule of bundle.rules) {
-      const rulePath = join23(rulesDir, `omnidev-${rule.name}.mdc`);
-      await writeFile19(rulePath, rule.content, "utf-8");
-      const relativePath = join23(ctx.outputPath, `omnidev-${rule.name}.mdc`);
+      const rulePath = join25(rulesDir, `omnidev-${rule.name}.mdc`);
+      await writeFile21(rulePath, rule.content, "utf-8");
+      const relativePath = join25(ctx.outputPath, `omnidev-${rule.name}.mdc`);
       filesWritten.push(relativePath);
       managedOutputs.push(createManagedOutput(relativePath, this.id, rule.content));
     }
@@ -7402,7 +7879,7 @@ var cursorAdapter = {
     { writer: CursorMcpJsonWriter, outputPath: ".cursor/mcp.json" }
   ],
   async init(ctx) {
-    const rulesDir = join24(ctx.projectRoot, ".cursor", "rules");
+    const rulesDir = join26(ctx.projectRoot, ".cursor", "rules");
     mkdirSync7(rulesDir, { recursive: true });
     return {
       filesCreated: [".cursor/rules/"],
@@ -7429,11 +7906,18 @@ var cursorAdapter = {
 };
 // ../adapters/src/opencode/index.ts
 import { mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join27 } from "node:path";
+import { join as join29 } from "node:path";
 
 // ../adapters/src/writers/opencode/agents.ts
-import { mkdir as mkdir12, writeFile as writeFile20 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { mkdir as mkdir14, writeFile as writeFile22 } from "node:fs/promises";
+import { join as join27 } from "node:path";
+function getClaudeConfig3(agent) {
+  return {
+    tools: agent.claude?.tools ?? agent.tools,
+    model: agent.claude?.model ?? agent.model,
+    permissionMode: agent.claude?.permissionMode ?? agent.permissionMode
+  };
+}
 function mapModelToOpenCode(model) {
   if (!model || model === "inherit")
     return;
@@ -7465,9 +7949,10 @@ function mapToolsToOpenCode(tools) {
   return toolsObject;
 }
 function generateFrontmatter3(agent) {
+  const claude2 = getClaudeConfig3(agent);
   const lines = ["---"];
   lines.push(`description: "${agent.description.replace(/"/g, "\\\"")}"`);
-  const modelId = agent.modelId ?? mapModelToOpenCode(agent.model);
+  const modelId = agent.modelId ?? mapModelToOpenCode(claude2.model);
   if (modelId) {
     lines.push(`model: ${modelId}`);
   }
@@ -7483,14 +7968,14 @@ function generateFrontmatter3(agent) {
   if (agent.hidden !== undefined) {
     lines.push(`hidden: ${agent.hidden}`);
   }
-  const toolsObj = agent.toolPermissions ?? mapToolsToOpenCode(agent.tools);
+  const toolsObj = agent.toolPermissions ?? mapToolsToOpenCode(claude2.tools);
   if (toolsObj) {
     lines.push("tools:");
     for (const [tool, enabled] of Object.entries(toolsObj)) {
       lines.push(`  ${tool}: ${enabled}`);
     }
   }
-  const permissions = agent.permissions ?? mapPermissionsToOpenCode(agent.permissionMode);
+  const permissions = agent.permissions ?? mapPermissionsToOpenCode(claude2.permissionMode);
   if (permissions) {
     lines.push("permissions:");
     for (const [key, value] of Object.entries(permissions)) {
@@ -7511,8 +7996,8 @@ function generateFrontmatter3(agent) {
 var OpenCodeAgentsWriter = {
   id: "opencode-agents",
   async write(bundle, ctx) {
-    const agentsDir = join25(ctx.projectRoot, ctx.outputPath);
-    await mkdir12(agentsDir, { recursive: true });
+    const agentsDir = join27(ctx.projectRoot, ctx.outputPath);
+    await mkdir14(agentsDir, { recursive: true });
     const filesWritten = [];
     const managedOutputs = [];
     for (const agent of bundle.subagents) {
@@ -7520,9 +8005,9 @@ var OpenCodeAgentsWriter = {
       const content = `${frontmatter}
 
 ${agent.systemPrompt}`;
-      const agentPath = join25(agentsDir, `${agent.name}.md`);
-      await writeFile20(agentPath, content, "utf-8");
-      const relativePath = join25(ctx.outputPath, `${agent.name}.md`);
+      const agentPath = join27(agentsDir, `${agent.name}.md`);
+      await writeFile22(agentPath, content, "utf-8");
+      const relativePath = join27(ctx.outputPath, `${agent.name}.md`);
       filesWritten.push(relativePath);
       managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
@@ -7533,8 +8018,8 @@ ${agent.systemPrompt}`;
   }
 };
 // ../adapters/src/writers/opencode/commands.ts
-import { mkdir as mkdir13, writeFile as writeFile21 } from "node:fs/promises";
-import { join as join26 } from "node:path";
+import { mkdir as mkdir15, writeFile as writeFile23 } from "node:fs/promises";
+import { join as join28 } from "node:path";
 function generateFrontmatter4(command) {
   const lines = ["---"];
   lines.push(`description: "${command.description.replace(/"/g, "\\\"")}"`);
@@ -7551,8 +8036,8 @@ function generateFrontmatter4(command) {
 var OpenCodeCommandsWriter = {
   id: "opencode-commands",
   async write(bundle, ctx) {
-    const commandsDir = join26(ctx.projectRoot, ctx.outputPath);
-    await mkdir13(commandsDir, { recursive: true });
+    const commandsDir = join28(ctx.projectRoot, ctx.outputPath);
+    await mkdir15(commandsDir, { recursive: true });
     const filesWritten = [];
     const managedOutputs = [];
     for (const command of bundle.commands) {
@@ -7560,9 +8045,9 @@ var OpenCodeCommandsWriter = {
       const content = `${frontmatter}
 
 ${command.prompt}`;
-      const commandPath = join26(commandsDir, `${command.name}.md`);
-      await writeFile21(commandPath, content, "utf-8");
-      const relativePath = join26(ctx.outputPath, `${command.name}.md`);
+      const commandPath = join28(commandsDir, `${command.name}.md`);
+      await writeFile23(commandPath, content, "utf-8");
+      const relativePath = join28(ctx.outputPath, `${command.name}.md`);
       filesWritten.push(relativePath);
       managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
@@ -7583,7 +8068,7 @@ var opencodeAdapter = {
     { writer: OpenCodeCommandsWriter, outputPath: ".opencode/commands/" }
   ],
   async init(ctx) {
-    const opencodeDir = join27(ctx.projectRoot, ".opencode");
+    const opencodeDir = join29(ctx.projectRoot, ".opencode");
     mkdirSync8(opencodeDir, { recursive: true });
     return {
       filesCreated: [".opencode/"],
@@ -7885,7 +8370,7 @@ If the capability name is omitted, it will be inferred from:
 - For GitHub sources: the repository name or last path segment
 
 Claude plugins (.claude-plugin/plugin.json) are automatically wrapped as OmniDev capabilities.
-Hooks defined in hooks.json are also supported and will be synced to .claude/settings.json.
+Hooks defined in hooks.json are also supported and will be synced into OmniDev's hook pipeline.
 
 Examples:
   omnidev add cap my-cap --github expo/skills              # Uses version = "latest"
@@ -8041,8 +8526,8 @@ var addRoutes = buildRouteMap({
 
 // src/commands/capability.ts
 import { existsSync as existsSync25, mkdirSync as mkdirSync9 } from "node:fs";
-import { writeFile as writeFile22 } from "node:fs/promises";
-import { join as join28 } from "node:path";
+import { writeFile as writeFile24 } from "node:fs/promises";
+import { join as join30 } from "node:path";
 import { input } from "@inquirer/prompts";
 init_src();
 import { buildCommand as buildCommand2, buildRouteMap as buildRouteMap2 } from "@stricli/core";
@@ -8262,21 +8747,21 @@ async function runCapabilityNew(flags, capabilityId) {
     const name = toTitleCase(id);
     mkdirSync9(capabilityDir, { recursive: true });
     const capabilityToml = generateCapabilityToml2({ id, name });
-    await writeFile22(join28(capabilityDir, "capability.toml"), capabilityToml, "utf-8");
-    const skillDir = join28(capabilityDir, "skills", "getting-started");
+    await writeFile24(join30(capabilityDir, "capability.toml"), capabilityToml, "utf-8");
+    const skillDir = join30(capabilityDir, "skills", "getting-started");
     mkdirSync9(skillDir, { recursive: true });
-    await writeFile22(join28(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
-    const rulesDir = join28(capabilityDir, "rules");
+    await writeFile24(join30(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
+    const rulesDir = join30(capabilityDir, "rules");
     mkdirSync9(rulesDir, { recursive: true });
-    await writeFile22(join28(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
-    const hooksDir = join28(capabilityDir, "hooks");
+    await writeFile24(join30(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
+    const hooksDir = join30(capabilityDir, "hooks");
     mkdirSync9(hooksDir, { recursive: true });
-    await writeFile22(join28(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
-    await writeFile22(join28(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
-    await writeFile22(join28(capabilityDir, ".gitignore"), generateGitignore(Boolean(flags.programmatic)), "utf-8");
+    await writeFile24(join30(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
+    await writeFile24(join30(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
+    await writeFile24(join30(capabilityDir, ".gitignore"), generateGitignore(Boolean(flags.programmatic)), "utf-8");
     if (flags.programmatic) {
-      await writeFile22(join28(capabilityDir, "package.json"), generatePackageJson(id), "utf-8");
-      await writeFile22(join28(capabilityDir, "index.ts"), generateIndexTs(id, name), "utf-8");
+      await writeFile24(join30(capabilityDir, "package.json"), generatePackageJson(id), "utf-8");
+      await writeFile24(join30(capabilityDir, "index.ts"), generateIndexTs(id, name), "utf-8");
     }
     console.log(`✓ Created capability: ${name}`);
     console.log(`  Location: ${capabilityDir}`);
@@ -8619,7 +9104,7 @@ async function checkCapabilitiesDir() {
 // src/commands/init.ts
 import { exec } from "node:child_process";
 import { existsSync as existsSync27, mkdirSync as mkdirSync10 } from "node:fs";
-import { readFile as readFile21, writeFile as writeFile23 } from "node:fs/promises";
+import { readFile as readFile21, writeFile as writeFile25 } from "node:fs/promises";
 import { promisify as promisify2 } from "node:util";
 init_src();
 import { buildCommand as buildCommand4 } from "@stricli/core";
@@ -8705,7 +9190,7 @@ async function runInit(_flags, providerArg) {
     await setActiveProfile("default");
   }
   if (!existsSync27("OMNI.md")) {
-    await writeFile23("OMNI.md", generateOmniMdTemplate(), "utf-8");
+    await writeFile25("OMNI.md", generateOmniMdTemplate(), "utf-8");
   }
   const config3 = await loadConfig();
   const ctx = {
@@ -8798,7 +9283,7 @@ async function addToGitignore(entriesToAdd, sectionHeader) {
 ${missingEntries.join(`
 `)}
 `;
-  await writeFile23(gitignorePath, content + section, "utf-8");
+  await writeFile25(gitignorePath, content + section, "utf-8");
 }
 async function getTrackedProviderFiles(files) {
   const tracked = [];
@@ -9675,7 +10160,7 @@ async function buildDynamicApp() {
     security: securityRoutes
   };
   debug("Core routes registered", Object.keys(routes));
-  const configPath = join29(process.cwd(), "omni.toml");
+  const configPath = join31(process.cwd(), "omni.toml");
   debug("Checking for config", { configPath, exists: existsSync32(configPath), cwd: process.cwd() });
   if (existsSync32(configPath)) {
     try {
@@ -9752,10 +10237,10 @@ async function loadCapabilityCommands() {
   return commands;
 }
 async function loadCapabilityExport(capability3) {
-  const capabilityPath = join29(process.cwd(), capability3.path);
-  const builtIndexPath = join29(capabilityPath, "dist", "index.js");
-  const jsIndexPath = join29(capabilityPath, "index.js");
-  const tsIndexPath = join29(capabilityPath, "index.ts");
+  const capabilityPath = join31(process.cwd(), capability3.path);
+  const builtIndexPath = join31(capabilityPath, "dist", "index.js");
+  const jsIndexPath = join31(capabilityPath, "index.js");
+  const tsIndexPath = join31(capabilityPath, "index.ts");
   debug(`Checking entry points for '${capability3.id}'`, {
     capabilityPath,
     builtIndexPath,