@canonical/pragma-cli 0.34.0 → 0.36.0

package/dist/src/capabilities/doctor/checks/checkPackageRefs.js

@@ -0,0 +1,148 @@
+/**
+ * Doctor check: report which pack answers this project's reads.
+ *
+ * It switches on the ONE boot decision ({@link resolveSources}) rather than
+ * re-deriving it from config, so doctor can never call an install healthy that
+ * every read would fail. That is the whole point of the check: a project that
+ * configured its own packs and never built them reports `fail` with the update
+ * remedy — not a pass listing the distribution's packs it is not reading.
+ * Storeless throughout: the pointer, the manifest, and the entity index are
+ * read off disk, never through a store session.
+ *
+ * It also names every read story that pack carries but cannot use. Those are
+ * DROPPED at dispatch rather than thrown (a third-party story must never break
+ * a command), so doctor is where the user finds out — and it goes through the
+ * same `validateStories` the dispatch path uses, so the two can never disagree.
+ */
+import { BIN_NAME } from "../../../constants.js";
+import { entityTotal, readPackIndex, } from "../../../kernel/completion/entitySource.js";
+import { validateStories } from "../../../kernel/packs/index.js";
+import { embeddedManifest, readManifest, } from "../../../kernel/runtime/graphpack/index.js";
+import { activeStories } from "../../../kernel/runtime/graphpack/stories.js";
+import { resolveSources } from "../../../kernel/runtime/resolveSources.js";
+/**
+ * The stories the answering pack carries but cannot use, as check items.
+ *
+ * The registry is reached through a RUNTIME dynamic import (as
+ * `collectColophon` does) so the static `capabilities/index → doctorModule →
+ * checkPackageRefs → capabilities/index` cycle can never form.
+ *
+ * @param decision - The boot decision the check already resolved.
+ * @returns One failing item per ignored story, in declaration order.
+ * @note Impure — reads the answering pack's `stories.json`.
+ */
+async function ignoredStoryItems(decision) {
+    const { capabilities } = await import("../../index.js");
+    const { problems } = validateStories(activeStories(decision), capabilities);
+    return problems.map((problem) => ({
+        label: problem.source,
+        detail: problem.message,
+        status: "fail",
+    }));
+}
+/** ` · N story/ies ignored` for a headline, or nothing when all are usable. */
+function ignoredSuffix(items) {
+    if (items.length === 0)
+        return "";
+    return ` · ${items.length} ${items.length === 1 ? "story" : "stories"} ignored`;
+}
+/**
+ * The answering pack's provenance, one item per pack it was built from.
+ *
+ * `sourceRef` is a single comma-joined string — `@canonical/design-system@git:
+ * d6d8a6c8268cf2bd103e956a2540d6e36bd08d72, @canonical/anatomy-dsl@npm:0.2.2,
+ * …` — and printing it whole put four packs and two forty-character SHAs on one
+ * line, in a report whose every other multi-part check (`mcp`, `harnesses`)
+ * uses the sub-item mechanism. Provenance is the thing a reader is here for
+ * when they read this line at all: which revision of which pack answered.
+ *
+ * The scheme (`git`/`npm`/`self`/`file`) is kept because it says how to move
+ * the pin, and a git hash is cut to the seven characters every other tool in
+ * this workflow shows. A ref that does not parse is passed through whole rather
+ * than dropped — an unreadable provenance is still provenance, and hiding it
+ * would be the one failure this check exists to prevent.
+ *
+ * @param sourceRef - The manifest's comma-joined provenance string.
+ * @returns One passing item per pack, in the order the pack records them.
+ */
+function packItems(sourceRef) {
+    return sourceRef
+        .split(",")
+        .map((ref) => ref.trim())
+        .filter((ref) => ref !== "")
+        .map((ref) => {
+        const parsed = /^(.+)@(git|npm|self|file|link):(.+)$/.exec(ref);
+        if (parsed === null)
+            return { label: ref, status: "pass" };
+        const [, pack, scheme, revision] = parsed;
+        const short = scheme === "git" && /^[0-9a-f]{40}$/.test(revision)
+            ? revision.slice(0, 7)
+            : revision;
+        return {
+            label: pack,
+            detail: `${scheme} ${short}`,
+            status: "pass",
+        };
+    });
+}
+/**
+ * Report which pack answers reads, its provenance, and its entity total.
+ *
+ * @param rt - The per-invocation runtime.
+ * @returns A CheckResult naming the answering pack, or the failure to build one.
+ * @note Impure — reads config, the active-pack pointer, and the pack index.
+ */
+export async function checkPackageRefs(rt) {
+    const decision = resolveSources(await rt.loadConfig(), rt.cwd);
+    // The display says "packs" (config declarations); the file/function keep
+    // "Package" (npm/git resolution vocabulary).
+    const name = "pack refs";
+    if (decision.kind === "unavailable") {
+        return {
+            name,
+            status: "fail",
+            detail: decision.reason,
+            remedy: `${BIN_NAME} sources update`,
+        };
+    }
+    const index = readPackIndex(decision);
+    const entities = (index ? entityTotal(index) : 0).toLocaleString();
+    // The pack DOES answer reads, so the check itself passes; the ignored stories
+    // are failing sub-items under it. (A `warn` status would ripple through the
+    // renderer and the DoctorData counts to buy an icon.)
+    const ignored = await ignoredStoryItems(decision);
+    const suffix = ignoredSuffix(ignored);
+    const sourceRef = decision.kind === "embedded"
+        ? embeddedManifest().sourceRef
+        : (readManifest(decision.dir)?.sourceRef ?? "");
+    // Packs first, then anything wrong with them: the composition is the answer to
+    // "which revision am I reading", and a failing story is a note about one of
+    // the rows above it.
+    const packs = packItems(sourceRef);
+    const items = [...packs, ...ignored];
+    const composition = `${packs.length} ${packs.length === 1 ? "pack" : "packs"}, ${entities} entities${suffix}`;
+    if (decision.kind === "embedded") {
+        return {
+            name,
+            status: "pass",
+            // The update hint stays in the DETAIL rather than moving to `remedy`:
+            // the renderer prints a remedy only where there is something to fix or
+            // to finish, and a snapshot that is answering reads correctly is
+            // neither. "shipped with the CLI" rather than "embedded snapshot" — the
+            // reader needs to know where these packs came from, not what the build
+            // calls the artefact.
+            detail: `shipped with the CLI — ${composition} · run \`${BIN_NAME} sources update\` to build from your own configured packs instead`,
+            ...(items.length > 0 ? { items } : {}),
+        };
+    }
+    const manifest = readManifest(decision.dir);
+    return {
+        name,
+        status: "pass",
+        detail: packs.length > 0
+            ? `built ${manifest?.createdAt ?? "?"} — ${composition}`
+            : `${decision.contentHash.slice(0, 12)} — ${composition}, built ${manifest?.createdAt ?? "?"}`,
+        ...(items.length > 0 ? { items } : {}),
+    };
+}
+//# sourceMappingURL=checkPackageRefs.js.map

package/dist/src/capabilities/doctor/checks/checkPackageRefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkPackageRefs.js","sourceRoot":"","sources":["../../../../../src/capabilities/doctor/checks/checkPackageRefs.ts"],"names":[],"mappings":"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"}

package/dist/src/capabilities/doctor/checks/checkPragmaVersion.js

@@ -0,0 +1,19 @@
+import { BIN_NAME } from "../../../constants.js";
+import { detectInstallSource } from "../../shared/index.js";
+/**
+ * Report the CLI version and how it was installed. Always passes — purely
+ * informational.
+ *
+ * @param rt - The per-invocation runtime (for `version`).
+ * @returns A CheckResult with version and install details.
+ * @note Impure — reads the process for the install heuristic.
+ */
+export async function checkPragmaVersion(rt) {
+    const install = detectInstallSource();
+    return {
+        name: `${BIN_NAME} version`,
+        status: "pass",
+        detail: `v${rt.version} (installed via ${install.label})`,
+    };
+}
+//# sourceMappingURL=checkPragmaVersion.js.map

package/dist/src/capabilities/doctor/checks/checkPragmaVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkPragmaVersion.js","sourceRoot":"","sources":["../../../../../src/capabilities/doctor/checks/checkPragmaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,EAAiB;IAEjB,MAAM,OAAO,GAAG,mBAAmB,EAAE,CAAC;IACtC,OAAO;QACL,IAAI,EAAE,GAAG,QAAQ,UAAU;QAC3B,MAAM,EAAE,MAAM;QACd,MAAM,EAAE,IAAI,EAAE,CAAC,OAAO,mBAAmB,OAAO,CAAC,KAAK,GAAG;KAC1D,CAAC;AACJ,CAAC"}

