peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/services/doctor/doctor-service/checks/skill-presence.js

@@ -0,0 +1,75 @@
+/**
+ * Check: skill presence current + freshness
+ * (`skill-presence:current` and `skill-presence:freshness`).
+ *
+ * Two checks sharing one read of the `presence` context field.
+ *   - `skill-presence:current` is informational: passes when the
+ *     presence is wired, with a message describing the active
+ *     skill / mode / gate / setAt. When no presence is wired, it
+ *     also passes (absence is the common case outside peaks-qa
+ *     flows).
+ *   - `skill-presence:freshness` is the operational gate: fails
+ *     when the presence's `setAt` is older than the freshness
+ *     threshold (default 24h) OR when `setAt` is unparsable. When
+ *     no presence is wired it passes trivially ("nothing to age-
+ *     check").
+ *
+ * Both checks share the presence signal computed once in
+ * `index.ts`; the legacy monolithic function probed it inline.
+ */
+const SKILL_PRESENCE_FRESHNESS_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function run({ options, presence }) {
+    const freshnessThresholdMs = options.skillPresenceFreshnessThresholdMs ?? SKILL_PRESENCE_FRESHNESS_THRESHOLD_MS;
+    if (presence === null) {
+        return [
+            {
+                id: 'skill-presence:current',
+                ok: true,
+                message: 'No active Peaks skill presence (.peaks/.active-skill.json absent or invalid)'
+            },
+            {
+                id: 'skill-presence:freshness',
+                ok: true,
+                message: 'No active Peaks skill presence to age-check'
+            }
+        ];
+    }
+    const modePart = presence.mode !== undefined ? `, mode ${presence.mode}` : '';
+    const gatePart = presence.gate !== undefined ? `, gate ${presence.gate}` : '';
+    const checks = [{
+            id: 'skill-presence:current',
+            ok: true,
+            message: `Active Peaks skill presence: ${presence.skill}${modePart}${gatePart} (set ${presence.setAt})`
+        }];
+    const setAtMs = Date.parse(presence.setAt);
+    if (Number.isNaN(setAtMs)) {
+        checks.push({
+            id: 'skill-presence:freshness',
+            ok: false,
+            message: `Skill presence ${presence.skill} has invalid setAt: ${presence.setAt}`
+        });
+    }
+    else {
+        const ageMs = Date.now() - setAtMs;
+        if (ageMs > freshnessThresholdMs) {
+            const ageHours = Math.round(ageMs / (60 * 60 * 1000));
+            checks.push({
+                id: 'skill-presence:freshness',
+                ok: false,
+                message: `Skill presence ${presence.skill} is stale (set ${presence.setAt}, ~${ageHours}h ago); run peaks skill presence:clear if the role has ended`
+            });
+        }
+        else {
+            checks.push({
+                id: 'skill-presence:freshness',
+                ok: true,
+                message: `Skill presence ${presence.skill} is fresh (set ${presence.setAt})`
+            });
+        }
+    }
+    return checks;
+}
+export const check = {
+    name: 'skill-presence',
+    run
+};

package/dist/services/doctor/doctor-service/checks/skill-runbook.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Check: required skill declares a `## Default runbook` section
+ * (`skill-runbook:<skill-name>`).
+ *
+ * Emits one `DoctorCheck` per *required* skill (we don't gate
+ * user-added skills; only the ones the doctor guarantees exist).
+ * Passes when the SKILL.md body contains a `## Default runbook`
+ * heading; fails with an actionable "missing a ## Default runbook
+ * section" message. Read failures degrade to a single
+ * `skill-runbook:<name>` fail (no second `skill-apply-note`
+ * emitted for the same skill).
+ */
+import type { DoctorCheckPlugin } from '../types.js';
+export declare const check: DoctorCheckPlugin;

package/dist/services/doctor/doctor-service/checks/skill-runbook.js

