cclaw-cli 1.0.0 → 3.0.0

package/dist/config.js

@@ -2,219 +2,67 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { parse, stringify } from "yaml";
 import { CCLAW_VERSION, DEFAULT_HARNESSES, FLOW_VERSION, RUNTIME_ROOT } from "./constants.js";
-import { isIronLawId, normalizeStrictLawIds } from "./content/iron-laws.js";
 import { exists, writeFileSafe } from "./fs-utils.js";
-import { FLOW_TRACKS, HARNESS_IDS, LANGUAGE_RULE_PACKS } from "./types.js";
+import { HARNESS_IDS } from "./types.js";
 const CONFIG_PATH = `${RUNTIME_ROOT}/config.yaml`;
 const HARNESS_ID_SET = new Set(HARNESS_IDS);
-const FLOW_TRACK_SET = new Set(FLOW_TRACKS);
-const LANGUAGE_RULE_PACK_SET = new Set(LANGUAGE_RULE_PACKS);
+const ALLOWED_CONFIG_KEYS = new Set(["version", "flowVersion", "harnesses"]);
 const SUPPORTED_HARNESSES_TEXT = HARNESS_IDS.join(", ");
-const SUPPORTED_TRACKS_TEXT = FLOW_TRACKS.join(", ");
-const SUPPORTED_LANGUAGE_RULE_PACKS_TEXT = LANGUAGE_RULE_PACKS.join(", ");
-const ALLOWED_CONFIG_KEYS = new Set([
-    "version",
-    "flowVersion",
-    "harnesses",
-    "vcs",
-    "strictness",
-    "tddTestGlobs",
-    "tdd",
-    "compound",
-    "earlyLoop",
-    "early_loop",
-    "gitHookGuards",
-    "defaultTrack",
-    "languageRulePacks",
-    "trackHeuristics",
-    "sliceReview",
-    "ironLaws",
-    "optInAudits",
-    "reviewLoop"
-]);
-/**
- * Config keys removed in the advisory-by-default consolidation. Kept here so
- * the parser can emit a helpful migration error pointing users at the new
- * single `strictness` knob instead of a generic "unknown key" message.
- */
-const RETIRED_GUARD_CONFIG_KEYS = new Set([
-    "promptGuardMode",
-    "tddEnforcement",
-    "workflowGuardMode"
-]);
-/**
- * Config keys always present in the minimal init template. Everything else
- * is "advanced" — parsed when present, but not pre-populated by `cclaw init`.
- *
- * Deliberately small: a first-time user should only see knobs they might
- * actually flip. Power users override by adding more keys by hand; the
- * reference lives in `docs/config.md`.
- */
-const MINIMAL_CONFIG_KEYS = [
-    "version",
-    "flowVersion",
-    "harnesses",
-    "vcs",
-    "strictness",
-    "gitHookGuards"
+// Kept for runtime modules that use these defaults directly.
+export const DEFAULT_TDD_TEST_PATH_PATTERNS = [
+    "**/*.test.*",
+    "**/tests/**",
+    "**/__tests__/**"
 ];
-const DEFAULT_SLICE_REVIEW_THRESHOLD = 5;
-const DEFAULT_SLICE_REVIEW_TRACKS = ["standard"];
+export const DEFAULT_TDD_TEST_GLOBS = [...DEFAULT_TDD_TEST_PATH_PATTERNS];
+export const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS = [];
+export const DEFAULT_COMPOUND_RECURRENCE_THRESHOLD = 3;
+export const DEFAULT_EARLY_LOOP_MAX_ITERATIONS = 3;
 export function createConfigWarningState() {
     return { emitted: new Set() };
 }
-function emitConfigWarningOnce(warningState, code, message) {
-    const key = `${code}:${message}`;
-    if (warningState.emitted.has(key)) {
-        return;
+export class InvalidConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidConfigError";
     }
-    warningState.emitted.add(key);
-    process.emitWarning(message, { code });
-}
-function sameStringArray(a, b) {
-    if (!a || !b)
-        return false;
-    if (a.length !== b.length)
-        return false;
-    return a.every((value, index) => value === b[index]);
 }
 function configFixExample() {
     return `harnesses:
   - claude
   - cursor`;
 }
-export class InvalidConfigError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "InvalidConfigError";
-    }
-}
 function configValidationError(configFilePath, reason) {
     return new InvalidConfigError(`Invalid cclaw config at ${configFilePath}: ${reason}\n` +
         `Supported harnesses: ${SUPPORTED_HARNESSES_TEXT}\n` +
-        `Supported tracks: ${SUPPORTED_TRACKS_TEXT}\n` +
-        `Supported languageRulePacks: ${SUPPORTED_LANGUAGE_RULE_PACKS_TEXT}\n` +
         `Example config:\n${configFixExample()}\n` +
         `After fixing, run: cclaw sync`);
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function validateStringArray(value, fieldName, configFilePath) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value)) {
-        throw configValidationError(configFilePath, `"${fieldName}" must be an array of strings`);
-    }
-    const invalid = value.filter((item) => typeof item !== "string");
-    if (invalid.length > 0) {
-        throw configValidationError(configFilePath, `"${fieldName}" must contain only strings`);
-    }
-    return value;
-}
 export function configPath(projectRoot) {
     return path.join(projectRoot, CONFIG_PATH);
 }
