@omnidev-ai/cli 0.18.0 → 0.18.1

package/dist/index.js

@@ -2638,7 +2638,10 @@ async function loadSkills(capabilityPath, capabilityId, variables) {
         const skillPath = join6(dir, entry.name, "SKILL.md");
         if (existsSync8(skillPath)) {
           const skill = await parseSkillFile(skillPath, capabilityId, resolvedVariables, `skill file ${skillPath}`);
-          skills.push(skill);
+          skills.push({
+            ...skill,
+            sourcePath: join6(dir, entry.name)
+          });
         }
       }
     }
@@ -3524,7 +3527,7 @@ import { existsSync as existsSync13 } from "node:fs";
 import { spawn } from "node:child_process";
 import { cp, mkdir, readdir, readFile as readFile10, rename, rm, stat, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join9 } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 async function spawnCapture(command, args, options) {
   const timeout = options?.timeout ?? 60000;
   return await new Promise((resolve2, reject) => {
@@ -3733,7 +3736,7 @@ function escapeTomlString(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
 }
 async function computeContentHash(dirPath, excludePatterns = CONTENT_HASH_EXCLUDES) {
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   const files = [];
   async function collectFiles(currentPath, relativeTo) {
     const entries = await readdir(currentPath, { withFileTypes: true });
@@ -5168,29 +5171,107 @@ var init_mcp_json = __esm(() => {
 });
 
 // ../core/src/state/manifest.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync2, rmSync } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync17, mkdirSync as mkdirSync2, readdirSync as readdirSync7, rmSync } from "node:fs";
+import { dirname, join as join10 } from "node:path";
 import { readFile as readFile14, writeFile as writeFile7 } from "node:fs/promises";
-async function loadManifest() {
-  if (!existsSync17(MANIFEST_PATH)) {
+function createEmptyManifest() {
+  return {
+    version: CURRENT_VERSION,
+    syncedAt: new Date().toISOString(),
+    capabilities: {},
+    providers: {}
+  };
+}
+function normalizeManifest(parsed) {
+  if (parsed.version === CURRENT_VERSION && "providers" in parsed) {
     return {
       version: CURRENT_VERSION,
-      syncedAt: new Date().toISOString(),
-      capabilities: {}
+      syncedAt: parsed.syncedAt,
+      capabilities: parsed.capabilities,
+      providers: parsed.providers ?? {}
     };
   }
+  return {
+    version: CURRENT_VERSION,
+    syncedAt: parsed.syncedAt,
+    capabilities: parsed.capabilities,
+    providers: {}
+  };
+}
+function hashContent2(content) {
+  return createHash3("sha256").update(content).digest("hex");
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function isDirectoryEmpty(path) {
+  return readdirSync7(path).length === 0;
+}
+async function cleanupManagedOutput(output) {
+  const outputPath = join10(process.cwd(), output.path);
+  if (!existsSync17(outputPath)) {
+    return { deleted: false };
+  }
+  if (output.cleanupStrategy === "remove-json-key") {
+    if (!output.jsonKey) {
+      return { deleted: false, reason: `missing jsonKey metadata for ${output.path}` };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile14(outputPath, "utf-8"));
+    } catch {
+      return { deleted: false, reason: `could not parse JSON at ${output.path}` };
+    }
+    const currentValue = parsed[output.jsonKey];
+    if (currentValue === undefined) {
+      return { deleted: false };
+    }
+    if (hashContent2(JSON.stringify(currentValue)) !== output.hash) {
+      return { deleted: false, reason: `managed section changed at ${output.path}` };
+    }
+    delete parsed[output.jsonKey];
+    if (Object.keys(parsed).length === 0) {
+      rmSync(outputPath);
+    } else {
+      await writeFile7(outputPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+    }
+    return { deleted: true };
+  }
+  const currentContent = await readFile14(outputPath, "utf-8");
+  if (hashContent2(currentContent) !== output.hash) {
+    return { deleted: false, reason: `managed file changed at ${output.path}` };
+  }
+  rmSync(outputPath);
+  if (output.cleanupStrategy === "delete-file-and-prune-empty-parents" && output.pruneRoot) {
+    const pruneRoot = join10(process.cwd(), output.pruneRoot);
+    let currentDir = dirname(outputPath);
+    while (normalizePath(currentDir).startsWith(normalizePath(pruneRoot)) && normalizePath(currentDir) !== normalizePath(pruneRoot) && existsSync17(currentDir) && isDirectoryEmpty(currentDir)) {
+      rmSync(currentDir, { recursive: true });
+      currentDir = dirname(currentDir);
+    }
+  }
+  return { deleted: true };
+}
+async function loadManifest() {
+  if (!existsSync17(MANIFEST_PATH)) {
+    return createEmptyManifest();
+  }
   const content = await readFile14(MANIFEST_PATH, "utf-8");
-  return JSON.parse(content);
+  return normalizeManifest(JSON.parse(content));
 }
 async function saveManifest(manifest) {
   mkdirSync2(".omni/state", { recursive: true });
   await writeFile7(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
-function buildManifestFromCapabilities(capabilities2) {
+function buildManifestFromCapabilities(capabilities2, providerOutputs = new Map) {
   const manifest = {
     version: CURRENT_VERSION,
     syncedAt: new Date().toISOString(),
-    capabilities: {}
+    capabilities: {},
+    providers: {}
   };
   for (const cap of capabilities2) {
     const resources = {
@@ -5202,38 +5283,59 @@ function buildManifestFromCapabilities(capabilities2) {
     };
     manifest.capabilities[cap.id] = resources;
   }
+  for (const [providerId, outputs] of providerOutputs) {
+    manifest.providers[providerId] = {
+      outputs: Object.fromEntries(outputs.map((output) => [output.path, output]))
+    };
+  }
   return manifest;
 }
-async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
-  const result = {
+async function cleanupStaleResources(_previousManifest, _currentCapabilityIds) {
+  return {
     deletedSkills: [],
     deletedRules: [],
     deletedCommands: [],
     deletedSubagents: [],
     deletedMcps: []
   };
-  for (const [capId, resources] of Object.entries(previousManifest.capabilities)) {
-    if (currentCapabilityIds.has(capId)) {
-      continue;
+}
+async function cleanupStaleManagedOutputs(previousManifest, nextProviders) {
+  const result = {
+    deletedPaths: [],
+    skippedPaths: []
+  };
+  const claimedPaths = new Set;
+  for (const outputs of nextProviders.values()) {
+    for (const output of outputs) {
+      claimedPaths.add(output.path);
     }
-    for (const skillName of resources.skills) {
-      const skillDir = `.claude/skills/${skillName}`;
-      if (existsSync17(skillDir)) {
-        rmSync(skillDir, { recursive: true });
-        result.deletedSkills.push(skillName);
+  }
+  for (const [providerId, providerState] of Object.entries(previousManifest.providers)) {
+    const nextPaths = new Set((nextProviders.get(providerId) ?? []).map((output) => output.path));
+    for (const output of Object.values(providerState.outputs)) {
+      if (nextPaths.has(output.path)) {
+        continue;
       }
-    }
-    for (const ruleName of resources.rules) {
-      const rulePath = `.cursor/rules/omnidev-${ruleName}.mdc`;
-      if (existsSync17(rulePath)) {
-        rmSync(rulePath);
-        result.deletedRules.push(ruleName);
+      if (claimedPaths.has(output.path)) {
+        continue;
+      }
+      const cleanup = await cleanupManagedOutput(output);
+      if (cleanup.deleted) {
+        result.deletedPaths.push(output.path);
+      } else if (cleanup.reason) {
+        result.skippedPaths.push({
+          path: output.path,
+          reason: cleanup.reason
+        });
       }
     }
   }
   return result;
 }
-var MANIFEST_PATH = ".omni/state/manifest.json", CURRENT_VERSION = 1;
+function getProviderManagedOutputs(manifest, providerId) {
+  return Object.values(manifest.providers[providerId]?.outputs ?? {});
+}
+var MANIFEST_PATH = ".omni/state/manifest.json", CURRENT_VERSION = 2;
 var init_manifest = () => {};
 
 // ../core/src/state/providers.ts
@@ -5382,7 +5484,7 @@ var init_state = __esm(() => {
 // ../core/src/sync.ts
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync20, mkdirSync as mkdirSync5, readFileSync as readFileSync3 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function getDeclaredPackageManager(packageManager) {
   if (typeof packageManager !== "string" || packageManager.trim().length === 0) {
     return;
@@ -5391,8 +5493,8 @@ function getDeclaredPackageManager(packageManager) {
   return atIndex === -1 ? packageManager : packageManager.slice(0, atIndex);
 }
 function resolveCapabilityInstallCommand(capabilityPath, options) {
-  const packageJsonPath = join10(capabilityPath, "package.json");
-  const packageLockPath = join10(capabilityPath, "package-lock.json");
+  const packageJsonPath = join11(capabilityPath, "package.json");
+  const packageLockPath = join11(capabilityPath, "package-lock.json");
   let packageManager;
   try {
     const pkgJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -5410,13 +5512,13 @@ function resolveCapabilityInstallCommand(capabilityPath, options) {
   };
 }
 async function installCapabilityDependencies(silent) {
-  const { readdirSync: readdirSync7 } = await import("node:fs");
+  const { readdirSync: readdirSync8 } = await import("node:fs");
   const { parse: parse2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
   const capabilitiesDir = ".omni/capabilities";
   if (!existsSync20(capabilitiesDir)) {
     return;
   }
-  const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
+  const entries = readdirSync8(capabilitiesDir, { withFileTypes: true });
   async function commandExists(cmd) {
     return await new Promise((resolve2) => {
       const proc = spawn2(cmd, ["--version"], { stdio: "ignore" });
@@ -5432,9 +5534,9 @@ async function installCapabilityDependencies(silent) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const capabilityPath = join10(capabilitiesDir, entry.name);
-    const packageJsonPath = join10(capabilityPath, "package.json");
-    const capabilityTomlPath = join10(capabilityPath, "capability.toml");
+    const capabilityPath = join11(capabilitiesDir, entry.name);
+    const packageJsonPath = join11(capabilityPath, "package.json");
+    const capabilityTomlPath = join11(capabilityPath, "capability.toml");
     if (!existsSync20(packageJsonPath)) {
       continue;
     }
@@ -5472,7 +5574,7 @@ ${stderr}`));
           reject(error);
         });
       });
-      const hasIndexTs = existsSync20(join10(capabilityPath, "index.ts"));
+      const hasIndexTs = existsSync20(join11(capabilityPath, "index.ts"));
       let hasBuildScript = false;
       try {
         const pkgJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -5501,7 +5603,7 @@ ${stderr}`));
           });
         });
       } else if (hasIndexTs && !silent) {
-        const hasBuiltIndex = existsSync20(join10(capabilityPath, "dist", "index.js"));
+        const hasBuiltIndex = existsSync20(join11(capabilityPath, "dist", "index.js"));
         if (!hasBuiltIndex) {
           console.warn(`Warning: Capability at ${capabilityPath} has index.ts but no build script.
   Add a "build" script to package.json (e.g., "build": "tsc") to compile TypeScript.`);
@@ -5572,8 +5674,8 @@ async function syncAgentConfiguration(options) {
   }
   mkdirSync5(".omni", { recursive: true });
   await syncMcpJson(capabilities2, previousManifest);
-  const newManifest = buildManifestFromCapabilities(capabilities2);
-  await saveManifest(newManifest);
+  const enabledProviderIds = new Set(adapters.map((adapter) => String(adapter.id)));
+  const successfulProviderOutputs = new Map;
   if (adapters.length > 0) {
     const config2 = await loadConfig();
     const ctx = {
@@ -5582,12 +5684,33 @@ async function syncAgentConfiguration(options) {
     };
     for (const adapter of adapters) {
       try {
-        await adapter.sync(bundle, ctx);
+        const adapterResult = await adapter.sync(bundle, ctx);
+        successfulProviderOutputs.set(String(adapter.id), adapterResult.managedOutputs ?? []);
       } catch (error) {
         console.error(`Error running ${adapter.displayName} adapter:`, error);
       }
     }
   }
+  const nextProviderOutputs = new Map;
+  if (adapters.length === 0) {
+    for (const providerId of Object.keys(previousManifest.providers)) {
+      nextProviderOutputs.set(providerId, getProviderManagedOutputs(previousManifest, providerId));
+    }
+  } else {
+    for (const providerId of enabledProviderIds) {
+      if (successfulProviderOutputs.has(providerId)) {
+        nextProviderOutputs.set(providerId, successfulProviderOutputs.get(providerId) ?? []);
+        continue;
+      }
+      nextProviderOutputs.set(providerId, getProviderManagedOutputs(previousManifest, providerId));
+    }
+  }
+  const cleanupResult = await cleanupStaleManagedOutputs(previousManifest, nextProviderOutputs);
+  for (const skipped of cleanupResult.skippedPaths) {
+    console.warn(`Warning: skipped cleanup for ${skipped.path} (${skipped.reason})`);
+  }
+  const newManifest = buildManifestFromCapabilities(capabilities2, nextProviderOutputs);
+  await saveManifest(newManifest);
   const result = {
     capabilities: capabilities2.map((c) => c.id),
     skillCount: bundle.skills.length,
@@ -5648,7 +5771,7 @@ var init_types3 = __esm(() => {
 // ../core/src/security/scanner.ts
 import { existsSync as existsSync21 } from "node:fs";
 import { lstat, readdir as readdir2, readFile as readFile17, readlink, realpath } from "node:fs/promises";
-import { join as join11, relative, resolve as resolve2 } from "node:path";
+import { join as join12, relative, resolve as resolve2 } from "node:path";
 async function scanFileForUnicode(filePath, relativePath) {
   const findings = [];
   try {
@@ -5835,7 +5958,7 @@ async function scanFileForNetworkRequests(filePath, relativePath) {
 async function checkSymlink(symlinkPath, relativePath, capabilityRoot) {
   try {
     const linkTarget = await readlink(symlinkPath);
-    const resolvedTarget = resolve2(join11(symlinkPath, "..", linkTarget));
+    const resolvedTarget = resolve2(join12(symlinkPath, "..", linkTarget));
     const normalizedRoot = await realpath(capabilityRoot);
     if (linkTarget.startsWith("/")) {
       return {
@@ -5882,7 +6005,7 @@ async function scanCapability(capabilityId, capabilityPath, settings = DEFAULT_S
   async function scanDirectory(dirPath) {
     const entries = await readdir2(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join11(dirPath, entry.name);
+      const fullPath = join12(dirPath, entry.name);
       const relativePath = relative(capabilityPath, fullPath);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "__pycache__") {
         continue;
@@ -6245,7 +6368,9 @@ var init_security = __esm(() => {
 
 // ../core/src/templates/agents.ts
 function generateAgentsTemplate() {
-  return `# Project Instructions
+  return `> IMPORTANT: Do not edit this file directly. Edit \`OMNI.md\` instead. This file is a generated copy of \`OMNI.md\` and is ephemeral. Any persistent change must be made in \`OMNI.md\`.
+
+# Project Instructions
 
 <!-- Add your project-specific instructions here -->
 
@@ -6372,7 +6497,9 @@ function formatDisplayName(kebabCase) {
 
 // ../core/src/templates/claude.ts
 function generateClaudeTemplate() {
-  return `# Project Instructions
+  return `> IMPORTANT: Do not edit this file directly. Edit \`OMNI.md\` instead. This file is a generated copy of \`OMNI.md\` and is ephemeral. Any persistent change must be made in \`OMNI.md\`.
+
+# Project Instructions
 
 <!-- Add your project-specific instructions here -->
 `;
@@ -6496,6 +6623,7 @@ __export(exports_src, {
   hasAnyHooks: () => hasAnyHooks,
   getVersion: () => getVersion,
   getSourceCapabilityPath: () => getSourceCapabilityPath,
+  getProviderManagedOutputs: () => getProviderManagedOutputs,
   getLockFilePath: () => getLockFilePath,
   getHooksDirectory: () => getHooksDirectory,
   getHooksConfigPath: () => getHooksConfigPath,
@@ -6533,6 +6661,7 @@ __export(exports_src, {
   clearAllSecurityAllows: () => clearAllSecurityAllows,
   clearActiveProfileState: () => clearActiveProfileState,
   cleanupStaleResources: () => cleanupStaleResources,
+  cleanupStaleManagedOutputs: () => cleanupStaleManagedOutputs,
   checkVersionMismatch: () => checkVersionMismatch,
   checkForUpdates: () => checkForUpdates,
   buildSyncBundle: () => buildSyncBundle,
@@ -6576,15 +6705,33 @@ var init_src = __esm(() => {
 import { run } from "@stricli/core";
 
 // src/lib/dynamic-app.ts
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 import { buildApplication, buildRouteMap as buildRouteMap7 } from "@stricli/core";
 
 // src/commands/add.ts
 import { existsSync as existsSync24 } from "node:fs";
 import { basename as basename5, resolve as resolve3 } from "node:path";
 
+// ../adapters/src/writers/generic/managed-outputs.ts
+import { createHash } from "node:crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function trimTrailingSlash(path) {
+  return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function createManagedOutput(path, writerId, content, options) {
+  return {
+    path,
+    writerId,
+    hash: hashContent(content),
+    cleanupStrategy: options?.cleanupStrategy ?? "delete-file",
+    ...options?.pruneRoot ? { pruneRoot: trimTrailingSlash(options.pruneRoot) } : {},
+    ...options?.jsonKey ? { jsonKey: options.jsonKey } : {}
+  };
+}
 // ../adapters/src/writers/generic/executor.ts
 async function executeWriters(writerConfigs, bundle, projectRoot, providerId) {
   const seen = new Set;
@@ -6600,6 +6747,7 @@ async function executeWriters(writerConfigs, bundle, projectRoot, providerId) {
     uniqueConfigs.push(config);
   }
   const allFilesWritten = [];
+  const allManagedOutputs = [];
   for (const config of uniqueConfigs) {
     const result = await config.writer.write(bundle, {
       outputPath: config.outputPath,
@@ -6607,25 +6755,27 @@ async function executeWriters(writerConfigs, bundle, projectRoot, providerId) {
       ...providerId ? { providerId } : {}
     });
     allFilesWritten.push(...result.filesWritten);
+    allManagedOutputs.push(...result.managedOutputs ?? []);
   }
   return {
     filesWritten: allFilesWritten,
-    deduplicatedCount
+    deduplicatedCount,
+    managedOutputs: allManagedOutputs
   };
 }
 // ../adapters/src/writers/generic/hooks.ts
 init_src();
 import { existsSync as existsSync22 } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile18, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname, join as join12 } from "node:path";
+import { dirname as dirname2, join as join13 } from "node:path";
 var HooksWriter = {
   id: "hooks",
   async write(bundle, ctx) {
     if (!bundle.hooks) {
       return { filesWritten: [] };
     }
-    const settingsPath = join12(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname(settingsPath);
+    const settingsPath = join13(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname2(settingsPath);
     await mkdir2(parentDir, { recursive: true });
     const claudeHooks = transformHooksConfig(bundle.hooks, "toClaude");
     let existingSettings = {};
@@ -6644,14 +6794,20 @@ var HooksWriter = {
     await writeFile10(settingsPath, `${JSON.stringify(newSettings, null, 2)}
 `, "utf-8");
     return {
-      filesWritten: [ctx.outputPath]
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [
+        createManagedOutput(ctx.outputPath, this.id, JSON.stringify(claudeHooks), {
+          cleanupStrategy: "remove-json-key",
+          jsonKey: "hooks"
+        })
+      ]
     };
   }
 };
 // ../adapters/src/writers/generic/instructions-md.ts
 import { existsSync as existsSync23 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile19, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname2, join as join13 } from "node:path";
+import { dirname as dirname3, join as join14 } from "node:path";
 
 // ../adapters/src/writers/generic/omni-md.ts
 init_src();
@@ -6673,20 +6829,32 @@ function renderOmniMdForProvider(content, providerId) {
 }
 
 // ../adapters/src/writers/generic/instructions-md.ts
+function getGeneratedCopyNotice(outputPath) {
+  if (outputPath !== "AGENTS.md" && outputPath !== "CLAUDE.md") {
+    return "";
+  }
+  return "> IMPORTANT: Do not edit this file directly. Edit `OMNI.md` instead. This file is a generated copy of `OMNI.md` and is ephemeral. Any persistent change must be made in `OMNI.md`.";
+}
 var InstructionsMdWriter = {
   id: "instructions-md",
   async write(bundle, ctx) {
-    const outputFullPath = join13(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname2(outputFullPath);
+    const outputFullPath = join14(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname3(outputFullPath);
     if (parentDir !== ctx.projectRoot) {
       await mkdir3(parentDir, { recursive: true });
     }
-    const omniMdPath = join13(ctx.projectRoot, "OMNI.md");
+    const omniMdPath = join14(ctx.projectRoot, "OMNI.md");
     let omniMdContent = "";
     if (existsSync23(omniMdPath)) {
       omniMdContent = renderOmniMdForProvider(await readFile19(omniMdPath, "utf-8"), ctx.providerId);
     }
     let content = omniMdContent;
+    const generatedCopyNotice = getGeneratedCopyNotice(ctx.outputPath);
+    if (generatedCopyNotice) {
+      content = content ? `${generatedCopyNotice}
+
+${content}` : generatedCopyNotice;
+    }
     if (bundle.instructionsContent) {
       content += `
 
@@ -6695,23 +6863,30 @@ ${bundle.instructionsContent}
     }
     await writeFile11(outputFullPath, content, "utf-8");
     return {
-      filesWritten: [ctx.outputPath]
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [createManagedOutput(ctx.outputPath, this.id, content)]
     };
   }
 };
 // ../adapters/src/writers/generic/skills.ts
-import { mkdir as mkdir4, writeFile as writeFile12 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { cp as cp2, mkdir as mkdir4, readdir as readdir3, rm as rm2, writeFile as writeFile12 } from "node:fs/promises";
+import { join as join15, relative as relative2 } from "node:path";
 var SkillsWriter = {
   id: "skills",
   async write(bundle, ctx) {
-    const skillsDir = join14(ctx.projectRoot, ctx.outputPath);
+    const skillsDir = join15(ctx.projectRoot, ctx.outputPath);
     await mkdir4(skillsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const skill of bundle.skills) {
-      const skillDir = join14(skillsDir, skill.name);
-      await mkdir4(skillDir, { recursive: true });
-      const skillPath = join14(skillDir, "SKILL.md");
+      const skillDir = join15(skillsDir, skill.name);
+      await rm2(skillDir, { recursive: true, force: true });
+      if (skill.sourcePath) {
+        await cp2(skill.sourcePath, skillDir, { recursive: true });
+      } else {
+        await mkdir4(skillDir, { recursive: true });
+      }
+      const skillPath = join15(skillDir, "SKILL.md");
       const content = `---
 name: ${skill.name}
 description: "${skill.description}"
@@ -6719,16 +6894,43 @@ description: "${skill.description}"
 
 ${skill.instructions}`;
       await writeFile12(skillPath, content, "utf-8");
-      filesWritten.push(join14(ctx.outputPath, skill.name, "SKILL.md"));
+      const relativePaths = skill.sourcePath ? await listRelativeFiles(skillDir) : ["SKILL.md"];
+      for (const relativeFile of relativePaths) {
+        filesWritten.push(join15(ctx.outputPath, skill.name, relativeFile));
+      }
+      const relativePath = join15(ctx.outputPath, skill.name, "SKILL.md");
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content, {
+        cleanupStrategy: "delete-file-and-prune-empty-parents",
+        pruneRoot: ctx.outputPath
+      }));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
+async function listRelativeFiles(basePath) {
+  const files = [];
+  const entries = await readdir3(basePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = join15(basePath, entry.name);
+    if (entry.isDirectory()) {
+      const nestedFiles = await listRelativeFiles(entryPath);
+      for (const nestedFile of nestedFiles) {
+        files.push(relative2(basePath, join15(entryPath, nestedFile)));
+      }
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(entry.name);
+    }
+  }
+  return files.sort((a, b) => a.localeCompare(b));
+}
 // ../adapters/src/writers/generic/commands-as-skills.ts
 import { mkdir as mkdir5, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function generateSkillFrontmatter(command) {
   const lines = ["---"];
   lines.push(`name: ${command.name}`);
@@ -6743,22 +6945,29 @@ function generateSkillFrontmatter(command) {
 var CommandsAsSkillsWriter = {
   id: "commands-as-skills",
   async write(bundle, ctx) {
-    const skillsDir = join15(ctx.projectRoot, ctx.outputPath);
+    const skillsDir = join16(ctx.projectRoot, ctx.outputPath);
     await mkdir5(skillsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const command of bundle.commands) {
-      const commandSkillDir = join15(skillsDir, command.name);
+      const commandSkillDir = join16(skillsDir, command.name);
       await mkdir5(commandSkillDir, { recursive: true });
       const frontmatter = generateSkillFrontmatter(command);
       const content = `${frontmatter}
 
 ${command.prompt}`;
-      const skillPath = join15(commandSkillDir, "SKILL.md");
+      const skillPath = join16(commandSkillDir, "SKILL.md");
       await writeFile13(skillPath, content, "utf-8");
-      filesWritten.push(join15(ctx.outputPath, command.name, "SKILL.md"));
+      const relativePath = join16(ctx.outputPath, command.name, "SKILL.md");
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content, {
+        cleanupStrategy: "delete-file-and-prune-empty-parents",
+        pruneRoot: ctx.outputPath
+      }));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
@@ -6811,7 +7020,7 @@ function createProviderScopedBundle(bundle, providerId) {
 
 // ../adapters/src/writers/claude/agents.ts
 import { mkdir as mkdir6, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function generateFrontmatter(agent) {
   const lines = ["---"];
   lines.push(`name: ${agent.name}`);
@@ -6838,20 +7047,24 @@ function generateFrontmatter(agent) {
 var ClaudeAgentsWriter = {
   id: "claude-agents",
   async write(bundle, ctx) {
-    const agentsDir = join16(ctx.projectRoot, ctx.outputPath);
+    const agentsDir = join17(ctx.projectRoot, ctx.outputPath);
     await mkdir6(agentsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const agent of bundle.subagents) {
       const frontmatter = generateFrontmatter(agent);
       const content = `${frontmatter}
 
 ${agent.systemPrompt}`;
-      const agentPath = join16(agentsDir, `${agent.name}.md`);
+      const agentPath = join17(agentsDir, `${agent.name}.md`);
       await writeFile14(agentPath, content, "utf-8");
-      filesWritten.push(join16(ctx.outputPath, `${agent.name}.md`));
+      const relativePath = join17(ctx.outputPath, `${agent.name}.md`);
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
@@ -6878,18 +7091,19 @@ var claudeCodeAdapter = {
     const result = await executeWriters(this.writers, providerBundle, ctx.projectRoot, providerId);
     return {
       filesWritten: result.filesWritten,
-      filesDeleted: []
+      filesDeleted: [],
+      managedOutputs: result.managedOutputs
     };
   }
 };
 // ../adapters/src/codex/index.ts
 import { mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 // ../adapters/src/writers/codex/toml.ts
 init_dist();
 import { mkdir as mkdir7, writeFile as writeFile15 } from "node:fs/promises";
-import { dirname as dirname3, join as join17 } from "node:path";
+import { dirname as dirname4, join as join18 } from "node:path";
 var FILE_HEADER = `# Generated by OmniDev - DO NOT EDIT
 # Run \`omnidev sync\` to regenerate
 
@@ -6940,8 +7154,8 @@ var CodexTomlWriter = {
     if (mcps.size === 0) {
       return { filesWritten: [] };
     }
-    const configPath = join17(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname3(configPath);
+    const configPath = join18(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname4(configPath);
     await mkdir7(parentDir, { recursive: true });
     const mcpServers = {};
     for (const [id, mcp] of mcps) {
@@ -6959,7 +7173,8 @@ var CodexTomlWriter = {
     const tomlContent = FILE_HEADER + stringify(codexConfig);
     await writeFile15(configPath, tomlContent, "utf-8");
     return {
-      filesWritten: [ctx.outputPath]
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [createManagedOutput(ctx.outputPath, this.id, tomlContent)]
     };
   }
 };
@@ -6974,7 +7189,7 @@ var codexAdapter = {
     { writer: CodexTomlWriter, outputPath: ".codex/config.toml" }
   ],
   async init(ctx) {
-    const codexDir = join18(ctx.projectRoot, ".codex");
+    const codexDir = join19(ctx.projectRoot, ".codex");
     mkdirSync6(codexDir, { recursive: true });
     return {
       filesCreated: [".codex/"],
@@ -6987,17 +7202,18 @@ var codexAdapter = {
     const result = await executeWriters(this.writers, providerBundle, ctx.projectRoot, providerId);
     return {
       filesWritten: result.filesWritten,
-      filesDeleted: []
+      filesDeleted: [],
+      managedOutputs: result.managedOutputs
     };
   }
 };
 // ../adapters/src/cursor/index.ts
 import { mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 
 // ../adapters/src/writers/cursor/agents.ts
 import { mkdir as mkdir8, writeFile as writeFile16 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 function mapModelToCursor(model) {
   if (!model || model === "inherit")
     return "inherit";
@@ -7029,50 +7245,58 @@ function generateFrontmatter2(agent) {
 var CursorAgentsWriter = {
   id: "cursor-agents",
   async write(bundle, ctx) {
-    const agentsDir = join19(ctx.projectRoot, ctx.outputPath);
+    const agentsDir = join20(ctx.projectRoot, ctx.outputPath);
     await mkdir8(agentsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const agent of bundle.subagents) {
       const frontmatter = generateFrontmatter2(agent);
       const content = `${frontmatter}
 
 ${agent.systemPrompt}`;
-      const agentPath = join19(agentsDir, `${agent.name}.md`);
+      const agentPath = join20(agentsDir, `${agent.name}.md`);
       await writeFile16(agentPath, content, "utf-8");
-      filesWritten.push(join19(ctx.outputPath, `${agent.name}.md`));
+      const relativePath = join20(ctx.outputPath, `${agent.name}.md`);
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
 // ../adapters/src/writers/cursor/commands.ts
 import { mkdir as mkdir9, writeFile as writeFile17 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 var CursorCommandsWriter = {
   id: "cursor-commands",
   async write(bundle, ctx) {
-    const commandsDir = join20(ctx.projectRoot, ctx.outputPath);
+    const commandsDir = join21(ctx.projectRoot, ctx.outputPath);
     await mkdir9(commandsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const command of bundle.commands) {
       const content = `# ${command.name}
 
 ${command.description}
 
 ${command.prompt}`;
-      const commandPath = join20(commandsDir, `${command.name}.md`);
+      const commandPath = join21(commandsDir, `${command.name}.md`);
       await writeFile17(commandPath, content, "utf-8");
-      filesWritten.push(join20(ctx.outputPath, `${command.name}.md`));
+      const relativePath = join21(ctx.outputPath, `${command.name}.md`);
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
 // ../adapters/src/writers/cursor/mcp-json.ts
 import { mkdir as mkdir10, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname4, join as join21 } from "node:path";
+import { dirname as dirname5, join as join22 } from "node:path";
 function buildCursorMcpConfig(mcp) {
   const transport = mcp.transport ?? "stdio";
   if (transport === "http" || transport === "sse") {
@@ -7117,8 +7341,8 @@ var CursorMcpJsonWriter = {
     if (mcps.size === 0) {
       return { filesWritten: [] };
     }
-    const configPath = join21(ctx.projectRoot, ctx.outputPath);
-    const parentDir = dirname4(configPath);
+    const configPath = join22(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname5(configPath);
     await mkdir10(parentDir, { recursive: true });
     const mcpServers = {};
     for (const [id, mcp] of mcps) {
@@ -7133,29 +7357,35 @@ var CursorMcpJsonWriter = {
     const cursorMcpJson = {
       mcpServers
     };
-    await writeFile18(configPath, `${JSON.stringify(cursorMcpJson, null, 2)}
-`, "utf-8");
+    const content = `${JSON.stringify(cursorMcpJson, null, 2)}
+`;
+    await writeFile18(configPath, content, "utf-8");
     return {
-      filesWritten: [ctx.outputPath]
+      filesWritten: [ctx.outputPath],
+      managedOutputs: [createManagedOutput(ctx.outputPath, this.id, content)]
     };
   }
 };
 // ../adapters/src/writers/cursor/rules.ts
 import { mkdir as mkdir11, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 var CursorRulesWriter = {
   id: "cursor-rules",
   async write(bundle, ctx) {
-    const rulesDir = join22(ctx.projectRoot, ctx.outputPath);
+    const rulesDir = join23(ctx.projectRoot, ctx.outputPath);
     await mkdir11(rulesDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const rule of bundle.rules) {
-      const rulePath = join22(rulesDir, `omnidev-${rule.name}.mdc`);
+      const rulePath = join23(rulesDir, `omnidev-${rule.name}.mdc`);
       await writeFile19(rulePath, rule.content, "utf-8");
-      filesWritten.push(join22(ctx.outputPath, `omnidev-${rule.name}.mdc`));
+      const relativePath = join23(ctx.outputPath, `omnidev-${rule.name}.mdc`);
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, rule.content));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
@@ -7172,7 +7402,7 @@ var cursorAdapter = {
     { writer: CursorMcpJsonWriter, outputPath: ".cursor/mcp.json" }
   ],
   async init(ctx) {
-    const rulesDir = join23(ctx.projectRoot, ".cursor", "rules");
+    const rulesDir = join24(ctx.projectRoot, ".cursor", "rules");
     mkdirSync7(rulesDir, { recursive: true });
     return {
       filesCreated: [".cursor/rules/"],
@@ -7192,17 +7422,18 @@ var cursorAdapter = {
       filesWritten: [
         ...new Set([...instructionsResult.filesWritten, ...cursorResult.filesWritten])
       ],
-      filesDeleted: []
+      filesDeleted: [],
+      managedOutputs: [...instructionsResult.managedOutputs, ...cursorResult.managedOutputs]
     };
   }
 };
 // ../adapters/src/opencode/index.ts
 import { mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 
 // ../adapters/src/writers/opencode/agents.ts
 import { mkdir as mkdir12, writeFile as writeFile20 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function mapModelToOpenCode(model) {
   if (!model || model === "inherit")
     return;
@@ -7280,26 +7511,30 @@ function generateFrontmatter3(agent) {
 var OpenCodeAgentsWriter = {
   id: "opencode-agents",
   async write(bundle, ctx) {
-    const agentsDir = join24(ctx.projectRoot, ctx.outputPath);
+    const agentsDir = join25(ctx.projectRoot, ctx.outputPath);
     await mkdir12(agentsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const agent of bundle.subagents) {
       const frontmatter = generateFrontmatter3(agent);
       const content = `${frontmatter}
 
 ${agent.systemPrompt}`;
-      const agentPath = join24(agentsDir, `${agent.name}.md`);
+      const agentPath = join25(agentsDir, `${agent.name}.md`);
       await writeFile20(agentPath, content, "utf-8");
-      filesWritten.push(join24(ctx.outputPath, `${agent.name}.md`));
+      const relativePath = join25(ctx.outputPath, `${agent.name}.md`);
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
 // ../adapters/src/writers/opencode/commands.ts
 import { mkdir as mkdir13, writeFile as writeFile21 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function generateFrontmatter4(command) {
   const lines = ["---"];
   lines.push(`description: "${command.description.replace(/"/g, "\\\"")}"`);
@@ -7316,20 +7551,24 @@ function generateFrontmatter4(command) {
 var OpenCodeCommandsWriter = {
   id: "opencode-commands",
   async write(bundle, ctx) {
-    const commandsDir = join25(ctx.projectRoot, ctx.outputPath);
+    const commandsDir = join26(ctx.projectRoot, ctx.outputPath);
     await mkdir13(commandsDir, { recursive: true });
     const filesWritten = [];
+    const managedOutputs = [];
     for (const command of bundle.commands) {
       const frontmatter = generateFrontmatter4(command);
       const content = `${frontmatter}
 
 ${command.prompt}`;
-      const commandPath = join25(commandsDir, `${command.name}.md`);
+      const commandPath = join26(commandsDir, `${command.name}.md`);
       await writeFile21(commandPath, content, "utf-8");
-      filesWritten.push(join25(ctx.outputPath, `${command.name}.md`));
+      const relativePath = join26(ctx.outputPath, `${command.name}.md`);
+      filesWritten.push(relativePath);
+      managedOutputs.push(createManagedOutput(relativePath, this.id, content));
     }
     return {
-      filesWritten
+      filesWritten,
+      managedOutputs
     };
   }
 };
@@ -7344,7 +7583,7 @@ var opencodeAdapter = {
     { writer: OpenCodeCommandsWriter, outputPath: ".opencode/commands/" }
   ],
   async init(ctx) {
-    const opencodeDir = join26(ctx.projectRoot, ".opencode");
+    const opencodeDir = join27(ctx.projectRoot, ".opencode");
     mkdirSync8(opencodeDir, { recursive: true });
     return {
       filesCreated: [".opencode/"],
@@ -7357,7 +7596,8 @@ var opencodeAdapter = {
     const result = await executeWriters(this.writers, providerBundle, ctx.projectRoot, providerId);
     return {
       filesWritten: result.filesWritten,
-      filesDeleted: []
+      filesDeleted: [],
+      managedOutputs: result.managedOutputs
     };
   }
 };
@@ -7802,7 +8042,7 @@ var addRoutes = buildRouteMap({
 // src/commands/capability.ts
 import { existsSync as existsSync25, mkdirSync as mkdirSync9 } from "node:fs";
 import { writeFile as writeFile22 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 import { input } from "@inquirer/prompts";
 init_src();
 import { buildCommand as buildCommand2, buildRouteMap as buildRouteMap2 } from "@stricli/core";
@@ -8022,21 +8262,21 @@ async function runCapabilityNew(flags, capabilityId) {
     const name = toTitleCase(id);
     mkdirSync9(capabilityDir, { recursive: true });
     const capabilityToml = generateCapabilityToml2({ id, name });
-    await writeFile22(join27(capabilityDir, "capability.toml"), capabilityToml, "utf-8");
-    const skillDir = join27(capabilityDir, "skills", "getting-started");
+    await writeFile22(join28(capabilityDir, "capability.toml"), capabilityToml, "utf-8");
+    const skillDir = join28(capabilityDir, "skills", "getting-started");
     mkdirSync9(skillDir, { recursive: true });
-    await writeFile22(join27(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
-    const rulesDir = join27(capabilityDir, "rules");
+    await writeFile22(join28(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
+    const rulesDir = join28(capabilityDir, "rules");
     mkdirSync9(rulesDir, { recursive: true });
-    await writeFile22(join27(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
-    const hooksDir = join27(capabilityDir, "hooks");
+    await writeFile22(join28(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
+    const hooksDir = join28(capabilityDir, "hooks");
     mkdirSync9(hooksDir, { recursive: true });
-    await writeFile22(join27(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
-    await writeFile22(join27(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
-    await writeFile22(join27(capabilityDir, ".gitignore"), generateGitignore(Boolean(flags.programmatic)), "utf-8");
+    await writeFile22(join28(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
+    await writeFile22(join28(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
+    await writeFile22(join28(capabilityDir, ".gitignore"), generateGitignore(Boolean(flags.programmatic)), "utf-8");
     if (flags.programmatic) {
-      await writeFile22(join27(capabilityDir, "package.json"), generatePackageJson(id), "utf-8");
-      await writeFile22(join27(capabilityDir, "index.ts"), generateIndexTs(id, name), "utf-8");
+      await writeFile22(join28(capabilityDir, "package.json"), generatePackageJson(id), "utf-8");
+      await writeFile22(join28(capabilityDir, "index.ts"), generateIndexTs(id, name), "utf-8");
     }
     console.log(`✓ Created capability: ${name}`);
     console.log(`  Location: ${capabilityDir}`);
@@ -8691,6 +8931,8 @@ async function runProfileSet(profileName) {
 }
 
 // src/commands/provider.ts
+import { existsSync as existsSync29 } from "node:fs";
+import { readFile as readFile22 } from "node:fs/promises";
 init_src();
 import { buildCommand as buildCommand6, buildRouteMap as buildRouteMap4 } from "@stricli/core";
 async function runProviderList() {
@@ -8724,6 +8966,7 @@ async function runProviderEnable(_flags, providerId) {
   }
   await enableProvider(providerId);
   console.log(`✓ Enabled provider: ${adapter.displayName}`);
+  await maybeRemindAboutProviderGitignore(providerId);
   const enabledAdapters = await getEnabledAdapters();
   await syncAgentConfiguration({ silent: false, adapters: enabledAdapters });
 }
@@ -8804,10 +9047,33 @@ var providerRoutes = buildRouteMap4({
     brief: "Manage AI provider adapters"
   }
 });
+async function maybeRemindAboutProviderGitignore(providerId) {
+  const missingEntries = await getMissingGitignoreEntries(getProviderGitignoreFiles([providerId]));
+  if (missingEntries.length === 0) {
+    return;
+  }
+  console.log("");
+  console.log("Also update your .gitignore to ignore provider files if you do not want to commit them:");
+  for (const entry of missingEntries) {
+    console.log(`  - ${entry}`);
+  }
+}
+async function getMissingGitignoreEntries(entries) {
+  if (entries.length === 0) {
+    return [];
+  }
+  let content = "";
+  if (existsSync29(".gitignore")) {
+    content = await readFile22(".gitignore", "utf-8");
+  }
+  const lines = new Set(content.split(`
+`).map((line) => line.trim()));
+  return [...new Set(entries)].filter((entry) => !lines.has(entry));
+}
 
 // src/commands/security.ts
 init_src();
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 import { buildCommand as buildCommand7, buildRouteMap as buildRouteMap5 } from "@stricli/core";
 var VALID_FINDING_TYPES = [
   "unicode_bidi",
@@ -8926,7 +9192,7 @@ function formatFindingsWithHints(summary) {
 }
 async function runSecurityIssues(flags = {}) {
   try {
-    if (!existsSync29("omni.toml")) {
+    if (!existsSync30("omni.toml")) {
       console.log("No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -9181,7 +9447,7 @@ var securityRoutes = buildRouteMap5({
 });
 
 // src/commands/sync.ts
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync31 } from "node:fs";
 init_src();
 import { buildCommand as buildCommand8 } from "@stricli/core";
 var PROVIDERS_STATE_PATH = ".omni/state/providers.json";
@@ -9199,7 +9465,7 @@ async function runSync() {
     const config3 = await loadConfig();
     const activeProfile = await getActiveProfile() ?? "default";
     let adapters = await getEnabledAdapters();
-    if (!existsSync30(PROVIDERS_STATE_PATH) || adapters.length === 0) {
+    if (!existsSync31(PROVIDERS_STATE_PATH) || adapters.length === 0) {
       console.log("No providers configured yet. Select your provider(s):");
       const providerIds = await promptForProviders();
       await writeEnabledProviders(providerIds);
@@ -9409,9 +9675,9 @@ async function buildDynamicApp() {
     security: securityRoutes
   };
   debug("Core routes registered", Object.keys(routes));
-  const configPath = join28(process.cwd(), "omni.toml");
-  debug("Checking for config", { configPath, exists: existsSync31(configPath), cwd: process.cwd() });
-  if (existsSync31(configPath)) {
+  const configPath = join29(process.cwd(), "omni.toml");
+  debug("Checking for config", { configPath, exists: existsSync32(configPath), cwd: process.cwd() });
+  if (existsSync32(configPath)) {
     try {
       debug("Loading capability commands...");
       const capabilityCommands = await loadCapabilityCommands();
@@ -9486,25 +9752,25 @@ async function loadCapabilityCommands() {
   return commands;
 }
 async function loadCapabilityExport(capability3) {
-  const capabilityPath = join28(process.cwd(), capability3.path);
-  const builtIndexPath = join28(capabilityPath, "dist", "index.js");
-  const jsIndexPath = join28(capabilityPath, "index.js");
-  const tsIndexPath = join28(capabilityPath, "index.ts");
+  const capabilityPath = join29(process.cwd(), capability3.path);
+  const builtIndexPath = join29(capabilityPath, "dist", "index.js");
+  const jsIndexPath = join29(capabilityPath, "index.js");
+  const tsIndexPath = join29(capabilityPath, "index.ts");
   debug(`Checking entry points for '${capability3.id}'`, {
     capabilityPath,
     builtIndexPath,
-    builtExists: existsSync31(builtIndexPath),
+    builtExists: existsSync32(builtIndexPath),
     jsIndexPath,
-    jsExists: existsSync31(jsIndexPath),
+    jsExists: existsSync32(jsIndexPath),
     tsIndexPath,
-    tsExists: existsSync31(tsIndexPath)
+    tsExists: existsSync32(tsIndexPath)
   });
   let indexPath = null;
-  if (existsSync31(builtIndexPath)) {
+  if (existsSync32(builtIndexPath)) {
     indexPath = builtIndexPath;
-  } else if (existsSync31(jsIndexPath)) {
+  } else if (existsSync32(jsIndexPath)) {
     indexPath = jsIndexPath;
-  } else if (existsSync31(tsIndexPath)) {
+  } else if (existsSync32(tsIndexPath)) {
     indexPath = tsIndexPath;
   }
   if (!indexPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@omnidev-ai/cli",
-	"version": "0.18.0",
+	"version": "0.18.1",
 	"type": "module",
 	"license": "MIT",
 	"imports": {