@omnidev-ai/cli 0.18.0 → 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
@@ -2638,7 +2697,10 @@ async function loadSkills(capabilityPath, capabilityId, variables) {
         const skillPath = join6(dir, entry.name, "SKILL.md");
         if (existsSync8(skillPath)) {
           const skill = await parseSkillFile(skillPath, capabilityId, resolvedVariables, `skill file ${skillPath}`);
-          skills.push(skill);
+          skills.push({
+            ...skill,
+            sourcePath: join6(dir, entry.name)
+          });
         }
       }
     }
@@ -2665,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";
@@ -2832,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) {
@@ -3524,7 +3690,7 @@ import { existsSync as existsSync13 } from "node:fs";
 import { spawn } from "node:child_process";
 import { cp, mkdir, readdir, readFile as readFile10, rename, rm, stat, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join9 } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 async function spawnCapture(command, args, options) {
   const timeout = options?.timeout ?? 60000;
   return await new Promise((resolve2, reject) => {
@@ -3733,7 +3899,7 @@ function escapeTomlString(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
 }
 async function computeContentHash(dirPath, excludePatterns = CONTENT_HASH_EXCLUDES) {
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   const files = [];
   async function collectFiles(currentPath, relativeTo) {
     const entries = await readdir(currentPath, { withFileTypes: true });
@@ -4758,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",
@@ -4786,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();
@@ -4794,6 +5173,7 @@ var init_hooks = __esm(() => {
   init_variables();
   init_loader();
   init_merger();
+  init_provider_config();
   init_json_loader();
 });
 
@@ -5168,29 +5548,107 @@ var init_mcp_json = __esm(() => {
 });
 
 // ../core/src/state/manifest.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync2, rmSync } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync17, mkdirSync as mkdirSync2, readdirSync as readdirSync7, rmSync } from "node:fs";
+import { dirname, join as join10 } from "node:path";
 import { readFile as readFile14, writeFile as writeFile7 } from "node:fs/promises";
-async function loadManifest() {
-  if (!existsSync17(MANIFEST_PATH)) {
+function createEmptyManifest() {
+  return {
+    version: CURRENT_VERSION,
+    syncedAt: new Date().toISOString(),
+    capabilities: {},
+    providers: {}
+  };
+}
+function normalizeManifest(parsed) {
+  if (parsed.version === CURRENT_VERSION && "providers" in parsed) {
     return {
       version: CURRENT_VERSION,
-      syncedAt: new Date().toISOString(),
-      capabilities: {}
+      syncedAt: parsed.syncedAt,
+      capabilities: parsed.capabilities,
+      providers: parsed.providers ?? {}
     };
   }
+  return {
+    version: CURRENT_VERSION,
+    syncedAt: parsed.syncedAt,
+    capabilities: parsed.capabilities,
+    providers: {}
+  };
+}
+function hashContent2(content) {
+  return createHash3("sha256").update(content).digest("hex");
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function isDirectoryEmpty(path) {
+  return readdirSync7(path).length === 0;
+}
+async function cleanupManagedOutput(output) {
+  const outputPath = join10(process.cwd(), output.path);
+  if (!existsSync17(outputPath)) {
+    return { deleted: false };
+  }
+  if (output.cleanupStrategy === "remove-json-key") {
+    if (!output.jsonKey) {
+      return { deleted: false, reason: `missing jsonKey metadata for ${output.path}` };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile14(outputPath, "utf-8"));
+    } catch {
+      return { deleted: false, reason: `could not parse JSON at ${output.path}` };
+    }
+    const currentValue = parsed[output.jsonKey];
+    if (currentValue === undefined) {
+      return { deleted: false };
+    }
+    if (hashContent2(JSON.stringify(currentValue)) !== output.hash) {
+      return { deleted: false, reason: `managed section changed at ${output.path}` };
+    }
+    delete parsed[output.jsonKey];
+    if (Object.keys(parsed).length === 0) {
+      rmSync(outputPath);
+    } else {
+      await writeFile7(outputPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+    }
+    return { deleted: true };
+  }
+  const currentContent = await readFile14(outputPath, "utf-8");
+  if (hashContent2(currentContent) !== output.hash) {
+    return { deleted: false, reason: `managed file changed at ${output.path}` };
+  }
+  rmSync(outputPath);
+  if (output.cleanupStrategy === "delete-file-and-prune-empty-parents" && output.pruneRoot) {
+    const pruneRoot = join10(process.cwd(), output.pruneRoot);
+    let currentDir = dirname(outputPath);
+    while (normalizePath(currentDir).startsWith(normalizePath(pruneRoot)) && normalizePath(currentDir) !== normalizePath(pruneRoot) && existsSync17(currentDir) && isDirectoryEmpty(currentDir)) {
+      rmSync(currentDir, { recursive: true });
+      currentDir = dirname(currentDir);
+    }
+  }
+  return { deleted: true };
+}
+async function loadManifest() {
+  if (!existsSync17(MANIFEST_PATH)) {
+    return createEmptyManifest();
+  }
   const content = await readFile14(MANIFEST_PATH, "utf-8");
-  return JSON.parse(content);
+  return normalizeManifest(JSON.parse(content));
 }
 async function saveManifest(manifest) {
   mkdirSync2(".omni/state", { recursive: true });
   await writeFile7(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
-function buildManifestFromCapabilities(capabilities2) {
+function buildManifestFromCapabilities(capabilities2, providerOutputs = new Map) {
   const manifest = {
     version: CURRENT_VERSION,
     syncedAt: new Date().toISOString(),
-    capabilities: {}
+    capabilities: {},
+    providers: {}
   };
   for (const cap of capabilities2) {
     const resources = {
@@ -5202,38 +5660,59 @@ function buildManifestFromCapabilities(capabilities2) {
     };
     manifest.capabilities[cap.id] = resources;
   }
+  for (const [providerId, outputs] of providerOutputs) {
+    manifest.providers[providerId] = {
+      outputs: Object.fromEntries(outputs.map((output) => [output.path, output]))
+    };
+  }
   return manifest;
 }
-async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
-  const result = {
+async function cleanupStaleResources(_previousManifest, _currentCapabilityIds) {
+  return {
     deletedSkills: [],
     deletedRules: [],
     deletedCommands: [],
     deletedSubagents: [],
     deletedMcps: []
   };
-  for (const [capId, resources] of Object.entries(previousManifest.capabilities)) {
-    if (currentCapabilityIds.has(capId)) {
-      continue;
+}
+async function cleanupStaleManagedOutputs(previousManifest, nextProviders) {
+  const result = {
+    deletedPaths: [],
+    skippedPaths: []
+  };
+  const claimedPaths = new Set;
+  for (const outputs of nextProviders.values()) {
+    for (const output of outputs) {
+      claimedPaths.add(output.path);
     }
-    for (const skillName of resources.skills) {
-      const skillDir = `.claude/skills/${skillName}`;
-      if (existsSync17(skillDir)) {
-        rmSync(skillDir, { recursive: true });
-        result.deletedSkills.push(skillName);
+  }
+  for (const [providerId, providerState] of Object.entries(previousManifest.providers)) {
+    const nextPaths = new Set((nextProviders.get(providerId) ?? []).map((output) => output.path));
+    for (const output of Object.values(providerState.outputs)) {
+      if (nextPaths.has(output.path)) {
+        continue;
       }
-    }
-    for (const ruleName of resources.rules) {
-      const rulePath = `.cursor/rules/omnidev-${ruleName}.mdc`;
-      if (existsSync17(rulePath)) {
-        rmSync(rulePath);
-        result.deletedRules.push(ruleName);
+      if (claimedPaths.has(output.path)) {
+        continue;
+      }
+      const cleanup = await cleanupManagedOutput(output);
+      if (cleanup.deleted) {
+        result.deletedPaths.push(output.path);
+      } else if (cleanup.reason) {
+        result.skippedPaths.push({
+          path: output.path,
+          reason: cleanup.reason
+        });
       }
     }
   }
   return result;
 }
-var MANIFEST_PATH = ".omni/state/manifest.json", CURRENT_VERSION = 1;
+function getProviderManagedOutputs(manifest, providerId) {
+  return Object.values(manifest.providers[providerId]?.outputs ?? {});
+}
+var MANIFEST_PATH = ".omni/state/manifest.json", CURRENT_VERSION = 2;
 var init_manifest = () => {};
 
 // ../core/src/state/providers.ts
@@ -5382,7 +5861,7 @@ var init_state = __esm(() => {
 // ../core/src/sync.ts
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync20, mkdirSync as mkdirSync5, readFileSync as readFileSync3 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function getDeclaredPackageManager(packageManager) {
   if (typeof packageManager !== "string" || packageManager.trim().length === 0) {
     return;
@@ -5391,8 +5870,8 @@ function getDeclaredPackageManager(packageManager) {
   return atIndex === -1 ? packageManager : packageManager.slice(0, atIndex);
 }
 function resolveCapabilityInstallCommand(capabilityPath, options) {
-  const packageJsonPath = join10(capabilityPath, "package.json");
-  const packageLockPath = join10(capabilityPath, "package-lock.json");
+  const packageJsonPath = join11(capabilityPath, "package.json");
+  const packageLockPath = join11(capabilityPath, "package-lock.json");
   let packageManager;
   try {
     const pkgJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -5410,13 +5889,13 @@ function resolveCapabilityInstallCommand(capabilityPath, options) {
   };
 }
 async function installCapabilityDependencies(silent) {
-  const { readdirSync: readdirSync7 } = await import("node:fs");
+  const { readdirSync: readdirSync8 } = await import("node:fs");
   const { parse: parse2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
   const capabilitiesDir = ".omni/capabilities";
   if (!existsSync20(capabilitiesDir)) {
     return;
   }
-  const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
+  const entries = readdirSync8(capabilitiesDir, { withFileTypes: true });
   async function commandExists(cmd) {
     return await new Promise((resolve2) => {
       const proc = spawn2(cmd, ["--version"], { stdio: "ignore" });
@@ -5432,9 +5911,9 @@ async function installCapabilityDependencies(silent) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const capabilityPath = join10(capabilitiesDir, entry.name);
-    const packageJsonPath = join10(capabilityPath, "package.json");
-    const capabilityTomlPath = join10(capabilityPath, "capability.toml");
+    const capabilityPath = join11(capabilitiesDir, entry.name);
+    const packageJsonPath = join11(capabilityPath, "package.json");
+    const capabilityTomlPath = join11(capabilityPath, "capability.toml");
     if (!existsSync20(packageJsonPath)) {
       continue;
     }
@@ -5472,7 +5951,7 @@ ${stderr}`));
           reject(error);
         });
       });
-      const hasIndexTs = existsSync20(join10(capabilityPath, "index.ts"));
+      const hasIndexTs = existsSync20(join11(capabilityPath, "index.ts"));
       let hasBuildScript = false;
       try {
         const pkgJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -5501,7 +5980,7 @@ ${stderr}`));
           });
         });
       } else if (hasIndexTs && !silent) {
-        const hasBuiltIndex = existsSync20(join10(capabilityPath, "dist", "index.js"));
+        const hasBuiltIndex = existsSync20(join11(capabilityPath, "dist", "index.js"));
         if (!hasBuiltIndex) {
           console.warn(`Warning: Capability at ${capabilityPath} has index.ts but no build script.
   Add a "build" script to package.json (e.g., "build": "tsc") to compile TypeScript.`);
@@ -5572,8 +6051,8 @@ async function syncAgentConfiguration(options) {
   }
   mkdirSync5(".omni", { recursive: true });
   await syncMcpJson(capabilities2, previousManifest);
-  const newManifest = buildManifestFromCapabilities(capabilities2);
-  await saveManifest(newManifest);
+  const enabledProviderIds = new Set(adapters.map((adapter) => String(adapter.id)));
+  const successfulProviderOutputs = new Map;
   if (adapters.length > 0) {
     const config2 = await loadConfig();
     const ctx = {
@@ -5582,12 +6061,33 @@ async function syncAgentConfiguration(options) {
     };
     for (const adapter of adapters) {
       try {
-        await adapter.sync(bundle, ctx);
+        const adapterResult = await adapter.sync(bundle, ctx);
+        successfulProviderOutputs.set(String(adapter.id), adapterResult.managedOutputs ?? []);
       } catch (error) {
         console.error(`Error running ${adapter.displayName} adapter:`, error);
       }
     }
   }
+  const nextProviderOutputs = new Map;
+  if (adapters.length === 0) {
+    for (const providerId of Object.keys(previousManifest.providers)) {
+      nextProviderOutputs.set(providerId, getProviderManagedOutputs(previousManifest, providerId));
+    }
+  } else {
+    for (const providerId of enabledProviderIds) {
+      if (successfulProviderOutputs.has(providerId)) {
+        nextProviderOutputs.set(providerId, successfulProviderOutputs.get(providerId) ?? []);
+        continue;
+      }
+      nextProviderOutputs.set(providerId, getProviderManagedOutputs(previousManifest, providerId));
+    }
+  }
+  const cleanupResult = await cleanupStaleManagedOutputs(previousManifest, nextProviderOutputs);
+  for (const skipped of cleanupResult.skippedPaths) {
+    console.warn(`Warning: skipped cleanup for ${skipped.path} (${skipped.reason})`);
+  }
+  const newManifest = buildManifestFromCapabilities(capabilities2, nextProviderOutputs);
+  await saveManifest(newManifest);
   const result = {
     capabilities: capabilities2.map((c) => c.id),
     skillCount: bundle.skills.length,
@@ -5648,7 +6148,7 @@ var init_types3 = __esm(() => {
 // ../core/src/security/scanner.ts
 import { existsSync as existsSync21 } from "node:fs";
 import { lstat, readdir as readdir2, readFile as readFile17, readlink, realpath } from "node:fs/promises";
-import { join as join11, relative, resolve as resolve2 } from "node:path";
+import { join as join12, relative, resolve as resolve2 } from "node:path";
 async function scanFileForUnicode(filePath, relativePath) {
   const findings = [];
   try {
@@ -5835,7 +6335,7 @@ async function scanFileForNetworkRequests(filePath, relativePath) {
 async function checkSymlink(symlinkPath, relativePath, capabilityRoot) {
   try {
     const linkTarget = await readlink(symlinkPath);
-    const resolvedTarget = resolve2(join11(symlinkPath, "..", linkTarget));
+    const resolvedTarget = resolve2(join12(symlinkPath, "..", linkTarget));
     const normalizedRoot = await realpath(capabilityRoot);
     if (linkTarget.startsWith("/")) {
       return {
@@ -5882,7 +6382,7 @@ async function scanCapability(capabilityId, capabilityPath, settings = DEFAULT_S
   async function scanDirectory(dirPath) {
     const entries = await readdir2(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join11(dirPath, entry.name);
+      const fullPath = join12(dirPath, entry.name);
       const relativePath = relative(capabilityPath, fullPath);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "__pycache__") {
         continue;
@@ -6245,7 +6745,9 @@ var init_security = __esm(() => {
 
 // ../core/src/templates/agents.ts
 function generateAgentsTemplate() {
-  return `# Project Instructions
+  return `> IMPORTANT: Do not edit this file directly. Edit \`OMNI.md\` instead. This file is a generated copy of \`OMNI.md\` and is ephemeral. Any persistent change must be made in \`OMNI.md\`.
+
+# Project Instructions
 
 <!-- Add your project-specific instructions here -->
 
@@ -6372,7 +6874,9 @@ function formatDisplayName(kebabCase) {
 
 // ../core/src/templates/claude.ts
 function generateClaudeTemplate() {
-  return `# Project Instructions
+  return `> IMPORTANT: Do not edit this file directly. Edit \`OMNI.md\` instead. This file is a generated copy of \`OMNI.md\` and is ephemeral. Any persistent change must be made in \`OMNI.md\`.
+
+# Project Instructions
 
 <!-- Add your project-specific instructions here -->
 `;
@@ -6442,6 +6946,7 @@ __export(exports_src, {
   saveManifest: () => saveManifest,
   saveLockFile: () => saveLockFile,
   resolveEnabledCapabilities: () => resolveEnabledCapabilities,
+  resolveCapabilityRootInValue: () => resolveCapabilityRootInValue,
   resolveCapabilityRootInConfig: () => resolveCapabilityRootInConfig,
   resolveCapabilityRoot: () => resolveCapabilityRoot,
   resolveCapabilityInstallCommand: () => resolveCapabilityInstallCommand,
@@ -6492,10 +6997,12 @@ __export(exports_src, {
   isFileSourceConfig: () => isFileSourceConfig,
   isFileSource: () => isFileSource,
   installCapabilityDependencies: () => installCapabilityDependencies,
+  hasHooksInConfig: () => hasHooksInConfig,
   hasHooks: () => hasHooks,
   hasAnyHooks: () => hasAnyHooks,
   getVersion: () => getVersion,
   getSourceCapabilityPath: () => getSourceCapabilityPath,
+  getProviderManagedOutputs: () => getProviderManagedOutputs,
   getLockFilePath: () => getLockFilePath,
   getHooksDirectory: () => getHooksDirectory,
   getHooksConfigPath: () => getHooksConfigPath,
@@ -6529,10 +7036,12 @@ __export(exports_src, {
   countHooks: () => countHooks,
   containsOmnidevVariables: () => containsOmnidevVariables,
   containsClaudeVariables: () => containsClaudeVariables,
+  composeHooksForProvider: () => composeHooksForProvider,
   clearCapabilityAllows: () => clearCapabilityAllows,
   clearAllSecurityAllows: () => clearAllSecurityAllows,
   clearActiveProfileState: () => clearActiveProfileState,
   cleanupStaleResources: () => cleanupStaleResources,
+  cleanupStaleManagedOutputs: () => cleanupStaleManagedOutputs,
   checkVersionMismatch: () => checkVersionMismatch,
   checkForUpdates: () => checkForUpdates,
   buildSyncBundle: () => buildSyncBundle,
@@ -6576,15 +7085,33 @@ var init_src = __esm(() => {
 import { run } from "@stricli/core";
 
 // src/lib/dynamic-app.ts
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join28 } from "node:path";
+import { join as join31 } from "node:path";
 import { buildApplication, buildRouteMap as buildRouteMap7 } from "@stricli/core";
 
 // src/commands/add.ts
 import { existsSync as existsSync24 } from "node:fs";
 import { basename as basename5, resolve as resolve3 } from "node:path";
 
+// ../adapters/src/writers/generic/managed-outputs.ts
+import { createHash } from "node:crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function trimTrailingSlash(path) {
+  return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function createManagedOutput(path, writerId, content, options) {
+  return {
+    path,
+    writerId,
+    hash: hashContent(content),
+    cleanupStrategy: options?.cleanupStrategy ?? "delete-file",
+    ...options?.pruneRoot ? { pruneRoot: trimTrailingSlash(options.pruneRoot) } : {},
+    ...options?.jsonKey ? { jsonKey: options.jsonKey } : {}
+  };
+}
 // ../adapters/src/writers/generic/executor.ts
 async function executeWriters(writerConfigs, bundle, projectRoot, providerId) {
   const seen = new Set;
@@ -6600,6 +7127,7 @@ async function executeWriters(writerConfigs, bundle, projectRoot, providerId) {
     uniqueConfigs.push(config);
   }
   const allFilesWritten = [];
+  const allManagedOutputs = [];
   for (const config of uniqueConfigs) {
     const result = await config.writer.write(bundle, {
       outputPath: config.outputPath,
@@ -6607,27 +7135,29 @@ async function executeWriters(writerConfigs, bundle, projectRoot, providerId) {
       ...providerId ? { providerId } : {}
     });
     allFilesWritten.push(...result.filesWritten);
+    allManagedOutputs.push(...result.managedOutputs ?? []);
   }
   return {
     filesWritten: allFilesWritten,
-    deduplicatedCount
+    deduplicatedCount,
+    managedOutputs: allManagedOutputs
   };
 }
 // ../adapters/src/writers/generic/hooks.ts
 init_src();
 import { existsSync as existsSync22 } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile18, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname, join as join12 } from "node:path";
+import { dirname as dirname2, join as join13 } from "node:path";
 var HooksWriter = {
   id: "hooks",
   async write(bundle, ctx) {
     if (!bundle.hooks) {
       return { filesWritten: [] };
     }
-    const settingsPath = join12(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname(settingsPath);
-    await mkdir2(parentDir, { recursive: true });
     const claudeHooks = transformHooksConfig(bundle.hooks, "toClaude");
+    const settingsPath = join13(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname2(settingsPath);
+    await mkdir2(parentDir, { recursive: true });
     let existingSettings = {};
     if (existsSync22(settingsPath)) {
       try {
@@ -6644,14 +7174,20 @@ var HooksWriter = {
     await writeFile10(settingsPath, `${JSON.stringify(newSettings, null, 2)}
 `, "utf-8");
     return {
-      filesWritten: [ctx.outputPath]
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [
+        createManagedOutput(ctx.outputPath, this.id, JSON.stringify(claudeHooks), {
+          cleanupStrategy: "remove-json-key",
+          jsonKey: "hooks"
+        })
+      ]
     };
   }
 };
 // ../adapters/src/writers/generic/instructions-md.ts
 import { existsSync as existsSync23 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile19, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname2, join as join13 } from "node:path";
+import { dirname as dirname3, join as join14 } from "node:path";
 
 // ../adapters/src/writers/generic/omni-md.ts
 init_src();
@@ -6673,20 +7209,32 @@ function renderOmniMdForProvider(content, providerId) {
 }
 
 // ../adapters/src/writers/generic/instructions-md.ts
+function getGeneratedCopyNotice(outputPath) {
+  if (outputPath !== "AGENTS.md" && outputPath !== "CLAUDE.md") {
+    return "";
+  }
+  return "> IMPORTANT: Do not edit this file directly. Edit `OMNI.md` instead. This file is a generated copy of `OMNI.md` and is ephemeral. Any persistent change must be made in `OMNI.md`.";
+}
 var InstructionsMdWriter = {
   id: "instructions-md",
   async write(bundle, ctx) {
-    const outputFullPath = join13(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname2(outputFullPath);
+    const outputFullPath = join14(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname3(outputFullPath);
     if (parentDir !== ctx.projectRoot) {
       await mkdir3(parentDir, { recursive: true });
     }
-    const omniMdPath = join13(ctx.projectRoot, "OMNI.md");
+    const omniMdPath = join14(ctx.projectRoot, "OMNI.md");
     let omniMdContent = "";
     if (existsSync23(omniMdPath)) {
       omniMdContent = renderOmniMdForProvider(await readFile19(omniMdPath, "utf-8"), ctx.providerId);
     }
     let content = omniMdContent;
+    const generatedCopyNotice = getGeneratedCopyNotice(ctx.outputPath);
+    if (generatedCopyNotice) {
+      content = content ? `${generatedCopyNotice}
+
+${content}` : generatedCopyNotice;
+    }
     if (bundle.instructionsContent) {
       content += `
 
@@ -6695,23 +7243,30 @@ ${bundle.instructionsContent}
     }
     await writeFile11(outputFullPath, content, "utf-8");
     return {
-      filesWritten: [ctx.outputPath]
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [createManagedOutput(ctx.outputPath, this.id, content)]
     };
   }
 };
 // ../adapters/src/writers/generic/skills.ts
-import { mkdir as mkdir4, writeFile as writeFile12 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { cp as cp2, mkdir as mkdir4, readdir as readdir3, rm as rm2, writeFile as writeFile12 } from "node:fs/promises";
+import { join as join15, relative as relative2 } from "node:path";
 var SkillsWriter = {
   id: "skills",
   async write(bundle, ctx) {
-    const skillsDir = join14(ctx.projectRoot, ctx.outputPath);
+    const skillsDir = join15(ctx.projectRoot, ctx.outputPath);
     await mkdir4(skillsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const skill of bundle.skills) {
-      const skillDir = join14(skillsDir, skill.name);
-      await mkdir4(skillDir, { recursive: true });
-      const skillPath = join14(skillDir, "SKILL.md");
+      const skillDir = join15(skillsDir, skill.name);
+      await rm2(skillDir, { recursive: true, force: true });
+      if (skill.sourcePath) {
+        await cp2(skill.sourcePath, skillDir, { recursive: true });
+      } else {
+        await mkdir4(skillDir, { recursive: true });
+      }
+      const skillPath = join15(skillDir, "SKILL.md");
       const content = `---
 name: ${skill.name}
 description: "${skill.description}"
@@ -6719,16 +7274,43 @@ description: "${skill.description}"
 
 ${skill.instructions}`;
       await writeFile12(skillPath, content, "utf-8");
-      filesWritten.push(join14(ctx.outputPath, skill.name, "SKILL.md"));
+      const relativePaths = skill.sourcePath ? await listRelativeFiles(skillDir) : ["SKILL.md"];
+      for (const relativeFile of relativePaths) {
+        filesWritten.push(join15(ctx.outputPath, skill.name, relativeFile));
+      }
+      const relativePath = join15(ctx.outputPath, skill.name, "SKILL.md");
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content, {
+        cleanupStrategy: "delete-file-and-prune-empty-parents",
+        pruneRoot: ctx.outputPath
+      }));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
+async function listRelativeFiles(basePath) {
+  const files = [];
+  const entries = await readdir3(basePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = join15(basePath, entry.name);
+    if (entry.isDirectory()) {
+      const nestedFiles = await listRelativeFiles(entryPath);
+      for (const nestedFile of nestedFiles) {
+        files.push(relative2(basePath, join15(entryPath, nestedFile)));
+      }
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(entry.name);
+    }
+  }
+  return files.sort((a, b) => a.localeCompare(b));
+}
 // ../adapters/src/writers/generic/commands-as-skills.ts
 import { mkdir as mkdir5, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function generateSkillFrontmatter(command) {
   const lines = ["---"];
   lines.push(`name: ${command.name}`);
@@ -6743,22 +7325,29 @@ function generateSkillFrontmatter(command) {
 var CommandsAsSkillsWriter = {
   id: "commands-as-skills",
   async write(bundle, ctx) {
-    const skillsDir = join15(ctx.projectRoot, ctx.outputPath);
+    const skillsDir = join16(ctx.projectRoot, ctx.outputPath);
     await mkdir5(skillsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const command of bundle.commands) {
-      const commandSkillDir = join15(skillsDir, command.name);
+      const commandSkillDir = join16(skillsDir, command.name);
       await mkdir5(commandSkillDir, { recursive: true });
       const frontmatter = generateSkillFrontmatter(command);
       const content = `${frontmatter}
 
 ${command.prompt}`;
-      const skillPath = join15(commandSkillDir, "SKILL.md");
+      const skillPath = join16(commandSkillDir, "SKILL.md");
       await writeFile13(skillPath, content, "utf-8");
-      filesWritten.push(join15(ctx.outputPath, command.name, "SKILL.md"));
+      const relativePath = join16(ctx.outputPath, command.name, "SKILL.md");
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content, {
+        cleanupStrategy: "delete-file-and-prune-empty-parents",
+        pruneRoot: ctx.outputPath
+      }));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
@@ -6802,34 +7391,47 @@ 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;
 }
 
 // ../adapters/src/writers/claude/agents.ts
 import { mkdir as mkdir6, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+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(`
@@ -6838,20 +7440,24 @@ function generateFrontmatter(agent) {
 var ClaudeAgentsWriter = {
   id: "claude-agents",
   async write(bundle, ctx) {
-    const agentsDir = join16(ctx.projectRoot, ctx.outputPath);
+    const agentsDir = join17(ctx.projectRoot, ctx.outputPath);
     await mkdir6(agentsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const agent of bundle.subagents) {
       const frontmatter = generateFrontmatter(agent);
       const content = `${frontmatter}
 
 ${agent.systemPrompt}`;
-      const agentPath = join16(agentsDir, `${agent.name}.md`);
+      const agentPath = join17(agentsDir, `${agent.name}.md`);
       await writeFile14(agentPath, content, "utf-8");
-      filesWritten.push(join16(ctx.outputPath, `${agent.name}.md`));
+      const relativePath = join17(ctx.outputPath, `${agent.name}.md`);
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
@@ -6878,18 +7484,89 @@ var claudeCodeAdapter = {
     const result = await executeWriters(this.writers, providerBundle, ctx.projectRoot, providerId);
     return {
       filesWritten: result.filesWritten,
-      filesDeleted: []
+      filesDeleted: [],
+      managedOutputs: result.managedOutputs
     };
   }
 };
 // ../adapters/src/codex/index.ts
 import { mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join18 } 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 dirname3, join as join17 } 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
 
@@ -6937,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 = join17(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname3(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);
@@ -6950,16 +7628,21 @@ 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]
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [createManagedOutput(ctx.outputPath, this.id, tomlContent)]
     };
   }
 };
@@ -6971,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 = join18(ctx.projectRoot, ".codex");
+    const codexDir = join21(ctx.projectRoot, ".codex");
     mkdirSync6(codexDir, { recursive: true });
     return {
       filesCreated: [".codex/"],
@@ -6987,17 +7672,24 @@ var codexAdapter = {
     const result = await executeWriters(this.writers, providerBundle, ctx.projectRoot, providerId);
     return {
       filesWritten: result.filesWritten,
-      filesDeleted: []
+      filesDeleted: [],
+      managedOutputs: result.managedOutputs
     };
   }
 };
 // ../adapters/src/cursor/index.ts
 import { mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join23 } 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 join19 } 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";
@@ -7009,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) {
@@ -7029,50 +7722,58 @@ function generateFrontmatter2(agent) {
 var CursorAgentsWriter = {
   id: "cursor-agents",
   async write(bundle, ctx) {
-    const agentsDir = join19(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) {
       const frontmatter = generateFrontmatter2(agent);
       const content = `${frontmatter}
 
 ${agent.systemPrompt}`;
-      const agentPath = join19(agentsDir, `${agent.name}.md`);
-      await writeFile16(agentPath, content, "utf-8");
-      filesWritten.push(join19(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));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
 // ../adapters/src/writers/cursor/commands.ts
-import { mkdir as mkdir9, writeFile as writeFile17 } from "node:fs/promises";
-import { join as join20 } 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 = join20(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) {
       const content = `# ${command.name}
 
 ${command.description}
 
 ${command.prompt}`;
-      const commandPath = join20(commandsDir, `${command.name}.md`);
-      await writeFile17(commandPath, content, "utf-8");
-      filesWritten.push(join20(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));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
 // ../adapters/src/writers/cursor/mcp-json.ts
-import { mkdir as mkdir10, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname4, join as join21 } 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") {
@@ -7117,9 +7818,9 @@ var CursorMcpJsonWriter = {
     if (mcps.size === 0) {
       return { filesWritten: [] };
     }
-    const configPath = join21(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname4(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);
@@ -7133,29 +7834,35 @@ var CursorMcpJsonWriter = {
     const cursorMcpJson = {
       mcpServers
     };
-    await writeFile18(configPath, `${JSON.stringify(cursorMcpJson, null, 2)}
-`, "utf-8");
+    const content = `${JSON.stringify(cursorMcpJson, null, 2)}
+`;
+    await writeFile20(configPath, content, "utf-8");
     return {
-      filesWritten: [ctx.outputPath]
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [createManagedOutput(ctx.outputPath, this.id, content)]
     };
   }
 };
 // ../adapters/src/writers/cursor/rules.ts
-import { mkdir as mkdir11, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join22 } 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 = join22(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 = join22(rulesDir, `omnidev-${rule.name}.mdc`);
-      await writeFile19(rulePath, rule.content, "utf-8");
-      filesWritten.push(join22(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));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
@@ -7172,7 +7879,7 @@ var cursorAdapter = {
     { writer: CursorMcpJsonWriter, outputPath: ".cursor/mcp.json" }
   ],
   async init(ctx) {
-    const rulesDir = join23(ctx.projectRoot, ".cursor", "rules");
+    const rulesDir = join26(ctx.projectRoot, ".cursor", "rules");
     mkdirSync7(rulesDir, { recursive: true });
     return {
       filesCreated: [".cursor/rules/"],
@@ -7192,17 +7899,25 @@ var cursorAdapter = {
       filesWritten: [
         ...new Set([...instructionsResult.filesWritten, ...cursorResult.filesWritten])
       ],
-      filesDeleted: []
+      filesDeleted: [],
+      managedOutputs: [...instructionsResult.managedOutputs, ...cursorResult.managedOutputs]
     };
   }
 };
 // ../adapters/src/opencode/index.ts
 import { mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join26 } 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 join24 } 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;
@@ -7234,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}`);
   }
@@ -7252,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)) {
@@ -7280,26 +7996,30 @@ function generateFrontmatter3(agent) {
 var OpenCodeAgentsWriter = {
   id: "opencode-agents",
   async write(bundle, ctx) {
-    const agentsDir = join24(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) {
       const frontmatter = generateFrontmatter3(agent);
       const content = `${frontmatter}
 
 ${agent.systemPrompt}`;
-      const agentPath = join24(agentsDir, `${agent.name}.md`);
-      await writeFile20(agentPath, content, "utf-8");
-      filesWritten.push(join24(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));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
 // ../adapters/src/writers/opencode/commands.ts
-import { mkdir as mkdir13, writeFile as writeFile21 } from "node:fs/promises";
-import { join as join25 } 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, "\\\"")}"`);
@@ -7316,20 +8036,24 @@ function generateFrontmatter4(command) {
 var OpenCodeCommandsWriter = {
   id: "opencode-commands",
   async write(bundle, ctx) {
-    const commandsDir = join25(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) {
       const frontmatter = generateFrontmatter4(command);
       const content = `${frontmatter}
 
 ${command.prompt}`;
-      const commandPath = join25(commandsDir, `${command.name}.md`);
-      await writeFile21(commandPath, content, "utf-8");
-      filesWritten.push(join25(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));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
@@ -7344,7 +8068,7 @@ var opencodeAdapter = {
     { writer: OpenCodeCommandsWriter, outputPath: ".opencode/commands/" }
   ],
   async init(ctx) {
-    const opencodeDir = join26(ctx.projectRoot, ".opencode");
+    const opencodeDir = join29(ctx.projectRoot, ".opencode");
     mkdirSync8(opencodeDir, { recursive: true });
     return {
       filesCreated: [".opencode/"],
@@ -7357,7 +8081,8 @@ var opencodeAdapter = {
     const result = await executeWriters(this.writers, providerBundle, ctx.projectRoot, providerId);
     return {
       filesWritten: result.filesWritten,
-      filesDeleted: []
+      filesDeleted: [],
+      managedOutputs: result.managedOutputs
     };
   }
 };
@@ -7645,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"
@@ -7801,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 join27 } 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";
@@ -8022,21 +8747,21 @@ async function runCapabilityNew(flags, capabilityId) {
     const name = toTitleCase(id);
     mkdirSync9(capabilityDir, { recursive: true });
     const capabilityToml = generateCapabilityToml2({ id, name });
-    await writeFile22(join27(capabilityDir, "capability.toml"), capabilityToml, "utf-8");
-    const skillDir = join27(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(join27(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
-    const rulesDir = join27(capabilityDir, "rules");
+    await writeFile24(join30(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
+    const rulesDir = join30(capabilityDir, "rules");
     mkdirSync9(rulesDir, { recursive: true });
-    await writeFile22(join27(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
-    const hooksDir = join27(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(join27(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
-    await writeFile22(join27(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
-    await writeFile22(join27(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(join27(capabilityDir, "package.json"), generatePackageJson(id), "utf-8");
-      await writeFile22(join27(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}`);
@@ -8379,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";
@@ -8465,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 = {
@@ -8558,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 = [];
@@ -8691,6 +9416,8 @@ async function runProfileSet(profileName) {
 }
 
 // src/commands/provider.ts
+import { existsSync as existsSync29 } from "node:fs";
+import { readFile as readFile22 } from "node:fs/promises";
 init_src();
 import { buildCommand as buildCommand6, buildRouteMap as buildRouteMap4 } from "@stricli/core";
 async function runProviderList() {
@@ -8724,6 +9451,7 @@ async function runProviderEnable(_flags, providerId) {
   }
   await enableProvider(providerId);
   console.log(`✓ Enabled provider: ${adapter.displayName}`);
+  await maybeRemindAboutProviderGitignore(providerId);
   const enabledAdapters = await getEnabledAdapters();
   await syncAgentConfiguration({ silent: false, adapters: enabledAdapters });
 }
@@ -8804,10 +9532,33 @@ var providerRoutes = buildRouteMap4({
     brief: "Manage AI provider adapters"
   }
 });
+async function maybeRemindAboutProviderGitignore(providerId) {
+  const missingEntries = await getMissingGitignoreEntries(getProviderGitignoreFiles([providerId]));
+  if (missingEntries.length === 0) {
+    return;
+  }
+  console.log("");
+  console.log("Also update your .gitignore to ignore provider files if you do not want to commit them:");
+  for (const entry of missingEntries) {
+    console.log(`  - ${entry}`);
+  }
+}
+async function getMissingGitignoreEntries(entries) {
+  if (entries.length === 0) {
+    return [];
+  }
+  let content = "";
+  if (existsSync29(".gitignore")) {
+    content = await readFile22(".gitignore", "utf-8");
+  }
+  const lines = new Set(content.split(`
+`).map((line) => line.trim()));
+  return [...new Set(entries)].filter((entry) => !lines.has(entry));
+}
 
 // src/commands/security.ts
 init_src();
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 import { buildCommand as buildCommand7, buildRouteMap as buildRouteMap5 } from "@stricli/core";
 var VALID_FINDING_TYPES = [
   "unicode_bidi",
@@ -8926,7 +9677,7 @@ function formatFindingsWithHints(summary) {
 }
 async function runSecurityIssues(flags = {}) {
   try {
-    if (!existsSync29("omni.toml")) {
+    if (!existsSync30("omni.toml")) {
       console.log("No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -9181,7 +9932,7 @@ var securityRoutes = buildRouteMap5({
 });
 
 // src/commands/sync.ts
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync31 } from "node:fs";
 init_src();
 import { buildCommand as buildCommand8 } from "@stricli/core";
 var PROVIDERS_STATE_PATH = ".omni/state/providers.json";
@@ -9199,7 +9950,7 @@ async function runSync() {
     const config3 = await loadConfig();
     const activeProfile = await getActiveProfile() ?? "default";
     let adapters = await getEnabledAdapters();
-    if (!existsSync30(PROVIDERS_STATE_PATH) || adapters.length === 0) {
+    if (!existsSync31(PROVIDERS_STATE_PATH) || adapters.length === 0) {
       console.log("No providers configured yet. Select your provider(s):");
       const providerIds = await promptForProviders();
       await writeEnabledProviders(providerIds);
@@ -9409,9 +10160,9 @@ async function buildDynamicApp() {
     security: securityRoutes
   };
   debug("Core routes registered", Object.keys(routes));
-  const configPath = join28(process.cwd(), "omni.toml");
-  debug("Checking for config", { configPath, exists: existsSync31(configPath), cwd: process.cwd() });
-  if (existsSync31(configPath)) {
+  const configPath = join31(process.cwd(), "omni.toml");
+  debug("Checking for config", { configPath, exists: existsSync32(configPath), cwd: process.cwd() });
+  if (existsSync32(configPath)) {
     try {
       debug("Loading capability commands...");
       const capabilityCommands = await loadCapabilityCommands();
@@ -9486,25 +10237,25 @@ async function loadCapabilityCommands() {
   return commands;
 }
 async function loadCapabilityExport(capability3) {
-  const capabilityPath = join28(process.cwd(), capability3.path);
-  const builtIndexPath = join28(capabilityPath, "dist", "index.js");
-  const jsIndexPath = join28(capabilityPath, "index.js");
-  const tsIndexPath = join28(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,
-    builtExists: existsSync31(builtIndexPath),
+    builtExists: existsSync32(builtIndexPath),
     jsIndexPath,
-    jsExists: existsSync31(jsIndexPath),
+    jsExists: existsSync32(jsIndexPath),
     tsIndexPath,
-    tsExists: existsSync31(tsIndexPath)
+    tsExists: existsSync32(tsIndexPath)
   });
   let indexPath = null;
-  if (existsSync31(builtIndexPath)) {
+  if (existsSync32(builtIndexPath)) {
     indexPath = builtIndexPath;
-  } else if (existsSync31(jsIndexPath)) {
+  } else if (existsSync32(jsIndexPath)) {
     indexPath = jsIndexPath;
-  } else if (existsSync31(tsIndexPath)) {
+  } else if (existsSync32(tsIndexPath)) {
     indexPath = tsIndexPath;
   }
   if (!indexPath) {