-/**
- * Default test-path patterns used by the workflow-guard hook to classify TDD writes.
- *
- * Scope is intentionally narrow and language-agnostic; users can extend this
- * list in config when their repository uses different conventions.
- */
-export const DEFAULT_TDD_TEST_PATH_PATTERNS = [
-    "**/*.test.*",
-    "**/tests/**",
-    "**/__tests__/**"
-];
-/**
- * Legacy alias kept for backwards compatibility with `tddTestGlobs`.
- * Prefer `tdd.testPathPatterns` in new configurations.
- */
-export const DEFAULT_TDD_TEST_GLOBS = [...DEFAULT_TDD_TEST_PATH_PATTERNS];
-export const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS = [];
-export const DEFAULT_COMPOUND_RECURRENCE_THRESHOLD = 3;
-export const DEFAULT_EARLY_LOOP_MAX_ITERATIONS = 3;
-/**
- * Populated runtime view of config values that downstream callers (install,
- * observe, sync/runtime checks) consume. Always has the derived guard modes populated,
- * regardless of whether the user wrote `strictness`, the legacy keys, both,
- * or neither.
- */
-export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, defaultTrack = "standard") {
-    const tddTestPathPatterns = [...DEFAULT_TDD_TEST_PATH_PATTERNS];
-    const tddProductionPathPatterns = [...DEFAULT_TDD_PRODUCTION_PATH_PATTERNS];
+export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, _defaultTrack = "standard") {
     return {
         version: CCLAW_VERSION,
         flowVersion: FLOW_VERSION,
-        harnesses,
-        vcs: "git-local-only",
-        strictness: "advisory",
-        tddTestGlobs: [...tddTestPathPatterns],
-        tdd: {
-            testPathPatterns: tddTestPathPatterns,
-            productionPathPatterns: tddProductionPathPatterns,
-            verificationRef: "auto"
-        },
-        compound: {
-            recurrenceThreshold: DEFAULT_COMPOUND_RECURRENCE_THRESHOLD
-        },
-        earlyLoop: {
-            enabled: true,
-            maxIterations: DEFAULT_EARLY_LOOP_MAX_ITERATIONS
-        },
-        gitHookGuards: false,
-        defaultTrack,
-        languageRulePacks: [],
-        ironLaws: {
-            strictLaws: []
-        },
-        optInAudits: {
-            scopePreAudit: false,
-            staleDiagramAudit: true
-        }
+        harnesses: [...new Set(harnesses)]
     };
 }
