@omnidev-ai/core 0.9.0 → 0.10.1

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, writeFile } 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(),
@@ -877,88 +829,14 @@ async function loadRules(capabilityPath, capabilityId) {
   }
   return rules;
 }
-async function writeRules(rules, docs = []) {
-  const instructionsPath = ".omni/instructions.md";
-  const rulesContent = generateRulesContent(rules, docs);
-  let content;
-  if (existsSync6(instructionsPath)) {
-    content = await readFile4(instructionsPath, "utf-8");
-  } else {
-    content = `# OmniDev Instructions
-
-## Project Description
-<!-- TODO: Add 2-3 sentences describing your project -->
-[Describe what this project does and its main purpose]
-
-<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
-<!-- END OMNIDEV GENERATED CONTENT -->
-`;
-  }
-  const beginMarker = "<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->";
-  const endMarker = "<!-- END OMNIDEV GENERATED CONTENT -->";
-  const beginIndex = content.indexOf(beginMarker);
-  const endIndex = content.indexOf(endMarker);
-  if (beginIndex === -1 || endIndex === -1) {
-    content += `
-
-${beginMarker}
-${rulesContent}
-${endMarker}
-`;
-  } else {
-    content = content.substring(0, beginIndex + beginMarker.length) + `
-` + rulesContent + `
-` + content.substring(endIndex);
-  }
-  await writeFile(instructionsPath, content, "utf-8");
-}
-function generateRulesContent(rules, docs = []) {
-  if (rules.length === 0 && docs.length === 0) {
-    return `<!-- This section is automatically updated when capabilities change -->
-
-## Capabilities
-
-No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.`;
-  }
-  let content = `<!-- This section is automatically updated when capabilities change -->
-
-## Capabilities
-
-`;
-  if (docs.length > 0) {
-    content += `### Documentation
-
-`;
-    for (const doc of docs) {
-      content += `#### ${doc.name} (from ${doc.capabilityId})
-
-${doc.content}
-
-`;
-    }
-  }
-  if (rules.length > 0) {
-    content += `### Rules
-
-`;
-    for (const rule of rules) {
-      content += `#### ${rule.name} (from ${rule.capabilityId})
-
-${rule.content}
-
-`;
-    }
-  }
-  return content.trim();
-}
 
 // src/capability/skills.ts
-import { existsSync as 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 = [];
@@ -966,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);
       }
@@ -975,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`);
@@ -994,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 = [];
@@ -1007,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);
       }
@@ -1016,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`);
@@ -1060,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);
         }
       }
