agents-inc 0.153.0 → 0.155.0

package/dist/commands/doctor.js

@@ -2,21 +2,23 @@
 import {
   detectProject,
   loadSource
-} from "../chunk-F7Z5I6GU.js";
-import "../chunk-REKOWTIB.js";
-import "../chunk-NXGMM5YN.js";
-import "../chunk-FRWKCE6R.js";
+} from "../chunk-WUQ3MTPF.js";
+import "../chunk-5QZAK6J7.js";
+import "../chunk-MHRC3KRX.js";
+import "../chunk-F2AMBBIA.js";
 import {
   filterExcludedEntries,
-  listAgentMdFiles
-} from "../chunk-FIHTAFST.js";
+  listAgentMdFiles,
+  splitAgentsByProvenance
+} from "../chunk-ZUAZHDKP.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-X5XJ6WKO.js";
-import "../chunk-TY6CAOL7.js";
-import "../chunk-K3O3YQYG.js";
+} from "../chunk-YO2LTXB4.js";
+import "../chunk-UMH2YZKG.js";
+import "../chunk-G47TDUK3.js";
 import {
+  ConfigDefaultExportError,
   checkMatrixHealth,
   configDirsInPlay,
   declaresNoContent,
@@ -32,13 +34,13 @@ import {
   installBaseDir,
   isHomeDirectory,
   isLocalSource,
-  isRecord,
   listRegisteredPluginInstalls,
   loadConfig,
   loadProjectConfigFromDir,
   loadProjectSourceConfig,
   loadSkillsMatrixFromSource,
   parseMarketplacePluginRef,
+  readForkedFromMetadata,
   resolveInstallPaths,
   resolvePrimarySourceEntry,
   validateAgentFrontmatter,
@@ -46,7 +48,7 @@ import {
   validatePlugin,
   validateProjectConfig,
   validateSkillFrontmatter
-} from "../chunk-NXQAY5U7.js";
+} from "../chunk-WCAUUBHO.js";
 import {
   agentYamlGenerationSchema,
   directoryExists,
@@ -54,6 +56,7 @@ import {
   formatZodErrors,
   getErrorMessage,
   glob,
+  isRecord,
   listDirectories,
   metadataValidationSchema,
   parseFrontmatter,
@@ -66,10 +69,10 @@ import {
   stackConfigValidationSchema,
   stacksConfigSchema,
   validateSkillMetadata
-} from "../chunk-U2YSGBHA.js";
+} from "../chunk-XAXJWXI4.js";
 import {
   matrix
-} from "../chunk-35VOK7XE.js";
+} from "../chunk-RWOYPOMR.js";
 import "../chunk-VASLW636.js";
 import {
   CLAUDE_SRC_DIR,
@@ -85,7 +88,7 @@ import {
   STACKS_FILE_PATH,
   STANDARD_FILES,
   UI_SYMBOLS
-} from "../chunk-R54KIGN2.js";
+} from "../chunk-IO5YBKHV.js";
 import "../chunk-VZRO7RYT.js";
 
 // src/cli/commands/doctor.ts
@@ -160,14 +163,14 @@ function validateSkillFilePairs(skillMdDirs, metadataDirs, skillsDir) {
   }));
   return [...missingMetadata, ...missingSkillMd];
 }
-async function validateSource(sourcePath) {
+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: "Source directory does not exist"
+      message: "Marketplace directory does not exist"
     });
     return buildResult(issues, 0);
   }
