@warpgogol/forge 0.3.1 → 0.5.0

package/dist/src/onboarding/doctor.js

@@ -14,12 +14,29 @@ Checks for forge.yaml, AGENTS.md, PREFERENCES.md, .agents/skills/, docs/rfcs/,
   <item>RFC-0524: added stale knowledge file detection — compares source and .agents/ copies.</item>
   <item>RFC-0539: extended knowledge file check to iterate pack skills via discoverPackSkills. Added pack-skills check for stale/missing copies and skillPacks config validation.</item>
   <item>RFC-0540: added defaultable-binding-null notices for forge-CLI-backed bindings.</item>
+  <item>RFC-0611: added nested AGENTS.md checks — missing, stale (dryRun comparison), hand-written improvement.</item>
+  <item>RFC-0640: added domain reporting, invariant listing (reported-only), terminology resolution, --strict flag, and software-specific check skipping for non-software domains.</item>
+  <item>RFC-0660: added legacy-section count reporting for structured knowledge files.</item>
+  <item>RFC-0661: added knowledge-budgets check — validates override shape, computes per-skill budget reports, reports summary with headroom %.</item>
+  <item>RFC-0663: added knowledge-duplicates check (cross-skill L2 duplicate detection) and shared-knowledge-file check (schema/id uniqueness for the shared layer).</item>
+  <item>RFC-0664: added memory-layer health check (budget usage, gitignore coverage, daily-file leak risk).</item>
 </CHANGE_SUMMARY>
 */
 import { readFile, readdir, stat } from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import { join, relative, dirname } from "node:path";
-import { resolveForgeRoot, loadForgeConfig, resolveBinding, FORGE_CLI_BINDING_DEFAULTS, resolvePmRunner } from "../config/forge-config.js";
+import { parse as parseYaml } from "yaml";
+import { resolveForgeRoot, loadForgeConfig, resolveBinding, resolveTerminology, FORGE_CLI_BINDING_DEFAULTS, resolvePmRunner } from "../config/forge-config.js";
 import { FORGE_SKILLS, discoverPackSkills } from "../registry.js";
+import { discoverWorkspaces } from "./workspace-discovery.js";
+import { buildNestedAgentsMd } from "./nested-agents-templates.js";
+import { listStackProfiles } from "../profiles/stack-profile.js";
+import { TERMINOLOGY_DEFAULTS } from "../profiles/profile-schema.js";
+import { runProfileValidate } from "./profile-validate.js";
+import { parseKnowledgeFile } from "../knowledge/index.js";
+import { computeLayerBudgets, resolveKnowledgeBudgets, DEFAULT_KNOWLEDGE_BUDGETS } from "../knowledge/budgets.js";
+import { detectDuplicatePrinciples } from "../knowledge/index.js";
+import { checkMemoryLayerHealth } from "./memory-scaffold.js";
 async function pathExists(target) {
     try {
         await stat(target);
@@ -72,6 +89,7 @@ const BINDING_COMMAND_KEYS = [
     "commands.test",
     "commands.scopedBuild",
     "commands.specValidate",
+    "commands.sessionSave",
 ];
 async function validateBindings(workspaceRoot) {
     const result = { resolved: [], absent: [], invalid: [], notices: [] };
@@ -201,6 +219,294 @@ async function checkStaleKnowledgeFiles(workspaceRoot, forgeRoot) {
     };
 }
 // ---------------------------------------------------------------------------
+// Legacy section detection (RFC-0660)
+// ---------------------------------------------------------------------------
+function checkLegacyKnowledgeSections(workspaceRoot, forgeRoot) {
+    let config;
+    try {
+        config = loadForgeConfig(workspaceRoot);
+    }
+    catch {
+        return { name: "knowledge-legacy", status: "pass", message: "No forge.yaml — legacy section check skipped" };
+    }
+    let totalLegacy = 0;
+    let filesWithLegacy = 0;
+    // Check forge skills
+    for (const skill of FORGE_SKILLS) {
+        if (!skill.knowledge || skill.knowledge.length === 0)
+            continue;
+        const skillDir = join(forgeRoot, dirname(skill.path));
+        for (const kf of skill.knowledge) {
+            const kfPath = join(skillDir, kf);
+            try {
+                const parsed = parseKnowledgeFile(kfPath);
+                if (parsed.isKnowledgeAdjacent)
+                    continue;
+                if (parsed.legacySections.length > 0) {
+                    totalLegacy += parsed.legacySections.length;
+                    filesWithLegacy++;
+                }
+            }
+            catch {
+                // File read errors are handled by stale knowledge check
+            }
+        }
+    }
+    // Check pack skills
+    const packSkills = discoverPackSkills(workspaceRoot, config);
+    for (const skill of packSkills) {
+        if (!skill.knowledge || skill.knowledge.length === 0)
+            continue;
+        const skillDir = join(workspaceRoot, skill.dir, dirname(skill.path));
+        for (const kf of skill.knowledge) {
+            const kfPath = join(skillDir, kf);
+            try {
+                const parsed = parseKnowledgeFile(kfPath);
+                if (parsed.isKnowledgeAdjacent)
+                    continue;
+                if (parsed.legacySections.length > 0) {
+                    totalLegacy += parsed.legacySections.length;
+                    filesWithLegacy++;
+                }
+            }
+            catch {
+                // File read errors are handled by stale knowledge check
+            }
+        }
+    }
+    return {
+        name: "knowledge-legacy",
+        status: totalLegacy === 0 ? "pass" : "warn",
+        message: totalLegacy === 0
+            ? "No legacy knowledge sections"
+            : `${totalLegacy} legacy section${totalLegacy === 1 ? "" : "s"} across ${filesWithLegacy} knowledge file${filesWithLegacy === 1 ? "" : "s"} — run the knowledge compaction command to migrate`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Knowledge budget check (RFC-0661)
+// ---------------------------------------------------------------------------
+function checkKnowledgeBudgets(workspaceRoot, forgeRoot) {
+    let config;
+    try {
+        config = loadForgeConfig(workspaceRoot);
+    }
+    catch {
+        return { name: "knowledge-budgets", status: "pass", message: "No forge.yaml — budget check skipped" };
+    }
+    // Validate override shape if present
+    const overrideWarnings = [];
+    const effectiveBudgets = resolveKnowledgeBudgets(workspaceRoot);
+    let usingDefaults = true;
+    try {
+        const forgeYamlPath = join(workspaceRoot, "forge.yaml");
+        const content = readFileSync(forgeYamlPath, "utf8");
+        const parsed = parseYaml(content);
+        const bindings = parsed?.bindings;
+        const knowledge = bindings?.knowledge;
+        const budgets = knowledge?.budgets;
+        if (budgets) {
+            usingDefaults = false;
+            if (typeof budgets.hot !== "number" || budgets.hot <= 0 || !Number.isInteger(budgets.hot)) {
+                overrideWarnings.push(`bindings.knowledge.budgets.hot invalid (got ${String(budgets.hot)}), using default ${DEFAULT_KNOWLEDGE_BUDGETS.hot}`);
+            }
+            if (typeof budgets.warm !== "number" || budgets.warm <= 0 || !Number.isInteger(budgets.warm)) {
+                overrideWarnings.push(`bindings.knowledge.budgets.warm invalid (got ${String(budgets.warm)}), using default ${DEFAULT_KNOWLEDGE_BUDGETS.warm}`);
+            }
+        }
+    }
+    catch {
+        // forge.yaml not readable — defaults already applied
+    }
+    // Collect all parsed knowledge files from forge skills and pack skills
+    const parsedFiles = [];
+    for (const skill of FORGE_SKILLS) {
+        if (!skill.knowledge || skill.knowledge.length === 0)
+            continue;
+        const skillDir = join(forgeRoot, dirname(skill.path));
+        for (const kf of skill.knowledge) {
+            const kfPath = join(skillDir, kf);
+            try {
+                const parsed = parseKnowledgeFile(kfPath);
+                if (parsed.layer !== null && parsed.layer !== "L0" && !parsed.isKnowledgeAdjacent && parsed.parseIssues.length === 0) {
+                    parsedFiles.push({ file: parsed, skillName: skill.name });
+                }
+            }
+            catch {
+                // File read errors are handled by stale knowledge check
+            }
+        }
+    }
+    const packSkills = discoverPackSkills(workspaceRoot, config);
+    for (const skill of packSkills) {
+        if (!skill.knowledge || skill.knowledge.length === 0)
+            continue;
+        const skillDir = join(workspaceRoot, skill.dir, dirname(skill.path));
+        for (const kf of skill.knowledge) {
+            const kfPath = join(skillDir, kf);
+            try {
+                const parsed = parseKnowledgeFile(kfPath);
+                if (parsed.layer !== null && parsed.layer !== "L0" && !parsed.isKnowledgeAdjacent && parsed.parseIssues.length === 0) {
+                    parsedFiles.push({ file: parsed, skillName: skill.name, pack: skill.pack });
+                }
+            }
+            catch {
+                // File read errors are handled by stale knowledge check
+            }
+        }
+    }
+    // Compute budget reports
+    const filesForBudget = parsedFiles.map((p) => p.file);
+    const skillNames = new Map();
+    for (const p of parsedFiles) {
+        skillNames.set(p.file.path, p.skillName);
+    }
+    const reports = computeLayerBudgets(filesForBudget, effectiveBudgets, skillNames);
+    // Build summary
+    const budgetSource = usingDefaults ? "defaults" : "override";
+    const parts = [`budgets: hot=${effectiveBudgets.hot} warm=${effectiveBudgets.warm} (${budgetSource})`];
+    if (reports.length > 0) {
+        const summary = reports.map((r) => {
+            const pct = Math.round((r.activeChars / r.budget) * 100);
+            return `${r.skill}/${r.file}[${r.layer}]: ${r.activeChars}/${r.budget} (${pct}%)`;
+        });
+        parts.push(`${reports.length} file${reports.length === 1 ? "" : "s"}: ${summary.join(", ")}`);
+    }
+    else {
+        parts.push("no hot/warm knowledge files to check");
+    }
+    if (overrideWarnings.length > 0) {
+        parts.push(overrideWarnings.join("; "));
+    }
+    const status = overrideWarnings.length > 0 ? "warn" : "pass";
+    return {
+        name: "knowledge-budgets",
+        status,
+        message: parts.join(" | "),
+    };
+}
+// ---------------------------------------------------------------------------
+// Knowledge duplicate detection (RFC-0663)
+// ---------------------------------------------------------------------------
+function collectL2Files(workspaceRoot, forgeRoot) {
+    let config;
+    try {
+        config = loadForgeConfig(workspaceRoot);
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const skill of FORGE_SKILLS) {
+        if (!skill.knowledge || skill.knowledge.length === 0)
+            continue;
+        const skillDir = join(forgeRoot, dirname(skill.path));
+        for (const kf of skill.knowledge) {
+            if (kf !== "learned-principles.md")
+                continue;
+            const kfPath = join(skillDir, kf);
+            try {
+                const parsed = parseKnowledgeFile(kfPath);
+                if (parsed.isKnowledgeAdjacent)
+                    continue;
+                if (parsed.parseIssues.length > 0)
+                    continue;
+                files.push({ skill: skill.name, parsed });
+            }
+            catch {
+                // File read errors are handled by stale knowledge check
+            }
+        }
+    }
+    const packSkills = discoverPackSkills(workspaceRoot, config);
+    for (const skill of packSkills) {
+        if (!skill.knowledge || skill.knowledge.length === 0)
+            continue;
+        const skillDir = join(workspaceRoot, skill.dir, dirname(skill.path));
+        for (const kf of skill.knowledge) {
+            if (kf !== "learned-principles.md")
+                continue;
+            const kfPath = join(skillDir, kf);
+            try {
+                const parsed = parseKnowledgeFile(kfPath);
+                if (parsed.isKnowledgeAdjacent)
+                    continue;
+                if (parsed.parseIssues.length > 0)
+                    continue;
+                files.push({ skill: skill.name, parsed });
+            }
+            catch {
+                // File read errors are handled by stale knowledge check
+            }
+        }
+    }
+    const sharedPath = join(forgeRoot, "skills", "shared", "knowledge", "learned-principles.md");
+    try {
+        const parsed = parseKnowledgeFile(sharedPath);
+        if (!parsed.isKnowledgeAdjacent && parsed.parseIssues.length === 0 && parsed.entries.length > 0) {
+            files.push({ skill: "shared", parsed });
+        }
+    }
+    catch {
+        // Shared layer not initialized — not an error
+    }
+    return files;
+}
+function checkKnowledgeDuplicates(workspaceRoot, forgeRoot) {
+    const l2Files = collectL2Files(workspaceRoot, forgeRoot);
+    if (l2Files.length === 0) {
+        return { name: "knowledge-duplicates", status: "pass", message: "No L2 knowledge files to check" };
+    }
+    const pairs = detectDuplicatePrinciples(l2Files);
+    if (pairs.length === 0) {
+        return { name: "knowledge-duplicates", status: "pass", message: "No cross-skill duplicate principles detected" };
+    }
+    const pairSummaries = pairs.map((p) => `${p.a.skill}/${p.a.entryId} ↔ ${p.b.skill}/${p.b.entryId} (${p.kind})`);
+    return {
+        name: "knowledge-duplicates",
+        status: "warn",
+        message: `${pairs.length} duplicate pair${pairs.length === 1 ? "" : "s"} detected — run fo-knowledge-distill to promote: ${pairSummaries.join("; ")}`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Shared knowledge file validation (RFC-0663)
+// ---------------------------------------------------------------------------
+function checkSharedKnowledgeFile(workspaceRoot, forgeRoot) {
+    const sharedPath = join(forgeRoot, "skills", "shared", "knowledge", "learned-principles.md");
+    let parsed;
+    try {
+        parsed = parseKnowledgeFile(sharedPath);
+    }
+    catch {
+        return { name: "shared-knowledge-file", status: "pass", message: "Shared knowledge layer not initialized — created on first promotion" };
+    }
+    if (parsed.isKnowledgeAdjacent) {
+        return { name: "shared-knowledge-file", status: "pass", message: "Shared knowledge layer is empty (no structured entries)" };
+    }
+    const issues = [];
+    for (const issue of parsed.parseIssues) {
+        issues.push(`line ${issue.line}: ${issue.message}`);
+    }
+    const seenIds = new Set();
+    for (const entry of parsed.entries) {
+        if (seenIds.has(entry.meta.id)) {
+            issues.push(`duplicate entry id: ${entry.meta.id}`);
+        }
+        seenIds.add(entry.meta.id);
+    }
+    if (issues.length > 0) {
+        return {
+            name: "shared-knowledge-file",
+            status: "fail",
+            message: `${issues.length} issue${issues.length === 1 ? "" : "s"}: ${issues.join("; ")}`,
+        };
+    }
+    return {
+        name: "shared-knowledge-file",
+        status: "pass",
+        message: `Shared knowledge layer: ${parsed.entries.length} entr${parsed.entries.length === 1 ? "y" : "ies"}`,
+    };
+}
+// ---------------------------------------------------------------------------
 // Pack skill diagnostics (RFC-0539)
 // ---------------------------------------------------------------------------
 async function checkPackSkills(workspaceRoot) {
@@ -262,8 +568,234 @@ async function checkPackSkills(workspaceRoot) {
             : `${issues.length} issue(s): ${issues.join(", ")} — run 'forge create' to sync`,
     };
 }
-export async function runDoctor(_input, context) {
+// ---------------------------------------------------------------------------
+// Nested AGENTS.md diagnostics (RFC-0611)
+// ---------------------------------------------------------------------------
+async function checkNestedAgentsMd(workspaceRoot, workspaceTypes) {
+    let config;
+    try {
+        config = loadForgeConfig(workspaceRoot);
+    }
+    catch {
+        return {
+            name: "nested-AGENTS.md",
+            status: "pass",
+            message: "forge.yaml not loadable — nested AGENTS.md check skipped",
+        };
+    }
+    const workspaces = discoverWorkspaces(workspaceRoot, workspaceTypes);
+    if (workspaces.length === 0) {
+        return {
+            name: "nested-AGENTS.md",
+            status: "pass",
+            message: "no workspace directories found",
+        };
+    }
+    const issues = [];
+    let missing = 0;
+    let stale = 0;
+    let handwritten = 0;
+    for (const ws of workspaces) {
+        if (!ws.hasAgentsMd) {
+            missing++;
+            issues.push(`${ws.path}/AGENTS.md missing`);
+            continue;
+        }
+        if (!ws.isGenerated) {
+            handwritten++;
+            const suggestions = [];
+            try {
+                const content = await readFile(join(workspaceRoot, ws.path, "AGENTS.md"), "utf8");
+                if (!content.includes("AGENTS.md")) {
+                    suggestions.push("reference root AGENTS.md");
+                }
+            }
+            catch {
+                // unreadable — skip
+            }
+            if (suggestions.length > 0) {
+                issues.push(`${ws.path}/AGENTS.md hand-written — consider: ${suggestions.join(", ")}`);
+            }
+            continue;
+        }
+        // Stale check: compare in-memory render to committed file
+        try {
+            const expected = buildNestedAgentsMd(ws, config);
+            const actual = await readFile(join(workspaceRoot, ws.path, "AGENTS.md"), "utf8");
+            if (expected !== actual) {
+                stale++;
+                issues.push(`${ws.path}/AGENTS.md stale — run 'forge agents generate'`);
+            }
+        }
+        catch {
+            // unreadable — skip
+        }
+    }
+    if (issues.length === 0) {
+        return {
+            name: "nested-AGENTS.md",
+            status: "pass",
+            message: `${workspaces.length} workspace(s) — all AGENTS.md in sync`,
+        };
+    }
+    const parts = [];
+    if (missing > 0)
+        parts.push(`${missing} missing`);
+    if (stale > 0)
+        parts.push(`${stale} stale`);
+    if (handwritten > 0)
+        parts.push(`${handwritten} hand-written`);
+    return {
+        name: "nested-AGENTS.md",
+        status: stale > 0 ? "warn" : "pass",
+        message: `${parts.join(", ")} — ${issues.slice(0, 3).join("; ")}${issues.length > 3 ? ` (+${issues.length - 3} more)` : ""}`,
+    };
+}
+function buildTerminologyMap(config, profileTerminology) {
+    const result = {};
+    for (const key of Object.keys(TERMINOLOGY_DEFAULTS)) {
+        result[key] = resolveTerminology(config, profileTerminology, key);
+    }
+    // Also include any custom keys from bindings.terminology
+    if (config.bindings?.terminology) {
+        for (const key of Object.keys(config.bindings.terminology)) {
+            if (!(key in result)) {
+                result[key] = resolveTerminology(config, profileTerminology, key);
+            }
+        }
+    }
+    return result;
+}
+function resolveDomainReport(workspaceRoot, forgeRoot) {
+    // 1. Try forge.yaml domain field
+    try {
+        const config = loadForgeConfig(workspaceRoot);
+        if (config.project.domain) {
+            const terminology = buildTerminologyMap(config);
+            const register = readRegisterFromPrefs(workspaceRoot);
+            return {
+                domain: config.project.domain,
+                register,
+                terminology,
+                invariants: [],
+                source: "forge.yaml",
+            };
+        }
+    }
+    catch {
+        // forge.yaml not loadable
+    }
+    // 2. Try to find domain from stack profile matching config.project.stack
+    try {
+        const config = loadForgeConfig(workspaceRoot);
+        const profiles = listStackProfiles(forgeRoot);
+        for (const stackId of config.project.stack) {
+            const profile = profiles.find((p) => p.id === stackId);
+            if (profile?.domain) {
+                const terminology = buildTerminologyMap(config, profile.terminology);
+                const register = profile.register ?? readRegisterFromPrefs(workspaceRoot);
+                return {
+                    domain: profile.domain,
+                    register,
+                    terminology,
+                    invariants: profile.invariants ?? [],
+                    source: "profile",
+                };
+            }
+        }
+    }
+    catch {
+        // config or profiles not loadable
+    }
+    // 3. Default: software domain
+    return {
+        domain: "software",
+        register: null,
+        terminology: {},
+        invariants: [],
+        source: "default",
+    };
+}
+function readRegisterFromPrefs(workspaceRoot) {
+    try {
+        const prefsPath = join(workspaceRoot, "PREFERENCES.md");
+        const content = readFileSync(prefsPath, "utf8");
+        const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+        if (fmMatch) {
+            const fm = parseYaml(fmMatch[1]);
+            if (fm["register"] === "creative")
+                return "creative";
+            if (fm["register"] === "business")
+                return "business";
+        }
+    }
+    catch {
+        // PREFERENCES.md missing or unreadable
+    }
+    return null;
+}
+function checkDomainInfo(domainReport) {
+    const parts = [`domain: ${domainReport.domain}`, `source: ${domainReport.source}`];
+    if (domainReport.register) {
+        parts.push(`register: ${domainReport.register}`);
+    }
+    if (Object.keys(domainReport.terminology).length > 0) {
+        const terms = Object.entries(domainReport.terminology)
+            .map(([k, v]) => `${k}=${v}`)
+            .join(", ");
+        parts.push(`terminology: ${terms}`);
+    }
+    if (domainReport.invariants.length > 0) {
+        parts.push(`invariants: ${domainReport.invariants.length} declared`);
+    }
+    return {
+        name: "domain-info",
+        status: "pass",
+        message: parts.join(", "),
+    };
+}
+// RFC-0664: Memory layer health check
+function checkMemoryLayer(workspaceRoot) {
+    const health = checkMemoryLayerHealth(workspaceRoot);
+    if (!health.memoryMdExists) {
+        return {
+            name: "memory-layer",
+            status: "pass",
+            message: "Memory layer not initialized — run 'forge create' or 'forge upgrade' to scaffold .agents/memory/",
+        };
+    }
+    const overBudget = health.memoryMdChars > health.budget;
+    const leakRisk = !health.gitignoreCoversDaily && health.dailyFileCount > 0;
+    if (overBudget && leakRisk) {
+        return {
+            name: "memory-layer",
+            status: "warn",
+            message: `MEMORY.md over budget (${health.memoryMdChars}/${health.budget} chars); ${health.dailyFileCount} daily file(s) untracked by .gitignore — add forge-agent-memory block`,
+        };
+    }
+    if (overBudget) {
+        return {
+            name: "memory-layer",
+            status: "warn",
+            message: `MEMORY.md over budget (${health.memoryMdChars}/${health.budget} chars) — compact or promote to skill knowledge`,
+        };
+    }
+    if (leakRisk) {
+        return {
+            name: "memory-layer",
+            status: "warn",
+            message: `${health.dailyFileCount} daily file(s) not covered by .gitignore — add forge-agent-memory block to prevent committing ephemeral logs`,
+        };
+    }
+    return {
+        name: "memory-layer",
+        status: "pass",
+        message: `MEMORY.md ${health.memoryMdChars}/${health.budget} chars; ${health.dailyFileCount} daily file(s); gitignore ${health.gitignoreCoversDaily ? "covers" : "absent (no daily files)"}`,
+    };
+}
+export async function runDoctor(input, context) {
     const { workspaceRoot, logger, outputFormat } = context;
+    const strict = input.flags["strict"] === true;
     const checks = [];
     // Check forge.yaml
     const forgeYamlExists = await pathExists(join(workspaceRoot, "forge.yaml"));
@@ -327,6 +859,29 @@ export async function runDoctor(_input, context) {
     catch {
         forgeRoot = join(workspaceRoot, "packages", "forge");
     }
+    // RFC-0640: Resolve domain report for domain-aware checks
+    const domainReport = resolveDomainReport(workspaceRoot, forgeRoot);
+    // RFC-0640: Domain info check
+    checks.push(checkDomainInfo(domainReport));
+    // RFC-0640: List invariants (reported-only, not automatically checked)
+    if (domainReport.invariants.length > 0) {
+        const invariantMessages = domainReport.invariants.map((inv) => `${inv.id}: ${inv.rule}`);
+        checks.push({
+            name: "domain-invariants",
+            status: "pass",
+            message: `${domainReport.invariants.length} invariant(s) declared (advisory): ${invariantMessages.slice(0, 3).join("; ")}${invariantMessages.length > 3 ? ` (+${invariantMessages.length - 3} more)` : ""}`,
+        });
+    }
+    // RFC-0640: Run forge.profile.validate as advisory check (warn on failure, not fail)
+    const profileValidateResult = await runProfileValidate({ argv: [], flags: {} }, { ...context, forgeRoot });
+    const invalidProfiles = profileValidateResult.data?.profiles.filter((p) => !p.valid) ?? [];
+    checks.push({
+        name: "profile-validate",
+        status: invalidProfiles.length === 0 ? "pass" : "warn",
+        message: invalidProfiles.length === 0
+            ? `${profileValidateResult.data?.profiles.length ?? 0} profile(s) valid`
+            : `${invalidProfiles.length} profile(s) invalid (advisory): ${invalidProfiles.map((p) => p.id).join(", ")}`,
+    });
     const forbiddenImports = await scanForForbiddenImports(forgeRoot, workspaceRoot);
     checks.push({
         name: "autonomy-guard",
@@ -347,14 +902,65 @@ export async function runDoctor(_input, context) {
     // Check stale knowledge files (RFC-0524, RFC-0539)
     const staleCheck = await checkStaleKnowledgeFiles(workspaceRoot, forgeRoot);
     checks.push(staleCheck);
+    // RFC-0660: Check legacy sections in knowledge files
+    const legacyCheck = checkLegacyKnowledgeSections(workspaceRoot, forgeRoot);
+    checks.push(legacyCheck);
+    // RFC-0661: Check knowledge layer token budgets
+    const budgetCheck = checkKnowledgeBudgets(workspaceRoot, forgeRoot);
+    checks.push(budgetCheck);
+    // RFC-0663: Check cross-skill duplicate principles
+    const duplicatesCheck = checkKnowledgeDuplicates(workspaceRoot, forgeRoot);
+    checks.push(duplicatesCheck);
+    // RFC-0663: Validate shared knowledge layer file
+    const sharedKnowledgeCheck = checkSharedKnowledgeFile(workspaceRoot, forgeRoot);
+    checks.push(sharedKnowledgeCheck);
+    // RFC-0664: Check memory layer health (budget, gitignore coverage, leak risk)
+    checks.push(checkMemoryLayer(workspaceRoot));
     // RFC-0539: Check pack skills — stale/missing copies and config validation
     const packCheck = await checkPackSkills(workspaceRoot);
     checks.push(packCheck);
-    const allPass = checks.every((c) => c.status === "pass");
-    const hasFails = checks.some((c) => c.status === "fail");
+    // RFC-0611: Check nested AGENTS.md — missing, stale, hand-written
+    // RFC-0640: Use profile-driven workspace types when available (all domains)
+    // RFC-0640 fix: previously gated by isSoftwareDomain, which skipped the check
+    // entirely for non-software domains. Now runs for all domains — profile-driven
+    // wsTypes replace hardcoded detection when present.
+    {
+        let wsTypes;
+        try {
+            const config = loadForgeConfig(workspaceRoot);
+            // RFC-0643: prefer config.profile (loaded by loadForgeConfig)
+            if (config.profile?.workspaceTypes && config.profile.workspaceTypes.length > 0) {
+                wsTypes = config.profile.workspaceTypes;
+            }
+            else {
+                const profiles = listStackProfiles(forgeRoot);
+                for (const stackId of config.project.stack) {
+                    const profile = profiles.find((p) => p.id === stackId);
+                    if (profile?.workspaceTypes && profile.workspaceTypes.length > 0) {
+                        wsTypes = profile.workspaceTypes;
+                        break;
+                    }
+                }
+            }
+        }
+        catch {
+            // profiles not loadable
+        }
+        const nestedCheck = await checkNestedAgentsMd(workspaceRoot, wsTypes);
+        checks.push(nestedCheck);
+    }
+    // RFC-0640: --strict flag elevates warn to fail for domain-related checks
+    const finalChecks = strict
+        ? checks.map((c) => c.status === "warn" &&
+            (c.name === "domain-invariants" || c.name === "profile-validate")
+            ? { ...c, status: "fail" }
+            : c)
+        : checks;
+    const allPass = finalChecks.every((c) => c.status === "pass");
+    const hasFails = finalChecks.some((c) => c.status === "fail");
     if (outputFormat === "pretty") {
         logger.section(`Forge Doctor — ${workspaceRoot}`);
-        for (const check of checks) {
+        for (const check of finalChecks) {
             const icon = check.status === "pass" ? "✓" : check.status === "warn" ? "⚠" : "✖";
             const fn = check.status === "pass" ? logger.success : check.status === "warn" ? logger.warn : logger.error;
             fn(`${icon} ${check.name}: ${check.message}`);
@@ -370,11 +976,11 @@ export async function runDoctor(_input, context) {
         }
     }
     return {
-        data: { command: "forge.doctor", checks, allPass, forbiddenImports, bindings: bindingsResult },
+        data: { command: "forge.doctor", checks: finalChecks, allPass, forbiddenImports, bindings: bindingsResult, domain: domainReport },
         exitCode: hasFails ? 1 : 0,
         summary: allPass
             ? "forge.doctor: all checks passed"
-            : `forge.doctor: ${checks.filter((c) => c.status === "fail").length} fail(s), ${checks.filter((c) => c.status === "warn").length} warn(s)`,
+            : `forge.doctor: ${finalChecks.filter((c) => c.status === "fail").length} fail(s), ${finalChecks.filter((c) => c.status === "warn").length} warn(s)`,
     };
 }
 //# sourceMappingURL=doctor.js.map