package/dist/src/capabilities/doctor/checks/checkShellCompletions.js

@@ -0,0 +1,199 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { BIN_NAME } from "../../../constants.js";
+import { emitScripts, indexCompletionEnv, runComplete, } from "../../../kernel/completion/index.js";
+import { capabilities } from "../../index.js";
+import { activationHint } from "../../setup/shell.js";
+const NAME = "Shell completions";
+/** The one remedy for an absent or out-of-date script. */
+const INSTALL_REMEDY = `${BIN_NAME} setup completions`;
+/**
+ * Whether the installed script is the config-free emit — the body
+ * `setup completions` writes when no `completion` config tunes it.
+ *
+ * The completion script is ONE file per user, but the `completion` config it is
+ * rendered from is layered per project. So `detectCompletions(cwd)`'s `stale`
+ * means only "not what THIS directory would write", and on its own it would let
+ * any project that tunes `minChars` call a globally-correct script out of date
+ * from every other directory — a `doctor` verdict that flips with `cd`, and a
+ * remedy that just moves the failure to the project you came from. A script
+ * that matches neither this project's body nor the untuned one is the one that
+ * is genuinely stale.
+ *
+ * @param path - The install path.
+ * @param shell - The detected shell.
+ * @returns Whether the file there is byte-identical to the untuned emit.
+ * @note Impure — reads the install path. An unreadable file counts as `false`.
+ */
+function isUntunedScript(path, shell) {
+    try {
+        return readFileSync(path, "utf-8") === emitScripts(capabilities)[shell];
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether the user's `.zshrc` puts `~/.zfunc` on `$fpath` — the activation step
+ * `setup completions` cannot perform for the user. zsh loads nothing from
+ * `~/.zfunc` unless it is on `fpath` before `compinit`, so an installed script
+ * with no fpath wiring is silently dead. A permissive check: any `fpath` line
+ * mentioning `.zfunc` counts (we can't parse ordering statically).
+ */
+function zfuncOnFpath() {
+    try {
+        const rc = readFileSync(join(homedir(), ".zshrc"), "utf-8");
+        return rc
+            .split("\n")
+            .some((line) => line.includes("fpath") && line.includes(".zfunc"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Drive the storeless `__complete` resolver and observe that it answers — the
+ * completion effect the installed script delegates every name context to. Uses
+ * the noun context (`pragma <TAB>`), which is grammar-derived and never empty,
+ * so a zero here means the resolver itself is broken, independent of any pack.
+ *
+ * @param cwd - The project directory (wires the entity seam, though the noun
+ *   context does not read it).
+ * @returns The number of candidates the resolver returned for a bare `pragma `.
+ */
+async function completeProbe(cwd) {
+    const matches = await runComplete([""], capabilities, indexCompletionEnv(cwd));
+    return matches.length;
+}
+/**
+ * Check that shell completions are installed AND up to date AND functional.
+ *
+ * Three gates, in order:
+ * 1. The resolver answers (`completeProbe` drives `runComplete` end to end) —
+ *    the effect every installed script depends on. A failure here is a real
+ *    regression, so it fails even when nothing is installed.
+ * 2. The installed script is present AND is a script `setup completions` would
+ *    write. Bytes, not existence: a file that merely exists proves nothing — a
+ *    user upgrading across a grammar change keeps the old script, loses the
+ *    moved nouns from TAB, and used to be told everything was fine. The path
+ *    and this project's body come from `detectCompletions`, the ONE owner of
+ *    that decision; {@link isUntunedScript} is what keeps a per-project
+ *    `completion` config from condemning a global file (see its docblock).
+ * 3. For zsh, `~/.zfunc` is on `$fpath` — the activation step setup can only
+ *    hint. Installed-but-unwired reports a distinct remedy.
+ *
+ * Fault tiers: a broken resolver, a stale installed script, or an unwired zsh
+ * install are `fail` — something that exists does not work. A script that was
+ * never installed is `available`: completions are opt-in and a fresh install
+ * is healthy without them.
+ *
+ * The detection is passed IN rather than re-read: the `completions` target
+ * detects once per invocation and both the setup plan and this row read that
+ * one answer, so the two surfaces cannot describe different files.
+ *
+ * @param cwd - The project directory (the resolver's entity seam).
+ * @param d - The `completions` target's detection for this invocation.
+ * @returns A CheckResult: pass (up to date + wired + answering), available
+ *   (never installed, with the setup remedy), fail (with the attributable
+ *   remedy), or skip (shell undetected).
+ * @note Impure — reads the install path, `.zshrc`, and drives the resolver.
+ */
+export async function checkShellCompletions(cwd, d) {
+    // 1. Effect test: the resolver the scripts delegate to must actually answer.
+    let candidates;
+    try {
+        candidates = await completeProbe(cwd);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return {
+            name: NAME,
+            status: "fail",
+            detail: `${BIN_NAME} cannot answer \`<TAB>\`: ${reason}`,
+            remedy: `Report this as a bug — \`${BIN_NAME} __complete\` should never throw.`,
+        };
+    }
+    if (candidates === 0) {
+        return {
+            name: NAME,
+            status: "fail",
+            detail: `${BIN_NAME} answered \`<TAB>\` with nothing to complete`,
+            remedy: "Report this as a bug — the noun context is always non-empty.",
+        };
+    }
+    // 2. The check is about the shell the user is IN. Reporting on the login
+    //    shell instead is what let this row print a green check for a shell the
+    //    user never opens while the one they live in had nothing installed.
+    const { shell, path, state } = d;
+    if (d.detection.kind === "ambiguous") {
+        return {
+            name: NAME,
+            status: "skip",
+            detail: `${BIN_NAME} answers \`<TAB>\`, but the running shell cannot be identified — SHELL names ${d.detection.login}, which is your login shell`,
+            remedy: `Run \`${INSTALL_REMEDY}\` from the shell you want completions in.`,
+        };
+    }
+    if (shell === null || path === null) {
+        return {
+            name: NAME,
+            status: "skip",
+            detail: `${BIN_NAME} answers \`<TAB>\`, but no bash, zsh, or fish was found in this process tree`,
+        };
+    }
+    // The installed script delegates every name context to the binary. A script
+    // that cannot reach it is inert, and reporting it as current is the same
+    // false green this row already told once.
+    //
+    // This gate runs BEFORE the install probe, so it says only what it has
+    // verified: that the binary does not resolve. Claiming "script installed" here
+    // told a user running this CLI by absolute path that a script they had never
+    // installed was broken — an invented file, in the row whose whole job is to
+    // report the real one. Nothing installed is still the opt-in `available` tier.
+    if (!d.binOnPath) {
+        const installed = state !== "absent";
+        return {
+            name: NAME,
+            status: installed ? "fail" : "available",
+            detail: installed
+                ? `${shell} script installed, but \`${BIN_NAME}\` is not on PATH — the script cannot run it`
+                : `${BIN_NAME} answers \`<TAB>\`, but is not on PATH — an installed script cannot run it`,
+            remedy: `Put \`${BIN_NAME}\` on your PATH.`,
+        };
+    }
+    if (state === "absent") {
+        // Never installed is `available`, not a fault: completions are opt-in and
+        // a fresh install is healthy without them. An INSTALLED script that is
+        // out of date or unwired (below) is the real failure — something the user
+        // set up no longer works.
+        return {
+            name: NAME,
+            status: "available",
+            detail: `${BIN_NAME} answers \`<TAB>\`; the ${shell} script is not installed`,
+            remedy: INSTALL_REMEDY,
+        };
+    }
+    if (state === "stale" && !isUntunedScript(path, shell)) {
+        return {
+            name: NAME,
+            status: "fail",
+            detail: `${BIN_NAME} answers \`<TAB>\`; the ${shell} script at ${path} is out of date`,
+            remedy: INSTALL_REMEDY,
+        };
+    }
+    // 3. zsh only: the script is dead unless ~/.zfunc is on $fpath.
+    if (shell === "zsh" && !zfuncOnFpath()) {
+        return {
+            name: NAME,
+            status: "fail",
+            detail: `installed at ${path}, but ~/.zfunc is not on your fpath`,
+            remedy: activationHint("zsh"),
+        };
+    }
+    return {
+        name: NAME,
+        status: "pass",
+        detail: `${shell} (the shell you are in) — installed, up to date, and completing ${candidates} commands`,
+    };
+}
+//# sourceMappingURL=checkShellCompletions.js.map

package/dist/src/capabilities/doctor/checks/checkShellCompletions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkShellCompletions.js","sourceRoot":"","sources":["../../../../../src/capabilities/doctor/checks/checkShellCompletions.ts"],"names":[],"mappings":"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"}

package/dist/src/capabilities/doctor/checks/harnessInventory.js

@@ -0,0 +1,195 @@
+/**
+ * The harness inventory: one row per harness per scope, saying what was detected
+ * and whether pragma is registered in it.
+ *
+ * Every fact this needs was ALREADY COMPUTED and thrown away.
+ * `TargetGroup.harnessNames` carries every harness sharing a config file and
+ * both consumers reduced it to `shortenPath(group.path)`; `McpDetection`
+ * carries the `absent`/`registered`/`drifted` classification of every WRITE in
+ * that file. The only thing detection could NOT answer is the negative —
+ * `detectHarnesses` filters to hits, so a harness the machine does not have was
+ * unrepresentable — which is why the roll-up takes the REGISTRY alongside the
+ * groups: the registry supplies the universe, the groups supply the state.
+ *
+ * The state arrives PER HARNESS, never per file. A shared `.vscode/mcp.json`
+ * holds VS Code's `servers` and Cline's `mcpServers` as two independent
+ * entries, so the file's aggregate — `drifted`, when one key is current and the
+ * other absent — is the standing of NEITHER harness. Pairing each name with
+ * the write it owns is the caller's job (it holds the registry's `mcpKey`s and
+ * the group's writes); by the time a group reaches this module the association
+ * is resolved and every name carries its own state.
+ *
+ * Three deliberate constraints:
+ *
+ * 1. **No `@canonical/harnesses` import, of any kind.** `capabilities/lazy.test`
+ *    forbids one from any file statically reachable from `capabilities/index`,
+ *    and its regex has no `import type` exemption. This module is reached only
+ *    through `runChecks`'s dynamic import today, but it is written so that
+ *    staying legal never depends on that: the inputs are declared here as
+ *    narrow structural records.
+ *
+ * 2. **Narrowed to DATA, so `mutates: false` is enforced rather than asserted.**
+ *    `McpDetection` is write-capable — it carries `writeMcpConfigTargets` and
+ *    `removeMcpConfigFrom` as live function references. Projecting it down to
+ *    {@link InventoryGroup} before it reaches this file means a read-only
+ *    report literally cannot reach a writer.
+ *
+ * 3. **It never invents a failure.** The states an inventory can report map onto
+ *    `pass`/`available`/`skip` and NEVER `fail` (see `../types.ts`): a machine
+ *    that simply does not have Windsurf is not a broken machine, and the `mcp`
+ *    row already owns the actionable finding for the harnesses it does have.
+ *    Reporting it twice is how a failure count becomes noise.
+ *
+ * Placement: this is a doctor helper because doctor is its only consumer today,
+ * and `shared/` is explicitly not a utility drawer (see `shared/index.ts`). It
+ * is written to MOVE there unchanged — pure, no capability imports beyond the
+ * scope type — the moment `setup`'s detection summary becomes the second caller.
+ */
+/** Whether a state means "this harness is on the machine". */
+export const isDetectedState = (state) => state === "registered" || state === "drifted" || state === "detected";
+/**
+ * Roll one scope's detected config groups up against the registry into one row
+ * per harness.
+ *
+ * Groups are keyed by harness NAME because that is the only identity
+ * `TargetGroup` records; the registry is the map back to an id, which is why it
+ * is a parameter rather than a lookup. A harness naming no registry row is
+ * ignored rather than invented — the inventory reports on the registry, not on
+ * whatever a group happened to say.
+ *
+ * @param registry - Every known harness, each flagged for scope membership.
+ * @param groups - This scope's detected config files (narrowed, path-shortened),
+ *   each naming the harnesses that share it with their own per-write state.
+ * @param scope - The scope being rolled up.
+ * @returns One row per registry harness, in registry order.
+ * @note Pure — it reads no filesystem and holds no live effect.
+ */
+export function harnessInventory(registry, groups, scope) {
+    const states = new Map();
+    const locations = new Map();
+    for (const group of groups) {
+        for (const member of group.harnesses) {
+            const paths = locations.get(member.name) ?? [];
+            paths.push(group.path);
+            locations.set(member.name, paths);
+            // A harness sharing two files is registered only where EVERY one of them
+            // carries the current entry — the same "all or nothing" rule
+            // `aggregateMcpStates` applies across the writes within a single file.
+            const prior = states.get(member.name);
+            states.set(member.name, prior === undefined || prior === member.state
+                ? member.state
+                : "drifted");
+        }
+    }
+    return registry.map((harness) => {
+        const detected = states.get(harness.name);
+        const paths = locations.get(harness.name) ?? [];
+        const state = detected === undefined
+            ? harness.inScope
+                ? "undetected"
+                : "unscoped"
+            : detected === "registered"
+                ? "registered"
+                : detected === "drifted"
+                    ? "drifted"
+                    : "detected";
+        return {
+            harnessId: harness.id,
+            harnessName: harness.name,
+            scope,
+            state,
+            locations: paths,
+        };
+    });
+}
+/** The per-item status each state renders as. Never `fail` — see the docblock. */
+const STATE_STATUS = {
+    registered: "pass",
+    drifted: "available",
+    detected: "available",
+    undetected: "skip",
+    unscoped: "skip",
+};
+/**
+ * The phrase each state reads as, scope-aware for the unscoped case.
+ *
+ * The unscoped line says WHERE the harness keeps its config rather than naming
+ * an internal partition. `no Global band` told the reader nothing: "band" was
+ * this repository's word, and the fact underneath it — VS Code stores its MCP
+ * config per project, so there is no global file for pragma to be in — is the
+ * thing that explains the row.
+ */
+const stateDetail = (row) => {
+    switch (row.state) {
+        case "registered":
+            return "registered";
+        case "drifted":
+            return "registered, entry differs from current";
+        case "detected":
+            return "detected, not registered";
+        case "undetected":
+            return "not detected";
+        case "unscoped":
+            return row.scope === "global"
+                ? "keeps no global config — it is per-project only"
+                : "keeps no per-project config — it is global only";
+    }
+};
+/**
+ * Project inventory rows into doctor sub-items.
+ *
+ * The default listing is DETECTED HARNESSES ONLY — a report that names every
+ * tool the user does not have buries the ones they do. `--verbose` widens it to
+ * the whole registry, which is the only view in which `undetected`/`unscoped`
+ * rows appear at all.
+ *
+ * @param rows - This scope's inventory rows.
+ * @param verbose - Whether to list the whole registry rather than the hits.
+ * @returns The sub-items, harness name in the left column.
+ */
+export function inventoryItems(rows, verbose) {
+    const shown = verbose
+        ? rows
+        : rows.filter((row) => isDetectedState(row.state));
+    return shown.map((row) => {
+        const where = row.locations.join(", ");
+        return {
+            label: row.harnessName,
+            status: STATE_STATUS[row.state],
+            detail: where ? `${stateDetail(row)} — ${where}` : stateDetail(row),
+        };
+    });
+}
+/**
+ * The whole inventory row for one scope: a listing, not a verdict.
+ *
+ * Its status is only ever `pass` (this scope has harnesses) or `skip` (it has
+ * none). It is the one scoped row that is not a setup target, so it derives no
+ * `fix:` line — the `mcp` and `skills` rows beside it own every action a
+ * harness can need, and a second row proposing the same command would be the
+ * "same finding seen twice" the report is built to avoid.
+ *
+ * @param rows - This scope's inventory rows.
+ * @param verbose - Whether the listing widens to the whole registry.
+ * @returns The status, headline and sub-items for the scope's inventory check.
+ */
+export function inventoryHealth(rows, verbose) {
+    const detected = rows.filter((row) => isDetectedState(row.state));
+    const registered = rows.filter((row) => row.state === "registered");
+    const items = inventoryItems(rows, verbose);
+    if (detected.length === 0) {
+        return {
+            status: "skip",
+            detail: verbose
+                ? `none of ${rows.length} known harnesses detected`
+                : "no harnesses detected",
+            items,
+        };
+    }
+    return {
+        status: "pass",
+        detail: `${detected.length} detected · ${registered.length} registered${verbose ? ` · ${rows.length} known` : ""}`,
+        items,
+    };
+}
+//# sourceMappingURL=harnessInventory.js.map

package/dist/src/capabilities/doctor/checks/harnessInventory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harnessInventory.js","sourceRoot":"","sources":["../../../../../src/capabilities/doctor/checks/harnessInventory.ts"],"names":[],"mappings":"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"}

package/dist/src/capabilities/doctor/checks/index.js

@@ -0,0 +1,27 @@
+/**
+ * The doctor check catalogue — the diagnoses `doctor` composes into a report.
+ *
+ * A check is the whole shape of this domain: it inspects ONE thing, decides
+ * pass or fail, and hands back a `CheckResult` carrying the remedy. Keeping
+ * them apart from the report body is what lets `runChecks` stay a composition
+ * — it orders and awaits, and knows nothing about what any check looks at.
+ *
+ * Two kinds live here, and the barrel exposes them differently. The UNSCOPED
+ * checks diagnose what `setup` cannot install — the Node floor, the CLI's own
+ * version and install source, the pack answering this project's reads, and the
+ * store — so each is its own named entry point. The SCOPED rows are derived
+ * per target, per scope, from the setup target table rather than authored here,
+ * so they surface as the one generator that derives them, never as a list of
+ * row names this file would then have to keep in step with `setup`.
+ *
+ * The per-target probes (the completions script check, the MCP command
+ * resolution helpers) stay internal on purpose: `scopedChecks` is the only way
+ * they are meant to be reached, and a row reachable past its scope is a row
+ * `doctor` can report and `setup` cannot fix.
+ */
+export { checkKeStore } from "./checkKeStore.js";
+export { checkNodeVersion } from "./checkNodeVersion.js";
+export { checkPackageRefs } from "./checkPackageRefs.js";
+export { checkPragmaVersion } from "./checkPragmaVersion.js";
+export { scopedChecks } from "./targetHealth.js";
+//# sourceMappingURL=index.js.map

package/dist/src/capabilities/doctor/checks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/capabilities/doctor/checks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}