akm-cli 0.9.17-alpha.2 → 0.9.17-alpha.4

package/dist/core/config/config.js

@@ -5,18 +5,18 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import { isBundleSlug } from "../asset/asset-ref.js";
-import { isRecord } from "../common.js";
+import { isBundleSlug, parseBundleRef } from "../asset/asset-ref.js";
+import { deriveBundleId } from "../bundle-id.js";
+import { isRecord, resolveStashDir } from "../common.js";
 import { ConfigError } from "../errors.js";
 import { liftLegacyEngineExtraParams } from "../extra-params.js";
 import { formatRegistryLabel, hasRegistryUrlCredentials } from "../registry-url.js";
 import { acquireConfigLock, backupExistingConfig, parseConfigText, readConfigText, withConfigLock, writeConfigAtomic, } from "./config-io.js";
-import { AkmConfigSchema, CURRENT_CONFIG_VERSION, listTopLevelConfigKeys } from "./config-schema.js";
-import { bundleComponentConfig, bundleContentRoot, bundleContentRoots, bundlesToSourceEntries } from "./config-sources.js";
-import { upgradeConfigVersion } from "./config-version-shim.js";
+import { AkmConfigSchema, CURRENT_CONFIG_VERSION } from "./config-schema.js";
+import { bundleComponentConfig, bundleContentRoot, bundleContentRoots, bundleSourceId, bundlesToSourceEntries, filesystemBundleSourceId, isBundleEnabled, } from "./config-sources.js";
+import { resolveSchemaAt } from "./config-walker.js";
 import { deepMergeConfig, isPlainObject } from "./deep-merge.js";
 import { migrateLegacySourceShape } from "./legacy-source-shape-shim.js";
-import { stripRetiredExperimentalKeys } from "./retired-experimental-keys-shim.js";
 import { isApiKeyReference, SECRET_STORE_REFERENCE_PATTERN } from "./schema/primitives.js";
 export { stripJsonComments } from "./config-io.js";
 import { getConfigPath } from "../paths.js";
@@ -125,40 +125,38 @@ export function loadUserConfig() {
     };
     return finalConfig;
 }
