claudekit-cli 3.42.2-dev.4 → 3.42.2-dev.6

package/cli-manifest.json

@@ -1,6 +1,6 @@
 {
-	"version": "3.42.2-dev.4",
-	"generatedAt": "2026-04-29T21:26:47.128Z",
+	"version": "3.42.2-dev.6",
+	"generatedAt": "2026-05-04T15:17:33.645Z",
 	"commands": {
 		"agents": {
 			"name": "agents",

package/dist/index.js

@@ -7054,7 +7054,7 @@ function convertFmToCodexToml(item) {
   if (modelResult.resolved) {
     lines.push(`model = ${JSON.stringify(modelResult.resolved.model)}`);
     if (modelResult.resolved.effort) {
-      lines.push(`# effort = ${JSON.stringify(modelResult.resolved.effort)}`);
+      lines.push(`model_reasoning_effort = ${JSON.stringify(modelResult.resolved.effort)}`);
     }
   } else if (typeof item.frontmatter.model === "string" && item.frontmatter.model.trim().length > 0 && item.frontmatter.model.trim() !== "inherit") {
     lines.push(`# model = ${JSON.stringify(item.frontmatter.model.trim())}`);
@@ -12460,6 +12460,9 @@ function getReasonCopy(code, _ctx) {
       return "Target state unavailable while CK changed — manual review required";
   }
 }
+function providerConfigAppliesToType(config, type) {
+  return config.types === undefined || config.types.includes(type);
+}
 var UNKNOWN_CHECKSUM = "unknown";
 
 // src/commands/portable/portable-registry.ts
@@ -43801,6 +43804,26 @@ function repairClaudeNodeCommandPath(cmd, root) {
     const command = formatCanonicalClaudeCommand(nodePrefix, root, relativePath, suffix);
     return { command, changed: command !== cmd, issue: "invalid-format" };
   }
+  const absoluteMatch = cmd.match(/^(node\s+)"((?:[A-Za-z]:[/\\]|\/)[^"]*?[/\\]\.claude[/\\][^"]+)"(.*)$/) ?? cmd.match(/^(node\s+)((?:[A-Za-z]:[\\/]|\/)[^\s"]*?[\\/]\.claude[\\/][^\s"]+)(.*)$/);
+  if (absoluteMatch) {
+    const [, nodePrefix, absolutePath, suffix] = absoluteMatch;
+    const normalizedAbsPath = absolutePath.replace(/\\/g, "/");
+    const dotClaudeIdx = normalizedAbsPath.indexOf("/.claude/");
+    if (dotClaudeIdx === -1) {
+      return { command: cmd, changed: false, issue: null };
+    }
+    const isWin2 = process.platform === "win32";
+    const cmp = (s) => isWin2 ? s.toLowerCase() : s;
+    const globalRoots = [
+      `${homedir11().replace(/\\/g, "/").replace(/\/+$/, "")}/.claude/`,
+      `${PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "")}/`
+    ];
+    const isUnderGlobal = globalRoots.some((g2) => cmp(normalizedAbsPath).startsWith(cmp(g2)));
+    const resolvedRoot = isUnderGlobal ? "$HOME" : root;
+    const relativePath = normalizedAbsPath.slice(dotClaudeIdx + 1);
+    const command = formatCanonicalClaudeCommand(nodePrefix, resolvedRoot, relativePath, suffix);
+    return { command, changed: command !== cmd, issue: "invalid-format" };
+  }
   return { command: cmd, changed: false, issue: null };
 }
 function normalizeCommand(cmd) {
@@ -51084,6 +51107,74 @@ var init_commands_discovery = __esm(() => {
   SKIP_DIRS2 = ["node_modules", ".git", "dist", "build"];
 });
 
+// src/commands/migrate/migrate-provider-scopes.ts
+function portableTypeToGroup(type) {
+  return TYPE_TO_GROUP[type];
+}
+function portableGroupToType(group) {
+  return GROUP_TO_TYPE[group];
+}
+function getEnabledPortableTypes(include) {
+  return RECONCILE_PORTABLE_TYPES.filter((type) => include[portableTypeToGroup(type)]);
+}
+function resolvePortableTypeGlobal(provider, type, requestedGlobal) {
+  if (requestedGlobal)
+    return true;
+  const providerConfig = providers[provider];
+  const group = portableTypeToGroup(type);
+  const pathConfig = providerConfig?.[group];
+  if (pathConfig?.projectPath === null && pathConfig.globalPath !== null) {
+    return true;
+  }
+  return false;
+}
+function resolvePortableGroupGlobal(provider, group, requestedGlobal) {
+  return resolvePortableTypeGlobal(provider, portableGroupToType(group), requestedGlobal);
+}
+function buildScopedProviderConfigs(selectedProviders, include, requestedGlobal) {
+  const enabledTypes = getEnabledPortableTypes(include);
+  const configs = [];
+  for (const provider of selectedProviders) {
+    const typesByScope = new Map;
+    for (const type of enabledTypes) {
+      const isGlobal = resolvePortableTypeGlobal(provider, type, requestedGlobal);
+      typesByScope.set(isGlobal, [...typesByScope.get(isGlobal) ?? [], type]);
+    }
+    for (const [global3, types4] of typesByScope) {
+      configs.push({ provider, global: global3, types: types4 });
+    }
+  }
+  return configs;
+}
+var RECONCILE_PORTABLE_TYPES, TYPE_TO_GROUP, GROUP_TO_TYPE;
+var init_migrate_provider_scopes = __esm(() => {
+  init_provider_registry();
+  RECONCILE_PORTABLE_TYPES = [
+    "agent",
+    "command",
+    "skill",
+    "config",
+    "rules",
+    "hooks"
+  ];
+  TYPE_TO_GROUP = {
+    agent: "agents",
+    command: "commands",
+    skill: "skills",
+    config: "config",
+    rules: "rules",
+    hooks: "hooks"
+  };
+  GROUP_TO_TYPE = {
+    agents: "agent",
+    commands: "command",
+    skills: "skill",
+    config: "config",
+    rules: "rules",
+    hooks: "hooks"
+  };
+});
+
 // src/commands/migrate/skill-directory-installer.ts
 import { existsSync as existsSync21 } from "node:fs";
 import { cp, mkdir as mkdir8, rename as rename5, rm as rm4 } from "node:fs/promises";
@@ -54668,11 +54759,13 @@ function buildSourceItemState(item, type, selectedProviders, options2) {
 }
 function buildTypeDirectoryStates(providerConfigs, types4) {
   const results = [];
-  for (const { provider, global: isGlobal } of providerConfigs) {
+  for (const { provider, global: isGlobal, types: configTypes } of providerConfigs) {
     const providerConfig = providers[provider];
     if (!providerConfig)
       continue;
     for (const type of types4) {
+      if (configTypes !== undefined && !configTypes.includes(type))
+        continue;
       const pathKey = portableTypeToProviderPathKey(type);
       const pathConfig = providerConfig[pathKey];
       if (!pathConfig)
@@ -54846,16 +54939,26 @@ function makeDirStateKey(provider, type, global3) {
   return JSON.stringify([provider, type, global3]);
 }
 function dedupeProviderConfigs(providerConfigs) {
-  const seen = new Set;
-  const unique = [];
+  const unique = new Map;
   for (const config of providerConfigs) {
     const key = makeProviderConfigKey(config.provider, config.global);
-    if (seen.has(key))
+    const existing = unique.get(key);
+    if (!existing) {
+      unique.set(key, config.types ? { ...config, types: [...config.types] } : { ...config });
       continue;
-    seen.add(key);
-    unique.push(config);
+    }
+    if (existing.types === undefined || config.types === undefined) {
+      existing.types = undefined;
+      continue;
+    }
+    existing.types = Array.from(new Set([...existing.types, ...config.types]));
   }
-  return unique;
+  return Array.from(unique.values());
+}
+function providerConfigIsActiveForEntry(providerConfigs, entry, options2 = {}) {
+  if (options2.emptyMeansAll && providerConfigs.length === 0)
+    return true;
+  return providerConfigs.some((config) => config.provider === entry.provider && config.global === entry.global && providerConfigAppliesToType(config, entry.type));
 }
 function buildTargetStateIndex(targetStates) {
   const index = new Map;
@@ -55044,6 +55147,8 @@ function reconcile(input) {
   actions.push(...sectionRenames);
   for (const sourceItem of input.sourceItems) {
     for (const providerConfig of uniqueProviderConfigs) {
+      if (!providerConfigAppliesToType(providerConfig, sourceItem.type))
+        continue;
       const action = determineAction(sourceItem, providerConfig, input, targetStateIndex, deletedIdentityKeys);
       actions.push(action);
     }
@@ -55307,13 +55412,12 @@ function findRegistryEntry(source, providerConfig, registry) {
 function detectOrphans(input, renamedFromKeys) {
   const actions = [];
   const sourceItemKeys = new Set(input.sourceItems.map((s) => makeItemTypeKey(s.item, s.type)));
-  const activeProviderKeys = new Set(input.providerConfigs.map((provider) => makeProviderConfigKey(provider.provider, provider.global)));
+  const activeProviderConfigs = dedupeProviderConfigs(input.providerConfigs);
   const hasConfigSource = input.sourceItems.some((source) => source.type === "config");
   for (const entry of input.registry.installations) {
     const key = makeRegistryIdentityKey(entry);
     const sourceItemKey = makeItemTypeKey(entry.item, entry.type);
-    const providerKey = makeProviderConfigKey(entry.provider, entry.global);
-    if (!activeProviderKeys.has(providerKey))
+    if (!providerConfigIsActiveForEntry(activeProviderConfigs, entry))
       continue;
     if (renamedFromKeys.has(key))
       continue;
@@ -55345,13 +55449,14 @@ function detectRenames(input) {
     return [];
   const applicable = getApplicableEntries(input.manifest.renames, input.registry.appliedManifestVersion, input.manifest.cliVersion);
   const actions = [];
+  const activeProviderConfigs = dedupeProviderConfigs(input.providerConfigs);
   for (const rename8 of applicable) {
     if (hasDotDotSegment(rename8.from) || hasDotDotSegment(rename8.to) || isAbsoluteLike(rename8.from) || isAbsoluteLike(rename8.to)) {
       console.warn(`[!] Skipping suspicious manifest rename: ${rename8.from} -> ${rename8.to}`);
       continue;
     }
     const normalizedFrom = normalizePortablePath(rename8.from);
-    const oldEntries = input.registry.installations.filter((e2) => normalizePortablePath(e2.sourcePath) === normalizedFrom);
+    const oldEntries = input.registry.installations.filter((e2) => normalizePortablePath(e2.sourcePath) === normalizedFrom && providerConfigIsActiveForEntry(activeProviderConfigs, e2, { emptyMeansAll: true }));
     for (const oldEntry of oldEntries) {
       const code = "renamed-cleanup";
       actions.push({
@@ -55378,8 +55483,9 @@ function detectPathMigrations(input) {
     return [];
   const applicable = getApplicableEntries(input.manifest.providerPathMigrations, input.registry.appliedManifestVersion, input.manifest.cliVersion);
   const actions = [];
+  const activeProviderConfigs = dedupeProviderConfigs(input.providerConfigs);
   for (const migration of applicable) {
-    const affectedEntries = input.registry.installations.filter((e2) => e2.provider === migration.provider && e2.type === migration.type && pathContainsSegments(e2.path, migration.from));
+    const affectedEntries = input.registry.installations.filter((e2) => e2.provider === migration.provider && e2.type === migration.type && pathContainsSegments(e2.path, migration.from) && providerConfigIsActiveForEntry(activeProviderConfigs, e2, { emptyMeansAll: true }));
     for (const entry of affectedEntries) {
       const code = "path-migrated-cleanup";
       actions.push({
@@ -55790,6 +55896,17 @@ function annotateResultsWithCollisions(results, collisions) {
     }
   }
 }
+function dedupeProviderPathCollisions(collisions) {
+  const unique = new Map;
+  for (const collision of collisions) {
+    const providersKey = [...collision.providers].sort().join("\x00");
+    const key = JSON.stringify([collision.path, collision.portableType, providersKey]);
+    if (!unique.has(key)) {
+      unique.set(key, { ...collision, providers: [...collision.providers] });
+    }
+  }
+  return Array.from(unique.values());
+}
 var init_migration_result_utils = __esm(() => {
   init_provider_registry();
 });
@@ -56164,6 +56281,19 @@ function providerSupportsType(provider, type) {
     return getProvidersSupporting("hooks").includes(provider);
   return false;
 }
+function groupProvidersByTypeScope(selectedProviders, type, requestedGlobal) {
+  const grouped = new Map;
+  for (const provider of selectedProviders) {
+    if (!providerSupportsType(provider, type))
+      continue;
+    const global3 = resolvePortableTypeGlobal(provider, type, requestedGlobal);
+    grouped.set(global3, [...grouped.get(global3) ?? [], provider]);
+  }
+  return Array.from(grouped, ([global3, providersForScope]) => ({
+    global: global3,
+    providers: providersForScope
+  }));
+}
 function createSkippedActionResult(action, reason) {
   const provider = action.provider;
   return {
@@ -56538,17 +56668,12 @@ function registerMigrationRoutes(app) {
         onReadFailure: (entryPath, error) => warnReadFailure("registry-target", entryPath, error)
       });
       const manifest = discovered.sourcePaths.agents ? await loadPortableManifest(discovered.sourcePaths.agents) : null;
-      const providerConfigs = selectedProviders.map((provider) => ({
-        provider,
-        global: globalParam
-      }));
-      const enabledTypes = ["agent", "command", "skill", "config", "rules", "hooks"].filter((type) => {
-        const key = type === "agent" ? "agents" : type === "command" ? "commands" : type === "skill" ? "skills" : type === "config" ? "config" : type === "rules" ? "rules" : "hooks";
-        return include[key];
-      });
+      const providerConfigs = buildScopedProviderConfigs(selectedProviders, include, globalParam);
+      const enabledTypes = getEnabledPortableTypes(include);
       const typeDirectoryStates = reinstallEmptyDirs ? buildTypeDirectoryStates(providerConfigs.map((p) => ({
         provider: p.provider,
-        global: p.global
+        global: p.global,
+        types: p.types
       })), enabledTypes) : undefined;
       const input = {
         sourceItems,
@@ -56596,13 +56721,14 @@ function registerMigrationRoutes(app) {
         for (const item of items) {
           const sourcePath = item.sourcePath ?? item.path ?? "";
           for (const provider of selectedProviders) {
-            const registryEntry = registry.installations.find((inst) => inst.item === item.name && inst.type === type && inst.provider === provider && inst.global === globalParam);
+            const candidateGlobal = resolvePortableTypeGlobal(provider, type, globalParam);
+            const registryEntry = registry.installations.find((inst) => inst.item === item.name && inst.type === type && inst.provider === provider && inst.global === candidateGlobal);
             const alreadyInstalled = registryEntry !== undefined;
             candidates.push({
               item: item.name,
               type,
               provider,
-              global: globalParam,
+              global: candidateGlobal,
               isDirectoryItem,
               description: item.description,
               sourcePath,
@@ -56690,14 +56816,12 @@ function registerMigrationRoutes(app) {
           sourcePath: h2.sourcePath ?? ""
         })), "hooks", false);
       }
-      const providerConfigs = selectedProviders.map((provider) => ({
-        provider,
-        global: globalParam
+      const providerConfigs = buildScopedProviderConfigs(selectedProviders, include, globalParam).map((config) => ({
+        provider: config.provider,
+        global: config.global,
+        types: config.types
       }));
-      const enabledTypes = ["agent", "command", "skill", "config", "rules", "hooks"].filter((type) => {
-        const key = type === "agent" ? "agents" : type === "command" ? "commands" : type === "skill" ? "skills" : type === "config" ? "config" : type === "rules" ? "rules" : "hooks";
-        return include[key];
-      });
+      const enabledTypes = getEnabledPortableTypes(include);
       const typeDirectoryStates = buildTypeDirectoryStates(providerConfigs, enabledTypes);
       res.status(200).json({ candidates, typeDirectoryStates });
     } catch (error) {
@@ -56860,13 +56984,15 @@ function registerMigrationRoutes(app) {
           const plannedSkills = allowedSkillNames.length > 0 ? discovered2.skills.filter((skill) => allowedSkillNames.includes(skill.name)) : executionMode === "install" ? [] : discovered2.skills;
           const skillProviders = allPlanProviders.filter((provider) => providerSupportsType(provider, "skill"));
           if (skillProviders.length > 0) {
-            const globalFromPlan = plan.actions[0]?.global ?? false;
             for (const skill of plannedSkills) {
-              const batch = await installSkillDirectories([skill], skillProviders, {
-                global: globalFromPlan
-              });
-              tagResults(batch, "skills", skill.name);
-              allResults.push(...batch);
+              for (const provider of skillProviders) {
+                const globalFromPlan = plan.actions.find((action) => action.provider === provider && action.type === "skill")?.global ?? false;
+                const batch = await installSkillDirectories([skill], [provider], {
+                  global: globalFromPlan
+                });
+                tagResults(batch, "skills", skill.name);
+                allResults.push(...batch);
+              }
             }
           }
         }
@@ -56886,12 +57012,12 @@ function registerMigrationRoutes(app) {
         for (const provider of allPlanProviders) {
           if (providers[provider]?.agents?.writeStrategy !== "codex-toml")
             continue;
-          const providerScopes = [
+          const providerScopes2 = [
             ...new Set(plan.actions.filter((a3) => a3.provider === provider).map((a3) => a3.global).filter((g2) => g2 !== undefined))
           ];
-          if (providerScopes.length === 0)
-            providerScopes.push(false);
-          for (const scope of providerScopes) {
+          if (providerScopes2.length === 0)
+            providerScopes2.push(false);
+          for (const scope of providerScopes2) {
             const staleSlugs = await cleanupStaleCodexConfigEntries({
               global: scope,
               provider
@@ -56918,7 +57044,7 @@ function registerMigrationRoutes(app) {
         const planScopes = [
           ...new Set(plan.actions.map((a3) => a3.global).filter((s) => s !== undefined))
         ];
-        const providerCollisions2 = planScopes.flatMap((scope) => detectProviderPathCollisions(allPlanProviders, { global: scope }));
+        const providerCollisions2 = dedupeProviderPathCollisions(planScopes.flatMap((scope) => detectProviderPathCollisions(allPlanProviders, { global: scope })));
         annotateResultsWithCollisions(sortedResults2, providerCollisions2);
         res.status(200).json({
           results: sortedResults2,
@@ -56954,10 +57080,10 @@ function registerMigrationRoutes(app) {
       }
       const configSource = sourceParsed.value;
       const codexCommandsRequireGlobal = include.commands && selectedProviders.includes("codex") && providers.codex.commands !== null && providers.codex.commands.projectPath === null;
-      const effectiveGlobal = requestedGlobal || codexCommandsRequireGlobal;
+      const effectiveGlobal = requestedGlobal;
       const warnings = [];
       if (codexCommandsRequireGlobal && !requestedGlobal) {
-        warnings.push("Codex commands are global-only; scope was automatically switched to global.");
+        warnings.push("Codex commands are global-only; they will be installed globally while other content stays project-local.");
       }
       const discovered = await discoverMigrationItems(include, configSource);
       const hasItems = discovered.agents.length > 0 || discovered.commands.length > 0 || discovered.skills.length > 0 || discovered.configItem !== null || discovered.ruleItems.length > 0 || discovered.hookItems.length > 0;
@@ -56980,7 +57106,6 @@ function registerMigrationRoutes(app) {
         });
         return;
       }
-      const installOptions = { global: effectiveGlobal };
       const results = [];
       const hookRegistrationResults = [];
       const successfulHookFiles = new Map;
@@ -56994,10 +57119,11 @@ function registerMigrationRoutes(app) {
         hooks: include.hooks ? selectedProviders.filter((provider) => !getProvidersSupporting("hooks").includes(provider)) : []
       };
       if (include.agents && discovered.agents.length > 0) {
-        const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("agents").includes(provider));
-        if (providersForType.length > 0) {
+        for (const group of groupProvidersByTypeScope(selectedProviders, "agent", requestedGlobal)) {
           const batches = await Promise.all(discovered.agents.map(async (agent) => {
-            const batch = await installPortableItems([agent], providersForType, "agent", installOptions);
+            const batch = await installPortableItems([agent], group.providers, "agent", {
+              global: group.global
+            });
             tagResults(batch, "agents", agent.name);
             return batch;
           }));
@@ -57007,10 +57133,11 @@ function registerMigrationRoutes(app) {
         }
       }
       if (include.commands && discovered.commands.length > 0) {
-        const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("commands").includes(provider));
-        if (providersForType.length > 0) {
+        for (const group of groupProvidersByTypeScope(selectedProviders, "command", requestedGlobal)) {
           const batches = await Promise.all(discovered.commands.map(async (command) => {
-            const batch = await installPortableItems([command], providersForType, "command", installOptions);
+            const batch = await installPortableItems([command], group.providers, "command", {
+              global: group.global
+            });
             tagResults(batch, "commands", command.name);
             return batch;
           }));
@@ -57020,10 +57147,11 @@ function registerMigrationRoutes(app) {
         }
       }
       if (include.skills && discovered.skills.length > 0) {
-        const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("skills").includes(provider));
-        if (providersForType.length > 0) {
+        for (const group of groupProvidersByTypeScope(selectedProviders, "skill", requestedGlobal)) {
           const batches = await Promise.all(discovered.skills.map(async (skill) => {
-            const batch = await installSkillDirectories([skill], providersForType, installOptions);
+            const batch = await installSkillDirectories([skill], group.providers, {
+              global: group.global
+            });
             tagResults(batch, "skills", skill.name);
             return batch;
           }));
@@ -57033,18 +57161,18 @@ function registerMigrationRoutes(app) {
         }
       }
       if (include.config && discovered.configItem) {
-        const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("config").includes(provider));
-        if (providersForType.length > 0) {
-          const batch = await installPortableItems([discovered.configItem], providersForType, "config", installOptions);
+        for (const group of groupProvidersByTypeScope(selectedProviders, "config", requestedGlobal)) {
+          const batch = await installPortableItems([discovered.configItem], group.providers, "config", { global: group.global });
           tagResults(batch, "config");
           results.push(...batch);
         }
       }
       if (include.rules && discovered.ruleItems.length > 0) {
-        const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("rules").includes(provider));
-        if (providersForType.length > 0) {
+        for (const group of groupProvidersByTypeScope(selectedProviders, "rules", requestedGlobal)) {
           const batches = await Promise.all(discovered.ruleItems.map(async (rule) => {
-            const batch = await installPortableItems([rule], providersForType, "rules", installOptions);
+            const batch = await installPortableItems([rule], group.providers, "rules", {
+              global: group.global
+            });
             tagResults(batch, "rules", rule.name);
             return batch;
           }));
@@ -57054,14 +57182,18 @@ function registerMigrationRoutes(app) {
         }
       }
       if (include.hooks && discovered.hookItems.length > 0) {
-        const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("hooks").includes(provider));
-        if (providersForType.length > 0) {
+        for (const group of groupProvidersByTypeScope(selectedProviders, "hooks", requestedGlobal)) {
           const batches = await Promise.all(discovered.hookItems.map(async (hook) => {
-            const batch = await installPortableItems([hook], providersForType, "hooks", installOptions);
+            const batch = await installPortableItems([hook], group.providers, "hooks", {
+              global: group.global
+            });
             tagResults(batch, "hooks", hook.name);
             for (const result of batch.filter((entry) => entry.success && !entry.skipped)) {
-              const existing = successfulHookFiles.get(result.provider) ?? [];
-              existing.push(basename12(result.path));
+              const existing = successfulHookFiles.get(result.provider) ?? {
+                files: [],
+                global: group.global
+              };
+              existing.files.push(basename12(result.path));
               successfulHookFiles.set(result.provider, existing);
               if (result.path.length > 0) {
                 const absExisting = successfulHookAbsPaths.get(result.provider) ?? [];
@@ -57076,22 +57208,25 @@ function registerMigrationRoutes(app) {
           }
         }
       }
-      for (const [provider, files] of successfulHookFiles) {
-        if (files.length === 0)
+      for (const [provider, entry] of successfulHookFiles) {
+        if (entry.files.length === 0)
           continue;
         const mergeResult = await migrateHooksSettings({
           sourceProvider: "claude-code",
           targetProvider: provider,
-          installedHookFiles: files,
+          installedHookFiles: entry.files,
           installedHookAbsolutePaths: successfulHookAbsPaths.get(provider),
-          global: effectiveGlobal
+          global: entry.global
         });
         recordHookRegistrationOutcome(provider, mergeResult, warnings, hookRegistrationResults);
       }
       const responseResults = [...results, ...hookRegistrationResults];
       const sortedResults = sortPortableInstallResults(responseResults);
       const counts = toExecutionCounts(sortedResults);
-      const providerCollisions = detectProviderPathCollisions(selectedProviders, installOptions);
+      const providerScopes = [
+        ...new Set(buildScopedProviderConfigs(selectedProviders, include, requestedGlobal).map((p) => p.global))
+      ];
+      const providerCollisions = dedupeProviderPathCollisions(providerScopes.flatMap((scope) => detectProviderPathCollisions(selectedProviders, { global: scope })));
       annotateResultsWithCollisions(sortedResults, providerCollisions);
       res.status(200).json({
         results: sortedResults,
@@ -57114,6 +57249,7 @@ var MIGRATION_TYPES, MAX_PROVIDER_COUNT = 20, MAX_PLAN_ACTIONS = 5000, ALLOWED_C
 var init_migration_routes = __esm(() => {
   init_agents_discovery();
   init_commands_discovery();
+  init_migrate_provider_scopes();
   init_skill_directory_installer();
   init_codex_toml_installer();
   init_config_discovery();
@@ -62253,7 +62389,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.42.2-dev.4",
+    version: "3.42.2-dev.6",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -104752,24 +104888,63 @@ import { mkdir as mkdir34 } from "node:fs/promises";
 import { join as join135, resolve as resolve38 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
+init_error2();
 init_logger();
 init_safe_spinner();
 init_types3();
+init_types3();
 init_github_client();
+function toGitHubError(error) {
+  if (error instanceof GitHubError) {
+    return error;
+  }
+  const classified = classifyGitHubError(error, "check repository access");
+  const actions = suggestActions(classified.category);
+  const formattedActions = formatActions(actions);
+  const messageParts = [classified.message];
+  if (classified.details) {
+    messageParts.push(`
+${classified.details}`);
+  }
+  if (formattedActions) {
+    messageParts.push(`
+Solutions:${formattedActions}`);
+  }
+  messageParts.push(`
+Need help? Run with: ck new --verbose`);
+  return new GitHubError(messageParts.join(`
+`), classified.httpStatus);
+}
 async function detectAccessibleKits() {
   const spinner = createSpinner("Checking kit access...").start();
   const github = new GitHubClient;
-  const results = await Promise.all(Object.entries(AVAILABLE_KITS).map(async ([type, config]) => {
-    try {
-      await github.checkAccess(config);
-      logger.debug(`Access confirmed: ${type}`);
-      return type;
-    } catch {
-      logger.debug(`No access to ${type}`);
-      return null;
-    }
+  const settled = await Promise.allSettled(Object.entries(AVAILABLE_KITS).map(async ([type, config]) => {
+    await github.checkAccess(config);
+    logger.debug(`Access confirmed: ${type}`);
+    return type;
   }));
-  const accessible = results.filter((kit) => kit !== null);
+  const accessible = [];
+  const fatalErrors = [];
+  for (const result of settled) {
+    if (result.status === "fulfilled") {
+      accessible.push(result.value);
+    } else {
+      const err = result.reason;
+      const status = err?.statusCode ?? err?.status;
+      if (status === 404) {
+        logger.debug("No access to kit (404)");
+      } else {
+        fatalErrors.push(toGitHubError(err));
+      }
+    }
+  }
+  if (fatalErrors.length > 0) {
+    spinner.fail("Kit access check failed");
+    for (const extra of fatalErrors.slice(1)) {
+      logger.debug(`Additional kit access error (suppressed): ${extra.message}`);
+    }
+    throw fatalErrors[0];
+  }
   if (accessible.length === 0) {
     spinner.fail("No kit access found");
   } else {
@@ -107521,6 +107696,9 @@ function createTtyProgressSink(total, context) {
   };
 }
 
+// src/commands/migrate/migrate-command.ts
+init_migrate_provider_scopes();
+
 // src/commands/migrate/migrate-scope-resolver.ts
 function resolveMigrationScope(argv, options2) {
   const argSet = new Set(argv);
@@ -107566,6 +107744,7 @@ function resolveMigrationScope(argv, options2) {
 
 // src/commands/migrate/migrate-ui-summary.ts
 init_provider_registry();
+init_migrate_provider_scopes();
 var PORTABLE_TYPES = [
   { key: "agents", label: "Agents" },
   { key: "commands", label: "Commands" },
@@ -107588,9 +107767,10 @@ function buildPreflightRows(counts, selectedProviders, options2) {
         notes.add(`${providers[provider].displayName}: unsupported`);
         continue;
       }
-      const destination = getPortableBasePath(provider, key, { global: options2.actualGlobal });
+      const actualGlobal = resolvePortableGroupGlobal(provider, key, options2.requestedGlobal);
+      const destination = getPortableBasePath(provider, key, { global: actualGlobal });
       if (!destination) {
-        const note2 = options2.actualGlobal ? "project-only" : "global-only";
+        const note2 = actualGlobal ? "project-only" : "global-only";
         notes.add(`${providers[provider].displayName}: ${note2}`);
         continue;
       }
@@ -107634,8 +107814,17 @@ function buildTargetSummaryLines(rows) {
   }
   return [...allDestinations.slice(0, 3), `+${allDestinations.length - 3} more destination(s)`];
 }
-function buildProviderScopeSubtitle(selectedProviders, global3) {
-  const scope = global3 ? "global" : "project";
+function buildProviderScopeSubtitle(selectedProviders, requestedGlobal, counts) {
+  const activeTypes = PORTABLE_TYPES.filter(({ key }) => !counts || counts[key] > 0);
+  const resolvedScopes = new Set;
+  for (const provider of selectedProviders) {
+    for (const { key } of activeTypes) {
+      if (!providers[provider][key])
+        continue;
+      resolvedScopes.add(resolvePortableGroupGlobal(provider, key, requestedGlobal));
+    }
+  }
+  const scope = resolvedScopes.size > 1 ? "mixed" : resolvedScopes.values().next().value ?? requestedGlobal ? "global" : "project";
   if (selectedProviders.length === 1) {
     return `${providers[selectedProviders[0]].displayName} -> ${scope}`;
   }
@@ -108055,8 +108244,7 @@ async function migrateCommand(options2) {
     }
     const codexCommandsRequireGlobal = scope.commands && selectedProviders.includes("codex") && providers.codex.commands !== null && providers.codex.commands.projectPath === null;
     if (codexCommandsRequireGlobal && !installGlobally) {
-      installGlobally = true;
-      f2.info(import_picocolors30.default.dim("Codex commands are global-only; scope adjusted to global."));
+      f2.info(import_picocolors30.default.dim("Codex commands are global-only; they will be installed globally while other content stays project-local."));
     }
     const sourceCounts = {
       agents: agents2.length,
@@ -108075,7 +108263,6 @@ async function migrateCommand(options2) {
       hooksSource
     ].filter((origin) => origin !== null);
     const preflightRows = buildPreflightRows(sourceCounts, selectedProviders, {
-      actualGlobal: installGlobally,
       requestedGlobal
     });
     const discoveryParts = [];
@@ -108105,7 +108292,7 @@ async function migrateCommand(options2) {
     console.log();
     console.log(renderSourceTargetHeader({
       sourceLines: buildSourceSummaryLines(sourceCounts, sourceOrigins),
-      subtitle: buildProviderScopeSubtitle(selectedProviders, installGlobally),
+      subtitle: buildProviderScopeSubtitle(selectedProviders, requestedGlobal, sourceCounts),
       targetLines: buildTargetSummaryLines(preflightRows),
       title: "ck migrate"
     }).join(`
@@ -108163,13 +108350,14 @@ async function migrateCommand(options2) {
       rules: effectiveRuleItems,
       hooks: effectiveHookItems
     }, selectedProviders);
-    const targetStates = await computeTargetStates(selectedProviders, installGlobally);
-    const providerConfigs = selectedProviders.map((provider) => ({
-      provider,
-      global: installGlobally
-    }));
-    const portableTypes = ["agent", "command", "config", "rules", "hooks"];
-    const typeDirectoryStates = buildTypeDirectoryStates(selectedProviders.map((provider) => ({ provider, global: installGlobally })), [...portableTypes]);
+    const providerConfigs = buildScopedProviderConfigs(selectedProviders, scope, installGlobally);
+    const targetStates = await computeTargetStates(providerConfigs);
+    const portableTypes = getEnabledPortableTypes(scope).filter((type) => type !== "skill");
+    const typeDirectoryStates = buildTypeDirectoryStates(providerConfigs.map((config) => ({
+      provider: config.provider,
+      global: config.global,
+      types: config.types?.filter((type) => type !== "skill")
+    })), portableTypes);
     const reinstallEmptyDirs = options2.respectDeletions ? false : options2.reinstallEmptyDirs ?? true;
     const plan = reconcile({
       sourceItems: sourceStates,
@@ -108232,7 +108420,6 @@ async function migrateCommand(options2) {
       }
     }
     let allResults = [];
-    const installOpts = { global: installGlobally };
     const agentByName = new Map(effectiveAgents.map((item) => [item.name, item]));
     const commandByName = new Map(effectiveCommands.map((item) => [item.name, item]));
     const skillByName = new Map(effectiveSkills.map((item) => [item.name, item]));
@@ -108251,42 +108438,42 @@ async function migrateCommand(options2) {
         const item = agentByName.get(action.item);
         if (!item || !getProvidersSupporting("agents").includes(provider))
           continue;
-        writeTasks.push({ item, provider, type: "agent" });
+        writeTasks.push({ item, provider, type: "agent", global: action.global });
         continue;
       }
       if (action.type === "command") {
         const item = commandByName.get(action.item);
         if (!item || !getProvidersSupporting("commands").includes(provider))
           continue;
-        writeTasks.push({ item, provider, type: "command" });
+        writeTasks.push({ item, provider, type: "command", global: action.global });
         continue;
       }
       if (action.type === "skill") {
         const item = skillByName.get(action.item);
         if (!item || !getProvidersSupporting("skills").includes(provider))
           continue;
-        writeTasks.push({ item, provider, type: "skill" });
+        writeTasks.push({ item, provider, type: "skill", global: action.global });
         continue;
       }
       if (action.type === "config") {
         const item = configByName.get(action.item);
         if (!item || !getProvidersSupporting("config").includes(provider))
           continue;
-        writeTasks.push({ item, provider, type: "config" });
+        writeTasks.push({ item, provider, type: "config", global: action.global });
         continue;
       }
       if (action.type === "rules") {
         const item = ruleByName.get(action.item);
         if (!item || !getProvidersSupporting("rules").includes(provider))
           continue;
-        writeTasks.push({ item, provider, type: "rules" });
+        writeTasks.push({ item, provider, type: "rules", global: action.global });
         continue;
       }
       if (action.type === "hooks") {
         const item = hookByName.get(action.item);
         if (!item || !getProvidersSupporting("hooks").includes(provider))
           continue;
-        writeTasks.push({ item, provider, type: "hooks" });
+        writeTasks.push({ item, provider, type: "hooks", global: action.global });
       }
     }
     const plannedSkillActions = plannedExecActions.filter((action) => action.type === "skill").length;
@@ -108294,22 +108481,31 @@ async function migrateCommand(options2) {
       const skillProviders = selectedProviders.filter((pv) => getProvidersSupporting("skills").includes(pv));
       for (const provider of skillProviders) {
         for (const skill of effectiveSkills) {
-          writeTasks.push({ item: skill, provider, type: "skill" });
+          writeTasks.push({
+            item: skill,
+            provider,
+            type: "skill",
+            global: resolvePortableTypeGlobal(provider, "skill", installGlobally)
+          });
         }
       }
     }
     const progressSink = createMigrateProgressSink(writeTasks.length + plannedDeleteActions.length);
     const writtenPaths = new Set;
     for (const task of writeTasks) {
-      const taskResults = task.type === "skill" ? annotateInstallResults(await installSkillDirectories([task.item], [task.provider], installOpts), "skill", task.item.name) : annotateInstallResults(await installPortableItems([task.item], [task.provider], task.type, installOpts), task.type, task.item.name);
+      const taskInstallOpts = { global: task.global };
+      const taskResults = task.type === "skill" ? annotateInstallResults(await installSkillDirectories([task.item], [task.provider], taskInstallOpts), "skill", task.item.name) : annotateInstallResults(await installPortableItems([task.item], [task.provider], task.type, taskInstallOpts), task.type, task.item.name);
       allResults.push(...taskResults);
       for (const result of taskResults.filter((entry) => entry.success && !entry.skipped)) {
         if (result.path.length > 0) {
           writtenPaths.add(resolve41(result.path));
         }
         if (task.type === "hooks") {
-          const existing = successfulHookFiles.get(task.provider) ?? [];
-          existing.push(basename27(result.path));
+          const existing = successfulHookFiles.get(task.provider) ?? {
+            files: [],
+            global: task.global
+          };
+          existing.files.push(basename27(result.path));
           successfulHookFiles.set(task.provider, existing);
           if (result.path.length > 0) {
             const absExisting = successfulHookAbsPaths.get(task.provider) ?? [];
@@ -108337,9 +108533,9 @@ async function migrateCommand(options2) {
       }
     }
     if (hooksSource && successfulHookFiles.size > 0) {
-      for (const hooksProvider of successfulHookFiles.keys()) {
+      for (const [hooksProvider, entry] of successfulHookFiles) {
         const providerCfg = providers[hooksProvider];
-        const targetHooksDir = installGlobally ? providerCfg.hooks?.globalPath : providerCfg.hooks?.projectPath;
+        const targetHooksDir = entry.global ? providerCfg.hooks?.globalPath : providerCfg.hooks?.projectPath;
         if (!targetHooksDir)
           continue;
         const companionResult = await copyHooksCompanionDirs(hooksSource, targetHooksDir);
@@ -108361,15 +108557,15 @@ async function migrateCommand(options2) {
         }
       }
     }
-    for (const [hooksProvider, files] of successfulHookFiles) {
-      if (files.length === 0)
+    for (const [hooksProvider, entry] of successfulHookFiles) {
+      if (entry.files.length === 0)
         continue;
       const mergeResult = await migrateHooksSettings({
         sourceProvider: "claude-code",
         targetProvider: hooksProvider,
-        installedHookFiles: files,
+        installedHookFiles: entry.files,
         installedHookAbsolutePaths: successfulHookAbsPaths.get(hooksProvider),
-        global: installGlobally
+        global: entry.global
       });
       if (mergeResult.success && mergeResult.hooksRegistered > 0) {
         logger.verbose(`Registered ${mergeResult.hooksRegistered} hook(s) in ${hooksProvider} settings.json`);
@@ -108400,15 +108596,22 @@ async function migrateCommand(options2) {
       const providerConfig = providers[provider];
       if (providerConfig.agents?.writeStrategy !== "codex-toml")
         continue;
-      const staleSlugs = await cleanupStaleCodexConfigEntries({
-        global: installGlobally,
-        provider
-      });
-      if (staleSlugs.length > 0) {
-        const staleSlugSet = new Set(staleSlugs.map((s) => `${s}.toml`));
-        const removed = await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === installGlobally && staleSlugSet.has(basename27(i.path)));
-        for (const entry of removed) {
-          logger.verbose(`[migrate] Cleaned stale registry entry: ${entry.item} (${provider})`);
+      const providerScopes = [
+        ...new Set(plan.actions.filter((action) => action.provider === provider).map((action) => action.global))
+      ];
+      if (providerScopes.length === 0)
+        providerScopes.push(installGlobally);
+      for (const scope2 of providerScopes) {
+        const staleSlugs = await cleanupStaleCodexConfigEntries({
+          global: scope2,
+          provider
+        });
+        if (staleSlugs.length > 0) {
+          const staleSlugSet = new Set(staleSlugs.map((s) => `${s}.toml`));
+          const removed = await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === scope2 && staleSlugSet.has(basename27(i.path)));
+          for (const entry of removed) {
+            logger.verbose(`[migrate] Cleaned stale registry entry: ${entry.item} (${provider})`);
+          }
         }
       }
     }
@@ -108498,12 +108701,11 @@ async function computeSourceStates(items, selectedProviders) {
   processItems(items.hooks, "hooks");
   return states;
 }
-async function computeTargetStates(selectedProviders, global3) {
+async function computeTargetStates(providerConfigs) {
   const registry = await readPortableRegistry();
   const relevantEntries = registry.installations.filter((entry) => {
-    if (!selectedProviders.includes(entry.provider))
-      return false;
-    if (entry.global !== global3)
+    const matchingConfig = providerConfigs.some((config) => config.provider === entry.provider && config.global === entry.global && providerConfigAppliesToType(config, entry.type));
+    if (!matchingConfig)
       return false;
     return entry.type !== "skill";
   });
@@ -108583,7 +108785,9 @@ function buildDryRunFallbackResults(skills, selectedProviders, installGlobally,
   }
   const results = [];
   for (const provider of selectedProviders.filter((entry) => getProvidersSupporting("skills").includes(entry))) {
-    const basePath = getPortableBasePath(provider, "skills", { global: installGlobally });
+    const basePath = getPortableBasePath(provider, "skills", {
+      global: resolvePortableTypeGlobal(provider, "skill", installGlobally)
+    });
     if (!basePath)
       continue;
     for (const skill of skills) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "3.42.2-dev.4",
+	"version": "3.42.2-dev.6",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {