@deftai/directive-core 0.55.0

package/dist/doctor/agents-md.js

@@ -0,0 +1,263 @@
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { contentRoot } from "../content-root.js";
+import { AGENTS_MANAGED_CLOSE } from "./constants.js";
+import { resolveDefaultFrameworkRoot } from "./paths.js";
+const AGENTS_MANAGED_OPEN_SINGLE = /<!--\s*deft:managed-section\s+v(1|2|3)(?:\s+([^>]*?))?\s*-->/;
+const AGENTS_MANAGED_OPEN_V3_LITERAL = "<!-- deft:managed-section v3 -->";
+function frameworkRoot(seams = {}) {
+    return seams.frameworkRoot ?? resolveDefaultFrameworkRoot();
+}
+function readAgentsTemplate(seams = {}) {
+    if (seams.readTemplate) {
+        return seams.readTemplate();
+    }
+    // #1875: the AGENTS.md template moved under content/ in the source repo
+    // (content/templates/agents-entry.md) but the C1 flatten deposits it at
+    // templates/agents-entry.md in a consumer install. Resolve via contentRoot so
+    // the same lookup works in both contexts (mirrors scripts/_agents_md.py
+    // _agents_template_path, which uses content_root(framework_root())).
+    const candidate = join(contentRoot(frameworkRoot(seams)), "templates", "agents-entry.md");
+    try {
+        if (!existsSync(candidate)) {
+            return null;
+        }
+        return readFileSync(candidate, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function resolveFrameworkSha(seams = {}) {
+    if (seams.resolveSha) {
+        return seams.resolveSha();
+    }
+    const root = frameworkRoot(seams);
+    try {
+        const proc = spawnSync("git", ["rev-parse", "--short=12", "HEAD"], {
+            cwd: root,
+            encoding: "utf8",
+            timeout: 5000,
+        });
+        if (proc.status !== 0) {
+            return "unknown";
+        }
+        const sha = (proc.stdout ?? "").trim();
+        return sha || "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function stripManagedSectionAttrs(section) {
+    return section.replace(AGENTS_MANAGED_OPEN_SINGLE, AGENTS_MANAGED_OPEN_V3_LITERAL);
+}
+function renderManagedSection(templateText) {
+    const normalised = templateText.replace(/\r\n/g, "\n");
+    const openMatch = AGENTS_MANAGED_OPEN_SINGLE.exec(normalised);
+    if (!openMatch) {
+        return null;
+    }
+    const openIdx = openMatch.index;
+    const closeIdx = normalised.indexOf(AGENTS_MANAGED_CLOSE, openMatch.index + openMatch[0].length);
+    if (closeIdx < 0) {
+        return null;
+    }
+    const end = closeIdx + AGENTS_MANAGED_CLOSE.length;
+    return stripManagedSectionAttrs(normalised.slice(openIdx, end));
+}
+function iterManagedSections(text) {
+    const results = [];
+    let pos = 0;
+    while (pos <= text.length) {
+        const slice = text.slice(pos);
+        const openMatch = AGENTS_MANAGED_OPEN_SINGLE.exec(slice);
+        if (!openMatch) {
+            break;
+        }
+        const absStart = pos + openMatch.index;
+        const closeIdx = text.indexOf(AGENTS_MANAGED_CLOSE, absStart + openMatch[0].length);
+        if (closeIdx < 0) {
+            break;
+        }
+        const end = closeIdx + AGENTS_MANAGED_CLOSE.length;
+        results.push([absStart, end, text.slice(absStart, end)]);
+        pos = end;
+    }
+    return results;
+}
+function parseManagedSectionAttrs(extracted) {
+    const match = AGENTS_MANAGED_OPEN_SINGLE.exec(extracted);
+    if (!match?.[1]) {
+        return null;
+    }
+    return { version: Number(match[1]) };
+}
+function attributeRenderManagedSection(rendered, attrs) {
+    const attrString = `v3 sha=${attrs.frameworkSha} refreshed=${attrs.refreshed} session=${attrs.sessionId}`;
+    const attributedOpen = `<!-- deft:managed-section ${attrString} -->`;
+    return rendered.replace(AGENTS_MANAGED_OPEN_V3_LITERAL, attributedOpen);
+}
+function wrapLegacyInMarkers(existing, rendered) {
+    const body = existing.replace(/\r\n/g, "\n").replace(/\n$/, "");
+    if (body) {
+        return `${body}\n\n${rendered}\n`;
+    }
+    return `${rendered}\n`;
+}
+/** Compute AGENTS.md managed-section freshness plan (mirrors scripts/_agents_md.py). */
+export function agentsRefreshPlan(projectRoot, seams = {}) {
+    const readTemplate = seams.readTemplate ?? (() => readAgentsTemplate(seams));
+    const resolveSha = seams.resolveSha ?? (() => resolveFrameworkSha(seams));
+    const nowIso = seams.nowIso ?? (() => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"));
+    const newSession = seams.newSession ?? (() => randomUUID().replace(/-/g, "").slice(0, 12));
+    const readAgents = seams.readAgents ??
+        ((path) => {
+            try {
+                if (!existsSync(path)) {
+                    return null;
+                }
+                return readFileSync(path, "utf8");
+            }
+            catch {
+                return null;
+            }
+        });
+    const templateText = readTemplate();
+    if (templateText === null) {
+        return {
+            state: "template-missing",
+            path: join(projectRoot, "AGENTS.md"),
+            rendered: null,
+            existing: null,
+            new_content: null,
+        };
+    }
+    const rendered = renderManagedSection(templateText);
+    if (rendered === null) {
+        return {
+            state: "template-malformed",
+            path: join(projectRoot, "AGENTS.md"),
+            rendered: null,
+            existing: null,
+            new_content: null,
+        };
+    }
+    const frameworkSha = resolveSha();
+    const refreshed = nowIso();
+    const sessionId = newSession();
+    const attributedRendered = attributeRenderManagedSection(rendered, {
+        frameworkSha,
+        refreshed,
+        sessionId,
+    });
+    const agentsMd = join(projectRoot, "AGENTS.md");
+    let existing;
+    try {
+        existing = readAgents(agentsMd);
+    }
+    catch (exc) {
+        return {
+            state: "unreadable",
+            path: agentsMd,
+            rendered,
+            existing: null,
+            new_content: null,
+            error: String(exc),
+        };
+    }
+    if (existing === null) {
+        return {
+            state: "absent",
+            path: agentsMd,
+            rendered,
+            attributed_rendered: attributedRendered,
+            sha: frameworkSha,
+            refreshed,
+            session: sessionId,
+            existing: null,
+            new_content: `${attributedRendered}\n`,
+        };
+    }
+    const normalised = existing.replace(/\r\n/g, "\n");
+    const blocks = iterManagedSections(normalised);
+    if (blocks.length === 0) {
+        return {
+            state: "missing",
+            path: agentsMd,
+            rendered,
+            attributed_rendered: attributedRendered,
+            sha: frameworkSha,
+            refreshed,
+            session: sessionId,
+            existing,
+            new_content: wrapLegacyInMarkers(normalised, attributedRendered),
+        };
+    }
+    if (blocks.length > 1) {
+        const firstStart = blocks[0]?.[0] ?? 0;
+        let newContent = normalised;
+        for (const [start, end] of [...blocks].reverse()) {
+            newContent = newContent.slice(0, start) + newContent.slice(end);
+        }
+        newContent =
+            newContent.slice(0, firstStart) + attributedRendered + newContent.slice(firstStart);
+        return {
+            state: "stale",
+            path: agentsMd,
+            rendered,
+            attributed_rendered: attributedRendered,
+            sha: frameworkSha,
+            refreshed,
+            session: sessionId,
+            existing,
+            new_content: newContent,
+        };
+    }
+    const extracted = blocks[0]?.[2] ?? "";
+    const extractedAttrs = parseManagedSectionAttrs(extracted);
+    const isLegacyMarker = extractedAttrs !== null && [1, 2].includes(extractedAttrs.version);
+    if (!isLegacyMarker && stripManagedSectionAttrs(extracted) === rendered) {
+        return {
+            state: "current",
+            path: agentsMd,
+            rendered,
+            existing,
+            new_content: existing,
+        };
+    }
+    const newContent = normalised.replace(extracted, attributedRendered);
+    return {
+        state: "stale",
+        path: agentsMd,
+        rendered,
+        attributed_rendered: attributedRendered,
+        sha: frameworkSha,
+        refreshed,
+        session: sessionId,
+        existing,
+        new_content: newContent,
+    };
+}
+export function hasV3ManagedMarker(projectRoot, readText = defaultReadAgents) {
+    const agentsMd = join(projectRoot, "AGENTS.md");
+    const text = readText(agentsMd);
+    if (text === null) {
+        return false;
+    }
+    return /<!--\s*deft:managed-section\s+v3(?:\s+[^>]*?)?\s*-->/.test(text);
+}
+function defaultReadAgents(path) {
+    try {
+        if (!existsSync(path)) {
+            return null;
+        }
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=agents-md.js.map

package/dist/doctor/checks.d.ts

@@ -0,0 +1,16 @@
+import type { CheckResult } from "./types.js";
+export interface CheckSeams {
+    readonly readText?: (path: string) => string | null;
+    readonly isFile?: (path: string) => boolean;
+    readonly isDir?: (path: string) => boolean;
+}
+export declare function checkQuickStartResolves(projectRoot: string, installRoot: string | null, seams?: CheckSeams): CheckResult;
+export declare function checkSkillPathsResolve(projectRoot: string, agentsMdText: string, seams?: CheckSeams): CheckResult;
+export declare function checkManifestAgreement(projectRoot: string, installRoot: string | null, seams?: CheckSeams): CheckResult;
+export declare function checkInstallPathConsistency(projectRoot: string, installRoot: string | null, seams?: CheckSeams): CheckResult;
+export declare function deriveExitCode(checks: readonly CheckResult[], errors: readonly string[]): number;
+export declare function runChecksImpl(projectRoot: string, seams?: CheckSeams & {
+    isDir?: (p: string) => boolean;
+}): import("./types.js").DoctorResult;
+export declare function runChecks(projectRoot: string, seams?: CheckSeams): Record<string, unknown>;
+//# sourceMappingURL=checks.d.ts.map

package/dist/doctor/checks.js

@@ -0,0 +1,351 @@
+import { join } from "node:path";
+import { findSkillPathsInText } from "../text/redos-safe.js";
+import { isDeprecationRedirectStub, locateManifest, manifestCandidatePaths, manifestTagToVersion, parseInstallRootFromAgentsMd, parseManifest, } from "./manifest.js";
+import { readTextSafe } from "./paths.js";
+function readText(path, seams) {
+    return (seams.readText ?? readTextSafe)(path);
+}
+export function checkQuickStartResolves(projectRoot, installRoot, seams = {}) {
+    if (installRoot === null) {
+        return {
+            name: "quick-start-resolves",
+            status: "skip",
+            detail: "AGENTS.md does not declare an install root; cannot check QUICK-START.md resolution.",
+        };
+    }
+    const qsPath = join(projectRoot, installRoot, "QUICK-START.md");
+    const isFile = seams.isFile ?? ((p) => readText(p, seams) !== null);
+    if (isFile(qsPath)) {
+        return {
+            name: "quick-start-resolves",
+            status: "pass",
+            detail: `Found QUICK-START.md at ${qsPath}.`,
+            data: { path: qsPath, install_root: installRoot },
+        };
+    }
+    return {
+        name: "quick-start-resolves",
+        status: "fail",
+        detail: `QUICK-START.md not found at ${qsPath}. AGENTS.md claims the ` +
+            `install root is '${installRoot}' but the file is missing. ` +
+            "Run `.deft/core/run agents:refresh` (Unix) / " +
+            "`.deft\\core\\run agents:refresh` (Windows) to align AGENTS.md " +
+            "with the on-disk install root, OR run `task upgrade` to " +
+            "re-pull the framework if the on-disk install is missing. " +
+            "See UPGRADING.md for the canonical drift-repair walkthrough.",
+        data: {
+            path: qsPath,
+            install_root: installRoot,
+            suggested_fix: ".deft/core/run agents:refresh",
+            suggested_fix_alt: "task upgrade",
+        },
+    };
+}
+export function checkSkillPathsResolve(projectRoot, agentsMdText, seams = {}) {
+    const referenced = findSkillPathsInText(agentsMdText).sort();
+    if (referenced.length === 0) {
+        return {
+            name: "skill-paths-resolve",
+            status: "skip",
+            detail: "AGENTS.md references no skill paths to verify.",
+            data: { referenced: [] },
+        };
+    }
+    const missing = [];
+    const redirectStubs = [];
+    const isFile = seams.isFile ?? ((p) => readText(p, seams) !== null);
+    for (const rel of referenced) {
+        const candidate = join(projectRoot, rel);
+        if (!isFile(candidate)) {
+            missing.push(rel);
+            continue;
+        }
+        const text = readText(candidate, seams);
+        if (text !== null && isDeprecationRedirectStub(text)) {
+            redirectStubs.push(rel);
+        }
+    }
+    if (missing.length === 0 && redirectStubs.length === 0) {
+        return {
+            name: "skill-paths-resolve",
+            status: "pass",
+            detail: `All ${referenced.length} skill path(s) resolve.`,
+            data: { referenced },
+        };
+    }
+    const parts = [];
+    if (missing.length) {
+        parts.push(`missing: ${JSON.stringify(missing)}`);
+    }
+    if (redirectStubs.length) {
+        parts.push(`deprecation-redirect stubs: ${JSON.stringify(redirectStubs)}`);
+    }
+    return {
+        name: "skill-paths-resolve",
+        status: "fail",
+        detail: `${missing.length} skill path(s) do not resolve; ${redirectStubs.length} stub redirect(s). ` +
+            `${parts.join("; ")}. Run \`.deft/core/run agents:refresh\` (Unix) / ` +
+            "`.deft\\core\\run agents:refresh` (Windows) to rewrite the managed AGENTS.md block so skill paths match the on-disk framework, OR run `task upgrade` if the on-disk skills are missing entirely. See UPGRADING.md for the drift-repair walkthrough.",
+        data: {
+            referenced,
+            missing,
+            redirect_stubs: redirectStubs,
+            suggested_fix: ".deft/core/run agents:refresh",
+            suggested_fix_alt: "task upgrade",
+        },
+    };
+}
+export function checkManifestAgreement(projectRoot, installRoot, seams = {}) {
+    const coreManifest = join(projectRoot, ".deft", "core", "VERSION");
+    const legacyManifest = join(projectRoot, ".deft", "VERSION");
+    const coreDualText = readText(coreManifest, seams);
+    const legacyDualText = readText(legacyManifest, seams);
+    if (coreDualText !== null && legacyDualText !== null) {
+        const coreVer = manifestTagToVersion(parseManifest(coreDualText));
+        const legacyVer = manifestTagToVersion(parseManifest(legacyDualText));
+        if (coreVer !== legacyVer) {
+            return {
+                name: "manifest-agreement",
+                status: "fail",
+                detail: `Two install manifests disagree: .deft/core/VERSION (tag='${coreVer}') vs legacy .deft/VERSION (tag='${legacyVer}'). The canonical manifest is .deft/core/VERSION -- run \`task upgrade\` to migrate the stale .deft/VERSION (backed up as .deft/VERSION.premigrate). See UPGRADING.md for the canonical drift-repair walkthrough.`,
+                data: {
+                    dual_manifest_drift: true,
+                    core_manifest_path: coreManifest,
+                    legacy_manifest_path: legacyManifest,
+                    core_version: coreVer,
+                    legacy_version: legacyVer,
+                    authoritative: "manifest",
+                    suggested_fix: "task upgrade",
+                },
+            };
+        }
+    }
+    const isFile = seams.isFile ?? ((p) => readText(p, seams) !== null);
+    const manifestPath = locateManifest(projectRoot, installRoot, isFile);
+    const expectedManifestPath = manifestPath ?? manifestCandidatePaths(projectRoot, installRoot)[0];
+    const bareCandidates = [
+        join(projectRoot, "vbrief", ".deft-version"),
+        join(projectRoot, ".deft-version"),
+    ];
+    const barePath = bareCandidates.find((p) => isFile(p)) ?? null;
+    const manifestText = manifestPath ? readText(manifestPath, seams) : null;
+    const bareText = barePath ? readText(barePath, seams) : null;
+    if (manifestText === null && bareText === null) {
+        return {
+            name: "manifest-agreement",
+            status: "skip",
+            detail: "Neither YAML manifest nor bare .deft-version exists; nothing to reconcile (greenfield install).",
+            data: {
+                manifest_path: manifestPath,
+                bare_path: barePath,
+            },
+        };
+    }
+    if (manifestText === null) {
+        return {
+            name: "manifest-agreement",
+            status: "fail",
+            detail: `Bare .deft-version exists at ${barePath} but YAML manifest is missing at ${expectedManifestPath}. Run \`task upgrade\` to write the canonical manifest (#1046 PR-B AC-4). See UPGRADING.md for the v0.27.x -> v0.28 transition walkthrough.`,
+            data: {
+                manifest_path: manifestPath,
+                expected_manifest_path: expectedManifestPath,
+                bare_path: barePath,
+                bare_value: bareText?.trim() ?? null,
+                suggested_fix: "task upgrade",
+            },
+        };
+    }
+    if (bareText === null) {
+        const manifest = parseManifest(manifestText);
+        const derived = manifestTagToVersion(manifest);
+        return {
+            name: "manifest-agreement",
+            status: "pass",
+            detail: `YAML manifest at ${manifestPath} present; bare .deft-version absent (derived value: '${derived}' from manifest tag). Run \`task upgrade\` to regenerate the derivative.`,
+            data: {
+                manifest_path: manifestPath,
+                manifest,
+                derived_version: derived,
+            },
+        };
+    }
+    const manifest = parseManifest(manifestText);
+    const derived = manifestTagToVersion(manifest);
+    const bareValue = bareText.trim();
+    if (derived === null) {
+        return {
+            name: "manifest-agreement",
+            status: "fail",
+            detail: `YAML manifest at ${manifestPath} has no parseable tag/ref field; cannot reconcile with bare .deft-version.`,
+            data: {
+                manifest_path: manifestPath,
+                bare_path: barePath,
+                manifest,
+                bare_value: bareValue,
+            },
+        };
+    }
+    if (derived === bareValue) {
+        return {
+            name: "manifest-agreement",
+            status: "pass",
+            detail: `YAML manifest (tag='${derived}') agrees with bare .deft-version ('${bareValue}').`,
+            data: {
+                manifest_path: manifestPath,
+                bare_path: barePath,
+                derived_version: derived,
+                bare_value: bareValue,
+            },
+        };
+    }
+    return {
+        name: "manifest-agreement",
+        status: "fail",
+        detail: `Drift detected: YAML manifest tag='${derived}' does NOT agree with bare .deft-version='${bareValue}'. Per #1046 PR-B AC-4 the YAML manifest is the canonical source -- run \`task upgrade\` to regenerate the bare derivative from the manifest, OR manually update ${manifestPath} if the bare value is correct. See UPGRADING.md for the canonical drift-repair walkthrough.`,
+        data: {
+            manifest_path: manifestPath,
+            bare_path: barePath,
+            derived_version: derived,
+            bare_value: bareValue,
+            authoritative: "manifest",
+            suggested_fix: "task upgrade",
+        },
+    };
+}
+export function checkInstallPathConsistency(projectRoot, installRoot, seams = {}) {
+    let effectiveInstallRoot = installRoot;
+    let fallbackInfoNote = "";
+    let source = "AGENTS.md";
+    const isDir = seams.isDir ?? (() => false);
+    for (const manifestPath of manifestCandidatePaths(projectRoot, installRoot)) {
+        const manifestText = readText(manifestPath, seams);
+        if (manifestText === null) {
+            continue;
+        }
+        const manifest = parseManifest(manifestText);
+        const manifestInstallRoot = manifest.install_root;
+        if (typeof manifestInstallRoot === "string" && manifestInstallRoot.trim()) {
+            effectiveInstallRoot = manifestInstallRoot.trim();
+            fallbackInfoNote = "";
+            source = "manifest";
+            break;
+        }
+        fallbackInfoNote = ` INFO: manifest at ${manifestPath} is missing install_root; fell back to the legacy AGENTS.md install-root parse.`;
+        break;
+    }
+    if (effectiveInstallRoot === null) {
+        return {
+            name: "install-path-consistency",
+            status: "skip",
+            detail: `AGENTS.md does not declare an install root.${fallbackInfoNote}`,
+            data: {
+                claimed_install_root: installRoot,
+                effective_install_root: effectiveInstallRoot,
+                fallback_info_note: fallbackInfoNote || null,
+            },
+        };
+    }
+    const claimedDir = join(projectRoot, effectiveInstallRoot);
+    if (!isDir(claimedDir)) {
+        return {
+            name: "install-path-consistency",
+            status: "fail",
+            detail: `Install root is recorded as '${effectiveInstallRoot}' (source: ${source}) but ${claimedDir} is not a directory. Pick one of two repair paths: (a) run \`.deft/core/run agents:refresh\` (Unix) / \`.deft\\core\\run agents:refresh\` (Windows) to rewrite AGENTS.md to match the on-disk framework -- pick this if the framework on disk is correct; OR (b) run \`task relocate:relocate -- --confirm\` to move the framework to the path AGENTS.md / the manifest claims -- pick this if AGENTS.md is correct. The YAML manifest (if present) is authoritative for the install-layout contract. See UPGRADING.md for the canonical drift-repair walkthrough.`,
+            data: {
+                claimed_install_root: installRoot,
+                effective_install_root: effectiveInstallRoot,
+                effective_install_root_source: source,
+                claimed_dir: claimedDir,
+                claimed_dir_exists: false,
+                fallback_info_note: fallbackInfoNote || null,
+                suggested_fix: ".deft/core/run agents:refresh",
+                suggested_fix_alt: "task relocate:relocate -- --confirm",
+            },
+        };
+    }
+    return {
+        name: "install-path-consistency",
+        status: "pass",
+        detail: `Install root ('${effectiveInstallRoot}', source: ${source}) matches an existing directory at ${claimedDir}.` +
+            fallbackInfoNote,
+        data: {
+            claimed_install_root: installRoot,
+            effective_install_root: effectiveInstallRoot,
+            effective_install_root_source: source,
+            claimed_dir: claimedDir,
+            fallback_info_note: fallbackInfoNote || null,
+        },
+    };
+}
+export function deriveExitCode(checks, errors) {
+    if (errors.length > 0 || checks.some((c) => c.status === "error")) {
+        return 2;
+    }
+    if (checks.some((c) => c.status === "fail")) {
+        return 1;
+    }
+    return 0;
+}
+export function runChecksImpl(projectRoot, seams = {}) {
+    const errors = [];
+    const isDir = seams.isDir ?? (() => false);
+    if (!isDir(projectRoot)) {
+        return {
+            projectRoot,
+            installRoot: null,
+            exitCode: 2,
+            checks: [],
+            errors: [`project root does not exist: ${projectRoot}`],
+        };
+    }
+    const agentsMdPath = join(projectRoot, "AGENTS.md");
+    const agentsMdText = readText(agentsMdPath, seams);
+    let installRoot = null;
+    if (agentsMdText !== null) {
+        installRoot = parseInstallRootFromAgentsMd(agentsMdText);
+    }
+    const checks = [];
+    if (agentsMdText === null) {
+        checks.push({
+            name: "agents-md-present",
+            status: "fail",
+            detail: "AGENTS.md not found at project root -- run `.deft/core/run agents:refresh` to generate it from the canonical template.",
+            data: { agents_md_path: agentsMdPath },
+        });
+        checks.push(checkManifestAgreement(projectRoot, null, seams));
+        return {
+            projectRoot,
+            installRoot: null,
+            exitCode: deriveExitCode(checks, errors),
+            checks,
+            errors,
+        };
+    }
+    checks.push(checkQuickStartResolves(projectRoot, installRoot, seams));
+    checks.push(checkSkillPathsResolve(projectRoot, agentsMdText, seams));
+    checks.push(checkManifestAgreement(projectRoot, installRoot, seams));
+    checks.push(checkInstallPathConsistency(projectRoot, installRoot, seams));
+    return {
+        projectRoot,
+        installRoot,
+        exitCode: deriveExitCode(checks, errors),
+        checks,
+        errors,
+    };
+}
+export function runChecks(projectRoot, seams = {}) {
+    const result = runChecksImpl(projectRoot, seams);
+    return {
+        project_root: result.projectRoot,
+        install_root: result.installRoot,
+        exit_code: result.exitCode,
+        checks: result.checks.map((c) => ({
+            name: c.name,
+            status: c.status,
+            detail: c.detail,
+            data: c.data ?? {},
+        })),
+        errors: [...result.errors],
+    };
+}
+//# sourceMappingURL=checks.js.map

package/dist/doctor/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/doctor/cli.js

@@ -0,0 +1,7 @@
+/* v8 ignore file -- thin shebang entry; covered via main.ts tests */
+import { fileURLToPath } from "node:url";
+import { cmdDoctor } from "./main.js";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(cmdDoctor(process.argv.slice(2)));
+}
+//# sourceMappingURL=cli.js.map

package/dist/doctor/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const UV_INSTALL_URL = "https://docs.astral.sh/uv/";
+export declare const AGENTS_MANAGED_CLOSE = "<!-- /deft:managed-section -->";
+export declare const DEPRECATED_REDIRECT_SENTINEL = "<!-- deft:deprecated-redirect -->";
+export declare const DEPRECATED_SKILL_REDIRECT_SENTINEL = "<!-- deft:deprecated-skill-redirect -->";
+export declare const REDIRECT_STUB_HEADER_LINES = 8;
+export declare const TASKFILE_INCLUDE_SNIPPET = "version: '3'\n\nincludes:\n  deft:\n    taskfile: ./.deft/core/Taskfile.yml\n    optional: true\n";
+export declare const DOCTOR_ALLOWED_FLAGS: readonly ["--session", "--fix", "--repair", "--repair-taskfile", "--json", "--quiet", "--full", "--project-root", "-h", "--help"];
+export declare const EXPECTED_FRAMEWORK_DIRS: readonly ["tasks", "scripts", "vbrief"];
+export declare const DEFT_REPO_POSITIVE_MARKERS: readonly ["content/templates/agents-entry.md", "content/skills/deft-directive-build/SKILL.md"];
+export declare const EXPECTED_CONTENT_DIRS: readonly ["languages", "strategies", "skills", "templates"];
+export declare const CANONICAL_UPGRADE_COMMAND = "deft-install --yes --upgrade --repo-root . --json";
+export declare const CLEAN_WINDOW_HOURS = 24;
+export declare const DIRTY_WINDOW_HOURS = 4;
+export declare const ENV_STATE_PATH = "DEFT_DOCTOR_STATE_PATH";
+//# sourceMappingURL=constants.d.ts.map