agents-inc 0.164.0 → 0.166.0

package/dist/commands/doctor.js

@@ -1,25 +1,35 @@
 #!/usr/bin/env node
+import {
+  unofferablePlacementsFound
+} from "../chunk-PXWG7KFO.js";
 import {
   detectProject,
   loadSource
-} from "../chunk-X37UYIE3.js";
-import "../chunk-2CQNPLVF.js";
-import "../chunk-B6FSLXYN.js";
+} from "../chunk-G6UREQ4V.js";
+import "../chunk-HWEKHVLE.js";
+import "../chunk-PMJWD27C.js";
+import "../chunk-ZR4YPKXQ.js";
 import {
   filterExcludedEntries,
+  listAgentFilesOf,
   listAgentMdFiles,
   splitAgentsByProvenance
-} from "../chunk-JU4ZGJ7A.js";
+} from "../chunk-GE3WKJ6Q.js";
+import {
+  ambiguityFinding
+} from "../chunk-NBXXFIIW.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-JIERYE6B.js";
-import "../chunk-NKGYKOB7.js";
-import "../chunk-PHCPUQVR.js";
+} from "../chunk-Y3VIRVVE.js";
+import "../chunk-VAPTVR3J.js";
+import "../chunk-RZDXDMT6.js";
 import {
   ConfigDefaultExportError,
+  MarketplaceManifestRequiredError,
   MarketplaceNameRefusedError,
   SOURCE_ENV_VAR,
+  agentCodec,
   agentYamlGenerationSchema,
   checkMatrixHealth,
   configDirsInPlay,
@@ -30,53 +40,65 @@ import {
   findConfigLoadFailures,
   formatZodErrors,
   getErrorMessage,
+  getInstalledConfigPath,
   getInstalledPluginsRegistryPath,
-  getProjectConfigPath,
   getProjectPluginsDir,
   getStackSkillIds,
   getUserPluginsDir,
   getVerifiedPluginInstallPaths,
   glob,
+  hostCompilesAgent,
   installBaseDir,
+  invalidResult,
   isHomeDirectory,
   isLocalSource,
   isRecord,
+  layoutIsCurrent,
   listDirectories,
   listRegisteredPluginInstalls,
   loadConfig,
-  loadProjectConfigFromDir,
-  loadProjectSourceConfig,
+  loadInstalledConfig,
   loadSkillsMatrixFromSource,
+  loadSourceRepoConfig,
+  mergeValidationResults,
   metadataValidationSchema,
   parseFrontmatter,
   parseMarketplacePluginRef,
+  plural,
+  providerInUse,
   readFile,
   readForkedFromMetadata,
   readSkillMetadata,
+  recreateConfigFrom,
+  relativeConfigPath,
   resolveInstallPaths,
   resolvePrimarySourceEntry,
+  scopeLabel,
+  scopeNoun,
   skillCategoriesFileSchema,
   skillRulesFileSchema,
+  skillsDir,
+  skillsPathPrefix,
+  sourceScopesInPlay,
   splitMetadataValidationIssues,
   stackConfigValidationSchema,
   stacksConfigSchema,
+  validResult,
   validateAgentFrontmatter,
   validateAllPlugins,
   validatePlugin,
   validateProjectConfig,
   validateSkillFrontmatter,
   validateSkillMetadata
-} from "../chunk-XPDVAJDH.js";
+} from "../chunk-A4KDXNOT.js";
 import {
   matrix
-} from "../chunk-AVK2HEKB.js";
+} from "../chunk-V5WXIM2F.js";
 import {
-  CLAUDE_SRC_DIR,
   CLI_INVOKE_COMMAND,
   DEFAULT_BRANDING,
   DIRS,
   EJECT_SOURCE,
-  LOCAL_SKILLS_PATH,
   MARKETPLACE_JSON,
   PLUGIN_MANIFEST_DIR,
   SKILLS_DIR_PATH,
@@ -86,7 +108,7 @@ import {
   STANDARD_FILES,
   UI_SYMBOLS,
   effectivelyExcludedSkillIds
-} from "../chunk-UITEKY2R.js";
+} from "../chunk-ENGYJCTF.js";
 import "../chunk-OI2H6M5I.js";
 
 // src/cli/commands/doctor.ts
@@ -98,7 +120,7 @@ import path from "path";
 import { parse as parseYaml } from "yaml";
 import "zod";
 async function isSourceRepo(dir) {
-  const sourceConfig = await loadProjectSourceConfig(dir);
+  const sourceConfig = await loadSourceRepoConfig(dir);
   return directoryExists(path.join(dir, sourceConfig?.skillsDir ?? SKILLS_DIR_PATH));
 }
 function isSnakeCase(key) {
@@ -122,11 +144,11 @@ function checkDirNameMatchesSkillId(skillId, relPath, dirName) {
     }
   ];
 }
