agents-inc 0.164.0 → 0.165.0

package/dist/commands/doctor.js

@@ -1,105 +1,189 @@
 #!/usr/bin/env node
+import {
+  unofferablePlacementsFound
+} from "../chunk-IVNKU4DM.js";
 import {
   detectProject,
   loadSource
-} from "../chunk-X37UYIE3.js";
-import "../chunk-2CQNPLVF.js";
-import "../chunk-B6FSLXYN.js";
+} from "../chunk-WTANOSXK.js";
+import "../chunk-WIFIAQZU.js";
+import "../chunk-42TNV2TK.js";
+import "../chunk-UR3RRTPO.js";
 import {
   filterExcludedEntries,
+  listAgentFilesOf,
   listAgentMdFiles,
   splitAgentsByProvenance
-} from "../chunk-JU4ZGJ7A.js";
+} from "../chunk-V5CWACR5.js";
+import {
+  ambiguityFinding
+} from "../chunk-MBUGQI2M.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-JIERYE6B.js";
-import "../chunk-NKGYKOB7.js";
-import "../chunk-PHCPUQVR.js";
+} from "../chunk-AAWZED5M.js";
+import "../chunk-6CY6PW5X.js";
+import "../chunk-CTUJO23Z.js";
 import {
   ConfigDefaultExportError,
+  MarketplaceManifestRequiredError,
   MarketplaceNameRefusedError,
+  REGISTRY_IS_NOT_AN_INVENTORY,
   SOURCE_ENV_VAR,
+  agentCodec,
   agentYamlGenerationSchema,
+  bothSourceFoldersPresent,
   checkMatrixHealth,
+  compiledAgentNamesTheOtherFolder,
   configDirsInPlay,
   declaresNoContent,
   directoryExists,
   discoverLocalSkills,
   fileExists,
   findConfigLoadFailures,
+  folderBeingRead,
   formatZodErrors,
   getErrorMessage,
+  getInstalledConfigPath,
   getInstalledPluginsRegistryPath,
-  getProjectConfigPath,
   getProjectPluginsDir,
   getStackSkillIds,
   getUserPluginsDir,
   getVerifiedPluginInstallPaths,
   glob,
+  hostCompilesAgent,
   installBaseDir,
+  invalidResult,
   isHomeDirectory,
   isLocalSource,
   isRecord,
+  layoutIsCurrent,
+  layoutIsLegacy,
   listDirectories,
   listRegisteredPluginInstalls,
   loadConfig,
-  loadProjectConfigFromDir,
-  loadProjectSourceConfig,
+  loadInstalledConfig,
   loadSkillsMatrixFromSource,
+  loadSourceRepoConfig,
+  mergeValidationResults,
   metadataValidationSchema,
   parseFrontmatter,
   parseMarketplacePluginRef,
+  plural,
+  providerInUse,
   readFile,
   readForkedFromMetadata,
   readSkillMetadata,
+  recreateConfigFrom,
+  relativeConfigPath,
   resolveInstallPaths,
   resolvePrimarySourceEntry,
+  resolveSourceDir,
+  scopeLabel,
+  scopeNoun,
   skillCategoriesFileSchema,
   skillRulesFileSchema,
+  skillsDir,
+  skillsPathPrefix,
+  sourceScopesInPlay,
   splitMetadataValidationIssues,
   stackConfigValidationSchema,
   stacksConfigSchema,
+  unusedSourceFolderName,
+  validResult,
   validateAgentFrontmatter,
   validateAllPlugins,
   validatePlugin,
   validateProjectConfig,
   validateSkillFrontmatter,
   validateSkillMetadata
-} from "../chunk-XPDVAJDH.js";
+} from "../chunk-IM45LLQX.js";
 import {
   matrix
-} from "../chunk-AVK2HEKB.js";
+} from "../chunk-GKPW33FP.js";
 import {
-  CLAUDE_SRC_DIR,
+  CLAUDE_DIR,
   CLI_INVOKE_COMMAND,
   DEFAULT_BRANDING,
   DIRS,
   EJECT_SOURCE,
-  LOCAL_SKILLS_PATH,
   MARKETPLACE_JSON,
   PLUGIN_MANIFEST_DIR,
   SKILLS_DIR_PATH,
   SKILL_CATEGORIES_PATH,
   SKILL_RULES_PATH,
   STACKS_FILE_PATH,
+  STANDARD_DIRS,
   STANDARD_FILES,
   UI_SYMBOLS,
   effectivelyExcludedSkillIds
-} from "../chunk-UITEKY2R.js";
+} from "../chunk-AQXKAPCD.js";
 import "../chunk-OI2H6M5I.js";
 
 // src/cli/commands/doctor.ts
 import os2 from "os";
-import path3 from "path";
+import path4 from "path";
 
-// src/cli/lib/source-validator.ts
+// src/cli/lib/installation/layout-findings.ts
 import path from "path";
+async function layoutFindingFor(scope) {
+  const { move } = scope;
+  const label = scopeLabel(scope.kind);
+  if (move === null) {
+    return { status: "pass", message: layoutIsCurrent(label, scope.relName), details: [] };
+  }
+  const whichLayout = layoutStatement(scope, move, label);
+  const faults = await faultsFor(scope, move);
+  const [worst, ...rest] = faults;
+  if (worst === void 0) return { ...whichLayout, details: [] };
+  return {
+    status: "fail",
+    message: `${label}: ${worst}`,
+    details: [...rest.map((fault) => `${label}: ${fault}`), whichLayout.message]
+  };
+}
+function layoutStatement(scope, move, label) {
+  if (!scope.legacy) return { status: "pass", message: layoutIsCurrent(label, move.to.relName) };
+  return { status: "warn", message: layoutIsLegacy(label, move.from.relName, move.to.relName) };
+}
+async function faultsFor(scope, move) {
+  const staleAgents = await compiledAgentsNamingTheOtherFolder(scope);
+  return [...rivalFolderFault(scope, move), ...staleAgents];
+}
+function rivalFolderFault(scope, move) {
+  if (!scope.both) return [];
+  return [
+    bothSourceFoldersPresent(move.from.relName, move.to.relName, folderBeingRead(scope, move))
+  ];
+}
+async function compiledAgentsNamingTheOtherFolder(scope) {
+  const unused = unusedSourceFolderName(scope.root, scope.provider);
+  if (unused === null) return [];
+  const agentsDir = path.join(scope.root, CLAUDE_DIR, STANDARD_DIRS.AGENTS);
+  const files = await listAgentMdFiles(agentsDir);
+  const named = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      names: await namesFolder(path.join(agentsDir, file), unused)
+    }))
+  );
+  return named.filter((entry) => entry.names).map((entry) => compiledAgentNamesTheOtherFolder(entry.file, unused));
+}
+async function namesFolder(agentPath, folder) {
+  try {
+    return (await readFile(agentPath)).includes(folder);
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/lib/source-validator.ts
+import path2 from "path";
 import { parse as parseYaml } from "yaml";
 import "zod";
 async function isSourceRepo(dir) {
-  const sourceConfig = await loadProjectSourceConfig(dir);
-  return directoryExists(path.join(dir, sourceConfig?.skillsDir ?? SKILLS_DIR_PATH));
+  const sourceConfig = await loadSourceRepoConfig(dir);
+  return directoryExists(path2.join(dir, sourceConfig?.skillsDir ?? SKILLS_DIR_PATH));
 }
 function isSnakeCase(key) {
   return /[a-z]_[a-z]/.test(key);
@@ -122,11 +206,11 @@ function checkDirNameMatchesSkillId(skillId, relPath, dirName) {
     }
   ];
 }
-async function checkSkillDirName(skillsDir, skillsDirRelPath, skillDir) {
-  const dirName = path.basename(skillDir);
-  const skillMdRelPath = path.join(skillsDirRelPath, skillDir, STANDARD_FILES.SKILL_MD);
+async function checkSkillDirName(skillsDir2, skillsDirRelPath, skillDir) {
+  const dirName = path2.basename(skillDir);
+  const skillMdRelPath = path2.join(skillsDirRelPath, skillDir, STANDARD_FILES.SKILL_MD);
   try {
-    const content = await readFile(path.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD));
+    const content = await readFile(path2.join(skillsDir2, skillDir, STANDARD_FILES.SKILL_MD));
     const frontmatter = parseFrontmatter(content, skillMdRelPath);
     if (frontmatter === null) {
       return [
@@ -148,67 +232,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: path2.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: path2.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);
+  const resolvedPath = path2.isAbsolute(sourcePath) ? sourcePath : path2.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 skillMdFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
-  const metadataFiles = await glob(`**/${STANDARD_FILES.METADATA_YAML}`, skillsDir);
-  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 validMetadataFiles = metadataFiles.filter((f) => skillMdDirs.has(path.dirname(f)));
-  for (const metadataFile of validMetadataFiles) {
-    issues.push(...await validateOneSkill(skillsDir, skillsDirRelPath, metadataFile));
+  const skillsDir2 = path2.join(resolvedPath, skillsDirRelPath);
+  if (!await directoryExists(skillsDir2)) {
+    return buildResult(
+      [{ severity: "error", file: skillsDir2, message: "Skills directory does not exist" }],
+      0
+    );
   }
-  issues.push(...await checkCrossReferences(resolvedPath, reader));
+  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) => path2.dirname(f)));
+  const metadataDirs = new Set(metadataFiles.map((f) => path2.dirname(f)));
+  const pairIssues = validateSkillFilePairs(skillMdDirs, metadataDirs, skillsDir2);
+  const validMetadataFiles = metadataFiles.filter((f) => skillMdDirs.has(path2.dirname(f)));
+  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) {
-  const relPath = path.join(skillsDirRelPath, metadataFile);
+async function validateOneSkill(skillsDir2, skillsDirRelPath, metadataFile) {
+  const relPath = path2.join(skillsDirRelPath, metadataFile);
   let rawMetadata;
   try {
-    rawMetadata = parseYaml(await readFile(path.join(skillsDir, metadataFile)));
+    rawMetadata = parseYaml(await readFile(path2.join(skillsDir2, metadataFile)));
   } catch (error) {
     return [{ severity: "error", file: relPath, message: yamlParseFailure(error) }];
   }
@@ -216,7 +302,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, path2.dirname(metadataFile))
   ];
 }
 function checkMetadataSchema(rawMetadata, relPath) {
@@ -228,7 +314,11 @@ function checkMetadataSchema(rawMetadata, relPath) {
     ...warnings.map((message) => ({ severity: "warning", file: relPath, message }))
   ];
 }
