cclaw-cli 0.11.0 → 0.13.0

package/dist/delegation.js

@@ -1,7 +1,9 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
+import { readConfig } from "./config.js";
 import { exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
+import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 import { readFlowState } from "./runs.js";
 import { stageSchema } from "./content/stage-schema.js";
 function delegationLogPath(projectRoot) {
@@ -84,11 +86,34 @@ export async function checkMandatoryDelegations(projectRoot, stage) {
         .map((e) => `${e.agent}(runId=${e.runId ?? "unknown"})`);
     const missing = [];
     const waived = [];
+    const autoWaived = [];
+    const config = await readConfig(projectRoot).catch(() => null);
+    const harnesses = config?.harnesses ?? [];
+    const nativeDelegationUnavailable = harnesses.length > 0 &&
+        harnesses.every((harness) => HARNESS_ADAPTERS[harness].capabilities.nativeSubagentDispatch === "none");
     for (const agent of mandatory) {
         const rows = forRun.filter((e) => e.agent === agent);
         const ok = rows.some((e) => e.status === "completed" || e.status === "waived");
         if (!ok) {
-            missing.push(agent);
+            if (nativeDelegationUnavailable) {
+                const existingHarnessWaiver = rows.some((e) => e.status === "waived" && e.waiverReason === "harness_limitation");
+                if (!existingHarnessWaiver) {
+                    await appendDelegation(projectRoot, {
+                        stage,
+                        agent,
+                        mode: "mandatory",
+                        status: "waived",
+                        waiverReason: "harness_limitation",
+                        ts: new Date().toISOString(),
+                        runId: activeRunId
+                    });
+                }
+                waived.push(agent);
+                autoWaived.push(agent);
+            }
+            else {
+                missing.push(agent);
+            }
         }
         else if (rows.some((e) => e.status === "waived")) {
             waived.push(agent);
@@ -98,6 +123,7 @@ export async function checkMandatoryDelegations(projectRoot, stage) {
         satisfied: missing.length === 0,
         missing,
         waived,
+        autoWaived,
         staleIgnored
     };
 }

package/dist/doctor-registry.d.ts

@@ -0,0 +1,8 @@
+export type DoctorSeverity = "error" | "warning" | "info";
+export interface DoctorCheckMetadata {
+    severity: DoctorSeverity;
+    summary: string;
+    fix: string;
+    docRef?: string;
+}
+export declare function doctorCheckMetadata(checkName: string): DoctorCheckMetadata;

package/dist/doctor-registry.js

@@ -0,0 +1,127 @@
+import { DOCTOR_REFERENCE_DIR } from "./content/doctor-references.js";
+function ref(fileName) {
+    return `${DOCTOR_REFERENCE_DIR}/${fileName}`;
+}
+const RULES = [
+    {
+        test: /^gates:reconcile:writeback$/,
+        metadata: {
+            severity: "info",
+            summary: "Gate reconciliation status update.",
+            fix: "No action required unless subsequent gate checks fail.",
+            docRef: ref("state-and-gates.md")
+        }
+    },
+    {
+        test: /^warning:/,
+        metadata: {
+            severity: "warning",
+            summary: "Advisory signal; runtime can continue with caution.",
+            fix: "Address when possible to prevent future drift or degraded behavior.",
+            docRef: ref("README.md")
+        }
+    },
+    {
+        test: /^skill:.*:(max_lines|min_lines|canonical_sections)$/,
+        metadata: {
+            severity: "warning",
+            summary: "Stage skill quality guardrail check.",
+            fix: "Tune generated stage skill content and re-run `cclaw sync`.",
+            docRef: ref("runtime-layout.md")
+        }
+    },
+    {
+        test: /^capability:runtime:json_parser$/,
+        metadata: {
+            severity: "warning",
+            summary: "Optional JSON fallback parser availability.",
+            fix: "Install at least one of `python3` or `jq` for resilient fallback parsing.",
+            docRef: ref("tooling-capabilities.md")
+        }
+    },
+    {
+        test: /^capability:required:/,
+        metadata: {
+            severity: "error",
+            summary: "Required runtime tooling availability check.",
+            fix: "Install the missing required tool and re-run `cclaw doctor`.",
+            docRef: ref("tooling-capabilities.md")
+        }
+    },
+    {
+        test: /^(dir:|command:|utility_command:|skill:|utility_skill:|agent:|harness_tool_ref:|harness_ref:|stage_examples_ref:|doctor_ref:)/,
+        metadata: {
+            severity: "error",
+            summary: "Generated runtime surface presence check.",
+            fix: "Run `cclaw sync` to regenerate runtime files, then re-run doctor.",
+            docRef: ref("runtime-layout.md")
+        }
+    },
+    {
+        test: /^(hook:|lifecycle:|git_hooks:)/,
+        metadata: {
+            severity: "error",
+            summary: "Hook wiring and lifecycle integration check.",
+            fix: "Repair hook/plugin wiring (usually via `cclaw sync`) and validate harness config.",
+            docRef: ref("hooks-and-lifecycle.md")
+        }
+    },
+    {
+        test: /^(shim:|agents:cclaw_block|rules:cursor:workflow)/,
+        metadata: {
+            severity: "error",
+            summary: "Harness shim and routing file consistency check.",
+            fix: "Regenerate harness adapters via `cclaw sync`; confirm enabled harness list.",
+            docRef: ref("harness-and-routing.md")
+        }
+    },
+    {
+        test: /^(flow_state:|state:|contexts:|gates:)/,
+        metadata: {
+            severity: "error",
+            summary: "Flow state and gate evidence consistency check.",
+            fix: "Repair flow-state artifacts and gate evidence, then run `cclaw doctor --reconcile-gates`.",
+            docRef: ref("state-and-gates.md")
+        }
+    },
+    {
+        test: /^delegation:/,
+        metadata: {
+            severity: "error",
+            summary: "Mandatory delegation completion check.",
+            fix: "Complete or explicitly waive missing mandatory delegations in delegation log.",
+            docRef: ref("delegation-and-preamble.md")
+        }
+    },
+    {
+        test: /^trace:/,
+        metadata: {
+            severity: "error",
+            summary: "Cross-artifact traceability integrity check.",
+            fix: "Restore criterion/task/test ID mappings across spec, plan, and tdd artifacts.",
+            docRef: ref("traceability.md")
+        }
+    },
+    {
+        test: /^(config:|rules:policy_schema|language_rule_pack:|gitignore:|git:)/,
+        metadata: {
+            severity: "error",
+            summary: "Config or policy schema consistency check.",
+            fix: "Fix config/rules drift, then run `cclaw sync` and re-run doctor.",
+            docRef: ref("config-and-policy.md")
+        }
+    }
+];
+export function doctorCheckMetadata(checkName) {
+    for (const rule of RULES) {
+        if (rule.test.test(checkName)) {
+            return { ...rule.metadata };
+        }
+    }
+    return {
+        severity: "error",
+        summary: "Doctor runtime integrity check.",
+        fix: "Inspect check details, apply the suggested remediation, and re-run `cclaw doctor`.",
+        docRef: ref("README.md")
+    };
+}

package/dist/doctor.d.ts

@@ -1,7 +1,12 @@
+import type { DoctorSeverity } from "./doctor-registry.js";
 export interface DoctorCheck {
     name: string;
     ok: boolean;
     details: string;
+    severity: DoctorSeverity;
+    summary: string;
+    fix: string;
+    docRef?: string;
 }
 export interface DoctorOptions {
     /** When true, normalize current-stage gate catalog and persist reconciliation before checks. */

package/dist/doctor.js

@@ -4,7 +4,7 @@ import { execFile } from "node:child_process";
 import { pathToFileURL } from "node:url";
 import { promisify } from "node:util";
 import { COMMAND_FILE_ORDER, REQUIRED_DIRS, RUNTIME_ROOT } from "./constants.js";
-import { CCLAW_AGENTS } from "./content/agents.js";
+import { CCLAW_AGENTS } from "./content/core-agents.js";
 import { readConfig } from "./config.js";
 import { exists } from "./fs-utils.js";
 import { gitignoreHasRequiredPatterns } from "./gitignore.js";
@@ -14,13 +14,18 @@ import { readFlowState } from "./runs.js";
 import { skippedStagesForTrack } from "./flow-state.js";
 import { TRACK_STAGES } from "./types.js";
 import { checkMandatoryDelegations } from "./delegation.js";
+import { ensureFeatureSystem, featureRootPath, listFeatures, readActiveFeature } from "./feature-system.js";
 import { buildTraceMatrix } from "./trace-matrix.js";
 import { reconcileAndWriteCurrentStageGateCatalog, verifyCompletedStagesGateClosure, verifyCurrentStageGateEvidence } from "./gate-evidence.js";
+import { parseTddCycleLog, validateTddCycleOrder } from "./tdd-cycle.js";
 import { stageSkillFolder } from "./content/skills.js";
+import { doctorCheckMetadata } from "./doctor-registry.js";
 import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LEGACY_LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS } from "./content/utility-skills.js";
 import { CONTEXT_MODES, DEFAULT_CONTEXT_MODE } from "./content/contexts.js";
+import { DOCTOR_REFERENCE_MARKDOWN } from "./content/doctor-references.js";
 import { validateHookDocument } from "./hook-schema.js";
 const execFileAsync = promisify(execFile);
+const PREAMBLE_COOLDOWN_MS = 15 * 60 * 1000;
 async function isGitRepo(projectRoot) {
     try {
         await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: projectRoot });
@@ -345,6 +350,20 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: refPath
         });
     }
+    checks.push({
+        name: "harness_ref:matrix",
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "references", "harnesses.md")),
+        details: `${RUNTIME_ROOT}/references/harnesses.md`
+    });
+    const doctorRefDir = path.join(projectRoot, RUNTIME_ROOT, "references", "doctor");
+    for (const fileName of Object.keys(DOCTOR_REFERENCE_MARKDOWN)) {
+        const refPath = path.join(doctorRefDir, fileName);
+        checks.push({
+            name: `doctor_ref:${fileName.replace(/\.md$/, "")}`,
+            ok: await exists(refPath),
+            details: refPath
+        });
+    }
     checks.push({
         name: "gitignore:required_patterns",
         ok: await gitignoreHasRequiredPatterns(projectRoot),
@@ -428,7 +447,19 @@ export async function doctorChecks(projectRoot, options = {}) {
             });
             continue;
         }