-/**
- * Acquire the existing config-write sentinel and read a fresh validated
- * generation while keeping the sentinel held. Source update uses this to
- * fence an audited bundle descriptor through publication: a cooperating
- * config writer can commit either before this snapshot or after the update,
- * never between the final generation check and index commit.
- */
-export function acquireConfigReadFence() {
-    const release = acquireConfigLock();
-    try {
-        cachedConfig = undefined;
-        return { config: loadUserConfig(), release };
-    }
-    catch (error) {
-        release();
-        throw error;
-    }
-}
 /**
  * Run the per-file config pipeline every raw config object goes through
  * before it is either validated (the local/top-level file) or merged in as
- * an `extends` base: JSONC parse already done by the caller, then version
- * shim, then legacy `stashDir`/`sources[]`/`installed[]` shim, then the
- * legacy `extraParams` lift (#852), then the retired `experimental.*` key
- * shim. Shared by {@link parseAndValidateConfigText}
- * (the local file) and {@link resolveExtendsChain} (each base in the chain) so
- * a fleet-shared base config can carry its own old `configVersion` / legacy
- * shape independently of the file that extends it.
+ * an `extends` base: JSONC parse already done by the caller, then the
+ * `configVersion` read ({@link readConfigVersion}), then the legacy
+ * `stashDir`/`sources[]`/`installed[]` shim, then the legacy `extraParams`
+ * lift (#852). Unknown keys are not an error: the schema drops them in
+ * memory. Shared by {@link parseAndValidateConfigText} (the local file) and
+ * {@link resolveExtendsChain} (each base in the chain) so a fleet-shared base
+ * config can carry its own `configVersion` / legacy shape independently of
+ * the file that extends it.
  */
 function runConfigFilePipeline(text, sourcePath) {
-    const versioned = upgradeConfigVersion(parseConfigText(text, sourcePath), sourcePath);
+    const versioned = readConfigVersion(parseConfigText(text, sourcePath), sourcePath);
     const parsedRaw = migrateLegacySourceShape(versioned, sourcePath);
-    const liftedRaw = liftExtraParamsOrThrow(parsedRaw, sourcePath);
-    return stripRetiredExperimentalKeys(liftedRaw, sourcePath);
+    return liftExtraParamsOrThrow(parsedRaw, sourcePath);
+}
+/**
+ * `configVersion` is read, never gated on. `"0.9.0"` is the only value akm
+ * has ever shipped, and a document without the field is that same document.
+ * Any other value is named once and the file is read as the current shape
+ * anyway; every ordinary config write and `akm migrate apply`'s `configFile`
+ * step then persist `"0.9.0"`.
+ */
+function readConfigVersion(raw, sourcePath) {
+    const version = raw.configVersion;
+    if (version === CURRENT_CONFIG_VERSION)
+        return raw;
+    if (version !== undefined) {
+        warnOnce(`config:config-version${sourcePath ? `:${sourcePath}` : ""}`, `${sourcePath ?? "config.json"} declares configVersion ${JSON.stringify(version)}; this release reads it as ${CURRENT_CONFIG_VERSION}.`);
+    }
+    return { ...raw, configVersion: CURRENT_CONFIG_VERSION };
 }
 /**
  * #852 (following #815): a config still using legacy `extraParams` keys —
@@ -195,49 +193,62 @@ function liftExtraParamsOrThrow(parsedRaw, sourcePath) {
  * keeps around, instead of only getting the final merged `AkmConfig` back.
  */
 function buildEffectiveConfig(liftedLocalRaw, sourcePath) {
-    warnUnknownTopLevelConfigKeys(liftedLocalRaw, sourcePath);
     const withExtends = resolveExtendsChain(liftedLocalRaw, sourcePath);
     const where = sourcePath ? ` at ${sourcePath}` : "";
+    warnUnknownConfigKeys(liftedLocalRaw, sourcePath);
     const parsed = AkmConfigSchema.safeParse(withExtends);
     if (!parsed.success) {
         const lines = parsed.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
-        const needsSchedulerMigration = parsed.error.issues.some((issue) => issue.path[0] === "scheduler" && issue.path.at(-1) === "sourceId");
-        throw new ConfigError(`Invalid config${where}:\n${lines}`, "INVALID_CONFIG_FILE", needsSchedulerMigration
-            ? "Run `akm migrate apply` to bind existing scheduler grants to their source."
-            : undefined);
+        throw new ConfigError(`Invalid config${where}:\n${lines}`, "INVALID_CONFIG_FILE");
     }
     const merged = deepMergeConfig(DEFAULT_CONFIG, parsed.data);
     const finalResult = AkmConfigSchema.safeParse(merged);
     if (!finalResult.success) {
         const lines = finalResult.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
-        const needsSchedulerMigration = finalResult.error.issues.some((issue) => issue.path[0] === "scheduler" && issue.path.at(-1) === "sourceId");
-        throw new ConfigError(`Invalid merged config${sourcePath ? ` at ${sourcePath}` : ""}:\n${lines}`, "INVALID_CONFIG_FILE", needsSchedulerMigration
-            ? "Run `akm migrate apply` to bind existing scheduler grants to their source."
-            : undefined);
+        throw new ConfigError(`Invalid merged config${sourcePath ? ` at ${sourcePath}` : ""}:\n${lines}`, "INVALID_CONFIG_FILE");
     }
     assertUniquePhysicalBundleRoots(finalResult.data, sourcePath);
     return finalResult.data;
 }