-var MARKETPLACE_MANIFEST_PATH = path.join(PLUGIN_MANIFEST_DIR, MARKETPLACE_JSON);
+var MARKETPLACE_MANIFEST_PATH = path2.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 +326,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",
@@ -290,7 +387,7 @@ function consumedMarketplaceMessage(marketplacePath, details) {
   return `Marketplace '${marketplacePath}': ${details}. Nothing to fix here \u2014 the rule is that marketplace's, not this project's`;
 }
 async function validateStacks(resolvedPath) {
-  const stacksDir = path.join(resolvedPath, DIRS.stacks);
+  const stacksDir = path2.join(resolvedPath, DIRS.stacks);
   if (!await directoryExists(stacksDir)) return [];
   const [skillMetaIssues, configIssues] = await Promise.all([
     validateYamlFiles({
@@ -309,7 +406,7 @@ async function validateStacks(resolvedPath) {
   return [...skillMetaIssues, ...configIssues];
 }
 async function validateAgents(resolvedPath) {
-  const agentsDir = path.join(resolvedPath, DIRS.agents);
+  const agentsDir = path2.join(resolvedPath, DIRS.agents);
   if (!await directoryExists(agentsDir)) return [];
   return validateYamlFiles({
     baseDir: agentsDir,
@@ -326,33 +423,32 @@ 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 = path2.join(scan.relBaseDir, relFile);
+  let parsed;
+  try {
+    parsed = parseYaml(await readFile(path2.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);
+  const absPath = path2.join(resolvedPath, relConfigPath);
   if (!await fileExists(absPath)) return [];
   try {
     const loaded = await loadConfig(absPath, schema);
@@ -382,7 +478,7 @@ function buildResult(issues, skillCount) {
 
 // src/cli/lib/content-validator.ts
 import os from "os";
-import path2 from "path";
+import path3 from "path";
 import { partition } from "remeda";
 var CWD_SOURCE_NAME = "current directory";
 var AGENT_FILE_EXTENSION = ".md";
@@ -400,8 +496,8 @@ function mergeValidations(parts) {
 function displayDir(absolutePath) {
   const home = os.homedir();
   if (absolutePath === home) return "~";
-  if (absolutePath.startsWith(home + path2.sep)) {
-    return `~${path2.sep}${path2.relative(home, absolutePath)}`;
+  if (absolutePath.startsWith(home + path3.sep)) {
+    return `~${path3.sep}${path3.relative(home, absolutePath)}`;
   }
   return absolutePath;
 }
@@ -422,13 +518,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;
 }
@@ -456,7 +552,7 @@ async function localSourcesToValidate(projectDir, registered) {
   return [...local, { name: CWD_SOURCE_NAME, url: projectDir }];
 }
 function isCwdMarketplace(projectDir, source) {
-  return path2.resolve(projectDir, source.url) === projectDir;
+  return path3.resolve(projectDir, source.url) === projectDir;
 }
 function readerFor(projectDir, source) {
   return isCwdMarketplace(projectDir, source) ? "author" : "consumer";
@@ -465,7 +561,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`,
@@ -525,7 +621,7 @@ async function findPluginDirectories(pluginsDir) {
   const checks = await Promise.all(
     entries.map(async (name) => ({
       name,
-      isPlugin: await directoryExists(path2.join(pluginsDir, name, PLUGIN_MANIFEST_DIR))
+      isPlugin: await directoryExists(path3.join(pluginsDir, name, PLUGIN_MANIFEST_DIR))
     }))
   );
   return checks.filter((check) => check.isPlugin).map((check) => check.name);
@@ -541,7 +637,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 +667,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);
 }
@@ -583,40 +681,40 @@ async function listAcrossScopes(dirs, listEntries) {
 async function listDisplayPaths(dir, listEntries) {
   if (!await directoryExists(dir)) return [];
   const entries = await listEntries(dir);
-  return entries.map((entry) => displayDir(path2.join(dir, entry)));
+  return entries.map((entry) => displayDir(path3.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 = path3.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(path3.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(path3.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;
@@ -624,46 +722,39 @@ async function validateAgentsDirectory(agentsDir) {
   if (agentFiles.length === 0) return NOTHING_VALIDATED;
   const results = await Promise.all(
     agentFiles.map(async (fileName) => {
-      const agentPath = path2.join(agentsDir, fileName);
+      const agentPath = path3.join(agentsDir, fileName);
       return toIssues(displayDir(agentPath), await validateAgentFrontmatter(agentPath));
     })
   );
   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 = path3.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 +766,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 +799,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 +811,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 +822,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 +832,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 +883,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 +902,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 +932,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(path4.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 +964,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 +974,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 +991,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) => path4.basename(fileName, codec.extension)).filter((agentName) => !knownAgents.has(agentName));
 }
 async function checkUnownedInstallation(projectDir) {
   const { skills, agents } = await listInstalledArtifacts(projectDir);
@@ -865,6 +1006,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 +1026,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(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) {
@@ -935,7 +1085,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 +1100,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 +1219,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 +1238,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 +1275,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 +1304,49 @@ 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(finding) {
+  return {
+    kind: "layout",
+    status: finding.status,
+    message: finding.message,
+    details: finding.details
+  };
+}
+async function registeredProjectsOnTheOldFolder(home) {
+  const loaded = await loadInstalledConfig(home).catch(() => null);
+  return (loaded?.config.projects ?? []).filter(isOnTheLegacySourceFolder);
+}
+function isOnTheLegacySourceFolder(dir) {
+  return resolveSourceDir(dir, providerInUse(dir)).legacy;
+}
+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 +1386,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 +1449,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 +1481,8 @@ var Doctor = class _Doctor extends BaseCommand {
     this.logCheck("Marketplace Reachable", sourceResult);
     return [
       configResult,
+      ...layoutResults,
+      placementsResult,
       skillsResult,
       agentsResult,
       orphansResult,
@@ -1299,6 +1491,49 @@ var Doctor = class _Doctor extends BaseCommand {
       sourceResult
     ];
   }
+  /**
+   * One `Layout` row per scope in play, and — at the home directory — the registered projects
+   * still on the old folder.
+   *
+   * Per scope rather than per machine: a project and the global installation can be on different
+   * layouts, and one row for the two can only be right about one of them.
+   *
+   * Printed right under `Config Valid`, because every row below it is read out of a config file
+   * whose folder this row is about — a scope with two rival folders has a config the rest of the
+   * report may have read from either one.
+   */
+  async reportLayout(projectDir) {
+    const scopes = await sourceScopesInPlay(projectDir);
+    const rows = await Promise.all(
+      scopes.map(async (scope) => toLayoutResult(await layoutFindingFor(scope)))
+    );
+    const withRegistry = await this.appendRegistryList(projectDir, rows);
+    for (const row of withRegistry) {
+      this.logCheck(LAYOUT_ROW_NAME, row);
+    }
+    return withRegistry;
+  }
+  /**
+   * The registered projects still on the old folder, added to the LAST row, and only at HOME.
+   *
+   * At home because that is where the registry lives, and the move a legacy project needs is made
+   * by hand in that project — a list of other people's projects printed inside one of them is a
+   * list nobody standing there can act on. The caveat travels with it: the registry holds a
+   * fraction of the installations on a machine, so a list printed without it reads as an
+   * inventory.
+   */
+  async appendRegistryList(projectDir, rows) {
+    const last = rows.at(-1);
+    if (!isHomeDirectory(projectDir) || last === void 0) return rows;
+    const legacyProjects = await registeredProjectsOnTheOldFolder(projectDir);
+    if (legacyProjects.length === 0) return rows;
+    const detailed = {
+      ...last,
+      status: last.status === "fail" ? "fail" : "warn",
+      details: [...last.details ?? [], REGISTRY_IS_NOT_AN_INVENTORY, ...legacyProjects]
+    };
+    return [...rows.slice(0, -1), detailed];
+  }
   /**
    * 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 +1577,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) {