@@ -1076,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 {
@@ -1102,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) => {
@@ -1282,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);
@@ -1322,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 as writeFile2 } 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] = {
@@ -1342,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 {};
@@ -1351,34 +1225,18 @@ 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);
 }
 async function writeConfig(config) {
   const content = generateConfigToml(config);
-  await writeFile2(CONFIG_PATH, content, "utf-8");
+  await writeFile(CONFIG_PATH, content, "utf-8");
 }
 function generateConfigToml(config) {
   const lines = [];
-  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]");
@@ -1386,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");
@@ -1414,7 +1255,7 @@ function generateConfigToml(config) {
     for (const [name, sourceConfig] of Object.entries(sources)) {
       if (typeof sourceConfig === "string") {
         lines.push(`${name} = "${sourceConfig}"`);
-      } else if (sourceConfig.path) {
+      } else if ("path" in sourceConfig && sourceConfig.path) {
         lines.push(`${name} = { source = "${sourceConfig.source}", path = "${sourceConfig.path}" }`);
       } else {
         lines.push(`${name} = "${sourceConfig.source}"`);
@@ -1482,10 +1323,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]`);
@@ -1505,8 +1344,7 @@ 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("# =============================================================================");
@@ -1545,16 +1383,16 @@ function generateConfigToml(config) {
 }
 
 // src/state/active-profile.ts
-import { existsSync as existsSync11, mkdirSync } from "node:fs";
-import { readFile as readFile9, unlink, writeFile as writeFile3 } 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 {
@@ -1563,10 +1401,10 @@ async function readActiveProfileState() {
 }
 async function writeActiveProfileState(profileName) {
   mkdirSync(STATE_DIR, { recursive: true });
-  await writeFile3(ACTIVE_PROFILE_PATH, profileName, "utf-8");
+  await writeFile2(ACTIVE_PROFILE_PATH, profileName, "utf-8");
 }
 async function clearActiveProfileState() {
-  if (existsSync11(ACTIVE_PROFILE_PATH)) {
+  if (existsSync10(ACTIVE_PROFILE_PATH)) {
     await unlink(ACTIVE_PROFILE_PATH);
   }
 }
@@ -1740,13 +1578,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);
       }
@@ -1777,11 +1614,28 @@ 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 writeFile4 } 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";
+
+// src/types/index.ts
+function isFileSourceConfig(config) {
+  if (typeof config === "string") {
+    return config.startsWith("file://");
+  }
+  return config.source.startsWith("file://");
+}
+function getActiveProviders(config) {
+  if (config.providers)
+    return config.providers;
+  if (config.provider)
+    return [config.provider];
+  return ["claude"];
+}
+
+// src/capability/sources.ts
 var OMNI_LOCAL = ".omni";
 var SKILL_DIRS = ["skills", "skill"];
 var AGENT_DIRS = ["agents", "agent", "subagents", "subagent"];
@@ -1813,8 +1667,39 @@ async function spawnCapture(command, args, options) {
     });
   });
 }
+function isGitSource(source) {
+  return source.startsWith("github:") || source.startsWith("git@") || source.startsWith("https://") || source.startsWith("http://");
+}
+function isFileSource(source) {
+  return source.startsWith("file://");
+}
+function parseFileSourcePath(source) {
+  if (!source.startsWith("file://")) {
+    throw new Error(`Invalid file source: ${source}`);
+  }
+  return source.slice(7);
+}
+async function readCapabilityIdFromPath(capabilityPath) {
+  const tomlPath = join8(capabilityPath, "capability.toml");
+  if (existsSync11(tomlPath)) {
+    try {
+      const content = await readFile9(tomlPath, "utf-8");
+      const parsed = parseToml2(content);
+      const capability = parsed["capability"];
+      if (capability?.["id"] && typeof capability["id"] === "string") {
+        return capability["id"];
+      }
+    } catch {}
+  }
+  const parts = capabilityPath.replace(/\\/g, "/").split("/");
+  const dirName = parts.pop() || parts.pop();
+  return dirName || null;
+}
 function parseSourceConfig(source) {
   if (typeof source === "string") {
+    if (isFileSource(source)) {
+      return { source };
+    }
     let sourceUrl = source;
     let ref;
     if (source.startsWith("github:") && source.includes("#")) {
@@ -1828,6 +1713,9 @@ function parseSourceConfig(source) {
     }
     return result;
   }
+  if (isFileSourceConfig(source)) {
+    return source;
+  }
   return source;
 }
 function sourceToGitUrl(source) {
@@ -1845,11 +1733,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 {
@@ -1886,7 +1774,7 @@ async function saveLockFile(lockFile) {
 
 `;
   const content = header + stringifyLockFile(lockFile);
-  await writeFile4(lockPath, content, "utf-8");
+  await writeFile3(lockPath, content, "utf-8");
 }
 async function getRepoCommit(repoPath) {
   const { exitCode, stdout, stderr } = await spawnCapture("git", ["rev-parse", "HEAD"], {
@@ -1938,16 +1826,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;
@@ -1959,7 +1847,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;
@@ -1970,7 +1858,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));
@@ -1978,7 +1866,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,
@@ -2000,11 +1888,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,
@@ -2025,11 +1913,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 = "";
@@ -2068,7 +1956,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()) {
@@ -2157,7 +2045,7 @@ repository = "${repoUrl}"
 wrapped = true
 commit = "${commit}"
 `;
-  await writeFile4(join8(repoPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile3(join8(repoPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function fetchGitCapabilitySource(id, config, options) {
   const gitUrl = sourceToGitUrl(config.source);
@@ -2167,7 +2055,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}...`);
       }
@@ -2183,17 +2071,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}...`);
       }
@@ -2232,9 +2120,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;
       }
@@ -2249,8 +2137,52 @@ async function fetchGitCapabilitySource(id, config, options) {
     wrapped: needsWrap
   };
 }
+async function fetchFileCapabilitySource(id, config, options) {
+  const sourcePath = parseFileSourcePath(config.source);
+  const targetPath = getSourceCapabilityPath(id);
+  if (!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 (!existsSync11(join8(sourcePath, "capability.toml"))) {
+    throw new Error(`No capability.toml found in: ${sourcePath}`);
+  }
+  if (!options?.silent) {
+    console.log(`  Copying ${id} from ${sourcePath}...`);
+  }
+  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 (existsSync11(capTomlPath)) {
+    try {
+      const content = await readFile9(capTomlPath, "utf-8");
+      const parsed = parseToml2(content);
+      const capability = parsed["capability"];
+      if (capability?.["version"] && typeof capability["version"] === "string") {
+        version = capability["version"];
+      }
+    } catch {}
+  }
+  return {
+    id,
+    path: targetPath,
+    version,
+    updated: true,
+    wrapped: false
+  };
+}
 async function fetchCapabilitySource(id, sourceConfig, options) {
   const config = parseSourceConfig(sourceConfig);
+  if (isFileSourceConfig(sourceConfig) || isFileSource(config.source)) {
+    return fetchFileCapabilitySource(id, config, options);
+  }
   return fetchGitCapabilitySource(id, config, options);
 }
 function generateMcpCapabilityTomlContent(id, mcpConfig) {
@@ -2317,16 +2249,16 @@ generated_from_omni_toml = true
 }
 async function generateMcpCapabilityToml(id, mcpConfig, targetPath) {
   const tomlContent = generateMcpCapabilityTomlContent(id, mcpConfig);
-  await writeFile4(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile3(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
 }
 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"];
@@ -2337,7 +2269,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 });
@@ -2387,12 +2319,14 @@ async function fetchAllCapabilitySources(config, options) {
         version: result.version,
         updated_at: new Date().toISOString()
       };
-      const gitConfig = parseSourceConfig(source);
       if (result.commit) {
         lockEntry.commit = result.commit;
       }
-      if (gitConfig.ref) {
-        lockEntry.ref = gitConfig.ref;
+      if (!isFileSourceConfig(source)) {
+        const gitConfig = parseSourceConfig(source);
+        if (gitConfig.ref) {
+          lockEntry.ref = gitConfig.ref;
+        }
       }
       const existing = lockFile.capabilities[id];
       const hasChanged = !existing || existing.commit !== result.commit;
@@ -2432,8 +2366,18 @@ async function checkForUpdates(config) {
     const sourceConfig = parseSourceConfig(source);
     const targetPath = getSourceCapabilityPath(id);
     const existing = lockFile.capabilities[id];
+    if (isFileSourceConfig(source) || isFileSource(sourceConfig.source)) {
+      updates.push({
+        id,
+        source: sourceConfig.source,
+        currentVersion: existing?.version || "local",
+        latestVersion: "local",
+        hasUpdate: false
+      });
+      continue;
+    }
     const gitConfig = sourceConfig;
-    if (!existsSync12(join8(targetPath, ".git"))) {
+    if (!existsSync11(join8(targetPath, ".git"))) {
       updates.push({
         id,
         source: gitConfig.source,
@@ -2469,15 +2413,15 @@ async function checkForUpdates(config) {
   return updates;
 }
 // src/config/provider.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { readFile as readFile11, writeFile as writeFile5 } 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;
 }
@@ -2504,7 +2448,7 @@ async function writeProviderConfig(config) {
     lines.push("# Default: Claude");
     lines.push('provider = "claude"');
   }
-  await writeFile5(PROVIDER_CONFIG_PATH, `${lines.join(`
+  await writeFile4(PROVIDER_CONFIG_PATH, `${lines.join(`
 `)}
 `, "utf-8");
 }
@@ -2519,17 +2463,17 @@ 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 writeFile6 } 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 writeFile6(CONFIG_PATH2, content, "utf-8");
+  await writeFile5(CONFIG_PATH2, content, "utf-8");
 }
 function findSection(lines, sectionPattern) {
   return lines.findIndex((line) => sectionPattern.test(line.trim()));
@@ -2550,7 +2494,7 @@ function formatCapabilitySource(name, source) {
   if (typeof source === "string") {
     return `${name} = "${source}"`;
   }
-  if (source.path) {
+  if ("path" in source && source.path) {
     return `${name} = { source = "${source.source}", path = "${source.path}" }`;
   }
   return `${name} = "${source.source}"`;
@@ -2616,10 +2560,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]`);
@@ -2725,15 +2667,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 writeFile7 } 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 || {}
@@ -2743,7 +2685,7 @@ async function readMcpJson() {
   }
 }
 async function writeMcpJson(config2) {
-  await writeFile7(MCP_JSON_PATH, `${JSON.stringify(config2, null, 2)}
+  await writeFile6(MCP_JSON_PATH, `${JSON.stringify(config2, null, 2)}
 `, "utf-8");
 }
 function buildMcpServerConfig(mcp) {
@@ -2812,24 +2754,24 @@ 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 writeFile8 } 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) {
   mkdirSync2(".omni/state", { recursive: true });
-  await writeFile8(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
+  await writeFile7(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
 function buildManifestFromCapabilities(capabilities2) {
@@ -2864,14 +2806,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);
       }
@@ -2880,17 +2822,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 writeFile9 } 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 {
@@ -2900,7 +2842,7 @@ async function readEnabledProviders() {
 async function writeEnabledProviders(providers) {
   mkdirSync3(STATE_DIR2, { recursive: true });
   const state = { enabled: providers };
-  await writeFile9(PROVIDERS_PATH, `${JSON.stringify(state, null, 2)}
+  await writeFile8(PROVIDERS_PATH, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 async function enableProvider(providerId) {
@@ -2922,10 +2864,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 });
@@ -2947,14 +2889,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, {
@@ -2995,7 +2937,6 @@ async function buildSyncBundle(options) {
     docs,
     commands,
     subagents,
-    instructionsPath: ".omni/instructions.md",
     instructionsContent
   };
   if (hasAnyHooks(mergedHooks)) {
@@ -3044,7 +2985,6 @@ async function syncAgentConfiguration(options) {
     }
   }
   mkdirSync4(".omni", { recursive: true });
-  await writeRules(bundle.rules, bundle.docs);
   await syncMcpJson(capabilities2, previousManifest, { silent });
   const newManifest = buildManifestFromCapabilities(capabilities2);
   await saveManifest(newManifest);
@@ -3067,7 +3007,7 @@ async function syncAgentConfiguration(options) {
   }
   if (!silent) {
     console.log("✓ Synced:");
-    console.log(`  - .omni/instructions.md (${bundle.docs.length} docs, ${bundle.rules.length} rules)`);
+    console.log(`  - ${bundle.docs.length} docs, ${bundle.rules.length} rules`);
     if (adapters.length > 0) {
       console.log(`  - Provider adapters: ${adapters.map((a) => a.displayName).join(", ")}`);
     }
@@ -3122,56 +3062,150 @@ function generateAgentsTemplate() {
 
 ## OmniDev
 
-@import .omni/instructions.md
+<!-- This section is populated during sync with capability rules and docs -->
 `;
 }
-// src/templates/claude.ts
-function generateClaudeTemplate() {
-  return `# Project Instructions
+// src/templates/capability.ts
+function generateCapabilityToml2(options) {
+  const description = options.description || "TODO: Add a description for your capability";
+  return `[capability]
+id = "${options.id}"
+name = "${options.name}"
+version = "0.1.0"
+description = "${description}"
 
-<!-- Add your project-specific instructions here -->
+# Optional author information
+# [capability.author]
+# name = "Your Name"
+# email = "you@example.com"
 
-## OmniDev
+# Optional metadata
+# [capability.metadata]
+# repository = "https://github.com/user/repo"
+# license = "MIT"
+`;
+}
+function generateSkillTemplate(skillName) {
+  return `---
+name: ${skillName}
+description: TODO: Add a description for this skill
+---
+
+## What I do
+
+<!-- Describe what this skill helps the AI agent accomplish -->
+- TODO: List the main capabilities of this skill
+
+## When to use me
+
+<!-- Describe scenarios when this skill should be invoked -->
+Use this skill when you need to:
+- TODO: Add trigger conditions
 
-@import .omni/instructions.md
+## Implementation
+
+<!-- Add detailed instructions for the AI agent -->
+### Steps
+
+1. TODO: Add implementation steps
+2. Validate inputs and outputs
+3. Report results to the user
+
+## Examples
+
+<!-- Optional: Add examples of how this skill should be used -->
+\`\`\`
+TODO: Add example usage
+\`\`\`
 `;
 }
-function generateInstructionsTemplate() {
-  return `# OmniDev Instructions
+function generateRuleTemplate(ruleName) {
+  return `# ${formatDisplayName(ruleName)}
 
-## Project Description
-<!-- TODO: Add 2-3 sentences describing your project -->
-[Describe what this project does and its main purpose]
+<!-- Rules are guidelines that the AI agent should follow when working in this project -->
 
-## How OmniDev Works
+## Overview
 
-OmniDev manages capability content for your project. Capabilities can provide:
+TODO: Describe what this rule enforces or guides.
 
-- Skills (for agent workflows)
-- Rules (for guardrails and conventions)
-- Docs (reference material)
-- Commands and subagents (optional)
+## Guidelines
 
-Enable capabilities with:
+- TODO: Add specific guidelines the AI should follow
+- Be specific and actionable
+- Include examples where helpful
+
+## Examples
+
+### Good
 
 \`\`\`
-omnidev capability enable <capability-id>
+TODO: Add example of correct behavior
 \`\`\`
 
-OmniDev will automatically sync enabled capabilities into your workspace. If you want to force a refresh:
+### Bad
 
 \`\`\`
-omnidev sync
+TODO: Add example of incorrect behavior
 \`\`\`
+`;
+}
+function generateHooksTemplate() {
+  return `# Hook configuration for this capability
+# See: https://omnidev.dev/docs/advanced/hooks
+
+# Example: Validate bash commands before execution
+# [[PreToolUse]]
+# matcher = "Bash"
+# [[PreToolUse.hooks]]
+# type = "command"
+# command = "\${OMNIDEV_CAPABILITY_ROOT}/hooks/validate-bash.sh"
+# timeout = 30
+
+# Example: Run linter after file edits
+# [[PostToolUse]]
+# matcher = "Write|Edit"
+# [[PostToolUse.hooks]]
+# type = "command"
+# command = "\${OMNIDEV_CAPABILITY_ROOT}/hooks/run-linter.sh"
+
+# Example: Load context at session start
+# [[SessionStart]]
+# matcher = "startup|resume"
+# [[SessionStart.hooks]]
+# type = "command"
+# command = "\${OMNIDEV_CAPABILITY_ROOT}/hooks/load-context.sh"
+`;
+}
+function generateHookScript() {
+  return `#!/bin/bash
+# Sample hook script
+# This script receives JSON input via stdin
 
-<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
-<!-- This section is automatically updated by 'omnidev agents sync' -->
+# Read JSON input from stdin
+INPUT=$(cat)
 
-## Capabilities
+# Example: Extract tool information
+# TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name')
+# COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
 
-No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.
+# Add your validation logic here
+# Exit 0 to allow, exit 2 to block
 
-<!-- END OMNIDEV GENERATED CONTENT -->
+exit 0
+`;
+}
+function formatDisplayName(kebabCase) {
+  return kebabCase.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+// src/templates/claude.ts
+function generateClaudeTemplate() {
+  return `# Project Instructions
+
+<!-- Add your project-specific instructions here -->
+
+## OmniDev
+
+<!-- This section is populated during sync with capability rules and docs -->
 `;
 }
 // src/templates/omni.ts
@@ -3195,14 +3229,6 @@ function generateOmniMdTemplate() {
 <!-- Describe your project's architecture and key components -->
 `;
 }
-// src/types/index.ts
-function getActiveProviders(config2) {
-  if (config2.providers)
-    return config2.providers;
-  if (config2.provider)
-    return [config2.provider];
-  return ["claude"];
-}
 // src/debug.ts
 function debug(message, data) {
   if (process.env["OMNIDEV_DEBUG"] !== "1") {
@@ -3224,7 +3250,6 @@ function getVersion() {
   return version;
 }
 export {
-  writeRules,
   writeProviderConfig,
   writeMcpJson,
   writeEnabledProviders,
@@ -3233,7 +3258,6 @@ export {
   version,
   validateHooksConfig,
   validateHook,
-  validateEnv,
   transformToOmnidev,
   transformToClaude,
   transformHooksConfig,
@@ -3247,6 +3271,7 @@ export {
   resolveEnabledCapabilities,
   readMcpJson,
   readEnabledProviders,
+  readCapabilityIdFromPath,
   readActiveProfileState,
   patchAddToProfile,
   patchAddMcp,
@@ -3254,6 +3279,7 @@ export {
   parseSourceConfig,
   parseProviderFlag,
   parseOmniConfig,
+  parseFileSourcePath,
   parseCapabilityConfig,
   mergeHooksConfigs,
   mergeAndDeduplicateHooks,
@@ -3265,7 +3291,6 @@ export {
   loadManifest,
   loadLockFile,
   loadHooksFromCapability,
-  loadEnvironment,
   loadDocs,
   loadConfig,
   loadCommands,
@@ -3274,7 +3299,6 @@ export {
   loadCapability,
   loadBaseConfig,
   isValidMatcherPattern,
-  isSecretEnvVar,
   isProviderEnabled,
   isPromptHookEvent,
   isMatcherEvent,
@@ -3282,6 +3306,9 @@ export {
   isHookPrompt,
   isHookEvent,
   isHookCommand,
+  isGitSource,
+  isFileSourceConfig,
+  isFileSource,
   installCapabilityDependencies,
   hasHooks,
   hasAnyHooks,
@@ -3294,9 +3321,13 @@ export {
   getEnabledCapabilities,
   getActiveProviders,
   getActiveProfile,
+  generateSkillTemplate,
+  generateRuleTemplate,
   generateOmniMdTemplate,
-  generateInstructionsTemplate,
+  generateHooksTemplate,
+  generateHookScript,
   generateClaudeTemplate,
+  generateCapabilityToml2 as generateCapabilityToml,
   generateAgentsTemplate,
   findDuplicateCommands,
   fetchCapabilitySource,