-        for (const shim of ["cc.md", "cc-next.md", "cc-learn.md"]) {
+        for (const shim of [
+            "cc.md",
+            "cc-next.md",
+            "cc-learn.md",
+            "cc-status.md",
+            "cc-tree.md",
+            "cc-diff.md",
+            "cc-feature.md",
+            "cc-tdd-log.md",
+            "cc-retro.md",
+            "cc-rewind.md",
+            "cc-rewind-ack.md"
+        ]) {
             const shimPath = path.join(projectRoot, adapter.commandDir, shim);
             checks.push({
                 name: `shim:${harness}:${shim.replace(".md", "")}`,
@@ -445,10 +476,32 @@ export async function doctorChecks(projectRoot, options = {}) {
         const hasCcCommand = content.includes("/cc");
         const hasCcNext = content.includes("/cc-next");
         const hasCcLearn = content.includes("/cc-learn");
+        const hasCcStatus = content.includes("/cc-status");
+        const hasCcTree = content.includes("/cc-tree");
+        const hasCcDiff = content.includes("/cc-diff");
+        const hasCcFeature = content.includes("/cc-feature");
+        const hasCcTddLog = content.includes("/cc-tdd-log");
+        const hasCcRetro = content.includes("/cc-retro");
+        const hasCcRewind = content.includes("/cc-rewind");
+        const hasCcRewindAck = content.includes("/cc-rewind-ack");
         const hasVerification = content.includes("Verification Discipline");
         const hasMinimalMarker = content.includes("intentionally minimal for cross-project use");
         const hasMetaSkillPointer = content.includes(".cclaw/skills/using-cclaw/SKILL.md");
-        agentsBlockOk = hasMarkers && hasCcCommand && hasCcNext && hasCcLearn && hasVerification && hasMinimalMarker && hasMetaSkillPointer;
+        agentsBlockOk = hasMarkers
+            && hasCcCommand
+            && hasCcNext
+            && hasCcLearn
+            && hasCcStatus
+            && hasCcTree
+            && hasCcDiff
+            && hasCcFeature
+            && hasCcTddLog
+            && hasCcRetro
+            && hasCcRewind
+            && hasCcRewindAck
+            && hasVerification
+            && hasMinimalMarker
+            && hasMetaSkillPointer;
     }
     checks.push({
         name: "agents:cclaw_block",
@@ -456,7 +509,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         details: `${agentsFile} must contain the managed cclaw marker block with routing, verification, and minimal detail pointer`
     });
     // Utility commands
-    for (const cmd of ["learn"]) {
+    for (const cmd of ["learn", "next", "status", "tree", "diff", "feature", "tdd-log", "retro", "rewind", "rewind-ack"]) {
         const cmdPath = path.join(projectRoot, RUNTIME_ROOT, "commands", `${cmd}.md`);
         checks.push({
             name: `utility_command:${cmd}`,
@@ -467,6 +520,12 @@ export async function doctorChecks(projectRoot, options = {}) {
     // Utility skills
     for (const [folder, label] of [
         ["learnings", "learnings"],
+        ["flow-tree", "flow-tree"],
+        ["flow-diff", "flow-diff"],
+        ["feature-workspaces", "feature-workspaces"],
+        ["tdd-cycle-log", "tdd-cycle-log"],
+        ["flow-retro", "flow-retro"],
+        ["flow-rewind", "flow-rewind"],
         ["subagent-dev", "sdd"],
         ["parallel-dispatch", "parallel-agents"],
         ["session", "session"],
@@ -810,6 +869,11 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "state", "suggestion-memory.json")),
         details: `${RUNTIME_ROOT}/state/suggestion-memory.json must exist for proactive suggestion memory`
     });
+    checks.push({
+        name: "state:harness_gaps_exists",
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "state", "harness-gaps.json")),
+        details: `${RUNTIME_ROOT}/state/harness-gaps.json must exist for tiered harness capability tracking`
+    });
     const contextModeStatePath = path.join(projectRoot, RUNTIME_ROOT, "state", "context-mode.json");
     checks.push({
         name: "state:context_mode_exists",
@@ -840,6 +904,83 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: modePath
         });
     }
+    const preambleLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "preamble-log.jsonl");
+    const preambleLogExists = await exists(preambleLogPath);
+    checks.push({
+        name: "state:preamble_log_exists",
+        ok: preambleLogExists,
+        details: `${RUNTIME_ROOT}/state/preamble-log.jsonl must exist for preamble budget tracking`
+    });
+    if (preambleLogExists) {
+        let duplicateHits = 0;
+        let parsedEntries = 0;
+        let malformedEntries = 0;
+        try {
+            const now = Date.now();
+            const byKey = new Map();
+            const raw = await fs.readFile(preambleLogPath, "utf8");
+            const lines = raw
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    const tsRaw = parsed.ts;
+                    const stageRaw = parsed.stage;
+                    const triggerRaw = parsed.trigger;
+                    const hashRaw = parsed.hash;
+                    if (typeof tsRaw !== "string" ||
+                        typeof stageRaw !== "string" ||
+                        typeof triggerRaw !== "string" ||
+                        typeof hashRaw !== "string") {
+                        malformedEntries += 1;
+                        continue;
+                    }
+                    const stamp = Date.parse(tsRaw);
+                    if (!Number.isFinite(stamp)) {
+                        malformedEntries += 1;
+                        continue;
+                    }
+                    if (now - stamp > 24 * 60 * 60 * 1000) {
+                        continue;
+                    }
+                    parsedEntries += 1;
+                    const key = `${stageRaw}|${triggerRaw}|${hashRaw}`;
+                    const bucket = byKey.get(key) ?? [];
+                    bucket.push(stamp);
+                    byKey.set(key, bucket);
+                }
+                catch {
+                    malformedEntries += 1;
+                }
+            }
+            for (const stamps of byKey.values()) {
+                stamps.sort((a, b) => a - b);
+                for (let i = 1; i < stamps.length; i += 1) {
+                    if (stamps[i] - stamps[i - 1] < PREAMBLE_COOLDOWN_MS) {
+                        duplicateHits += 1;
+                    }
+                }
+            }
+        }
+        catch {
+            malformedEntries += 1;
+        }
+        checks.push({
+            name: "warning:preamble:dedup",
+            ok: true,
+            details: duplicateHits > 0
+                ? `warning: detected ${duplicateHits} repeated preamble emission(s) inside ${Math.floor(PREAMBLE_COOLDOWN_MS / 60000)}m cooldown window`
+                : parsedEntries > 0
+                    ? `preamble budget healthy (${parsedEntries} recent preamble entry/entries checked)`
+                    : malformedEntries > 0
+                        ? `warning: preamble log exists but entries are malformed (${malformedEntries} line(s) ignored)`
+                        : "preamble log is empty; no recent preamble emissions recorded"
+        });
+    }
+    await ensureFeatureSystem(projectRoot);
+    const activeFeature = await readActiveFeature(projectRoot);
     let flowState = await readFlowState(projectRoot);
     if (options.reconcileCurrentStageGates === true) {
         const reconciliation = await reconcileAndWriteCurrentStageGateCatalog(projectRoot);
@@ -894,6 +1035,108 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "artifacts")),
         details: `${RUNTIME_ROOT}/artifacts must exist as the active artifact root`
     });
+    const features = await listFeatures(projectRoot);
+    checks.push({
+        name: "state:active_feature_meta",
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "state", "active-feature.json")),
+        details: `${RUNTIME_ROOT}/state/active-feature.json must exist`
+    });
+    checks.push({
+        name: "state:active_feature_exists",
+        ok: features.includes(activeFeature),
+        details: features.includes(activeFeature)
+            ? `active feature "${activeFeature}" is present in ${RUNTIME_ROOT}/features`
+            : `active feature "${activeFeature}" is missing from ${RUNTIME_ROOT}/features`
+    });
+    checks.push({
+        name: "state:features_nonempty",
+        ok: features.length > 0,
+        details: features.length > 0
+            ? `${features.length} feature snapshot(s): ${features.join(", ")}`
+            : `no feature snapshots found under ${RUNTIME_ROOT}/features`
+    });
+    checks.push({
+        name: "state:active_feature_snapshot_dirs",
+        ok: await exists(path.join(featureRootPath(projectRoot, activeFeature), "artifacts")) &&
+            await exists(path.join(featureRootPath(projectRoot, activeFeature), "state")),
+        details: `${RUNTIME_ROOT}/features/${activeFeature}/artifacts and /state must exist`
+    });
+    const staleStages = Object.keys(flowState.staleStages).filter((value) => COMMAND_FILE_ORDER.includes(value));
+    checks.push({
+        name: "state:stale_stages_resolved",
+        ok: staleStages.length === 0,
+        details: staleStages.length === 0
+            ? "no stale stages pending acknowledgement"
+            : `stale stages must be acknowledged via /cc-rewind-ack: ${staleStages.join(", ")}`
+    });
+    const retroRequired = flowState.completedStages.includes("ship");
+    const retroComplete = !retroRequired ||
+        (typeof flowState.retro.completedAt === "string" && flowState.retro.compoundEntries > 0);
+    checks.push({
+        name: "state:retro_gate",
+        ok: retroComplete,
+        details: retroComplete
+            ? retroRequired
+                ? `retro gate complete (${flowState.retro.compoundEntries} compound entries)`
+                : "retro gate not required yet (ship not completed)"
+            : "retro gate incomplete: run /cc-retro and record at least one compound knowledge entry"
+    });
+    const flowSnapshotPath = path.join(projectRoot, RUNTIME_ROOT, "state", "flow-state.snapshot.json");
+    const flowSnapshotExists = await exists(flowSnapshotPath);
+    let flowSnapshotValid = flowSnapshotExists;
+    if (flowSnapshotExists) {
+        try {
+            JSON.parse(await fs.readFile(flowSnapshotPath, "utf8"));
+            flowSnapshotValid = true;
+        }
+        catch {
+            flowSnapshotValid = false;
+        }
+    }
+    checks.push({
+        name: "state:flow_snapshot",
+        ok: flowSnapshotExists && flowSnapshotValid,
+        details: flowSnapshotExists
+            ? flowSnapshotValid
+                ? `${RUNTIME_ROOT}/state/flow-state.snapshot.json exists and is valid JSON`
+                : `${RUNTIME_ROOT}/state/flow-state.snapshot.json exists but is invalid JSON`
+            : `${RUNTIME_ROOT}/state/flow-state.snapshot.json is missing`
+    });
+    const tddLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-cycle-log.jsonl");
+    const tddLogExists = await exists(tddLogPath);
+    checks.push({
+        name: "state:tdd_cycle_log_exists",
+        ok: tddLogExists,
+        details: `${RUNTIME_ROOT}/state/tdd-cycle-log.jsonl must exist`
+    });
+    const tddCompleted = flowState.completedStages.includes("tdd")
+        || (flowState.currentStage === "review" || flowState.currentStage === "ship");
+    if (tddLogExists) {
+        const tddLogRaw = await fs.readFile(tddLogPath, "utf8");
+        const parsedCycles = parseTddCycleLog(tddLogRaw);
+        const validation = validateTddCycleOrder(parsedCycles, { runId: activeRunId || undefined });
+        const hasCoverage = validation.sliceCount > 0;
+        checks.push({
+            name: "state:tdd_cycle_order",
+            ok: validation.ok && (!tddCompleted || hasCoverage),
+            details: validation.ok
+                ? tddCompleted && !hasCoverage
+                    ? "tdd stage complete but no RED/GREEN cycle evidence logged"
+                    : `tdd cycle log valid (${validation.sliceCount} slice(s), open_red=${validation.openRedSlices.length})`
+                : `tdd cycle order issues: ${validation.issues.join("; ")}${validation.openRedSlices.length > 0
+                    ? ` | open red slices: ${validation.openRedSlices.join(", ")}`
+                    : ""}`
+        });
+    }
+    else {
+        checks.push({
+            name: "state:tdd_cycle_order",
+            ok: !tddCompleted,
+            details: tddCompleted
+                ? "tdd stage complete but tdd-cycle-log.jsonl is missing"
+                : "tdd cycle order deferred until tdd stage evidence is generated"
+        });
+    }
     checks.push({
         name: "runs:archive_root",
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "runs")),
@@ -911,7 +1154,9 @@ export async function doctorChecks(projectRoot, options = {}) {
         name: "warning:delegation:waived",
         ok: true,
         details: delegation.waived.length > 0
-            ? `warning: waived mandatory delegations for stage "${flowState.currentStage}": ${delegation.waived.join(", ")}`
+            ? `warning: waived mandatory delegations for stage "${flowState.currentStage}": ${delegation.waived.join(", ")}${delegation.autoWaived.length > 0
+                ? ` (auto-waived due to harness limitation: ${delegation.autoWaived.join(", ")})`
+                : ""}`
             : "no waived mandatory delegations for current stage"
     });
     checks.push({
@@ -1025,8 +1270,17 @@ export async function doctorChecks(projectRoot, options = {}) {
     });
     const policy = await policyChecks(projectRoot, { harnesses: configuredHarnesses });
     checks.push(...policy);
-    return checks;
+    return checks.map((check) => {
+        const metadata = doctorCheckMetadata(check.name);
+        return {
+            ...check,
+            severity: check.severity ?? metadata.severity,
+            summary: check.summary ?? metadata.summary,
+            fix: check.fix ?? metadata.fix,
+            docRef: check.docRef ?? metadata.docRef
+        };
+    });
 }
 export function doctorSucceeded(checks) {
-    return checks.every((check) => check.ok);
+    return checks.every((check) => check.ok || check.severity !== "error");
 }

package/dist/feature-system.d.ts

@@ -0,0 +1,18 @@
+export interface ActiveFeatureMeta {
+    activeFeature: string;
+    updatedAt: string;
+}
+export declare function activeFeatureMetaPath(projectRoot: string): string;
+export declare function featureRootPath(projectRoot: string, featureId: string): string;
+export declare function featureArtifactsPath(projectRoot: string, featureId: string): string;
+export declare function featureStatePath(projectRoot: string, featureId: string): string;
+export declare function readActiveFeature(projectRoot: string): Promise<string>;
+export declare function listFeatures(projectRoot: string): Promise<string[]>;
+export declare function ensureFeatureSystem(projectRoot: string): Promise<ActiveFeatureMeta>;
+export declare function syncActiveFeatureSnapshot(projectRoot: string): Promise<void>;
+export declare function switchActiveFeature(projectRoot: string, featureId: string): Promise<ActiveFeatureMeta>;
+export interface CreateFeatureOptions {
+    cloneActive?: boolean;
+    switchTo?: boolean;
+}
+export declare function createFeature(projectRoot: string, rawFeatureId: string, options?: CreateFeatureOptions): Promise<string>;