-async function checkSkillDirName(skillsDir, skillsDirRelPath, skillDir) {
+async function checkSkillDirName(skillsDir2, skillsDirRelPath, skillDir) {
   const dirName = path.basename(skillDir);
   const skillMdRelPath = path.join(skillsDirRelPath, skillDir, STANDARD_FILES.SKILL_MD);
   try {
-    const content = await readFile(path.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD));
+    const content = await readFile(path.join(skillsDir2, skillDir, STANDARD_FILES.SKILL_MD));
     const frontmatter = parseFrontmatter(content, skillMdRelPath);
     if (frontmatter === null) {
       return [
@@ -148,67 +170,69 @@ async function checkSkillDirName(skillsDir, skillsDirRelPath, skillDir) {
     ];
   }
 }
-function validateSkillFilePairs(skillMdDirs, metadataDirs, skillsDir) {
+function validateSkillFilePairs(skillMdDirs, metadataDirs, skillsDir2) {
   const missingMetadata = [...skillMdDirs].filter((dir) => !metadataDirs.has(dir)).map((dir) => ({
     severity: "error",
-    file: path.join(skillsDir, dir),
+    file: path.join(skillsDir2, dir),
     message: `Missing ${STANDARD_FILES.METADATA_YAML} \u2014 skill directory has ${STANDARD_FILES.SKILL_MD} but no metadata`
   }));
   const missingSkillMd = [...metadataDirs].filter((dir) => !skillMdDirs.has(dir)).map((dir) => ({
     severity: "error",
-    file: path.join(skillsDir, dir),
+    file: path.join(skillsDir2, dir),
     message: `Missing ${STANDARD_FILES.SKILL_MD} \u2014 skill directory has ${STANDARD_FILES.METADATA_YAML} but no SKILL.md`
   }));
   return [...missingMetadata, ...missingSkillMd];
 }
 async function validateSource(sourcePath, reader = "author") {
-  const issues = [];
   const resolvedPath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(sourcePath);
   if (!await directoryExists(resolvedPath)) {
-    issues.push({
-      severity: "error",
-      file: resolvedPath,
-      message: "Marketplace directory does not exist"
-    });
-    return buildResult(issues, 0);
+    return buildResult(
+      [{ severity: "error", file: resolvedPath, message: "Marketplace directory does not exist" }],
+      0
+    );
   }
-  const sourceProjectConfig = await loadProjectSourceConfig(resolvedPath);
+  const sourceProjectConfig = await loadSourceRepoConfig(resolvedPath);
   const skillsDirRelPath = sourceProjectConfig?.skillsDir ?? SKILLS_DIR_PATH;
-  const skillsDir = path.join(resolvedPath, skillsDirRelPath);
-  if (!await directoryExists(skillsDir)) {
-    issues.push({
-      severity: "error",
-      file: skillsDir,
-      message: "Skills directory does not exist"
-    });
-    return buildResult(issues, 0);
+  const skillsDir2 = path.join(resolvedPath, skillsDirRelPath);
+  if (!await directoryExists(skillsDir2)) {
+    return buildResult(
+      [{ severity: "error", file: skillsDir2, message: "Skills directory does not exist" }],
+      0
+    );
   }
-  const skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
-  const metadataFiles = await glob(`**/${STANDARD_FILES.METADATA_YAML}`, skillsDir);
+  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)));
-  issues.push(...validateSkillFilePairs(skillMdDirs, metadataDirs, skillsDir));
+  const pairIssues = validateSkillFilePairs(skillMdDirs, metadataDirs, skillsDir2);
   const validMetadataFiles = metadataFiles.filter((f) => skillMdDirs.has(path.dirname(f)));
-  for (const metadataFile of validMetadataFiles) {
-    issues.push(...await validateOneSkill(skillsDir, skillsDirRelPath, metadataFile));
-  }
-  issues.push(...await checkCrossReferences(resolvedPath, reader));
+  const skillIssues = await validateSkillsInTurn(skillsDir2, skillsDirRelPath, validMetadataFiles);
+  const crossReferenceIssues = await checkCrossReferences(resolvedPath, reader);
   const extraIssues = await Promise.all([
     validateStacks(resolvedPath),
     validateAgents(resolvedPath),
     validateConfigFiles(resolvedPath)
   ]);
-  issues.push(...extraIssues.flat());
-  return buildResult(issues, validMetadataFiles.length);
+  return buildResult(
+    [...pairIssues, ...skillIssues, ...crossReferenceIssues, ...extraIssues.flat()],
+    validMetadataFiles.length
+  );
+}
+async function validateSkillsInTurn(skillsDir2, skillsDirRelPath, metadataFiles) {
+  const issues = [];
+  for (const metadataFile of metadataFiles) {
+    issues.push(...await validateOneSkill(skillsDir2, skillsDirRelPath, metadataFile));
+  }
+  return issues;
 }
 function yamlParseFailure(error) {
   return `Failed to parse YAML: ${getErrorMessage(error)}`;
 }
-async function validateOneSkill(skillsDir, skillsDirRelPath, metadataFile) {
+async function validateOneSkill(skillsDir2, skillsDirRelPath, metadataFile) {
   const relPath = path.join(skillsDirRelPath, metadataFile);
   let rawMetadata;
   try {
-    rawMetadata = parseYaml(await readFile(path.join(skillsDir, metadataFile)));
+    rawMetadata = parseYaml(await readFile(path.join(skillsDir2, metadataFile)));
   } catch (error) {
     return [{ severity: "error", file: relPath, message: yamlParseFailure(error) }];
   }
@@ -216,7 +240,7 @@ async function validateOneSkill(skillsDir, skillsDirRelPath, metadataFile) {
     ...checkSnakeCaseKeys(rawMetadata, relPath),
     ...checkMetadataSchema(rawMetadata, relPath),
     // Independent of metadata validity — the id lives in SKILL.md frontmatter
-    ...await checkSkillDirName(skillsDir, skillsDirRelPath, path.dirname(metadataFile))
+    ...await checkSkillDirName(skillsDir2, skillsDirRelPath, path.dirname(metadataFile))
   ];
 }
 function checkMetadataSchema(rawMetadata, relPath) {
@@ -229,6 +253,10 @@ function checkMetadataSchema(rawMetadata, relPath) {
   ];
 }
 var MARKETPLACE_MANIFEST_PATH = path.join(PLUGIN_MANIFEST_DIR, MARKETPLACE_JSON);
+var MANIFEST_REQUIRED_SEVERITY = {
+  author: "warning",
+  consumer: "error"
+};
 async function checkCrossReferences(resolvedPath, reader) {
   try {
     await loadSkillsMatrixFromSource({ sourceFlag: resolvedPath, skipExtraSources: true });
@@ -236,10 +264,17 @@ async function checkCrossReferences(resolvedPath, reader) {
       (healthIssue) => toSourceIssue(healthIssue, resolvedPath, reader)
     );
   } catch (error) {
-    return [matrixLoadFailure(error)];
+    return [matrixLoadFailure(error, reader)];
   }
 }
-function matrixLoadFailure(error) {
+function matrixLoadFailure(error, reader) {
+  if (error instanceof MarketplaceManifestRequiredError) {
+    return {
+      severity: MANIFEST_REQUIRED_SEVERITY[reader],
+      file: MARKETPLACE_MANIFEST_PATH,
+      message: getErrorMessage(error)
+    };
+  }
   if (error instanceof MarketplaceNameRefusedError) {
     return {
       severity: "error",
@@ -326,31 +361,30 @@ async function validateConfigFiles(resolvedPath) {
   ]);
   return results.flat();
 }
-async function validateYamlFiles(opts) {
+async function validateYamlFiles(scan) {
   const issues = [];
-  const files = await glob(opts.pattern, opts.baseDir);
+  const files = await glob(scan.pattern, scan.baseDir);
   for (const relFile of files) {
-    const absPath = path.join(opts.baseDir, relFile);
-    const displayPath = path.join(opts.relBaseDir, relFile);
-    let parsed;
-    try {
-      parsed = parseYaml(await readFile(absPath));
-    } catch (error) {
-      issues.push({ severity: "error", file: displayPath, message: yamlParseFailure(error) });
-      continue;
-    }
-    const result = opts.schema.safeParse(parsed);
-    if (result.success) continue;
-    issues.push(
-      ...formatZodErrors(result.error).map((message) => ({
-        severity: "error",
-        file: displayPath,
-        message
-      }))
-    );
+    issues.push(...await validateYamlFile(scan, relFile));
   }
   return issues;
 }
+async function validateYamlFile(scan, relFile) {
+  const displayPath = path.join(scan.relBaseDir, relFile);
+  let parsed;
+  try {
+    parsed = parseYaml(await readFile(path.join(scan.baseDir, relFile)));
+  } catch (error) {
+    return [{ severity: "error", file: displayPath, message: yamlParseFailure(error) }];
+  }
+  const result = scan.schema.safeParse(parsed);
+  if (result.success) return [];
+  return formatZodErrors(result.error).map((message) => ({
+    severity: "error",
+    file: displayPath,
+    message
+  }));
+}
 async function validateTsConfig(resolvedPath, relConfigPath, schema) {
   const absPath = path.join(resolvedPath, relConfigPath);
   if (!await fileExists(absPath)) return [];
@@ -422,13 +456,13 @@ async function validateProjectConfigFile(projectDir) {
 function toUnreadableConfigIssue(failure) {
   return {
     severity: "error",
-    file: displayDir(failure.configPath),
+    file: `${scopeLabel(failure.scope)}'s ${displayDir(failure.configPath)}`,
     message: `${CONFIG_UNREADABLE}: ${failure.reason}`
   };
 }
 async function countExistingConfigs(projectDir) {
   const present = await Promise.all(
-    configDirsInPlay(projectDir).map((dir) => fileExists(getProjectConfigPath(dir)))
+    configDirsInPlay(projectDir).map((dir) => fileExists(getInstalledConfigPath(dir)))
   );
   return present.filter(Boolean).length;
 }
@@ -465,7 +499,7 @@ async function validateOneSource(source, reader) {
   const label = `${source.name} (${source.url})`;
   try {
     const result = await validateSource(source.url, reader);
-    return { note: `${label} \u2014 ${result.skillCount} skills`, issues: result.issues };
+    return { note: `${label} \u2014 ${plural(result.skillCount, "skill")}`, issues: result.issues };
   } catch (error) {
     return {
       note: `${label} \u2014 failed`,
@@ -541,7 +575,9 @@ async function validateInstalledSkills(projectDir) {
   );
 }
 async function configuredSkillIds(projectDir) {
-  const loaded = await Promise.all(configDirsInPlay(projectDir).map(loadProjectConfigFromDir));
+  const loaded = await Promise.all(
+    configDirsInPlay(projectDir).map((dir) => loadInstalledConfig(dir))
+  );
   return new Set(loaded.flatMap(configuredIdsOf));
 }
 function configuredIdsOf(loaded) {
@@ -569,10 +605,10 @@ async function listAgentFilesWithOurProvenance(agentsDir) {
   const { marked } = await splitAgentsByProvenance(agentsDir);
   return marked.map((name) => `${name}${AGENT_FILE_EXTENSION}`);
 }
-async function listSkillDirsWithOurProvenance(skillsDir) {
-  const names = await listDirectories(skillsDir);
+async function listSkillDirsWithOurProvenance(skillsDir2) {
+  const names = await listDirectories(skillsDir2);
   const judged = await Promise.all(
-    names.map(async (name) => ({ name, ours: await carriesOurProvenance(skillsDir, name) }))
+    names.map(async (name) => ({ name, ours: await carriesOurProvenance(skillsDir2, name) }))
   );
   return judged.filter((entry) => entry.ours).map((entry) => entry.name);
 }
@@ -585,38 +621,38 @@ async function listDisplayPaths(dir, listEntries) {
   const entries = await listEntries(dir);
   return entries.map((entry) => displayDir(path2.join(dir, entry)));
 }
-async function validateSkillsDirectory(skillsDir, configuredIds) {
-  if (!await directoryExists(skillsDir)) return NOTHING_VALIDATED;
-  const skillDirs = await listDirectories(skillsDir);
+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(skillsDir, name, configuredIds)
+      ours: await isOurSkillDirectory(skillsDir2, name, configuredIds)
     }))
   );
   const [ours, foreign] = partition(judged, (entry) => entry.ours);
   const results = await Promise.all(
     ours.map(async ({ name }) => {
-      const skillDir = path2.join(skillsDir, name);
+      const skillDir = path2.join(skillsDir2, name);
       return toIssues(displayDir(skillDir), await validateInstalledSkill(skillDir));
     })
   );
   return {
     count: ours.length,
     issues: results.flat(),
-    notes: foreign.map(({ name }) => foreignSkillNote(skillsDir, name))
+    notes: foreign.map(({ name }) => foreignSkillNote(skillsDir2, name))
   };
 }
-async function isOurSkillDirectory(skillsDir, name, configuredIds) {
+async function isOurSkillDirectory(skillsDir2, name, configuredIds) {
   if (configuredIds.has(name)) return true;
-  return carriesOurProvenance(skillsDir, name);
+  return carriesOurProvenance(skillsDir2, name);
 }
-async function carriesOurProvenance(skillsDir, name) {
-  return await readForkedFromMetadata(path2.join(skillsDir, name)) !== null;
+async function carriesOurProvenance(skillsDir2, name) {
+  return await readForkedFromMetadata(path2.join(skillsDir2, name)) !== null;
 }
-function foreignSkillNote(skillsDir, name) {
-  return `${displayDir(path2.join(skillsDir, name))} \u2014 not installed by this CLI and named by no configuration here: not validated`;
+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;
@@ -631,39 +667,32 @@ async function validateAgentsDirectory(agentsDir) {
   return { count: agentFiles.length, issues: results.flat(), notes: [] };
 }
 async function validateInstalledSkill(skillDir) {
-  const skillMdPath = path2.join(skillDir, STANDARD_FILES.SKILL_MD);
-  const metadataPath = path2.join(skillDir, STANDARD_FILES.METADATA_YAML);
-  const errors = [];
-  const warnings = [];
-  if (!await fileExists(skillMdPath)) {
-    errors.push(`Missing ${STANDARD_FILES.SKILL_MD}`);
-  } else {
-    const frontmatterResult = await validateSkillFrontmatter(skillMdPath);
-    errors.push(...frontmatterResult.errors);
-    warnings.push(...frontmatterResult.warnings);
-  }
-  if (!await fileExists(metadataPath)) {
-    errors.push(`Missing ${STANDARD_FILES.METADATA_YAML}`);
-  } else {
-    const metadataResult = await validateInstalledSkillMetadata(metadataPath);
-    errors.push(...metadataResult.errors);
-    warnings.push(...metadataResult.warnings);
-  }
-  return { valid: errors.length === 0, errors, warnings };
+  const skillMd = await validateSkillFile(
+    skillDir,
+    STANDARD_FILES.SKILL_MD,
+    validateSkillFrontmatter
+  );
+  const metadata = await validateSkillFile(
+    skillDir,
+    STANDARD_FILES.METADATA_YAML,
+    validateInstalledSkillMetadata
+  );
+  return mergeValidationResults([skillMd, metadata]);
+}
+async function validateSkillFile(skillDir, fileName, validate) {
+  const filePath = path2.join(skillDir, fileName);
+  if (!await fileExists(filePath)) return invalidResult(`Missing ${fileName}`);
+  return validate(filePath);
 }
 async function validateInstalledSkillMetadata(metadataPath) {
   const read = await readSkillMetadata(metadataPath);
   if (!read.usable) {
-    return {
-      valid: false,
-      errors: [`${STANDARD_FILES.METADATA_YAML}: ${read.reason}`],
-      warnings: []
-    };
+    return invalidResult(`${STANDARD_FILES.METADATA_YAML}: ${read.reason}`);
   }
   const metadata = read.metadata;
   const result = validateSkillMetadata(metadata);
   if (result.success) {
-    return { valid: true, errors: [], warnings: [] };
+    return validResult();
   }
   const { errors, warnings } = splitMetadataValidationIssues(result.error, metadata);
   return {
@@ -675,20 +704,29 @@ async function validateInstalledSkillMetadata(metadataPath) {
 
 // src/cli/commands/doctor.ts
 import { countBy, unique } from "remeda";
-var CONFIG_TS_REL = `${CLAUDE_SRC_DIR}/${STANDARD_FILES.CONFIG_TS}`;
 async function resolveConfigState(detected, projectDir) {
-  if (detected?.config) return { kind: "loaded", config: detected.config };
-  const loaded = await loadProjectConfigFromDir(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 };
+  return declaresNoContent(loaded.config) ? { kind: "declares-nothing", config: loaded.config } : { kind: "loaded", config: loaded.config, inherited: false };
+}
+function inheritsTheGlobalConfig(readFrom, projectDir) {
+  return isHomeDirectory(readFrom) && !isHomeDirectory(projectDir);
 }
-function checkConfigValid(state) {
+function checkConfigValid(state, projectDir) {
+  const theConfig = (verdict) => configRowMessage(state, projectDir, verdict);
   if (state.kind === "absent") {
     return {
       result: {
         kind: "config",
         status: "fail",
-        message: `${CONFIG_TS_REL} not found`,
+        message: theConfig("not found"),
         details: [`Run '${CLI_INVOKE_COMMAND} init' to create a configuration`]
       },
       config: null
@@ -699,7 +737,7 @@ function checkConfigValid(state) {
       result: {
         kind: "config-empty",
         status: "warn",
-        message: `${CONFIG_TS_REL} is valid but declares no skills and no agents`
+        message: theConfig("is valid but declares no skills and no agents")
       },
       config: state.config
     };
@@ -711,7 +749,7 @@ function checkConfigValid(state) {
       result: {
         kind: "config",
         status: "fail",
-        message: `${CONFIG_TS_REL} has errors`,
+        message: theConfig("has errors"),
         details: validation.errors
       },
       config: null
@@ -722,7 +760,7 @@ function checkConfigValid(state) {
       result: {
         kind: "config",
         status: "warn",
-        message: `${CONFIG_TS_REL} has warnings`,
+        message: theConfig("has warnings"),
         details: validation.warnings
       },
       config
@@ -732,11 +770,29 @@ function checkConfigValid(state) {
     result: {
       kind: "config",
       status: "pass",
-      message: `${CONFIG_TS_REL} is valid`
+      message: theConfig("is valid")
     },
     config
   };
 }
+function configRowMessage(state, projectDir, verdict) {
+  if (state.kind === "loaded" && state.inherited)
+    return `${theInheritedConfig()}, which ${verdict}`;
+  return `${theOwnConfig(projectDir)} ${verdict}`;
+}
+function theOwnConfig(projectDir) {
+  return `${scopeLabel(scopeOf(projectDir))}: ${configNamedFrom(projectDir)}`;
+}
+function theInheritedConfig() {
+  return `${scopeLabel("project")}: no ${STANDARD_FILES.CONFIG_TS}, using ${scopeNoun("global")}'s (${configNamedFrom(os2.homedir())})`;
+}
+function scopeOf(dir) {
+  return isHomeDirectory(dir) ? "global" : "project";
+}
+function configNamedFrom(root) {
+  const relPath = relativeConfigPath(root, providerInUse(root));
+  return isHomeDirectory(root) ? `~/${relPath}` : relPath;
+}
 async function checkSkillsResolved(config, matrix2, projectDir) {
   const excludedIds = effectivelyExcludedSkillIds(config.skills);
   const stackIds = config.stack ? getStackSkillIds(config.stack) : [];
@@ -765,14 +821,14 @@ async function checkSkillsResolved(config, matrix2, projectDir) {
     return {
       kind: "skills",
       status: "fail",
-      message: `${uniqueSkills.length - missingSkills.length}/${uniqueSkills.length} skills found`,
+      message: `${ratio(uniqueSkills.length - missingSkills.length, uniqueSkills.length, "skill")} found`,
       details: missingSkills.map((s) => `- ${s} (not found)`)
     };
   }
   return {
     kind: "skills",
     status: "pass",
-    message: `${uniqueSkills.length}/${uniqueSkills.length} skills found`
+    message: `${ratio(uniqueSkills.length, uniqueSkills.length, "skill")} found`
   };
 }
 async function checkAgentsCompiled(config, projectDir) {
@@ -784,16 +840,28 @@ async function checkAgentsCompiled(config, projectDir) {
       message: "No agents configured"
     };
   }
-  const projectAgentsDir = resolveInstallPaths(projectDir, "project").agentsDir;
-  const globalAgentsDir = resolveInstallPaths(projectDir, "global").agentsDir;
+  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(async (agent) => {
-      const agentsDir = agent.scope === "global" ? globalAgentsDir : projectAgentsDir;
-      const agentPath = path3.join(agentsDir, `${agent.name}.md`);
-      return { name: agent.name, compiled: await fileExists(agentPath) };
-    })
+    agents.map((agent) => agentCompileCheck(agent, hosts, dirs))
   );
-  const missingAgents = agentChecks.filter((c) => !c.compiled).map((c) => c.name);
+  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) {
+    const hostsLeavingThemOut = unique(unrenderable.map((a) => a.provider)).join(" or ");
+    return {
+      kind: "agents",
+      status: "pass",
+      message: `No sub-agent in this configuration is carried by ${hostsLeavingThemOut}`,
+      details: unrenderable.map((a) => `- ${a.name} (left out of ${a.provider})`)
+    };
+  }
   if (missingAgents.length > 0) {
     return {
       kind: "agents",
@@ -802,13 +870,24 @@ async function checkAgentsCompiled(config, projectDir) {
       details: missingAgents.map((a) => `- ${a} (missing)`)
     };
   }
+  const renderable = agents.length - unrenderable.length;
   return {
     kind: "agents",
     status: "pass",
-    message: `${agents.length}/${agents.length} agents compiled`
+    message: `${ratio(renderable, renderable, "agent")} compiled`
   };
 }
+async function agentCompileCheck(agent, hosts, agentsDirs) {
+  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));
+  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);
@@ -823,8 +902,8 @@ async function checkNoOrphans(config, projectDir) {
       message: "No agents directory"
     };
   }
-  const projectMdFiles = projectExists ? await listAgentMdFiles(projectAgentsDir) : [];
-  const globalMdFiles = globalExists ? await listAgentMdFiles(globalAgentsDir) : [];
+  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)
   );
@@ -833,8 +912,8 @@ async function checkNoOrphans(config, projectDir) {
   );
   const knownProjectDirAgents = scopesShareAgentsDir ? /* @__PURE__ */ new Set([...activeProjectAgents, ...knownGlobalAgents]) : activeProjectAgents;
   const orphanedFiles = [
-    ...orphanedAgentNames(projectMdFiles, knownProjectDirAgents),
-    ...orphanedAgentNames(globalMdFiles, knownGlobalAgents)
+    ...orphanedAgentNames(projectMdFiles, knownProjectDirAgents, codec),
+    ...orphanedAgentNames(globalMdFiles, knownGlobalAgents, codec)
   ];
   if (orphanedFiles.length > 0) {
     return {
@@ -850,8 +929,8 @@ async function checkNoOrphans(config, projectDir) {
     message: "No orphaned agent files"
   };
 }
-function orphanedAgentNames(mdFiles, knownAgents) {
-  return mdFiles.map((fileName) => fileName.replace(/\.md$/, "")).filter((agentName) => !knownAgents.has(agentName));
+function orphanedAgentNames(mdFiles, knownAgents, codec) {
+  return mdFiles.map((fileName) => path3.basename(fileName, codec.extension)).filter((agentName) => !knownAgents.has(agentName));
 }
 async function checkUnownedInstallation(projectDir) {
   const { skills, agents } = await listInstalledArtifacts(projectDir);
@@ -865,6 +944,9 @@ async function checkUnownedInstallation(projectDir) {
     details: [...skills, ...agents].map((artifact) => `- ${artifact}`)
   };
 }
+function ratio(found, total, noun) {
+  return `${found}/${plural(total, noun)}`;
+}
 function countedArtifacts(skills, agents) {
   return [
     ...skills.length > 0 ? [plural(skills.length, "skill")] : [],
@@ -882,25 +964,31 @@ async function checkSkillsInstalled(config, projectDir) {
     };
   }
   const skillChecks = await Promise.all(
-    ejectSkills.map(async (skill) => {
-      const baseDir = installBaseDir(projectDir, skill.scope);
-      const skillMdPath = path3.join(baseDir, LOCAL_SKILLS_PATH, skill.id, STANDARD_FILES.SKILL_MD);
-      return { id: skill.id, installed: await fileExists(skillMdPath) };
-    })
+    ejectSkills.map((skill) => ejectedSkillCheck(skill, projectDir))
   );
-  const missingSkills = skillChecks.filter((c) => !c.installed).map((c) => c.id);
+  const missingSkills = skillChecks.filter((c) => !c.installed);
   if (missingSkills.length > 0) {
     return {
       kind: "installed",
       status: "warn",
       message: `${plural(missingSkills.length, "skill")} missing from disk`,
-      details: missingSkills.map((s) => `- ${s} (not found in ${LOCAL_SKILLS_PATH}/)`)
+      details: missingSkills.map((s) => `- ${s.id} (not found in ${s.lookedIn}/)`)
     };
   }
   return {
     kind: "installed",
     status: "pass",
-    message: `${ejectSkills.length}/${ejectSkills.length} eject-mode skills installed`
+    message: `${ratio(ejectSkills.length, ejectSkills.length, "eject-mode skill")} installed`
+  };
+}
+async function ejectedSkillCheck(skill, projectDir) {
+  const provider = providerInUse(installBaseDir(projectDir, skill.scope));
+  const dir = skillsDir(provider, skill.scope, projectDir);
+  const installed = await fileExists(path3.join(dir, skill.id, STANDARD_FILES.SKILL_MD));
+  return {
+    id: skill.id,
+    installed,
+    lookedIn: skillsPathPrefix(provider, skill.scope, projectDir)
   };
 }
 async function checkPluginSkillsInstalled(config, projectDir) {
@@ -935,7 +1023,7 @@ async function checkPluginSkillsInstalled(config, projectDir) {
   return {
     kind: "plugins",
     status: "pass",
-    message: `${pluginSkills.length}/${pluginSkills.length} plugin-mode skills installed`
+    message: `${ratio(pluginSkills.length, pluginSkills.length, "plugin-mode skill")} installed`
   };
 }
 var MARKETPLACE_CHOSEN_BY = {
@@ -950,7 +1038,7 @@ function howItWasReached(source, isLocal) {
 }
 function reachedMarketplace(result) {
   const { source, sourceOrigin } = result.sourceConfig;
-  const skillCount = Object.keys(matrix.skills).length;
+  const skillCount = result.marketplaceSkillIds.size;
   const sourceLabel = result.isLocal ? "local" : "remote";
   return {
     kind: "source",
@@ -1069,9 +1157,6 @@ var SKIP_AFTER_CONFIG_ERROR = "Skipped \u2014 fix the content errors above first
 function skipRestatingContent(nouns) {
   return `Skipped \u2014 this row would only restate the ${nouns.join(" and ")} errors above`;
 }
-function plural(count, word) {
-  return `${count} ${word}${count === 1 ? "" : "s"}`;
-}
 function formatCheckName(name) {
   return name.padEnd(CHECK_WIDTH);
 }
@@ -1091,13 +1176,15 @@ function formatStatus(status) {
     }
   }
 }
+var DETAIL_INDENT = `${ROW_INDENT}${" ".repeat(CHECK_WIDTH)}   `;
 function formatCheckLine(name, result) {
   const headerLine = `${ROW_INDENT}${formatCheckName(name)}${formatStatus(result.status)}  ${result.message}`;
-  const detailLines = (result.details ?? []).map(
-    (detail) => `${ROW_INDENT}${" ".repeat(CHECK_WIDTH)}   ${detail}`
-  );
+  const detailLines = (result.details ?? []).flatMap(indentedDetailLines);
   return [headerLine, ...detailLines];
 }
+function indentedDetailLines(detail) {
+  return detail.split("\n").filter((line) => line !== "").map((line) => `${DETAIL_INDENT}${line}`);
+}
 function formatSummary(results) {
   const counts = countBy(results, (r) => r.status);
   const parts = [
@@ -1126,14 +1213,6 @@ var TIPS = [
     status: "warn",
     tip: `  Tip: Nothing is configured yet \u2014 run '${CLI_INVOKE_COMMAND} init' to choose skills and sub-agents`
   },
-  {
-    // The one remedy that applies to a config that cannot be read. `init` does not clear such a
-    // file — it refuses it — so the tip above would send the reader in a circle; this is the same
-    // way out `edit` and `init` themselves name, worded the same way.
-    kind: "content-config",
-    status: "fail",
-    tip: `  Tip: There is no automatic repair \u2014 recreate the configuration: '${CLI_INVOKE_COMMAND} uninstall' still works on a config it cannot read, then '${CLI_INVOKE_COMMAND} init'`
-  },
   {
     // 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
@@ -1163,6 +1242,41 @@ function formatTips(results) {
     (t) => t.tip
   );
 }
+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)}`
+  );
+}
+var LAYOUT_ROW_NAME = "Layout";
+function toLayoutResult(scope) {
+  return {
+    kind: "layout",
+    status: "pass",
+    message: layoutIsCurrent(scopeLabel(scope.kind), scope.relName)
+  };
+}
+var PLACEMENTS_ROW_NAME = "Placements Offered";
+async function checkOfferedPlacements(projectDir) {
+  const findings = await everythingThatWouldStopACommandActing(projectDir);
+  if (findings.length === 0) {
+    return { kind: "placements", status: "pass", message: "Every configured skill is placeable" };
+  }
+  return {
+    kind: "placements",
+    status: "fail",
+    message: `${plural(findings.length, "finding")} would stop a command acting here`,
+    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)" };
 }
@@ -1202,7 +1316,7 @@ var Doctor = class _Doctor extends BaseCommand {
     const contentResults = await this.runContentChecks(projectDir);
     const operationalResults = await this.runOperationalChecks(projectDir, contentResults);
     const results = [...contentResults, ...operationalResults];
-    this.printResults(results);
+    this.printResults(results, await recreateConfigTips(contentResults, projectDir));
     if (results.some((r) => r.status === "fail")) {
       this.exit(EXIT_CODES.ERROR);
     }
@@ -1265,12 +1379,18 @@ var Doctor = class _Doctor extends BaseCommand {
    * at all, not merely no usable one.
    */
   async isUninstalledSourceRepo(projectDir) {
-    if (await fileExists(getProjectConfigPath(projectDir))) return false;
+    if (await fileExists(getInstalledConfigPath(projectDir))) return false;
     return isSourceRepo(projectDir);
   }
   async runAllChecks(projectDir, configState, failedContent) {
-    const { result: configResult, config } = checkConfigValid(configState);
+    const { result: configResult, config } = checkConfigValid(configState, projectDir);
     this.logCheck("Config Valid", configResult);
+    const layoutResults = await this.reportLayout(projectDir);
+    const placementsResult = await safeCheck(
+      "placements",
+      () => checkOfferedPlacements(projectDir)
+    );
+    this.logCheck(PLACEMENTS_ROW_NAME, placementsResult);
     const sourceResult = await safeCheck("source", () => checkSourceReachable(projectDir));
     const filteredConfig = config ? filterExcludedEntries(config) : null;
     const skillsResult = await this.resolveSkillsCheck(
@@ -1291,6 +1411,8 @@ var Doctor = class _Doctor extends BaseCommand {
     this.logCheck("Marketplace Reachable", sourceResult);
     return [
       configResult,
+      ...layoutResults,
+      placementsResult,
       skillsResult,
       agentsResult,
       orphansResult,
@@ -1299,6 +1421,22 @@ 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);
+    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
@@ -1342,10 +1480,10 @@ var Doctor = class _Doctor extends BaseCommand {
       this.log(line);
     }
   }
-  printResults(results) {
+  printResults(results, recreateTips) {
     this.log("");
     this.log(formatSummary(results));
-    const tips = formatTips(results);
+    const tips = [...formatTips(results), ...recreateTips];
     if (tips.length > 0) {
       this.log("");
       for (const tip of tips) {