@curdx/flow 3.0.0 → 3.2.0

package/cli/lib/doctor-report.js

@@ -1,978 +0,0 @@
-import { BUNDLED_MCPS, REQUIRED_PLUGINS, RECOMMENDED_PLUGINS } from "../registry.js";
-import {
-  findDuplicateMcps,
-  findPluginByRegistryEntry,
-  hasMarketplace,
-} from "./claude.js";
-import { isVersionAtLeast } from "./semver.js";
-
-export const MIN_CLAUDE_VERSION = "2.1.110";
-
-function pluginErrorDetails(plugin) {
-  return Array.isArray(plugin?.errors) ? plugin.errors : [];
-}
-
-function projectSettingsWarningDetails(warning) {
-  if (warning?.scope === "managed") {
-    if (warning.kind === "unknown-plugin-option") {
-      return [
-        "file-based managed settings override user, project, and local CurDX-Flow plugin options on this machine",
-        "remove the unknown key or rename it to a supported CurDX-Flow plugin option under pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
-      ];
-    }
-
-    if (warning.kind === "invalid-managed-setting") {
-      return [
-        "file-based managed settings are evaluated before user/project/local settings",
-        "fix the managed JSON value shape so CurDX-Flow runtime projection matches the intended policy",
-      ];
-    }
-
-    return [
-      "file-based managed settings override user, project, and local CurDX-Flow plugin options on this machine",
-      "fix the managed policy or move the value to a supported CurDX-Flow plugin option key",
-    ];
-  }
-
-  if (warning?.scope === "user") {
-    if (warning.kind === "unknown-plugin-option") {
-      return [
-        "~/.claude/settings.json applies across all your repositories on this machine",
-        "remove the unknown key or rename it to a supported CurDX-Flow plugin option under pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
-      ];
-    }
-
-    if (
-      warning.kind === "invalid-user-setting" &&
-      (
-        warning.message?.includes("pluginConfigs[curdx-flow@curdx-flow-marketplace]") ||
-        warning.message?.includes("CurDX-Flow plugin option")
-      )
-    ) {
-      return [
-        "CurDX-Flow plugin options in ~/.claude/settings.json apply across all local repositories unless a project or local override wins",
-        "use boolean values for autonomous_blocking and daily_dependency_check, and keep monitor_interval_seconds as an integer between 3 and 60",
-      ];
-    }
-
-    return [
-      "~/.claude/settings.json applies across all your repositories on this machine",
-      "fix or remove the user-scoped override if CurDX-Flow behaves unexpectedly everywhere",
-    ];
-  }
-
-  if (warning?.scope === "local") {
-    if (warning.kind === "unknown-plugin-option") {
-      return [
-        "settings.local.json overrides shared project settings on this machine",
-        "remove the unknown key or rename it to a supported CurDX-Flow plugin option under pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
-      ];
-    }
-
-    if (
-      warning.kind === "invalid-local-setting" &&
-      (
-        warning.message?.includes("pluginConfigs[curdx-flow@curdx-flow-marketplace]") ||
-        warning.message?.includes("CurDX-Flow plugin option")
-      )
-    ) {
-      return [
-        "CurDX-Flow plugin options in settings.local.json override project and user settings on this machine",
-        "use boolean values for autonomous_blocking and daily_dependency_check, and keep monitor_interval_seconds as an integer between 3 and 60",
-      ];
-    }
-
-    if (warning.kind === "invalid-local-setting") {
-      return [
-        "settings.local.json is the highest-precedence repo-scoped settings surface on this machine",
-        "fix the JSON shape or remove the local override if Claude behaves unexpectedly",
-      ];
-    }
-
-    if (warning.kind === "required-plugin-disabled") {
-      return [
-        "settings.local.json overrides project and user plugin preferences on this machine",
-        "remove the false entry or enable the required companion plugin locally",
-      ];
-    }
-
-    if (warning.kind === "flow-runtime-blocker") {
-      return [
-        "settings.local.json has higher precedence than .claude/settings.json and can break CurDX-Flow only on this machine",
-        "remove the local blocker or add explicit exceptions for curdx-flow workflows",
-      ];
-    }
-
-    return [
-      "settings.local.json overrides shared project settings on this machine",
-      "fix or remove the local override if Claude behaves differently from the rest of the team",
-    ];
-  }
-
-  if (warning.kind === "unknown-plugin-option") {
-    return [
-      "CurDX-Flow only reads keys declared in the plugin manifest",
-      "remove the unknown key or rename it under pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
-    ];
-  }
-
-  if (
-    warning.kind === "invalid-project-setting" &&
-    (
-      warning.message?.includes("pluginConfigs[curdx-flow@curdx-flow-marketplace]") ||
-      warning.message?.includes("CurDX-Flow plugin option")
-    )
-  ) {
-    return [
-      "CurDX-Flow non-sensitive plugin options belong under pluginConfigs[curdx-flow@curdx-flow-marketplace].options in .claude/settings.json",
-      "use boolean values for autonomous_blocking and daily_dependency_check, and keep monitor_interval_seconds as an integer between 3 and 60",
-    ];
-  }
-
-  if (!warning?.kind) {
-    return [
-      "project settings are shared with collaborators",
-      "prefer deny rules for .env/secrets and avoid bypassPermissions defaults",
-    ];
-  }
-
-  if (warning.kind === "ignored-project-setting" || warning.kind === "managed-only-setting") {
-    return [
-      "Claude Code will ignore this at project scope or only honor it from managed settings",
-      "move it to user settings, settings.local.json, or managed settings as appropriate",
-    ];
-  }
-
-  if (warning.kind === "invalid-project-setting") {
-    return [
-      "Claude Code expects this setting to follow the official settings.json shape",
-      "fix the value shape or remove the key from shared project settings",
-    ];
-  }
-
-  if (warning.kind === "required-plugin-disabled") {
-    return [
-      "project enabledPlugins has higher precedence than user plugin preferences",
-      "remove the false entry or enable the required companion plugin for this project",
-    ];
-  }
-
-  if (
-    warning.kind === "shared-script-setting" ||
-    warning.kind === "shared-env-setting" ||
-    warning.kind === "shared-mcp-auto-approve" ||
-    warning.kind === "shared-hook-policy" ||
-    warning.kind === "shared-sandbox-policy"
-  ) {
-    return [
-      "project settings are shared with collaborators",
-      "avoid shared settings that run scripts, inject env vars, narrow hooks, or change sandbox behavior for every collaborator",
-    ];
-  }
-
-  if (warning.kind === "skill-shell-disabled") {
-    return [
-      "Claude Code replaces inline skill shell output with a disabled placeholder when this policy is active",
-      "keep it only if your team intentionally bans dynamic shell-backed skill content",
-    ];
-  }
-
-  if (warning.kind === "low-effort-project-setting") {
-    return [
-      "project effortLevel applies to main-thread planning and review turns",
-      "prefer high/xhigh for CurDX-Flow planning and verification-heavy workflows",
-    ];
-  }
-
-  if (warning.kind === "flow-runtime-blocker") {
-    return [
-      "CurDX-Flow relies on Claude Code hooks, Agent dispatch, AskUserQuestion, Monitor plus Bash/Read/Edit tooling, and sonnet/opus model aliases",
-      "move restrictive policy to a narrower scope or add explicit exceptions for curdx-flow workflows",
-    ];
-  }
-
-  if (warning.kind === "deprecated-setting") {
-    return [
-      "deprecated settings are still accepted for compatibility but should be migrated",
-      "prefer the current official replacement before the old key is removed",
-    ];
-  }
-
-  return [
-    "project settings are shared with collaborators",
-    "prefer deny rules for .env/secrets and avoid bypassPermissions defaults",
-  ];
-}
-
-function formatInlineValue(value) {
-  if (typeof value === "string") return `"${value}"`;
-  return String(value);
-}
-
-export function buildDoctorReport({
-  claudeVersionValue,
-  nodeVersion,
-  plugins = [],
-  marketplaces = [],
-  mcps = [],
-  userMcpConfig,
-  runtimeStatus,
-  runtimeEnvironment,
-  cwd,
-  projectState,
-  projectMcpConfig,
-  projectTeamConfig,
-  projectClaudeSettings,
-  bundledPluginRuntimeDefaults,
-  legacyInstallState,
-}) {
-  const lines = [];
-  const sections = [];
-  let errors = 0;
-  let warnings = 0;
-
-  const pushLine = (target, level, text, details = []) => {
-    target.push({ level, text, details });
-    if (level === "err") errors++;
-    if (level === "warn") warnings++;
-  };
-  const pushSectionLine = (section, level, text, details = []) => {
-    pushLine(section.lines, level, text, details);
-  };
-  const createSection = (title) => {
-    const section = { title, lines: [] };
-    sections.push(section);
-    return section;
-  };
-
-  if (claudeVersionValue) {
-    pushLine(lines, "ok", `claude CLI            ${claudeVersionValue}`);
-    if (!isVersionAtLeast(claudeVersionValue, MIN_CLAUDE_VERSION)) {
-      pushLine(
-        lines,
-        "warn",
-        `claude CLI            ${claudeVersionValue} below recommended ${MIN_CLAUDE_VERSION}`,
-        [
-          "curdx-flow uses modern Claude Code plugin dependency resolution, plugin bin/PATH support, plugin-level main-agent routing, and monitor surfaces",
-          "run: claude update",
-        ]
-      );
-    }
-  } else {
-    pushLine(lines, "err", "claude CLI            not found (install Claude Code)");
-  }
-  pushLine(lines, "ok", `Node                  ${nodeVersion}`);
-
-  const curdx = plugins.find((plugin) => plugin.name === "curdx-flow");
-  const bundledVersion =
-    bundledPluginRuntimeDefaults?.pluginVersion || bundledPluginRuntimeDefaults?.packageVersion || null;
-  const bundledSourceRepo = bundledPluginRuntimeDefaults?.sourceRepo || {};
-  if (curdx) {
-    if (curdx.status === "enabled") {
-      pushLine(lines, "ok", `curdx-flow            v${curdx.version} (enabled)`);
-      if (bundledVersion && curdx.version && curdx.version !== bundledVersion) {
-        pushLine(
-          lines,
-          "warn",
-          `curdx-flow source/body  v${bundledVersion} differs from installed v${curdx.version}`,
-          [
-            "you are not validating the same CurDX-Flow build that Claude currently loads",
-            "reinstall the plugin from the current source/package, then restart Claude Code",
-            "run: npx @curdx/flow install --all",
-          ]
-        );
-      }
-      if (bundledSourceRepo.isGitRepo && bundledSourceRepo.dirty) {
-        pushLine(
-          lines,
-          "warn",
-          "curdx-flow source repo has uninstalled local changes",
-          [
-            "the current CLI/source checkout has git modifications that Claude's installed plugin cannot see until you reinstall it",
-            "re-run: npx @curdx/flow install --all",
-            "then fully restart Claude Code before validating plugin behavior",
-          ]
-        );
-      }
-    } else {
-      pushLine(
-        lines,
-        "err",
-        `curdx-flow            v${curdx.version} (${curdx.status})`,
-        pluginErrorDetails(curdx)
-      );
-    }
-  } else {
-    pushLine(lines, "warn", "curdx-flow            not installed → run curdx-flow install");
-  }
-
-  const requiredSection = createSection("Required plugins:");
-  for (const entry of REQUIRED_PLUGINS) {
-    const plugin = findPluginByRegistryEntry(plugins, entry);
-    if (!hasMarketplace(marketplaces, entry)) {
-      pushSectionLine(
-        requiredSection,
-        "warn",
-        `${entry.marketplaceId.padEnd(22)} marketplace missing`,
-        [`run: claude plugin marketplace add --scope ${entry.scope} ${entry.marketplaceSource}`]
-      );
-    }
-    if (plugin && plugin.status === "enabled") {
-      pushSectionLine(requiredSection, "ok", `${entry.name.padEnd(22)} v${plugin.version || "unknown"}`);
-    } else if (plugin && plugin.status === "failed") {
-      pushSectionLine(
-        requiredSection,
-        "err",
-        `${entry.name.padEnd(22)} load failed`,
-        pluginErrorDetails(plugin)
-      );
-    } else {
-      pushSectionLine(
-        requiredSection,
-        "warn",
-        `${entry.name.padEnd(22)} not installed`,
-        [`run: claude plugin install --scope ${entry.scope} ${entry.installSpec}`]
-      );
-    }
-  }
-
-  const mcpSection = createSection("MCP Servers (required by L2 mandatory tools):");
-  for (const expected of BUNDLED_MCPS) {
-    const userLevel = mcps.find((entry) => entry.name === expected.name && entry.plugin === null);
-    const pluginLevel = mcps.find((entry) => entry.name === expected.name && entry.plugin !== null);
-
-    if (userLevel) {
-      pushSectionLine(mcpSection, "ok", `${expected.name.padEnd(22)} user-level (standard)`);
-    } else if (pluginLevel) {
-      pushSectionLine(
-        mcpSection,
-        "warn",
-        `${expected.name.padEnd(22)} registered via plugin:${pluginLevel.plugin} (legacy)`,
-        ["run: npx @curdx/flow install --all"]
-      );
-    } else if (curdx) {
-      pushSectionLine(
-        mcpSection,
-        "warn",
-        `${expected.name.padEnd(22)} missing`,
-        [`run: claude mcp add --scope user ${expected.name} -- ${expected.command} ${expected.args.join(" ")}`]
-      );
-    } else {
-      pushSectionLine(mcpSection, "info", `${expected.name.padEnd(22)} waiting for curdx-flow install`);
-    }
-  }
-
-  const recommendedSection = createSection("Recommended plugins:");
-  let claudeMemEnabled = false;
-  for (const entry of RECOMMENDED_PLUGINS) {
-    const plugin = findPluginByRegistryEntry(plugins, entry);
-    if (!hasMarketplace(marketplaces, entry)) {
-      pushSectionLine(
-        recommendedSection,
-        "warn",
-        `${entry.marketplaceId.padEnd(22)} marketplace missing`,
-        [`run: claude plugin marketplace add --scope ${entry.scope} ${entry.marketplaceSource}`]
-      );
-    }
-    if (plugin && plugin.status === "enabled") {
-      pushSectionLine(recommendedSection, "ok", `${entry.name.padEnd(22)} v${plugin.version}`);
-      if (entry.postInstall === "claude-mem-runtimes") claudeMemEnabled = true;
-    } else if (plugin && plugin.status === "failed") {
-      pushSectionLine(
-        recommendedSection,
-        "err",
-        `${entry.name.padEnd(22)} load failed`,
-        pluginErrorDetails(plugin)
-      );
-    } else {
-      pushSectionLine(
-        recommendedSection,
-        "warn",
-        `${entry.name.padEnd(22)} not installed`,
-        [`run: claude plugin install --scope ${entry.scope} ${entry.installSpec}`]
-      );
-    }
-  }
-
-  const duplicates = findDuplicateMcps(mcps, userMcpConfig);
-  if (duplicates.length > 0) {
-    const duplicateSection = createSection("Duplicate MCP registrations:");
-    for (const duplicate of duplicates) {
-      const details = duplicate.pluginEntry.plugin === "curdx-flow"
-        ? [
-          "migration: claude plugin update curdx-flow@curdx-flow-marketplace",
-          "then restart Claude Code",
-        ]
-        : duplicate.pluginEntry.plugin === "context7-plugin" && duplicate.name === "context7"
-          ? [
-            "official Context7 plugin already owns the context7 MCP server",
-            "run: npx @curdx/flow doctor --fix",
-            `or run manually: claude mcp remove --scope user ${duplicate.name}`,
-          ]
-        : [
-          `remove the duplicate user-level server if plugin:${duplicate.pluginEntry.plugin} should own it`,
-          `run: claude mcp remove --scope user ${duplicate.name}`,
-        ];
-      pushSectionLine(
-        duplicateSection,
-        "warn",
-        `${duplicate.name.padEnd(22)} both user-level AND plugin:${duplicate.pluginEntry.plugin} active`,
-        details
-      );
-    }
-  }
-
-  if (legacyInstallState?.hasLegacyContext7ApiKey) {
-    const legacySection = createSection("Legacy installer state:");
-    pushSectionLine(
-      legacySection,
-      "warn",
-      "legacy Context7 API key stored in curdx-flow install config",
-      [
-        `path: ${legacyInstallState.configPath}`,
-        "this key belonged to the retired user-level Context7 MCP install flow and is no longer used by the official context7-plugin",
-        "run: npx @curdx/flow doctor --fix",
-      ]
-    );
-  }
-
-  if (claudeMemEnabled && runtimeStatus) {
-    const runtimeSection = createSection("Runtime (claude-mem dependencies):");
-    for (const [name, status] of Object.entries(runtimeStatus)) {
-      if (status.status === "ok") {
-        pushSectionLine(runtimeSection, "ok", `${name.padEnd(22)} visible on PATH`);
-      } else if (status.status === "linkable") {
-        pushSectionLine(
-          runtimeSection,
-          "warn",
-          `${name.padEnd(22)} installed but not on PATH`,
-          [
-            `detected at ${status.path}`,
-            "run: npx @curdx/flow doctor --fix",
-          ]
-        );
-      } else if (status.status === "linked") {
-        pushSectionLine(runtimeSection, "ok", `${name.padEnd(22)} auto-linked ${status.link} → ${status.path}`);
-      } else if (status.status === "missing") {
-        pushSectionLine(
-          runtimeSection,
-          "warn",
-          `${name.padEnd(22)} not installed`,
-          ["claude-mem will auto-install on next Claude Code session"]
-        );
-      } else if (status.status === "path-unwritable") {
-        const dir = status.path.split("/").slice(0, -1).join("/");
-        pushSectionLine(
-          runtimeSection,
-          "err",
-          `${name.padEnd(22)} installed but not on PATH`,
-          [
-            `add export PATH="${dir}:$PATH" to your shell rc`,
-            "then rerun: npx @curdx/flow doctor",
-          ]
-        );
-      }
-    }
-  }
-
-  if (runtimeEnvironment?.entries?.length > 0) {
-    const runtimeEnvSection = createSection("Runtime environment:");
-    for (const entry of runtimeEnvironment.entries) {
-      pushSectionLine(
-        runtimeEnvSection,
-        entry.level || "info",
-        entry.text,
-        entry.details || []
-      );
-    }
-  }
-
-  if (bundledPluginRuntimeDefaults?.exists) {
-    const bundledRuntimeSection = createSection("CurDX-Flow bundled runtime:");
-
-    if (bundledVersion) {
-      pushSectionLine(
-        bundledRuntimeSection,
-        "info",
-        `Bundled plugin body    v${bundledVersion}`
-      );
-    }
-
-    if (bundledSourceRepo.isGitRepo) {
-      const sourceSummary = [
-        bundledSourceRepo.branch,
-        bundledSourceRepo.shortSha,
-      ].filter(Boolean).join(" @ ");
-      const sourceDetails = [];
-      if (bundledSourceRepo.exactTag) {
-        sourceDetails.push(`exact tag: ${bundledSourceRepo.exactTag}`);
-      }
-      sourceDetails.push(
-        bundledSourceRepo.dirty
-          ? "git worktree dirty: local source changes are not reflected in Claude until reinstall"
-          : "git worktree clean"
-      );
-      pushSectionLine(
-        bundledRuntimeSection,
-        bundledSourceRepo.dirty ? "warn" : "info",
-        `Bundled source repo    ${sourceSummary || "git checkout detected"}`,
-        sourceDetails
-      );
-    }
-
-    if (bundledPluginRuntimeDefaults.defaultAgent) {
-      pushSectionLine(
-        bundledRuntimeSection,
-        "ok",
-        `Main thread agent     ${bundledPluginRuntimeDefaults.defaultAgent}`,
-        [
-          "plugin-level settings route the main Claude thread through this agent by default",
-        ]
-      );
-    }
-
-    if (bundledPluginRuntimeDefaults.subagentStatusLineCommand) {
-      pushSectionLine(
-        bundledRuntimeSection,
-        "info",
-        `Subagent status line  configured`,
-        [bundledPluginRuntimeDefaults.subagentStatusLineCommand]
-      );
-    }
-
-    if (bundledPluginRuntimeDefaults.monitorCount > 0) {
-      const monitorSummary = bundledPluginRuntimeDefaults.monitors
-        .map((monitor) => `${monitor.name} (${monitor.when})`)
-        .join(", ");
-      pushSectionLine(
-        bundledRuntimeSection,
-        "ok",
-        `Plugin monitors       ${bundledPluginRuntimeDefaults.monitorCount} configured`,
-        [
-          monitorSummary,
-          "official docs: plugin monitors run only in interactive Claude Code sessions where the Monitor tool is available",
-        ]
-      );
-    }
-
-    if ((bundledPluginRuntimeDefaults.userConfig || []).length > 0) {
-      const optionSummary = bundledPluginRuntimeDefaults.userConfig
-        .map((option) => {
-          const suffix = option.default === undefined ? "" : `=${String(option.default)}`;
-          return `${option.key}${suffix}`;
-        })
-        .join(", ");
-      pushSectionLine(
-        bundledRuntimeSection,
-        "info",
-        `Plugin options        ${bundledPluginRuntimeDefaults.userConfig.length} available`,
-        [
-          optionSummary,
-          "non-sensitive values are stored under pluginConfigs[curdx-flow@curdx-flow-marketplace].options in Claude settings.json",
-        ]
-      );
-    }
-  }
-
-  if (
-    bundledPluginRuntimeDefaults?.exists ||
-    projectClaudeSettings?.pluginOptions
-  ) {
-    const configuredOptionsSection = createSection("CurDX-Flow configured options:");
-    const optionState = projectClaudeSettings?.pluginOptions;
-    const managedOverrides = optionState?.managed?.overrides || {};
-    const userOverrides = optionState?.user?.overrides || {};
-    const projectOverrides = optionState?.project?.overrides || {};
-    const localOverrides = optionState?.local?.overrides || {};
-    const machineEffective = optionState?.machineEffective || optionState?.repoEffective || {};
-    const definitions = bundledPluginRuntimeDefaults?.userConfig?.length
-      ? bundledPluginRuntimeDefaults.userConfig
-      : (optionState?.definitions || []);
-
-    pushSectionLine(
-      configuredOptionsSection,
-      "info",
-      "Scope precedence      file-managed > settings.local.json > settings.json > ~/.claude/settings.json > bundled default",
-      [
-        "server-managed settings, MDM/registry policies, and command-line overrides are not inspected here",
-        "effective values below reflect this machine only",
-      ]
-    );
-
-    if (projectClaudeSettings?.managedSettings?.exists) {
-      if (Object.keys(managedOverrides).length > 0) {
-        const summary = Object.entries(managedOverrides)
-          .map(([key, value]) => `${key}=${formatInlineValue(value)}`)
-          .join(", ");
-        pushSectionLine(
-          configuredOptionsSection,
-          "info",
-          `file-managed settings ${Object.keys(managedOverrides).length} valid override(s)`,
-          [
-            summary,
-            projectClaudeSettings.managedSettings.rootPath,
-          ]
-        );
-      } else {
-        pushSectionLine(
-          configuredOptionsSection,
-          "info",
-          "file-managed settings present without valid CurDX-Flow overrides"
-        );
-      }
-    } else {
-      pushSectionLine(
-        configuredOptionsSection,
-        "info",
-        "file-managed settings not present"
-      );
-    }
-
-    if (projectClaudeSettings?.userExists) {
-      if (Object.keys(userOverrides).length > 0) {
-        const summary = Object.entries(userOverrides)
-          .map(([key, value]) => `${key}=${formatInlineValue(value)}`)
-          .join(", ");
-        pushSectionLine(
-          configuredOptionsSection,
-          "info",
-          `~/.claude/settings.json ${Object.keys(userOverrides).length} valid override(s)`,
-          [
-            summary,
-            "user-scoped overrides apply across repositories unless project/local settings win",
-          ]
-        );
-      } else {
-        pushSectionLine(
-          configuredOptionsSection,
-          "info",
-          "~/.claude/settings.json present without valid CurDX-Flow overrides"
-        );
-      }
-    } else {
-      pushSectionLine(
-        configuredOptionsSection,
-        "info",
-        "~/.claude/settings.json not present"
-      );
-    }
-
-    if (Object.keys(projectOverrides).length > 0) {
-      const summary = Object.entries(projectOverrides)
-        .map(([key, value]) => `${key}=${formatInlineValue(value)}`)
-        .join(", ");
-      pushSectionLine(
-        configuredOptionsSection,
-        "info",
-        `.claude/settings.json ${Object.keys(projectOverrides).length} valid override(s)`,
-        [
-          summary,
-          "path: pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
-        ]
-      );
-    } else {
-      pushSectionLine(
-        configuredOptionsSection,
-        "info",
-        ".claude/settings.json no CurDX-Flow repo override"
-      );
-    }
-
-    if (projectClaudeSettings?.localExists) {
-      if (Object.keys(localOverrides).length > 0) {
-        const summary = Object.entries(localOverrides)
-          .map(([key, value]) => `${key}=${formatInlineValue(value)}`)
-          .join(", ");
-        pushSectionLine(
-          configuredOptionsSection,
-          "info",
-          `.claude/settings.local.json ${Object.keys(localOverrides).length} valid override(s)`,
-          [
-            summary,
-            "local overrides have higher precedence than .claude/settings.json on this machine",
-          ]
-        );
-      } else {
-        pushSectionLine(
-          configuredOptionsSection,
-          "info",
-          ".claude/settings.local.json present without valid CurDX-Flow overrides"
-        );
-      }
-    } else {
-      pushSectionLine(
-        configuredOptionsSection,
-        "info",
-        ".claude/settings.local.json not present"
-      );
-    }
-
-    for (const definition of definitions) {
-      const effective = machineEffective[definition.key] || {
-        value: definition.default,
-        source: "default",
-      };
-      const sourceLabel = effective.source === "local"
-        ? "local"
-        : effective.source === "project"
-          ? "project"
-          : effective.source === "user"
-            ? "user"
-            : effective.source === "managed"
-              ? "managed"
-              : "bundled default";
-      pushSectionLine(
-        configuredOptionsSection,
-        "ok",
-        `${definition.key.padEnd(22)} ${formatInlineValue(effective.value)} (${sourceLabel})`
-      );
-    }
-  }
-
-  if ((projectClaudeSettings?.pluginRuntimeProjection || []).length > 0) {
-    const runtimeProjectionSection = createSection("CurDX-Flow runtime projection:");
-
-    for (const entry of projectClaudeSettings.pluginRuntimeProjection) {
-      const sourceLabel = entry.source === "local"
-        ? "local"
-        : entry.source === "project"
-          ? "project"
-          : entry.source === "user"
-            ? "user"
-            : entry.source === "managed"
-              ? "managed"
-              : "bundled default";
-      pushSectionLine(
-        runtimeProjectionSection,
-        "info",
-        `${entry.envVar.padEnd(36)} ${formatInlineValue(entry.value)} (${sourceLabel})`,
-        [
-          `consumer: ${entry.consumer}`,
-          entry.summary,
-          ...(entry.details || []),
-        ]
-      );
-    }
-  }
-
-  const localProjectSection = createSection("Local project:");
-  if (projectState?.exists) {
-    pushSectionLine(localProjectSection, "ok", `.flow/                ${cwd}`);
-    if (projectState.activeSpec) {
-      pushSectionLine(localProjectSection, "info", `Active spec           ${projectState.activeSpec}`);
-    } else {
-      pushSectionLine(localProjectSection, "info", "Active spec           (none)");
-    }
-  } else {
-    pushSectionLine(localProjectSection, "info", ".flow/                not a curdx-flow project (run: curdx-flow init)");
-  }
-
-  const projectMcpSection = createSection("Project MCP config:");
-  if (projectMcpConfig?.misplacedExists) {
-    pushSectionLine(
-      projectMcpSection,
-      projectMcpConfig.exists ? "warn" : "err",
-      `.claude/.mcp.json      ignored by Claude Code`,
-      [
-        "project MCP config must live at repo root as .mcp.json",
-        "move .claude/.mcp.json → .mcp.json, then reopen /mcp or rerun doctor",
-      ]
-    );
-  }
-
-  if (projectMcpConfig?.exists) {
-    if (projectMcpConfig.invalid) {
-      pushSectionLine(
-        projectMcpSection,
-        "err",
-        `.mcp.json            invalid JSON`,
-        [
-          projectMcpConfig.parseError,
-          "fix the JSON syntax, then run /mcp or npx @curdx/flow doctor again",
-        ]
-      );
-    } else if (projectMcpConfig.shapeError) {
-      pushSectionLine(
-        projectMcpSection,
-        "err",
-        `.mcp.json            unsupported shape`,
-        [
-          projectMcpConfig.shapeError,
-          'expected: { "mcpServers": { "<name>": { ... } } }',
-        ]
-      );
-    } else {
-      pushSectionLine(
-        projectMcpSection,
-        "ok",
-        `.mcp.json            ${projectMcpConfig.serverCount} server(s) declared`
-      );
-
-      for (const warning of projectMcpConfig.relativePathWarnings || []) {
-        pushSectionLine(
-          projectMcpSection,
-          "warn",
-          `${warning.serverName.padEnd(22)} relative path in ${warning.field}`,
-          [
-            `value: ${warning.value}`,
-            "Claude Code resolves relative MCP paths against the launch directory, not .mcp.json",
-            "use an absolute path or a PATH executable such as npx / uvx",
-            "debug: claude --debug mcp",
-          ]
-        );
-      }
-    }
-  } else if (!projectMcpConfig?.misplacedExists) {
-    pushSectionLine(projectMcpSection, "info", ".mcp.json            not present");
-  }
-
-  const projectTeamsSection = createSection("Project agent teams:");
-  if (projectTeamConfig?.exists) {
-    pushSectionLine(
-      projectTeamsSection,
-      "warn",
-      `.claude/teams/teams.json ignored by Claude Code`,
-      [
-        "official agent-teams docs say project directories do not have a recognized team config surface",
-        "remove the file or move team configuration to the supported user-level agent-teams runtime",
-      ]
-    );
-  } else {
-    pushSectionLine(projectTeamsSection, "info", ".claude/teams/teams.json not present");
-  }
-
-  const projectSettingsSection = createSection("Project Claude settings:");
-  const managedSettingsSection = createSection("Managed Claude settings:");
-  const userSettingsSection = createSection("User Claude settings:");
-
-  if (projectClaudeSettings?.managedSettings?.supported) {
-    if (projectClaudeSettings.managedSettings.exists) {
-      pushSectionLine(
-        managedSettingsSection,
-        "info",
-        "File-based managed settings detected",
-        [projectClaudeSettings.managedSettings.rootPath]
-      );
-
-      for (const file of projectClaudeSettings.managedSettings.files || []) {
-        if (file.invalid) {
-          pushSectionLine(
-            managedSettingsSection,
-            "err",
-            `${file.label} invalid JSON`,
-            [file.parseError]
-          );
-          continue;
-        }
-
-        if (Object.keys(file.overrides || {}).length > 0) {
-          const summary = Object.entries(file.overrides)
-            .map(([key, value]) => `${key}=${formatInlineValue(value)}`)
-            .join(", ");
-          pushSectionLine(
-            managedSettingsSection,
-            "info",
-            `${file.label} ${Object.keys(file.overrides).length} CurDX-Flow override(s)`,
-            [summary]
-          );
-        } else {
-          pushSectionLine(
-            managedSettingsSection,
-            "ok",
-            `${file.label} present`
-          );
-        }
-      }
-
-      if ((projectClaudeSettings.managedWarnings || []).length > 0) {
-        pushSectionLine(managedSettingsSection, "warn", "Managed CurDX-Flow settings need review");
-        for (const warning of projectClaudeSettings.managedWarnings) {
-          pushSectionLine(
-            managedSettingsSection,
-            "warn",
-            warning.message,
-            projectSettingsWarningDetails(warning)
-          );
-        }
-      }
-    } else {
-      pushSectionLine(managedSettingsSection, "info", "File-based managed settings not present");
-    }
-  } else {
-    pushSectionLine(managedSettingsSection, "info", "File-based managed settings not supported on this platform");
-  }
-
-  if (projectClaudeSettings?.userExists) {
-    if (projectClaudeSettings.userInvalid) {
-      pushSectionLine(
-        userSettingsSection,
-        "err",
-        "~/.claude/settings.json invalid JSON",
-        [projectClaudeSettings.userParseError]
-      );
-    } else if ((projectClaudeSettings.userWarnings || []).length > 0) {
-      pushSectionLine(userSettingsSection, "warn", "~/.claude/settings.json affects CurDX-Flow globally");
-      for (const warning of projectClaudeSettings.userWarnings) {
-        pushSectionLine(
-          userSettingsSection,
-          "warn",
-          warning.message,
-          projectSettingsWarningDetails(warning)
-        );
-      }
-    } else {
-      pushSectionLine(userSettingsSection, "ok", "~/.claude/settings.json present");
-    }
-  } else {
-    pushSectionLine(userSettingsSection, "info", "~/.claude/settings.json not present");
-  }
-
-  if (projectClaudeSettings?.exists) {
-    if (projectClaudeSettings.invalid) {
-      pushSectionLine(
-        projectSettingsSection,
-        "err",
-        `.claude/settings.json invalid JSON`,
-        [projectClaudeSettings.parseError]
-      );
-    } else if ((projectClaudeSettings.warnings || []).length > 0) {
-      pushSectionLine(projectSettingsSection, "warn", ".claude/settings.json needs review");
-      for (const warning of projectClaudeSettings.warnings) {
-        pushSectionLine(
-          projectSettingsSection,
-          "warn",
-          warning.message,
-          projectSettingsWarningDetails(warning)
-        );
-      }
-    } else {
-      pushSectionLine(projectSettingsSection, "ok", ".claude/settings.json conservative");
-    }
-  } else {
-    pushSectionLine(projectSettingsSection, "info", ".claude/settings.json not present");
-  }
-
-  if (projectClaudeSettings?.localExists) {
-    pushSectionLine(projectSettingsSection, "info", ".claude/settings.local.json present (local overrides)");
-    if (projectClaudeSettings.localInvalid) {
-      pushSectionLine(
-        projectSettingsSection,
-        "err",
-        ".claude/settings.local.json invalid JSON",
-        [projectClaudeSettings.localParseError]
-      );
-    } else if ((projectClaudeSettings.localWarnings || []).length > 0) {
-      pushSectionLine(projectSettingsSection, "warn", ".claude/settings.local.json affects the local runtime");
-      for (const warning of projectClaudeSettings.localWarnings) {
-        pushSectionLine(
-          projectSettingsSection,
-          "warn",
-          warning.message,
-          projectSettingsWarningDetails(warning)
-        );
-      }
-    }
-  }
-
-  return { lines, sections, errors, warnings };
-}