-const RETIRED_TOP_LEVEL_CONFIG_KEYS = new Set([
-    "agent",
-    "bindings",
-    "features",
-    "installed",
-    "llm",
-    "modelAliases",
-    "profiles",
-    "sources",
-    "stashDir",
-    "stashes",
-    "writable",
-]);
-function warnUnknownTopLevelConfigKeys(raw, sourcePath) {
-    const known = new Set(listTopLevelConfigKeys());
-    for (const key of Object.keys(raw).sort()) {
-        if (known.has(key) || RETIRED_TOP_LEVEL_CONFIG_KEYS.has(key))
+/**
+ * Every dotted key in `raw` the schema does not know, at any depth (arrays
+ * are not descended). Unknown keys are never an error: they are a typo, or a
+ * key another release used. Reads keep them (they round-trip through
+ * ordinary writes, so a newer release's settings survive a downgrade);
+ * `akm migrate apply` drops them.
+ */
+export function unknownConfigKeyPaths(root, node = root, prefix = []) {
+    const found = [];
+    for (const key of Object.keys(node).sort()) {
+        const keyPath = [...prefix, key];
+        if (resolveSchemaAt(keyPath, root) === undefined) {
+            found.push(keyPath);
             continue;
-        warnOnce(`config:unknown-key:${sourcePath ?? "inline"}:${key}`, `Unknown config key ${JSON.stringify(key)}${sourcePath ? ` at ${sourcePath}` : ""} has no defined akm behavior. Check the spelling or remove it.`);
+        }
+        const value = node[key];
+        if (isPlainConfigObject(value))
+            found.push(...unknownConfigKeyPaths(root, value, keyPath));
+    }
+    return found;
+}
+function warnUnknownConfigKeys(raw, sourcePath) {
+    for (const keyPath of unknownConfigKeyPaths(raw)) {
+        const dotted = keyPath.join(".");
+        warnOnce(`config:unknown-key:${sourcePath ?? "inline"}:${dotted}`, `Unknown config key ${JSON.stringify(dotted)}${sourcePath ? ` at ${sourcePath}` : ""} has no defined akm behavior and is ignored. Check the spelling; a key retired by this release or added by a newer one is dropped by \`akm migrate apply\`.`);
+    }
+}
+function deleteConfigPath(node, keyPath) {
+    let cursor = node;
+    for (const segment of keyPath.slice(0, -1)) {
+        if (!isPlainConfigObject(cursor))
+            return;
+        cursor = cursor[segment];
     }
+    if (isPlainConfigObject(cursor))
+        delete cursor[keyPath[keyPath.length - 1]];
+}
+function isPlainConfigObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function assertUniquePhysicalBundleRoots(config, sourcePath) {
     const owners = new Map();
@@ -253,11 +264,10 @@ function assertUniquePhysicalBundleRoots(config, sourcePath) {
  * Parse raw config text and validate via Zod.
  * ({@link AkmConfigSchema}). Returns the merged-with-defaults AkmConfig.
  *
- * The schema accepts only the current config version. A known older version
- * is auto-upgraded in memory first (see `./config-version-shim`); anything
- * else — including anything newer — is rejected before the canonical shape
- * is validated. When the config sets `extends` (#945), its resolved chain is
- * deep-merged underneath before validation — see {@link resolveExtendsChain}.
+ * `configVersion` is read as the current version whatever it says (see
+ * {@link readConfigVersion}). When the config sets `extends` (#945), its
+ * resolved chain is deep-merged underneath before validation — see
+ * {@link resolveExtendsChain}.
  */
 export function parseAndValidateConfigText(text, sourcePath) {
     const liftedConfig = runConfigFilePipeline(text, sourcePath);
@@ -290,7 +300,7 @@ function collectExtendsLayers(localRaw, configPath) {
         }
         visited.add(resolvedPath);
         const baseRaw = runConfigFilePipeline(text, resolvedPath);
-        warnUnknownTopLevelConfigKeys(baseRaw, resolvedPath);
+        warnUnknownConfigKeys(baseRaw, resolvedPath);
         layers.push({ ref, raw: baseRaw });
         current = baseRaw;
         currentPath = resolvedPath;
@@ -666,6 +676,36 @@ function configWriteBody(localRaw, current, next, persistTopLevelKeys = []) {
     }
     return ordered;
 }
+/**
+ * The migrator's one config step. The reader already tolerates every shape
+ * akm has written (`configVersion` read as current, legacy source layout,
+ * `extraParams` lift, unknown keys dropped); this writes that current shape back to
+ * `config.json` — the same body `mutateConfig` writes — so the tolerance
+ * becomes durable. Reports without writing unless `apply` is set.
+ */
+export function normalizeConfigFile(configPath, options) {
+    return withConfigLock(() => {
+        const text = readConfigText(configPath);
+        if (text === undefined)
+            return { keys: [], changed: false, applied: false };
+        const raw = parseConfigText(text, configPath);
+        const localRaw = runConfigFilePipeline(text, configPath);
+        const current = buildEffectiveConfig(localRaw, configPath);
+        const next = validateCompleteConfig({ ...current, configVersion: CURRENT_CONFIG_VERSION });
+        const body = withSchedulerOnDisk(configWriteBody(localRaw, current, next), next);
+        for (const keyPath of unknownConfigKeyPaths(body))
+            deleteConfigPath(body, keyPath);
+        const keys = [...new Set([...Object.keys(raw), ...Object.keys(body)])]
+            .filter((key) => JSON.stringify(raw[key]) !== JSON.stringify(body[key]))
+            .sort();
+        if (keys.length === 0 || !options.apply)
+            return { keys, changed: keys.length > 0, applied: false };
+        const backup = backupExistingConfig(configPath);
+        writeConfigAtomic(configPath, body);
+        cachedConfig = undefined;
+        return { keys, changed: true, applied: true, ...(backup ? { backupPath: backup.timestamped } : {}) };
+    });
+}
 /**
  * Mutate config under one fail-closed lock spanning read, merge, validation,
  * ordinary backup, and atomic write.
@@ -719,6 +759,61 @@ export async function mutateConfigWithPrecommit(mutate, precommit, options) {
         release();
     }
 }
+const UNBOUND_SCHEDULER_SOURCE_ID = `sha256:${"0".repeat(64)}`;
+/**
+ * The source identity 0.9.16 bound a scheduler grant to: the configured
+ * bundle's source id, or the implicit `AKM_BUNDLE_DIR` stash's. `undefined`
+ * when the bundle is not active on this host.
+ */
+export function schedulerSourceIdFor(config, bundleId) {
+    if (isBundleEnabled(config, bundleId))
+        return bundleSourceId(config, bundleId);
+    if (config.bundles?.[bundleId] !== undefined || !process.env.AKM_BUNDLE_DIR?.trim())
+        return undefined;
+    try {
+        const root = resolveStashDir();
+        const implicitId = deriveBundleId(undefined, root, new Set(Object.keys(config.bundles ?? {})));
+        return implicitId === bundleId ? filesystemBundleSourceId(root) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * `scheduler.enabled` is a list of refs in memory but is written in the
+ * `{kind, ref, sourceId}` shape 0.9.16 reads, so that release still runs
+ * against a config this one wrote (the upgrade rehearsal's read-back). This
+ * release reads either shape; the object form can go once no supported
+ * release is strict about it.
+ */
+function schedulerEnabledOnDisk(config) {
+    const enabled = config.scheduler?.enabled;
+    if (enabled === undefined)
+        return undefined;
+    return enabled.map((ref) => {
+        let bundle;
+        let conceptId = "";
+        try {
+            const parsed = parseBundleRef(ref);
+            bundle = parsed.bundle;
+            conceptId = parsed.conceptId;
+        }
+        catch {
+            return ref;
+        }
+        return {
+            kind: conceptId.startsWith("workflows/") ? "workflow" : "task",
+            ref,
+            sourceId: (bundle !== undefined ? schedulerSourceIdFor(config, bundle) : undefined) ?? UNBOUND_SCHEDULER_SOURCE_ID,
+        };
+    });
+}
+function withSchedulerOnDisk(body, config) {
+    const onDisk = schedulerEnabledOnDisk(config);
+    if (onDisk === undefined || !isPlainConfigObject(body.scheduler))
+        return body;
+    return { ...body, scheduler: { ...body.scheduler, enabled: onDisk } };
+}
 /**
  * Strip literal apiKey fields before writing config to disk.
  * API keys are expected to come from environment variables
@@ -783,7 +878,7 @@ export function sanitizeConfigForWrite(config) {
             warn(`Config sanitizer dropped registry entr${droppedRegistries.length === 1 ? "y" : "ies"} with URL credentials before writing to disk:\n  - ${droppedRegistries.join("\n  - ")}\n\nRegistry URLs must be credential-free; configure a credential-free HTTPS endpoint.`);
         }
     }
-    return sanitized;
+    return withSchedulerOnDisk(sanitized, config);
 }
 export function updateConfig(partial) {
     return mutateConfig((current) => deepMergeConfig(current, partial)).config;

package/dist/core/config/legacy-source-shape-shim.js

@@ -55,20 +55,29 @@ function filesystemLocator(bundle) {
         return undefined;
     return path.resolve(bundle.path);
 }
-export function migrateLegacySourceShape(raw, sourcePath) {
-    const hasStashDir = typeof raw.stashDir === "string" && raw.stashDir.trim().length > 0;
-    const hasSources = Array.isArray(raw.sources) && raw.sources.length > 0;
+/**
+ * Pure legacy `stashDir`/`sources[]`/`installed` -> `bundles`/`defaultBundle`
+ * conversion. Triggers on key *presence* (not on the value being usable), so
+ * an unusable value — `stashDir: ""`, `sources: []` — is still removed along
+ * with the rest of the legacy shape; only a usable `stashDir` or `sources[]`
+ * entry is actually folded into `bundles`. Never warns — see
+ * {@link migrateLegacySourceShape} for the warn-once wrapper callers use.
+ */
+export function convertLegacySourceShape(raw) {
+    const hasStashDir = "stashDir" in raw;
+    const hasSources = "sources" in raw;
     const hasInstalled = "installed" in raw && raw.installed !== undefined;
     if (!hasStashDir && !hasSources && !hasInstalled)
-        return raw;
+        return { config: raw, converted: [] };
     const { stashDir: _stashDir, sources: _sources, installed: _installed, ...rest } = raw;
     const bundles = isPlainRecord(rest.bundles) ? { ...rest.bundles } : {};
     let defaultBundle = typeof rest.defaultBundle === "string" ? rest.defaultBundle : undefined;
-    if (hasStashDir) {
+    const usableStashDir = typeof raw.stashDir === "string" && raw.stashDir.trim().length > 0;
+    if (usableStashDir) {
         bundles.stash = { path: raw.stashDir, writable: true };
         defaultBundle ??= "stash";
     }
-    if (hasSources) {
+    if (Array.isArray(raw.sources)) {
         raw.sources.forEach((entry, index) => {
             const converted = bundleFromLegacySource(entry, index);
             if (!converted)
@@ -81,8 +90,28 @@ export function migrateLegacySourceShape(raw, sourcePath) {
             defaultBundle ??= key;
         });
     }
-    const droppedKeys = [hasStashDir && "stashDir", hasSources && "sources", hasInstalled && "installed"].filter(Boolean);
+    const converted = [hasStashDir && "stashDir", hasSources && "sources", hasInstalled && "installed"].filter((key) => typeof key === "string");
+    // Only add a `bundles` key when there is something to say: either a
+    // legacy entry actually converted into one, or the config already had a
+    // `bundles` map (preserved as-is). An unusable `stashDir: ""` / `sources: []`
+    // with no pre-existing `bundles` should just disappear, not leave behind
+    // an empty `bundles: {}`.
+    const hasBundles = Object.keys(bundles).length > 0 || isPlainRecord(rest.bundles);
+    return {
+        config: { ...rest, ...(hasBundles ? { bundles } : {}), ...(defaultBundle !== undefined ? { defaultBundle } : {}) },
+        converted,
+    };
+}
+/**
+ * Warn-once wrapper around {@link convertLegacySourceShape} for the
+ * in-memory read path: converts the legacy shape and, when it removed
+ * anything, warns once that `akm migrate apply` will persist the rewrite.
+ */
+export function migrateLegacySourceShape(raw, sourcePath) {
+    const { config, converted } = convertLegacySourceShape(raw);
+    if (converted.length === 0)
+        return config;
     const where = sourcePath ? ` at ${sourcePath}` : "";
-    warnOnce(`legacy-source-shape${sourcePath ? `:${sourcePath}` : ""}`, `Config${where} uses the retired ${droppedKeys.join("/")} shape — auto-migrated in memory to \`bundles\`/\`defaultBundle\`. Run \`akm migrate apply\` to rewrite the config file and silence this warning.`);
-    return { ...rest, bundles, ...(defaultBundle !== undefined ? { defaultBundle } : {}) };
+    warnOnce(`legacy-source-shape${sourcePath ? `:${sourcePath}` : ""}`, `Config${where} uses the retired ${converted.join("/")} shape — auto-migrated in memory to \`bundles\`/\`defaultBundle\`. Run \`akm migrate apply\` to rewrite the config file and silence this warning.`);
+    return config;
 }

package/dist/core/config/schema/embedding.js

@@ -27,11 +27,7 @@ export const EmbeddingConnectionConfigSchema = z
     endpoint: z.string().optional(),
     model: z.string().optional(),
     apiKey: symbolicOrWarnApiKey("embedding.apiKey").optional(),
-    // Bounded to the index schema's own vec-table guard (1–4096,
-    // storage/repositories/index-schema.ts) so an out-of-range dimension
-    // fails at config validation with a clear message instead of crashing
-    // `akm index` when ensureSchema rejects it (§24.2 "Semantic" gate).
-    dimension: positiveInt.max(4096).optional(),
+    dimension: positiveInt.optional(),
     localModel: z.string().min(1).optional(),
     /**
      * Per-document token cap applied BEFORE batching (default 512,
@@ -68,6 +64,25 @@ export const EmbeddingConnectionConfigSchema = z
      * no retry — every batch that hit it was silently dropped (#954).
      */
     timeoutMs: positiveInt.optional(),
+    /**
+     * How long search waits for the query embedding (default 3000,
+     * `DEFAULT_QUERY_EMBED_TIMEOUT_MS` in `src/indexer/search/db-search.ts`).
+     * On expiry the search is served by keyword ranking alone, with a warning.
+     */
+    queryTimeoutMs: positiveInt.optional(),
+    /**
+     * Text sent to the model around a search query, `{text}` marking the
+     * query (a template without it is a prefix). Overrides the preset matched
+     * on the model name (`src/llm/embedders/profile.ts`); `""` sends the query
+     * as is.
+     */
+    queryTemplate: z.string().optional(),
+    /**
+     * Text sent to the model around each document at index time, as
+     * `queryTemplate`. Part of the embedding fingerprint: changing it
+     * re-embeds the index.
+     */
+    documentTemplate: z.string().optional(),
     /**
      * Overrides the fixed in-flight request window (#954, added after field
      * evidence from multi-slot local servers). Bounded 1-16. Unset keeps

package/dist/core/config/schema/engines.js

@@ -77,6 +77,11 @@ const LlmEngineSchema = z
     maxTokens: positiveInt.optional(),
     timeoutMs: timeoutMsField,
     concurrency: positiveInt.optional(),
+    // Same user-settable override LlmConnectionConfigSchema declares above; a
+    // named `kind: "llm"` engine is validated by THIS object, so without the
+    // field here the unknown-key walk reported a live setting as unknown and
+    // `akm migrate apply` dropped it from config.json.
+    supportsJsonSchema: z.boolean().optional(),
     extraParams: ExtraParamsSchema.optional(),
     contextLength: positiveInt.optional(),
     enableThinking: z.boolean().optional(),

package/dist/core/config/schema/execution.js

@@ -20,4 +20,4 @@ export const ExecutionPolicyConfigSchema = z
         }
     }),
 })
-    .strict();
+    .passthrough();

package/dist/core/config/schema/experimental.js

@@ -27,4 +27,4 @@ export const ExperimentalConfigSchema = z
      */
     improveAutonomy: z.boolean().optional(),
 })
-    .strict();
+    .passthrough();

package/dist/core/config/schema/improve-processes.js

@@ -64,8 +64,6 @@ const processLimitField = positiveInt.optional();
  * `reflect` process (proposal-side quality gate; see reflect.ts).
  */
 const qualityGateField = z.object({ enabled: z.boolean().optional() }).passthrough().optional();
-/** Consolidate process: gate for the M-1 (#367) contradiction-detection pass. */
-const contradictionDetectionField = z.object({ enabled: z.boolean().optional() }).passthrough().optional();
 /**
  * WS-3b: CLS (Complementary Learning System) interleaving (step 9).
  * distill/memoryInference prompts include embedding-retrieved existing adjacent
@@ -109,19 +107,10 @@ const extractTriageGateField = z
 })
     .passthrough()
     .optional();
-const triageJudgmentErrorMap = (issue, ctx) => {
-    if (issue.code === z.ZodIssueCode.unrecognized_keys) {
-        const retired = issue.keys.find((key) => key === "mode" || key === "profile");
-        if (retired)
-            return { message: `${retired} is retired; use engine` };
-    }
-    return { message: ctx.defaultError };
-};
-// Judgment is an explicit opt-in surface, so invocation typos must fail closed.
-// Keep the shared override schema lenient for ordinary cross-version config
-// compatibility, while making this nested surface strict. `extraParams`
-// remains the intentional arbitrary provider-parameter escape hatch.
-const triageJudgmentLlmOverridesField = LlmInvocationOverridesSchema.strict();
+// Unknown keys pass through here like every other nested surface (the loader
+// names them once); `extraParams` remains the arbitrary provider-parameter
+// escape hatch.
+const triageJudgmentLlmOverridesField = LlmInvocationOverridesSchema.passthrough();
 const triageJudgmentObjectField = z
     .object({
     enabled: z.boolean().optional(),
@@ -129,41 +118,26 @@ const triageJudgmentObjectField = z
     model: nonEmptyString.optional(),
     timeoutMs: z.union([positiveInt, z.null()]).optional(),
     llm: triageJudgmentLlmOverridesField.optional(),
-}, { errorMap: triageJudgmentErrorMap })
-    .strict();
+})
+    .passthrough();
 /** Triage process: explicit LLM-as-judge enablement and execution overrides. */
 const triageJudgmentField = z
     .union([z.boolean(), triageJudgmentObjectField])
     .transform((value) => typeof value === "boolean" ? { enabled: value } : { ...value, enabled: value.enabled ?? true })
     .optional();
 /**
- * WS-3b: Anti-collapse guards (step 8). Prevents the consolidation pipeline
- * from collapsing too aggressively and losing diversity. Consolidate process
- * only. Default ON since R5 (opt out via enabled: false).
- *   - maxGeneration: refuse to merge two assets both above this generation (default 2).
- *   - lexicalDiversityCheck: low n-gram diversity ⇒ raise merge threshold.
- *   - randomClusterFraction: occasional random (non-similar) cluster in pool (default 0.05).
- *   - mergeInformationFloor: LIVE gate (anti-collapse.ts:143) — NOT a
- *     decorative/inert knob. `false` skips the merge-information-floor
- *     measurement entirely (no counting, no warning) for every merge;
- *     true/absent (default) measures it on every merge. The MEASUREMENT's
- *     outcome is advisory in v1: a failing merge is counted
- *     (`merge_floor_violations`) and warned but never refused (promotion path:
- *     docs/architecture/specs/improve-collapse-churn-detector-design.md §7). In short:
- *     this field gates whether the check runs at all (a real code path), not
- *     whether a merge is allowed.
- *   - minSpecificityRetention: distinct-token retention floor for merges (default 0.6).
- * (WS-3b step 0a `homeostaticDemotion` was removed — R4. Continuous decay is
- * now part of the always-applied salience recency term.)
+ * WS-3b: Anti-collapse guard (step 8), consolidate process only: a small
+ * random (non-similarity-driven) fraction of the pool is mixed into the
+ * clustered order so consolidation is not purely rich-get-richer. Default ON
+ * (opt out via `enabled: false`); `randomClusterFraction` defaults to 0.05.
+ * The retired merge guards (`maxGeneration`, `lexicalDiversityCheck`,
+ * `mergeInformationFloor`, `minSpecificityRetention`) never refused a merge
+ * and are tolerated as unknown keys.
  */
 const antiCollapseField = z
     .object({
     enabled: z.boolean().optional(),
-    maxGeneration: z.number().int().min(1).optional(),
-    lexicalDiversityCheck: z.boolean().optional(),
     randomClusterFraction: z.number().min(0).max(1).optional(),
-    mergeInformationFloor: z.boolean().optional(),
-    minSpecificityRetention: z.number().min(0).max(1).optional(),
 })
     .passthrough()
     .optional();
@@ -202,7 +176,6 @@ const CONSOLIDATE_PROCESS_FIELDS = {
     // accumulates; this value is only used on the very first run. Default 30s.
     p90ChunkSecondsDefault: z.number().finite().positive().optional(),
     antiCollapse: antiCollapseField,
-    contradictionDetection: contradictionDetectionField,
 };
 const MEMORY_INFERENCE_PROCESS_FIELDS = {
     // Minimum pending memory count to run the pass.
@@ -261,10 +234,7 @@ const EXTRACT_PROCESS_FIELDS = {
 };
 const TRIAGE_PROCESS_FIELDS = {
     applyMode: z.enum(["queue", "promote"]).optional(),
-    policy: z.string().min(1).optional(),
     maxAcceptsPerRun: positiveInt.optional(),
-    maxDiffLines: positiveInt.optional(),
-    rejectEmpty: z.boolean().optional(),
     judgment: triageJudgmentField,
 };
 /** proactiveMaintenance process fields (Layer 2). */
@@ -276,38 +246,6 @@ const PROACTIVE_MAINTENANCE_PROCESS_FIELDS = {
     maxPerRun: positiveInt.optional(),
     limit: processLimitField,
 };
-/**
- * Shared cross-process superRefine: rejects the retired `mode`/`profile`
- * knobs (top-level and inside a `judgment` sub-object) in favour of `engine`.
- * Applied identically to every per-process schema and to the wide
- * ImproveProcessConfigSchema.
- */
-function checkRetiredProcessKeys(value, ctx) {
-    for (const key of ["mode", "profile"]) {
-        if (key in value) {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, path: [key], message: `${key} is retired; use engine` });
-        }
-    }
-    if ("judgement" in value) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["judgement"],
-            message: "judgement is not a valid key; use judgment",
-        });
-    }
-    const judgment = value.judgment;
-    if (judgment) {
-        for (const key of ["mode", "profile"]) {
-            if (key in judgment) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ["judgment", key],
-                    message: `${key} is retired; use engine`,
-                });
-            }
-        }
-    }
-}
 /** distill/consolidate are memory-only and never read `excludeRefPrefixes` (reflect only, R12). */
 function rejectExcludeRefPrefixesOutsideReflect(value, ctx) {
     if ("excludeRefPrefixes" in value) {
@@ -330,55 +268,43 @@ export const ImproveProcessConfigSchema = z
     ...TRIAGE_PROCESS_FIELDS,
     ...PROACTIVE_MAINTENANCE_PROCESS_FIELDS,
 })
-    .passthrough()
-    .superRefine(checkRetiredProcessKeys);
+    .passthrough();
 /** `processes.reflect` — narrow per-process schema (WI-9.6). */
 export const ReflectProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...REFLECT_PROCESS_FIELDS })
-    .passthrough()
-    .superRefine(checkRetiredProcessKeys);
+    .passthrough();
 /** `processes.distill` — narrow per-process schema (WI-9.6). */
 export const DistillProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...DISTILL_PROCESS_FIELDS })
     .passthrough()