-/**
- * Probe common project-root manifests to infer which language rule packs the
- * user would reasonably want. Pure-functional best-effort: any filesystem
- * error is swallowed, producing an empty list — the user can always override
- * by hand.
- *
- * Called from `cclaw init` only (not `readConfig`), so subsequent upgrades
- * never surprise a user who intentionally cleared the list.
- */
-export async function detectLanguageRulePacks(projectRoot) {
-    const detected = [];
-    const pkgPath = path.join(projectRoot, "package.json");
-    if (await exists(pkgPath)) {
-        try {
-            const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
-            const deps = {
-                ...pkg.dependencies,
-                ...pkg.devDependencies
-            };
-            if ("typescript" in deps || typeof pkg.types === "string") {
-                detected.push("typescript");
-            }
-        }
-        catch {
-            // Malformed package.json — skip; user can set the pack manually later.
-        }
-    }
-    const pythonMarkers = ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"];
-    for (const marker of pythonMarkers) {
-        if (await exists(path.join(projectRoot, marker))) {
-            detected.push("python");
-            break;
-        }
-    }
-    if (await exists(path.join(projectRoot, "go.mod"))) {
-        detected.push("go");
-    }
-    return [...new Set(detected)];
+function assertOnlySupportedKeys(parsed, fullPath) {
+    const unknownKeys = Object.keys(parsed).filter((key) => !ALLOWED_CONFIG_KEYS.has(key));
+    if (unknownKeys.length === 0)
+        return;
+    const keyList = unknownKeys.join(", ");
+    throw configValidationError(fullPath, `key(s) ${keyList} are no longer supported in cclaw 3.0.0; see CHANGELOG.md`);
+}
+export async function detectLanguageRulePacks(_projectRoot) {
+    // Wave 21: harness-only config. Language packs are no longer configurable.
+    return [];
 }
-export async function readConfig(projectRoot, options = {}) {
-    const warningState = options.warningState ?? createConfigWarningState();
+export async function readConfig(projectRoot, _options = {}) {
     const fullPath = configPath(projectRoot);
     if (!(await exists(fullPath))) {
         return createDefaultConfig();
@@ -227,486 +75,48 @@ export async function readConfig(projectRoot, options = {}) {
         const reason = error instanceof Error ? error.message : "unknown parse error";
         throw configValidationError(fullPath, `failed to parse YAML (${reason})`);
     }
-    if (parsedUnknown !== null && parsedUnknown !== undefined && typeof parsedUnknown !== "object") {
+    if (parsedUnknown !== null && parsedUnknown !== undefined && !isRecord(parsedUnknown)) {
         throw configValidationError(fullPath, "top-level config must be a YAML mapping/object");
     }
-    const parsed = (parsedUnknown && typeof parsedUnknown === "object"
-        ? parsedUnknown
-        : {});
-    const retiredGuardKeys = Object.keys(parsed).filter((key) => RETIRED_GUARD_CONFIG_KEYS.has(key));
-    if (retiredGuardKeys.length > 0) {
-        throw configValidationError(fullPath, `config key(s) ${retiredGuardKeys.join(", ")} were removed; ` +
-            `use the single \`strictness: advisory|strict\` knob instead ` +
-            `(advisory is the default). See docs/config.md#strictness for migration.`);
-    }
-    const unknownKeys = Object.keys(parsed).filter((key) => !ALLOWED_CONFIG_KEYS.has(key));
-    if (unknownKeys.length > 0) {
-        throw configValidationError(fullPath, `unknown top-level key(s): ${unknownKeys.join(", ")}`);
-    }
-    const hasHarnessesField = Object.prototype.hasOwnProperty.call(parsed, "harnesses");
-    if (hasHarnessesField && !Array.isArray(parsed.harnesses)) {
+    const parsed = (isRecord(parsedUnknown) ? parsedUnknown : {});
+    assertOnlySupportedKeys(parsed, fullPath);
+    if (Object.prototype.hasOwnProperty.call(parsed, "harnesses") &&
+        !Array.isArray(parsed.harnesses)) {
         throw configValidationError(fullPath, `"harnesses" must be an array`);
     }
-    const configuredHarnesses = (parsed.harnesses ?? []);
-    const invalidHarnesses = configuredHarnesses.filter((harness) => typeof harness !== "string" || !HARNESS_ID_SET.has(harness));
-    if (invalidHarnesses.length > 0) {
-        const formatted = invalidHarnesses
-            .map((item) => (typeof item === "string" ? item : JSON.stringify(item)))
-            .join(", ");
-        throw configValidationError(fullPath, `unknown harness id(s): ${formatted}`);
-    }
-    const validatedHarnesses = configuredHarnesses;
-    if (hasHarnessesField && validatedHarnesses.length === 0) {
-        throw configValidationError(fullPath, `"harnesses" must include at least one harness`);
-    }
-    const harnesses = hasHarnessesField
-        ? [...new Set(validatedHarnesses)]
-        : DEFAULT_HARNESSES;
-    const vcsRaw = parsed.vcs;
-    if (Object.prototype.hasOwnProperty.call(parsed, "vcs") &&
-        vcsRaw !== "git-with-remote" &&
-        vcsRaw !== "git-local-only" &&
-        vcsRaw !== "none") {
-        throw configValidationError(fullPath, `"vcs" must be one of: git-with-remote, git-local-only, none`);
-    }
-    const vcs = vcsRaw === "git-with-remote" || vcsRaw === "git-local-only" || vcsRaw === "none"
-        ? vcsRaw
-        : "git-local-only";
-    const strictnessRaw = parsed.strictness;
-    if (Object.prototype.hasOwnProperty.call(parsed, "strictness") &&
-        strictnessRaw !== "advisory" &&
-        strictnessRaw !== "strict") {
-        throw configValidationError(fullPath, `"strictness" must be "advisory" or "strict"`);
-    }
-    const strictness = strictnessRaw === "strict" ? "strict" : "advisory";
-    const tddTestGlobsRaw = parsed.tddTestGlobs;
-    const tddTestGlobs = validateStringArray(tddTestGlobsRaw, "tddTestGlobs", fullPath)
-        ?? [...DEFAULT_TDD_TEST_GLOBS];
-    const hasTddField = Object.prototype.hasOwnProperty.call(parsed, "tdd");
-    const tddRaw = parsed.tdd;
-    let explicitTddTestPathPatterns;
-    let explicitTddProductionPathPatterns;
-    let explicitTddVerificationRef;
-    if (hasTddField) {
-        if (!isRecord(tddRaw)) {
-            throw configValidationError(fullPath, `"tdd" must be an object`);
-        }
-        const unknownTddKeys = Object.keys(tddRaw).filter((key) => key !== "testPathPatterns" && key !== "productionPathPatterns" && key !== "verificationRef");
-        if (unknownTddKeys.length > 0) {
-            throw configValidationError(fullPath, `"tdd" has unknown key(s): ${unknownTddKeys.join(", ")}`);
+    const rawHarnesses = Array.isArray(parsed.harnesses) ? parsed.harnesses : DEFAULT_HARNESSES;
+    const normalizedHarnesses = [];
+    for (const harness of rawHarnesses) {
+        if (typeof harness !== "string" || !HARNESS_ID_SET.has(harness)) {
+            throw configValidationError(fullPath, `unknown harness id "${String(harness)}"`);
         }
-        explicitTddTestPathPatterns = validateStringArray(tddRaw.testPathPatterns, "tdd.testPathPatterns", fullPath);
-        explicitTddProductionPathPatterns = validateStringArray(tddRaw.productionPathPatterns, "tdd.productionPathPatterns", fullPath);
-        if (tddRaw.verificationRef !== undefined &&
-            tddRaw.verificationRef !== "auto" &&
-            tddRaw.verificationRef !== "required" &&
-            tddRaw.verificationRef !== "disabled") {
-            throw configValidationError(fullPath, '"tdd.verificationRef" must be one of: auto, required, disabled');
+        if (!normalizedHarnesses.includes(harness)) {
+            normalizedHarnesses.push(harness);
         }
-        explicitTddVerificationRef = tddRaw.verificationRef;
-    }
-    if (tddTestGlobsRaw !== undefined &&
-        explicitTddTestPathPatterns !== undefined &&
-        !sameStringArray(tddTestGlobs, explicitTddTestPathPatterns)) {
-        emitConfigWarningOnce(warningState, "CCLAW_CONFIG_DEPRECATED_TDD_TEST_GLOBS", `[cclaw] Both "tddTestGlobs" (deprecated) and "tdd.testPathPatterns" are set in ${fullPath}. ` +
-            `Using "tdd.testPathPatterns".`);
     }
-    const resolvedTddTestPathPatterns = [
-        ...(explicitTddTestPathPatterns ?? tddTestGlobs ?? DEFAULT_TDD_TEST_PATH_PATTERNS)
-    ];
-    const resolvedTddProductionPathPatterns = [
-        ...(explicitTddProductionPathPatterns ?? DEFAULT_TDD_PRODUCTION_PATH_PATTERNS)
-    ];
-    const hasCompoundField = Object.prototype.hasOwnProperty.call(parsed, "compound");
-    const compoundRaw = parsed.compound;
-    let compoundRecurrenceThreshold = DEFAULT_COMPOUND_RECURRENCE_THRESHOLD;
-    if (hasCompoundField) {
-        if (!isRecord(compoundRaw)) {
-            throw configValidationError(fullPath, `"compound" must be an object`);
-        }
-        const unknownCompoundKeys = Object.keys(compoundRaw).filter((key) => key !== "recurrenceThreshold");
-        if (unknownCompoundKeys.length > 0) {
-            throw configValidationError(fullPath, `"compound" has unknown key(s): ${unknownCompoundKeys.join(", ")}`);
-        }
-        if (compoundRaw.recurrenceThreshold !== undefined &&
-            (typeof compoundRaw.recurrenceThreshold !== "number" ||
-                !Number.isInteger(compoundRaw.recurrenceThreshold) ||
-                compoundRaw.recurrenceThreshold < 1)) {
-            throw configValidationError(fullPath, `"compound.recurrenceThreshold" must be a positive integer`);
-        }
-        if (typeof compoundRaw.recurrenceThreshold === "number") {
-            compoundRecurrenceThreshold = compoundRaw.recurrenceThreshold;
-        }
-    }
-    const hasEarlyLoopField = Object.prototype.hasOwnProperty.call(parsed, "earlyLoop");
-    const hasLegacyEarlyLoopField = Object.prototype.hasOwnProperty.call(parsed, "early_loop");
-    if (hasEarlyLoopField && hasLegacyEarlyLoopField) {
-        emitConfigWarningOnce(warningState, "CCLAW_CONFIG_EARLY_LOOP_ALIAS", `[cclaw] Both "earlyLoop" and legacy "early_loop" are set in ${fullPath}. Using "earlyLoop".`);
-    }
-    const earlyLoopRaw = hasEarlyLoopField
-        ? parsed.earlyLoop
-        : parsed.early_loop;
-    let earlyLoopEnabled = true;
-    let earlyLoopMaxIterations = DEFAULT_EARLY_LOOP_MAX_ITERATIONS;
-    if (hasEarlyLoopField || hasLegacyEarlyLoopField) {
-        if (!isRecord(earlyLoopRaw)) {
-            throw configValidationError(fullPath, `"${hasEarlyLoopField ? "earlyLoop" : "early_loop"}" must be an object`);
-        }
-        const unknownEarlyLoopKeys = Object.keys(earlyLoopRaw).filter((key) => key !== "enabled" && key !== "maxIterations" && key !== "max_iterations");
-        if (unknownEarlyLoopKeys.length > 0) {
-            throw configValidationError(fullPath, `"${hasEarlyLoopField ? "earlyLoop" : "early_loop"}" has unknown key(s): ${unknownEarlyLoopKeys.join(", ")}`);
-        }
-        if (earlyLoopRaw.enabled !== undefined && typeof earlyLoopRaw.enabled !== "boolean") {
-            throw configValidationError(fullPath, `"${hasEarlyLoopField ? "earlyLoop" : "early_loop"}.enabled" must be a boolean`);
-        }
-        if (earlyLoopRaw.maxIterations !== undefined &&
-            earlyLoopRaw.max_iterations !== undefined &&
-            earlyLoopRaw.maxIterations !== earlyLoopRaw.max_iterations) {
-            emitConfigWarningOnce(warningState, "CCLAW_CONFIG_EARLY_LOOP_MAX_ITERATIONS_ALIAS", `[cclaw] Both "${hasEarlyLoopField ? "earlyLoop.maxIterations" : "early_loop.maxIterations"}" and "${hasEarlyLoopField ? "earlyLoop.max_iterations" : "early_loop.max_iterations"}" are set in ${fullPath}. Using "maxIterations".`);
-        }
-        const rawMaxIterations = earlyLoopRaw.maxIterations ?? earlyLoopRaw.max_iterations;
-        if (rawMaxIterations !== undefined &&
-            (typeof rawMaxIterations !== "number" ||
-                !Number.isInteger(rawMaxIterations) ||
-                rawMaxIterations < 1)) {
-            throw configValidationError(fullPath, `"${hasEarlyLoopField ? "earlyLoop" : "early_loop"}.maxIterations" must be a positive integer`);
-        }
-        if (typeof earlyLoopRaw.enabled === "boolean") {
-            earlyLoopEnabled = earlyLoopRaw.enabled;
-        }
-        if (typeof rawMaxIterations === "number") {
-            earlyLoopMaxIterations = rawMaxIterations;
-        }
-    }
-    const gitHookGuardsRaw = parsed.gitHookGuards;
-    if (Object.prototype.hasOwnProperty.call(parsed, "gitHookGuards") &&
-        typeof gitHookGuardsRaw !== "boolean") {
-        throw configValidationError(fullPath, `"gitHookGuards" must be a boolean`);
-    }
-    const gitHookGuards = typeof gitHookGuardsRaw === "boolean" ? gitHookGuardsRaw : false;
-    const defaultTrackRaw = parsed.defaultTrack;
-    if (Object.prototype.hasOwnProperty.call(parsed, "defaultTrack") &&
-        (typeof defaultTrackRaw !== "string" || !FLOW_TRACK_SET.has(defaultTrackRaw))) {
-        throw configValidationError(fullPath, `"defaultTrack" must be one of: ${SUPPORTED_TRACKS_TEXT}`);
-    }
-    const defaultTrack = typeof defaultTrackRaw === "string" && FLOW_TRACK_SET.has(defaultTrackRaw)
-        ? defaultTrackRaw
-        : "standard";
-    const languageRulePacksRaw = parsed.languageRulePacks;
-    const hasLanguageRulePacksField = Object.prototype.hasOwnProperty.call(parsed, "languageRulePacks");
-    if (hasLanguageRulePacksField && !Array.isArray(languageRulePacksRaw)) {
-        throw configValidationError(fullPath, `"languageRulePacks" must be an array`);
-    }
-    const rawPacks = (languageRulePacksRaw ?? []);
-    const invalidPacks = rawPacks.filter((pack) => typeof pack !== "string" || !LANGUAGE_RULE_PACK_SET.has(pack));
-    if (invalidPacks.length > 0) {
-        const formatted = invalidPacks
-            .map((item) => (typeof item === "string" ? item : JSON.stringify(item)))
-            .join(", ");
-        throw configValidationError(fullPath, `unknown languageRulePacks id(s): ${formatted}`);
-    }
-    const languageRulePacks = [...new Set(rawPacks)];
-    const trackHeuristicsRaw = parsed.trackHeuristics;
-    let trackHeuristics = undefined;
-    if (Object.prototype.hasOwnProperty.call(parsed, "trackHeuristics")) {
-        if (!isRecord(trackHeuristicsRaw)) {
-            throw configValidationError(fullPath, `"trackHeuristics" must be an object`);
-        }
-        const fallbackRaw = trackHeuristicsRaw.fallback;
-        if (fallbackRaw !== undefined && (typeof fallbackRaw !== "string" || !FLOW_TRACK_SET.has(fallbackRaw))) {
-            throw configValidationError(fullPath, `"trackHeuristics.fallback" must be one of: ${SUPPORTED_TRACKS_TEXT}`);
-        }
-        if (Object.prototype.hasOwnProperty.call(trackHeuristicsRaw, "priority")) {
-            throw configValidationError(fullPath, `"trackHeuristics.priority" is no longer supported (removed in v0.38.0). Track evaluation order is always standard -> medium -> quick. Remove the field to upgrade.`);
-        }
-        const tracksRaw = trackHeuristicsRaw.tracks;
-        let tracks = undefined;
-        if (tracksRaw !== undefined) {
-            if (!isRecord(tracksRaw)) {
-                throw configValidationError(fullPath, `"trackHeuristics.tracks" must be an object`);
-            }
-            tracks = {};
-            for (const [trackName, ruleRaw] of Object.entries(tracksRaw)) {
-                if (!FLOW_TRACK_SET.has(trackName)) {
-                    throw configValidationError(fullPath, `"trackHeuristics.tracks" contains unknown track "${trackName}". Supported: ${SUPPORTED_TRACKS_TEXT}`);
-                }
-                if (!isRecord(ruleRaw)) {
-                    throw configValidationError(fullPath, `"trackHeuristics.tracks.${trackName}" must be an object`);
-                }
-                if (Object.prototype.hasOwnProperty.call(ruleRaw, "patterns")) {
-                    throw configValidationError(fullPath, `"trackHeuristics.tracks.${trackName}.patterns" is no longer supported (removed in v0.38.0). Regex patterns were never wired into runtime routing. Move the intent into "triggers" (substrings) or "veto".`);
-                }
-                const triggers = validateStringArray(ruleRaw.triggers, `trackHeuristics.tracks.${trackName}.triggers`, fullPath);
-                const veto = validateStringArray(ruleRaw.veto, `trackHeuristics.tracks.${trackName}.veto`, fullPath);
-                tracks[trackName] = {
-                    triggers,
-                    veto
-                };
-            }
-        }
-        trackHeuristics = {
-            fallback: fallbackRaw,
-            tracks
-        };
-    }
-    const sliceReviewRaw = parsed.sliceReview;
-    let sliceReview = undefined;
-    if (Object.prototype.hasOwnProperty.call(parsed, "sliceReview")) {
-        if (!isRecord(sliceReviewRaw)) {
-            throw configValidationError(fullPath, `"sliceReview" must be an object`);
-        }
-        const enabledRaw = sliceReviewRaw.enabled;
-        if (enabledRaw !== undefined && typeof enabledRaw !== "boolean") {
-            throw configValidationError(fullPath, `"sliceReview.enabled" must be a boolean`);
-        }
-        const thresholdRaw = sliceReviewRaw.filesChangedThreshold;
-        if (thresholdRaw !== undefined &&
-            (typeof thresholdRaw !== "number" || !Number.isInteger(thresholdRaw) || thresholdRaw < 1)) {
-            throw configValidationError(fullPath, `"sliceReview.filesChangedThreshold" must be a positive integer`);
-        }
-        const touchTriggers = validateStringArray(sliceReviewRaw.touchTriggers, "sliceReview.touchTriggers", fullPath);
-        const enforceRaw = sliceReviewRaw.enforceOnTracks;
-        let enforceOnTracks;
-        if (enforceRaw !== undefined) {
-            if (!Array.isArray(enforceRaw)) {
-                throw configValidationError(fullPath, `"sliceReview.enforceOnTracks" must be an array`);
-            }
-            const invalidTracks = enforceRaw.filter((value) => typeof value !== "string" || !FLOW_TRACK_SET.has(value));
-            if (invalidTracks.length > 0) {
-                throw configValidationError(fullPath, `"sliceReview.enforceOnTracks" must contain only: ${SUPPORTED_TRACKS_TEXT}`);
-            }
-            enforceOnTracks = [...new Set(enforceRaw)];
-        }
-        sliceReview = {
-            enabled: typeof enabledRaw === "boolean" ? enabledRaw : false,
-            filesChangedThreshold: typeof thresholdRaw === "number" ? thresholdRaw : DEFAULT_SLICE_REVIEW_THRESHOLD,
-            touchTriggers: touchTriggers ?? [],
-            enforceOnTracks: enforceOnTracks ?? DEFAULT_SLICE_REVIEW_TRACKS
-        };
-    }
-    const ironLawsRaw = parsed.ironLaws;
-    let ironLaws = undefined;
-    if (Object.prototype.hasOwnProperty.call(parsed, "ironLaws")) {
-        if (!isRecord(ironLawsRaw)) {
-            throw configValidationError(fullPath, `"ironLaws" must be an object`);
-        }
-        if (Object.prototype.hasOwnProperty.call(ironLawsRaw, "mode")) {
-            throw configValidationError(fullPath, `"ironLaws.mode" was removed; the project-wide \`strictness\` knob now ` +
-                `controls iron-law enforcement. Use \`ironLaws.strictLaws\` for per-law overrides.`);
-        }
-        const unknownIronLawKeys = Object.keys(ironLawsRaw).filter((key) => key !== "strictLaws");
-        if (unknownIronLawKeys.length > 0) {
-            throw configValidationError(fullPath, `"ironLaws" has unknown key(s): ${unknownIronLawKeys.join(", ")}`);
-        }
-        const strictLawIdsRaw = validateStringArray(ironLawsRaw.strictLaws, "ironLaws.strictLaws", fullPath) ?? [];
-        const unknownStrictLawIds = strictLawIdsRaw.filter((id) => !isIronLawId(id));
-        if (unknownStrictLawIds.length > 0) {
-            throw configValidationError(fullPath, `"ironLaws.strictLaws" contains unknown law id(s): ${unknownStrictLawIds.join(", ")}`);
-        }
-        ironLaws = {
-            strictLaws: normalizeStrictLawIds(strictLawIdsRaw)
-        };
-    }
-    else {
-        ironLaws = { strictLaws: [] };
-    }
-    const optInAuditsRaw = parsed.optInAudits;
-    let optInAudits = undefined;
-    if (Object.prototype.hasOwnProperty.call(parsed, "optInAudits")) {
-        if (!isRecord(optInAuditsRaw)) {
-            throw configValidationError(fullPath, `"optInAudits" must be an object`);
-        }
-        const unknownOptInAuditKeys = Object.keys(optInAuditsRaw).filter((key) => key !== "scopePreAudit" && key !== "staleDiagramAudit");
-        if (unknownOptInAuditKeys.length > 0) {
-            throw configValidationError(fullPath, `"optInAudits" has unknown key(s): ${unknownOptInAuditKeys.join(", ")}`);
-        }
-        if (optInAuditsRaw.scopePreAudit !== undefined &&
-            typeof optInAuditsRaw.scopePreAudit !== "boolean") {
-            throw configValidationError(fullPath, `"optInAudits.scopePreAudit" must be a boolean`);
-        }
-        if (optInAuditsRaw.staleDiagramAudit !== undefined &&
-            typeof optInAuditsRaw.staleDiagramAudit !== "boolean") {
-            throw configValidationError(fullPath, `"optInAudits.staleDiagramAudit" must be a boolean`);
-        }
-        optInAudits = {
-            scopePreAudit: typeof optInAuditsRaw.scopePreAudit === "boolean"
-                ? optInAuditsRaw.scopePreAudit
-                : false,
-            staleDiagramAudit: typeof optInAuditsRaw.staleDiagramAudit === "boolean"
-                ? optInAuditsRaw.staleDiagramAudit
-                : true
-        };
-    }
-    if (!optInAudits) {
-        optInAudits = {
-            scopePreAudit: false,
-            staleDiagramAudit: true
-        };
-    }
-    const reviewLoopRaw = parsed.reviewLoop;
-    let reviewLoop = undefined;
-    if (Object.prototype.hasOwnProperty.call(parsed, "reviewLoop")) {
-        if (!isRecord(reviewLoopRaw)) {
-            throw configValidationError(fullPath, `"reviewLoop" must be an object`);
-        }
-        const unknownReviewLoopKeys = Object.keys(reviewLoopRaw).filter((key) => key !== "externalSecondOpinion");
-        if (unknownReviewLoopKeys.length > 0) {
-            throw configValidationError(fullPath, `"reviewLoop" has unknown key(s): ${unknownReviewLoopKeys.join(", ")}`);
-        }
-        const externalRaw = reviewLoopRaw.externalSecondOpinion;
-        let externalSecondOpinion = undefined;
-        if (externalRaw !== undefined) {
-            if (!isRecord(externalRaw)) {
-                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion" must be an object`);
-            }
-            const unknownExternalKeys = Object.keys(externalRaw).filter((key) => key !== "enabled" && key !== "model" && key !== "scoreDeltaThreshold");
-            if (unknownExternalKeys.length > 0) {
-                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion" has unknown key(s): ${unknownExternalKeys.join(", ")}`);
-            }
-            if (externalRaw.enabled !== undefined && typeof externalRaw.enabled !== "boolean") {
-                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion.enabled" must be a boolean`);
-            }
-            if (externalRaw.model !== undefined && typeof externalRaw.model !== "string") {
-                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion.model" must be a string`);
-            }
-            if (externalRaw.scoreDeltaThreshold !== undefined &&
-                (typeof externalRaw.scoreDeltaThreshold !== "number" ||
-                    Number.isNaN(externalRaw.scoreDeltaThreshold) ||
-                    externalRaw.scoreDeltaThreshold < 0 ||
-                    externalRaw.scoreDeltaThreshold > 1)) {
-                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion.scoreDeltaThreshold" must be a number between 0 and 1`);
-            }
-            externalSecondOpinion = {
-                enabled: externalRaw.enabled === true,
-                model: typeof externalRaw.model === "string" ? externalRaw.model : undefined,
-                scoreDeltaThreshold: typeof externalRaw.scoreDeltaThreshold === "number"
-                    ? externalRaw.scoreDeltaThreshold
-                    : 0.2
-            };
-        }
-        reviewLoop = { externalSecondOpinion };
+    if (normalizedHarnesses.length === 0) {
+        throw configValidationError(fullPath, `"harnesses" must include at least one harness`);
     }
+    const version = typeof parsed.version === "string" && parsed.version.trim().length > 0
+        ? parsed.version
+        : CCLAW_VERSION;
+    const flowVersion = typeof parsed.flowVersion === "string" && parsed.flowVersion.trim().length > 0
+        ? parsed.flowVersion
+        : FLOW_VERSION;
     return {
-        version: parsed.version ?? CCLAW_VERSION,
-        flowVersion: parsed.flowVersion ?? FLOW_VERSION,
-        harnesses,
-        vcs,
-        strictness,
-        tddTestGlobs,
-        tdd: {
-            testPathPatterns: resolvedTddTestPathPatterns,
-            productionPathPatterns: resolvedTddProductionPathPatterns,
-            verificationRef: explicitTddVerificationRef ?? "auto"
-        },
-        compound: {
-            recurrenceThreshold: compoundRecurrenceThreshold
-        },
-        earlyLoop: {
-            enabled: earlyLoopEnabled,
-            maxIterations: earlyLoopMaxIterations
-        },
-        gitHookGuards,
-        defaultTrack,
-        languageRulePacks,
-        trackHeuristics,
-        sliceReview,
-        ironLaws,
-        optInAudits,
-        reviewLoop
+        version,
+        flowVersion,
+        harnesses: normalizedHarnesses
     };
 }
-function isMinimalKey(key) {
-    return MINIMAL_CONFIG_KEYS.includes(key);
-}
-function buildSerializableConfig(config, options = {}) {
-    const mode = options.mode ?? "full";
-    const advanced = options.advancedKeysPresent;
-    const output = {};
-    const ordered = [
-        "version",
-        "flowVersion",
-        "harnesses",
-        "vcs",
-        "strictness",
-        "tddTestGlobs",
-        "tdd",
-        "compound",
-        "earlyLoop",
-        "gitHookGuards",
-        "defaultTrack",
-        "languageRulePacks",
-        "trackHeuristics",
-        "sliceReview",
-        "ironLaws",
-        "optInAudits",
-        "reviewLoop"
-    ];
-    for (const key of ordered) {
-        const value = config[key];
-        if (value === undefined)
-            continue;
-        if (mode === "full") {
-            output[key] = value;
-            continue;
-        }
-        // Minimal mode: always include the short list; advanced keys only when
-        // the caller explicitly opted in, or for auto-detected non-empty
-        // `languageRulePacks`.
-        if (isMinimalKey(key)) {
-            output[key] = value;
-            continue;
-        }
-        if (advanced?.has(key)) {
-            output[key] = value;
-            continue;
-        }
-        if (key === "languageRulePacks" && Array.isArray(value) && value.length > 0) {
-            output[key] = value;
-        }
-    }
-    return output;
-}
-export async function writeConfig(projectRoot, config, options = {}) {
-    const serialisable = buildSerializableConfig(config, options);
+export async function writeConfig(projectRoot, config, _options = {}) {
+    const serialisable = {
+        version: config.version,
+        flowVersion: config.flowVersion,
+        harnesses: config.harnesses
+    };
     await writeFileSafe(configPath(projectRoot), stringify(serialisable));
 }
-/**
- * Enumerate which advanced keys are currently set in the on-disk config.
- * Used by `cclaw upgrade` to preserve the user's existing shape — if they
- * wrote `tddTestGlobs` by hand, the upgrade keeps it; if they didn't, the
- * upgrade stays minimal.
- */
-export async function detectAdvancedKeys(projectRoot) {
-    const fullPath = configPath(projectRoot);
-    if (!(await exists(fullPath)))
-        return new Set();
-    try {
-        const parsedUnknown = parse(await fs.readFile(fullPath, "utf8"));
-        if (!isRecord(parsedUnknown))
-            return new Set();
-        const advancedCandidates = [
-            "tddTestGlobs",
-            "tdd",
-            "compound",
-            "earlyLoop",
-            "defaultTrack",
-            "languageRulePacks",
-            "trackHeuristics",
-            "sliceReview",
-            "ironLaws",
-            "optInAudits",
-            "reviewLoop"
-        ];
-        const present = new Set();
-        for (const key of advancedCandidates) {
-            if (Object.prototype.hasOwnProperty.call(parsedUnknown, key) ||
-                (key === "earlyLoop" && Object.prototype.hasOwnProperty.call(parsedUnknown, "early_loop"))) {
-                present.add(key);
-            }
-        }
-        return present;
-    }
-    catch {
-        return new Set();
-    }
+export async function detectAdvancedKeys(_projectRoot) {
+    return new Set();
 }