akm-cli 0.9.0-beta.11 → 0.9.0-beta.26

package/dist/core/asset/frontmatter.js

@@ -4,170 +4,43 @@
 /**
  * Shared frontmatter parsing utilities.
  *
- * Provides a single, canonical YAML-subset frontmatter parser used by both
- * the stash open logic and the metadata generator.
+ * Uses the `yaml` library for all YAML parsing so that the full YAML spec
+ * (block scalars, multi-line strings, nested objects, flow sequences, escape
+ * sequences) is handled correctly without a brittle hand-rolled state machine.
  */
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 /**
- * Parse YAML-subset frontmatter from a Markdown (or similar) string.
+ * Parse YAML frontmatter from a Markdown (or similar) string.
  *
  * Returns the parsed key-value data and the remaining body content.
- *
- * **Limitations**: This is a hand-rolled YAML-subset parser with intentional
- * constraints for simplicity and safety:
- * - **Top-level values**: string, boolean, and number scalars are supported,
- *   as well as top-level list-valued keys using YAML block sequences
- *   (`- item`) or flow arrays (`[a, b, c]`).
- * - **List item types**: list items must be scalar values and may be strings,
- *   booleans, or numbers.
- * - **No nested objects beyond one level**: Only a single level of indented
- *   key-value pairs is supported.
- * - **Block scalars**: `|` (literal), `|-` (strip), and `|+` (keep) block
- *   scalars are supported for multi-line string values as emitted by the
- *   `yaml` library's `stringify`.
+ * Delegates all YAML parsing to the `yaml` library; the only responsibility
+ * of this function is extracting the `---…---` block and normalizing the
+ * parsed result (e.g. converting YAML timestamp values to ISO date strings).
  */
 export function parseFrontmatter(raw) {
     const parsedBlock = parseFrontmatterBlock(raw);
     if (!parsedBlock) {
         return { data: {}, content: raw, frontmatter: null, bodyStartLine: 1 };
     }
-    const data = {};
-    let currentKey = null;
-    /**
-     * "scalar" | "list" | "object" | "pending" | "block" —
-     * "pending" means empty value, mode determined by next line.
-     * "block" means we are accumulating lines for a `|`-block scalar.
-     */
-    let mode = "scalar";
-    let nested = null;
-    let currentList = null;
-    /** Lines collected while in "block" mode. */
-    let blockLines = null;
-    /** Block scalar chomping: "clip" (|), "strip" (|-), "keep" (|+). */
-    let blockChomping = "clip";
-    const flushPending = () => {
-        // Called when we start a new top-level key and the previous key was still "pending".
-        // An empty-value key followed by another top-level key means it was an empty scalar.
-        if (mode === "pending" && currentKey !== null) {
-            data[currentKey] = "";
-        }
-    };
-    const flushBlock = () => {
-        // Commit the accumulated block-scalar lines to `data[currentKey]`.
-        if (mode !== "block" || currentKey === null || blockLines === null)
-            return;
-        // De-indent: strip the common 2-space prefix `yaml.stringify` emits.
-        const deindented = blockLines.map((l) => (l.startsWith("  ") ? l.slice(2) : l));
-        // Chomping: apply trailing-newline policy.
-        // "clip" (|): single trailing newline.
-        // "strip" (|-): no trailing newline.
-        // "keep" (|+): keep all trailing newlines as-is.
-        if (blockChomping === "keep") {
-            data[currentKey] = deindented.join("\n");
-        }
-        else if (blockChomping === "strip") {
-            data[currentKey] = deindented.join("\n").replace(/\n+$/, "");
-        }
-        else {
-            // "clip": exactly one trailing newline
-            data[currentKey] = `${deindented.join("\n").replace(/\n+$/, "")}\n`;
-        }
-    };
-    for (const line of parsedBlock.frontmatter.split(/\r?\n/)) {
-        // If we are in block-scalar mode, collect indented lines or end the block.
-        if (mode === "block") {
-            if (line.startsWith("  ") || line === "") {
-                // Continuation of the block scalar (indented content or blank line).
-                blockLines.push(line);
-                continue;
+    let data = {};
+    if (parsedBlock.frontmatter.trim()) {
+        try {
+            const parsed = yamlParse(parsedBlock.frontmatter);
+            if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+                // Normalize Date objects: the yaml "core" schema parses YYYY-MM-DD
+                // literals as JS Date instances. Convert them back to ISO date strings
+                // to preserve the string type that callers (and yaml.stringify on write)
+                // expect.
+                data = normalizeYamlValues(parsed);
             }
-            // Non-indented line ends the block scalar — flush and fall through to
-            // parse the new line as a top-level key.
-            flushBlock();
-            mode = "scalar";
-            blockLines = null;
         }
-        // Block-sequence item: "- value" or "  - value" (optional 2-space indent)
-        // Only match when the current key is in list or pending mode.
-        const seqItem = line.match(/^(?: {2})?- (.*)$/);
-        if (seqItem && currentKey !== null && (mode === "list" || mode === "pending")) {
-            if (mode === "pending") {
-                // First block-sequence item after an empty-value key — switch to list mode
-                currentList = [];
-                data[currentKey] = currentList;
-                mode = "list";
-            }
-            currentList.push(parseYamlScalar(seqItem[1].trim()));
-            continue;
-        }
-        // Plain-style multi-line scalar continuation: a 2-space-indented line that
-        // is not a sequence item or nested key. YAML plain scalars fold newlines
-        // into a single space, so we append with a space. This handles LLM-emitted
-        // descriptions like:
-        //   description: Use 4-colon outer containers when mixing
-        //     nesting depths in markdown-it-container plugins.
-        // Without this, only the first line is captured and the truncation
-        // heuristic wrongly flags it as cut off mid-sentence.
-        if (mode === "scalar" && currentKey !== null && /^ {2}\S/.test(line)) {
-            data[currentKey] = `${String(data[currentKey])} ${line.trim()}`;
-            continue;
-        }
-        // Indented nested key-value (object under a key with empty value)
-        const indented = line.match(/^ {2}(\w[\w-]*):\s*(.+)$/);
-        if (indented && currentKey !== null && (mode === "object" || mode === "pending")) {
-            if (mode === "pending") {
-                // First indented k-v after an empty-value key — switch to object mode
-                nested = {};
-                data[currentKey] = nested;
-                mode = "object";
-            }
-            nested[indented[1]] = parseYamlScalar(indented[2].trim());
-            continue;
+        catch {
+            // Malformed YAML (e.g. unterminated quotes from LLM output corruption).
+            // Fall back to line-by-line best-effort extraction so callers still get
+            // whatever scalar values they can rather than a completely empty record.
+            data = parseFrontmatterLenient(parsedBlock.frontmatter);
         }
-        // Top-level key (possibly with inline value)
-        const top = line.match(/^(\w[\w-]*):\s*(.*)$/);
-        if (!top) {
-            continue;
-        }
-        // Starting a new top-level key — flush any pending empty-value key
-        flushPending();
-        currentKey = top[1];
-        const value = top[2].trim();
-        if (value === "|" || value === "|-" || value === "|+") {
-            // Block scalar header — collect subsequent indented lines.
-            mode = "block";
-            blockLines = [];
-            blockChomping = value === "|-" ? "strip" : value === "|+" ? "keep" : "clip";
-            nested = null;
-            currentList = null;
-        }
-        else if (value === "") {
-            // Defer mode decision until we see the next line
-            mode = "pending";
-            nested = null;
-            currentList = null;
-            // Don't store anything yet — flushPending will set "" if no continuation
-        }
-        else if (value.startsWith("[") && value.endsWith("]")) {
-            // Inline flow array: tags: [ops, networking]
-            mode = "list";
-            nested = null;
-            currentList = null;
-            currentList = parseFlowArray(value);
-            data[currentKey] = currentList;
-        }
-        else {
-            mode = "scalar";
-            nested = null;
-            currentList = null;
-            data[currentKey] = parseYamlScalar(value);
-        }
-    }
-    // Flush any in-progress block scalar at end of frontmatter.
-    if (mode === "block") {
-        flushBlock();
     }
-    // Flush the last key if it was still pending (empty value, no continuation)
-    flushPending();
     return {
         data,
         content: parsedBlock.content,
@@ -176,29 +49,89 @@ export function parseFrontmatter(raw) {
     };
 }
 /**
- * Parse a YAML flow array string like `[a, b, c]` into an array of scalars.
+ * Normalize YAML-parsed values to match expected AKM frontmatter types.
+ *
+ * Two conversions:
+ * 1. `Date` → YYYY-MM-DD string: the yaml "core" schema parses bare date
+ *    scalars like `2026-06-18` as JS Date instances. AKM frontmatter treats
+ *    `updated:` and similar fields as plain strings.
+ * 2. `null` → `""`: the yaml library parses empty-value keys (`key:` with no
+ *    value) as `null`, but AKM callers historically received `""` from the
+ *    hand-rolled parser. Convert to preserve backward compatibility.
  */
-function parseFlowArray(value) {
-    const inner = value.slice(1, -1).trim();
-    if (!inner)
-        return [];
-    return inner.split(",").map((item) => parseYamlScalar(item.trim()));
+function normalizeYamlValues(value) {
+    if (value instanceof Date) {
+        const y = value.getUTCFullYear();
+        const m = String(value.getUTCMonth() + 1).padStart(2, "0");
+        const d = String(value.getUTCDate()).padStart(2, "0");
+        return `${y}-${m}-${d}`;
+    }
+    if (value === null)
+        return "";
+    if (Array.isArray(value))
+        return value.map(normalizeYamlValues);
+    if (typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, normalizeYamlValues(v)]));
+    }
+    return value;
+}
+/**
+ * Best-effort line-by-line frontmatter extraction for malformed YAML.
+ *
+ * Used as a fallback when yaml.parse throws (e.g. unterminated quotes from LLM
+ * output corruption). Extracts simple `key: value` scalar pairs only — nested
+ * objects and sequences are skipped. Values that are individually parseable by
+ * yaml are normalized; otherwise stored as raw strings.
+ */
+function parseFrontmatterLenient(frontmatter) {
+    const data = {};
+    for (const line of frontmatter.split(/\r?\n/)) {
+        const m = line.match(/^([\w][\w-]*):\s*(.*)$/);
+        if (!m)
+            continue;
+        const key = m[1];
+        const rawValue = (m[2] ?? "").trim();
+        try {
+            const singleEntry = yamlParse(`k: ${rawValue}`);
+            if (singleEntry !== null && typeof singleEntry === "object" && !Array.isArray(singleEntry)) {
+                const v = singleEntry.k;
+                data[key] = v === null || v === undefined ? "" : v;
+            }
+            else {
+                data[key] = rawValue;
+            }
+        }
+        catch {
+            data[key] = rawValue;
+        }
+    }
+    return data;
 }
 export function parseFrontmatterBlock(raw) {
     // Handle both LF and CRLF line endings throughout.
     // The closing --- may be preceded by \r\n; capture and strip trailing \r
     // from the frontmatter block so key parsing sees clean LF-terminated lines.
     const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r\n|\r|\n|$)([\s\S]*)$/);
-    if (!match)
-        return null;
-    // Strip any \r characters from the frontmatter block to normalise CRLF → LF
-    const frontmatter = match[1].replace(/\r/g, "");
-    const content = match[2];
-    return {
-        frontmatter,
-        content,
-        bodyStartLine: countLines(raw.slice(0, match[0].length - match[2].length)) + 1,
-    };
+    if (match) {
+        // Strip any \r characters from the frontmatter block to normalise CRLF → LF
+        const frontmatter = match[1].replace(/\r/g, "");
+        const content = match[2];
+        return {
+            frontmatter,
+            content,
+            bodyStartLine: countLines(raw.slice(0, match[0].length - match[2].length)) + 1,
+        };
+    }
+    // Empty frontmatter (---\n---): the content-bearing regex above requires at
+    // least one character between the fences. Handle the degenerate case so
+    // callers can reconstruct `---\nkey: val\n---\n\nbody` from a previously
+    // empty-frontmatter file without corrupting it by wrapping the entire raw
+    // string as body content.
+    const emptyMatch = raw.match(/^---\r?\n---(?:\r\n|\r|\n)([\s\S]*)$/);
+    if (emptyMatch) {
+        return { frontmatter: "", content: emptyMatch[1], bodyStartLine: 3 };
+    }
+    return null;
 }
 function countLines(text) {
     if (text.length === 0)
@@ -206,7 +139,13 @@ function countLines(text) {
     return text.split(/\r?\n/).length - 1;
 }
 /**
- * Parse a simple YAML scalar value (string, boolean, or number).
+ * Parse a YAML scalar value (string, boolean, or number).
+ *
+ * For quoted strings (single or double), delegates to the `yaml` library so
+ * escape sequences are handled correctly per spec. The previous hand-rolled
+ * `slice(1, -1)` only stripped one layer of quoting and left inner quotes and
+ * escape sequences as literal characters in the stored value, causing visible
+ * corruption when `yaml.stringify` re-quoted them on the next write.
  */
 export function parseYamlScalar(value) {
     if (value === "")
@@ -219,7 +158,67 @@ export function parseYamlScalar(value) {
     if (!Number.isNaN(asNumber))
         return asNumber;
     if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        try {
+            const parsed = yamlParse(value);
+            if (typeof parsed === "string")
+                return parsed;
+        }
+        catch {
+            // Fall through to raw slice on malformed YAML — better than throwing.
+        }
         return value.slice(1, -1);
     }
     return value;
 }
+// ── Minimum score delta to trigger a frontmatter salience rewrite ─────────────
+const SALIENCE_WRITE_DELTA_THRESHOLD = 0.05;
+/**
+ * Idempotently write `salience` and `salienceInputs` fields into the YAML
+ * frontmatter of a raw asset string.
+ *
+ * Skips the write when the existing `salience` field differs from `score` by
+ * less than {@link SALIENCE_WRITE_DELTA_THRESHOLD}, to avoid churn for minor
+ * floating-point drift. Returns the raw string unchanged when no write is needed
+ * or when no frontmatter block is present.
+ *
+ * The `salienceInputs` field is written for auditability only; no pipeline code
+ * reads it back. `state.db :: asset_salience` is the canonical store.
+ */
+export function writeSalienceToFrontmatter(raw, score, inputs) {
+    const parsed = parseFrontmatterBlock(raw);
+    if (!parsed)
+        return raw;
+    const existingData = parseFrontmatter(raw).data;
+    const existingSalience = typeof existingData.salience === "number" ? existingData.salience : undefined;
+    if (existingSalience !== undefined && Math.abs(existingSalience - score) < SALIENCE_WRITE_DELTA_THRESHOLD) {
+        return raw;
+    }
+    // Parse existing frontmatter into an object, then set/overwrite salience fields.
+    let fm = {};
+    if (parsed.frontmatter.trim()) {
+        try {
+            const p = yamlParse(parsed.frontmatter);
+            if (p !== null && typeof p === "object" && !Array.isArray(p)) {
+                fm = p;
+            }
+        }
+        catch {
+            // Malformed YAML — rebuild from best-effort parse
+            fm = parseFrontmatterLenient(parsed.frontmatter);
+        }
+    }
+    fm.salience = roundTo2dp(score);
+    fm.salienceInputs = {
+        novelty: roundTo2dp(inputs.novelty),
+        magnitude: roundTo2dp(inputs.magnitude),
+        predictionError: roundTo2dp(inputs.predictionError),
+    };
+    const newFrontmatter = yamlStringify(fm).trimEnd();
+    const body = parsed.content;
+    // Preserve original line ending style between frontmatter and body
+    const separator = body.startsWith("\n") ? "" : "\n";
+    return `---\n${newFrontmatter}\n---\n${separator}${body}`;
+}
+function roundTo2dp(n) {
+    return Math.round(n * 100) / 100;
+}

package/dist/core/asset/markdown.js

@@ -8,7 +8,15 @@ export function parseMarkdownToc(content) {
     const headings = [];
     const parsed = parseFrontmatter(content);
     const start = parsed.frontmatter ? parsed.bodyStartLine - 1 : 0;
+    let inFence = false;
     for (let i = start; i < lines.length; i++) {
+        // Track fenced code blocks (``` or ~~~) so headings inside them are skipped.
+        if (/^\s*(`{3,}|~{3,})/.test(lines[i])) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
         const match = lines[i].match(/^(#{1,6})\s+(.+)$/);
         if (match) {
             headings.push({

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

@@ -133,6 +133,34 @@ export const ImproveProcessConfigSchema = z
     // consolidation pass skips entirely (emits `pool_below_min_size`). 0 disables
     // the guard. Only meaningful on the `consolidate` process. Default 500.
     minPoolSize: z.number().int().min(0).optional(),
+    // Consolidate process: deterministic near-duplicate dedup pre-pass (#617).
+    // A cheap, no-LLM fast path that collapses obvious duplicates (`.derived`
+    // origin pairs + content twins) before the LLM consolidation. Default OFF
+    // — when absent the consolidate pass behaves byte-identically to today.
+    // `cosineThreshold` is a strict floor in [0, 1] (default 0.97) for the
+    // optional embedding-similarity match; exact normalized content-hash
+    // equality always collapses regardless of the threshold. Only meaningful
+    // on the `consolidate` process.
+    dedup: z
+        .object({
+        enabled: z.boolean().optional(),
+        cosineThreshold: z.number().min(0).max(1).optional(),
+        // WS-3a: maximum pool size for the O(n²) cosine-similarity twin compare.
+        // Only the first `cosineCandidateLimit` memories are cosine-compared;
+        // exact-hash matches still run over the full pool. Default 500. Raise
+        // with care — cost is O(n²).
+        cosineCandidateLimit: z.number().int().positive().optional(),
+    })
+        .strict()
+        .optional(),
+    // Consolidate process: judged-state cache (#581). When enabled, a memory
+    // whose current content hash equals its cached judged hash is SKIPPED from
+    // the LLM pool (judged-unchanged → no re-judge), letting one run sweep the
+    // whole corpus at O(changed/new) cost instead of narrowing to a recent
+    // time-window slice. Default OFF — when absent the consolidate pass behaves
+    // byte-identically to today (the incrementalSince path is unaffected). Only
+    // meaningful on the `consolidate` process.
+    judgedCache: z.object({ enabled: z.boolean().optional() }).strict().optional(),
     qualityGate: z.object({ enabled: z.boolean().optional() }).strict().optional(),
     contradictionDetection: z.object({ enabled: z.boolean().optional() }).strict().optional(),
     // Extract process config (only meaningful for extract process)
@@ -162,9 +190,6 @@ export const ImproveProcessConfigSchema = z
     // proactiveMaintenance process: top-N bound per run (default 25). Alias for
     // `limit`; `maxPerRun` wins when both are set.
     maxPerRun: positiveInt.optional(),
-    // proactiveMaintenance process: optional per-type importance overrides,
-    // merged over the built-in defaults. Only meaningful on `proactiveMaintenance`.
-    importanceWeights: z.record(z.string().min(1), z.number()).optional(),
     // MemoryInference process: minimum pending memory count to run the pass.
     minPendingCount: z.number().int().min(0).optional(),
     // Extract process: minimum number of new (unseen, in-window) candidate
@@ -182,6 +207,114 @@ export const ImproveProcessConfigSchema = z
     // #561 — minimum session duration in minutes for session indexing. 0
     // disables the gate. Absent = default 5. Only meaningful on `extract`.
     minSessionDuration: z.number().min(0).optional(),
+    // Consolidate process: fallback p90 wall-clock time per consolidation chunk
+    // in seconds, used for cold-start budget estimation when no telemetry
+    // history exists. The actual p90 is derived from observed run durations
+    // once sufficient history accumulates; this value is only used on the very
+    // first run. Default 30 s. Only meaningful on the `consolidate` process.
+    p90ChunkSecondsDefault: z.number().finite().positive().optional(),
+    // WS-3b: Homeostatic demotion (step 0a). Before any LLM merge, demote
+    // retrievalSalience for stale/low-value assets so the merge pool is bounded
+    // and high-SNR. Demotion is state.db-only (file content untouched);
+    // re-promotable on re-retrieval. Default OFF. Only meaningful on the
+    // `consolidate` process.
+    homeostaticDemotion: z
+        .object({
+        enabled: z.boolean().optional(),
+        // Minimum days since last retrieval to consider an asset stale (default 30).
+        staleDays: z.number().int().min(0).optional(),
+        // Demotion factor: multiply retrievalSalience by this when stale (default 0.5).
+        demotionFactor: z.number().min(0).max(1).optional(),
+    })
+        .strict()
+        .optional(),
+    // WS-3b: Schema-similarity gate (step 0b). At intake, if a new candidate's
+    // body embedding is within epsilon of an existing derived-layer lesson/knowledge
+    // node, mark it schema-consistent and lower its priority. Default OFF.
+    // Only meaningful on the `consolidate` and `extract` processes.
+    schemaSimilarity: z
+        .object({
+        enabled: z.boolean().optional(),
+        // Epsilon: cosine similarity threshold above which a candidate is schema-consistent
+        // (default 0.85 — looser than dedup's 0.97 since we want to catch conceptual overlap).
+        epsilon: z.number().min(0).max(1).optional(),
+        // Multiplicative factor applied to candidate confidence when schema-consistent.
+        // Default 0.5 — halves the confidence so schema-consistent candidates are less likely
+        // to pass the quality gate and create redundant stash entries.
+        confidencePenalty: z.number().min(0).max(1).optional(),
+    })
+        .strict()
+        .optional(),
+    // WS-3b: Hot-probation intake buffer (step 0c, #604). New system-generated
+    // extractions enter captureMode: hot-probation and spend ONE consolidation
+    // cycle in probation. Dedup + quality second-pass runs before promotion.
+    // Default OFF. Only meaningful on the `extract` process.
+    hotProbation: z
+        .object({
+        enabled: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+    // WS-3b: Anti-collapse guards (step 8). Prevents the consolidation pipeline
+    // from collapsing too aggressively and losing diversity.
+    //   - 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).
+    // Default OFF. Only meaningful on the `consolidate` process.
+    antiCollapse: 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(),
+    })
+        .strict()
+        .optional(),
+    // WS-3b: CLS (Complementary Learning System) interleaving (step 9).
+    // distill/memoryInference prompts include embedding-retrieved existing adjacent
+    // lessons/knowledge to prevent catastrophic interference with prior generalizations.
+    // Default OFF. Only meaningful on `distill` and `memoryInference` processes.
+    cls: z
+        .object({
+        enabled: z.boolean().optional(),
+        // Number of adjacent lessons/knowledge to include in prompts (default 3).
+        adjacentCount: z.number().int().min(1).optional(),
+    })
+        .strict()
+        .optional(),
+    // WS-3b: Distill→source fidelity check (step 10). After a distill proposal,
+    // check it against its cited source memories; a contradiction flag forces
+    // human review. Default OFF. Only meaningful on `distill` process.
+    fidelityCheck: z
+        .object({
+        enabled: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+    // #609 — recombine process: minimum related-memory cluster size before an
+    // LLM generalization call. Default 3. Only meaningful on `recombine`.
+    minClusterSize: z.number().int().min(2).optional(),
+    // #609 — recombine process: hard cap on clusters processed per run (one
+    // bounded LLM call each). Default 5. Only meaningful on `recombine`.
+    maxClustersPerRun: positiveInt.optional(),
+    // #609 — recombine process: relatedness signal used to form clusters
+    // (tags | graph | both). Clustering is by relatedness, never embedding
+    // similarity. Default "tags". Only meaningful on `recombine`.
+    relatednessSource: z.enum(["tags", "graph", "both"]).optional(),
+    // #609 — recombine process: consecutive re-inductions required before a
+    // hypothesis is promoted to a lesson. Default 2. Only meaningful on
+    // `recombine`.
+    confirmThreshold: z.number().int().min(1).optional(),
+    // #615 — procedural process: minimum number of distinct assets sharing the
+    // same successful normalized ordered-action sequence before it is compiled
+    // into a workflow proposal. Default 3. Only meaningful on `procedural`.
+    minRecurrence: z.number().int().min(2).optional(),
+    // #615 — procedural process: hard cap on workflow proposals emitted per run
+    // (one bounded LLM call each). Default 3. Only meaningful on `procedural`.
+    maxProposalsPerRun: positiveInt.optional(),
+    // #615 — procedural process: asset type a compiled sequence is emitted as.
+    // Reserved; v1 always emits "workflow". Only meaningful on `procedural`.
+    emitAs: z.enum(["workflow", "skill"]).optional(),
     // Triage process config (only meaningful for the `triage` process)
     applyMode: z.enum(["queue", "promote"]).optional(),
     policy: z.string().min(1).optional(),
@@ -208,6 +341,8 @@ const ImproveProfileProcessesSchema = z
     validation: ImproveProcessConfigSchema.optional(),
     triage: ImproveProcessConfigSchema.optional(),
     proactiveMaintenance: ImproveProcessConfigSchema.optional(),
+    recombine: ImproveProcessConfigSchema.optional(),
+    procedural: ImproveProcessConfigSchema.optional(),
 })
     .passthrough()
     .superRefine((val, ctx) => {
@@ -232,6 +367,8 @@ const ImproveProfileProcessesSchema = z
         "extract",
         "triage",
         "proactiveMaintenance",
+        "recombine",
+        "procedural",
     ]);
     for (const k of Object.keys(raw)) {
         if (!allowed.has(k)) {
@@ -249,6 +386,12 @@ export const ImproveProfileConfigSchema = z
     processes: ImproveProfileProcessesSchema.optional(),
     autoAccept: nonNegativeNumber.optional(),
     limit: positiveInt.optional(),
+    // #614 — symmetric valence weighting in the eligibility sort. When true,
+    // the attention term becomes |valence| MAGNITUDE so BOTH strong positive
+    // and strong negative feedback drive attention (utility stays dominant) and
+    // strong-signed assets are routed to a fix/reinforce lane. DEFAULT OFF —
+    // false/absent preserves the legacy negative-only ranking byte-for-byte.
+    symmetricValence: z.boolean().optional(),
     sync: z
         .object({
         enabled: z.boolean().optional(),
@@ -365,6 +508,7 @@ const SearchGraphBoostSchema = z
 export const SearchConfigSchema = z
     .object({
     minScore: nonNegativeNumber.optional(),
+    defaultExcludeTypes: z.array(nonEmptyString).optional(),
     curateRerank: z.object({ enabled: z.boolean().optional() }).strict().optional(),
     graphBoost: SearchGraphBoostSchema.optional(),
 })
@@ -383,10 +527,74 @@ const ImproveUtilityDecaySchema = z
     feedbackStabilityBoost: z.number().finite().min(1).optional(),
 })
     .strict();
+// #612 / WS-4 — auto-accept gate calibration + bounded, opt-in per-phase
+// threshold auto-tune. DEFAULT OFF: when absent (or `autoTune: false`) no
+// tuning occurs, so the gate behaves byte-identically to today.
+// WS-4 adds: per-phase persistence (state.db) + auto-tune ceiling default 85.
+const ImproveCalibrationSchema = z
+    .object({
+    /** Master switch for the bounded threshold auto-tune. Default false (parity). */
+    autoTune: z.boolean().optional(),
+    /** Lower bound (0-100) the tuned threshold may never drop below. */
+    minThreshold: z.number().int().min(0).max(100).optional(),
+    /**
+     * Upper bound (0-100) the tuned threshold may never rise above.
+     * WS-4 default: 85 (prevents gate converging to pure exploitation).
+     */
+    maxThreshold: z.number().int().min(0).max(100).optional(),
+    /** Maximum adjustment magnitude (points) applied in one tune step. */
+    maxStep: positiveInt.optional(),
+    /** Minimum acted-on sample count required before any adjustment. */
+    minSamples: nonNegativeNumber.optional(),
+    /** Target realized accept rate in [0, 1]. Default 0.9. */
+    targetAcceptRate: z.number().finite().min(0).max(1).optional(),
+})
+    .strict();
+// WS-4 — exploration budget: a fixed fraction of proposals accepted per run
+// regardless of confidence. DEFAULT OFF.
+const ImproveExplorationSchema = z
+    .object({
+    /**
+     * Enable the exploration budget lane. Default false (parity).
+     * When true, a fraction of proposals are accepted regardless of confidence.
+     */
+    enabled: z.boolean().optional(),
+    /**
+     * Fraction of proposals per run to accept as exploration [0, 1].
+     * Default 0.05 (5%). Clamped to [0, 1] at read time.
+     */
+    budgetFraction: z.number().finite().min(0).max(1).optional(),
+})
+    .strict();
+const ImproveSalienceSchema = z
+    .object({
+    /**
+     * WS-2 Part-V gate: enable the outcome-weight term in the salience projection.
+     * Default false (parity — WS-1 weights w_e=0.30, w_r=0.70 until Part-V confirms
+     * no regression). Set to true after running scripts/akm-eval + health report.
+     */
+    outcomeWeightEnabled: z.boolean().optional(),
+    /**
+     * Minimum encoding salience score [0, 1] for a zero-feedback asset to be
+     * admitted to the high-salience improve lane (#608).
+     * Default 0.75. Set to 1.0 to disable the lane entirely.
+     */
+    salienceThreshold: z.number().min(0).max(1).optional(),
+    /**
+     * Per-run additive replay budget (#610). Up to this many top-salience refs are
+     * revisited even with no reactive signal and regardless of cooldown. Additive
+     * on top of --limit. Default 0 = no replay.
+     */
+    replayBudget: z.number().int().min(0).optional(),
+})
+    .strict();
 export const ImproveConfigSchema = z
     .object({
     utilityDecay: ImproveUtilityDecaySchema.optional(),
     eventRetentionDays: nonNegativeNumber.optional(),
+    calibration: ImproveCalibrationSchema.optional(),
+    exploration: ImproveExplorationSchema.optional(),
+    salience: ImproveSalienceSchema.optional(),
 })
     .strict();
 // ── Index / per-pass ────────────────────────────────────────────────────────