agents-inc 0.170.1 → 0.170.2

package/dist/commands/doctor.js

@@ -1,51 +1,45 @@
 #!/usr/bin/env node
-import {
-  unofferablePlacementsFound
-} from "../chunk-WTWMGH2C.js";
-import {
-  detectProject,
-  loadSource
-} from "../chunk-7RDMTR64.js";
-import "../chunk-F2BHT5C4.js";
-import "../chunk-HED2DAXZ.js";
-import "../chunk-3G7X2WKI.js";
+import "../chunk-5BNX73OU.js";
 import {
   filterExcludedEntries,
   listAgentFilesOf,
   listAgentMdFiles,
   splitAgentsByProvenance
-} from "../chunk-BMRUNMPV.js";
+} from "../chunk-2YA4DDRM.js";
 import {
   ambiguityFinding
-} from "../chunk-RIPSGNLU.js";
+} from "../chunk-OCAVW6N5.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-V3KTSP3Q.js";
-import "../chunk-CLPUWOSA.js";
+} from "../chunk-GEMW5RQ2.js";
 import {
   ConfigDefaultExportError,
+  ConfigLoadError,
   MarketplaceManifestRequiredError,
   MarketplaceNameRefusedError,
+  MarketplaceRefusedError,
   SOURCE_ENV_VAR,
   agentCodec,
   agentYamlGenerationSchema,
+  agentsDir,
   configDirsInPlay,
   declaresNoContent,
+  detectInstallations,
   directoryExists,
-  discoverLocalSkills,
   fileExists,
   findConfigLoadFailures,
   formatZodErrors,
   getErrorMessage,
   getInstalledConfigPath,
   getInstalledPluginsRegistryPath,
+  getPluginManifestPath,
   getProjectPluginsDir,
   getStackSkillIds,
   getUserPluginsDir,
-  getVerifiedPluginInstallPaths,
   glob,
   hostCompilesAgent,
+  hostFor,
   installBaseDir,
   invalidResult,
   isHomeDirectory,
@@ -53,9 +47,11 @@ import {
   isRecord,
   layoutIsCurrent,
   listDirectories,
+  listPluginDirNames,
   listRegisteredPluginInstalls,
   loadConfig,
   loadInstalledConfig,
+  loadProjectConfigFromDir,
   loadSkillsMatrixFromSource,
   loadSourceRepoConfig,
   matrixHealthIssues,
@@ -63,17 +59,19 @@ import {
   metadataValidationSchema,
   parseFrontmatter,
   parseMarketplacePluginRef,
-  plural,
+  providerArgument,
   providerInUse,
   readFile,
   readForkedFromMetadata,
   readSkillMetadata,
   recreateConfigFrom,
+  refuseUnofferedPlacements,
   relativeConfigPath,
   resolveInstallPaths,
   resolvePrimarySourceEntry,
   scopeLabel,
   scopeNoun,
+  scopeRootsInPlay,
   skillCategoriesFileSchema,
   skillRulesFileSchema,
   skillsDir,
@@ -82,17 +80,20 @@ import {
   splitMetadataValidationIssues,
   stackConfigValidationSchema,
   stacksConfigSchema,
+  typedValues,
   validResult,
   validateAgentFrontmatter,
   validateAllPlugins,
   validatePlugin,
   validateProjectConfig,
   validateSkillFrontmatter,
-  validateSkillMetadata
-} from "../chunk-MQ6CGZNJ.js";
+  validateSkillMetadata,
+  verbose
+} from "../chunk-GAKVZNTX.js";
 import {
-  matrix
-} from "../chunk-52HDHJ7I.js";
+  matrix,
+  plural
+} from "../chunk-AUNRHWH4.js";
 import {
   CLI_INVOKE_COMMAND,
   DEFAULT_BRANDING,
@@ -107,12 +108,106 @@ import {
   STANDARD_FILES,
   UI_SYMBOLS,
   effectivelyExcludedSkillIds
-} from "../chunk-PJWGTNOX.js";
-import "../chunk-NQW25DCF.js";
+} from "../chunk-7C3PFRBU.js";
+import "../chunk-GHHJYNAN.js";
 
 // src/cli/commands/doctor.ts
-import os2 from "os";
+import os3 from "os";
+import path4 from "path";
+
+// src/cli/lib/doctor/installation-reads.ts
+import os from "os";
+function hostsOnDisk(projectDir) {
+  return { project: providerInUse(projectDir), global: providerInUse(os.homedir()) };
+}
+function hostsOf(provider) {
+  return { project: provider, global: provider };
+}
+async function providersInPlay(projectDir) {
+  const found = await detectInstallations(projectDir);
+  const inTheProject = found.filter((installation) => installation.scope === "project");
+  const inPlay = inTheProject.length > 0 ? inTheProject : found;
+  return inPlay.map((installation) => installation.provider);
+}
+async function resolveConfigState({
+  projectDir,
+  hosts
+}) {
+  try {
+    return await readConfigState(projectDir, hosts);
+  } catch (error) {
+    if (error instanceof ConfigLoadError) return { kind: "unreadable", failure: error };
+    throw error;
+  }
+}
+async function readConfigState(projectDir, hosts) {
+  const own = await loadProjectConfigFromDir(projectDir, hosts.project);
+  if (own && !declaresNoContent(own.config)) {
+    return { kind: "loaded", config: own.config, inherited: false };
+  }
+  const inherited = isHomeDirectory(projectDir) ? null : await loadProjectConfigFromDir(os.homedir(), hosts.global);
+  if (inherited && !declaresNoContent(inherited.config)) {
+    return { kind: "loaded", config: inherited.config, inherited: true };
+  }
+  return own ? { kind: "declares-nothing", config: own.config } : { kind: "absent" };
+}
+async function installedPluginSkillIds(baseDir, provider) {
+  const plugins = await verifiedPlugins(baseDir, provider);
+  return new Set(plugins.map((plugin) => parseMarketplacePluginRef(plugin.pluginKey)));
+}
+async function verifiedPlugins(baseDir, provider) {
+  const enabled = (await pluginsListedBy(provider, baseDir)).filter((plugin) => plugin.enabled);
+  const onDisk = await Promise.all(
+    enabled.map((plugin) => fileExists(getPluginManifestPath(plugin.installPath)))
+  );
+  return enabled.filter((_, index) => onDisk[index] === true);
+}
+async function pluginsListedBy(provider, baseDir) {
+  try {
+    return await hostFor(provider).listPlugins(baseDir);
+  } catch (error) {
+    verbose(`Failed to list installed plugins: ${getErrorMessage(error)}`);
+    return [];
+  }
+}
+async function unofferablePlacements({
+  projectDir,
+  hosts
+}) {
+  const projectFirst = [...scopeRootsInPlay(projectDir)].reverse();
+  const findings = await Promise.all(
+    projectFirst.map(({ kind, root }) => unofferablePlacementIn(root, hosts[kind]))
+  );
+  return findings.filter((finding) => finding !== null);
+}
+async function unofferablePlacementIn(root, provider) {
+  const skills = await configuredSkillsAt(root, provider);
+  if (skills === null) return null;
+  try {
+    refuseUnofferedPlacements(skills, hostFor(provider));
+    return null;
+  } catch (error) {
+    return getErrorMessage(error);
+  }
+}
+async function configuredSkillsAt(root, provider) {
+  try {
+    const loaded = await loadProjectConfigFromDir(root, provider);
+    return loaded?.config.skills ?? null;
+  } catch (error) {
+    if (error instanceof ConfigLoadError) return null;
+    throw error;
+  }
+}
+
+// src/cli/lib/doctor/ownership.ts
 import path3 from "path";
+import { groupBy } from "remeda";
+
+// src/cli/lib/content-validator.ts
+import os2 from "os";
+import path2 from "path";
+import { partition } from "remeda";
 
 // src/cli/lib/source-validator.ts
 import path from "path";
@@ -199,12 +294,7 @@ async function validateSource(sourcePath, reader = "author") {
       0
     );
   }
