@omnidev-ai/core 0.10.0 → 0.11.0

package/dist/index.js

@@ -118,58 +118,10 @@ async function loadDocs(capabilityPath, capabilityId) {
   return docs;
 }
 // src/capability/loader.ts
-import { existsSync as existsSync9, readdirSync as readdirSync6 } from "node:fs";
-import { readFile as readFile7 } from "node:fs/promises";
+import { existsSync as existsSync8, readdirSync as readdirSync6 } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 
-// src/config/env.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile3 } from "node:fs/promises";
-var ENV_FILE = ".omni/.env";
-async function loadEnvironment() {
-  const env = {};
-  if (existsSync3(ENV_FILE)) {
-    const content = await readFile3(ENV_FILE, "utf-8");
-    for (const line of content.split(`
-`)) {
-      const trimmed = line.trim();
-      if (trimmed && !trimmed.startsWith("#")) {
-        const eqIndex = trimmed.indexOf("=");
-        if (eqIndex > 0) {
-          const key = trimmed.slice(0, eqIndex).trim();
-          const value = trimmed.slice(eqIndex + 1).trim();
-          const unquotedValue = value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'") ? value.slice(1, -1) : value;
-          env[key] = unquotedValue;
-        }
-      }
-    }
-  }
-  const processEnv = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (value !== undefined) {
-      processEnv[key] = value;
-    }
-  }
-  return { ...env, ...processEnv };
-}
-function validateEnv(declarations, env, capabilityId) {
-  const missing = [];
-  for (const [key, decl] of Object.entries(declarations)) {
-    const declaration = decl;
-    const value = env[key] ?? declaration.default;
-    if (declaration.required && !value) {
-      missing.push(key);
-    }
-  }
-  if (missing.length > 0) {
-    throw new Error(`Missing required environment variable${missing.length > 1 ? "s" : ""} for capability "${capabilityId}": ${missing.join(", ")}. ` + `Set ${missing.length > 1 ? "them" : "it"} in .omni/.env or as environment variable${missing.length > 1 ? "s" : ""}.`);
-  }
-}
-function isSecretEnvVar(key, declarations) {
-  const decl = declarations[key];
-  return decl?.secret === true;
-}
-
 // src/config/parser.ts
 import { parse } from "smol-toml";
 function parseOmniConfig(tomlContent) {
@@ -208,7 +160,7 @@ function parseCapabilityConfig(tomlContent) {
 }
 
 // src/hooks/loader.ts
-import { existsSync as existsSync5, readFileSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync } from "node:fs";
 import { join as join3 } from "node:path";
 import { parse as parseToml } from "smol-toml";
 
@@ -274,7 +226,7 @@ var HOOKS_CONFIG_FILENAME = "hooks.toml";
 var HOOKS_DIRECTORY = "hooks";
 
 // src/hooks/validation.ts
-import { existsSync as existsSync4, statSync } from "node:fs";
+import { existsSync as existsSync3, statSync } from "node:fs";
 import { resolve } from "node:path";
 
 // src/hooks/types.ts
@@ -590,7 +542,7 @@ function validateScriptInCommand(command, basePath, event, matcherIndex, hookInd
       const relativePath = match[1];
       if (relativePath) {
         const fullPath = resolve(basePath, relativePath);
-        if (!existsSync4(fullPath)) {
+        if (!existsSync3(fullPath)) {
           issues.push({
             severity: "error",
             code: "HOOKS_SCRIPT_NOT_FOUND",
@@ -757,7 +709,7 @@ function loadHooksFromCapability(capabilityPath, options) {
   };
   const hooksDir = join3(capabilityPath, HOOKS_DIRECTORY);
   const configPath = join3(hooksDir, HOOKS_CONFIG_FILENAME);
-  if (!existsSync5(configPath)) {
+  if (!existsSync4(configPath)) {
     return {
       config: createEmptyHooksConfig(),
       validation: createEmptyValidationResult(),
@@ -844,7 +796,7 @@ function loadCapabilityHooks(capabilityName, capabilityPath, options) {
 }
 function hasHooks(capabilityPath) {
   const configPath = join3(capabilityPath, HOOKS_DIRECTORY, HOOKS_CONFIG_FILENAME);
-  return existsSync5(configPath);
+  return existsSync4(configPath);
 }
 function getHooksDirectory(capabilityPath) {
   return join3(capabilityPath, HOOKS_DIRECTORY);
@@ -854,12 +806,12 @@ function getHooksConfigPath(capabilityPath) {
 }
 
 // src/capability/rules.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3 } from "node:fs";
-import { readFile as readFile4 } from "node:fs/promises";
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
 import { basename as basename2, join as join4 } from "node:path";
 async function loadRules(capabilityPath, capabilityId) {
   const rulesDir = join4(capabilityPath, "rules");
-  if (!existsSync6(rulesDir)) {
+  if (!existsSync5(rulesDir)) {
     return [];
   }
   const rules = [];
@@ -867,7 +819,7 @@ async function loadRules(capabilityPath, capabilityId) {
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".md")) {
       const rulePath = join4(rulesDir, entry.name);
-      const content = await readFile4(rulePath, "utf-8");
+      const content = await readFile3(rulePath, "utf-8");
       rules.push({
         name: basename2(entry.name, ".md"),
         content: content.trim(),
@@ -879,12 +831,12 @@ async function loadRules(capabilityPath, capabilityId) {
 }
 
 // src/capability/skills.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
+import { existsSync as existsSync6, readdirSync as readdirSync4 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 async function loadSkills(capabilityPath, capabilityId) {
   const skillsDir = join5(capabilityPath, "skills");
-  if (!existsSync7(skillsDir)) {
+  if (!existsSync6(skillsDir)) {
     return [];
   }
   const skills = [];
@@ -892,7 +844,7 @@ async function loadSkills(capabilityPath, capabilityId) {
   for (const entry of entries) {
     if (entry.isDirectory()) {
       const skillPath = join5(skillsDir, entry.name, "SKILL.md");
-      if (existsSync7(skillPath)) {
+      if (existsSync6(skillPath)) {
         const skill = await parseSkillFile(skillPath, capabilityId);
         skills.push(skill);
       }
@@ -901,7 +853,7 @@ async function loadSkills(capabilityPath, capabilityId) {
   return skills;
 }
 async function parseSkillFile(filePath, capabilityId) {
-  const content = await readFile5(filePath, "utf-8");
+  const content = await readFile4(filePath, "utf-8");
   const parsed = parseFrontmatterWithMarkdown(content);
   if (!parsed) {
     throw new Error(`Invalid SKILL.md format at ${filePath}: missing YAML frontmatter`);
@@ -920,12 +872,12 @@ async function parseSkillFile(filePath, capabilityId) {
 }
 
 // src/capability/subagents.ts
-import { existsSync as existsSync8, readdirSync as readdirSync5 } from "node:fs";
-import { readFile as readFile6 } from "node:fs/promises";
+import { existsSync as existsSync7, readdirSync as readdirSync5 } from "node:fs";
+import { readFile as readFile5 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 async function loadSubagents(capabilityPath, capabilityId) {
   const subagentsDir = join6(capabilityPath, "subagents");
-  if (!existsSync8(subagentsDir)) {
+  if (!existsSync7(subagentsDir)) {
     return [];
   }
   const subagents = [];
@@ -933,7 +885,7 @@ async function loadSubagents(capabilityPath, capabilityId) {
   for (const entry of entries) {
     if (entry.isDirectory()) {
       const subagentPath = join6(subagentsDir, entry.name, "SUBAGENT.md");
-      if (existsSync8(subagentPath)) {
+      if (existsSync7(subagentPath)) {
         const subagent = await parseSubagentFile(subagentPath, capabilityId);
         subagents.push(subagent);
       }
@@ -942,7 +894,7 @@ async function loadSubagents(capabilityPath, capabilityId) {
   return subagents;
 }
 async function parseSubagentFile(filePath, capabilityId) {
-  const content = await readFile6(filePath, "utf-8");
+  const content = await readFile5(filePath, "utf-8");
   const parsed = parseFrontmatterWithMarkdown(content);
   if (!parsed) {
     throw new Error(`Invalid SUBAGENT.md format at ${filePath}: missing YAML frontmatter`);
@@ -986,13 +938,13 @@ function parseCommaSeparatedList(value) {
 var CAPABILITIES_DIR = ".omni/capabilities";
 async function discoverCapabilities() {
   const capabilities = [];
-  if (existsSync9(CAPABILITIES_DIR)) {
+  if (existsSync8(CAPABILITIES_DIR)) {
     const entries = readdirSync6(CAPABILITIES_DIR, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const entryPath = join7(CAPABILITIES_DIR, entry.name);
         const configPath = join7(entryPath, "capability.toml");
-        if (existsSync9(configPath)) {
+        if (existsSync8(configPath)) {
           capabilities.push(entryPath);
         }
       }
@@ -1002,13 +954,13 @@ async function discoverCapabilities() {
 }
 async function loadCapabilityConfig(capabilityPath) {
   const configPath = join7(capabilityPath, "capability.toml");
-  const content = await readFile7(configPath, "utf-8");
+  const content = await readFile6(configPath, "utf-8");
   const config = parseCapabilityConfig(content);
   return config;
 }
 async function importCapabilityExports(capabilityPath) {
   const indexPath = join7(capabilityPath, "index.ts");
-  if (!existsSync9(indexPath)) {
+  if (!existsSync8(indexPath)) {
     return {};
   }
   try {
@@ -1028,10 +980,10 @@ If this is a project-specific capability, install dependencies or remove it from
 }
 async function loadTypeDefinitions(capabilityPath) {
   const typesPath = join7(capabilityPath, "types.d.ts");
-  if (!existsSync9(typesPath)) {
+  if (!existsSync8(typesPath)) {
     return;
   }
-  return readFile7(typesPath, "utf-8");
+  return readFile6(typesPath, "utf-8");
 }
 function convertSkillExports(skillExports, capabilityId) {
   return skillExports.map((skillExport) => {
@@ -1208,12 +1160,9 @@ function convertCommandExports(commandExports, capabilityId) {
     return result;
   });
 }
-async function loadCapability(capabilityPath, env) {
+async function loadCapability(capabilityPath) {
   const config = await loadCapabilityConfig(capabilityPath);
   const id = config.capability.id;
-  if (config.env) {
-    validateEnv(config.env, env, id);
-  }
   const exports = await importCapabilityExports(capabilityPath);
   const exportsAny = exports;
   const skills = "skills" in exports && Array.isArray(exportsAny.skills) ? convertSkillExports(exportsAny.skills, id) : await loadSkills(capabilityPath, id);
@@ -1248,13 +1197,12 @@ async function loadCapability(capabilityPath, env) {
   return result;
 }
 // src/config/config.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { readFile as readFile8, writeFile } from "node:fs/promises";
+import { existsSync as existsSync9 } from "node:fs";
+import { readFile as readFile7, writeFile } from "node:fs/promises";
 var CONFIG_PATH = "omni.toml";
 var LOCAL_CONFIG = "omni.local.toml";
 function mergeConfigs(base, override) {
   const merged = { ...base, ...override };
-  merged.env = { ...base.env, ...override.env };
   merged.profiles = { ...base.profiles };
   for (const [name, profile] of Object.entries(override.profiles || {})) {
     merged.profiles[name] = {
@@ -1268,8 +1216,8 @@ function mergeConfigs(base, override) {
   return merged;
 }
 async function loadBaseConfig() {
-  if (existsSync10(CONFIG_PATH)) {
-    const content = await readFile8(CONFIG_PATH, "utf-8");
+  if (existsSync9(CONFIG_PATH)) {
+    const content = await readFile7(CONFIG_PATH, "utf-8");
     return parseOmniConfig(content);
   }
   return {};
@@ -1277,8 +1225,8 @@ async function loadBaseConfig() {
 async function loadConfig() {
   const baseConfig = await loadBaseConfig();
   let localConfig = {};
-  if (existsSync10(LOCAL_CONFIG)) {
-    const content = await readFile8(LOCAL_CONFIG, "utf-8");
+  if (existsSync9(LOCAL_CONFIG)) {
+    const content = await readFile7(LOCAL_CONFIG, "utf-8");
     localConfig = parseOmniConfig(content);
   }
   return mergeConfigs(baseConfig, localConfig);
@@ -1289,22 +1237,6 @@ async function writeConfig(config) {
 }
 function generateConfigToml(config) {
   const lines = [];
-  lines.push("# =============================================================================");
-  lines.push("# OmniDev Configuration");
-  lines.push("# =============================================================================");
-  lines.push("# This file defines your project's capabilities, profiles, and settings.");
-  lines.push("#");
-  lines.push("# Files:");
-  lines.push("#   • omni.toml - Main config (commit to share with team)");
-  lines.push("#   • omni.local.toml - Local overrides (add to .gitignore)");
-  lines.push("#   • omni.lock.toml - Version lock file (commit for reproducibility)");
-  lines.push("#");
-  lines.push("# Quick start:");
-  lines.push("#   1. Add capability sources to [capabilities.sources]");
-  lines.push("#   2. Reference them in your profiles");
-  lines.push("#   3. Run: omnidev sync");
-  lines.push("#   4. Switch profiles: omnidev profile use <name>");
-  lines.push("");
   if (config.providers?.enabled && config.providers.enabled.length > 0) {
     lines.push("# AI providers to enable (claude, codex, or both)");
     lines.push("[providers]");
@@ -1312,23 +1244,6 @@ function generateConfigToml(config) {
     lines.push("");
   }
   lines.push("# =============================================================================");
-  lines.push("# Environment Variables");
-  lines.push("# =============================================================================");
-  lines.push("# Global environment variables available to all capabilities.");
-  lines.push("# Use ${VAR_NAME} syntax to reference shell environment variables.");
-  lines.push("#");
-  if (config.env && Object.keys(config.env).length > 0) {
-    lines.push("[env]");
-    for (const [key, value] of Object.entries(config.env)) {
-      lines.push(`${key} = "${value}"`);
-    }
-  } else {
-    lines.push("# [env]");
-    lines.push('# DATABASE_URL = "${DATABASE_URL}"');
-    lines.push('# API_KEY = "${MY_API_KEY}"');
-  }
-  lines.push("");
-  lines.push("# =============================================================================");
   lines.push("# Capability Sources");
   lines.push("# =============================================================================");
   lines.push("# Fetch capabilities from Git repositories. On sync, these are");
@@ -1382,6 +1297,22 @@ function generateConfigToml(config) {
   }
   lines.push("");
   lines.push("# =============================================================================");
+  lines.push("# Always Enabled Capabilities");
+  lines.push("# =============================================================================");
+  lines.push("# Capabilities that load in ALL profiles, regardless of profile config.");
+  lines.push("# Useful for essential tools needed everywhere.");
+  lines.push("#");
+  const alwaysEnabled = config.capabilities?.always_enabled;
+  if (alwaysEnabled && alwaysEnabled.length > 0) {
+    const caps = alwaysEnabled.map((c) => `"${c}"`).join(", ");
+    lines.push(`[capabilities]`);
+    lines.push(`always_enabled = [${caps}]`);
+  } else {
+    lines.push("# [capabilities]");
+    lines.push('# always_enabled = ["git-tools", "linting"]');
+  }
+  lines.push("");
+  lines.push("# =============================================================================");
   lines.push("# MCP Servers");
   lines.push("# =============================================================================");
   lines.push("# Define MCP servers that automatically become capabilities.");
@@ -1408,10 +1339,8 @@ function generateConfigToml(config) {
         lines.push(`url = "${mcpConfig.url}"`);
       }
       if (mcpConfig.env && Object.keys(mcpConfig.env).length > 0) {
-        lines.push(`[mcps.${name}.env]`);
-        for (const [key, value] of Object.entries(mcpConfig.env)) {
-          lines.push(`${key} = "${value}"`);
-        }
+        const entries = Object.entries(mcpConfig.env).map(([key, value]) => `${key} = "${value}"`);
+        lines.push(`env = { ${entries.join(", ")} }`);
       }
       if (mcpConfig.headers && Object.keys(mcpConfig.headers).length > 0) {
         lines.push(`[mcps.${name}.headers]`);
@@ -1431,24 +1360,10 @@ function generateConfigToml(config) {
     lines.push('# command = "node"');
     lines.push('# args = ["./servers/database.js"]');
     lines.push('# cwd = "./mcp-servers"');
-    lines.push("# [mcps.database.env]");
-    lines.push('# DB_URL = "${DATABASE_URL}"');
+    lines.push('# env = { DB_URL = "${DATABASE_URL}" }');
     lines.push("");
   }
   lines.push("# =============================================================================");
-  lines.push("# Always Enabled Capabilities");
-  lines.push("# =============================================================================");
-  lines.push("# Capabilities that load in ALL profiles, regardless of profile config.");
-  lines.push("# Useful for essential tools needed everywhere.");
-  lines.push("#");
-  if (config.always_enabled_capabilities && config.always_enabled_capabilities.length > 0) {
-    const caps = config.always_enabled_capabilities.map((c) => `"${c}"`).join(", ");
-    lines.push(`always_enabled_capabilities = [${caps}]`);
-  } else {
-    lines.push('# always_enabled_capabilities = ["git-tools", "linting"]');
-  }
-  lines.push("");
-  lines.push("# =============================================================================");
   lines.push("# Profiles");
   lines.push("# =============================================================================");
   lines.push("# Define different capability sets for different workflows.");
@@ -1471,16 +1386,16 @@ function generateConfigToml(config) {
 }
 
 // src/state/active-profile.ts
-import { existsSync as existsSync11, mkdirSync } from "node:fs";
-import { readFile as readFile9, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync10, mkdirSync } from "node:fs";
+import { readFile as readFile8, unlink, writeFile as writeFile2 } from "node:fs/promises";
 var STATE_DIR = ".omni/state";
 var ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
 async function readActiveProfileState() {
-  if (!existsSync11(ACTIVE_PROFILE_PATH)) {
+  if (!existsSync10(ACTIVE_PROFILE_PATH)) {
     return null;
   }
   try {
-    const content = await readFile9(ACTIVE_PROFILE_PATH, "utf-8");
+    const content = await readFile8(ACTIVE_PROFILE_PATH, "utf-8");
     const trimmed = content.trim();
     return trimmed || null;
   } catch {
@@ -1492,27 +1407,22 @@ async function writeActiveProfileState(profileName) {
   await writeFile2(ACTIVE_PROFILE_PATH, profileName, "utf-8");
 }
 async function clearActiveProfileState() {
-  if (existsSync11(ACTIVE_PROFILE_PATH)) {
+  if (existsSync10(ACTIVE_PROFILE_PATH)) {
     await unlink(ACTIVE_PROFILE_PATH);
   }
 }
 
 // src/config/profiles.ts
 async function getActiveProfile() {
-  const stateProfile = await readActiveProfileState();
-  if (stateProfile) {
-    return stateProfile;
-  }
-  const config = await loadConfig();
-  return config.active_profile ?? null;
+  return await readActiveProfileState();
 }
 async function setActiveProfile(name) {
   await writeActiveProfileState(name);
 }
 function resolveEnabledCapabilities(config, profileName) {
-  const profile = profileName ? config.profiles?.[profileName] : config.profiles?.[config.active_profile ?? "default"];
+  const profile = profileName ? config.profiles?.[profileName] : config.profiles?.["default"];
   const profileCapabilities = profile?.capabilities ?? [];
-  const alwaysEnabled = config.always_enabled_capabilities ?? [];
+  const alwaysEnabled = config.capabilities?.always_enabled ?? [];
   const groups = config.capabilities?.groups ?? {};
   const expandCapabilities = (caps) => {
     return caps.flatMap((cap) => {
@@ -1548,12 +1458,12 @@ async function setProfile(profileName, profileConfig) {
 // src/config/capabilities.ts
 async function getEnabledCapabilities() {
   const config = await loadConfig();
-  const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+  const activeProfile = await getActiveProfile() ?? "default";
   return resolveEnabledCapabilities(config, activeProfile);
 }
 async function enableCapability(capabilityId) {
   const config = await loadBaseConfig();
-  const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+  const activeProfile = await getActiveProfile() ?? "default";
   if (!config.profiles) {
     config.profiles = {};
   }
@@ -1567,7 +1477,7 @@ async function enableCapability(capabilityId) {
 }
 async function disableCapability(capabilityId) {
   const config = await loadBaseConfig();
-  const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+  const activeProfile = await getActiveProfile() ?? "default";
   if (!config.profiles?.[activeProfile]) {
     return;
   }
@@ -1666,13 +1576,12 @@ function getEventsWithHooks(config) {
 
 // src/capability/registry.ts
 async function buildCapabilityRegistry() {
-  const env = await loadEnvironment();
   const enabledIds = await getEnabledCapabilities();
   const capabilityPaths = await discoverCapabilities();
   const capabilities = new Map;
   for (const path of capabilityPaths) {
     try {
-      const cap = await loadCapability(path, env);
+      const cap = await loadCapability(path);
       if (enabledIds.includes(cap.id)) {
         capabilities.set(cap.id, cap);
       }
@@ -1703,9 +1612,9 @@ async function buildCapabilityRegistry() {
   };
 }
 // src/capability/sources.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync11 } 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 { cp, mkdir, readdir, readFile as readFile9, rename, rm, stat, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join8 } from "node:path";
 import { parse as parseToml2 } from "smol-toml";
 
@@ -1770,9 +1679,9 @@ function parseFileSourcePath(source) {
 }
 async function readCapabilityIdFromPath(capabilityPath) {
   const tomlPath = join8(capabilityPath, "capability.toml");
-  if (existsSync12(tomlPath)) {
+  if (existsSync11(tomlPath)) {
     try {
-      const content = await readFile10(tomlPath, "utf-8");
+      const content = await readFile9(tomlPath, "utf-8");
       const parsed = parseToml2(content);
       const capability = parsed["capability"];
       if (capability?.["id"] && typeof capability["id"] === "string") {
@@ -1822,11 +1731,11 @@ function getLockFilePath() {
 }
 async function loadLockFile() {
   const lockPath = getLockFilePath();
-  if (!existsSync12(lockPath)) {
+  if (!existsSync11(lockPath)) {
     return { capabilities: {} };
   }
   try {
-    const content = await readFile10(lockPath, "utf-8");
+    const content = await readFile9(lockPath, "utf-8");
     const parsed = parseToml2(content);
     const capabilities = parsed["capabilities"];
     return {
@@ -1915,16 +1824,16 @@ async function fetchRepo(repoPath, ref) {
   return true;
 }
 function hasCapabilityToml(dirPath) {
-  return existsSync12(join8(dirPath, "capability.toml"));
+  return existsSync11(join8(dirPath, "capability.toml"));
 }
 async function shouldWrapDirectory(dirPath) {
-  if (existsSync12(join8(dirPath, ".claude-plugin", "plugin.json"))) {
+  if (existsSync11(join8(dirPath, ".claude-plugin", "plugin.json"))) {
     return true;
   }
   const allDirs = [...SKILL_DIRS, ...AGENT_DIRS, ...COMMAND_DIRS, ...RULE_DIRS, ...DOC_DIRS];
   for (const dirName of allDirs) {
     const checkPath = join8(dirPath, dirName);
-    if (existsSync12(checkPath)) {
+    if (existsSync11(checkPath)) {
       const stats = await stat(checkPath);
       if (stats.isDirectory()) {
         return true;
@@ -1936,7 +1845,7 @@ async function shouldWrapDirectory(dirPath) {
 async function findMatchingDirs(basePath, names) {
   for (const name of names) {
     const dirPath = join8(basePath, name);
-    if (existsSync12(dirPath)) {
+    if (existsSync11(dirPath)) {
       const stats = await stat(dirPath);
       if (stats.isDirectory()) {
         return dirPath;
@@ -1947,7 +1856,7 @@ async function findMatchingDirs(basePath, names) {
 }
 async function findContentItems(dirPath, filePatterns) {
   const items = [];
-  if (!existsSync12(dirPath)) {
+  if (!existsSync11(dirPath)) {
     return items;
   }
   const entries = (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
@@ -1955,7 +1864,7 @@ async function findContentItems(dirPath, filePatterns) {
     const entryPath = join8(dirPath, entry.name);
     if (entry.isDirectory()) {
       for (const pattern of filePatterns) {
-        if (existsSync12(join8(entryPath, pattern))) {
+        if (existsSync11(join8(entryPath, pattern))) {
           items.push({
             name: entry.name,
             path: entryPath,
@@ -1977,11 +1886,11 @@ async function findContentItems(dirPath, filePatterns) {
 }
 async function parsePluginJson(dirPath) {
   const pluginJsonPath = join8(dirPath, ".claude-plugin", "plugin.json");
-  if (!existsSync12(pluginJsonPath)) {
+  if (!existsSync11(pluginJsonPath)) {
     return null;
   }
   try {
-    const content = await readFile10(pluginJsonPath, "utf-8");
+    const content = await readFile9(pluginJsonPath, "utf-8");
     const data = JSON.parse(content);
     const result = {
       name: data.name,
@@ -2002,11 +1911,11 @@ async function parsePluginJson(dirPath) {
 }
 async function readReadmeDescription(dirPath) {
   const readmePath = join8(dirPath, "README.md");
-  if (!existsSync12(readmePath)) {
+  if (!existsSync11(readmePath)) {
     return null;
   }
   try {
-    const content = await readFile10(readmePath, "utf-8");
+    const content = await readFile9(readmePath, "utf-8");
     const lines = content.split(`
 `);
     let description = "";
@@ -2045,7 +1954,7 @@ async function normalizeFolderNames(repoPath) {
   for (const { from, to } of renameMappings) {
     const fromPath = join8(repoPath, from);
     const toPath = join8(repoPath, to);
-    if (existsSync12(fromPath) && !existsSync12(toPath)) {
+    if (existsSync11(fromPath) && !existsSync11(toPath)) {
       try {
         const stats = await stat(fromPath);
         if (stats.isDirectory()) {
@@ -2144,7 +2053,7 @@ async function fetchGitCapabilitySource(id, config, options) {
   let repoPath;
   if (config.path) {
     const tempPath = join8(OMNI_LOCAL, "_temp", `${id}-repo`);
-    if (existsSync12(join8(tempPath, ".git"))) {
+    if (existsSync11(join8(tempPath, ".git"))) {
       if (!options?.silent) {
         console.log(`  Checking ${id}...`);
       }
@@ -2160,17 +2069,17 @@ async function fetchGitCapabilitySource(id, config, options) {
       updated = true;
     }
     const sourcePath = join8(tempPath, config.path);
-    if (!existsSync12(sourcePath)) {
+    if (!existsSync11(sourcePath)) {
       throw new Error(`Path not found in repository: ${config.path}`);
     }
-    if (existsSync12(targetPath)) {
+    if (existsSync11(targetPath)) {
       await rm(targetPath, { recursive: true });
     }
     await mkdir(join8(targetPath, ".."), { recursive: true });
     await cp(sourcePath, targetPath, { recursive: true });
     repoPath = targetPath;
   } else {
-    if (existsSync12(join8(targetPath, ".git"))) {
+    if (existsSync11(join8(targetPath, ".git"))) {
       if (!options?.silent) {
         console.log(`  Checking ${id}...`);
       }
@@ -2209,9 +2118,9 @@ async function fetchGitCapabilitySource(id, config, options) {
   }
   let version = shortCommit(commit);
   const pkgJsonPath = join8(repoPath, "package.json");
-  if (existsSync12(pkgJsonPath)) {
+  if (existsSync11(pkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(await readFile10(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(await readFile9(pkgJsonPath, "utf-8"));
       if (pkgJson.version) {
         version = pkgJson.version;
       }
@@ -2229,29 +2138,29 @@ async function fetchGitCapabilitySource(id, config, options) {
 async function fetchFileCapabilitySource(id, config, options) {
   const sourcePath = parseFileSourcePath(config.source);
   const targetPath = getSourceCapabilityPath(id);
-  if (!existsSync12(sourcePath)) {
+  if (!existsSync11(sourcePath)) {
     throw new Error(`File source not found: ${sourcePath}`);
   }
   const sourceStats = await stat(sourcePath);
   if (!sourceStats.isDirectory()) {
     throw new Error(`File source must be a directory: ${sourcePath}`);
   }
-  if (!existsSync12(join8(sourcePath, "capability.toml"))) {
+  if (!existsSync11(join8(sourcePath, "capability.toml"))) {
     throw new Error(`No capability.toml found in: ${sourcePath}`);
   }
   if (!options?.silent) {
     console.log(`  Copying ${id} from ${sourcePath}...`);
   }
-  if (existsSync12(targetPath)) {
+  if (existsSync11(targetPath)) {
     await rm(targetPath, { recursive: true });
   }
   await mkdir(join8(targetPath, ".."), { recursive: true });
   await cp(sourcePath, targetPath, { recursive: true });
   let version = "local";
   const capTomlPath = join8(targetPath, "capability.toml");
-  if (existsSync12(capTomlPath)) {
+  if (existsSync11(capTomlPath)) {
     try {
-      const content = await readFile10(capTomlPath, "utf-8");
+      const content = await readFile9(capTomlPath, "utf-8");
       const parsed = parseToml2(content);
       const capability = parsed["capability"];
       if (capability?.["version"] && typeof capability["version"] === "string") {
@@ -2342,12 +2251,12 @@ async function generateMcpCapabilityToml(id, mcpConfig, targetPath) {
 }
 async function isGeneratedMcpCapability(capabilityDir) {
   const tomlPath = join8(capabilityDir, "capability.toml");
-  if (!existsSync12(tomlPath)) {
+  if (!existsSync11(tomlPath)) {
     console.warn("no capability.toml found in", capabilityDir);
     return false;
   }
   try {
-    const content = await readFile10(tomlPath, "utf-8");
+    const content = await readFile9(tomlPath, "utf-8");
     const parsed = parseToml2(content);
     const capability = parsed["capability"];
     const metadata = capability?.["metadata"];
@@ -2358,7 +2267,7 @@ async function isGeneratedMcpCapability(capabilityDir) {
 }
 async function cleanupStaleMcpCapabilities(currentMcpIds) {
   const capabilitiesDir = join8(OMNI_LOCAL, "capabilities");
-  if (!existsSync12(capabilitiesDir)) {
+  if (!existsSync11(capabilitiesDir)) {
     return;
   }
   const entries = await readdir(capabilitiesDir, { withFileTypes: true });
@@ -2466,7 +2375,7 @@ async function checkForUpdates(config) {
       continue;
     }
     const gitConfig = sourceConfig;
-    if (!existsSync12(join8(targetPath, ".git"))) {
+    if (!existsSync11(join8(targetPath, ".git"))) {
       updates.push({
         id,
         source: gitConfig.source,
@@ -2502,15 +2411,15 @@ async function checkForUpdates(config) {
   return updates;
 }
 // src/config/provider.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { readFile as readFile11, writeFile as writeFile4 } from "node:fs/promises";
+import { existsSync as existsSync12 } from "node:fs";
+import { readFile as readFile10, writeFile as writeFile4 } from "node:fs/promises";
 import { parse as parse2 } from "smol-toml";
 var PROVIDER_CONFIG_PATH = ".omni/provider.toml";
 async function loadProviderConfig() {
-  if (!existsSync13(PROVIDER_CONFIG_PATH)) {
+  if (!existsSync12(PROVIDER_CONFIG_PATH)) {
     return { provider: "claude" };
   }
-  const content = await readFile11(PROVIDER_CONFIG_PATH, "utf-8");
+  const content = await readFile10(PROVIDER_CONFIG_PATH, "utf-8");
   const parsed = parse2(content);
   return parsed;
 }
@@ -2552,14 +2461,14 @@ function parseProviderFlag(flag) {
   throw new Error(`Invalid provider: ${flag}. Must be 'claude', 'codex', or 'both'.`);
 }
 // src/config/toml-patcher.ts
-import { existsSync as existsSync14 } from "node:fs";
-import { readFile as readFile12, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync13 } from "node:fs";
+import { readFile as readFile11, writeFile as writeFile5 } from "node:fs/promises";
 var CONFIG_PATH2 = "omni.toml";
 async function readConfigFile() {
-  if (!existsSync14(CONFIG_PATH2)) {
+  if (!existsSync13(CONFIG_PATH2)) {
     return "";
   }
-  return readFile12(CONFIG_PATH2, "utf-8");
+  return readFile11(CONFIG_PATH2, "utf-8");
 }
 async function writeConfigFile(content) {
   await writeFile5(CONFIG_PATH2, content, "utf-8");
@@ -2649,10 +2558,8 @@ function formatMcpConfig(name, config) {
     lines.push(`url = "${config.url}"`);
   }
   if (config.env && Object.keys(config.env).length > 0) {
-    lines.push(`[mcps.${name}.env]`);
-    for (const [key, value] of Object.entries(config.env)) {
-      lines.push(`${key} = "${value}"`);
-    }
+    const entries = Object.entries(config.env).map(([key, value]) => `${key} = "${value}"`);
+    lines.push(`env = { ${entries.join(", ")} }`);
   }
   if (config.headers && Object.keys(config.headers).length > 0) {
     lines.push(`[mcps.${name}.headers]`);
@@ -2758,15 +2665,15 @@ function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/mcp-json/manager.ts
-import { existsSync as existsSync15 } from "node:fs";
-import { readFile as readFile13, writeFile as writeFile6 } from "node:fs/promises";
+import { existsSync as existsSync14 } from "node:fs";
+import { readFile as readFile12, writeFile as writeFile6 } from "node:fs/promises";
 var MCP_JSON_PATH = ".mcp.json";
 async function readMcpJson() {
-  if (!existsSync15(MCP_JSON_PATH)) {
+  if (!existsSync14(MCP_JSON_PATH)) {
     return { mcpServers: {} };
   }
   try {
-    const content = await readFile13(MCP_JSON_PATH, "utf-8");
+    const content = await readFile12(MCP_JSON_PATH, "utf-8");
     const parsed = JSON.parse(content);
     return {
       mcpServers: parsed.mcpServers || {}
@@ -2845,19 +2752,19 @@ async function syncMcpJson(capabilities2, previousManifest, options = {}) {
   }
 }
 // src/state/manifest.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync2, rmSync } from "node:fs";
-import { readFile as readFile14, writeFile as writeFile7 } from "node:fs/promises";
+import { existsSync as existsSync15, mkdirSync as mkdirSync2, rmSync } from "node:fs";
+import { readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
 var MANIFEST_PATH = ".omni/state/manifest.json";
 var CURRENT_VERSION = 1;
 async function loadManifest() {
-  if (!existsSync16(MANIFEST_PATH)) {
+  if (!existsSync15(MANIFEST_PATH)) {
     return {
       version: CURRENT_VERSION,
       syncedAt: new Date().toISOString(),
       capabilities: {}
     };
   }
-  const content = await readFile14(MANIFEST_PATH, "utf-8");
+  const content = await readFile13(MANIFEST_PATH, "utf-8");
   return JSON.parse(content);
 }
 async function saveManifest(manifest) {
@@ -2897,14 +2804,14 @@ async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
     }
     for (const skillName of resources.skills) {
       const skillDir = `.claude/skills/${skillName}`;
-      if (existsSync16(skillDir)) {
+      if (existsSync15(skillDir)) {
         rmSync(skillDir, { recursive: true });
         result.deletedSkills.push(skillName);
       }
     }
     for (const ruleName of resources.rules) {
       const rulePath = `.cursor/rules/omnidev-${ruleName}.mdc`;
-      if (existsSync16(rulePath)) {
+      if (existsSync15(rulePath)) {
         rmSync(rulePath);
         result.deletedRules.push(ruleName);
       }
@@ -2913,17 +2820,17 @@ async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
   return result;
 }
 // src/state/providers.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync3 } from "node:fs";
-import { readFile as readFile15, writeFile as writeFile8 } from "node:fs/promises";
+import { existsSync as existsSync16, mkdirSync as mkdirSync3 } from "node:fs";
+import { readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
 var STATE_DIR2 = ".omni/state";
 var PROVIDERS_PATH = `${STATE_DIR2}/providers.json`;
 var DEFAULT_PROVIDERS = ["claude-code"];
 async function readEnabledProviders() {
-  if (!existsSync17(PROVIDERS_PATH)) {
+  if (!existsSync16(PROVIDERS_PATH)) {
     return DEFAULT_PROVIDERS;
   }
   try {
-    const content = await readFile15(PROVIDERS_PATH, "utf-8");
+    const content = await readFile14(PROVIDERS_PATH, "utf-8");
     const state = JSON.parse(content);
     return state.enabled.length > 0 ? state.enabled : DEFAULT_PROVIDERS;
   } catch {
@@ -2955,10 +2862,10 @@ async function isProviderEnabled(providerId) {
 import { spawn as spawn2 } from "node:child_process";
 import { mkdirSync as mkdirSync4 } from "node:fs";
 async function installCapabilityDependencies(silent) {
-  const { existsSync: existsSync18, readdirSync: readdirSync7 } = await import("node:fs");
+  const { existsSync: existsSync17, readdirSync: readdirSync7 } = await import("node:fs");
   const { join: join9 } = await import("node:path");
   const capabilitiesDir = ".omni/capabilities";
-  if (!existsSync18(capabilitiesDir)) {
+  if (!existsSync17(capabilitiesDir)) {
     return;
   }
   const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
@@ -2980,14 +2887,14 @@ async function installCapabilityDependencies(silent) {
     }
     const capabilityPath = join9(capabilitiesDir, entry.name);
     const packageJsonPath = join9(capabilityPath, "package.json");
-    if (!existsSync18(packageJsonPath)) {
+    if (!existsSync17(packageJsonPath)) {
       continue;
     }
     if (!silent) {
       console.log(`Installing dependencies for ${capabilityPath}...`);
     }
     await new Promise((resolve2, reject) => {
-      const useNpmCi = hasNpm && existsSync18(join9(capabilityPath, "package-lock.json"));
+      const useNpmCi = hasNpm && existsSync17(join9(capabilityPath, "package-lock.json"));
       const cmd = hasBun ? "bun" : "npm";
       const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
       const proc = spawn2(cmd, args, {
@@ -3110,38 +3017,17 @@ async function syncAgentConfiguration(options) {
     docCount: bundle.docs.length
   };
 }
-function generateInstructionsContent(rules, docs) {
-  if (rules.length === 0 && docs.length === 0) {
-    return `## Capabilities
-
-No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.`;
-  }
-  let content = `## Capabilities
-
-`;
-  if (docs.length > 0) {
-    content += `### Documentation
-
-`;
-    for (const doc of docs) {
-      content += `#### ${doc.name} (from ${doc.capabilityId})
-
-${doc.content}
-
-`;
-    }
+function generateInstructionsContent(rules, _docs) {
+  if (rules.length === 0) {
+    return "";
   }
-  if (rules.length > 0) {
-    content += `### Rules
+  let content = `## Rules
 
 `;
-    for (const rule of rules) {
-      content += `#### ${rule.name} (from ${rule.capabilityId})
-
-${rule.content}
+  for (const rule of rules) {
+    content += `${rule.content}
 
 `;
-    }
   }
   return content.trim();
 }
@@ -3211,33 +3097,12 @@ TODO: Add example usage
 `;
 }
 function generateRuleTemplate(ruleName) {
-  return `# ${formatDisplayName(ruleName)}
+  return `### ${formatDisplayName(ruleName)}
 
 <!-- Rules are guidelines that the AI agent should follow when working in this project -->
+<!-- Each rule should start with a ### header -->
 
-## Overview
-
-TODO: Describe what this rule enforces or guides.
-
-## Guidelines
-
-- TODO: Add specific guidelines the AI should follow
-- Be specific and actionable
-- Include examples where helpful
-
-## Examples
-
-### Good
-
-\`\`\`
-TODO: Add example of correct behavior
-\`\`\`
-
-### Bad
-
-\`\`\`
-TODO: Add example of incorrect behavior
-\`\`\`
+TODO: Add specific guidelines the AI should follow. Be specific and actionable.
 `;
 }
 function generateHooksTemplate() {
@@ -3293,10 +3158,6 @@ function generateClaudeTemplate() {
   return `# Project Instructions
 
 <!-- Add your project-specific instructions here -->
-
-## OmniDev
-
-<!-- This section is populated during sync with capability rules and docs -->
 `;
 }
 // src/templates/omni.ts
@@ -3349,7 +3210,6 @@ export {
   version,
   validateHooksConfig,
   validateHook,
-  validateEnv,
   transformToOmnidev,
   transformToClaude,
   transformHooksConfig,
@@ -3383,7 +3243,6 @@ export {
   loadManifest,
   loadLockFile,
   loadHooksFromCapability,
-  loadEnvironment,
   loadDocs,
   loadConfig,
   loadCommands,
@@ -3392,7 +3251,6 @@ export {
   loadCapability,
   loadBaseConfig,
   isValidMatcherPattern,
-  isSecretEnvVar,
   isProviderEnabled,
   isPromptHookEvent,
   isMatcherEvent,