-    .superRefine(checkRetiredProcessKeys)
     .superRefine(rejectExcludeRefPrefixesOutsideReflect);
 /** `processes.consolidate` — narrow per-process schema (WI-9.6). */
 export const ConsolidateProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...CONSOLIDATE_PROCESS_FIELDS })
     .passthrough()
-    .superRefine(checkRetiredProcessKeys)
     .superRefine(rejectExcludeRefPrefixesOutsideReflect);
 /** `processes.memoryInference` — narrow per-process schema (WI-9.6). */
 export const MemoryInferenceProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...MEMORY_INFERENCE_PROCESS_FIELDS })
-    .passthrough()
-    .superRefine(checkRetiredProcessKeys);
+    .passthrough();
 /** `processes.graphExtraction` — narrow per-process schema (WI-9.6). */
 export const GraphExtractionProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...GRAPH_EXTRACTION_PROCESS_FIELDS })
-    .passthrough()
-    .superRefine(checkRetiredProcessKeys);
+    .passthrough();
 /** `processes.extract` — narrow per-process schema (WI-9.6). */
 export const ExtractProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...EXTRACT_PROCESS_FIELDS })
-    .passthrough()
-    .superRefine(checkRetiredProcessKeys);
+    .passthrough();
 /** `processes.validation` — narrow per-process schema (WI-9.6); no extra fields beyond the shared base. */
-export const ValidationProcessConfigSchema = z
-    .object({ ...IMPROVE_PROCESS_BASE_FIELDS })
-    .passthrough()
-    .superRefine(checkRetiredProcessKeys);
+export const ValidationProcessConfigSchema = z.object({ ...IMPROVE_PROCESS_BASE_FIELDS }).passthrough();
 /** `processes.triage` — narrow per-process schema (WI-9.6). */
 export const TriageProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...TRIAGE_PROCESS_FIELDS })
-    .passthrough()
-    .superRefine(checkRetiredProcessKeys);
+    .passthrough();
 /** `processes.proactiveMaintenance` — narrow per-process schema (WI-9.6). */
 export const ProactiveMaintenanceProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...PROACTIVE_MAINTENANCE_PROCESS_FIELDS })
-    .passthrough()
-    .superRefine(checkRetiredProcessKeys);
+    .passthrough();
 const ImproveProfileProcessesSchema = z
     .object({
     reflect: ReflectProcessConfigSchema.optional(),