@@ -0,0 +1,47 @@
+/**
+ * Check: required skill declares a `## Default runbook` section
+ * (`skill-runbook:<skill-name>`).
+ *
+ * Emits one `DoctorCheck` per *required* skill (we don't gate
+ * user-added skills; only the ones the doctor guarantees exist).
+ * Passes when the SKILL.md body contains a `## Default runbook`
+ * heading; fails with an actionable "missing a ## Default runbook
+ * section" message. Read failures degrade to a single
+ * `skill-runbook:<name>` fail (no second `skill-apply-note`
+ * emitted for the same skill).
+ */
+import { readText } from 'peaks-loop-shared/fs';
+import { requiredSkillNames } from 'peaks-loop-shared/paths';
+import { getErrorMessage } from 'peaks-loop-shared/result';
+const REQUIRED_SKILL_NAMES = new Set(requiredSkillNames);
+async function run({ registry }) {
+    const checks = [];
+    for (const skill of registry.skills) {
+        if (!REQUIRED_SKILL_NAMES.has(skill.name)) {
+            continue;
+        }
+        try {
+            const body = await readText(skill.skillPath);
+            const hasRunbook = /## Default runbook\s/.test(body);
+            checks.push({
+                id: `skill-runbook:${skill.name}`,
+                ok: hasRunbook,
+                message: hasRunbook
+                    ? `Skill ${skill.name} declares a Default runbook`
+                    : `Skill ${skill.name} is missing a ## Default runbook section`
+            });
+        }
+        catch (error) {
+            checks.push({
+                id: `skill-runbook:${skill.name}`,
+                ok: false,
+                message: `Skill ${skill.name} runbook check failed: ${getErrorMessage(error)}`
+            });
+        }
+    }
+    return checks;
+}
+export const check = {
+    name: 'skill-runbook',
+    run
+};

package/dist/services/doctor/doctor-service/checks/statusline-install.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Check: statusline install discovery nudge (`statusline:install`).
+ *
+ * Informational only (always passes). When a Peaks skill is active
+ * but the statusLine is not installed, the message suggests running
+ * `peaks statusline install` so the active skill shows in the
+ * terminal status bar. When no skill is active, the message
+ * downgrades to "install is optional".
+ *
+ * The check is non-failing because the statusline is a UI
+ * accelerator — its absence does not break the doctor pipeline.
+ */
+import type { DoctorCheckPlugin } from '../types.js';
+export declare const check: DoctorCheckPlugin;

package/dist/services/doctor/doctor-service/checks/statusline-install.js

@@ -0,0 +1,32 @@
+/**
+ * Check: statusline install discovery nudge (`statusline:install`).
+ *
+ * Informational only (always passes). When a Peaks skill is active
+ * but the statusLine is not installed, the message suggests running
+ * `peaks statusline install` so the active skill shows in the
+ * terminal status bar. When no skill is active, the message
+ * downgrades to "install is optional".
+ *
+ * The check is non-failing because the statusline is a UI
+ * accelerator — its absence does not break the doctor pipeline.
+ */
+function run({ presence, statusLineInstalled }) {
+    if (presence !== null && !statusLineInstalled) {
+        return [{
+                id: 'statusline:install',
+                ok: true,
+                message: 'A Peaks skill is active but the statusLine is not installed; run `peaks statusline install` so the active skill shows in the terminal status bar'
+            }];
+    }
+    return [{
+            id: 'statusline:install',
+            ok: true,
+            message: statusLineInstalled
+                ? 'Peaks statusLine is installed'
+                : 'Peaks statusLine not installed (no active skill; install optional)'
+        }];
+}
+export const check = {
+    name: 'statusline-install',
+    run
+};

package/dist/services/doctor/doctor-service/checks/statusline-runtime.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Check: statusline runtime diagnostic (`statusline:runtime`).
+ *
+ * Informational only (always passes). Reports the running peaks
+ * version + platform string. On Windows, adds a hint that the
+ * statusLine shows nothing in git bash when `peaks` is not on PATH
+ * in the shell Claude Code spawns — the user must reinstall
+ * globally if the version is older than `CLI_VERSION` and reload
+ * Claude Code. On other platforms, the message is a short platform
+ * marker.
+ */
+import type { DoctorCheckPlugin } from '../types.js';
+export declare const check: DoctorCheckPlugin;

package/dist/services/doctor/doctor-service/checks/statusline-runtime.js