-  const skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir2);
-  const metadataFiles = await glob(`**/${STANDARD_FILES.METADATA_YAML}`, skillsDir2);
-  const skillMdDirs = new Set(skillMdFiles.map((f) => path.dirname(f)));
-  const metadataDirs = new Set(metadataFiles.map((f) => path.dirname(f)));
-  const pairIssues = validateSkillFilePairs(skillMdDirs, metadataDirs, skillsDir2);
-  const validMetadataFiles = metadataFiles.filter((f) => skillMdDirs.has(path.dirname(f)));
+  const { pairIssues, validMetadataFiles } = await pairSkillFiles(skillsDir2);
   const skillIssues = await validateSkillsInTurn(skillsDir2, skillsDirRelPath, validMetadataFiles);
   const crossReferenceIssues = await checkCrossReferences(resolvedPath, reader);
   const extraIssues = await Promise.all([
@@ -217,6 +307,16 @@ async function validateSource(sourcePath, reader = "author") {
     validMetadataFiles.length
   );
 }
+async function pairSkillFiles(skillsDir2) {
+  const skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir2);
+  const metadataFiles = await glob(`**/${STANDARD_FILES.METADATA_YAML}`, skillsDir2);
+  const skillMdDirs = new Set(skillMdFiles.map((f) => path.dirname(f)));
+  const metadataDirs = new Set(metadataFiles.map((f) => path.dirname(f)));
+  return {
+    pairIssues: validateSkillFilePairs(skillMdDirs, metadataDirs, skillsDir2),
+    validMetadataFiles: metadataFiles.filter((f) => skillMdDirs.has(path.dirname(f)))
+  };
+}
 async function validateSkillsInTurn(skillsDir2, skillsDirRelPath, metadataFiles) {
   const issues = [];
   for (const metadataFile of metadataFiles) {
@@ -343,10 +443,10 @@ async function validateStacks(resolvedPath) {
   return [...skillMetaIssues, ...configIssues];
 }
 async function validateAgents(resolvedPath) {
-  const agentsDir = path.join(resolvedPath, DIRS.agents);
-  if (!await directoryExists(agentsDir)) return [];
+  const agentsDir2 = path.join(resolvedPath, DIRS.agents);
+  if (!await directoryExists(agentsDir2)) return [];
   return validateYamlFiles({
-    baseDir: agentsDir,
+    baseDir: agentsDir2,
     relBaseDir: DIRS.agents,
     pattern: `**/${STANDARD_FILES.AGENT_METADATA_YAML}`,
     schema: agentYamlGenerationSchema
@@ -414,11 +514,7 @@ function buildResult(issues, skillCount) {
 }
 
 // src/cli/lib/content-validator.ts
-import os from "os";
-import path2 from "path";
-import { partition } from "remeda";
 var CWD_SOURCE_NAME = "current directory";
-var AGENT_FILE_EXTENSION = ".md";
 var NOTHING_VALIDATED = { count: 0, issues: [], notes: [] };
 function mergeValidations(parts) {
   return parts.reduce(
@@ -431,7 +527,7 @@ function mergeValidations(parts) {
   );
 }
 function displayDir(absolutePath) {
-  const home = os.homedir();
+  const home = os2.homedir();
   if (absolutePath === home) return "~";
   if (absolutePath.startsWith(home + path2.sep)) {
     return `~${path2.sep}${path2.relative(home, absolutePath)}`;
@@ -519,7 +615,7 @@ async function validatePluginsDirectory(pluginsDir) {
     const registryValidation = await validateRegistryPlugins(pluginsDir);
     if (registryValidation !== void 0) return registryValidation;
   }
-  const pluginDirs = await findPluginDirectories(pluginsDir);
+  const pluginDirs = await listPluginDirNames(pluginsDir);
   if (pluginDirs.length === 0) return NOTHING_VALIDATED;
   const { results } = await validateAllPlugins(pluginsDir);
   return {
@@ -553,16 +649,6 @@ async function validateRegistryPlugins(pluginsDir) {
   );
   return { count: installs.length, issues: results.flat(), notes: [] };
 }
-async function findPluginDirectories(pluginsDir) {
-  const entries = await listDirectories(pluginsDir);
-  const checks = await Promise.all(
-    entries.map(async (name) => ({
-      name,
-      isPlugin: await directoryExists(path2.join(pluginsDir, name, PLUGIN_MANIFEST_DIR))
-    }))
-  );
-  return checks.filter((check) => check.isPlugin).map((check) => check.name);
-}
 async function validateInstalledSkills(projectDir) {
   const configuredIds = await configuredSkillIds(projectDir);
   return mergeValidations(
@@ -593,27 +679,26 @@ function installedDirs(projectDir, key) {
   if (isHomeDirectory(projectDir)) return [global];
   return [global, resolveInstallPaths(projectDir, "project")[key]];
 }
-async function listInstalledArtifacts(projectDir) {
-  const [skills, agents] = await Promise.all([
-    listAcrossScopes(installedDirs(projectDir, "skillsDir"), listSkillDirsWithOurProvenance),
-    listAcrossScopes(installedDirs(projectDir, "agentsDir"), listAgentFilesWithOurProvenance)
-  ]);
-  return { skills, agents };
+async function skillDirsWithOurProvenanceIn(skillsDir2) {
+  return listDisplayPaths(skillsDir2, listSkillDirsWithOurProvenance);
+}
+async function agentFilesWithOurProvenanceIn(agentsDir2, codec) {
+  return listDisplayPaths(agentsDir2, (dir) => listAgentFilesWithOurProvenance(dir, codec));
 }
-async function listAgentFilesWithOurProvenance(agentsDir) {
-  const { marked } = await splitAgentsByProvenance(agentsDir);
-  return marked.map((name) => `${name}${AGENT_FILE_EXTENSION}`);
+async function listAgentFilesWithOurProvenance(agentsDir2, codec) {
+  const { marked } = await splitAgentsByProvenance(agentsDir2, codec);
+  return marked.map((name) => `${name}${codec.extension}`);
 }
 async function listSkillDirsWithOurProvenance(skillsDir2) {
-  const names = await listDirectories(skillsDir2);
-  const judged = await Promise.all(
-    names.map(async (name) => ({ name, ours: await carriesOurProvenance(skillsDir2, name) }))
+  const [ours] = await partitionByVerdict(
+    await listDirectories(skillsDir2),
+    (name) => carriesOurProvenance(skillsDir2, name)
   );
-  return judged.filter((entry) => entry.ours).map((entry) => entry.name);
+  return ours;
 }
-async function listAcrossScopes(dirs, listEntries) {
-  const perDir = await Promise.all(dirs.map((dir) => listDisplayPaths(dir, listEntries)));
-  return perDir.flat();
+async function partitionByVerdict(names, verdict) {
+  const verdicts = await Promise.all(names.map(verdict));
+  return partition(names, (_, index) => verdicts[index] === true);
 }
 async function listDisplayPaths(dir, listEntries) {
   if (!await directoryExists(dir)) return [];
@@ -624,15 +709,12 @@ async function validateSkillsDirectory(skillsDir2, configuredIds) {
   if (!await directoryExists(skillsDir2)) return NOTHING_VALIDATED;
   const skillDirs = await listDirectories(skillsDir2);
   if (skillDirs.length === 0) return NOTHING_VALIDATED;
-  const judged = await Promise.all(
-    skillDirs.map(async (name) => ({
-      name,
-      ours: await isOurSkillDirectory(skillsDir2, name, configuredIds)
-    }))
+  const [ours, foreign] = await partitionByVerdict(
+    skillDirs,
+    (name) => isOurSkillDirectory(skillsDir2, name, configuredIds)
   );
-  const [ours, foreign] = partition(judged, (entry) => entry.ours);
   const results = await Promise.all(
-    ours.map(async ({ name }) => {
+    ours.map(async (name) => {
       const skillDir = path2.join(skillsDir2, name);
       return toIssues(displayDir(skillDir), await validateInstalledSkill(skillDir));
     })
@@ -640,7 +722,7 @@ async function validateSkillsDirectory(skillsDir2, configuredIds) {
   return {
     count: ours.length,
     issues: results.flat(),
-    notes: foreign.map(({ name }) => foreignSkillNote(skillsDir2, name))
+    notes: foreign.map((name) => foreignSkillNote(skillsDir2, name))
   };
 }
 async function isOurSkillDirectory(skillsDir2, name, configuredIds) {
@@ -653,29 +735,23 @@ async function carriesOurProvenance(skillsDir2, name) {
 function foreignSkillNote(skillsDir2, name) {
   return `${displayDir(path2.join(skillsDir2, name))} \u2014 not installed by this CLI and named by no configuration here: not validated`;
 }
-async function validateAgentsDirectory(agentsDir) {
-  if (!await directoryExists(agentsDir)) return NOTHING_VALIDATED;
-  const agentFiles = await listAgentMdFiles(agentsDir);
+async function validateAgentsDirectory(agentsDir2) {
+  if (!await directoryExists(agentsDir2)) return NOTHING_VALIDATED;
+  const agentFiles = await listAgentMdFiles(agentsDir2);
   if (agentFiles.length === 0) return NOTHING_VALIDATED;
   const results = await Promise.all(
     agentFiles.map(async (fileName) => {
-      const agentPath = path2.join(agentsDir, fileName);
+      const agentPath = path2.join(agentsDir2, fileName);
       return toIssues(displayDir(agentPath), await validateAgentFrontmatter(agentPath));
     })
   );
   return { count: agentFiles.length, issues: results.flat(), notes: [] };
 }
 async function validateInstalledSkill(skillDir) {
-  const skillMd = await validateSkillFile(
-    skillDir,
-    STANDARD_FILES.SKILL_MD,
-    validateSkillFrontmatter
-  );
-  const metadata = await validateSkillFile(
-    skillDir,
-    STANDARD_FILES.METADATA_YAML,
-    validateInstalledSkillMetadata
-  );
+  const [skillMd, metadata] = await Promise.all([
+    validateSkillFile(skillDir, STANDARD_FILES.SKILL_MD, validateSkillFrontmatter),
+    validateSkillFile(skillDir, STANDARD_FILES.METADATA_YAML, validateInstalledSkillMetadata)
+  ]);
   return mergeValidationResults([skillMd, metadata]);
 }
 async function validateSkillFile(skillDir, fileName, validate) {
@@ -701,25 +777,100 @@ async function validateInstalledSkillMetadata(metadataPath) {
   };
 }
 
-// src/cli/commands/doctor.ts
-import { countBy, unique } from "remeda";
-async function resolveConfigState(detected, projectDir) {
-  if (detected?.config) {
-    return {
-      kind: "loaded",
-      config: detected.config,
-      inherited: inheritsTheGlobalConfig(detected.installation.projectDir, projectDir)
-    };
-  }
-  const loaded = await loadInstalledConfig(projectDir);
-  if (!loaded) return { kind: "absent" };
-  return declaresNoContent(loaded.config) ? { kind: "declares-nothing", config: loaded.config } : { kind: "loaded", config: loaded.config, inherited: false };
+// src/cli/lib/doctor/ownership.ts
+async function judgeOwnership(state, config, installation) {
+  const agentFolders = agentFoldersToJudge(state, config, installation);
+  const skillFolders = skillFoldersToJudge(state, config, installation);
+  const [unowned, orphans] = await Promise.all([
+    unownedIn(agentFolders, skillFolders),
+    orphansIn(agentFolders, skillFolders)
+  ]);
+  return { unowned, orphans };
+}
+function agentFoldersToJudge(state, config, { projectDir, hosts }) {
+  return oncePerFolder(
+    scopesToJudge(state, hosts).map((scope) => ({
+      dir: agentsDir(hosts[scope], scope, projectDir),
+      codec: agentCodec(hosts[scope]),
+      claimed: claimed(state, scope, config && agentNamesClaimedIn(config, scope))
+    }))
+  );
+}
+function skillFoldersToJudge(state, config, { projectDir, hosts }) {
+  return oncePerFolder(
+    scopesToJudge(state, hosts).map((scope) => ({
+      dir: skillsDir(hosts[scope], scope, projectDir),
+      claimed: claimed(state, scope, config && skillIdsClaimedIn(config, scope))
+    }))
+  );
 }
-function inheritsTheGlobalConfig(readFrom, projectDir) {
-  return isHomeDirectory(readFrom) && !isHomeDirectory(projectDir);
+function scopesToJudge(state, hosts) {
+  const ownConfig = state.kind !== "absent" && !inherits(state);
+  return ownConfig && hosts.global !== hosts.project ? ["project"] : ["project", "global"];
 }
-function checkConfigValid(state, projectDir) {
-  const theConfig = (verdict) => configRowMessage(state, projectDir, verdict);
+function inherits(state) {
+  return state.kind === "loaded" && state.inherited;
+}
+function claimed(state, scope, names) {
+  if (names === null || state.kind === "absent") return null;
+  if (inherits(state) && scope === "project") return null;
+  return new Set(names);
+}
+function agentNamesClaimedIn(config, scope) {
+  return config.agents.filter((agent) => claimsAt(agent, scope)).map((agent) => agent.name);
+}
+function skillIdsClaimedIn(config, scope) {
+  return config.skills.filter((skill) => claimsAt(skill, scope)).map((skill) => skill.id);
+}
+function claimsAt(entry, scope) {
+  return entry.scope === scope && (scope === "global" || !entry.excluded);
+}
+function oncePerFolder(folders) {
+  return typedValues(groupBy(folders, (folder) => folder.dir)).map(
+    (sharing) => sharing.reduce(joinClaims)
+  );
+}
+function joinClaims(into, from) {
+  if (into.claimed === null) return from;
+  if (from.claimed === null) return into;
+  return { ...into, claimed: /* @__PURE__ */ new Set([...into.claimed, ...from.claimed]) };
+}
+async function unownedIn(agentFolders, skillFolders) {
+  const [skills, agents] = await Promise.all([
+    Promise.all(
+      skillFolders.filter(isUnclaimed).map(({ dir }) => skillDirsWithOurProvenanceIn(dir))
+    ),
+    Promise.all(
+      agentFolders.filter(isUnclaimed).map(({ dir, codec }) => agentFilesWithOurProvenanceIn(dir, codec))
+    )
+  ]);
+  return { skills: skills.flat(), agents: agents.flat() };
+}
+async function orphansIn(agentFolders, skillFolders) {
+  const [skills, agents] = await Promise.all([
+    Promise.all(skillFolders.map(unclaimedSkillDirs)),
+    Promise.all(agentFolders.map(unclaimedAgentFiles))
+  ]);
+  return { skills: skills.flat(), agents: agents.flat() };
+}
+function isUnclaimed(folder) {
+  return folder.claimed === null;
+}
+async function unclaimedSkillDirs({ dir, claimed: claimed2 }) {
+  if (claimed2 === null) return [];
+  const ours = await listSkillDirsWithOurProvenance(dir);
+  return ours.filter((name) => !claimed2.has(name));
+}
+async function unclaimedAgentFiles({ dir, codec, claimed: claimed2 }) {
+  if (claimed2 === null || !await directoryExists(dir)) return [];
+  const files = await listAgentFilesOf(dir, codec);
+  return files.filter((file) => !claimed2.has(path3.basename(file, codec.extension)));
+}
+
+// src/cli/commands/doctor.ts
+import { countBy, unique } from "remeda";
+function checkConfigValid(state, installation) {
+  const theConfig = (verdict) => configRowMessage(state, installation, verdict);
   if (state.kind === "absent") {
     return {
       result: {
@@ -731,6 +882,17 @@ function checkConfigValid(state, projectDir) {
       config: null
     };
   }
+  if (state.kind === "unreadable") {
+    return {
+      result: {
+        kind: "config",
+        status: "fail",
+        message: theConfig("exists but could not be loaded"),
+        details: [state.failure.reason]
+      },
+      config: null
+    };
+  }
   if (state.kind === "declares-nothing") {
     return {
       result: {
@@ -774,30 +936,30 @@ function checkConfigValid(state, projectDir) {
     config
   };
 }
-function configRowMessage(state, projectDir, verdict) {
+function configRowMessage(state, { projectDir, hosts }, verdict) {
   if (state.kind === "loaded" && state.inherited)
-    return `${theInheritedConfig()}, which ${verdict}`;
-  return `${theOwnConfig(projectDir)} ${verdict}`;
+    return `${theInheritedConfig(hosts.global)}, which ${verdict}`;
+  if (state.kind === "unreadable") {
+    const { scopeRoot, scope } = state.failure;
+    return `${theConfigAt(scopeRoot, hosts[scope])} ${verdict}`;
+  }
+  return `${theConfigAt(projectDir, hosts.project)} ${verdict}`;
 }
-function theOwnConfig(projectDir) {
-  return `${scopeLabel(scopeOf(projectDir))}: ${configNamedFrom(projectDir)}`;
+function theConfigAt(root, provider) {
+  return `${scopeLabel(scopeOf(root))}: ${configNamedFrom(root, provider)}`;
 }
-function theInheritedConfig() {
-  return `${scopeLabel("project")}: no ${STANDARD_FILES.CONFIG_TS}, using ${scopeNoun("global")}'s (${configNamedFrom(os2.homedir())})`;
+function theInheritedConfig(provider) {
+  return `${scopeLabel("project")}: no ${STANDARD_FILES.CONFIG_TS}, using ${scopeNoun("global")}'s (${configNamedFrom(os3.homedir(), provider)})`;
 }
 function scopeOf(dir) {
   return isHomeDirectory(dir) ? "global" : "project";
 }
-function configNamedFrom(root) {
-  const relPath = relativeConfigPath(root, providerInUse(root));
+function configNamedFrom(root, provider) {
+  const relPath = relativeConfigPath(root, provider);
   return isHomeDirectory(root) ? `~/${relPath}` : relPath;
 }
-async function checkSkillsResolved(config, matrix2, projectDir) {
-  const excludedIds = effectivelyExcludedSkillIds(config.skills);
-  const stackIds = config.stack ? getStackSkillIds(config.stack) : [];
-  const uniqueSkills = unique([...stackIds, ...config.skills.map((s) => s.id)]).filter(
-    (id) => !excludedIds.has(id)
-  );
+function checkSkillsResolved(config, matrix2) {
+  const uniqueSkills = skillIdsToResolve(config);
   if (uniqueSkills.length === 0) {
     return {
       kind: "skills",
@@ -805,17 +967,7 @@ async function checkSkillsResolved(config, matrix2, projectDir) {
       message: "No skills configured"
     };
   }
-  const [localResult, globalResult] = await Promise.all([
-    discoverLocalSkills(projectDir),
-    !isHomeDirectory(projectDir) ? discoverLocalSkills(os2.homedir()) : null
-  ]);
-  const localSkillIds = /* @__PURE__ */ new Set([
-    ...localResult?.skills.map((s) => s.id) ?? [],
-    ...globalResult?.skills.map((s) => s.id) ?? []
-  ]);
-  const missingSkills = uniqueSkills.filter(
-    (skillId) => !(skillId in matrix2.skills) && !localSkillIds.has(skillId)
-  );
+  const missingSkills = uniqueSkills.filter((skillId) => !(skillId in matrix2.skills));
   if (missingSkills.length > 0) {
     return {
       kind: "skills",
@@ -830,29 +982,27 @@ async function checkSkillsResolved(config, matrix2, projectDir) {
     message: `${ratio(uniqueSkills.length, uniqueSkills.length, "skill")} found`
   };
 }
-async function checkAgentsCompiled(config, projectDir) {
-  const agents = config.agents;
-  if (agents.length === 0) {
+function skillIdsToResolve(config) {
+  const excludedIds = effectivelyExcludedSkillIds(config.skills);
+  const stackIds = config.stack ? getStackSkillIds(config.stack) : [];
+  return unique([...stackIds, ...config.skills.map((s) => s.id)]).filter(
+    (id) => !excludedIds.has(id)
+  );
+}
+async function checkAgentsCompiled(config, installation) {
+  if (config.agents.length === 0) {
     return {
       kind: "agents",
       status: "pass",
       message: "No agents configured"
     };
   }
-  const hosts = {
-    global: providerInUse(installBaseDir(projectDir, "global")),
-    project: providerInUse(installBaseDir(projectDir, "project"))
-  };
-  const dirs = {
-    global: resolveInstallPaths(projectDir, "global").agentsDir,
-    project: resolveInstallPaths(projectDir, "project").agentsDir
-  };
   const agentChecks = await Promise.all(
-    agents.map((agent) => agentCompileCheck(agent, hosts, dirs))
+    config.agents.map((agent) => agentCompileCheck(agent, installation))
   );
   const unrenderable = agentChecks.filter((c) => c.state === "unrenderable");
   const missingAgents = agentChecks.filter((c) => c.state === "missing").map((c) => c.name);
-  if (unrenderable.length === agents.length) {
+  if (unrenderable.length === config.agents.length) {
     const hostsLeavingThemOut = unique(unrenderable.map((a) => a.provider)).join(" or ");
     return {
       kind: "agents",
@@ -865,96 +1015,71 @@ async function checkAgentsCompiled(config, projectDir) {
     return {
       kind: "agents",
       status: "warn",
-      message: `${missingAgents.length} agent${missingAgents.length === 1 ? "" : "s"} need${missingAgents.length === 1 ? "s" : ""} recompilation`,
+      message: needRecompilation(missingAgents.length),
       details: missingAgents.map((a) => `- ${a} (missing)`)
     };
   }
-  const renderable = agents.length - unrenderable.length;
+  const renderable = config.agents.length - unrenderable.length;
   return {
     kind: "agents",
     status: "pass",
     message: `${ratio(renderable, renderable, "agent")} compiled`
   };
 }
-async function agentCompileCheck(agent, hosts, agentsDirs) {
+function needRecompilation(count) {
+  return `${plural(count, "agent")} ${count === 1 ? "needs" : "need"} recompilation`;
+}
+async function agentCompileCheck(agent, { projectDir, hosts }) {
   const provider = hosts[agent.scope];
   if (!hostCompilesAgent(provider, agent.name)) {
     return { name: agent.name, provider, state: "unrenderable" };
   }
   const file = `${agent.name}${agentCodec(provider).extension}`;
-  const compiled = await fileExists(path3.join(agentsDirs[agent.scope], file));
+  const compiled = await fileExists(path4.join(agentsDir(provider, agent.scope, projectDir), file));
   return { name: agent.name, provider, state: compiled ? "compiled" : "missing" };
 }
-async function checkNoOrphans(config, projectDir) {
-  const codec = agentCodec(providerInUse(projectDir));
-  const projectAgentsDir = resolveInstallPaths(projectDir, "project").agentsDir;
-  const globalAgentsDir = resolveInstallPaths(projectDir, "global").agentsDir;
-  const scopesShareAgentsDir = isHomeDirectory(projectDir);
-  const [projectExists, globalExists] = await Promise.all([
-    directoryExists(projectAgentsDir),
-    !scopesShareAgentsDir ? directoryExists(globalAgentsDir) : false
-  ]);
-  if (!projectExists && !globalExists) {
+async function checkNoOrphans(state, config, installation) {
+  return ownershipResult(state, await judgeOwnership(state, config, installation));
+}
+function ownershipResult(state, { unowned, orphans }) {
+  if (unowned.skills.length > 0 || unowned.agents.length > 0) {
     return {
-      kind: "orphans",
-      status: "pass",
-      message: "No agents directory"
+      kind: "orphans-unowned",
+      status: "fail",
+      message: `${countedArtifacts(unowned.skills, unowned.agents)} installed here, and no configuration declares them`,
+      details: [...unowned.skills, ...unowned.agents, ...orphanLines(orphans)].map(
+        (line) => `- ${line}`
+      )
     };
   }
-  const projectMdFiles = projectExists ? await listAgentFilesOf(projectAgentsDir, codec) : [];
-  const globalMdFiles = globalExists ? await listAgentFilesOf(globalAgentsDir, codec) : [];
-  const activeProjectAgents = new Set(
-    config.agents.filter((a) => a.scope === "project" && !a.excluded).map((a) => a.name)
-  );
-  const knownGlobalAgents = new Set(
-    config.agents.filter((a) => a.scope === "global").map((a) => a.name)
-  );
-  const knownProjectDirAgents = scopesShareAgentsDir ? /* @__PURE__ */ new Set([...activeProjectAgents, ...knownGlobalAgents]) : activeProjectAgents;
-  const orphanedFiles = [
-    ...orphanedAgentNames(projectMdFiles, knownProjectDirAgents, codec),
-    ...orphanedAgentNames(globalMdFiles, knownGlobalAgents, codec)
-  ];
-  if (orphanedFiles.length > 0) {
+  if (orphans.skills.length > 0 || orphans.agents.length > 0) {
     return {
       kind: "orphans",
       status: "warn",
-      message: plural(orphanedFiles.length, "orphaned agent file"),
-      details: orphanedFiles.map((f) => `- ${f}.md (not in config)`)
+      message: countedOrphans(orphans),
+      details: orphanLines(orphans).map((line) => `- ${line}`)
     };
   }
-  return {
-    kind: "orphans",
-    status: "pass",
-    message: "No orphaned agent files"
-  };
+  if (state.kind === "absent") return skippedResult("orphans");
+  return { kind: "orphans", status: "pass", message: "No orphaned skills or agent files" };
 }
-function orphanedAgentNames(mdFiles, knownAgents, codec) {
-  return mdFiles.map((fileName) => path3.basename(fileName, codec.extension)).filter((agentName) => !knownAgents.has(agentName));
+function orphanLines({ skills, agents }) {
+  return [...skills, ...agents].map((name) => `${name} (not in config)`);
 }
-async function checkUnownedInstallation(projectDir) {
-  const { skills, agents } = await listInstalledArtifacts(projectDir);
-  if (skills.length === 0 && agents.length === 0) return skippedResult("orphans");
-  return {
-    kind: "orphans-unowned",
-    status: "fail",
-    // The per-line "(not in config)" the other verdict repeats is said once here instead:
-    // with no configuration it is true of every line, and there are as many lines as files.
-    message: `${countedArtifacts(skills, agents)} installed here, and no configuration declares them`,
-    details: [...skills, ...agents].map((artifact) => `- ${artifact}`)
-  };
+function countedOrphans({ skills, agents }) {
+  return nonZeroCounts([skills.length, "orphaned skill"], [agents.length, "orphaned agent file"]);
 }
 function ratio(found, total, noun) {
   return `${found}/${plural(total, noun)}`;
 }
 function countedArtifacts(skills, agents) {
-  return [
-    ...skills.length > 0 ? [plural(skills.length, "skill")] : [],
-    ...agents.length > 0 ? [plural(agents.length, "agent")] : []
-  ].join(" and ");
+  return nonZeroCounts([skills.length, "skill"], [agents.length, "agent"]);
 }
-async function checkSkillsInstalled(config, projectDir) {
-  const skills = config.skills;
-  const ejectSkills = skills.filter((s) => s.origin === EJECT_SOURCE);
+function nonZeroCounts(...counts) {
+  return counts.filter(([count]) => count > 0).map(([count, noun]) => plural(count, noun)).join(" and ");
+}
+async function checkSkillsInstalled(config, installation) {
+  const ejectSkills = config.skills.filter((s) => s.origin === EJECT_SOURCE);
   if (ejectSkills.length === 0) {
     return {
       kind: "installed",
@@ -963,7 +1088,7 @@ async function checkSkillsInstalled(config, projectDir) {
     };
   }
   const skillChecks = await Promise.all(
-    ejectSkills.map((skill) => ejectedSkillCheck(skill, projectDir))
+    ejectSkills.map((skill) => ejectedSkillCheck(skill, installation))
   );
   const missingSkills = skillChecks.filter((c) => !c.installed);
   if (missingSkills.length > 0) {
@@ -980,17 +1105,17 @@ async function checkSkillsInstalled(config, projectDir) {
     message: `${ratio(ejectSkills.length, ejectSkills.length, "eject-mode skill")} installed`
   };
 }
-async function ejectedSkillCheck(skill, projectDir) {
-  const provider = providerInUse(installBaseDir(projectDir, skill.scope));
+async function ejectedSkillCheck(skill, { projectDir, hosts }) {
+  const provider = hosts[skill.scope];
   const dir = skillsDir(provider, skill.scope, projectDir);
-  const installed = await fileExists(path3.join(dir, skill.id, STANDARD_FILES.SKILL_MD));
+  const installed = await fileExists(path4.join(dir, skill.id, STANDARD_FILES.SKILL_MD));
   return {
     id: skill.id,
     installed,
     lookedIn: skillsPathPrefix(provider, skill.scope, projectDir)
   };
 }
-async function checkPluginSkillsInstalled(config, projectDir) {
+async function checkPluginSkillsInstalled(config, installation) {
   const pluginSkills = config.skills.filter((s) => s.origin !== EJECT_SOURCE);
   if (pluginSkills.length === 0) {
     return {
@@ -999,18 +1124,11 @@ async function checkPluginSkillsInstalled(config, projectDir) {
       message: "No plugin-mode skills configured"
     };
   }
-  const baseDirs = unique(pluginSkills.map((s) => installBaseDir(projectDir, s.scope)));
-  const missingPerBaseDir = await Promise.all(
-    baseDirs.map(async (baseDir) => {
-      const installedIds = new Set(
-        (await getVerifiedPluginInstallPaths(baseDir)).map(
-          (plugin) => parseMarketplacePluginRef(plugin.pluginKey)
-        )
-      );
-      return pluginSkills.filter((skill) => installBaseDir(projectDir, skill.scope) === baseDir).filter((skill) => !installedIds.has(skill.id)).map((skill) => skill.id);
-    })
+  const scopes = unique(pluginSkills.map((s) => s.scope));
+  const missingPerScope = await Promise.all(
+    scopes.map((scope) => pluginSkillsMissingAt(scope, pluginSkills, installation))
   );
-  const missingSkills = missingPerBaseDir.flat();
+  const missingSkills = missingPerScope.flat();
   if (missingSkills.length > 0) {
     return {
       kind: "plugins",
@@ -1025,6 +1143,13 @@ async function checkPluginSkillsInstalled(config, projectDir) {
     message: `${ratio(pluginSkills.length, pluginSkills.length, "plugin-mode skill")} installed`
   };
 }
+async function pluginSkillsMissingAt(scope, pluginSkills, { projectDir, hosts }) {
+  const installedIds = await installedPluginSkillIds(
+    installBaseDir(projectDir, scope),
+    hosts[scope]
+  );
+  return pluginSkills.filter((skill) => skill.scope === scope).filter((skill) => !installedIds.has(skill.id)).map((skill) => skill.id);
+}
 var MARKETPLACE_CHOSEN_BY = {
   flag: "named by this run",
   env: `named by ${SOURCE_ENV_VAR}`,
@@ -1037,29 +1162,37 @@ function howItWasReached(source, isLocal) {
 }
 function reachedMarketplace(result) {
   const { source, sourceOrigin } = result.sourceConfig;
-  const skillCount = result.marketplaceSkillIds.size;
-  const sourceLabel = result.isLocal ? "local" : "remote";
+  const available = `${plural(result.marketplaceSkillIds.size, "skill")} available`;
+  const chosenBy = MARKETPLACE_CHOSEN_BY[sourceOrigin];
+  if (result.unreachable) {
+    return {
+      kind: "source",
+      status: "warn",
+      message: `Could not reach ${source} \u2014 read its cached copy instead`,
+      details: [available, `The copy at ${result.sourcePath} may be out of date \u2014 ${chosenBy}`]
+    };
+  }
   return {
     kind: "source",
     status: "pass",
-    message: `Connected to ${sourceLabel}: ${result.sourcePath}`,
-    details: [
-      `${plural(skillCount, "skill")} available`,
-      `${howItWasReached(source, result.isLocal)} \u2014 ${MARKETPLACE_CHOSEN_BY[sourceOrigin]}`
-    ]
+    message: `Connected to ${result.isLocal ? "local" : "remote"}: ${result.sourcePath}`,
+    details: [available, `${howItWasReached(source, result.isLocal)} \u2014 ${chosenBy}`]
   };
 }
-async function checkSourceReachable(projectDir) {
+async function checkSourceReachable({
+  projectDir,
+  hosts
+}) {
   try {
-    const { sourceResult } = await loadSource({ projectDir });
-    return reachedMarketplace(sourceResult);
+    return reachedMarketplace(
+      await loadSkillsMatrixFromSource({ projectDir, provider: hosts.project })
+    );
   } catch (error) {
-    const message = getErrorMessage(error);
     return {
       kind: "source",
       status: "fail",
-      message: "Failed to load marketplace",
-      details: [message]
+      message: refusedOr(error, "Failed to load marketplace"),
+      details: [getErrorMessage(error)]
     };
   }
 }
@@ -1074,11 +1207,8 @@ var CONTENT_CHECKS = [
     kind: "content-sources",
     name: "Marketplaces",
     noun: "marketplace",
-    // The registered marketplaces are the ones config.ts names.
     readsConfig: true,
-    // A marketplace whose content is broken is missing skills from the matrix every configured
-    // id is resolved against, so the skills row would call ids "not found" that this row has
-    // already accounted for.
+    // A broken marketplace leaves skills out of the matrix ids resolve against.
     blocks: ["skills"],
     run: validateRegisteredSources
   },
@@ -1087,9 +1217,7 @@ var CONTENT_CHECKS = [
     name: "Plugins",
     noun: "plugin",
     readsConfig: false,
-    // `resolvePluginInstallPaths` swallows a registry it cannot parse and returns none, so every
-    // plugin-mode skill would read "no enabled plugin found" — the registry's finding, once per
-    // configured skill, wearing the row's words.
+    // An unparseable registry resolves as no installs at all.
     blocks: ["plugins"],
     run: validateInstalledPlugins
   },
@@ -1097,12 +1225,9 @@ var CONTENT_CHECKS = [
     kind: "content-skills",
     name: "Skills",
     noun: "skill",
-    // `~/.claude/skills/` is shared with everything else that installs a skill there, so which of
-    // its directories are this installation's is a question only the config can answer for the
-    // ones carrying no provenance marker. A config nobody can read leaves that unanswerable.
+    // Only the config says which unmarked shared-skills directories are this installation's.
     readsConfig: true,
-    // `extractLocalSkill` DROPS a skill whose metadata.yaml is missing or unusable, so a "not
-    // found" from the skills row would be this finding re-worded.
+    // `extractLocalSkill` drops a skill with unusable metadata.
     blocks: ["skills"],
     run: validateInstalledSkills
   },
@@ -1111,8 +1236,7 @@ var CONTENT_CHECKS = [
     name: "Agents",
     noun: "agent",
     readsConfig: false,
-    // Nothing downstream opens an agent .md. `Agents Compiled` asks whether the file is there and
-    // `No Orphans` reads the names of the files that are — broken frontmatter changes neither.
+    // No operational row reads agent file contents.
     blocks: [],
     run: validateInstalledAgents
   }
@@ -1197,58 +1321,77 @@ var TIPS = [
   {
     kind: "agents",
     status: "warn",
-    tip: `  Tip: Run '${CLI_INVOKE_COMMAND} compile' to generate missing agent files`
+    line: (provider) => `  Tip: Run '${commandActingOn(provider, "compile")}' to generate missing agent files`
   },
   {
     kind: "config",
     status: "fail",
-    tip: `  Tip: Run '${CLI_INVOKE_COMMAND} init' to create or fix configuration`
+    line: () => `  Tip: Run '${CLI_INVOKE_COMMAND} init' to create or fix configuration`
   },
   {
-    // The remedy for a valid config with nothing in it. Not the tip above: there is nothing to
-    // create and nothing to fix. `init` on this config opens the editor rather than the dashboard
-    // — that is what the detection returning null is FOR — so it is the way to fill it in.
     kind: "config-empty",
     status: "warn",
-    tip: `  Tip: Nothing is configured yet \u2014 run '${CLI_INVOKE_COMMAND} init' to choose skills and sub-agents`
+    line: () => `  Tip: Nothing is configured yet \u2014 run '${CLI_INVOKE_COMMAND} init' to choose skills and sub-agents`
   },
   {
-    // Printed beside the config tip above, which says how to get a configuration back and
-    // nothing about the files that outlived the old one. Both halves are named with what they
-    // actually do: `uninstall` matches skill directories by their own `forked-from` metadata and
-    // compiled agents by the marker each one carries, so neither needs the configuration that is
-    // gone — which is why the row can name both and this tip can promise both.
     kind: "orphans-unowned",
     status: "fail",
-    tip: `  Tip: Nothing declares the files above \u2014 '${CLI_INVOKE_COMMAND} init --from <id>' writes a configuration that can own them again, or '${CLI_INVOKE_COMMAND} uninstall' removes them, the compiled agents included: each file listed carries this CLI's own provenance, which is what that command reads when there is no configuration left`
+    line: (provider) => `  Tip: Nothing declares the files above \u2014 '${commandActingOn(provider, "init --from <id>")}' writes a configuration that can own them again, or '${commandActingOn(provider, "uninstall")}' removes them, the compiled agents included: each file listed carries this CLI's own provenance, which is what that command reads when there is no configuration left`
   },
   {
     kind: "skills",
     status: "fail",
-    tip: "  Tip: Check skill IDs in config match available skills"
+    line: () => "  Tip: Check skill IDs in config match available skills"
   },
   {
     kind: "installed",
     status: "warn",
-    // No command is named on purpose: 'eject skills --force' re-copies every skill in the
-    // marketplace and always targets project scope, so it cannot repair a global-scoped
-    // skill and it litters a plugin-mode project with local skill directories.
-    tip: "  Tip: Re-eject the missing skills from the marketplace to restore their files"
+    // No command named: `eject skills --force` copies every skill, and only at project scope.
+    line: () => "  Tip: Re-eject the missing skills from the marketplace to restore their files"
   }
 ];
+function commandActingOn(provider, command) {
+  return `${CLI_INVOKE_COMMAND} ${command}${providerArgument(provider)}`;
+}
 function formatTips(results) {
-  return TIPS.filter((t) => results.some((r) => r.kind === t.kind && r.status === t.status)).map(
-    (t) => t.tip
-  );
+  return unique(TIPS.flatMap((tip) => linesOf(tip, results)));
+}
+function linesOf(tip, results) {
+  return results.filter((result) => answers(tip, result)).map((result) => tip.line(result.provider));
+}
+function answers(tip, result) {
+  return result.kind === tip.kind && result.status === tip.status;
 }
 async function recreateConfigTips(contentResults, projectDir) {
   if (!failedContentKinds(contentResults).has(CONFIG_CHECK.kind)) return [];
   const failures = await findConfigLoadFailures(projectDir).catch(() => []);
   return failures.map(
-    (failure) => `  Tip: There is no automatic repair \u2014 recreate the configuration by running ${recreateConfigFrom(failure.scopeRoot)}`
+    (failure) => `  Tip: There is no automatic repair \u2014 recreate the configuration by running ${recreateConfigFrom(failure)}`
   );
 }
+var INSTALLATIONS_ROW_NAME = "Installations";
+async function checkInstallationsInPlay(projectDir, providers) {
+  const finding = await ambiguityFinding(projectDir);
+  return {
+    kind: "installations",
+    status: "fail",
+    message: `${providers.length} installations here, each checked below`,
+    details: finding === null ? [] : [`- ${finding}`]
+  };
+}
+function installationHeading(provider) {
+  return `${SECTION_INDENT}The ${provider} installation`;
+}
+var SOURCE_REPO_ROW_NAME = "Marketplace Repository";
+async function uninstalledSourceRepo(projectDir) {
+  if (!await isSourceRepo(projectDir)) return null;
+  return { kind: "source-repo", status: "skip", message: SKIP_NO_INSTALLATION };
+}
 var LAYOUT_ROW_NAME = "Layout";
+async function checkLayout({ projectDir, hosts }) {
+  const scopes = await sourceScopesInPlay(projectDir, ({ kind }) => hosts[kind]);
+  return scopes.map(toLayoutResult);
+}
 function toLayoutResult(scope) {
   return {
     kind: "layout",
@@ -1257,8 +1400,8 @@ function toLayoutResult(scope) {
   };
 }
 var PLACEMENTS_ROW_NAME = "Placements Offered";
-async function checkOfferedPlacements(projectDir) {
-  const findings = await everythingThatWouldStopACommandActing(projectDir);
+async function checkOfferedPlacements(installation) {
+  const findings = await unofferablePlacements(installation);
   if (findings.length === 0) {
     return { kind: "placements", status: "pass", message: "Every configured skill is placeable" };
   }
@@ -1269,13 +1412,6 @@ async function checkOfferedPlacements(projectDir) {
     details: findings.map((finding) => `- ${finding}`)
   };
 }
-async function everythingThatWouldStopACommandActing(projectDir) {
-  const [unofferable, ambiguous] = await Promise.all([
-    unofferablePlacementsFound(projectDir),
-    ambiguityFinding(projectDir)
-  ]);
-  return ambiguous === null ? unofferable : [...unofferable, ambiguous];
-}
 function skippedResult(kind) {
   return { kind, status: "skip", message: "Skipped (config invalid)" };
 }
@@ -1296,13 +1432,31 @@ function contentBlockedResult(row, failedContent) {
 function runContentCheck(check, projectDir) {
   return safeCheck(check.kind, async () => toContentResult(check, await check.run(projectDir)));
 }
+async function runGatedContentCheck(check, projectDir, configUnreadable) {
+  if (check.readsConfig && configUnreadable) return skippedContentResult(check.kind);
+  return runContentCheck(check, projectDir);
+}
+async function flatMapInTurn(items, step) {
+  return items.reduce(
+    async (earlier, item) => [...await earlier, ...await step(item)],
+    Promise.resolve([])
+  );
+}
 async function safeCheck(kind, fn) {
   try {
     return await fn();
   } catch (error) {
-    return { kind, status: "fail", message: "Check threw", details: [getErrorMessage(error)] };
+    return {
+      kind,
+      status: "fail",
+      message: refusedOr(error, "Check threw"),
+      details: [getErrorMessage(error)]
+    };
   }
 }
+function refusedOr(error, otherwise) {
+  return error instanceof MarketplaceRefusedError ? "Refused" : otherwise;
+}
 var Doctor = class _Doctor extends BaseCommand {
   static summary = "Diagnose common configuration issues";
   static description = `Run diagnostic checks on your ${DEFAULT_BRANDING.NAME} configuration to identify issues with config validity, skill resolution, agent compilation, and marketplace connectivity.`;
@@ -1327,12 +1481,6 @@ var Doctor = class _Doctor extends BaseCommand {
     this.log(`${SECTION_INDENT}Checking configuration health...`);
     this.log("");
   }
-  /**
-   * The config is checked first and alone. A check that reads it to know what to validate would
-   * otherwise ask a file already reported as unreadable — and asking is what emitted the loader's
-   * own failure line once per read, spliced between these rows. Everything that walks installed
-   * content on disk still runs: it says something true whatever the config is in.
-   */
   async runContentChecks(projectDir) {
     this.log(`${SECTION_INDENT}${SECTION_CONTENT}`);
     const configResult = await runContentCheck(CONFIG_CHECK, projectDir);
@@ -1340,7 +1488,7 @@ var Doctor = class _Doctor extends BaseCommand {
     const rows = await Promise.all(
       CONTENT_CHECKS.map(async (check) => ({
         name: check.name,
-        result: check.readsConfig && configUnreadable ? skippedContentResult(check.kind) : await runContentCheck(check, projectDir)
+        result: await runGatedContentCheck(check, projectDir, configUnreadable)
       }))
     );
     const allRows = [{ name: CONFIG_CHECK.name, result: configResult }, ...rows];
@@ -1349,13 +1497,6 @@ var Doctor = class _Doctor extends BaseCommand {
     }
     return allRows.map((row) => row.result);
   }
-  /**
-   * The whole layer stands down for the two findings that leave every row with nothing to say: a
-   * config nobody can read — every row is read out of it, so all of them would be cascades of that
-   * one file — and a marketplace repository with nothing installed, where a marketplace author has
-   * no install for the layer to describe. Every other content error is scoped to the rows that
-   * read what it is about; {@link GatedContentCheck} says which those are, per pass.
-   */
   async runOperationalChecks(projectDir, contentResults) {
     this.log("");
     this.log(`${SECTION_INDENT}${SECTION_OPERATIONAL}`);
@@ -1364,48 +1505,78 @@ var Doctor = class _Doctor extends BaseCommand {
       this.log(`${ROW_INDENT}${SKIP_AFTER_CONFIG_ERROR}`);
       return [];
     }
-    const detected = await detectProject(projectDir);
-    if (!detected && await this.isUninstalledSourceRepo(projectDir)) {
-      this.log(`${ROW_INDENT}${SKIP_NO_INSTALLATION}`);
+    const providers = await providersInPlay(projectDir);
+    if (providers.length > 1) {
+      return this.checkEachInstallation(projectDir, providers, failedContent);
+    }
+    return this.checkTheInstallation(projectDir, failedContent);
+  }
+  async checkTheInstallation(projectDir, failedContent) {
+    const installation = { projectDir, hosts: hostsOnDisk(projectDir) };
+    const configState = await resolveConfigState(installation);
+    if (configState.kind === "absent") {
+      const sourceRepo = await safeCheck("source-repo", () => uninstalledSourceRepo(projectDir));
+      if (sourceRepo !== null) return this.reportSourceRepo(sourceRepo);
+    }
+    return this.runAllChecks(installation, configState, failedContent);
+  }
+  /** A repository nothing is installed in skips the layer; one whose own config breaks is a row. */
+  reportSourceRepo(sourceRepo) {
+    if (sourceRepo.status === "skip") {
+      this.log(`${ROW_INDENT}${sourceRepo.message}`);
       return [];
     }
-    const configState = await resolveConfigState(detected, projectDir);
-    return this.runAllChecks(projectDir, configState, failedContent);
-  }
-  /**
-   * A config file that exists but failed to load also detects as "no project", and
-   * that is a finding rather than an absence — so the skip requires no config file
-   * at all, not merely no usable one.
-   */
-  async isUninstalledSourceRepo(projectDir) {
-    if (await fileExists(getInstalledConfigPath(projectDir))) return false;
-    return isSourceRepo(projectDir);
-  }
-  async runAllChecks(projectDir, configState, failedContent) {
-    const { result: configResult, config } = checkConfigValid(configState, projectDir);
+    this.logCheck(SOURCE_REPO_ROW_NAME, sourceRepo);
+    return [sourceRepo];
+  }
+  /** In turn rather than at once: each block prints as it runs, and each load seats the matrix. */
+  async checkEachInstallation(projectDir, providers, failedContent) {
+    const installations = await safeCheck(
+      "installations",
+      () => checkInstallationsInPlay(projectDir, providers)
+    );
+    this.logCheck(INSTALLATIONS_ROW_NAME, installations);
+    const blocks = await flatMapInTurn(
+      providers,
+      (provider) => this.checkOneOf(projectDir, provider, failedContent)
+    );
+    return [installations, ...blocks];
+  }
+  async checkOneOf(projectDir, provider, failedContent) {
+    this.log("");
+    this.log(installationHeading(provider));
+    const installation = { projectDir, hosts: hostsOf(provider) };
+    const results = await this.runAllChecks(
+      installation,
+      await resolveConfigState(installation),
+      failedContent
+    );
+    return results.map((result) => ({ ...result, provider }));
+  }
+  async runAllChecks(installation, configState, failedContent) {
+    const { result: configResult, config } = checkConfigValid(configState, installation);
     this.logCheck("Config Valid", configResult);
-    const layoutResults = await this.reportLayout(projectDir);
+    const layoutResults = await this.reportLayout(installation);
     const placementsResult = await safeCheck(
       "placements",
-      () => checkOfferedPlacements(projectDir)
+      () => checkOfferedPlacements(installation)
     );
     this.logCheck(PLACEMENTS_ROW_NAME, placementsResult);
-    const sourceResult = await safeCheck("source", () => checkSourceReachable(projectDir));
+    const sourceResult = await safeCheck("source", () => checkSourceReachable(installation));
     const filteredConfig = config ? filterExcludedEntries(config) : null;
-    const skillsResult = await this.resolveSkillsCheck(
-      config,
-      sourceResult,
-      projectDir,
-      failedContent
-    );
+    const skillsResult = await this.resolveSkillsCheck(config, sourceResult, failedContent);
     this.logCheck("Skills Resolved", skillsResult);
-    const agentsResult = filteredConfig ? await safeCheck("agents", () => checkAgentsCompiled(filteredConfig, projectDir)) : skippedResult("agents");
+    const agentsResult = await this.resolveAgentsCheck(filteredConfig, installation);
     this.logCheck("Agents Compiled", agentsResult);
-    const orphansResult = await this.resolveOrphansCheck(config, configState, projectDir);
+    const orphansResult = await this.resolveOrphansCheck(config, configState, installation);
     this.logCheck("No Orphans", orphansResult);
-    const installedResult = filteredConfig ? await safeCheck("installed", () => checkSkillsInstalled(filteredConfig, projectDir)) : skippedResult("installed");
+    const installedResult = await this.resolveInstalledCheck(filteredConfig, installation);
     this.logCheck("Skills Installed", installedResult);
-    const pluginsResult = await this.resolvePluginsCheck(filteredConfig, projectDir, failedContent);
+    const pluginsResult = await this.resolvePluginsCheck(
+      filteredConfig,
+      installation,
+      failedContent
+    );
     this.logCheck("Plugins Installed", pluginsResult);
     this.logCheck("Marketplace Reachable", sourceResult);
     return [
@@ -1420,59 +1591,38 @@ var Doctor = class _Doctor extends BaseCommand {
       sourceResult
     ];
   }
-  /**
-   * One `Layout` row per scope in play.
-   *
-   * Per scope rather than per machine: a project and the global installation are two
-   * installations, and one row for the two can only name one of their folders.
-   *
-   * Printed right under `Config Valid`, because every row below it is read out of a config file
-   * in the folder this row names.
-   */
-  async reportLayout(projectDir) {
-    const rows = (await sourceScopesInPlay(projectDir)).map(toLayoutResult);
+  async reportLayout(installation) {
+    const rows = await checkLayout(installation);
     for (const row of rows) {
       this.logCheck(LAYOUT_ROW_NAME, row);
     }
     return rows;
   }
-  /**
-   * The orphan row, and which question it can answer. With a config it names the compiled
-   * agents that config does not; with no config at all every installed file is unowned and it
-   * names all of them. It skips for the one state left — a config that loads and fails
-   * validation — because there the file that says who owns what has already been rejected, and
-   * an installation must not be called stranded on the strength of one nobody can trust.
-   */
-  async resolveOrphansCheck(config, configState, projectDir) {
-    if (config) return safeCheck("orphans", () => checkNoOrphans(config, projectDir));
-    if (configState.kind === "absent") {
-      return safeCheck("orphans", () => checkUnownedInstallation(projectDir));
-    }
-    return skippedResult("orphans");
-  }
-  /**
-   * The skills row, and the three states in which it cannot be computed: no config to read the
-   * skills out of, content it resolves against that the layer above has already reported broken,
-   * and a marketplace that never loaded — so there is no populated matrix to resolve them
-   * against, and every configured skill would be reported "not found".
-   */
-  async resolveSkillsCheck(config, sourceResult, projectDir, failedContent) {
+  /** Skips on a config the checks rejected: ownership can't be judged from a rejected file. */
+  async resolveOrphansCheck(config, configState, installation) {
+    if (!config && configState.kind !== "absent") return skippedResult("orphans");
+    return safeCheck("orphans", () => checkNoOrphans(configState, config, installation));
+  }
+  async resolveSkillsCheck(config, sourceResult, failedContent) {
     if (!config) return skippedResult("skills");
     const blocked = contentBlockedResult("skills", failedContent);
     if (blocked) return blocked;
     if (sourceResult.status === "fail") return sourceUnreachableSkillsResult();
-    return safeCheck("skills", () => checkSkillsResolved(config, matrix, projectDir));
-  }
-  /**
-   * The plugin row, and the two states in which it cannot be computed: no config to read the
-   * plugin-mode skills out of, and a plugin registry the layer above could not parse — which
-   * resolves as no installs at all, so every configured skill would be reported missing.
-   */
-  async resolvePluginsCheck(config, projectDir, failedContent) {
+    return safeCheck("skills", () => checkSkillsResolved(config, matrix));
+  }
+  async resolveAgentsCheck(config, installation) {
+    if (!config) return skippedResult("agents");
+    return safeCheck("agents", () => checkAgentsCompiled(config, installation));
+  }
+  async resolveInstalledCheck(config, installation) {
+    if (!config) return skippedResult("installed");
+    return safeCheck("installed", () => checkSkillsInstalled(config, installation));
+  }
+  async resolvePluginsCheck(config, installation, failedContent) {
     if (!config) return skippedResult("plugins");
     const blocked = contentBlockedResult("plugins", failedContent);
     if (blocked) return blocked;
-    return safeCheck("plugins", () => checkPluginSkillsInstalled(config, projectDir));
+    return safeCheck("plugins", () => checkPluginSkillsInstalled(config, installation));
   }
   logCheck(name, result) {
     for (const line of formatCheckLine(name, result)) {