@alessandroraffa/tangyr 9.0.0 → 10.0.0

package/dist/index.js

@@ -16362,8 +16362,8 @@ function assertSupportedNodeRuntime(nodeVersion = process.version) {
 }
 
 // src/commands/assess.ts
-import fs12 from "fs";
-import path14 from "path";
+import fs13 from "fs";
+import path15 from "path";
 
 // src/core/scope.ts
 import fs7 from "fs";
@@ -17263,22 +17263,107 @@ function toPosixRelativePath(root, filePath) {
   return path11.relative(root, filePath).split(path11.sep).join(path11.posix.sep);
 }
 
+// src/core/managed-sources.ts
+var import_yaml5 = __toESM(require_dist(), 1);
+import fs11 from "fs";
+import path12 from "path";
+function resolveKitComponentNames(sourceRoot, category) {
+  const manifestPath = path12.resolve(sourceRoot, "tangyr-kit.yaml");
+  if (!fs11.existsSync(manifestPath)) {
+    return void 0;
+  }
+  try {
+    const raw = fs11.readFileSync(manifestPath, "utf8");
+    const doc = (0, import_yaml5.parse)(raw);
+    if (doc && typeof doc === "object" && !Array.isArray(doc) && "components" in doc) {
+      const components = doc.components;
+      if (components && typeof components === "object" && !Array.isArray(components) && category in components) {
+        const names = components[category];
+        if (Array.isArray(names) && names.every((n7) => typeof n7 === "string")) {
+          return names;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function resolveKitHookNames(sourceRoot) {
+  return resolveKitComponentNames(sourceRoot, "hooks");
+}
+function resolveKitSkillNames(sourceRoot) {
+  return resolveKitComponentNames(sourceRoot, "skills");
+}
+function resolveKitSlotNames(sourceRoot, category) {
+  return resolveKitComponentNames(sourceRoot, category);
+}
+function resolveKitEntrypointName(sourceRoot) {
+  const manifestPath = path12.resolve(sourceRoot, "tangyr-kit.yaml");
+  if (!fs11.existsSync(manifestPath)) {
+    return void 0;
+  }
+  try {
+    const doc = (0, import_yaml5.parse)(fs11.readFileSync(manifestPath, "utf8"));
+    if (doc && typeof doc === "object" && !Array.isArray(doc)) {
+      const value = doc.entrypoint;
+      if (typeof value === "string" && value.trim().length > 0) {
+        return value.trim();
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function resolveHooksSourceFile(sourceRoot, config) {
+  return path12.resolve(sourceRoot, config.source.hooks, "hooks.json");
+}
+function resolveHooksSourceDir(sourceRoot, config) {
+  return path12.resolve(sourceRoot, config.source.hooks);
+}
+function hooksSourceExists(sourceRoot, config) {
+  const hooksJsonPath = resolveHooksSourceFile(sourceRoot, config);
+  if (fs11.existsSync(hooksJsonPath)) {
+    return true;
+  }
+  const hooksDir = resolveHooksSourceDir(sourceRoot, config);
+  if (!fs11.existsSync(hooksDir) || !fs11.statSync(hooksDir).isDirectory()) {
+    return false;
+  }
+  return fs11.readdirSync(hooksDir).some((f) => f.endsWith(".md") && !f.startsWith("."));
+}
+function hooksSourceLabel(sourceRoot, config) {
+  const dir = normalizeManagedSourcePath(
+    config.source.hooks.replace(/\\/gu, "/")
+  );
+  return fs11.existsSync(resolveHooksSourceFile(sourceRoot, config)) ? path12.posix.join(dir, "hooks.json") : `${dir}/`;
+}
+function resolveMcpSourceFile(sourceRoot, config) {
+  return path12.resolve(sourceRoot, config.source.mcp);
+}
+function mcpSourceLabel(config) {
+  return normalizeManagedSourcePath(config.source.mcp);
+}
+function normalizeManagedSourcePath(rawPath) {
+  const normalized = rawPath.replace(/\\/gu, "/");
+  return normalized.startsWith("./") ? normalized.slice(2) : normalized;
+}
+
 // src/core/foreign-instructions.ts
-import path13 from "path";
+import path14 from "path";
 
 // src/core/contested-instructions.ts
-import fs11 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path13 from "path";
 var FOLDS_RULES_INTO_INSTRUCTIONS = {
   codex: "its own rules slot takes only exec-policy rules, so guidance rules are folded in",
   opencode: "it has no rules slot of its own, so every rule is folded in"
 };
 function markerTarget(destination) {
   try {
-    if (fs11.lstatSync(destination).isSymbolicLink()) {
+    if (fs12.lstatSync(destination).isSymbolicLink()) {
       return null;
     }
-    const firstNonEmpty = fs11.readFileSync(destination, "utf8").split("\n").find((line) => line.trim().length > 0) ?? "";
+    const firstNonEmpty = fs12.readFileSync(destination, "utf8").split("\n").find((line) => line.trim().length > 0) ?? "";
     return extractProvenanceMarker(firstNonEmpty)?.target ?? null;
   } catch {
     return null;
@@ -17287,7 +17372,7 @@ function markerTarget(destination) {
 function findContestedInstructions(instructionsByTarget) {
   const byPath = /* @__PURE__ */ new Map();
   for (const [target, destination] of instructionsByTarget) {
-    const resolved = path12.resolve(destination);
+    const resolved = path13.resolve(destination);
     byPath.set(resolved, [...byPath.get(resolved) ?? [], target]);
   }
   const contested = [];
@@ -17349,7 +17434,7 @@ function instructionsByActiveTarget(tools, scope, projectRoot, mappings) {
     }
   }
   if (scope === "project" && projectRoot && tools.includes("copilot")) {
-    byTarget.set("copilot", path12.join(projectRoot, "AGENTS.md"));
+    byTarget.set("copilot", path13.join(projectRoot, "AGENTS.md"));
   }
   return byTarget;
 }
@@ -17358,7 +17443,7 @@ function instructionsByActiveTarget(tools, scope, projectRoot, mappings) {
 function instructionsEntrypoints(tools, scope, projectRoot, mappings) {
   const byPath = /* @__PURE__ */ new Map();
   const add = (destination, tool) => {
-    const resolved2 = path13.resolve(destination);
+    const resolved2 = path14.resolve(destination);
     const targets = byPath.get(resolved2) ?? [];
     if (!targets.includes(tool)) {
       targets.push(tool);
@@ -17389,7 +17474,7 @@ function instructionsEntrypoints(tools, scope, projectRoot, mappings) {
 function findForeignInstructions(conflicting, entrypoints) {
   const found2 = /* @__PURE__ */ new Map();
   for (const finding of conflicting) {
-    const resolved = path13.resolve(finding.path);
+    const resolved = path14.resolve(finding.path);
     const targets = entrypoints.get(resolved);
     if (targets && !found2.has(resolved)) {
       found2.set(resolved, { path: resolved, targets });
@@ -17402,7 +17487,7 @@ function describeForeignInstructions(foreign, projectRoot) {
     if (!projectRoot) {
       return target;
     }
-    const relative = path13.relative(projectRoot, target);
+    const relative = path14.relative(projectRoot, target);
     return relative.startsWith("..") ? target : relative;
   };
   const width = Math.max(...foreign.map((one) => display2(one.path).length));
@@ -17549,10 +17634,10 @@ function collectAssessFindings(scope, projectRoot, toolFilter, assessOptions) {
       }
       for (const target of probe.paths) {
         const resolvedPath = resolveTargetPath(target.path);
-        if (!fs12.existsSync(resolvedPath)) {
+        if (!fs13.existsSync(resolvedPath)) {
           continue;
         }
-        const stat = fs12.lstatSync(resolvedPath);
+        const stat = fs13.lstatSync(resolvedPath);
         findings.push({
           path: resolvedPath,
           tool: probe.tool,
@@ -17580,16 +17665,17 @@ function collectAssessFindings(scope, projectRoot, toolFilter, assessOptions) {
     if (finding.classification !== "conflicting") {
       continue;
     }
-    const resolved = path14.resolve(finding.path);
+    const resolved = path15.resolve(finding.path);
     const ours = recorded.has(resolved) || finding.type === "directory" && holdsOnlyRecorded(resolved, recorded);
     if (ours) {
       finding.classification = "compatible";
       finding.description = `${finding.description} (recorded by this installation)`;
     }
   }
-  if (fs12.existsSync(path14.join(scopePath, "manifest.json"))) {
+  expandPerEntrySlots(findings, recorded, scope, projectRoot, assessOptions);
+  if (fs13.existsSync(path15.join(scopePath, "manifest.json"))) {
     findings.push({
-      path: path14.join(scopePath, "manifest.json"),
+      path: path15.join(scopePath, "manifest.json"),
       tool: "tangyr",
       type: "file",
       classification: "compatible",
@@ -17733,7 +17819,7 @@ function collectProjectScopeFindings(projectRoot, tools, options) {
     for (const { resolvedPath, description, classification } of probePaths) {
       let stat;
       try {
-        stat = fs12.lstatSync(resolvedPath);
+        stat = fs13.lstatSync(resolvedPath);
       } catch {
         continue;
       }
@@ -17750,6 +17836,87 @@ function collectProjectScopeFindings(projectRoot, tools, options) {
   }
   return findings;
 }
+function expandPerEntrySlots(findings, recorded, scope, projectRoot, options) {
+  const slots = perEntrySlotPaths(scope, projectRoot, options);
+  if (slots.size === 0) {
+    return;
+  }
+  for (let index = findings.length - 1; index >= 0; index--) {
+    const finding = findings[index];
+    if (finding.classification !== "conflicting" || finding.type !== "directory" || !slots.has(path15.resolve(finding.path))) {
+      continue;
+    }
+    const wanted = slots.get(path15.resolve(finding.path)) ?? /* @__PURE__ */ new Set();
+    let entries;
+    try {
+      entries = fs13.readdirSync(finding.path);
+    } catch {
+      continue;
+    }
+    const foreign = entries.filter((entry) => wanted.has(entry)).map((entry) => path15.join(finding.path, entry)).filter((entry) => !recorded.has(path15.resolve(entry))).filter((entry) => !carriesProvenanceMarker(entry));
+    findings.splice(
+      index,
+      1,
+      ...foreign.map((entry) => ({
+        path: entry,
+        tool: finding.tool,
+        type: "file",
+        classification: "conflicting",
+        description: `${finding.description} \u2014 this entry is not ours`
+      }))
+    );
+  }
+}
+function perEntrySlotPaths(scope, projectRoot, options) {
+  const slots = /* @__PURE__ */ new Map();
+  let config;
+  let configDir;
+  let kitPath;
+  try {
+    ({ config, configDir } = resolveConfig(options.config));
+    kitPath = resolveKitPath(config, configDir);
+    if (!kitPath) {
+      return slots;
+    }
+  } catch {
+    return slots;
+  }
+  let profile;
+  try {
+    profile = resolveTargetPaths({
+      scope,
+      projectRoot,
+      mappings: loadMappings(kitPath, config, configDir).platformPaths
+    })["claude-code"];
+  } catch {
+    return slots;
+  }
+  const kit = kitPath;
+  const named = (slot, category, sourceKey, extension) => {
+    if (typeof slot !== "string") {
+      return;
+    }
+    const source = path15.resolve(kit, String(config.source[sourceKey]));
+    const declared = resolveKitSlotNames(kit, category);
+    const names = declared?.map((name) => `${name}${extension}`) ?? listSourceEntries(source, extension);
+    slots.set(path15.resolve(slot), new Set(names));
+  };
+  named(profile.agents, "agents", "agents", ".md");
+  named(profile.commands, "commands", "commands", ".md");
+  named(profile.rules, "rules", "rules", ".md");
+  named(profile.output_styles, "output-styles", "outputStyles", ".md");
+  named(profile.skills, "skills", "skills", "");
+  return slots;
+}
+function listSourceEntries(source, extension) {
+  try {
+    return fs13.readdirSync(source, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).filter(
+      (entry) => extension === "" ? entry.isDirectory() : entry.isFile() && entry.name.endsWith(extension)
+    ).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
 function requestedAssessTools(toolFilter) {
   return toolFilter ?? [...DEFAULT_ASSESS_TARGETS];
 }
@@ -17784,7 +17951,7 @@ function alwaysOnProjectFiles(tool, projectRoot) {
   if (tool === "claude-code") {
     return [
       {
-        resolvedPath: path14.resolve(projectRoot, "CLAUDE.md"),
+        resolvedPath: path15.resolve(projectRoot, "CLAUDE.md"),
         description: "Project-level Claude instructions",
         classification: "conflicting"
       }
@@ -17793,7 +17960,7 @@ function alwaysOnProjectFiles(tool, projectRoot) {
   if (tool === "copilot") {
     return [
       {
-        resolvedPath: path14.resolve(
+        resolvedPath: path15.resolve(
           projectRoot,
           ".github/copilot-instructions.md"
         ),
@@ -17805,7 +17972,7 @@ function alwaysOnProjectFiles(tool, projectRoot) {
   if (tool === "codex") {
     return [
       {
-        resolvedPath: path14.resolve(projectRoot, "AGENTS.md"),
+        resolvedPath: path15.resolve(projectRoot, "AGENTS.md"),
         description: "Codex project instructions",
         classification: "conflicting"
       }
@@ -17842,11 +18009,11 @@ function recordedArtifactPaths(scopePath) {
     }
     for (const artifact of manifest.artifacts) {
       if (artifact.path) {
-        paths.add(path14.resolve(artifact.path));
+        paths.add(path15.resolve(artifact.path));
       }
     }
     for (const link of manifest.managedLinks) {
-      paths.add(path14.resolve(link.path));
+      paths.add(path15.resolve(link.path));
     }
   } catch {
   }
@@ -17855,15 +18022,15 @@ function recordedArtifactPaths(scopePath) {
 function holdsOnlyRecorded(dir, recorded) {
   let entries;
   try {
-    entries = fs12.readdirSync(dir, { withFileTypes: true });
+    entries = fs13.readdirSync(dir, { withFileTypes: true });
   } catch {
     return false;
   }
   if (entries.length === 0) {
-    return [...recorded].some((p) => p.startsWith(`${dir}${path14.sep}`));
+    return [...recorded].some((p) => p.startsWith(`${dir}${path15.sep}`));
   }
   for (const entry of entries) {
-    const full = path14.join(dir, entry.name);
+    const full = path15.join(dir, entry.name);
     if (entry.isDirectory() && !entry.isSymbolicLink()) {
       if (!holdsOnlyRecorded(full, recorded)) {
         return false;
@@ -17878,7 +18045,7 @@ function holdsOnlyRecorded(dir, recorded) {
 }
 
 // src/commands/auth.ts
-import fs15 from "fs";
+import fs16 from "fs";
 
 // src/core/transport.ts
 var KIT_CONTRACT_VERSION = "1";
@@ -17967,11 +18134,11 @@ function createFetchKitTransport(options = {}) {
 }
 
 // src/core/credentials.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import os3 from "os";
-import path15 from "path";
-var CREDENTIALS_DIR = path15.join(os3.homedir(), ".tangyr");
-var CREDENTIALS_PATH = path15.join(CREDENTIALS_DIR, "credentials.json");
+import path16 from "path";
+var CREDENTIALS_DIR = path16.join(os3.homedir(), ".tangyr");
+var CREDENTIALS_PATH = path16.join(CREDENTIALS_DIR, "credentials.json");
 function isCurrentCredentialRecord(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -17980,10 +18147,10 @@ function isCurrentCredentialRecord(value) {
   return record.schema === 2 && typeof record.clientId === "string" && record.clientId.length > 0 && typeof record.clientSecret === "string" && record.clientSecret.length > 0 && (record.validation === "validated" || record.validation === "unvalidated") && typeof record.storedAt === "string";
 }
 function readStoredCredentials() {
-  if (!fs13.existsSync(CREDENTIALS_PATH)) {
+  if (!fs14.existsSync(CREDENTIALS_PATH)) {
     return null;
   }
-  const raw = fs13.readFileSync(CREDENTIALS_PATH, "utf8");
+  const raw = fs14.readFileSync(CREDENTIALS_PATH, "utf8");
   const parsed = JSON.parse(raw);
   if (!isCurrentCredentialRecord(parsed)) {
     throw new CredentialsLegacyError();
@@ -17993,13 +18160,13 @@ function readStoredCredentials() {
 function ensureCredentialsDir(logger) {
   let created = false;
   try {
-    created = fs13.mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 448 }) !== void 0;
+    created = fs14.mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 448 }) !== void 0;
   } catch (err) {
     if (err.code !== "EEXIST") {
       throw err;
     }
   }
-  if (fs13.lstatSync(CREDENTIALS_DIR).isSymbolicLink()) {
+  if (fs14.lstatSync(CREDENTIALS_DIR).isSymbolicLink()) {
     throw new Error(
       `Refusing to write credentials: "${CREDENTIALS_DIR}" already exists as a symbolic link, not a directory. Remove it and run 'tangyr auth login' again.`
     );
@@ -18013,7 +18180,7 @@ function ensureCredentialsDir(logger) {
     return;
   }
   try {
-    fs13.chmodSync(CREDENTIALS_DIR, 448);
+    fs14.chmodSync(CREDENTIALS_DIR, 448);
   } catch {
     logger.warn(
       "Could not set owner-only (0700) permissions on the credentials directory on this platform; at-rest protection is reduced (REQ-AUT-007)."
@@ -18026,41 +18193,41 @@ function writeStoredCredentials(record, logger) {
 `;
   const tmpPath = `${CREDENTIALS_PATH}.tmp`;
   try {
-    fs13.writeFileSync(tmpPath, content, { mode: 384, flag: "wx" });
+    fs14.writeFileSync(tmpPath, content, { mode: 384, flag: "wx" });
   } catch (err) {
     if (err.code === "EEXIST") {
-      fs13.unlinkSync(tmpPath);
-      fs13.writeFileSync(tmpPath, content, { mode: 384, flag: "wx" });
+      fs14.unlinkSync(tmpPath);
+      fs14.writeFileSync(tmpPath, content, { mode: 384, flag: "wx" });
     } else {
       throw err;
     }
   }
   try {
-    fs13.renameSync(tmpPath, CREDENTIALS_PATH);
+    fs14.renameSync(tmpPath, CREDENTIALS_PATH);
   } catch (renameErr) {
     try {
       try {
-        const destStat = fs13.lstatSync(CREDENTIALS_PATH);
+        const destStat = fs14.lstatSync(CREDENTIALS_PATH);
         if (destStat.isSymbolicLink()) {
-          fs13.unlinkSync(CREDENTIALS_PATH);
+          fs14.unlinkSync(CREDENTIALS_PATH);
         }
       } catch {
       }
-      fs13.copyFileSync(tmpPath, CREDENTIALS_PATH);
+      fs14.copyFileSync(tmpPath, CREDENTIALS_PATH);
       try {
-        fs13.chmodSync(CREDENTIALS_PATH, 384);
+        fs14.chmodSync(CREDENTIALS_PATH, 384);
       } catch {
         logger.warn(
           "Could not set owner-only (0600) permissions on the credentials file on this platform; at-rest protection is reduced (REQ-AUT-007)."
         );
       }
       try {
-        fs13.unlinkSync(tmpPath);
+        fs14.unlinkSync(tmpPath);
       } catch {
       }
     } catch (copyErr) {
       try {
-        fs13.unlinkSync(tmpPath);
+        fs14.unlinkSync(tmpPath);
       } catch {
       }
       throw new Error(
@@ -18105,16 +18272,16 @@ function resolveCredentialNonInteractive() {
 }
 
 // src/core/freshness.ts
-import fs14 from "fs";
-import path16 from "path";
+import fs15 from "fs";
+import path17 from "path";
 var AUTHORIZATION_FRESHNESS_TTL_MS = 24 * 60 * 60 * 1e3;
 var FRESHNESS_STATE_FILENAME = ".tangyr-freshness.json";
 function resolveFreshnessStatePath(cacheRoot) {
-  return path16.join(cacheRoot, FRESHNESS_STATE_FILENAME);
+  return path17.join(cacheRoot, FRESHNESS_STATE_FILENAME);
 }
 function readFreshnessStateFile(statePath) {
   try {
-    const raw = fs14.readFileSync(statePath, "utf8");
+    const raw = fs15.readFileSync(statePath, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       return {};
@@ -18134,13 +18301,13 @@ function readLastAuthorizedAt(cacheRoot, originUrl) {
   return Number.isNaN(parsed.getTime()) ? void 0 : parsed;
 }
 function writeLastAuthorizedAt(cacheRoot, originUrl, at2) {
-  fs14.mkdirSync(cacheRoot, { recursive: true, mode: 448 });
+  fs15.mkdirSync(cacheRoot, { recursive: true, mode: 448 });
   const statePath = resolveFreshnessStatePath(cacheRoot);
   const state = readFreshnessStateFile(statePath);
   state[originUrl] = at2.toISOString();
   const tmpPath = `${statePath}.tmp`;
-  fs14.writeFileSync(tmpPath, JSON.stringify(state), { mode: 384 });
-  fs14.renameSync(tmpPath, statePath);
+  fs15.writeFileSync(tmpPath, JSON.stringify(state), { mode: 384 });
+  fs15.renameSync(tmpPath, statePath);
 }
 function isWithinFreshnessWindow(lastAuthorizedAt, now) {
   if (lastAuthorizedAt === void 0) {
@@ -18361,21 +18528,21 @@ async function runAuthStatusCommand(options, logger, transport = createFetchKitT
   }
 }
 function runAuthLogoutCommand(_options, logger) {
-  if (!fs15.existsSync(CREDENTIALS_PATH)) {
+  if (!fs16.existsSync(CREDENTIALS_PATH)) {
     logger.info("No credential found. Nothing to remove.");
     return;
   }
-  fs15.unlinkSync(CREDENTIALS_PATH);
+  fs16.unlinkSync(CREDENTIALS_PATH);
   logger.info("Credential removed.");
 }
 
 // src/commands/cache.ts
-import fs17 from "fs";
-import path18 from "path";
+import fs18 from "fs";
+import path19 from "path";
 
 // src/core/cache.ts
-import fs16 from "fs";
-import path17 from "path";
+import fs17 from "fs";
+import path18 from "path";
 
 // src/core/kit-reference.ts
 var BARE_URL = /^https?:\/\//u;
@@ -18434,10 +18601,10 @@ function resolveCacheRoot(env2 = process.env) {
   );
 }
 function cacheEntryPath(cacheRoot, reference) {
-  const entry = path17.join(cacheRoot, reference.name, reference.version);
-  const resolvedRoot = path17.resolve(cacheRoot);
-  const resolvedEntry = path17.resolve(entry);
-  if (!resolvedEntry.startsWith(resolvedRoot + path17.sep)) {
+  const entry = path18.join(cacheRoot, reference.name, reference.version);
+  const resolvedRoot = path18.resolve(cacheRoot);
+  const resolvedEntry = path18.resolve(entry);
+  if (!resolvedEntry.startsWith(resolvedRoot + path18.sep)) {
     throw new IntegrityError(
       `Cache entry path for "${reference.name}@${reference.version}" resolves outside the cache root \u2014 refusing to write.`
     );
@@ -18450,14 +18617,14 @@ function writeCompletionMarker(entryDir, reference) {
     version: reference.version,
     completedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs16.writeFileSync(
-    path17.join(entryDir, CACHE_COMPLETION_MARKER),
+  fs17.writeFileSync(
+    path18.join(entryDir, CACHE_COMPLETION_MARKER),
     JSON.stringify(marker)
   );
 }
 function writeBundleDocument(entryDir, bundle) {
-  fs16.writeFileSync(
-    path17.join(entryDir, BUNDLE_DOCUMENT_FILENAME),
+  fs17.writeFileSync(
+    path18.join(entryDir, BUNDLE_DOCUMENT_FILENAME),
     JSON.stringify(bundle),
     {
       mode: 384
@@ -18465,10 +18632,10 @@ function writeBundleDocument(entryDir, bundle) {
   );
 }
 function readBundleDocument(entryDir) {
-  const documentPath = path17.join(entryDir, BUNDLE_DOCUMENT_FILENAME);
+  const documentPath = path18.join(entryDir, BUNDLE_DOCUMENT_FILENAME);
   let raw;
   try {
-    raw = fs16.readFileSync(documentPath, "utf8");
+    raw = fs17.readFileSync(documentPath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -18487,11 +18654,11 @@ function readBundleDocument(entryDir) {
 }
 function isCompleteCacheEntry(entryDir) {
   try {
-    if (!fs16.statSync(entryDir).isDirectory()) {
+    if (!fs17.statSync(entryDir).isDirectory()) {
       return false;
     }
-    const markerPath = path17.join(entryDir, CACHE_COMPLETION_MARKER);
-    const raw = fs16.readFileSync(markerPath, "utf8");
+    const markerPath = path18.join(entryDir, CACHE_COMPLETION_MARKER);
+    const raw = fs17.readFileSync(markerPath, "utf8");
     JSON.parse(raw);
     return true;
   } catch {
@@ -18499,53 +18666,53 @@ function isCompleteCacheEntry(entryDir) {
   }
 }
 function createStagingDir(cacheRoot, reference) {
-  const stagingRoot = path17.join(cacheRoot, ".staging");
-  fs16.mkdirSync(stagingRoot, { recursive: true, mode: 448 });
-  const prefix = path17.join(
+  const stagingRoot = path18.join(cacheRoot, ".staging");
+  fs17.mkdirSync(stagingRoot, { recursive: true, mode: 448 });
+  const prefix = path18.join(
     stagingRoot,
     `${reference.name}-${reference.version}-`
   );
-  return fs16.mkdtempSync(prefix);
+  return fs17.mkdtempSync(prefix);
 }
 function publishCacheEntry(stagingDir, entryDir) {
-  fs16.mkdirSync(path17.dirname(entryDir), { recursive: true, mode: 448 });
+  fs17.mkdirSync(path18.dirname(entryDir), { recursive: true, mode: 448 });
   try {
-    fs16.renameSync(stagingDir, entryDir);
+    fs17.renameSync(stagingDir, entryDir);
     return;
   } catch (error) {
-    const entryExists = fs16.existsSync(entryDir);
+    const entryExists = fs17.existsSync(entryDir);
     if (entryExists && isCompleteCacheEntry(entryDir)) {
-      fs16.rmSync(stagingDir, { recursive: true, force: true });
+      fs17.rmSync(stagingDir, { recursive: true, force: true });
       return;
     }
     if (entryExists) {
-      fs16.rmSync(entryDir, { recursive: true, force: true });
+      fs17.rmSync(entryDir, { recursive: true, force: true });
       try {
-        fs16.renameSync(stagingDir, entryDir);
+        fs17.renameSync(stagingDir, entryDir);
         return;
       } catch (retryError) {
-        fs16.rmSync(stagingDir, { recursive: true, force: true });
+        fs17.rmSync(stagingDir, { recursive: true, force: true });
         throw retryError;
       }
     }
     if (error.code === "EXDEV") {
       const stagedMarker = JSON.parse(
-        fs16.readFileSync(path17.join(stagingDir, CACHE_COMPLETION_MARKER), "utf8")
+        fs17.readFileSync(path18.join(stagingDir, CACHE_COMPLETION_MARKER), "utf8")
       );
-      fs16.cpSync(stagingDir, entryDir, {
+      fs17.cpSync(stagingDir, entryDir, {
         recursive: true,
         preserveTimestamps: false,
-        mode: fs16.constants.COPYFILE_EXCL,
-        filter: (source) => path17.basename(source) !== CACHE_COMPLETION_MARKER
+        mode: fs17.constants.COPYFILE_EXCL,
+        filter: (source) => path18.basename(source) !== CACHE_COMPLETION_MARKER
       });
       writeCompletionMarker(entryDir, {
         name: stagedMarker.name,
         version: stagedMarker.version
       });
-      fs16.rmSync(stagingDir, { recursive: true, force: true });
+      fs17.rmSync(stagingDir, { recursive: true, force: true });
       return;
     }
-    fs16.rmSync(stagingDir, { recursive: true, force: true });
+    fs17.rmSync(stagingDir, { recursive: true, force: true });
     throw error;
   }
 }
@@ -18553,12 +18720,12 @@ function isReservedCacheRootName(name) {
   return name.startsWith(".");
 }
 function listCacheEntryDirectories(cacheRoot) {
-  if (!fs16.existsSync(cacheRoot)) {
+  if (!fs17.existsSync(cacheRoot)) {
     return [];
   }
-  return fs16.readdirSync(cacheRoot, { withFileTypes: true }).filter(
+  return fs17.readdirSync(cacheRoot, { withFileTypes: true }).filter(
     (entry) => entry.isDirectory() && !isReservedCacheRootName(entry.name)
-  ).map((entry) => path17.join(cacheRoot, entry.name));
+  ).map((entry) => path18.join(cacheRoot, entry.name));
 }
 function resolveCacheClearTarget(cacheRoot, raw) {
   if (raw.includes("@")) {
@@ -18576,10 +18743,10 @@ function resolveCacheClearTarget(cacheRoot, raw) {
       `Cache clear target "${raw}" must not begin with "." \u2014 reserved cache-root filenames are excluded from removal by name, not only from the no-argument enumeration form.`
     );
   }
-  const resolvedRoot = path17.resolve(cacheRoot);
-  const target = path17.join(cacheRoot, raw);
-  const resolvedTarget = path17.resolve(target);
-  if (!resolvedTarget.startsWith(resolvedRoot + path17.sep)) {
+  const resolvedRoot = path18.resolve(cacheRoot);
+  const target = path18.join(cacheRoot, raw);
+  const resolvedTarget = path18.resolve(target);
+  if (!resolvedTarget.startsWith(resolvedRoot + path18.sep)) {
     throw new IntegrityError(
       `Cache clear target "${raw}" resolves outside the cache root \u2014 refusing to remove.`
     );
@@ -18591,7 +18758,7 @@ function resolveCacheClearTarget(cacheRoot, raw) {
 async function runCacheClearCommand(options, logger) {
   const cacheRoot = resolveCacheRoot();
   const targets = options.target === void 0 ? listCacheEntryDirectories(cacheRoot) : [resolveCacheClearTarget(cacheRoot, options.target)];
-  const existing = targets.filter((target) => fs17.existsSync(target));
+  const existing = targets.filter((target) => fs18.existsSync(target));
   if (existing.length === 0) {
     if (options.target === void 0) {
       logger.info("Cache is already empty. Nothing to remove.");
@@ -18610,7 +18777,7 @@ async function runCacheClearCommand(options, logger) {
     return;
   }
   if (!options.yes) {
-    const label = options.target ?? existing.map((target) => path18.basename(target)).join(", ");
+    const label = options.target ?? existing.map((target) => path19.basename(target)).join(", ");
     const proceed = await dist_default5({
       message: `Remove ${existing.length} cached ${existing.length === 1 ? "entry" : "entries"} (${label})?`
     });
@@ -18620,7 +18787,7 @@ async function runCacheClearCommand(options, logger) {
     }
   }
   for (const target of existing) {
-    fs17.rmSync(target, { recursive: true, force: true });
+    fs18.rmSync(target, { recursive: true, force: true });
     logger.info(`Removed ${target}`);
   }
   logger.info(
@@ -18679,14 +18846,14 @@ var hs = new RegExp(pe, "g");
 var as = /\\\\/g;
 var ls = /\\{/g;
 var cs = /\\}/g;
-var fs18 = /\\,/g;
+var fs19 = /\\,/g;
 var us = /\\./g;
 var ds = 1e5;
 function Ht(n7) {
   return isNaN(n7) ? n7.charCodeAt(0) : parseInt(n7, 10);
 }
 function ps(n7) {
-  return n7.replace(as, fe).replace(ls, ue).replace(cs, qt).replace(fs18, de).replace(us, pe);
+  return n7.replace(as, fe).replace(ls, ue).replace(cs, qt).replace(fs19, de).replace(us, pe);
 }
 function ms(n7) {
   return n7.replace(is, "\\").replace(rs, "{").replace(ns, "}").replace(os4, ",").replace(hs, ".");
@@ -21617,8 +21784,8 @@ var Ze = Object.assign(Je, { glob: Je, globSync: ts, sync: Ui, globStream: Qe, s
 Ze.glob = Ze;
 
 // src/core/ownership.ts
-import fs19 from "fs";
-import path19 from "path";
+import fs20 from "fs";
+import path20 from "path";
 var KNOWN_COMPONENTS = /* @__PURE__ */ new Set([
   "agents",
   "skills",
@@ -21633,8 +21800,8 @@ var LEGACY_SOURCE_DIRECTORIES = /* @__PURE__ */ new Set([
   "operational-machinery"
 ]);
 function classifyArtifact(artifactPath, config, sourceRoot) {
-  const resolvedArtifactPath = path19.resolve(artifactPath);
-  if (!fs19.existsSync(resolvedArtifactPath) && !isBrokenSymlink(resolvedArtifactPath)) {
+  const resolvedArtifactPath = path20.resolve(artifactPath);
+  if (!fs20.existsSync(resolvedArtifactPath) && !isBrokenSymlink(resolvedArtifactPath)) {
     return "missing";
   }
   if (isOurSymlink(resolvedArtifactPath, sourceRoot)) {
@@ -21654,42 +21821,42 @@ function classifyArtifact(artifactPath, config, sourceRoot) {
 }
 function isOurSymlink(linkPath, machineryRoot) {
   try {
-    const linkTarget = fs19.readlinkSync(linkPath);
-    const absoluteTarget = path19.resolve(path19.dirname(linkPath), linkTarget);
-    const relative = path19.relative(machineryRoot, absoluteTarget);
-    return !relative.startsWith("..") && !path19.isAbsolute(relative);
+    const linkTarget = fs20.readlinkSync(linkPath);
+    const absoluteTarget = path20.resolve(path20.dirname(linkPath), linkTarget);
+    const relative = path20.relative(machineryRoot, absoluteTarget);
+    return !relative.startsWith("..") && !path20.isAbsolute(relative);
   } catch {
     return false;
   }
 }
 function isOurStaleSymlink(linkPath, managedPaths, config) {
-  const resolvedLinkPath = path19.resolve(linkPath);
+  const resolvedLinkPath = path20.resolve(linkPath);
   if (!managedPaths.has(resolvedLinkPath)) {
     return false;
   }
   try {
-    const linkTarget = fs19.readlinkSync(resolvedLinkPath);
-    const absoluteTarget = path19.resolve(
-      path19.dirname(resolvedLinkPath),
+    const linkTarget = fs20.readlinkSync(resolvedLinkPath);
+    const absoluteTarget = path20.resolve(
+      path20.dirname(resolvedLinkPath),
       linkTarget
     );
     let isBroken = false;
     try {
-      fs19.realpathSync(resolvedLinkPath);
+      fs20.realpathSync(resolvedLinkPath);
     } catch {
       isBroken = true;
     }
     const knownFiles = new Set(
       Object.values(config.source).map(
-        (sourcePath) => path19.basename(sourcePath)
+        (sourcePath) => path20.basename(sourcePath)
       )
     );
-    const lastSegment = path19.basename(linkTarget);
-    const parentSegment = path19.basename(path19.dirname(linkTarget));
+    const lastSegment = path20.basename(linkTarget);
+    const parentSegment = path20.basename(path20.dirname(linkTarget));
     if (isBroken) {
       return KNOWN_COMPONENTS.has(lastSegment) || KNOWN_COMPONENTS.has(parentSegment) || KNOWN_INSTRUCTION_FILES.has(lastSegment) || knownFiles.has(lastSegment);
     }
-    const targetSegments = absoluteTarget.split(path19.sep);
+    const targetSegments = absoluteTarget.split(path20.sep);
     const traversesLegacyRoot = targetSegments.some(
       (segment) => LEGACY_SOURCE_DIRECTORIES.has(segment)
     );
@@ -21703,12 +21870,12 @@ function isOurStaleSymlink(linkPath, managedPaths, config) {
 }
 function isBrokenSymlink(filePath) {
   try {
-    fs19.lstatSync(filePath);
+    fs20.lstatSync(filePath);
   } catch {
     return false;
   }
   try {
-    fs19.realpathSync(filePath);
+    fs20.realpathSync(filePath);
     return false;
   } catch {
     return true;
@@ -21716,26 +21883,26 @@ function isBrokenSymlink(filePath) {
 }
 function isManagedCompiledFile(filePath) {
   try {
-    const stat = fs19.lstatSync(filePath);
+    const stat = fs20.lstatSync(filePath);
     if (!stat.isFile() || stat.isSymbolicLink()) {
       return false;
     }
-    return extractProvenanceMarker(fs19.readFileSync(filePath, "utf8")) !== null;
+    return extractProvenanceMarker(fs20.readFileSync(filePath, "utf8")) !== null;
   } catch {
     return false;
   }
 }
 
 // src/core/merge.ts
-import fs20 from "fs";
-import path20 from "path";
+import fs21 from "fs";
+import path21 from "path";
 function readSharedFile(filePath, parser) {
-  if (!fs20.existsSync(filePath)) {
+  if (!fs21.existsSync(filePath)) {
     return { parsed: parser(""), unparseable: false };
   }
   try {
     return {
-      parsed: parser(fs20.readFileSync(filePath, "utf8")),
+      parsed: parser(fs21.readFileSync(filePath, "utf8")),
       unparseable: false
     };
   } catch {
@@ -21744,13 +21911,13 @@ function readSharedFile(filePath, parser) {
 }
 function writeSharedFile(filePath, parsed, serializer, logger) {
   const serialized = serializer(parsed);
-  if (fs20.existsSync(filePath) && fs20.readFileSync(filePath, "utf8") === serialized) {
+  if (fs21.existsSync(filePath) && fs21.readFileSync(filePath, "utf8") === serialized) {
     return false;
   }
   let realTarget = null;
   try {
-    if (fs20.lstatSync(filePath).isSymbolicLink()) {
-      realTarget = fs20.realpathSync(filePath);
+    if (fs21.lstatSync(filePath).isSymbolicLink()) {
+      realTarget = fs21.realpathSync(filePath);
     }
   } catch {
     realTarget = null;
@@ -21760,12 +21927,12 @@ function writeSharedFile(filePath, parsed, serializer, logger) {
       `tangyr: ${filePath} is a symlink \u2014 the file being modified is ${realTarget}`
     );
   }
-  fs20.mkdirSync(path20.dirname(filePath), { recursive: true });
-  fs20.writeFileSync(filePath, serialized);
+  fs21.mkdirSync(path21.dirname(filePath), { recursive: true });
+  fs21.writeFileSync(filePath, serialized);
   return true;
 }
 function removeManagedEntries(filePath, parser, serializer, removeManaged, logger, options) {
-  if (!fs20.existsSync(filePath)) {
+  if (!fs21.existsSync(filePath)) {
     return;
   }
   const readResult = readSharedFile(filePath, parser);
@@ -21777,98 +21944,16 @@ function removeManagedEntries(filePath, parser, serializer, removeManaged, logge
   }
   const cleaned = removeManaged(readResult.parsed);
   if (options?.removeFileWhen?.(readResult.parsed, cleaned)) {
-    fs20.rmSync(filePath, { force: true });
+    fs21.rmSync(filePath, { force: true });
     return;
   }
-  fs20.writeFileSync(filePath, serializer(cleaned));
+  fs21.writeFileSync(filePath, serializer(cleaned));
 }
 
 // src/commands/uninstall.ts
 import fs29 from "fs";
 import path29 from "path";
 
-// src/core/managed-sources.ts
-var import_yaml5 = __toESM(require_dist(), 1);
-import fs21 from "fs";
-import path21 from "path";
-function resolveKitComponentNames(sourceRoot, category) {
-  const manifestPath = path21.resolve(sourceRoot, "tangyr-kit.yaml");
-  if (!fs21.existsSync(manifestPath)) {
-    return void 0;
-  }
-  try {
-    const raw = fs21.readFileSync(manifestPath, "utf8");
-    const doc = (0, import_yaml5.parse)(raw);
-    if (doc && typeof doc === "object" && !Array.isArray(doc) && "components" in doc) {
-      const components = doc.components;
-      if (components && typeof components === "object" && !Array.isArray(components) && category in components) {
-        const names = components[category];
-        if (Array.isArray(names) && names.every((n7) => typeof n7 === "string")) {
-          return names;
-        }
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-function resolveKitHookNames(sourceRoot) {
-  return resolveKitComponentNames(sourceRoot, "hooks");
-}
-function resolveKitSkillNames(sourceRoot) {
-  return resolveKitComponentNames(sourceRoot, "skills");
-}
-function resolveKitEntrypointName(sourceRoot) {
-  const manifestPath = path21.resolve(sourceRoot, "tangyr-kit.yaml");
-  if (!fs21.existsSync(manifestPath)) {
-    return void 0;
-  }
-  try {
-    const doc = (0, import_yaml5.parse)(fs21.readFileSync(manifestPath, "utf8"));
-    if (doc && typeof doc === "object" && !Array.isArray(doc)) {
-      const value = doc.entrypoint;
-      if (typeof value === "string" && value.trim().length > 0) {
-        return value.trim();
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-function resolveHooksSourceFile(sourceRoot, config) {
-  return path21.resolve(sourceRoot, config.source.hooks, "hooks.json");
-}
-function resolveHooksSourceDir(sourceRoot, config) {
-  return path21.resolve(sourceRoot, config.source.hooks);
-}
-function hooksSourceExists(sourceRoot, config) {
-  const hooksJsonPath = resolveHooksSourceFile(sourceRoot, config);
-  if (fs21.existsSync(hooksJsonPath)) {
-    return true;
-  }
-  const hooksDir = resolveHooksSourceDir(sourceRoot, config);
-  if (!fs21.existsSync(hooksDir) || !fs21.statSync(hooksDir).isDirectory()) {
-    return false;
-  }
-  return fs21.readdirSync(hooksDir).some((f) => f.endsWith(".md") && !f.startsWith("."));
-}
-function hooksSourceLabel(sourceRoot, config) {
-  const dir = normalizeManagedSourcePath(
-    config.source.hooks.replace(/\\/gu, "/")
-  );
-  return fs21.existsSync(resolveHooksSourceFile(sourceRoot, config)) ? path21.posix.join(dir, "hooks.json") : `${dir}/`;
-}
-function resolveMcpSourceFile(sourceRoot, config) {
-  return path21.resolve(sourceRoot, config.source.mcp);
-}
-function mcpSourceLabel(config) {
-  return normalizeManagedSourcePath(config.source.mcp);
-}
-function normalizeManagedSourcePath(rawPath) {
-  const normalized = rawPath.replace(/\\/gu, "/");
-  return normalized.startsWith("./") ? normalized.slice(2) : normalized;
-}
-
 // src/compiler/hook-components.ts
 import fs23 from "fs";
 import path23 from "path";
@@ -24916,12 +25001,26 @@ function restoreBackup(backup, logger) {
     });
     fs29.rmSync(backup.backupLocation, { recursive: true, force: true });
   } else {
+    if (isEmptyDirectory(backup.originalPath)) {
+      fs29.rmdirSync(backup.originalPath);
+    }
     fs29.renameSync(backup.backupLocation, backup.originalPath);
   }
   logger.verbose(
     `  restored: ${backup.backupLocation} \u2192 ${backup.originalPath}`
   );
 }
+function isEmptyDirectory(candidate) {
+  try {
+    const stat = fs29.lstatSync(candidate);
+    if (!stat.isDirectory()) {
+      return false;
+    }
+    return fs29.readdirSync(candidate).length === 0;
+  } catch {
+    return false;
+  }
+}
 function isSymlink(p) {
   try {
     return fs29.lstatSync(p).isSymbolicLink();
@@ -27173,9 +27272,10 @@ function buildAgentsMdShim(_shimPath, _agentsMdPath, target) {
 ${SHIM_BODY}`;
 }
 
-// src/core/skills-slot.ts
+// src/core/linked-slot.ts
 import fs37 from "fs";
 import path37 from "path";
+var SKILL_ENTRY = { component: "skills", kind: "dir" };
 function isForeignSkillsSlotSymlink(destination, config, sourceRoot, source) {
   if (!isSymlinkPath(destination)) {
     return false;
@@ -27188,16 +27288,17 @@ function isForeignSkillsSlotSymlink(destination, config, sourceRoot, source) {
 }
 function syncSkillsSlot(sync) {
   const { source, destination, logger } = sync;
+  const entry = sync.entry ?? SKILL_ENTRY;
   if (!fs37.existsSync(source)) {
     return [
       {
-        component: "skills",
+        component: entry.component,
         status: "skipped",
         path: `${source}: source not configured`
       }
     ];
   }
-  const declaredNames = resolveKitSkillNames(sync.sourceRoot);
+  const declaredNames = sync.declared ?? (entry.component === "skills" ? resolveKitSkillNames(sync.sourceRoot) : void 0);
   const foreignSlotSymlink = isForeignSkillsSlotSymlink(
     destination,
     sync.config,
@@ -27208,56 +27309,103 @@ function syncSkillsSlot(sync) {
   if (sync.dryRun) {
     if (foreignSlotSymlink) {
       logger.info(
-        `[dry-run] skills: ${destination} is a symlink Tangyr did not create \u2014 unmanaged conflict, slot left alone`
+        `[dry-run] ${entry.component}: ${destination} is a symlink Tangyr did not create \u2014 unmanaged conflict, slot left alone`
       );
-      return [{ component: "skills", status: "conflict", path: destination }];
+      return [
+        { component: entry.component, status: "conflict", path: destination }
+      ];
     }
     const outcomes2 = [];
     if (isLegacyWholesaleSymlink) {
-      for (const name of foreignSkillNames(source, declaredNames)) {
+      for (const name of foreignSkillNames(source, declaredNames, entry)) {
+        const file = entryFileName(name, entry);
         logger.info(
-          `[dry-run] skills: migrate foreign skill ${path37.join(source, name)} -> ${path37.join(destination, name)}`
+          `[dry-run] ${entry.component}: migrate undeclared ${path37.join(source, file)} -> ${path37.join(destination, file)}`
         );
       }
       logger.info(
-        `[dry-run] skills: replace wholesale symlink with real directory ${destination}`
+        `[dry-run] ${entry.component}: replace wholesale symlink with real directory ${destination}`
       );
     }
-    for (const name of declaredNames ?? listSkillDirNames(source)) {
-      const skillDestination = path37.join(destination, name);
+    for (const name of declaredNames ?? listEntryNames(source, entry)) {
+      const file = entryFileName(name, entry);
+      const entryDestination = path37.join(destination, file);
       logger.info(
-        `[dry-run] skills: symlink ${path37.join(source, name)} -> ${skillDestination}`
+        `[dry-run] ${entry.component}: symlink ${path37.join(source, file)} -> ${entryDestination}`
       );
       outcomes2.push({
-        component: "skills",
+        component: entry.component,
         status: "dry-run",
-        path: skillDestination
+        path: entryDestination
       });
     }
     return outcomes2;
   }
   if (foreignSlotSymlink) {
     if (!sync.onUnmanagedConflict(destination) || isSymlinkPath(destination)) {
-      return [{ component: "skills", status: "conflict", path: destination }];
+      return [
+        { component: entry.component, status: "conflict", path: destination }
+      ];
     }
   }
   if (isLegacyWholesaleSymlink) {
-    migrateWholesaleSkillsSymlink(source, destination, declaredNames, logger);
+    migrateWholesaleSkillsSymlink(
+      source,
+      destination,
+      declaredNames,
+      entry,
+      logger
+    );
   }
   ensureDir(destination);
   const outcomes = [];
-  for (const name of declaredNames ?? listSkillDirNames(source)) {
-    outcomes.push(syncSingleSkill(sync, name));
+  for (const name of declaredNames ?? listEntryNames(source, entry)) {
+    outcomes.push(syncSingleSkill(sync, name, entry));
   }
+  pruneUndeclaredLinks(source, destination, declaredNames, entry, logger);
   return outcomes;
 }
-function syncSingleSkill(sync, name) {
+function pruneUndeclaredLinks(source, destination, declaredNames, entry, logger) {
+  if (!declaredNames) {
+    return;
+  }
+  const declared = new Set(
+    declaredNames.map((name) => entryFileName(name, entry))
+  );
+  let present;
+  try {
+    present = fs37.readdirSync(destination, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const found2 of present) {
+    if (!found2.isSymbolicLink() || declared.has(found2.name)) {
+      continue;
+    }
+    const link = path37.join(destination, found2.name);
+    let target;
+    try {
+      target = path37.resolve(destination, fs37.readlinkSync(link));
+    } catch {
+      continue;
+    }
+    if (path37.dirname(target) !== path37.resolve(source)) {
+      continue;
+    }
+    fs37.unlinkSync(link);
+    logger.verbose(
+      `  ${entry.component}: removed ${link} \u2014 the kit no longer declares it`
+    );
+  }
+}
+function syncSingleSkill(sync, name, entry) {
   const { config, sourceRoot, source, destination } = sync;
-  const skillSource = path37.join(source, name);
-  const skillDestination = path37.join(destination, name);
+  const file = entryFileName(name, entry);
+  const skillSource = path37.join(source, file);
+  const skillDestination = path37.join(destination, file);
   if (!fs37.existsSync(skillSource)) {
     return {
-      component: "skills",
+      component: entry.component,
       status: "skipped",
       path: `${skillSource}: source not configured`
     };
@@ -27265,7 +27413,7 @@ function syncSingleSkill(sync, name) {
   const artifactClass = classifyArtifact(skillDestination, config, sourceRoot);
   if (artifactClass === "managed-symlink" && isSymlinkTo2(skillDestination, skillSource)) {
     return {
-      component: "skills",
+      component: entry.component,
       status: "skipped-current",
       path: skillDestination
     };
@@ -27273,44 +27421,63 @@ function syncSingleSkill(sync, name) {
   if (artifactClass === "managed-stale" && isOurStaleSymlink(skillDestination, /* @__PURE__ */ new Set([skillDestination]), config)) {
     fs37.unlinkSync(skillDestination);
   } else if (artifactClass === "unmanaged-conflict" && !sync.onUnmanagedConflict(skillDestination)) {
-    return { component: "skills", status: "conflict", path: skillDestination };
+    return {
+      component: entry.component,
+      status: "conflict",
+      path: skillDestination
+    };
   } else if (artifactClass === "managed-symlink") {
     fs37.unlinkSync(skillDestination);
   }
-  createRelativeSymlink(skillSource, skillDestination, "dir");
-  return { component: "skills", status: "success", path: skillDestination };
+  createRelativeSymlink(skillSource, skillDestination, entry.kind);
+  return {
+    component: entry.component,
+    status: "success",
+    path: skillDestination
+  };
 }
-function migrateWholesaleSkillsSymlink(source, destination, declaredNames, logger) {
-  const foreignNames = foreignSkillNames(source, declaredNames);
+function migrateWholesaleSkillsSymlink(source, destination, declaredNames, entry, logger) {
+  const foreignNames = foreignSkillNames(source, declaredNames, entry);
   fs37.unlinkSync(destination);
   ensureDir(destination);
   for (const name of foreignNames) {
-    const from = path37.join(source, name);
-    const to = path37.join(destination, name);
+    const file = entryFileName(name, entry);
+    const from = path37.join(source, file);
+    const to = path37.join(destination, file);
     if (fs37.existsSync(to)) {
       logger.warn(
-        `skills migration: ${to} already exists \u2014 skipping ${from} to avoid overwrite. Nothing in the kit was changed.`
+        `${entry.component} migration: ${to} already exists \u2014 skipping ${from} to avoid overwrite. Nothing in the kit was changed.`
       );
       continue;
     }
     fs37.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
     logger.warn(
-      `skills migration: '${name}' is present under the kit's skills/ but is not declared in its manifest. Copied ${from} -> ${to} so the harness can read it. The original is left in the kit deliberately: this command does not modify a kit. Remove ${from} yourself if it does not belong there, or declare it in tangyr-kit.yaml if it does.`
+      `${entry.component} migration: '${name}' is present in the kit's ${entry.component}/ but is not declared in its manifest. Copied ${from} -> ${to} so the harness can read it. The original is left in the kit deliberately: this command does not modify a kit. Remove ${from} yourself if it does not belong there, or declare it in tangyr-kit.yaml if it does.`
     );
   }
 }
-function foreignSkillNames(source, declaredNames) {
+function foreignSkillNames(source, declaredNames, entry) {
   if (!declaredNames) {
     return [];
   }
   const declaredSet = new Set(declaredNames);
-  return listSkillDirNames(source).filter((name) => !declaredSet.has(name));
+  return listEntryNames(source, entry).filter((name) => !declaredSet.has(name));
 }
-function listSkillDirNames(dir) {
+function listEntryNames(dir, entry) {
   if (!fs37.existsSync(dir)) {
     return [];
   }
-  return fs37.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+  const found2 = fs37.readdirSync(dir, { withFileTypes: true });
+  if (entry.kind === "dir") {
+    return found2.filter((one) => one.isDirectory() && !one.name.startsWith(".")).map((one) => one.name);
+  }
+  const extension = entry.extension ?? "";
+  return found2.filter(
+    (one) => one.isFile() && !one.name.startsWith(".") && one.name.endsWith(extension)
+  ).map((one) => one.name.slice(0, one.name.length - extension.length));
+}
+function entryFileName(name, entry) {
+  return entry.kind === "dir" ? name : `${name}${entry.extension ?? ""}`;
 }
 function isSymlinkPath(filePath) {
   try {
@@ -27500,6 +27667,20 @@ function syncClaudeCode(config, sourceRoot, options, logger, mappings, manifest,
     if (shouldSkipComponent(options, directComponent.component)) {
       continue;
     }
+    if (directComponent.type === "dir") {
+      outcomes.push(
+        ...syncClaudeCodeSlot(
+          config,
+          sourceRoot,
+          options,
+          logger,
+          directComponent,
+          manifest,
+          scopePath
+        )
+      );
+      continue;
+    }
     outcomes.push(
       syncDirectComponent(
         config,
@@ -27692,6 +27873,52 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
   recordShimState(manifest, shimPath);
   logger?.verbose(`instructions-shim: backed up and replaced -> ${shimPath}`);
 }
+var SLOT_ENTRIES = {
+  agents: {
+    category: "agents",
+    entry: { component: "agents", kind: "file", extension: ".md" }
+  },
+  commands: {
+    category: "commands",
+    entry: { component: "commands", kind: "file", extension: ".md" }
+  },
+  rules: {
+    category: "rules",
+    entry: { component: "rules", kind: "file", extension: ".md" }
+  },
+  "output-styles": {
+    category: null,
+    entry: { component: "output-styles", kind: "file", extension: ".md" }
+  }
+};
+function syncClaudeCodeSlot(config, sourceRoot, options, logger, directComponent, manifest, scopePath) {
+  const shape = SLOT_ENTRIES[directComponent.component];
+  const source = path40.resolve(
+    sourceRoot,
+    config.source[directComponent.sourceKey]
+  );
+  if (!shape) {
+    return [skippedMissingSource(directComponent.component, source)];
+  }
+  return syncSkillsSlot({
+    config,
+    sourceRoot,
+    source,
+    destination: directComponent.destination,
+    dryRun: options.dryRun,
+    logger,
+    entry: shape.entry,
+    declared: shape.category === null ? void 0 : resolveKitSlotNames(sourceRoot, shape.category),
+    onUnmanagedConflict: (conflictPath) => handleConflict(
+      conflictPath,
+      config,
+      options,
+      logger,
+      manifest,
+      scopePath
+    )
+  });
+}
 function syncDirectComponent(config, sourceRoot, options, logger, directComponent, manifest, scopePath) {
   const source = directComponent.sourceKey === "instructions" ? instructionsSourcePath(sourceRoot, config) : path40.resolve(sourceRoot, config.source[directComponent.sourceKey]);
   const sourceLabel = directComponent.sourceKey === "instructions" ? instructionsSourceLabel(sourceRoot, config) : config.source[directComponent.sourceKey];
@@ -32458,8 +32685,28 @@ async function runInstallCommand(options, logger) {
     config: options.config,
     scope
   });
+  const claudeProfileForConflicts = (() => {
+    try {
+      return resolveTargetPaths({
+        scope,
+        projectRoot,
+        mappings: loadMappings(kitInfo.path, config, configDir).platformPaths
+      })["claude-code"];
+    } catch {
+      return void 0;
+    }
+  })();
   const skillsSource = path50.resolve(kitInfo.path, config.source.skills);
-  const isPerSkillSkillsSlot = (f) => (f.tool === "claude-code" || f.tool === "copilot") && path50.basename(f.path) === "skills";
+  const perEntrySlots = new Set(
+    [
+      claudeProfileForConflicts?.agents,
+      claudeProfileForConflicts?.commands,
+      claudeProfileForConflicts?.rules,
+      claudeProfileForConflicts?.output_styles,
+      claudeProfileForConflicts?.skills
+    ].filter((slot) => typeof slot === "string")
+  );
+  const isPerSkillSkillsSlot = (f) => f.tool === "copilot" && path50.basename(f.path) === "skills" || f.tool === "claude-code" && perEntrySlots.has(f.path);
   const foreignSkillsSlots = new Set(
     assessResult.findings.filter(
       (f) => isPerSkillSkillsSlot(f) && isForeignSkillsSlotSymlink(
@@ -33038,7 +33285,13 @@ function installClaudeCodeAdapterSlots(args) {
     { component: "hooks", slot: "hooks_shared_file" },
     { component: "settings", slot: "settings_shared_file" },
     { component: "mcp", slot: "mcp_shared_file" },
-    { component: "output-styles", slot: "output_styles" }
+    { component: "output-styles", slot: "output_styles" },
+    // Filled one entry at a time, so they are the adapter's work and not a
+    // placement's. The slot root is still what `skippedTargetPaths` is asked
+    // about: an operator who declined the whole directory declined all of it.
+    { component: "agents", slot: "agents" },
+    { component: "commands", slot: "commands" },
+    { component: "rules", slot: "rules" }
   ];
   const scopePath = resolveScopePath(
     scope,
@@ -33119,6 +33372,15 @@ function claudeCodeOutcomeToManifestKey(profile, outcome, scope, projectRoot, ma
       return `claude-code/${slot}`;
     }
   }
+  for (const [slot, slotPath] of Object.entries(profile)) {
+    if (typeof slotPath !== "string") {
+      continue;
+    }
+    const prefix = `${slotPath}${path50.sep}`;
+    if (outcome.path.startsWith(prefix)) {
+      return `claude-code/${slot}/${outcome.path.slice(prefix.length)}`;
+    }
+  }
   return null;
 }
 function resolveClaudeCodeSkillsDestination(scope, projectRoot, mappings) {
@@ -33468,6 +33730,19 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
   if (shared) {
     return shared;
   }
+  if (tool === "claude-code") {
+    return claudeCodeOutcomeToManifestKey(
+      resolveTargetPaths({
+        scope,
+        projectRoot,
+        mappings: mappings.platformPaths
+      })["claude-code"],
+      outcome,
+      scope,
+      projectRoot,
+      mappings
+    );
+  }
   if (tool !== "copilot" && tool !== "codex" && tool !== "opencode" && tool !== "cursor" && tool !== "cline") {
     if (isDeferredTarget(tool)) {
       throw new Error(
@@ -33715,23 +33990,6 @@ function getClaudeCodePlacements(kitInfo, config, scope = "global", projectRoot,
       isDir: false
     });
   }
-  const componentDirMap = {
-    agents: resolvedPaths.agents,
-    commands: resolvedPaths.commands,
-    rules: resolvedPaths.rules
-  };
-  for (const [component, targetPath] of Object.entries(componentDirMap)) {
-    const componentDir = path50.join(kitInfo.path, component);
-    if (fs47.existsSync(componentDir) && fs47.statSync(componentDir).isDirectory()) {
-      placements.push({
-        source: componentDir,
-        destination: targetPath,
-        manifestKey: `claude-code/${component}`,
-        type: "symlink",
-        isDir: true
-      });
-    }
-  }
   return placements;
 }
 function getClaudeCodePlacementsFromProfile(kitInfo, profile, config) {
@@ -33746,23 +34004,6 @@ function getClaudeCodePlacementsFromProfile(kitInfo, profile, config) {
       isDir: false
     });
   }
-  const componentDirMap = {
-    agents: profile.agents,
-    commands: profile.commands,
-    rules: profile.rules
-  };
-  for (const [component, targetPath] of Object.entries(componentDirMap)) {
-    const componentDir = path50.join(kitInfo.path, component);
-    if (fs47.existsSync(componentDir) && fs47.statSync(componentDir).isDirectory()) {
-      placements.push({
-        source: componentDir,
-        destination: targetPath,
-        manifestKey: `claude-code/${component}`,
-        type: "symlink",
-        isDir: true
-      });
-    }
-  }
   return placements;
 }
 function collectAllFiles(kitInfo, config) {
@@ -36043,6 +36284,7 @@ function updateManifest(kitInfo, kitSync, written) {
   writeManifest(kitSync.scopePath, kitSync.manifest);
 }
 var outcomeRecordableTargets = /* @__PURE__ */ new Set([
+  "claude-code",
   "copilot",
   "codex",
   "opencode",