@@ -0,0 +1,30 @@
+/**
+ * Check: statusline runtime diagnostic (`statusline:runtime`).
+ *
+ * Informational only (always passes). Reports the running peaks
+ * version + platform string. On Windows, adds a hint that the
+ * statusLine shows nothing in git bash when `peaks` is not on PATH
+ * in the shell Claude Code spawns — the user must reinstall
+ * globally if the version is older than `CLI_VERSION` and reload
+ * Claude Code. On other platforms, the message is a short platform
+ * marker.
+ */
+import { CLI_VERSION } from 'peaks-loop-shared/version';
+function run({ platform }) {
+    if (platform === 'win32') {
+        return [{
+                id: 'statusline:runtime',
+                ok: true,
+                message: `peaks ${CLI_VERSION} (win32): if the statusLine shows nothing in git bash, verify \`peaks\` resolves on PATH in the shell Claude Code uses (run \`peaks -v\` there), reinstall globally with \`npm i -g peaks-loop@latest\` if the version is older than ${CLI_VERSION}, then re-run \`peaks statusline install\` and reload Claude Code`
+            }];
+    }
+    return [{
+            id: 'statusline:runtime',
+            ok: true,
+            message: `peaks ${CLI_VERSION} (${platform}): statusLine command is \`peaks statusline\``
+        }];
+}
+export const check = {
+    name: 'statusline-runtime',
+    run
+};

package/dist/services/doctor/doctor-service/checks/user-config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Check: optional user config presence (`config:user`).
+ *
+ * Single informational check that flags whether the user has a
+ * personal `~/.peaks/config.json`. This check NEVER fails
+ * (presence is optional) — it just tells the operator the file
+ * is present vs absent so they can correlate it with later
+ * "user-config says X" surprises.
+ */
+import type { DoctorCheckPlugin } from '../types.js';
+export declare const check: DoctorCheckPlugin;

package/dist/services/doctor/doctor-service/checks/user-config.js

@@ -0,0 +1,27 @@
+/**
+ * Check: optional user config presence (`config:user`).
+ *
+ * Single informational check that flags whether the user has a
+ * personal `~/.peaks/config.json`. This check NEVER fails
+ * (presence is optional) — it just tells the operator the file
+ * is present vs absent so they can correlate it with later
+ * "user-config says X" surprises.
+ */
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function run() {
+    const userConfigPath = join(homedir(), '.peaks', 'config.json');
+    const hasUserConfig = existsSync(userConfigPath);
+    return [{
+            id: 'config:user',
+            ok: true,
+            message: hasUserConfig
+                ? 'User config exists at ~/.peaks/config.json'
+                : 'Optional user config not found at ~/.peaks/config.json'
+        }];
+}
+export const check = {
+    name: 'user-config',
+    run
+};

package/dist/services/doctor/doctor-service/checks/workspace-init.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Check: workspace initialization guard (`skill-presence:workspace`).
+ *
+ * Fail-closed rule: when a skill is actively orchestrating AND the
+ * workspace session binding is absent, the check fails and tells the
+ * operator to run `peaks workspace init --project <repo>`. This is
+ * the #1 reported failure mode where `.peaks/` artifacts are never
+ * created — the SKILL.md "MUST create the workspace" prose turned
+ * into an executable check.
+ *
+ * When no skill is active, the check passes (workspace guard is
+ * N/A). When a skill IS active AND the workspace session exists,
+ * it also passes (the happy path).
+ */
+import type { DoctorCheckPlugin } from '../types.js';
+export declare const check: DoctorCheckPlugin;

package/dist/services/doctor/doctor-service/checks/workspace-init.js

@@ -0,0 +1,34 @@
+/**
+ * Check: workspace initialization guard (`skill-presence:workspace`).
+ *
+ * Fail-closed rule: when a skill is actively orchestrating AND the
+ * workspace session binding is absent, the check fails and tells the
+ * operator to run `peaks workspace init --project <repo>`. This is
+ * the #1 reported failure mode where `.peaks/` artifacts are never
+ * created — the SKILL.md "MUST create the workspace" prose turned
+ * into an executable check.
+ *
+ * When no skill is active, the check passes (workspace guard is
+ * N/A). When a skill IS active AND the workspace session exists,
+ * it also passes (the happy path).
+ */
+function run({ presence, workspaceInitialized }) {
+    if (presence !== null && !workspaceInitialized) {
+        return [{
+                id: 'skill-presence:workspace',
+                ok: false,
+                message: `Skill ${presence.skill} is active but no workspace session exists (.peaks/_runtime/session.json missing); run \`peaks workspace init --project <repo>\` — peaks-code Step 0 must anchor the workspace before any work`
+            }];
+    }
+    return [{
+            id: 'skill-presence:workspace',
+            ok: true,
+            message: presence === null
+                ? 'No active skill presence; workspace guard not applicable'
+                : `Workspace session present for active skill ${presence.skill}`
+        }];
+}
+export const check = {
+    name: 'workspace-init',
+    run
+};

package/dist/services/doctor/doctor-service/checks/workspace-layout.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Check: workspace layout is post-F3 canonical
+ * (`build:workspace-layout-canonical`).
+ *
+ * Build-hygiene check that surfaces any leftover top-level session
+ * dirs (`.peaks/<YYYY-MM-DD-session-<hex>>/`), the legacy runtime
+ * dotfiles (`.peaks/.session.json`, `.peaks/.active-skill.json`),
+ * OR per-change-id top-level dirs (`.peaks/NNN-YYYY-MM-DD-<slug>/`).
+ *
+ * The post-F3 canonical layout puts session dirs under
+ * `.peaks/_runtime/<sid>/` and the runtime binding at
+ * `.peaks/_runtime/session.json`. The legacy paths must be absent.
+ *
+ * The pure `inspectWorkspaceLayout` helper is exported so tests
+ * can drive the filesystem walk without monkey-patching
+ * `process.cwd()` or `findProjectRoot`. Both scanners fail-soft
+ * (return `[]` on read errors) so a flaky filesystem read on a
+ * non-fatal probe path never escalates into a doctor failure.
+ */
+import type { DoctorCheckPlugin, WorkspaceLayoutInspection } from '../types.js';
+/**
+ * Pure helper that inspects the on-disk workspace layout for
+ * post-F3-canonical violations. Exported so tests can drive the
+ * filesystem walk without monkey-patching `process.cwd()` or
+ * `findProjectRoot`.
+ */
+export declare function inspectWorkspaceLayout(opts: {
+    projectRoot: string;
+    topLevelScanner?: (root: string) => string[];
+    dotfileScanner?: (root: string) => string[];
+    perChangeIdScanner?: (root: string) => string[];
+}): WorkspaceLayoutInspection;
+export declare const check: DoctorCheckPlugin;

package/dist/services/doctor/doctor-service/checks/workspace-layout.js

@@ -0,0 +1,180 @@
+/**
+ * Check: workspace layout is post-F3 canonical
+ * (`build:workspace-layout-canonical`).
+ *
+ * Build-hygiene check that surfaces any leftover top-level session
+ * dirs (`.peaks/<YYYY-MM-DD-session-<hex>>/`), the legacy runtime
+ * dotfiles (`.peaks/.session.json`, `.peaks/.active-skill.json`),
+ * OR per-change-id top-level dirs (`.peaks/NNN-YYYY-MM-DD-<slug>/`).
+ *
+ * The post-F3 canonical layout puts session dirs under
+ * `.peaks/_runtime/<sid>/` and the runtime binding at
+ * `.peaks/_runtime/session.json`. The legacy paths must be absent.
+ *
+ * The pure `inspectWorkspaceLayout` helper is exported so tests
+ * can drive the filesystem walk without monkey-patching
+ * `process.cwd()` or `findProjectRoot`. Both scanners fail-soft
+ * (return `[]` on read errors) so a flaky filesystem read on a
+ * non-fatal probe path never escalates into a doctor failure.
+ */
+import { existsSync, lstatSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getErrorMessage } from 'peaks-loop-shared/result';
+const SESSION_DIR_PATTERN = /^\d{4}-\d{2}-\d{2}-session-[a-f0-9]+$/;
+/**
+ * Slice 007 — per-change-id top-level dir pattern. Matches the
+ * F3-canonical (pre-canonicalization) layout the 5 already-shipped
+ * slices left behind, e.g. `.peaks/001-2026-06-06-doctor-dist-version-check/`.
+ * The pattern is intentionally narrow so it does NOT match the
+ * post-F3 system dirs (`_runtime/`, `_dogfood/`, `retrospective/`,
+ * `memory/`, `perf-baseline/`, `project-scan/`, `sops/`,
+ * `0NN-session-...`, `YYYY-MM-DD-session-...`).
+ */
+const PER_CHANGE_ID_PATTERN = /^\d{3}-\d{4}-\d{2}-\d{2}-[a-z][a-z0-9-]*[a-z0-9]$/;
+const LEGACY_DOTFILES = ['.session.json', '.active-skill.json'];
+/**
+ * Pure helper that inspects the on-disk workspace layout for
+ * post-F3-canonical violations. Exported so tests can drive the
+ * filesystem walk without monkey-patching `process.cwd()` or
+ * `findProjectRoot`.
+ */
+export function inspectWorkspaceLayout(opts) {
+    const topLevel = opts.topLevelScanner ?? defaultTopLevelSessionDirScanner;
+    const dotfiles = opts.dotfileScanner ?? defaultLegacyDotfileScanner;
+    const perChangeId = opts.perChangeIdScanner ?? defaultPerChangeIdDirScanner;
+    return {
+        topLevelSessionDirs: safeList(() => topLevel(opts.projectRoot)),
+        legacyDotfiles: safeList(() => dotfiles(opts.projectRoot)),
+        perChangeIdDirs: safeList(() => perChangeId(opts.projectRoot))
+    };
+}
+function safeList(reader) {
+    try {
+        const out = reader();
+        return Array.isArray(out) ? out : [];
+    }
+    catch {
+        return [];
+    }
+}
+function defaultTopLevelSessionDirScanner(projectRoot) {
+    const peaksRoot = join(projectRoot, '.peaks');
+    if (!existsSync(peaksRoot))
+        return [];
+    let names;
+    try {
+        names = readdirSync(peaksRoot);
+    }
+    catch {
+        return [];
+    }
+    const offenders = [];
+    for (const name of names) {
+        if (!SESSION_DIR_PATTERN.test(name))
+            continue;
+        const full = join(peaksRoot, name);
+        try {
+            const stat = existsSync(full) ? lstatSync(full) : null;
+            if (stat === null)
+                continue;
+            // Directories only — the regex should never match a dotfile or
+            // regular file, but be defensive against weird filesystem state
+            // (e.g. someone manually created a file whose name happens to
+            // match the session-id pattern).
+            if (stat.isDirectory()) {
+                offenders.push(join('.peaks', name) + '/');
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return offenders;
+}
+function defaultLegacyDotfileScanner(projectRoot) {
+    const peaksRoot = join(projectRoot, '.peaks');
+    if (!existsSync(peaksRoot))
+        return [];
+    const offenders = [];
+    for (const name of LEGACY_DOTFILES) {
+        if (existsSync(join(peaksRoot, name))) {
+            offenders.push(join('.peaks', name));
+        }
+    }
+    return offenders;
+}
+function defaultPerChangeIdDirScanner(projectRoot) {
+    const peaksRoot = join(projectRoot, '.peaks');
+    if (!existsSync(peaksRoot))
+        return [];
+    let names;
+    try {
+        names = readdirSync(peaksRoot);
+    }
+    catch {
+        return [];
+    }
+    const offenders = [];
+    for (const name of names) {
+        if (!PER_CHANGE_ID_PATTERN.test(name))
+            continue;
+        const full = join(peaksRoot, name);
+        try {
+            const stat = existsSync(full) ? lstatSync(full) : null;
+            if (stat === null)
+                continue;
+            if (stat.isDirectory()) {
+                offenders.push(join('.peaks', name) + '/');
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return offenders;
+}
+function defaultWorkspaceLayoutProbe(projectRootResolver) {
+    const projectRoot = projectRootResolver();
+    if (projectRoot === null) {
+        return { topLevelSessionDirs: [], legacyDotfiles: [], perChangeIdDirs: [] };
+    }
+    return inspectWorkspaceLayout({ projectRoot });
+}
+function run({ options, projectRootResolver }) {
+    const probe = options.workspaceLayoutProbe ?? (() => defaultWorkspaceLayoutProbe(projectRootResolver));
+    try {
+        const layout = probe();
+        // Back-compat: probes injected by older tests (pre-slice-007)
+        // return a 2-field shape (no perChangeIdDirs). Treat missing
+        // field as empty.
+        const perChangeIdDirs = layout.perChangeIdDirs ?? [];
+        if (layout.topLevelSessionDirs.length === 0 && layout.legacyDotfiles.length === 0 && perChangeIdDirs.length === 0) {
+            return [{
+                    id: 'build:workspace-layout-canonical',
+                    ok: true,
+                    message: 'Workspace layout is canonical: no top-level session dirs, no legacy runtime dotfiles, no per-change-id top-level dirs'
+                }];
+        }
+        const offenders = [
+            ...layout.topLevelSessionDirs.map((p) => `top-level session dir: ${p}`),
+            ...layout.legacyDotfiles.map((p) => `legacy dotfile: ${p}`),
+            ...perChangeIdDirs.map((p) => `per-change-id top-level dir: ${p}`)
+        ];
+        return [{
+                id: 'build:workspace-layout-canonical',
+                ok: false,
+                message: `Workspace layout is not canonical. Offenders: ${offenders.join('; ')}. Run \`peaks workspace migrate --to-runtime --project <repo> --apply\` to consolidate.`
+            }];
+    }
+    catch (error) {
+        return [{
+                id: 'build:workspace-layout-canonical',
+                ok: false,
+                message: `Workspace layout check failed: ${getErrorMessage(error)}`
+            }];
+    }
+}
+export const check = {
+    name: 'workspace-layout',
+    run
+};

package/dist/services/doctor/doctor-service/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * doctor-service facade (slice rid-004).
+ *
+ * Public entrypoint for the code-driven fixed-registry doctor
+ * pipeline. Replaces the legacy 1309-line monolithic `runDoctor`
+ * with a thin dispatcher that:
+ *
+ *   1. Resolves all cross-domain injections (project-root resolver,
+ *      skill loader, sid validator, schema root, presence, etc.)
+ *      and builds a read-only `DoctorContext` once.
+ *   2. Walks the `PLUGINS` array in `plugin-registry.ts` in order,
+ *      calling each plugin's `run(context)`, flattening the
+ *      returned `DoctorCheck[]` into the accumulator.
+ *   3. Updates `context.accumulatedChecks` after each plugin so the
+ *      `check-id-schema` self-validation plugin observes the full
+ *      prior list.
+ *   4. Hands the accumulated checks to `report/final-summary.ts`
+ *      which builds the public `DoctorReport`.
+ *
+ * The `runDoctor` signature is unchanged from the legacy version;
+ * main peaks-loop package imports it via
+ * `import { runDoctor } from '../index.js'`.
+ *
+ * slice-3b Option C: the doctor package stays standalone by
+ * accepting the cross-domain utilities as injectable probes. When
+ * no injection is provided, the doctor falls back to a safe
+ * "no-op / assume healthy" probe so the standalone test suite
+ * does not depend on the main package. The CLI wires the main-
+ * package implementations at call-site
+ * (`src/cli/commands/core/doctor-command.ts`).
+ */
+import type { DoctorOptions, DoctorReport } from './types.js';
+/**
+ * Pure helper extracted so tests can drive the filesystem check
+ * without monkey-patching `process.cwd()` or `findProjectRoot`.
+ * Returns `true` when EITHER the canonical
+ * `.peaks/_runtime/session.json` OR the legacy
+ * `.peaks/.session.json` exists.
+ */
+export declare function isWorkspaceInitializedAt(projectRoot: string): boolean;
+/**
+ * Public entrypoint. Walks the `PLUGINS` array, building the
+ * `DoctorContext` once at the top and threading it through every
+ * plugin. The accumulator is a mutable list shared via
+ * `context.accumulatedChecks` so plugins like `check-id-schema`
+ * that need to observe the prior list can do so.
+ */
+export declare function runDoctor(options?: DoctorOptions): Promise<DoctorReport>;