@@ -191,7 +194,7 @@ async function validateSource(sourcePath) {
   for (const metadataFile of validMetadataFiles) {
     issues.push(...await validateOneSkill(skillsDir, skillsDirRelPath, metadataFile));
   }
-  issues.push(...await checkCrossReferences(resolvedPath));
+  issues.push(...await checkCrossReferences(resolvedPath, reader));
   const extraIssues = await Promise.all([
     validateStacks(resolvedPath),
     validateAgents(resolvedPath),
@@ -200,19 +203,16 @@ async function validateSource(sourcePath) {
   issues.push(...extraIssues.flat());
   return buildResult(issues, validMetadataFiles.length);
 }
+function yamlParseFailure(error) {
+  return `Failed to parse YAML: ${getErrorMessage(error)}`;
+}
 async function validateOneSkill(skillsDir, skillsDirRelPath, metadataFile) {
   const relPath = path.join(skillsDirRelPath, metadataFile);
   let rawMetadata;
   try {
     rawMetadata = parseYaml(await readFile(path.join(skillsDir, metadataFile)));
   } catch (error) {
-    return [
-      {
-        severity: "error",
-        file: relPath,
-        message: `Failed to parse YAML: ${getErrorMessage(error)}`
-      }
-    ];
+    return [{ severity: "error", file: relPath, message: yamlParseFailure(error) }];
   }
   return [
     ...checkSnakeCaseKeys(rawMetadata, relPath),
@@ -230,14 +230,12 @@ function checkMetadataSchema(rawMetadata, relPath) {
     ...warnings.map((message) => ({ severity: "warning", file: relPath, message }))
   ];
 }
-async function checkCrossReferences(resolvedPath) {
+async function checkCrossReferences(resolvedPath, reader) {
   try {
     await loadSkillsMatrixFromSource({ sourceFlag: resolvedPath, skipExtraSources: true });
-    return checkMatrixHealth(matrix).map((healthIssue) => ({
-      severity: healthIssue.severity,
-      file: SKILL_CATEGORIES_PATH,
-      message: healthIssue.details
-    }));
+    return checkMatrixHealth(matrix).map(
+      (healthIssue) => toSourceIssue(healthIssue, resolvedPath, reader)
+    );
   } catch (error) {
     return [
       {
@@ -248,6 +246,42 @@ async function checkCrossReferences(resolvedPath) {
     ];
   }
 }
+var SKILL_AUDIT_PATH = "src/cli/lib/configuration/skill-audit.ts";
+function fileHoldingDefect(finding) {
+  switch (finding) {
+    case "category-missing-domain":
+    case "skill-unknown-category":
+      return SKILL_CATEGORIES_PATH;
+    case "skill-unresolved-relation-ref":
+    case "rule-unresolved-slug":
+      return SKILL_RULES_PATH;
+    case "audit-verdict-contradiction":
+    case "skill-unaudited":
+      return SKILL_AUDIT_PATH;
+    default: {
+      const exhaustive = finding;
+      return exhaustive;
+    }
+  }
+}
+function toSourceIssue(healthIssue, marketplacePath, reader) {
+  const file = fileHoldingDefect(healthIssue.finding);
+  if (reader === "consumer" && healthIssue.finding === "rule-unresolved-slug") {
+    return {
+      severity: "warning",
+      file,
+      message: consumedMarketplaceMessage(marketplacePath, healthIssue.details)
+    };
+  }
+  return {
+    severity: healthIssue.severity,
+    file,
+    message: healthIssue.details
+  };
+}
+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);
   if (!await directoryExists(stacksDir)) return [];
@@ -294,8 +328,8 @@ async function validateYamlFiles(opts) {
     let parsed;
     try {
       parsed = parseYaml(await readFile(absPath));
-    } catch {
-      issues.push({ severity: "error", file: displayPath, message: "Failed to parse YAML" });
+    } catch (error) {
+      issues.push({ severity: "error", file: displayPath, message: yamlParseFailure(error) });
       continue;
     }
     const result = opts.schema.safeParse(parsed);
@@ -316,10 +350,13 @@ async function validateTsConfig(resolvedPath, relConfigPath, schema) {
   try {
     const loaded = await loadConfig(absPath, schema);
     if (loaded === null) {
-      return [{ severity: "error", file: relConfigPath, message: "Config has no default export" }];
+      return [{ severity: "error", file: relConfigPath, message: "Config is empty" }];
     }
     return [];
   } catch (error) {
+    if (error instanceof ConfigDefaultExportError) {
+      return [{ severity: "error", file: relConfigPath, message: "Config has no default export" }];
+    }
     return [
       { severity: "error", file: relConfigPath, message: formatLoadError(relConfigPath, error) }
     ];
@@ -339,7 +376,9 @@ 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(
@@ -391,28 +430,34 @@ async function validateRegisteredSources(projectDir) {
   const registered = [primary];
   const remote = registered.filter((source) => !isLocalSource(source.url));
   const local = await localSourcesToValidate(projectDir, registered);
-  const outcomes = await Promise.all(local.map(validateOneSource));
+  const outcomes = await Promise.all(
+    local.map((source) => validateOneSource(source, readerFor(projectDir, source)))
+  );
   return {
     count: local.length,
     issues: outcomes.flatMap((outcome) => outcome.issues),
     notes: [
       ...outcomes.map((outcome) => outcome.note),
-      ...remote.map((source) => `${source.name} (${source.url}) \u2014 skipped (remote source)`)
+      ...remote.map((source) => `${source.name} (${source.url}) \u2014 skipped (remote)`)
     ]
   };
 }
 async function localSourcesToValidate(projectDir, registered) {
   const local = registered.filter((source) => isLocalSource(source.url));
-  const alreadyCovered = local.some(
-    (source) => path2.resolve(projectDir, source.url) === projectDir
-  );
+  const alreadyCovered = local.some((source) => isCwdMarketplace(projectDir, source));
   if (alreadyCovered || !await isSourceRepo(projectDir)) return local;
   return [...local, { name: CWD_SOURCE_NAME, url: projectDir }];
 }
-async function validateOneSource(source) {
+function isCwdMarketplace(projectDir, source) {
+  return path2.resolve(projectDir, source.url) === projectDir;
+}
+function readerFor(projectDir, source) {
+  return isCwdMarketplace(projectDir, source) ? "author" : "consumer";
+}
+async function validateOneSource(source, reader) {
   const label = `${source.name} (${source.url})`;
   try {
-    const result = await validateSource(source.url);
+    const result = await validateSource(source.url, reader);
     return { note: `${label} \u2014 ${result.skillCount} skills`, issues: result.issues };
   } catch (error) {
     return {
@@ -479,10 +524,23 @@ async function findPluginDirectories(pluginsDir) {
   return checks.filter((check) => check.isPlugin).map((check) => check.name);
 }
 async function validateInstalledSkills(projectDir) {
+  const configuredIds = await configuredSkillIds(projectDir);
   return mergeValidations(
-    await Promise.all(installedDirs(projectDir, "skillsDir").map(validateSkillsDirectory))
+    await Promise.all(
+      installedDirs(projectDir, "skillsDir").map(
+        (dir) => validateSkillsDirectory(dir, configuredIds)
+      )
+    )
   );
 }
+async function configuredSkillIds(projectDir) {
+  const loaded = await Promise.all(configDirsInPlay(projectDir).map(loadProjectConfigFromDir));
+  return new Set(loaded.flatMap(configuredIdsOf));
+}
+function configuredIdsOf(loaded) {
+  if (!loaded) return [];
+  return loaded.config.skills.map((skill) => skill.id);
+}
 async function validateInstalledAgents(projectDir) {
   return mergeValidations(
     await Promise.all(installedDirs(projectDir, "agentsDir").map(validateAgentsDirectory))
@@ -495,11 +553,22 @@ function installedDirs(projectDir, key) {
 }
 async function listInstalledArtifacts(projectDir) {
   const [skills, agents] = await Promise.all([
-    listAcrossScopes(installedDirs(projectDir, "skillsDir"), listDirectories),
-    listAcrossScopes(installedDirs(projectDir, "agentsDir"), listAgentMdFiles)
+    listAcrossScopes(installedDirs(projectDir, "skillsDir"), listSkillDirsWithOurProvenance),
+    listAcrossScopes(installedDirs(projectDir, "agentsDir"), listAgentFilesWithOurProvenance)
   ]);
   return { skills, agents };
 }
+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);
+  const judged = await Promise.all(
+    names.map(async (name) => ({ name, ours: await carriesOurProvenance(skillsDir, name) }))
+  );
+  return judged.filter((entry) => entry.ours).map((entry) => entry.name);
+}
 async function listAcrossScopes(dirs, listEntries) {
   const perDir = await Promise.all(dirs.map((dir) => listDisplayPaths(dir, listEntries)));
   return perDir.flat();
@@ -509,17 +578,38 @@ async function listDisplayPaths(dir, listEntries) {
   const entries = await listEntries(dir);
   return entries.map((entry) => displayDir(path2.join(dir, entry)));
 }
-async function validateSkillsDirectory(skillsDir) {
+async function validateSkillsDirectory(skillsDir, configuredIds) {
   if (!await directoryExists(skillsDir)) return NOTHING_VALIDATED;
   const skillDirs = await listDirectories(skillsDir);
   if (skillDirs.length === 0) return NOTHING_VALIDATED;
+  const judged = await Promise.all(
+    skillDirs.map(async (name) => ({
+      name,
+      ours: await isOurSkillDirectory(skillsDir, name, configuredIds)
+    }))
+  );
+  const [ours, foreign] = partition(judged, (entry) => entry.ours);
   const results = await Promise.all(
-    skillDirs.map(async (name) => {
+    ours.map(async ({ name }) => {
       const skillDir = path2.join(skillsDir, name);
       return toIssues(displayDir(skillDir), await validateInstalledSkill(skillDir));
     })
   );
-  return { count: skillDirs.length, issues: results.flat(), notes: [] };
+  return {
+    count: ours.length,
+    issues: results.flat(),
+    notes: foreign.map(({ name }) => foreignSkillNote(skillsDir, name))
+  };
+}
+async function isOurSkillDirectory(skillsDir, name, configuredIds) {
+  if (configuredIds.has(name)) return true;
+  return carriesOurProvenance(skillsDir, name);
+}
+async function carriesOurProvenance(skillsDir, name) {
+  return await readForkedFromMetadata(path2.join(skillsDir, 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`;
 }
 async function validateAgentsDirectory(agentsDir) {
   if (!await directoryExists(agentsDir)) return NOTHING_VALIDATED;
@@ -776,7 +866,7 @@ function countedArtifacts(skills, agents) {
 }
 async function checkSkillsInstalled(config, projectDir) {
   const skills = config.skills;
-  const ejectSkills = skills.filter((s) => s.source === EJECT_SOURCE);
+  const ejectSkills = skills.filter((s) => s.origin === EJECT_SOURCE);
   if (ejectSkills.length === 0) {
     return {
       kind: "installed",
@@ -807,7 +897,7 @@ async function checkSkillsInstalled(config, projectDir) {
   };
 }
 async function checkPluginSkillsInstalled(config, projectDir) {
-  const pluginSkills = config.skills.filter((s) => s.source !== EJECT_SOURCE);
+  const pluginSkills = config.skills.filter((s) => s.origin !== EJECT_SOURCE);
   if (pluginSkills.length === 0) {
     return {
       kind: "plugins",
@@ -859,7 +949,7 @@ async function checkSourceReachable(projectDir) {
     return {
       kind: "source",
       status: "fail",
-      message: "Failed to load source",
+      message: "Failed to load marketplace",
       details: [message]
     };
   }
@@ -873,10 +963,14 @@ var CONFIG_CHECK = {
 var CONTENT_CHECKS = [
   {
     kind: "content-sources",
-    name: "Sources",
-    noun: "source",
-    // The registered sources are the ones config.ts names.
+    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.
+    blocks: ["skills"],
     run: validateRegisteredSources
   },
   {
@@ -884,13 +978,23 @@ 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.
+    blocks: ["plugins"],
     run: validateInstalledPlugins
   },
   {
     kind: "content-skills",
     name: "Skills",
     noun: "skill",
-    readsConfig: false,
+    // `~/.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.
+    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.
+    blocks: ["skills"],
     run: validateInstalledSkills
   },
   {
@@ -898,6 +1002,9 @@ 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.
+    blocks: [],
     run: validateInstalledAgents
   }
 ];
@@ -929,14 +1036,17 @@ function toContentResult(check, validation) {
     ]
   };
 }
-var CHECK_WIDTH = 20;
+var CHECK_WIDTH = 24;
 var SECTION_INDENT = "  ";
 var ROW_INDENT = "    ";
 var SECTION_CONTENT = "Content checks";
 var SECTION_OPERATIONAL = "Operational checks";
-var SKIP_AFTER_CONTENT_ERRORS = "Skipped \u2014 fix the content errors above first";
-var SKIP_NO_INSTALLATION = "Skipped \u2014 no installation here (skills source repository)";
+var SKIP_NO_INSTALLATION = "Skipped \u2014 no installation here (marketplace repository)";
 var SKIP_CONFIG_UNREADABLE = "Skipped \u2014 the configuration that names them cannot be read";
+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"}`;
 }
@@ -1005,11 +1115,12 @@ var TIPS = [
   {
     // 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,
-    // so it clears them without a config — and identifies compiled agents only through one.
+    // 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' writes a configuration that can own them again, or '${CLI_INVOKE_COMMAND} uninstall' removes the installed skills (the compiled agents outlive it: identifying them needs the configuration that is gone)`
+    tip: `  Tip: Nothing declares the files above \u2014 '${CLI_INVOKE_COMMAND} init' 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`
   },
   {
     kind: "skills",
@@ -1020,9 +1131,9 @@ var TIPS = [
     kind: "installed",
     status: "warn",
     // No command is named on purpose: 'eject skills --force' re-copies every skill in the
-    // source 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 source to restore their files"
+    // 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"
   }
 ];
 function formatTips(results) {
@@ -1034,11 +1145,19 @@ function skippedResult(kind) {
   return { kind, status: "skip", message: "Skipped (config invalid)" };
 }
 function sourceUnreachableSkillsResult() {
-  return { kind: "skills", status: "skip", message: "Skipped (source unreachable)" };
+  return { kind: "skills", status: "skip", message: "Skipped (marketplace unreachable)" };
 }
 function skippedContentResult(kind) {
   return { kind, status: "skip", message: SKIP_CONFIG_UNREADABLE };
 }
+function failedContentKinds(contentResults) {
+  return new Set(contentResults.filter((r) => r.status === "fail").map((r) => r.kind));
+}
+function contentBlockedResult(row, failedContent) {
+  const blockingNouns = CONTENT_CHECKS.filter((check) => failedContent.has(check.kind)).filter((check) => check.blocks.includes(row)).map((check) => check.noun);
+  if (blockingNouns.length === 0) return null;
+  return { kind: row, status: "skip", message: skipRestatingContent(blockingNouns) };
+}
 function runContentCheck(check, projectDir) {
   return safeCheck(check.kind, async () => toContentResult(check, await check.run(projectDir)));
 }
@@ -1051,7 +1170,7 @@ async function safeCheck(kind, fn) {
 }
 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 source connectivity.`;
+  static description = `Run diagnostic checks on your ${DEFAULT_BRANDING.NAME} configuration to identify issues with config validity, skill resolution, agent compilation, and marketplace connectivity.`;
   static examples = ["<%= config.bin %> <%= command.id %>"];
   static flags = {};
   async run() {
@@ -1097,16 +1216,18 @@ var Doctor = class _Doctor extends BaseCommand {
     return allRows.map((row) => row.result);
   }
   /**
-   * The operational layer runs only when it can say something the reader can act on:
-   * not after content errors (its findings would be their cascades), and not in a
-   * source repository with nothing installed (a marketplace author has no install
-   * for it to describe).
+   * 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}`);
-    if (contentResults.some((r) => r.status === "fail")) {
-      this.log(`${ROW_INDENT}${SKIP_AFTER_CONTENT_ERRORS}`);
+    const failedContent = failedContentKinds(contentResults);
+    if (failedContent.has(CONFIG_CHECK.kind)) {
+      this.log(`${ROW_INDENT}${SKIP_AFTER_CONFIG_ERROR}`);
       return [];
     }
     const detected = await detectProject(projectDir);
@@ -1114,7 +1235,8 @@ var Doctor = class _Doctor extends BaseCommand {
       this.log(`${ROW_INDENT}${SKIP_NO_INSTALLATION}`);
       return [];
     }
-    return this.runAllChecks(projectDir, await resolveConfigState(detected, projectDir));
+    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
@@ -1125,12 +1247,17 @@ var Doctor = class _Doctor extends BaseCommand {
     if (await fileExists(getProjectConfigPath(projectDir))) return false;
     return isSourceRepo(projectDir);
   }
-  async runAllChecks(projectDir, configState) {
+  async runAllChecks(projectDir, configState, failedContent) {
     const { result: configResult, config } = checkConfigValid(configState);
     this.logCheck("Config Valid", configResult);
     const sourceResult = await safeCheck("source", () => checkSourceReachable(projectDir));
     const filteredConfig = config ? filterExcludedEntries(config) : null;
-    const skillsResult = await this.resolveSkillsCheck(config, sourceResult, projectDir);
+    const skillsResult = await this.resolveSkillsCheck(
+      config,
+      sourceResult,
+      projectDir,
+      failedContent
+    );
     this.logCheck("Skills Resolved", skillsResult);
     const agentsResult = filteredConfig ? await safeCheck("agents", () => checkAgentsCompiled(filteredConfig, projectDir)) : skippedResult("agents");
     this.logCheck("Agents Compiled", agentsResult);
@@ -1138,9 +1265,9 @@ var Doctor = class _Doctor extends BaseCommand {
     this.logCheck("No Orphans", orphansResult);
     const installedResult = filteredConfig ? await safeCheck("installed", () => checkSkillsInstalled(filteredConfig, projectDir)) : skippedResult("installed");
     this.logCheck("Skills Installed", installedResult);
-    const pluginsResult = filteredConfig ? await safeCheck("plugins", () => checkPluginSkillsInstalled(filteredConfig, projectDir)) : skippedResult("plugins");
+    const pluginsResult = await this.resolvePluginsCheck(filteredConfig, projectDir, failedContent);
     this.logCheck("Plugins Installed", pluginsResult);
-    this.logCheck("Source Reachable", sourceResult);
+    this.logCheck("Marketplace Reachable", sourceResult);
     return [
       configResult,
       skillsResult,
@@ -1166,15 +1293,29 @@ var Doctor = class _Doctor extends BaseCommand {
     return skippedResult("orphans");
   }
   /**
-   * The skills row, and the two states in which it cannot be computed: no config to read the
-   * skills out of, and a source that never loaded — so there is no populated matrix to resolve
-   * them against, and every configured skill would be reported "not found".
+   * 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) {
+  async resolveSkillsCheck(config, sourceResult, projectDir, 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) {
+    if (!config) return skippedResult("plugins");
+    const blocked = contentBlockedResult("plugins", failedContent);
+    if (blocked) return blocked;
+    return safeCheck("plugins", () => checkPluginSkillsInstalled(config, projectDir));
+  }
   logCheck(name, result) {
     for (const line of formatCheckLine(name, result)) {
       this.log(line);