akm-cli 0.9.1 → 0.9.2-alpha.2

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

@@ -25,12 +25,10 @@
  * - Top-level uses `.passthrough()` so unknown future keys round-trip intact on
  *   read; `sanitizeConfigForWrite` decides what to persist.
  * - Most nested sub-objects use `.catch(undefined)` so malformed entries are
- *   silently dropped (matches the legacy parser's warn-and-ignore semantics for
- *   field-level shape errors — keeps cold-start working when a user has a
- *   typo in their config).
- * - Two exceptions (hard-rejected): openviking source type and legacy
- *   `stashes[]` key. Both have explicit migration paths; silently dropping
- *   would mask user data loss.
+ *   silently dropped to keep cold-start working when a user has a field-level
+ *   typo in an optional section.
+ * - Unsupported top-level source shapes and provider kinds are hard-rejected;
+ *   silently dropping them would mask user data loss.
  * - UNKNOWN-KEY POLICY: object schemas use passthrough (unknown keys are
  *   preserved and ignored, NOT rejected). akm runs across multiple installed
  *   versions sharing one config.json; a newer version writes keys an older
@@ -51,7 +49,7 @@ import { FeedbackConfigSchema } from "./schema/feedback.js";
 import { ImproveConfigSchema } from "./schema/improve.js";
 import { IndexConfigSchema } from "./schema/index-config.js";
 import { OutputConfigSchema } from "./schema/output.js";
-import { CURRENT_CONFIG_VERSION, engineName, GlobalModelAliasesSchema, nonEmptyString, nonNegativeNumber, } from "./schema/primitives.js";
+import { CURRENT_CONFIG_VERSION, engineName, nonEmptyString, nonNegativeNumber } from "./schema/primitives.js";
 import { SearchConfigSchema } from "./schema/search.js";
 import { SetupConfigSchema } from "./schema/setup.js";
 import { BundlesConfigSchema, RegistryConfigEntrySchema } from "./schema/sources-bundles.js";
@@ -85,33 +83,21 @@ export const DefaultsSchema = z
  * with cross-field refinements (`.superRefine()`).
  *
  * All fields validate loudly — typos and shape errors throw at load time. The
- * legacy parser's warn-and-drop tolerance was a frequent source of silent
- * configuration loss; the migration module ({@link migrateConfigShape}) handles
- * one-time 0.7→0.8 input transforms before the schema sees the value.
+ * the removed parser's warn-and-drop tolerance was a source of silent
+ * configuration loss. There is no pre-schema compatibility transform.
  */
 export const AkmConfigShape = {
     configVersion: z.literal(CURRENT_CONFIG_VERSION),
     engines: EnginesSchema.optional(),
     defaults: DefaultsSchema.optional(),
-    // Global model-alias tiers: alias → platform → exact model string, with a
-    // reserved `"*"` platform key as fallback. Lets workflows/callers name a
-    // semantic tier ("fast", "deep") that resolves per-harness at dispatch
-    // time. Values are literal model strings, never other aliases (one
-    // resolution level). Platform keys match the platform string a command
-    // builder resolves against ("claude", "opencode", "opencode-sdk", or a
-    // custom profile's name for the default builder) — unknown keys are inert.
-    // Precedence: profile modelAliases > this table > built-in aliases.
-    modelAliases: GlobalModelAliasesSchema.optional(),
     semanticSearchMode: z.enum(["off", "auto"]).default("off"),
     embedding: EmbeddingConnectionConfigSchema.optional(),
     index: IndexConfigSchema.optional(),
     registries: z.array(RegistryConfigEntrySchema).optional(),
-    // 0.9.0 config-shape cutover (spec §10.1 / D-R5). `bundles` + `defaultBundle`
-    // are the ONLY source shape — the retired `stashDir`/`sources[]`/`installed[]`
-    // trio is hard-rejected at load (see the top-level superRefine). The migrator
-    // ({@link migrateConfigSourcesToBundles}) converts a pre-cutover config to this
-    // shape before validation. `defaultBundle` names the primary bundle (spec
-    // §11.1 short-ref resolution / D-R4).
+    // `bundles` + `defaultBundle` are the only source configuration shape. The
+    // retired `stashDir`/`sources[]`/`installed[]` keys are rejected at load;
+    // there is no runtime config translator. `defaultBundle` names the primary
+    // bundle used for short-ref resolution.
     bundles: BundlesConfigSchema.optional(),
     defaultBundle: nonEmptyString.optional(),
     output: OutputConfigSchema.optional(),
@@ -128,17 +114,14 @@ export const AkmConfigShape = {
 };
 export const AkmConfigBaseSchema = z.object(AkmConfigShape).passthrough();
 /**
- * Per-key overrides for the retired `stashDir`/`sources`/`installed` source-
- * shape rejection below. Keys without an entry fall back to the shared
- * "retired pre-cutover source shape" message, which already names the
- * replacement (bundles) and the migration command.
+ * Per-key overrides for unsupported pre-cutover source shapes.
  */
 const RETIRED_SOURCE_SHAPE_KEY_MESSAGES = {
-    stashDir: "stashDir is retired in 0.9; the stash path now comes from `bundles`. Run `akm-migrate apply` to convert a pre-0.9 config, or see `akm config path --all` / `akm info`.",
+    stashDir: "stashDir is not supported; configure `bundles`, or use `akm config path --all` / `akm info` to inspect current paths.",
 };
 export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) => {
     const raw = config;
-    for (const key of ["profiles", "llm", "agent", "features", "stashes"]) {
+    for (const key of ["profiles", "llm", "agent", "features", "stashes", "modelAliases"]) {
         if (key in raw) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
@@ -157,19 +140,14 @@ export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) =>
             message: "bindings is not supported in 0.9.0 (Tier B); it is neither emitted nor accepted",
         });
     }
-    // 0.9.0 config-shape cutover (spec §10.1): the retired `stashDir`/`sources`/
-    // `installed` trio is HARD-REJECTED at load whenever present — `bundles` +
-    // `defaultBundle` fully supersede it. A pre-cutover config never loads through
-    // this validated path; the migrator ({@link migrateConfigSourcesToBundles})
-    // normalizes old→bundles BEFORE validation, and `inspectConfig` classifies an
-    // old-shape-alone config "old" (migration-eligible) via that same normalize.
+    // Only the current source shape enters the runtime. There is no config
+    // compatibility path; `bundles` + `defaultBundle` fully supersede these keys.
     for (const key of ["stashDir", "sources", "installed"]) {
         if (key in raw && raw[key] !== undefined) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
                 path: [key],
-                message: RETIRED_SOURCE_SHAPE_KEY_MESSAGES[key] ??
-                    `${key} is the retired pre-cutover source shape; run \`akm-migrate apply\` to convert it to bundles`,
+                message: RETIRED_SOURCE_SHAPE_KEY_MESSAGES[key] ?? `${key} is not supported; configure the current bundles shape`,
             });
         }
     }
@@ -295,7 +273,7 @@ export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) =>
                 }
             }
             const judgmentEngine = processConfig.judgment?.engine;
-            if (judgmentEngine) {
+            if (processConfig.judgment?.enabled === true && judgmentEngine) {
                 const engine = config.engines?.[judgmentEngine];
                 if (!engine) {
                     ctx.addIssue({

package/dist/core/config/config-sources.js

@@ -2,9 +2,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * Runtime helpers that derive {@link ConfiguredSource} values from the
- * persisted {@link SourceConfigEntry} / {@link InstalledBundle} shapes
- * in an {@link AkmConfig}.
+ * Runtime helpers that derive provider-ready and {@link ConfiguredSource}
+ * values from the current bundle map in an {@link AkmConfig}.
  */
 import { createHash } from "node:crypto";
 import path from "node:path";
@@ -20,15 +19,9 @@ export function bundleComponentConfig(bundle) {
     return components[0];
 }
 /**
- * Convert a `bundles` map (0.9.0 config-shape cutover, spec §10.1 / D-R5) into
- * the ordered {@link SourceConfigEntry} list the transitional runtime source
- * resolvers already consume — `defaultBundle` first (primary), then map
- * insertion order (preserving today's installation-priority semantics, on which
- * D-R4 short-ref resolution depends). Each entry's `name` IS its bundle key, so
- * `deriveInstallations` re-derives the exact same installation id (D-R5 rule 1).
- *
- * Returns `undefined` for an old-shape config (no `bundles`), so callers fall
- * back to the pre-cutover `stashDir`/`sources[]`/`installed[]` resolution.
+ * Convert the current `bundles` map into its ordered provider projection:
+ * `defaultBundle` first, then map insertion order. Each entry's `name` is its
+ * bundle key. Returns `undefined` when no bundles map is configured.
  */
 /**
  * The resolved primary stash path — the `defaultBundle`'s filesystem `path`
@@ -83,9 +76,7 @@ export function bundleEntryToSourceEntry(key, bundle, isPrimary = false) {
         return { type: "git", url: normalizeInstalledGitRef("", bundle.git), ...base };
     }
     if (bundle.website && typeof bundle.website.url === "string") {
-        // All non-`url` website-descriptor keys (maxPages/refresh/maxDepth + any
-        // passthrough provider options) round-trip back to the runtime entry's
-        // `options` bag, mirroring the pre-cutover `sources[].options` shape.
+        // All non-`url` website-descriptor keys become provider options.
         const { url, ...rest } = bundle.website;
         return {
             type: "website",
@@ -144,9 +135,9 @@ function normalizeInstalledGitRef(source, ref) {
     return requestedRef ? `${cloneUrl}/tree/${requestedRef}` : cloneUrl;
 }
 /**
- * Synthesize a stable identifier when a {@link SourceConfigEntry} omits its
- * `name`. Uses a short hash of the discriminating fields so two equivalent
- * entries collapse to the same generated name.
+ * Produce a stable internal identifier for a provider projection. Current
+ * bundle-derived entries always carry `name`; the hash protects manually
+ * constructed internal values.
  */
 function deriveBundleName(entry) {
     if (entry.name)
@@ -160,7 +151,7 @@ function deriveBundleName(entry) {
     return `${entry.type}-${hash}`;
 }
 /**
- * Convert a persisted {@link SourceConfigEntry} into the runtime
+ * Convert a provider-ready {@link SourceConfigEntry} into the runtime
  * {@link SourceSpec} discriminated union. Returns `undefined` when the entry
  * is missing the fields its provider type requires (e.g. a `filesystem`
  * entry with no `path`); callers should drop or warn for those.
@@ -189,8 +180,7 @@ export function parseSourceSpec(entry) {
  * Build the full ordered list of runtime {@link ConfiguredSource} values from a
  * loaded {@link AkmConfig}, resolved from `bundles` + `defaultBundle` (spec
  * §10.1): the `defaultBundle` (primary) first, then map insertion order. The
- * retired `stashDir`/`sources[]`/`installed[]` trio is no longer read here — a
- * pre-cutover config is normalized to bundles by the migrator before it loads.
+ * retired `stashDir`/`sources[]`/`installed[]` trio is never read or normalized.
  *
  * Entries with `enabled: false` are still emitted — callers decide whether to
  * honour the flag. Entries that fail {@link parseSourceSpec} drop silently.

package/dist/core/config/config-walker.js

@@ -180,11 +180,26 @@ export function configSet(config, dotted, raw) {
     if (!schema && !symbolicApiKey) {
         throw new UsageError(`Unknown config key: ${dotted}`, "INVALID_FLAG_VALUE", unknownKeyHint(dotted));
     }
-    const value = path[0] === "engines" && path.length === 2
-        ? parseObjectPatch(raw, dotted)
-        : symbolicApiKey
-            ? raw
-            : coerceForSchema(schema, raw, dotted);
+    const judgmentObjectPath = isTriageJudgmentPath(path);
+    const value = judgmentObjectPath && raw === "null"
+        ? undefined
+        : path[0] === "engines" && path.length === 2
+            ? parseObjectPatch(raw, dotted)
+            : symbolicApiKey
+                ? raw
+                : coerceForSchema(schema, raw, dotted);
+    const existing = path.reduce((value, key) => {
+        if (value && typeof value === "object")
+            return value[key];
+        return undefined;
+    }, config);
+    // The judgment leaf supplies `enabled: true` when the field is omitted.
+    // Merge a JSON object patch with the existing value before that current
+    // schema transform,
+    // otherwise the synthesized default can overwrite an explicit false.
+    const candidate = judgmentObjectPath && isPlainObject(value)
+        ? deepMergeConfig(isPlainObject(existing) ? existing : {}, value)
+        : value;
     // Validate the coerced value against the leaf schema. This catches enum
     // mismatches, out-of-range numbers, schema-level shape errors (writable
     // npm/website sources via .superRefine, strict-mode unknown keys in nested
@@ -195,7 +210,7 @@ export function configSet(config, dotted, raw) {
             ? /^\$[A-Za-z_][A-Za-z0-9_]*$|^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(raw)
                 ? { success: true, data: value }
                 : { success: false, error: { issues: [{ path: [], message: `apiKey must be $VAR or \${VAR}` }] } }
-            : schema.safeParse(value);
+            : schema.safeParse(candidate);
     if (!parsed.success) {
         const lines = parsed.error.issues
             .map((i) => {
@@ -205,11 +220,6 @@ export function configSet(config, dotted, raw) {
             .join("\n");
         throw new UsageError(`Invalid value for ${dotted}:\n${lines}`, "INVALID_FLAG_VALUE");
     }
-    const existing = path.reduce((value, key) => {
-        if (value && typeof value === "object")
-            return value[key];
-        return undefined;
-    }, config);
     const next = setPath(config, path, isPlainObject(existing) && isPlainObject(parsed.data) ? deepMergeConfig(existing, parsed.data) : parsed.data);
     // Targeted invariant: defaultWriteTarget must point at a configured bundle
     // (#464.a). Whole-config validation happens at save time; this check fires
@@ -223,6 +233,14 @@ export function configSet(config, dotted, raw) {
     }
     return next;
 }
+function isTriageJudgmentPath(path) {
+    return (path.length === 6 &&
+        path[0] === "improve" &&
+        path[1] === "strategies" &&
+        path[3] === "processes" &&
+        path[4] === "triage" &&
+        path[5] === "judgment");
+}
 /**
  * Unset the value at the dotted path. Removes the leaf key (and prunes empty
  * parent objects if they become empty). Returns a new config object.
@@ -411,8 +429,8 @@ function unsetPath(config, path) {
  */
 const RETIRED_KEY_HINTS = {
     stashDir: "stashDir was removed in 0.9; get the stash path from `akm config path --all` or `akm info`.",
-    sources: "sources was replaced by bundles in 0.9; run `akm-migrate apply` on a pre-0.9 config to convert it.",
-    installed: "installed was replaced by bundles in 0.9; run `akm-migrate apply` on a pre-0.9 config to convert it.",
+    sources: "sources is not supported; configure `bundles` instead.",
+    installed: "installed is not supported; configure `bundles` instead.",
     wikiName: "the wiki subsystem was removed in 0.9; wikis are ordinary knowledge assets now — see `akm import`.",
     wiki: "the wiki subsystem was removed in 0.9; wikis are ordinary knowledge assets now — see `akm import`.",
     llm: "llm was replaced by named engines configuration in 0.9; configure `engines` instead.",

package/dist/core/config/config.js

@@ -4,19 +4,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { ConfigError } from "../errors.js";
-import { assertNoPendingMigrationOperation } from "../migration-operation.js";
 import { acquireConfigLock, backupExistingConfig, parseConfigText, readConfigText, withConfigLock, writeConfigAtomic, } from "./config-io.js";
 import { AkmConfigSchema, CURRENT_CONFIG_VERSION } from "./config-schema.js";
 import { bundlesToSourceEntries } from "./config-sources.js";
 import { deepMergeConfig } from "./deep-merge.js";
 export { stripJsonComments } from "./config-io.js";
-// requireLlmConfig / getDefaultLlmConfig moved to
-// integrations/agent/engine-resolution.ts (WI-9.8 KILL 3, D.3 edge A) — they
-// called that module's materializeLlmConnection/resolveLlmEngineUse, and that
-// module imported LlmConnectionConfig back from this file, closing a 2-file
-// cycle that also fused config.ts into the harness/agent-runtime SCC. This
-// file can no longer re-export them (a re-export is still a graph edge to
-// engine-resolution.ts) — import them from there directly.
 import { getConfigPath } from "../paths.js";
 import { warn } from "../warn.js";
 // Canonical harness-id source of truth (#565) — runtime value re-export.
@@ -74,7 +66,6 @@ export function resetConfigCache() {
     cachedConfig = undefined;
 }
 export function loadUserConfig() {
-    assertNoPendingMigrationOperation();
     const configPath = getConfigPath();
     let stat;
     try {
@@ -124,6 +115,24 @@ 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;
+    }
+}
 /**
  * Parse raw config text and validate via Zod.
  * ({@link AkmConfigSchema}). Returns the merged-with-defaults AkmConfig.
@@ -153,11 +162,9 @@ export function parseAndValidateConfigText(text, sourcePath) {
 /**
  * The configured stash sources as an ordered {@link SourceConfigEntry} list.
  *
- * 0.9.0 (spec §10.1): the retired `stashDir`/`sources[]`/`installed[]` trio is
- * gone — every source is a `bundles.<slug>` entry. This derives the unified
- * source list from `bundles` (defaultBundle first, then map order), so callers
- * that iterated `sources[]` keep working over the new shape. Returns `[]` when
- * no bundles are configured.
+ * Every source is a `bundles.<slug>` entry. This derives the provider-ready
+ * source list from `bundles` (defaultBundle first, then map order). Returns
+ * `[]` when no bundles are configured.
  */
 export function getSources(config) {
     return bundlesToSourceEntries(config) ?? [];
@@ -181,13 +188,11 @@ export function saveConfig(config) {
     saveConfigReal(currentConfig);
 }
 function saveConfigReal(config) {
-    assertNoPendingMigrationOperation();
     cachedConfig = undefined;
     const configPath = getConfigPath();
     const dir = path.dirname(configPath);
     fs.mkdirSync(dir, { recursive: true });
     withConfigLock(() => {
-        assertNoPendingMigrationOperation();
         const validated = validateCompleteConfig(config);
         backupExistingConfig(configPath);
         writeConfigAtomic(configPath, sanitizeConfigForWrite(validated));
@@ -206,11 +211,9 @@ export function validateCompleteConfig(config) {
  * ordinary backup, and atomic write.
  */
 export function mutateConfig(mutate, options) {
-    assertNoPendingMigrationOperation();
     cachedConfig = undefined;
     const configPath = getConfigPath();
     return withConfigLock(() => {
-        assertNoPendingMigrationOperation();
         const text = readConfigText(configPath);
         if (text === undefined && options?.absentNoop) {
             return { config: { ...DEFAULT_CONFIG }, written: false };
@@ -233,12 +236,10 @@ export function mutateConfig(mutate, options) {
  * its stash, while preventing another config writer from racing the final save.
  */
 export async function mutateConfigWithPrecommit(mutate, precommit) {
-    assertNoPendingMigrationOperation();
     cachedConfig = undefined;
     const configPath = getConfigPath();
     const release = acquireConfigLock();
     try {
-        assertNoPendingMigrationOperation();
         const text = readConfigText(configPath);
         const current = text === undefined ? { ...DEFAULT_CONFIG } : parseAndValidateConfigText(text, configPath);
         const mutated = mutate(current);
@@ -346,12 +347,8 @@ export function resolveSecret(value) {
  * filtering out the reserved feature-section keys so callers don't mistake
  * `metadataEnhance` for a pass.
  */
-/**
- * Reserved well-known keys on IndexConfig that are NOT per-pass entries.
- * `indexBodyOpening` (stash-conventions SPEC-8) is a boolean feature flag, not
- * a pass section.
- */
-const INDEX_RESERVED_KEYS = new Set(["metadataEnhance", "indexBodyOpening"]);
+/** Reserved well-known keys on IndexConfig that are NOT per-pass entries. */
+const INDEX_RESERVED_KEYS = new Set(["metadataEnhance"]);
 export function getIndexPassConfig(config, passName) {
     if (!config)
         return undefined;

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

@@ -15,7 +15,7 @@ import { z } from "zod";
 // a config-schema ↔ config-types type cycle that collapses inference.
 import { HARNESS_AGENT_DISPATCH_IDS, VALID_HARNESS_IDS } from "../../../integrations/harnesses/ids.js";
 import { WORKFLOW_MAX_TIMEOUT_MS } from "../../../workflows/resource-limits.js";
-import { chatCompletionsEndpoint, ENV_REFERENCE_PATTERN, ExtraParamsSchema, engineName, LlmCapabilitiesSchema, ModelAliasMapSchema, nonEmptyString, positiveInt, } from "./primitives.js";
+import { chatCompletionsEndpoint, ENV_REFERENCE_PATTERN, ExtraParamsSchema, engineName, LlmCapabilitiesSchema, nonEmptyString, positiveInt, } from "./primitives.js";
 /**
  * Engine-config timeouts share the workflow ceiling.
  *
@@ -29,11 +29,9 @@ const timeoutMsField = z.union([positiveInt.max(WORKFLOW_MAX_TIMEOUT_MS), z.null
 // ── Connection configs (LLM) ────────────────────────────────────────────────
 /**
  * OpenAI-compatible connection fields shared by named LLM engines and bounded
- * internal call helpers. `model` is required at schema level — partial entries
- * created by `akm config set llm.endpoint <url>` (where model is left absent)
- * are normalized to `model: ""` *before* Zod sees them by the load-time
- * pre-Zod migrator hook, so this strict shape gates CLI writes without
- * breaking legacy load-time partial configs.
+ * internal call helpers. `model` is required at schema level: current loads and
+ * CLI writes reject a partial named engine rather than normalizing it through a
+ * pre-schema compatibility transform.
  */
 export const LlmConnectionConfigSchema = z
     .object({
@@ -49,6 +47,7 @@ export const LlmConnectionConfigSchema = z
     extraParams: ExtraParamsSchema.optional(),
     contextLength: positiveInt.optional(),
     enableThinking: z.boolean().optional(),
+    reasoningEffort: nonEmptyString.optional(),
 })
     .passthrough();
 export const LlmProfileConfigSchema = LlmConnectionConfigSchema.extend({
@@ -73,6 +72,7 @@ const LlmEngineSchema = z
     extraParams: ExtraParamsSchema.optional(),
     contextLength: positiveInt.optional(),
     enableThinking: z.boolean().optional(),
+    reasoningEffort: nonEmptyString.optional(),
 })
     .passthrough()
     .superRefine((value, ctx) => {
@@ -92,7 +92,6 @@ const AgentEngineSchema = z
     workspace: nonEmptyString.optional(),
     model: nonEmptyString.optional(),
     timeoutMs: timeoutMsField,
-    modelAliases: ModelAliasMapSchema.optional(),
     llmEngine: engineName.optional(),
 })
     .passthrough()
@@ -108,6 +107,8 @@ const AgentEngineSchema = z
         "extraParams",
         "contextLength",
         "enableThinking",
+        "reasoningEffort",
+        "modelAliases",
     ]) {
         if (key in value)
             ctx.addIssue({ code: z.ZodIssueCode.custom, path: [key], message: `${key} is not valid on an agent engine` });

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

@@ -100,15 +100,32 @@ const extractTriageGateField = z
 })
     .passthrough()
     .optional();
-/** Triage process: LLM-as-judge triage-apply decision engine override. */
-const triageJudgmentField = z
+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();
+const triageJudgmentObjectField = z
     .object({
+    enabled: z.boolean().optional(),
     engine: engineName.optional(),
     model: nonEmptyString.optional(),
     timeoutMs: z.union([positiveInt, z.null()]).optional(),
-    llm: LlmInvocationOverridesSchema.optional(),
-})
-    .passthrough()
+    llm: triageJudgmentLlmOverridesField.optional(),
+}, { errorMap: triageJudgmentErrorMap })
+    .strict();
+/** 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
@@ -256,6 +273,13 @@ function checkRetiredProcessKeys(value, ctx) {
             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"]) {

package/dist/core/config/schema/index-config.js

@@ -99,14 +99,6 @@ const IndexDefaultsSchema = z
  * Index config is a union of reserved feature sections and per-pass entries.
  * Passthrough so per-pass entries (keyed by arbitrary pass names like `graph`,
  * `enrichment`) can live next to the reserved keys.
- *
- * Reserved scalar key `indexBodyOpening` (stash-conventions SPEC-8, default
- * false): when true, the metadata pass captures the first prose paragraph of
- * each markdown asset body into `entry.bodyOpening`, which folds into the
- * lowest-weight `content` FTS column and the embedding text. It is a boolean,
- * not a per-pass object — the preprocess below exempts it from the
- * object-shape check so it never routes into the per-pass catchall.
- *
  * The outer preprocess emits the legacy parser's actionable error messages
  * for the two most common type-shape mistakes:
  *   - An array at the `index` block.
@@ -136,17 +128,6 @@ const IndexConfigRuntimeSchema = z.preprocess((raw, ctx) => {
             });
             return raw;
         }
-        if (passName === "indexBodyOpening") {
-            if (typeof value !== "boolean") {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: "Invalid `index.indexBodyOpening`: expected a boolean (true to index the first body paragraph " +
-                        `of markdown assets into search). Got ${Array.isArray(value) ? "array" : typeof value}.`,
-                });
-                return raw;
-            }
-            continue;
-        }
         if (typeof value !== "object" || value === null || Array.isArray(value)) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
@@ -160,14 +141,6 @@ const IndexConfigRuntimeSchema = z.preprocess((raw, ctx) => {
     .object({
     defaults: IndexDefaultsSchema.optional(),
     metadataEnhance: MetadataEnhanceSchema.optional(),
-    indexBodyOpening: z
-        .boolean()
-        .optional()
-        .describe("Index the first prose paragraph of each markdown asset body (capped at 280 chars) into the " +
-        "lowest-weight `content` search column and the embedding text (default false). Secret/env files " +
-        "and session-kind memories are never captured. Toggling the flag changes indexed text: run " +
-        "`akm index --full` afterwards to re-extract every entry and regenerate embeddings, and re-mint " +
-        "collapse-detector canary baselines via `bun scripts/refresh-canary-set.ts --refresh`."),
 })
     .catchall(IndexPassConfigSchema));
 // The runtime catchall correctly validates arbitrary pass objects, but its

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

@@ -53,29 +53,6 @@ export const ExtraParamsSchema = z.record(z.unknown()).superRefine((value, ctx)
         ctx.addIssue({ code: z.ZodIssueCode.custom, path: issue.path, message: issue.message });
     }
 });
-function normalizeAliasKeys(raw, ctx) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const normalized = {};
-    const originalByKey = new Map();
-    for (const [key, value] of Object.entries(raw)) {
-        const lower = key.toLowerCase();
-        const previous = originalByKey.get(lower);
-        if (previous !== undefined) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: [key],
-                message: `alias collides case-insensitively with ${previous}`,
-            });
-            continue;
-        }
-        originalByKey.set(lower, key);
-        normalized[lower] = value;
-    }
-    return normalized;
-}
-export const ModelAliasMapSchema = z.preprocess((raw, ctx) => normalizeAliasKeys(raw, ctx), z.record(z.string().min(1), z.string().min(1)));
-export const GlobalModelAliasesSchema = z.preprocess((raw, ctx) => normalizeAliasKeys(raw, ctx), z.record(z.string().min(1), z.record(z.string().min(1), z.string().min(1))));
 // ── Shared connection/invocation building blocks ────────────────────────────
 export const LlmCapabilitiesSchema = z
     .object({
@@ -90,5 +67,6 @@ export const LlmInvocationOverridesSchema = z
     extraParams: ExtraParamsSchema.optional(),
     contextLength: positiveInt.optional(),
     enableThinking: z.boolean().optional(),
+    reasoningEffort: nonEmptyString.optional(),
 })
     .passthrough();