omniagent 0.1.5 → 0.1.6

package/dist/cli.js

@@ -38,7 +38,7 @@ async function findRepoRoot(startDir) {
   }
   return await findUp(startDir, "package.json");
 }
-function hashIdentifier$3(value) {
+function hashIdentifier$4(value) {
   return createHash("sha256").update(value).digest("hex");
 }
 async function pathExists$1(candidate) {
@@ -72,7 +72,7 @@ async function listRepoSlashCommandManifestPaths(repoRoot) {
   return matches;
 }
 function resolveRepoScopedStatePaths(repoRoot, homeDir) {
-  const repoHash = hashIdentifier$3(repoRoot);
+  const repoHash = hashIdentifier$4(repoRoot);
   return [
     path.join(homeDir, ".omniagent", "state", "managed-outputs", "projects", repoHash),
     path.join(homeDir, ".omniagent", "state", "instructions", "projects", repoHash),
@@ -333,11 +333,20 @@ function matchAny(name, patterns) {
   }
   return matched;
 }
+function normalizeItemSelection(item) {
+  if (!item) {
+    return { canonicalName: "", enabledByDefault: true };
+  }
+  if (typeof item === "string") {
+    return { canonicalName: item, enabledByDefault: true };
+  }
+  return item;
+}
 function createProfileItemFilter(resolved) {
   if (!resolved || resolved.names.length === 0) {
     return {
       enabled: false,
-      includes: () => true,
+      includes: (_category, item) => normalizeItemSelection(item).enabledByDefault,
       collectUnknownWarnings: () => []
     };
   }
@@ -349,17 +358,20 @@ function createProfileItemFilter(resolved) {
   }
   return {
     enabled: true,
-    includes(category, canonicalName) {
+    includes(category, item) {
+      const { canonicalName, enabledByDefault } = normalizeItemSelection(item);
       const enablePatterns = enablePatternsByCategory.get(category) ?? [];
       const disablePatterns = disablePatternsByCategory.get(category) ?? [];
       const enableApplies = enablePatterns.length > 0;
-      if (enableApplies && !matchAny(canonicalName, enablePatterns)) {
+      const enableMatches = matchAny(canonicalName, enablePatterns);
+      const disableMatches = matchAny(canonicalName, disablePatterns);
+      if (disableMatches) {
         return false;
       }
-      if (matchAny(canonicalName, disablePatterns)) {
-        return false;
+      if (enableApplies) {
+        return enableMatches;
       }
-      return true;
+      return enabledByDefault;
     },
     collectUnknownWarnings() {
       const warnings = [];
@@ -976,6 +988,28 @@ async function listSkillDirectories(root) {
   }
   return directories;
 }
+const SYNC_ROUTING_FRONTMATTER_KEYS = /* @__PURE__ */ new Set(["targets", "targetagents", "enabled"]);
+function resolveFrontmatterEnabledByDefault(options) {
+  const rawEnabled = options.frontmatter.enabled;
+  if (rawEnabled === void 0) {
+    return true;
+  }
+  if (Array.isArray(rawEnabled)) {
+    throw new Error(
+      `${options.itemKind} "${options.itemName}" has invalid enabled value in ${options.sourcePath}. Expected true or false.`
+    );
+  }
+  const normalized = rawEnabled.trim().toLowerCase();
+  if (normalized === "true") {
+    return true;
+  }
+  if (normalized === "false") {
+    return false;
+  }
+  throw new Error(
+    `${options.itemKind} "${options.itemName}" has invalid enabled value "${rawEnabled}" in ${options.sourcePath}. Expected true or false.`
+  );
+}
 function resolveLocalPrecedence(options) {
   const local = [...options.localPath, ...options.localSuffix];
   const localPathKeys = new Set(options.localPath.map(options.key));
@@ -1389,7 +1423,6 @@ function stripFrontmatterFields(contents, keysToRemove) {
   const outputLines = [lines[0], ...filtered, ...lines.slice(endIndex)];
   return outputLines.join(eol);
 }
-const TARGET_FRONTMATTER_KEYS$3 = /* @__PURE__ */ new Set(["targets", "targetagents"]);
 function isSlashCommandLike(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -1459,7 +1492,7 @@ const copilotTarget = {
             outputs: [
               {
                 outputPath: agentPath,
-                content: stripFrontmatterFields(item.rawContents, TARGET_FRONTMATTER_KEYS$3)
+                content: stripFrontmatterFields(item.rawContents, SYNC_ROUTING_FRONTMATTER_KEYS)
               },
               {
                 outputPath: promptPath,
@@ -1534,7 +1567,7 @@ const BUILTIN_TARGETS = [
   copilotTarget
 ];
 Object.freeze(BUILTIN_TARGETS.map((target) => target.id));
-function resolveSkillName(frontmatter, fallback) {
+function resolveSkillName$1(frontmatter, fallback) {
   const rawName = frontmatter.name;
   if (typeof rawName === "string") {
     const trimmed = rawName.trim();
@@ -1547,7 +1580,7 @@ function resolveSkillName(frontmatter, fallback) {
 function normalizeSkillKey$1(relativePath) {
   return path.normalize(relativePath).replace(/\\/g, "/").toLowerCase();
 }
-function resolveSkillRelativePath(skillsRoot, directoryPath) {
+function resolveSkillRelativePath$1(skillsRoot, directoryPath) {
   const relativePath = path.relative(skillsRoot, directoryPath);
   if (!relativePath) {
     return { relativePath, hadLocalSuffix: false };
@@ -1561,6 +1594,16 @@ function resolveSkillRelativePath(skillsRoot, directoryPath) {
   const normalized = parent === "." ? strippedBase : path.join(parent, strippedBase);
   return { relativePath: normalized, hadLocalSuffix: true };
 }
+function resolveSkillRoutingError(options) {
+  if (options.invalidTargets.length > 0) {
+    const invalidList = options.invalidTargets.join(", ");
+    return `Skill "${options.name}" has unsupported targets (${invalidList}) in ${options.sourcePath}.`;
+  }
+  if (hasRawTargetValues(options.rawTargets) && (!options.targets || options.targets.length === 0)) {
+    return `Skill "${options.name}" has empty targets in ${options.sourcePath}.`;
+  }
+  return null;
+}
 async function buildSkillDefinition(options) {
   let metadata;
   if (options.sourceType === "local") {
@@ -1576,24 +1619,32 @@ async function buildSkillDefinition(options) {
   const rawContents = await readFile(sourcePath, "utf8");
   const { frontmatter, body } = extractFrontmatter$1(rawContents);
   const relativePath = options.relativePath ?? path.relative(options.skillsRoot, options.directoryPath);
-  const name = resolveSkillName(frontmatter, relativePath || path.basename(options.directoryPath));
+  const name = resolveSkillName$1(frontmatter, relativePath || path.basename(options.directoryPath));
+  const enabledByDefault = resolveFrontmatterEnabledByDefault({
+    frontmatter,
+    itemKind: "Skill",
+    itemName: name,
+    sourcePath
+  });
   const rawTargets = [frontmatter.targets, frontmatter.targetAgents];
   const { targets, invalidTargets } = resolveFrontmatterTargets(
     rawTargets,
     options.resolveTargetName
   );
-  if (invalidTargets.length > 0) {
-    const invalidList = invalidTargets.join(", ");
-    throw new InvalidFrontmatterTargetsError(
-      `Skill "${name}" has unsupported targets (${invalidList}) in ${sourcePath}.`
-    );
-  }
-  if (hasRawTargetValues(rawTargets) && (!targets || targets.length === 0)) {
-    throw new InvalidFrontmatterTargetsError(`Skill "${name}" has empty targets in ${sourcePath}.`);
+  const routingError = resolveSkillRoutingError({
+    name,
+    sourcePath,
+    rawTargets,
+    targets,
+    invalidTargets
+  });
+  if (enabledByDefault && routingError) {
+    throw new InvalidFrontmatterTargetsError(routingError);
   }
   const { outputFileName } = stripLocalSuffix(options.skillFileName, ".md");
   return {
     name,
+    enabledByDefault,
     relativePath,
     directoryPath: options.directoryPath,
     sourcePath,
@@ -1606,9 +1657,15 @@ async function buildSkillDefinition(options) {
     frontmatter,
     body,
     targetAgents: targets,
-    invalidTargets
+    invalidTargets,
+    routingError
   };
 }
+function assertSkillDefinitionUsable(skill) {
+  if (skill.routingError) {
+    throw new InvalidFrontmatterTargetsError(skill.routingError);
+  }
+}
 async function loadSkillCatalog(repoRoot, options = {}) {
   const includeLocal = options.includeLocal ?? true;
   const fallbackResolver = createTargetNameResolver(BUILTIN_TARGETS).resolveTargetName;
@@ -1629,7 +1686,7 @@ async function loadSkillCatalog(repoRoot, options = {}) {
   const localPathSkills = [];
   const localSuffixSkills = [];
   for (const entry2 of sharedEntries) {
-    const { relativePath, hadLocalSuffix } = resolveSkillRelativePath(
+    const { relativePath, hadLocalSuffix } = resolveSkillRelativePath$1(
       skillsRoot,
       entry2.directoryPath
     );
@@ -1686,7 +1743,7 @@ async function loadSkillCatalog(repoRoot, options = {}) {
       if (!skillFileName) {
         continue;
       }
-      const { relativePath } = resolveSkillRelativePath(localSkillsRoot, entry2.directoryPath);
+      const { relativePath } = resolveSkillRelativePath$1(localSkillsRoot, entry2.directoryPath);
       localPathSkills.push(
         await buildSkillDefinition({
           directoryPath: entry2.directoryPath,
@@ -1740,7 +1797,13 @@ async function buildCommandDefinition(options) {
   const contents = await readFile(options.filePath, "utf8");
   const { frontmatter, body } = extractFrontmatter$1(contents);
   const prompt = body.trimEnd();
-  if (!prompt.trim()) {
+  const enabledByDefault = resolveFrontmatterEnabledByDefault({
+    frontmatter,
+    itemKind: "Slash command",
+    itemName: options.commandName,
+    sourcePath: options.filePath
+  });
+  if (enabledByDefault && !prompt.trim()) {
     throw new Error(`Slash command "${options.commandName}" has an empty prompt.`);
   }
   const rawTargets = [frontmatter.targets, frontmatter.targetAgents];
@@ -1748,16 +1811,15 @@ async function buildCommandDefinition(options) {
     rawTargets,
     options.resolveTargetName
   );
+  let routingError = null;
   if (invalidTargets.length > 0) {
     const invalidList = invalidTargets.join(", ");
-    throw new InvalidFrontmatterTargetsError(
-      `Slash command "${options.commandName}" has unsupported targets (${invalidList}) in ${options.filePath}.`
-    );
+    routingError = `Slash command "${options.commandName}" has unsupported targets (${invalidList}) in ${options.filePath}.`;
+  } else if (hasRawTargetValues(rawTargets) && (!targets || targets.length === 0)) {
+    routingError = `Slash command "${options.commandName}" has empty targets in ${options.filePath}.`;
   }
-  if (hasRawTargetValues(rawTargets) && (!targets || targets.length === 0)) {
-    throw new InvalidFrontmatterTargetsError(
-      `Slash command "${options.commandName}" has empty targets in ${options.filePath}.`
-    );
+  if (enabledByDefault && routingError) {
+    throw new InvalidFrontmatterTargetsError(routingError);
   }
   let metadata;
   if (options.sourceType === "local") {
@@ -1771,6 +1833,7 @@ async function buildCommandDefinition(options) {
   }
   return {
     name: options.commandName,
+    enabledByDefault,
     prompt,
     sourcePath: options.filePath,
     sourceType: metadata.sourceType,
@@ -1779,9 +1842,18 @@ async function buildCommandDefinition(options) {
     rawContents: contents,
     targetAgents: targets,
     invalidTargets,
-    frontmatter
+    frontmatter,
+    routingError
   };
 }
+function assertSlashCommandDefinitionUsable(command) {
+  if (!command.prompt.trim()) {
+    throw new Error(`Slash command "${command.name}" has an empty prompt.`);
+  }
+  if (command.routingError) {
+    throw new InvalidFrontmatterTargetsError(command.routingError);
+  }
+}
 function registerUniqueName$1(seen, commandName, filePath) {
   const lowerName = normalizeName(commandName);
   if (seen.has(lowerName)) {
@@ -2003,9 +2075,6 @@ async function buildSubagentDefinition(options) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Invalid frontmatter in ${options.filePath}: ${message}`);
   }
-  if (!body.trim()) {
-    throw new Error(`Subagent file has empty body: ${options.filePath}.`);
-  }
   let resolvedName;
   try {
     resolvedName = resolveSubagentName(frontmatter, options.fileName);
@@ -2013,21 +2082,29 @@ async function buildSubagentDefinition(options) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Invalid frontmatter in ${options.filePath}: ${message}`);
   }
+  const enabledByDefault = resolveFrontmatterEnabledByDefault({
+    frontmatter,
+    itemKind: "Subagent",
+    itemName: resolvedName,
+    sourcePath: options.filePath
+  });
+  if (enabledByDefault && !body.trim()) {
+    throw new Error(`Subagent file has empty body: ${options.filePath}.`);
+  }
   const rawTargets = [frontmatter.targets, frontmatter.targetAgents];
   const { targets, invalidTargets } = resolveFrontmatterTargets(
     rawTargets,
     options.resolveTargetName
   );
+  let routingError = null;
   if (invalidTargets.length > 0) {
     const invalidList = invalidTargets.join(", ");
-    throw new InvalidFrontmatterTargetsError(
-      `Subagent "${resolvedName}" has unsupported targets (${invalidList}) in ${options.filePath}.`
-    );
+    routingError = `Subagent "${resolvedName}" has unsupported targets (${invalidList}) in ${options.filePath}.`;
+  } else if (hasRawTargetValues(rawTargets) && (!targets || targets.length === 0)) {
+    routingError = `Subagent "${resolvedName}" has empty targets in ${options.filePath}.`;
   }
-  if (hasRawTargetValues(rawTargets) && (!targets || targets.length === 0)) {
-    throw new InvalidFrontmatterTargetsError(
-      `Subagent "${resolvedName}" has empty targets in ${options.filePath}.`
-    );
+  if (enabledByDefault && routingError) {
+    throw new InvalidFrontmatterTargetsError(routingError);
   }
   let metadata;
   if (options.sourceType === "local") {
@@ -2041,6 +2118,7 @@ async function buildSubagentDefinition(options) {
   }
   return {
     resolvedName,
+    enabledByDefault,
     sourcePath: options.filePath,
     fileName: options.fileName,
     sourceType: metadata.sourceType,
@@ -2050,9 +2128,18 @@ async function buildSubagentDefinition(options) {
     frontmatter,
     body,
     targetAgents: targets,
-    invalidTargets
+    invalidTargets,
+    routingError
   };
 }
+function assertSubagentDefinitionUsable(subagent) {
+  if (!subagent.body.trim()) {
+    throw new Error(`Subagent file has empty body: ${subagent.sourcePath}.`);
+  }
+  if (subagent.routingError) {
+    throw new InvalidFrontmatterTargetsError(subagent.routingError);
+  }
+}
 function registerUniqueName(seen, resolvedName, filePath) {
   const nameKey = normalizeName(resolvedName);
   const existingPath = seen.get(nameKey);
@@ -2863,23 +2950,64 @@ async function loadProfileValidationCatalog(repoRoot, agentsDir) {
   ]);
   return {
     resolveTargetName,
-    skillNames: skillCatalog.skills.map((skill) => skill.name),
-    commandNames: commandCatalog.commands.map((command) => command.name),
-    subagentNames: subagentCatalog.subagents.map((subagent) => subagent.resolvedName)
+    skills: skillCatalog.skills,
+    commands: commandCatalog.commands,
+    subagents: subagentCatalog.subagents
   };
 }
 function collectProfileReferenceIssues(profileName, resolvedProfile, catalog) {
   const filter = createProfileItemFilter(resolvedProfile);
-  for (const skillName of catalog.skillNames) {
-    filter.includes("skills", skillName);
+  const issues = [];
+  for (const skill of catalog.skills) {
+    const included = filter.includes("skills", {
+      canonicalName: skill.name,
+      enabledByDefault: skill.enabledByDefault
+    });
+    if (!included) {
+      continue;
+    }
+    try {
+      assertSkillDefinitionUsable(skill);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      issues.push(`profile "${profileName}" includes unusable skill "${skill.name}": ${message}`);
+    }
   }
-  for (const commandName of catalog.commandNames) {
-    filter.includes("commands", commandName);
+  for (const command of catalog.commands) {
+    const included = filter.includes("commands", {
+      canonicalName: command.name,
+      enabledByDefault: command.enabledByDefault
+    });
+    if (!included) {
+      continue;
+    }
+    try {
+      assertSlashCommandDefinitionUsable(command);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      issues.push(
+        `profile "${profileName}" includes unusable command "${command.name}": ${message}`
+      );
+    }
   }
-  for (const subagentName of catalog.subagentNames) {
-    filter.includes("subagents", subagentName);
+  for (const subagent of catalog.subagents) {
+    const included = filter.includes("subagents", {
+      canonicalName: subagent.resolvedName,
+      enabledByDefault: subagent.enabledByDefault
+    });
+    if (!included) {
+      continue;
+    }
+    try {
+      assertSubagentDefinitionUsable(subagent);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      issues.push(
+        `profile "${profileName}" includes unusable subagent "${subagent.resolvedName}": ${message}`
+      );
+    }
   }
-  const issues = filter.collectUnknownWarnings();
+  issues.push(...filter.collectUnknownWarnings());
   for (const targetName of Object.keys(resolvedProfile.targets)) {
     if (catalog.resolveTargetName(targetName)) {
       continue;
@@ -3232,11 +3360,11 @@ function applyAgentTemplating(options) {
     sourcePath: options.sourcePath
   });
 }
-function hashIdentifier$2(value) {
+function hashIdentifier$3(value) {
   return createHash("sha256").update(value).digest("hex");
 }
 function resolveIgnorePreferencePath(repoRoot, homeDir = os.homedir()) {
-  const repoHash = hashIdentifier$2(repoRoot);
+  const repoHash = hashIdentifier$3(repoRoot);
   return path.join(homeDir, ".omniagent", "state", "ignore-rules", "projects", `${repoHash}.json`);
 }
 async function readIgnorePreference(repoRoot, homeDir = os.homedir()) {
@@ -3248,7 +3376,7 @@ async function readIgnorePreference(repoRoot, homeDir = os.homedir()) {
       return null;
     }
     return {
-      projectId: parsed.projectId ?? hashIdentifier$2(repoRoot),
+      projectId: parsed.projectId ?? hashIdentifier$3(repoRoot),
       ignorePromptDeclined: parsed.ignorePromptDeclined,
       updatedAt: parsed.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString()
     };
@@ -3263,7 +3391,7 @@ async function readIgnorePreference(repoRoot, homeDir = os.homedir()) {
 async function recordIgnorePromptDeclined(repoRoot, homeDir = os.homedir()) {
   const filePath = resolveIgnorePreferencePath(repoRoot, homeDir);
   const preference = {
-    projectId: hashIdentifier$2(repoRoot),
+    projectId: hashIdentifier$3(repoRoot),
     ignorePromptDeclined: true,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -3957,7 +4085,7 @@ async function runConvertHook(hooks, stage, context) {
   }
   await runHook(hooks[stage], context);
 }
-function hashIdentifier$1(value) {
+function hashIdentifier$2(value) {
   return createHash("sha256").update(value).digest("hex");
 }
 function hashContent$1(value) {
@@ -4018,7 +4146,7 @@ async function hashOutputPath(outputPath) {
   }
 }
 function resolveManagedOutputsPath(repoRoot, homeDir = os.homedir()) {
-  const repoHash = hashIdentifier$1(repoRoot);
+  const repoHash = hashIdentifier$2(repoRoot);
   const baseDir = path.join(
     homeDir,
     ".omniagent",
@@ -4547,9 +4675,8 @@ function listTemplateScriptExecutions(runtime) {
   );
 }
 const utf8Decoder$1 = new TextDecoder("utf-8", { fatal: true });
-const TARGET_FRONTMATTER_KEYS$2 = /* @__PURE__ */ new Set(["targets", "targetagents"]);
 const SKILL_FRONTMATTER_KEYS_TO_REMOVE = /* @__PURE__ */ new Set([
-  ...TARGET_FRONTMATTER_KEYS$2,
+  ...SYNC_ROUTING_FRONTMATTER_KEYS,
   "tools",
   "model",
   "color"
@@ -4741,7 +4868,7 @@ async function copySkillDirectory(options) {
       validAgents: options.validAgents,
       sourcePath: winner.sourcePath
     });
-    const output = winner.isSkillFile ? stripFrontmatterFields(templated, TARGET_FRONTMATTER_KEYS$2) : templated;
+    const output = winner.isSkillFile ? stripFrontmatterFields(templated, SYNC_ROUTING_FRONTMATTER_KEYS) : templated;
     await mkdir(path.dirname(winner.destinationPath), { recursive: true });
     await writeFile(winner.destinationPath, output, "utf8");
   }
@@ -4785,7 +4912,7 @@ const defaultSubagentWriter = {
       validAgents: options.context.validAgents,
       sourcePath: item.sourcePath
     });
-    const cleaned = item.outputKind === "skill" ? stripFrontmatterFields(templated, SKILL_FRONTMATTER_KEYS_TO_REMOVE) : stripFrontmatterFields(templated, TARGET_FRONTMATTER_KEYS$2);
+    const cleaned = item.outputKind === "skill" ? stripFrontmatterFields(templated, SKILL_FRONTMATTER_KEYS_TO_REMOVE) : stripFrontmatterFields(templated, SYNC_ROUTING_FRONTMATTER_KEYS);
     if (item.outputKind === "skill") {
       const destinationPath = path.join(options.outputPath, "SKILL.md");
       return writeOutputFile(destinationPath, cleaned);
@@ -4806,16 +4933,16 @@ const defaultInstructionWriter = {
 async function writeFileOutput(outputPath, content) {
   return writeOutputFile(outputPath, content);
 }
-function hashIdentifier(value) {
+function hashIdentifier$1(value) {
   return createHash("sha256").update(value).digest("hex");
 }
-function resolveManifestPath(repoRoot, homeDir = os.homedir()) {
-  const repoHash = hashIdentifier(repoRoot);
+function resolveManifestPath$1(repoRoot, homeDir = os.homedir()) {
+  const repoHash = hashIdentifier$1(repoRoot);
   const baseDir = path.join(homeDir, ".omniagent", "state", "instructions", "projects", repoHash);
   return path.join(baseDir, "instruction-outputs.json");
 }
-async function readManifest(repoRoot, homeDir) {
-  const manifestPath = resolveManifestPath(repoRoot, homeDir);
+async function readManifest$1(repoRoot, homeDir) {
+  const manifestPath = resolveManifestPath$1(repoRoot, homeDir);
   try {
     const contents = await readFile(manifestPath, "utf8");
     const parsed = JSON.parse(contents);
@@ -4828,7 +4955,7 @@ async function readManifest(repoRoot, homeDir) {
   }
 }
 async function writeManifest(repoRoot, manifest, homeDir) {
-  const manifestPath = resolveManifestPath(repoRoot, homeDir);
+  const manifestPath = resolveManifestPath$1(repoRoot, homeDir);
   const sorted = [...manifest.entries].sort((left, right) => {
     const targetCompare = left.targetName.localeCompare(right.targetName);
     if (targetCompare !== 0) {
@@ -5397,7 +5524,7 @@ async function syncInstructions(request) {
       groupResult.hadFailure = true;
     }
   }
-  const previousManifest = await readManifest(request.repoRoot) ?? { entries: [] };
+  const previousManifest = await readManifest$1(request.repoRoot) ?? { entries: [] };
   const previousEntries = /* @__PURE__ */ new Map();
   for (const entry2 of previousManifest.entries) {
     const group = resolveInstructionTargetGroup(entry2.targetName);
@@ -5649,6 +5776,9 @@ function formatDisplayPath$3(repoRoot, absolutePath) {
   const isWithinRepo = relative && !relative.startsWith("..") && !path.isAbsolute(relative);
   return isWithinRepo ? relative : absolutePath;
 }
+function buildManagedOutputPathKey(entry2) {
+  return `${entry2.targetId}:${normalizeManagedOutputPath(entry2.outputPath)}`;
+}
 function buildInvalidTargetWarnings$2(skills) {
   const warnings = [];
   for (const skill of skills) {
@@ -5662,6 +5792,20 @@ function buildInvalidTargetWarnings$2(skills) {
   }
   return warnings;
 }
+function assertUsableSkillsForTargets(options) {
+  for (const skill of options.skills) {
+    const effectiveTargets = resolveEffectiveTargets({
+      defaultTargets: skill.targetAgents,
+      overrideOnly: options.overrideOnly ?? void 0,
+      overrideSkip: options.overrideSkip ?? void 0,
+      allTargets: options.allTargets
+    });
+    if (!effectiveTargets.some((targetId) => options.activeTargetIds.has(targetId))) {
+      continue;
+    }
+    assertSkillDefinitionUsable(skill);
+  }
+}
 async function syncSkills(request) {
   const templateScriptRuntime = request.templateScriptRuntime ?? createTemplateScriptRuntime({ cwd: request.repoRoot });
   const sourcePath = resolveSharedCategoryRoot(request.repoRoot, "skills", request.agentsDir);
@@ -5680,17 +5824,25 @@ async function syncSkills(request) {
     agentsDir: request.agentsDir,
     resolveTargetName: request.resolveTargetName
   });
-  if (request.includeItem) {
-    const includeItem = request.includeItem;
-    const predicate = (skill) => includeItem(skill.name);
-    catalog.skills = catalog.skills.filter(predicate);
-    catalog.sharedSkills = catalog.sharedSkills.filter(predicate);
-    catalog.localSkills = catalog.localSkills.filter(predicate);
-    catalog.localEffectiveSkills = catalog.localEffectiveSkills.filter(predicate);
-  }
-  const warnings = buildInvalidTargetWarnings$2(catalog.skills);
+  const includeItem = request.includeItem;
+  const predicate = (skill) => includeItem ? includeItem({
+    canonicalName: skill.name,
+    enabledByDefault: skill.enabledByDefault
+  }) : skill.enabledByDefault;
+  catalog.skills = catalog.skills.filter(predicate);
+  catalog.sharedSkills = catalog.sharedSkills.filter(predicate);
+  catalog.localSkills = catalog.localSkills.filter(predicate);
+  catalog.localEffectiveSkills = catalog.localEffectiveSkills.filter(predicate);
   const allTargetIds = request.targets.map((target) => target.id);
   const targetNames = new Set(skillTargets.map((target) => target.id));
+  assertUsableSkillsForTargets({
+    skills: catalog.skills,
+    activeTargetIds: targetNames,
+    overrideOnly: request.overrideOnly,
+    overrideSkip: request.overrideSkip,
+    allTargets: allTargetIds
+  });
+  const warnings = buildInvalidTargetWarnings$2(catalog.skills);
   const effectiveTargetsBySkill = /* @__PURE__ */ new Map();
   const activeSourcesByTarget = /* @__PURE__ */ new Map();
   for (const skill of catalog.skills) {
@@ -5950,7 +6102,13 @@ async function syncSkills(request) {
   if (managedManifest.entries.length > 0 || nextManaged.size > 0) {
     const updatedEntries = [];
     const managedTargetIds = new Set(skillTargets.map((target) => target.id));
+    const claimedSkillOutputPaths = new Set(
+      Array.from(nextManaged.values()).filter((entry2) => entry2.sourceType === "skill").map((entry2) => buildManagedOutputPathKey(entry2))
+    );
     for (const entry2 of managedManifest.entries) {
+      if (entry2.sourceType === "subagent" && claimedSkillOutputPaths.has(buildManagedOutputPathKey(entry2))) {
+        continue;
+      }
       if (entry2.sourceType !== "skill" || !managedTargetIds.has(entry2.targetId)) {
         updatedEntries.push(entry2);
         continue;
@@ -6075,11 +6233,10 @@ function formatTomlValue(value) {
 function formatYamlString(value) {
   return JSON.stringify(value);
 }
-const TARGET_FRONTMATTER_KEYS$1 = /* @__PURE__ */ new Set(["targets", "targetagents"]);
 function stripTargetMetadata(frontmatter) {
   const filtered = {};
   for (const [key, value] of Object.entries(frontmatter)) {
-    if (TARGET_FRONTMATTER_KEYS$1.has(key.toLowerCase())) {
+    if (SYNC_ROUTING_FRONTMATTER_KEYS.has(key.toLowerCase())) {
       continue;
     }
     filtered[key] = value;
@@ -6141,9 +6298,9 @@ function renderYamlFrontmatter(frontmatter, defaultName) {
   lines.push("---", "");
   return lines.join("\n");
 }
-const TOML_RESERVED_KEYS = /* @__PURE__ */ new Set(["prompt", "targets", "targetagents"]);
+const TOML_RESERVED_KEYS = /* @__PURE__ */ new Set(["prompt", ...SYNC_ROUTING_FRONTMATTER_KEYS]);
 function renderMarkdownCommand(command) {
-  return stripFrontmatterFields(command.rawContents, TARGET_FRONTMATTER_KEYS$1);
+  return stripFrontmatterFields(command.rawContents, SYNC_ROUTING_FRONTMATTER_KEYS);
 }
 function renderTomlCommand(command) {
   const lines = [];
@@ -6281,6 +6438,36 @@ function formatSyncSummary(summary, jsonOutput) {
   }
   return lines.join("\n");
 }
+function includeCommandByDefault(command, includeItem) {
+  if (!includeItem) {
+    return command.enabledByDefault;
+  }
+  return includeItem({
+    canonicalName: command.name,
+    enabledByDefault: command.enabledByDefault
+  });
+}
+function filterCommandCatalog(catalog, includeItem) {
+  const predicate = (command) => includeCommandByDefault(command, includeItem);
+  catalog.commands = catalog.commands.filter(predicate);
+  catalog.sharedCommands = catalog.sharedCommands.filter(predicate);
+  catalog.localCommands = catalog.localCommands.filter(predicate);
+  catalog.localEffectiveCommands = catalog.localEffectiveCommands.filter(predicate);
+}
+function assertUsableCommandsForTargets(options) {
+  for (const command of options.commands) {
+    const effectiveTargets = resolveEffectiveTargets({
+      defaultTargets: command.targetAgents,
+      overrideOnly: options.overrideOnly ?? void 0,
+      overrideSkip: options.overrideSkip ?? void 0,
+      allTargets: options.allTargets
+    });
+    if (!effectiveTargets.some((targetId) => options.activeTargetIds.has(targetId))) {
+      continue;
+    }
+    assertSlashCommandDefinitionUsable(command);
+  }
+}
 function renderCommandOutput(command, outputKind, outputPath) {
   if (outputKind === "skill") {
     return renderSkillFromCommand(command);
@@ -6310,14 +6497,7 @@ async function syncSlashCommands(request) {
     agentsDir: request.agentsDir,
     resolveTargetName: request.resolveTargetName
   });
-  if (request.includeItem) {
-    const includeItem = request.includeItem;
-    const predicate = (command) => includeItem(command.name);
-    catalog.commands = catalog.commands.filter(predicate);
-    catalog.sharedCommands = catalog.sharedCommands.filter(predicate);
-    catalog.localCommands = catalog.localCommands.filter(predicate);
-    catalog.localEffectiveCommands = catalog.localEffectiveCommands.filter(predicate);
-  }
+  filterCommandCatalog(catalog, request.includeItem);
   const targets = request.targets.filter(
     (target) => normalizeCommandOutputDefinition(target.outputs.commands) !== null
   );
@@ -6338,6 +6518,13 @@ async function syncSlashCommands(request) {
   const removeMissing = request.removeMissing ?? false;
   const allTargetIds = request.targets.map((target) => target.id);
   const activeTargetIds = new Set(targets.map((target) => target.id));
+  assertUsableCommandsForTargets({
+    commands: catalog.commands,
+    activeTargetIds,
+    overrideOnly: request.overrideOnly,
+    overrideSkip: request.overrideSkip,
+    allTargets: allTargetIds
+  });
   const effectiveTargetsByCommand = /* @__PURE__ */ new Map();
   const activeSourcesByTarget = /* @__PURE__ */ new Map();
   for (const command of catalog.commands) {
@@ -6803,9 +6990,95 @@ async function syncSlashCommands(request) {
     sourceCounts
   };
 }
-const TARGET_FRONTMATTER_KEYS = /* @__PURE__ */ new Set(["targets", "targetagents"]);
+function hashIdentifier(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function resolveManifestPath(repoRoot, targetName, homeDir) {
+  const repoHash = hashIdentifier(repoRoot);
+  const baseDir = path.join(homeDir, ".omniagent", "state", "subagents", "projects", repoHash);
+  return path.join(baseDir, `${targetName}.toml`);
+}
+function parseTomlValue(rawValue) {
+  const trimmed = rawValue.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return trimmed.slice(1, -1);
+    }
+  }
+  return trimmed;
+}
+function parseManifest(contents) {
+  const lines = contents.split(/\r?\n/);
+  let targetName = null;
+  const managedSubagents = [];
+  let current = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    if (trimmed === "[[managedSubagents]]") {
+      if (current?.name && current.hash && current.lastSyncedAt) {
+        managedSubagents.push({
+          name: current.name,
+          hash: current.hash,
+          lastSyncedAt: current.lastSyncedAt
+        });
+      }
+      current = {};
+      continue;
+    }
+    const match = trimmed.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+    if (!match) {
+      continue;
+    }
+    const [, key, rawValue] = match;
+    const value = parseTomlValue(rawValue);
+    if (current) {
+      if (key === "name") {
+        current.name = value;
+        continue;
+      }
+      if (key === "hash") {
+        current.hash = value;
+        continue;
+      }
+      if (key === "lastSyncedAt") {
+        current.lastSyncedAt = value;
+        continue;
+      }
+    }
+    if (key === "targetName") {
+      targetName = value;
+    }
+  }
+  if (current?.name && current.hash && current.lastSyncedAt) {
+    managedSubagents.push({
+      name: current.name,
+      hash: current.hash,
+      lastSyncedAt: current.lastSyncedAt
+    });
+  }
+  if (!targetName) {
+    return null;
+  }
+  return {
+    targetName,
+    managedSubagents
+  };
+}
+async function readManifest(manifestPath) {
+  try {
+    const contents = await readFile(manifestPath, "utf8");
+    return parseManifest(contents);
+  } catch {
+    return null;
+  }
+}
 /* @__PURE__ */ new Set([
-  ...TARGET_FRONTMATTER_KEYS,
+  ...SYNC_ROUTING_FRONTMATTER_KEYS,
   "tools",
   "model",
   "color"
@@ -6816,14 +7089,14 @@ function emptySummaryCounts() {
 function normalizeSkillKey(name) {
   return path.normalize(name).replace(/\\/g, "/").toLowerCase();
 }
-function normalizeSkillRelativePath(relativePath) {
-  if (!relativePath) {
-    return relativePath;
+function includeCanonicalSkill(options) {
+  if (!options.includeSkill) {
+    return options.enabledByDefault;
   }
-  const baseName = path.basename(relativePath);
-  const { baseName: strippedBase } = stripLocalPathSuffix(baseName);
-  const parent = path.dirname(relativePath);
-  return parent === "." ? strippedBase : path.join(parent, strippedBase);
+  return options.includeSkill({
+    canonicalName: options.canonicalName,
+    enabledByDefault: options.enabledByDefault
+  });
 }
 function formatDisplayPath$1(repoRoot, absolutePath) {
   const relative = path.relative(repoRoot, absolutePath);
@@ -6858,71 +7131,313 @@ function buildSourceCounts(subagents, targets, allTargets, request) {
   }
   return counts;
 }
-async function loadCanonicalSkillIndex(repoRoot, options = {}) {
+function resolveSkillRelativePath(skillsRoot, directoryPath) {
+  const relativePath = path.relative(skillsRoot, directoryPath);
+  if (!relativePath) {
+    return { relativePath, hadLocalSuffix: false };
+  }
+  const baseName = path.basename(relativePath);
+  const { baseName: strippedBase, hadLocalSuffix } = stripLocalPathSuffix(baseName);
+  if (!hadLocalSuffix) {
+    return { relativePath, hadLocalSuffix: false };
+  }
+  const parent = path.dirname(relativePath);
+  const normalized = parent === "." ? strippedBase : path.join(parent, strippedBase);
+  return { relativePath: normalized, hadLocalSuffix: true };
+}
+function resolveSkillName(frontmatter, fallback) {
+  const rawName = frontmatter.name;
+  if (typeof rawName === "string") {
+    const trimmed = rawName.trim();
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return fallback;
+}
+function shouldIncludeCanonicalSkillRelativePath(relativePath, skillKeyFilter) {
+  if (!skillKeyFilter) {
+    return true;
+  }
+  return skillKeyFilter.has(normalizeSkillKey(relativePath));
+}
+async function loadCanonicalSkillIndex(repoRoot, options) {
   const includeLocal = options.includeLocal ?? true;
+  const fallbackResolver = createTargetNameResolver(BUILTIN_TARGETS).resolveTargetName;
+  const resolveTargetName = options.resolveTargetName ?? fallbackResolver;
   const skillsRoot = resolveSharedCategoryRoot(repoRoot, "skills", options.agentsDir);
   const localSkillsRoot = resolveLocalCategoryRoot(repoRoot, "skills", options.agentsDir);
-  let directories = [];
-  try {
-    directories = await listSkillDirectories(skillsRoot);
-  } catch (error) {
-    const code = error.code;
-    if (code !== "ENOENT" && code !== "ENOTDIR") {
-      throw error;
-    }
-  }
+  const targetFilter = options.targetIds ? new Set(options.targetIds) : null;
+  const skillKeyFilter = options.skillKeys ? new Set(options.skillKeys) : null;
   const index = /* @__PURE__ */ new Map();
-  const addEntry = (relativePath, skillPath) => {
-    if (!relativePath) {
-      return;
+  const sharedStats = await readDirectoryStats(skillsRoot);
+  if (sharedStats && !sharedStats.isDirectory()) {
+    throw new Error(`Skills root is not a directory: ${skillsRoot}.`);
+  }
+  const localStats = includeLocal ? await readDirectoryStats(localSkillsRoot) : null;
+  if (localStats && !localStats.isDirectory()) {
+    throw new Error(`Local skills root is not a directory: ${localSkillsRoot}.`);
+  }
+  const sharedEntries = sharedStats ? await listSkillDirectories(skillsRoot) : [];
+  const localEntries = localStats ? await listSkillDirectories(localSkillsRoot) : [];
+  const sharedSkills = [];
+  const localPathSkills = [];
+  const localSuffixSkills = [];
+  for (const entry2 of sharedEntries) {
+    const { relativePath, hadLocalSuffix } = resolveSkillRelativePath(
+      skillsRoot,
+      entry2.directoryPath
+    );
+    if (!shouldIncludeCanonicalSkillRelativePath(relativePath, skillKeyFilter)) {
+      continue;
     }
-    const normalized = normalizeSkillKey(normalizeSkillRelativePath(relativePath));
-    index.set(normalized, skillPath);
-  };
-  for (const entry2 of directories) {
-    const relative = path.relative(skillsRoot, entry2.directoryPath);
-    if (!relative) {
+    if (hadLocalSuffix) {
+      if (!includeLocal) {
+        continue;
+      }
+      const skillFileName = entry2.localSkillFile ?? entry2.sharedSkillFile;
+      if (!skillFileName) {
+        continue;
+      }
+      localSuffixSkills.push({
+        relativePath,
+        sourcePath: path.join(entry2.directoryPath, skillFileName)
+      });
       continue;
     }
-    const isLocalDir = stripLocalPathSuffix(path.basename(entry2.directoryPath)).hadLocalSuffix;
-    if (!isLocalDir && entry2.sharedSkillFile) {
-      addEntry(relative, path.join(entry2.directoryPath, entry2.sharedSkillFile));
+    if (entry2.sharedSkillFile) {
+      sharedSkills.push({
+        relativePath,
+        sourcePath: path.join(entry2.directoryPath, entry2.sharedSkillFile)
+      });
     }
-    if (includeLocal) {
-      if (isLocalDir) {
-        const skillFileName = entry2.localSkillFile ?? entry2.sharedSkillFile;
-        if (skillFileName) {
-          addEntry(relative, path.join(entry2.directoryPath, skillFileName));
-        }
-      } else if (entry2.localSkillFile) {
-        addEntry(relative, path.join(entry2.directoryPath, entry2.localSkillFile));
-      }
+    if (includeLocal && entry2.localSkillFile) {
+      localSuffixSkills.push({
+        relativePath,
+        sourcePath: path.join(entry2.directoryPath, entry2.localSkillFile)
+      });
     }
   }
   if (includeLocal) {
-    let localDirectories = [];
-    try {
-      localDirectories = await listSkillDirectories(localSkillsRoot);
-    } catch (error) {
-      const code = error.code;
-      if (code === "ENOENT" || code === "ENOTDIR") {
-        return index;
+    for (const entry2 of localEntries) {
+      const skillFileName = entry2.sharedSkillFile ?? entry2.localSkillFile;
+      if (!skillFileName) {
+        continue;
       }
-      throw error;
+      const { relativePath } = resolveSkillRelativePath(localSkillsRoot, entry2.directoryPath);
+      if (!shouldIncludeCanonicalSkillRelativePath(relativePath, skillKeyFilter)) {
+        continue;
+      }
+      localPathSkills.push({
+        relativePath,
+        sourcePath: path.join(entry2.directoryPath, skillFileName)
+      });
+    }
+  }
+  const { localEffective: localEffectiveSkills, sharedEffective: sharedEffectiveSkills } = resolveLocalPrecedence({
+    shared: sharedSkills,
+    localPath: localPathSkills,
+    localSuffix: localSuffixSkills,
+    key: (skill) => normalizeSkillKey(skill.relativePath)
+  });
+  const effectiveSkills = includeLocal ? [...sharedEffectiveSkills, ...localEffectiveSkills] : sharedSkills;
+  for (const skill of effectiveSkills) {
+    const rawContents = await readFile(skill.sourcePath, "utf8");
+    const { frontmatter } = extractFrontmatter$1(rawContents);
+    const fallbackName = skill.relativePath || path.basename(path.dirname(skill.sourcePath));
+    const skillName = resolveSkillName(frontmatter, fallbackName);
+    const rawTargets = [frontmatter.targets, frontmatter.targetAgents];
+    const { targets, invalidTargets } = resolveFrontmatterTargets(rawTargets, resolveTargetName);
+    const hasEmptyTargets = hasRawTargetValues(rawTargets) && (!targets || targets.length === 0);
+    const effectiveTargets = hasEmptyTargets ? [] : resolveEffectiveTargets({
+      defaultTargets: targets,
+      overrideOnly: options.overrideOnly ?? void 0,
+      overrideSkip: options.overrideSkip ?? void 0,
+      allTargets: options.allTargets
+    });
+    const matchingTargets = targetFilter ? effectiveTargets.filter((targetId) => targetFilter.has(targetId)) : effectiveTargets;
+    if (matchingTargets.length === 0) {
+      continue;
     }
-    for (const entry2 of localDirectories) {
-      const relative = path.relative(localSkillsRoot, entry2.directoryPath);
-      if (!relative) {
+    const enabledByDefault = resolveFrontmatterEnabledByDefault({
+      frontmatter,
+      itemKind: "Skill",
+      itemName: skillName,
+      sourcePath: skill.sourcePath
+    });
+    if (!includeCanonicalSkill({
+      canonicalName: skillName,
+      enabledByDefault,
+      includeSkill: options.includeSkill
+    })) {
+      continue;
+    }
+    if (invalidTargets.length > 0) {
+      const invalidList = invalidTargets.join(", ");
+      throw new InvalidFrontmatterTargetsError(
+        `Skill "${skillName}" has unsupported targets (${invalidList}) in ${skill.sourcePath}.`
+      );
+    }
+    if (hasEmptyTargets) {
+      throw new InvalidFrontmatterTargetsError(
+        `Skill "${skillName}" has empty targets in ${skill.sourcePath}.`
+      );
+    }
+    const skillKey = normalizeSkillKey(skill.relativePath);
+    for (const targetId of matchingTargets) {
+      const targetSkills = index.get(targetId) ?? /* @__PURE__ */ new Map();
+      targetSkills.set(skillKey, skill.sourcePath);
+      index.set(targetId, targetSkills);
+    }
+  }
+  return index;
+}
+function collectRelevantCanonicalSkillKeys(options) {
+  const relevant = /* @__PURE__ */ new Set();
+  for (const subagent of options.subagents) {
+    const effectiveTargets = resolveEffectiveTargets({
+      defaultTargets: subagent.targetAgents,
+      overrideOnly: options.overrideOnly ?? void 0,
+      overrideSkip: options.overrideSkip ?? void 0,
+      allTargets: options.allTargets
+    });
+    if (!effectiveTargets.some((targetId) => options.activeTargetIds.has(targetId))) {
+      continue;
+    }
+    relevant.add(normalizeSkillKey(subagent.resolvedName));
+  }
+  return relevant;
+}
+async function collectManagedCanonicalSkillKeys(options) {
+  const managed = /* @__PURE__ */ new Set();
+  const homeDir = os.homedir();
+  const targetIds = new Set(options.targetIds);
+  for (const targetId of options.targetIds) {
+    const manifest = await readManifest(resolveManifestPath(options.repoRoot, targetId, homeDir));
+    if (!manifest || manifest.targetName !== targetId) {
+      continue;
+    }
+    for (const entry2 of manifest.managedSubagents) {
+      managed.add(normalizeSkillKey(entry2.name));
+    }
+  }
+  const managedOutputs = await readManagedOutputs(options.repoRoot, homeDir);
+  for (const entry2 of managedOutputs?.entries ?? []) {
+    if (entry2.sourceType !== "subagent" || !targetIds.has(entry2.targetId)) {
+      continue;
+    }
+    managed.add(normalizeSkillKey(entry2.sourceId));
+  }
+  return managed;
+}
+function getCanonicalSkillPath(index, targetId, skillKey) {
+  return index.get(targetId)?.get(skillKey);
+}
+function recordShadowedSubagentSource(shadowedSources, targetId, sourceId) {
+  const existing = shadowedSources.get(targetId) ?? /* @__PURE__ */ new Set();
+  existing.add(normalizeName(sourceId));
+  shadowedSources.set(targetId, existing);
+}
+function includeSubagentByDefault(subagent, includeItem) {
+  if (!includeItem) {
+    return subagent.enabledByDefault;
+  }
+  return includeItem({
+    canonicalName: subagent.resolvedName,
+    enabledByDefault: subagent.enabledByDefault
+  });
+}
+function filterSubagentCatalog(catalog, includeItem) {
+  const predicate = (subagent) => includeSubagentByDefault(subagent, includeItem);
+  catalog.subagents = catalog.subagents.filter(predicate);
+  catalog.sharedSubagents = catalog.sharedSubagents.filter(predicate);
+  catalog.localSubagents = catalog.localSubagents.filter(predicate);
+  catalog.localEffectiveSubagents = catalog.localEffectiveSubagents.filter(predicate);
+}
+function assertUsableSubagentsForTargets(options) {
+  for (const subagent of options.subagents) {
+    const effectiveTargets = resolveEffectiveTargets({
+      defaultTargets: subagent.targetAgents,
+      overrideOnly: options.overrideOnly ?? void 0,
+      overrideSkip: options.overrideSkip ?? void 0,
+      allTargets: options.allTargets
+    });
+    if (!effectiveTargets.some((targetId) => options.activeTargetIds.has(targetId))) {
+      continue;
+    }
+    assertSubagentDefinitionUsable(subagent);
+  }
+}
+function targetRequiresCanonicalSkillLookup(target) {
+  const outputDef = normalizeOutputDefinition(target.outputs.subagents);
+  if (!outputDef) {
+    return false;
+  }
+  if (outputDef.fallback?.mode !== "convert" || outputDef.fallback.targetType !== "skills") {
+    return false;
+  }
+  return normalizeOutputDefinition(target.outputs.skills) !== null;
+}
+async function resolveCanonicalSkillsForSubagentSync(options) {
+  const targetIds = options.activeTargets.filter(targetRequiresCanonicalSkillLookup).map((target) => target.id);
+  if (targetIds.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const relevantCanonicalSkillKeys = collectRelevantCanonicalSkillKeys({
+    subagents: options.subagents,
+    activeTargetIds: new Set(targetIds),
+    overrideOnly: options.overrideOnly,
+    overrideSkip: options.overrideSkip,
+    allTargets: options.allTargetIds
+  });
+  for (const skillKey of await collectManagedCanonicalSkillKeys({
+    repoRoot: options.repoRoot,
+    targetIds
+  })) {
+    relevantCanonicalSkillKeys.add(skillKey);
+  }
+  if (relevantCanonicalSkillKeys.size === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  return loadCanonicalSkillIndex(options.repoRoot, {
+    includeLocal: options.includeLocalSkills ?? true,
+    agentsDir: options.agentsDir,
+    resolveTargetName: options.resolveTargetName,
+    overrideOnly: options.overrideOnly ?? null,
+    overrideSkip: options.overrideSkip ?? null,
+    allTargets: options.allTargetIds,
+    targetIds,
+    skillKeys: relevantCanonicalSkillKeys,
+    includeSkill: options.includeSkill
+  });
+}
+async function resolveShadowedSubagentNamesForTargets(options) {
+  const activeTargetIds = new Set(options.activeTargets.map((target) => target.id));
+  const canonicalSkills = await resolveCanonicalSkillsForSubagentSync(options);
+  const shadowedSources = /* @__PURE__ */ new Map();
+  for (const subagent of options.subagents) {
+    const effectiveTargets = resolveEffectiveTargets({
+      defaultTargets: subagent.targetAgents,
+      overrideOnly: options.overrideOnly ?? void 0,
+      overrideSkip: options.overrideSkip ?? void 0,
+      allTargets: options.allTargetIds
+    });
+    for (const targetId of effectiveTargets) {
+      if (!activeTargetIds.has(targetId)) {
         continue;
       }
-      const skillFileName = entry2.sharedSkillFile ?? entry2.localSkillFile;
-      if (!skillFileName) {
+      const canonicalSkillPath = getCanonicalSkillPath(
+        canonicalSkills,
+        targetId,
+        normalizeSkillKey(subagent.resolvedName)
+      );
+      if (!canonicalSkillPath) {
         continue;
       }
-      addEntry(relative, path.join(entry2.directoryPath, skillFileName));
+      recordShadowedSubagentSource(shadowedSources, targetId, subagent.resolvedName);
     }
   }
-  return index;
+  return shadowedSources;
 }
 function buildInvalidTargetWarnings(subagents) {
   const warnings = [];
@@ -6974,14 +7489,7 @@ async function syncSubagents(request) {
     agentsDir: request.agentsDir,
     resolveTargetName: request.resolveTargetName
   });
-  if (request.includeItem) {
-    const includeItem = request.includeItem;
-    const predicate = (subagent) => includeItem(subagent.resolvedName);
-    catalog.subagents = catalog.subagents.filter(predicate);
-    catalog.sharedSubagents = catalog.sharedSubagents.filter(predicate);
-    catalog.localSubagents = catalog.localSubagents.filter(predicate);
-    catalog.localEffectiveSubagents = catalog.localEffectiveSubagents.filter(predicate);
-  }
+  filterSubagentCatalog(catalog, request.includeItem);
   const targets = request.targets.filter(
     (target) => normalizeOutputDefinition(target.outputs.subagents) !== null
   );
@@ -7002,6 +7510,13 @@ async function syncSubagents(request) {
   }
   const allTargetIds = request.targets.map((target) => target.id);
   const activeTargetIds = new Set(targets.map((target) => target.id));
+  assertUsableSubagentsForTargets({
+    subagents: catalog.subagents,
+    activeTargetIds,
+    overrideOnly: request.overrideOnly,
+    overrideSkip: request.overrideSkip,
+    allTargets: allTargetIds
+  });
   const effectiveTargetsBySubagent = /* @__PURE__ */ new Map();
   const activeSourcesByTarget = /* @__PURE__ */ new Map();
   for (const subagent of catalog.subagents) {
@@ -7036,6 +7551,7 @@ async function syncSubagents(request) {
   const managedManifest = await readManagedOutputs(request.repoRoot, homeDir) ?? { entries: [] };
   const nextManaged = /* @__PURE__ */ new Map();
   const activeOutputPaths = /* @__PURE__ */ new Set();
+  const shadowedSubagentSources = /* @__PURE__ */ new Map();
   const countsByTarget = /* @__PURE__ */ new Map();
   const getCounts = (targetId) => {
     const existing = countsByTarget.get(targetId) ?? emptySummaryCounts();
@@ -7046,9 +7562,17 @@ async function syncSubagents(request) {
   const writerRegistry = /* @__PURE__ */ new Map([
     [defaultSubagentWriter.id, defaultSubagentWriter]
   ]);
-  const canonicalSkills = await loadCanonicalSkillIndex(request.repoRoot, {
-    includeLocal: request.includeLocalSkills ?? true,
-    agentsDir: request.agentsDir
+  const canonicalSkills = await resolveCanonicalSkillsForSubagentSync({
+    repoRoot: request.repoRoot,
+    activeTargets: targets,
+    allTargetIds,
+    subagents: catalog.subagents,
+    agentsDir: request.agentsDir,
+    includeLocalSkills: request.includeLocalSkills,
+    resolveTargetName: request.resolveTargetName,
+    overrideOnly: request.overrideOnly,
+    overrideSkip: request.overrideSkip,
+    includeSkill: request.includeSkill
   });
   const validAgents = request.validAgents ?? buildSupportedAgentNames(request.targets);
   const outputDefs = /* @__PURE__ */ new Map();
@@ -7114,8 +7638,13 @@ async function syncSubagents(request) {
       }
       if (outputKind === "skill") {
         const canonicalSkillKey = normalizeSkillKey(subagent.resolvedName);
-        const canonicalSkillPath = canonicalSkills.get(canonicalSkillKey);
+        const canonicalSkillPath = getCanonicalSkillPath(
+          canonicalSkills,
+          target.id,
+          canonicalSkillKey
+        );
         if (canonicalSkillPath) {
+          recordShadowedSubagentSource(shadowedSubagentSources, target.id, subagent.resolvedName);
           warnings.push(
             `Skipped ${target.displayName} skill "${subagent.resolvedName}" because canonical skill exists at ${canonicalSkillPath}.`
           );
@@ -7320,6 +7849,35 @@ async function syncSubagents(request) {
       if (nextManaged.has(key)) {
         continue;
       }
+      const canonicalSkillPath = getCanonicalSkillPath(
+        canonicalSkills,
+        entry2.targetId,
+        normalizeSkillKey(entry2.sourceId)
+      );
+      const skillDef = skillDefs.get(entry2.targetId);
+      if (canonicalSkillPath && skillDef) {
+        const expectedSkillOutputPath = resolveOutputPath({
+          template: skillDef.path,
+          context: {
+            repoRoot: request.repoRoot,
+            agentsDir: agentsDirPath,
+            homeDir,
+            targetId: entry2.targetId,
+            itemName: entry2.sourceId
+          },
+          item: { name: entry2.sourceId },
+          baseDir: request.repoRoot
+        });
+        if (normalizeManagedOutputPath(expectedSkillOutputPath) === normalizeManagedOutputPath(entry2.outputPath)) {
+          updatedEntries.push(entry2);
+          continue;
+        }
+      }
+      const shadowedSources = shadowedSubagentSources.get(entry2.targetId);
+      if (shadowedSources?.has(normalizeName(entry2.sourceId))) {
+        updatedEntries.push(entry2);
+        continue;
+      }
       const activeSources = activeSourcesByTarget.get(entry2.targetId);
       const sourceStillActive = activeSources?.has(entry2.sourceId) ?? false;
       if (!removeMissing || sourceStillActive) {
@@ -7813,12 +8371,21 @@ function replayTraversedProfileWarnings(profile, traversedNames) {
     }
   });
   for (const name of traversedNames.skills) {
+    if (!name) {
+      continue;
+    }
     warningFilter.includes("skills", name);
   }
   for (const name of traversedNames.subagents) {
+    if (!name) {
+      continue;
+    }
     warningFilter.includes("subagents", name);
   }
   for (const name of traversedNames.commands) {
+    if (!name) {
+      continue;
+    }
     warningFilter.includes("commands", name);
   }
   return warningFilter.collectUnknownWarnings();
@@ -7838,6 +8405,18 @@ function addTemplateScriptSource(sources, templatePath, content) {
 function intersectsTargets(targets, selectedTargetIds) {
   return targets.some((target) => selectedTargetIds.has(target));
 }
+function areSelectedTargetsFullyShadowed(options) {
+  const relevantTargets = options.effectiveTargets.filter(
+    (targetId) => options.selectedTargetIds.has(targetId)
+  );
+  if (relevantTargets.length === 0) {
+    return false;
+  }
+  const normalizedName = options.subagentName.trim().toLowerCase();
+  return relevantTargets.every(
+    (targetId) => options.shadowedSubagentsByTarget.get(targetId)?.has(normalizedName)
+  );
+}
 async function listAllFiles(root) {
   const entries = await readdir(root, { withFileTypes: true });
   const files = [];
@@ -7872,7 +8451,10 @@ async function gatherTemplateScriptSources(options) {
       resolveTargetName: options.resolveTargetName
     });
     for (const command of commandCatalog.commands) {
-      if (options.includeCommand && !options.includeCommand(command.name)) {
+      if (options.includeCommand && !options.includeCommand({
+        canonicalName: command.name,
+        enabledByDefault: command.enabledByDefault
+      })) {
         continue;
       }
       const effectiveTargets = resolveEffectiveTargets({
@@ -7884,6 +8466,7 @@ async function gatherTemplateScriptSources(options) {
       if (!intersectsTargets(effectiveTargets, selectedCommandTargetIds)) {
         continue;
       }
+      assertSlashCommandDefinitionUsable(command);
       addTemplateScriptSource(sources, command.sourcePath, command.rawContents);
     }
   }
@@ -7893,8 +8476,23 @@ async function gatherTemplateScriptSources(options) {
       agentsDir: options.agentsDir,
       resolveTargetName: options.resolveTargetName
     });
+    const shadowedSubagentsByTarget = await resolveShadowedSubagentNamesForTargets({
+      repoRoot: options.repoRoot,
+      activeTargets: options.selectedSubagentTargets,
+      allTargetIds: options.allTargetIds,
+      subagents: subagentCatalog.subagents,
+      agentsDir: options.agentsDir,
+      includeLocalSkills: !options.excludeLocalSkills,
+      resolveTargetName: options.resolveTargetName,
+      overrideOnly: options.overrideOnly,
+      overrideSkip: options.overrideSkip,
+      includeSkill: options.includeSkill
+    });
     for (const subagent of subagentCatalog.subagents) {
-      if (options.includeSubagent && !options.includeSubagent(subagent.resolvedName)) {
+      if (options.includeSubagent && !options.includeSubagent({
+        canonicalName: subagent.resolvedName,
+        enabledByDefault: subagent.enabledByDefault
+      })) {
         continue;
       }
       const effectiveTargets = resolveEffectiveTargets({
@@ -7906,6 +8504,15 @@ async function gatherTemplateScriptSources(options) {
       if (!intersectsTargets(effectiveTargets, selectedSubagentTargetIds)) {
         continue;
       }
+      if (areSelectedTargetsFullyShadowed({
+        selectedTargetIds: selectedSubagentTargetIds,
+        effectiveTargets,
+        shadowedSubagentsByTarget,
+        subagentName: subagent.resolvedName
+      })) {
+        continue;
+      }
+      assertSubagentDefinitionUsable(subagent);
       addTemplateScriptSource(sources, subagent.sourcePath, subagent.rawContents);
     }
   }
@@ -7936,7 +8543,10 @@ async function gatherTemplateScriptSources(options) {
       resolveTargetName: options.resolveTargetName
     });
     for (const skill of skillCatalog.skills) {
-      if (options.includeSkill && !options.includeSkill(skill.name)) {
+      if (options.includeSkill && !options.includeSkill({
+        canonicalName: skill.name,
+        enabledByDefault: skill.enabledByDefault
+      })) {
         continue;
       }
       const effectiveTargets = resolveEffectiveTargets({
@@ -7948,6 +8558,7 @@ async function gatherTemplateScriptSources(options) {
       if (!intersectsTargets(effectiveTargets, selectedSkillTargetIds)) {
         continue;
       }
+      assertSkillDefinitionUsable(skill);
       const files = await listAllFiles(skill.directoryPath);
       for (const filePath of files) {
         const buffer = await readFile(filePath);
@@ -8088,6 +8699,16 @@ async function validateTemplatingSources(options) {
       sourcePath
     });
   };
+  const selectedSkillTargetIds = new Set(options.selectedSkillTargets.map((target) => target.id));
+  const selectedCommandTargetIds = new Set(
+    options.selectedCommandTargets.map((target) => target.id)
+  );
+  const selectedSubagentTargetIds = new Set(
+    options.selectedSubagentTargets.map((target) => target.id)
+  );
+  const selectedInstructionTargetIds = new Set(
+    options.selectedInstructionTargets.map((target) => target.id)
+  );
   if (options.commandsAvailable) {
     const commandCatalog = await loadCommandCatalog(options.repoRoot, {
       includeLocal: options.includeLocalCommands,
@@ -8095,9 +8716,20 @@ async function validateTemplatingSources(options) {
       resolveTargetName: options.resolveTargetName
     });
     for (const command of commandCatalog.commands) {
-      if (options.includeCommand && !options.includeCommand(command.name)) {
+      if (options.includeCommand && !options.includeCommand({
+        canonicalName: command.name,
+        enabledByDefault: command.enabledByDefault
+      })) {
         continue;
       }
+      const effectiveTargets = resolveEffectiveTargets({
+        defaultTargets: command.targetAgents,
+        allTargets: options.selectedCommandTargets.map((target) => target.id)
+      });
+      if (!intersectsTargets(effectiveTargets, selectedCommandTargetIds)) {
+        continue;
+      }
+      assertSlashCommandDefinitionUsable(command);
       validateContent(command.sourcePath, command.rawContents);
     }
   }
@@ -8108,9 +8740,20 @@ async function validateTemplatingSources(options) {
       resolveTargetName: options.resolveTargetName
     });
     for (const skill of skillCatalog.skills) {
-      if (options.includeSkill && !options.includeSkill(skill.name)) {
+      if (options.includeSkill && !options.includeSkill({
+        canonicalName: skill.name,
+        enabledByDefault: skill.enabledByDefault
+      })) {
         continue;
       }
+      const effectiveTargets = resolveEffectiveTargets({
+        defaultTargets: skill.targetAgents,
+        allTargets: options.selectedSkillTargets.map((target) => target.id)
+      });
+      if (!intersectsTargets(effectiveTargets, selectedSkillTargetIds)) {
+        continue;
+      }
+      assertSkillDefinitionUsable(skill);
       const files = await listFiles(skill.directoryPath);
       const filesToValidate = options.includeLocalSkills ? files : files.filter((filePath) => !hasLocalMarker(filePath));
       for (const filePath of filesToValidate) {
@@ -8129,29 +8772,61 @@ async function validateTemplatingSources(options) {
       agentsDir: options.agentsDir,
       resolveTargetName: options.resolveTargetName
     });
+    const shadowedSubagentsByTarget = await resolveShadowedSubagentNamesForTargets({
+      repoRoot: options.repoRoot,
+      activeTargets: options.selectedSubagentTargets,
+      allTargetIds: options.selectedSubagentTargets.map((target) => target.id),
+      subagents: subagentCatalog.subagents,
+      agentsDir: options.agentsDir,
+      includeLocalSkills: options.includeLocalSkills,
+      resolveTargetName: options.resolveTargetName,
+      includeSkill: options.includeSkill
+    });
     for (const subagent of subagentCatalog.subagents) {
-      if (options.includeSubagent && !options.includeSubagent(subagent.resolvedName)) {
+      if (options.includeSubagent && !options.includeSubagent({
+        canonicalName: subagent.resolvedName,
+        enabledByDefault: subagent.enabledByDefault
+      })) {
         continue;
       }
+      const effectiveTargets = resolveEffectiveTargets({
+        defaultTargets: subagent.targetAgents,
+        allTargets: options.selectedSubagentTargets.map((target) => target.id)
+      });
+      if (!intersectsTargets(effectiveTargets, selectedSubagentTargetIds)) {
+        continue;
+      }
+      if (areSelectedTargetsFullyShadowed({
+        selectedTargetIds: selectedSubagentTargetIds,
+        effectiveTargets,
+        shadowedSubagentsByTarget,
+        subagentName: subagent.resolvedName
+      })) {
+        continue;
+      }
+      assertSubagentDefinitionUsable(subagent);
       validateContent(subagent.sourcePath, subagent.rawContents);
     }
   }
   if (options.instructionsAvailable) {
-    const entries = await scanInstructionTemplateSources({
+    const catalog = await loadInstructionTemplateCatalog({
       repoRoot: options.repoRoot,
       includeLocal: options.includeLocalInstructions,
-      agentsDir: options.agentsDir
+      agentsDir: options.agentsDir,
+      resolveTargetName: options.resolveTargetName
     });
-    for (const entry2 of entries) {
-      const buffer = await readFile(entry2.sourcePath);
-      const contents = decodeUtf8(buffer);
-      if (contents === null) {
+    for (const template of catalog.templates) {
+      const effectiveTargets = resolveEffectiveTargets({
+        defaultTargets: template.targets,
+        allTargets: options.selectedInstructionTargets.map((target) => target.id)
+      });
+      if (!intersectsTargets(effectiveTargets, selectedInstructionTargetIds)) {
         continue;
       }
       validateAgentTemplating({
-        content: contents,
+        content: template.rawContents,
         validAgents: options.validAgents,
-        sourcePath: entry2.sourcePath
+        sourcePath: template.sourcePath
       });
     }
   }
@@ -8746,12 +9421,11 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
         commands: /* @__PURE__ */ new Set()
       };
       const includeItemFor = (category) => {
-        if (!profileItemFilter.enabled) {
-          return void 0;
-        }
-        return (name) => {
-          traversedProfileNames[category].add(name);
-          return profileItemFilter.includes(category, name);
+        return (item) => {
+          if (profileItemFilter.enabled) {
+            traversedProfileNames[category].add(item.canonicalName);
+          }
+          return profileItemFilter.includes(category, item);
         };
       };
       if (filteredTargets.length === 0 && !listLocal) {
@@ -8957,6 +9631,10 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
           repoRoot,
           agentsDir,
           validAgents,
+          selectedSkillTargets,
+          selectedCommandTargets,
+          selectedSubagentTargets,
+          selectedInstructionTargets,
           commandsAvailable: hasCommandsToSync,
           skillsAvailable: hasSkillsToSync,
           subagentsAvailable: hasSubagentsToSync,
@@ -9159,7 +9837,8 @@ Config: auto-discovered as omniagent.config.(ts|mts|cts|js|mjs|cjs) in the agent
         resolveTargetName,
         hooks: globalHooks,
         templateScriptRuntime: scriptRuntime,
-        includeItem: includeItemFor("subagents")
+        includeItem: includeItemFor("subagents"),
+        includeSkill: includeItemFor("skills")
       });
       if (availabilitySubagentSkips.length > 0) {
         const subagentWarnings = mergeWarnings(