simt-dev 0.3.1 → 0.5.0

package/src/index/store.mjs

@@ -9,12 +9,16 @@ import { stat } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
 import { readManifest } from '../projection/manifest.mjs';
+import { readLocalConfig } from '../local/config.mjs';
+import { localEmbed } from '../local/client.mjs';
 import { extract, resolveImports } from './extract.mjs';
 import {
   JSONL_FILE,
   SCHEMA_V,
   SQLITE_FILE,
   countSqlite,
+  decodeVectorBlob,
+  encodeVectorBlob,
   readJsonl,
   readSchema,
   readSqliteRows,
@@ -22,7 +26,7 @@ import {
   writeSqlite,
 } from './persist.mjs';
 
-export { JSONL_FILE, SQLITE_FILE };
+export { JSONL_FILE, SQLITE_FILE, decodeVectorBlob, encodeVectorBlob };
 
 const MARKERS = ['package.json', 'pyproject.toml', 'go.mod', 'Cargo.toml', 'pom.xml'];
 
@@ -45,11 +49,64 @@ async function probeBackend() {
   }
 }
 
+export function ftsKindOf(filePath, lang = '') {
+  if (filePath.startsWith('docs/decisions/')) return 'decisions';
+  if (filePath.startsWith('docs/lessons/')) return 'lessons';
+  if (filePath.includes('skills') && (filePath.endsWith('.md') || filePath.endsWith('.json'))) return 'skills';
+  if (lang) return 'code';
+  return 'docs';
+}
+
+export function buildFtsBody(filePath, symbolsForPath = [], text = null) {
+  const tokens = [];
+  for (const part of String(filePath ?? '').toLowerCase().split(/[^a-z0-9]+/)) {
+    if (part.length >= 2) tokens.push(part);
+  }
+  for (const s of symbolsForPath) {
+    if (s?.name) tokens.push(s.name, s.name);
+    if (s?.sig) tokens.push(s.sig);
+  }
+  if (typeof text === 'string' && text.length > 0) {
+    const head = text.slice(0, 24000);
+    const seen = new Map();
+    for (const m of head.matchAll(/[A-Za-z][A-Za-z0-9_-]{2,}/g)) {
+      const w = m[0].toLowerCase();
+      const c = (seen.get(w) ?? 0) + 1;
+      if (c <= 6) {
+        seen.set(w, c);
+        tokens.push(w);
+      }
+      if (seen.size >= 600) break;
+    }
+  }
+  return tokens.join(' ');
+}
+
+const FTS_STOP = new Set([
+  'this', 'that', 'with', 'from', 'have', 'been', 'into', 'only', 'when', 'what',
+  'which', 'their', 'about', 'after', 'before', 'where', 'there', 'these', 'those',
+  'would', 'could', 'should', 'every', 'other', 'than', 'then', 'them', 'they',
+  'your', 'will', 'does', 'file', 'files', 'test', 'tests', 'line', 'lines', 'code',
+  'also', 'just', 'more', 'some', 'such', 'each', 'same', 'over', 'used', 'using',
+  'the', 'and', 'for', 'not', 'are', 'was', 'were', 'has', 'had', 'but', 'can', 'one', 'two',
+]);
+
+export function ftsQueryTerms(task) {
+  return [
+    ...new Set(
+      String(task ?? '')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((w) => w.length >= 3 && !FTS_STOP.has(w)),
+    ),
+  ].slice(0, 48);
+}
+
 /**
  * Rebuild the index from the git index. Unchanged blobs are left as they are.
  *
  * @param {string} root
- * @param {{backend?: 'sqlite'|'jsonl'}} [opts]
+ * @param {{backend?: 'sqlite'|'jsonl', embed?: boolean, allowRemote?: boolean, fetchImpl?: typeof fetch}} [opts]
  */
 export async function reindex(root, opts = {}) {
   const started = Date.now();
@@ -91,16 +148,25 @@ export async function reindex(root, opts = {}) {
       : await runExtract(entry.path, text, lang, adapter.module);
     symbols.push(...pulled.symbols);
     edges.push(...(pulled.edges ?? resolveImports(entry.path, pulled.imports, paths, lang)));
-    const names = [...new Set(pulled.symbols.map((row) => row.name))].sort();
-    if (names.length > 0) fts.push({ kind: 'code', ref: entry.path, body: names.join(' ') });
+    const body = buildFtsBody(entry.path, pulled.symbols, text);
+    if (body.length > 0) {
+      fts.push({ kind: ftsKindOf(entry.path, lang), ref: entry.path, body });
+    }
   }
   const removed = previous.filter((row) => !paths.has(row.path)).map((row) => row.path);
+  const embedBuild = await buildEmbeddings(root, listed, fts, {
+    backend,
+    force,
+    embed: opts.embed === true,
+    allowRemote: opts.allowRemote === true,
+    fetchImpl: opts.fetchImpl,
+  });
   let stored;
   if (backend === 'sqlite') {
-    await writeSqlite(root, next, removed, symbols, edges, fts);
+    await writeSqlite(root, next, removed, symbols, edges, fts, embedBuild.rows);
     stored = await countSqlite(root);
   } else {
-    stored = await writeJsonl(root, previous, next, removed, symbols, edges, fts, force);
+    stored = await writeJsonl(root, previous, next, removed, symbols, edges, fts, force, embedBuild.rows);
   }
   return {
     backend,
@@ -109,11 +175,67 @@ export async function reindex(root, opts = {}) {
     removed: removed.length,
     symbols: stored.symbols,
     edges: stored.edges,
+    embeddings: stored.embeddings ?? 0,
+    embedState: embedBuild.state,
     parsers: adapter.state,
     ms: Date.now() - started,
   };
 }
 
+async function buildEmbeddings(root, listed, changedFts, { backend, force, embed, allowRemote, fetchImpl }) {
+  if (!embed) return { state: 'off', rows: [] };
+  const localCfg = await readLocalConfig(root, { allowRemote });
+  if (!localCfg.embed) return { state: 'off', rows: [] };
+  if (localCfg.embed.blocked) return { state: 'refused-remote', rows: [] };
+
+  const existingEmbeds = force ? [] : await readEmbeddings(root, { backend });
+  const embedByPath = new Map(existingEmbeds.map((row) => [row.path, row]));
+  const ftsByPath = new Map(changedFts.map((row) => [row.ref, row.body]));
+  const missingEntries = [];
+  for (const entry of listed) {
+    const prev = embedByPath.get(entry.path);
+    if (prev && prev.blob === entry.blob && prev.model === localCfg.embed.model && prev.vec.length > 0) {
+      continue;
+    }
+    missingEntries.push(entry);
+  }
+  if (missingEntries.length === 0) return { state: 'cached', rows: [] };
+
+  // Ensure FTS summaries are available for any entry that did not change in this pass.
+  const needFts = missingEntries.some((entry) => !ftsByPath.has(entry.path));
+  if (needFts) {
+    const storedFts = await readFts(root, { backend });
+    for (const row of storedFts) {
+      if (!ftsByPath.has(row.ref)) ftsByPath.set(row.ref, row.body);
+    }
+  }
+
+  const rows = [];
+  const batchSize = 32;
+  for (let i = 0; i < missingEntries.length; i += batchSize) {
+    const slice = missingEntries.slice(i, i + batchSize);
+    const inputs = slice.map((entry) => {
+      const summary = ftsByPath.get(entry.path) ?? entry.path;
+      return `${entry.path}\n${summary}`.slice(0, 4096);
+    });
+    const res = await localEmbed(localCfg.embed, { input: inputs, allowRemote, fetchImpl });
+    if (!res.ok || res.embeddings.length !== slice.length) {
+      return { state: 'failed', rows };
+    }
+    for (let j = 0; j < slice.length; j += 1) {
+      const vec = res.embeddings[j];
+      rows.push({
+        path: slice[j].path,
+        blob: slice[j].blob,
+        model: res.model ?? localCfg.embed.model,
+        dims: vec.length,
+        vec: encodeVectorBlob(vec),
+      });
+    }
+  }
+  return { state: 'embedded', rows };
+}
+
 /** File rows, sorted by path. The same blobs read back as the same rows. */
 export async function readFiles(root, opts = {}) {
   const backend = opts.backend ?? await probeBackend();
@@ -135,7 +257,99 @@ export async function readEdges(root, opts = {}) {
   return readJsonl(root, 'edges');
 }
 
-function langOf(filePath) {
+/** FTS rows currently indexed. */
+export async function readFts(root, opts = {}) {
+  const backend = opts.backend ?? await probeBackend();
+  if (backend === 'sqlite') return readSqliteRows(root, 'select kind, ref, body from fts order by ref, kind');
+  return readJsonl(root, 'fts');
+}
+
+/** Stored vector embeddings, decoded as Float32Array per path. */
+export async function readEmbeddings(root, opts = {}) {
+  const backend = opts.backend ?? await probeBackend();
+  if (backend === 'sqlite') {
+    const raw = await readSqliteRows(root, 'select path, blob, model, dims, vec from embeddings order by path');
+    return raw.map((row) => {
+      const vec = decodeVectorBlob(row.vec);
+      return {
+        path: row.path,
+        blob: row.blob ?? '',
+        model: row.model ?? '',
+        dims: Number.isInteger(row.dims) ? row.dims : vec.length,
+        vec,
+      };
+    });
+  }
+  return readJsonl(root, 'embeddings');
+}
+
+/**
+ * Rank indexed documents against a task string using BM25.
+ *
+ * Uses SQLite FTS5 `bm25(fts)` when the sqlite backend is active on disk, and
+ * falls back to an identical Okapi BM25 computation over `fts` rows otherwise.
+ */
+export async function searchFtsBm25(root, task, opts = {}) {
+  const terms = ftsQueryTerms(task);
+  if (terms.length === 0) return [];
+  const backend = opts.backend ?? await probeBackend();
+  if (backend === 'sqlite') {
+    const matchExpr = terms.map((t) => `"${t}"`).join(' OR ');
+    const rows = await readSqliteRows(
+      root,
+      'select kind, ref as path, -bm25(fts) as score from fts where fts match ? order by score desc, path asc',
+      [matchExpr],
+    );
+    if (rows.length > 0) {
+      return rows.map((row) => ({ kind: row.kind, path: row.path, score: Number(row.score) || 0 }));
+    }
+  }
+  const ftsRows = opts.fts ?? await readFts(root, { backend });
+  return scoreFtsBm25(ftsRows, task);
+}
+
+/**
+ * Deterministic Okapi BM25 ranking over FTS rows (`{ kind, ref, body }`).
+ */
+export function scoreFtsBm25(ftsRows, task) {
+  const terms = ftsQueryTerms(task);
+  if (terms.length === 0 || !Array.isArray(ftsRows) || ftsRows.length === 0) return [];
+  const k1 = 1.2;
+  const b = 0.75;
+  const N = ftsRows.length;
+  const docs = ftsRows.map((row) => {
+    const path = row.ref ?? row.path ?? '';
+    const words = `${row.kind ?? ''} ${path} ${row.body ?? ''}`
+      .toLowerCase()
+      .split(/[^a-z0-9_]+/)
+      .filter(Boolean);
+    const tf = new Map();
+    for (const w of words) tf.set(w, (tf.get(w) ?? 0) + 1);
+    return { kind: row.kind ?? 'code', path, len: words.length, tf };
+  });
+  const avgdl = docs.reduce((sum, d) => sum + d.len, 0) / N || 1;
+  const df = new Map();
+  for (const term of terms) {
+    let n = 0;
+    for (const d of docs) if (d.tf.has(term)) n += 1;
+    df.set(term, n);
+  }
+  const out = [];
+  for (const d of docs) {
+    let score = 0;
+    for (const term of terms) {
+      const f = d.tf.get(term) ?? 0;
+      if (f === 0) continue;
+      const n = df.get(term) ?? 0;
+      const idf = Math.max(1e-6, Math.log((N - n + 0.5) / (n + 0.5)));
+      score += idf * ((f * (k1 + 1)) / (f + k1 * (1 - b + b * (d.len / avgdl))));
+    }
+    if (score > 0) out.push({ kind: d.kind, path: d.path, score });
+  }
+  return out.sort((a, b) => b.score - a.score || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}
+
+export function langOf(filePath) {
   const base = filePath.slice(filePath.lastIndexOf('/') + 1);
   const dot = base.lastIndexOf('.');
   if (dot <= 0) return '';
@@ -263,7 +477,7 @@ function normalise(filePath, got) {
   return { symbols, imports: Array.isArray(got.imports) ? got.imports : [], edges };
 }
 
-async function blobTexts(root, blobs) {
+export async function blobTexts(root, blobs) {
   const unique = [...new Set(blobs)];
   const texts = new Map();
   if (unique.length === 0) return texts;

package/src/kernel/variants.mjs

@@ -0,0 +1,353 @@
+// Rule text variant parsing, validation, and deterministic projection folding
+// (plan 0003 R35).
+//
+// A rule line or list item may carry `<!-- simt-variants: <slot> <spec> -->`.
+// When unlocked, projection uses the baseline variant (`a`, or the line's own
+// prose) and strips the marker so `simt-` annotations never reach a reader.
+// When `simt-dev.lock.json` records a locked winner for `<ruleId>.<slot>`,
+// projection deterministically renders that winning variant.
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export const VARIANTS_MARKER = 'simt-variants';
+const LOCK_FILE_NAME = 'simt-dev.lock.json';
+
+/**
+ * Read the locked `variants` map from `simt-dev.lock.json` in `root`, or `{}` when absent.
+ */
+export async function readLockedVariants(root) {
+  if (!root) return {};
+  try {
+    const raw = await readFile(join(root, LOCK_FILE_NAME), 'utf8');
+    const parsed = JSON.parse(raw);
+    if (
+      parsed &&
+      typeof parsed === 'object' &&
+      parsed.variants &&
+      typeof parsed.variants === 'object' &&
+      !Array.isArray(parsed.variants)
+    ) {
+      return parsed.variants;
+    }
+  } catch {
+    // Missing or unreadable lockfile falls back to baseline variants.
+  }
+  return {};
+}
+
+const MARKER = /<!--\s*simt-variants:\s*([\s\S]*?)\s*-->/g;
+const MARKER_AT = /\s*<!--\s*simt-variants:\s*[\s\S]*?-->/g;
+const HAS_MARKER = /<!--\s*simt-variants:/;
+const ITEM_START = /^(\s*)((?:[-*]|\d+\.)\s+)/;
+const SLOT_ID_RE = /^[A-Za-z0-9._-]+$/;
+const VARIANT_KEY_RE = /^[A-Za-z0-9_-]+$/;
+
+function fenced(unit) {
+  return /^\s*(```|~~~)/.test(unit);
+}
+
+function markersIn(unit) {
+  return [...unit.matchAll(MARKER)].map((m) => m[1]);
+}
+
+function stripMarkers(unit) {
+  return unit.replace(MARKER_AT, '').replace(/[ \t]+$/gm, '');
+}
+
+/** Lines of a body, fences kept whole, list items split from their neighbours. */
+function units(body) {
+  const lines = String(body ?? '').split('\n');
+  const out = [];
+  let inFence = false;
+  let current = [];
+  const flush = () => {
+    if (current.length > 0) out.push(current.join('\n'));
+    current = [];
+  };
+  for (const line of lines) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      if (!inFence) flush();
+      current.push(line);
+      inFence = !inFence;
+      if (!inFence) flush();
+      continue;
+    }
+    if (inFence) {
+      current.push(line);
+      continue;
+    }
+    if (line.trim() === '') {
+      flush();
+      out.push(line);
+      continue;
+    }
+    if (ITEM_START.test(line) && current.length > 0) flush();
+    current.push(line);
+  }
+  flush();
+  return out;
+}
+
+function stripItemPrefix(text) {
+  const m = ITEM_START.exec(text);
+  if (!m) return { indent: '', bullet: '', content: text.trim() };
+  return {
+    indent: m[1],
+    bullet: m[2],
+    content: text.slice(m[0].length).trim(),
+  };
+}
+
+function qualifySlotId(ruleId, rawSlot) {
+  const slot = String(rawSlot ?? '').trim();
+  if (!slot) return { slotId: '', shortId: '' };
+  const prefix = ruleId ? `${ruleId}.` : '';
+  if (prefix && slot.startsWith(prefix)) {
+    return { slotId: slot, shortId: slot.slice(prefix.length) };
+  }
+  if (slot.includes('.')) {
+    const dot = slot.indexOf('.');
+    return { slotId: slot, shortId: slot.slice(dot + 1) };
+  }
+  return {
+    slotId: prefix ? `${prefix}${slot}` : slot,
+    shortId: slot,
+  };
+}
+
+function parseKvPairs(rawSpec) {
+  const map = {};
+  const pairRe = /([A-Za-z0-9_-]+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')/g;
+  let matched = 0;
+  for (const m of rawSpec.matchAll(pairRe)) {
+    const key = m[1];
+    const val = (m[2] ?? m[3] ?? '').replace(/\\(["'\\])/g, '$1').trim();
+    map[key] = val;
+    matched += 1;
+  }
+  if (matched === 0) return null;
+  const leftover = rawSpec.replace(pairRe, '').replace(/[|\s,]+/g, '').trim();
+  if (leftover !== '') return null;
+  return map;
+}
+
+/**
+ * Parse one `simt-variants` marker expression together with the stripped unit text.
+ */
+export function parseVariantSpec(expr, ruleId = '', strippedUnit = '') {
+  const raw = String(expr ?? '').trim();
+  if (!raw) {
+    return { error: `${VARIANTS_MARKER} is empty; name a slot and its variants` };
+  }
+
+  let rawSlot = '';
+  let rawMap = null;
+
+  if (raw.startsWith('{')) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      return { error: `${VARIANTS_MARKER} JSON is invalid (${error.message})` };
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return { error: `${VARIANTS_MARKER} must be a JSON object` };
+    }
+    const keys = Object.keys(parsed);
+    if (
+      keys.length === 1 &&
+      parsed[keys[0]] &&
+      typeof parsed[keys[0]] === 'object' &&
+      !Array.isArray(parsed[keys[0]])
+    ) {
+      rawSlot = keys[0];
+      rawMap = parsed[keys[0]];
+    } else if (typeof parsed.id === 'string' || typeof parsed.slot === 'string') {
+      rawSlot = String(parsed.id ?? parsed.slot);
+      rawMap = {};
+      for (const [k, v] of Object.entries(parsed)) {
+        if (k === 'id' || k === 'slot') continue;
+        rawMap[k] = v;
+      }
+    } else {
+      return { error: `${VARIANTS_MARKER} JSON object must name a slot id` };
+    }
+  } else {
+    const firstSpace = raw.search(/\s/);
+    if (firstSpace === -1) {
+      return { error: `${VARIANTS_MARKER} "${raw}" names a slot but no variants` };
+    }
+    rawSlot = raw.slice(0, firstSpace).trim();
+    const rest = raw.slice(firstSpace + 1).trim();
+    if (rest.startsWith('{')) {
+      try {
+        rawMap = JSON.parse(rest);
+      } catch (error) {
+        return { error: `${VARIANTS_MARKER} "${rawSlot}" has invalid JSON (${error.message})` };
+      }
+      if (!rawMap || typeof rawMap !== 'object' || Array.isArray(rawMap)) {
+        return { error: `${VARIANTS_MARKER} "${rawSlot}" must map variant keys to strings` };
+      }
+    } else {
+      rawMap = parseKvPairs(rest);
+      if (!rawMap) {
+        return {
+          error: `${VARIANTS_MARKER} "${rawSlot}" must specify variants as JSON or key="text" pairs`,
+        };
+      }
+    }
+  }
+
+  const { slotId, shortId } = qualifySlotId(ruleId, rawSlot);
+  if (!slotId || !shortId || !SLOT_ID_RE.test(slotId) || !SLOT_ID_RE.test(shortId)) {
+    return { error: `${VARIANTS_MARKER} has invalid slot id "${rawSlot}"` };
+  }
+
+  const { indent, bullet, content: baseProse } = stripItemPrefix(strippedUnit);
+  const variants = {};
+
+  if (baseProse !== '' && rawMap.a === undefined) {
+    variants.a = baseProse;
+  }
+
+  for (const [k, v] of Object.entries(rawMap)) {
+    if (!VARIANT_KEY_RE.test(k)) {
+      return { error: `${VARIANTS_MARKER} "${slotId}" has invalid variant key "${k}"` };
+    }
+    if (typeof v !== 'string' || v.trim() === '') {
+      return { error: `${VARIANTS_MARKER} "${slotId}" variant "${k}" must be a non-empty string` };
+    }
+    const { content } = stripItemPrefix(v.trim());
+    variants[k] = content;
+  }
+
+  const variantKeys = Object.keys(variants);
+  if (variantKeys.length < 2) {
+    return {
+      error: `${VARIANTS_MARKER} "${slotId}" needs at least 2 variants (found ${variantKeys.length})`,
+    };
+  }
+
+  const baseline = variants.a !== undefined ? 'a' : variantKeys[0];
+  return {
+    slotId,
+    shortId,
+    ruleId: ruleId || (slotId.includes('.') ? slotId.slice(0, slotId.indexOf('.')) : ''),
+    baseline,
+    variants,
+    indent,
+    bullet,
+    error: null,
+  };
+}
+
+/**
+ * Report the first defect in a rule body's `simt-variants` markers, or null.
+ */
+export function variantsDefect(body, ruleId = '') {
+  const seenSlots = new Set();
+  for (const unit of units(body)) {
+    if (fenced(unit)) continue;
+    const found = markersIn(unit);
+    if (found.length === 0) continue;
+    if (found.length > 1) {
+      return `carries more than one ${VARIANTS_MARKER} marker on one item; one item is one variant slot`;
+    }
+    const stripped = stripMarkers(unit);
+    const parsed = parseVariantSpec(found[0], ruleId, stripped);
+    if (parsed.error) return parsed.error;
+    if (seenSlots.has(parsed.slotId)) {
+      return `declares duplicate ${VARIANTS_MARKER} slot "${parsed.slotId}"`;
+    }
+    seenSlots.add(parsed.slotId);
+  }
+  return null;
+}
+
+/**
+ * Extract all declared variant slots from a rule (`{id, source, body}`).
+ */
+export function extractVariantsFromRule(rule) {
+  const body = String(rule?.body ?? '');
+  const ruleId = String(rule?.id ?? '');
+  if (!HAS_MARKER.test(body) || variantsDefect(body, ruleId) !== null) return [];
+  const slots = [];
+  for (const unit of units(body)) {
+    if (fenced(unit)) continue;
+    const found = markersIn(unit);
+    if (found.length !== 1) continue;
+    const stripped = stripMarkers(unit);
+    const parsed = parseVariantSpec(found[0], ruleId, stripped);
+    if (parsed.error) continue;
+    slots.push({
+      slotId: parsed.slotId,
+      shortId: parsed.shortId,
+      ruleId: parsed.ruleId,
+      source: rule?.source ?? null,
+      baseline: parsed.baseline,
+      variants: parsed.variants,
+    });
+  }
+  return slots;
+}
+
+function lookupLockedWinner(lockedVariants, slotId, shortId) {
+  if (!lockedVariants || typeof lockedVariants !== 'object') return null;
+  const entry = lockedVariants[slotId] ?? (shortId ? lockedVariants[shortId] : undefined);
+  if (typeof entry === 'string') return { winner: entry, entry: { winner: entry } };
+  if (entry && typeof entry === 'object') {
+    const w = entry.winner ?? entry.variant;
+    if (typeof w === 'string' && w !== '') return { winner: w, entry };
+  }
+  return null;
+}
+
+/**
+ * Resolve every `simt-variants` slot in `body` using `lockedVariants` (or the baseline
+ * variant when unlocked) and strip the marker comments.
+ *
+ * When `body` carries no `simt-variants` marker, returns `body` by identity so
+ * untouched rules do not move a byte.
+ *
+ * @returns {{body: string, selected: {slotId: string, winner: string, baseline: string, locked: boolean, entry: object|null}[], changed: boolean}}
+ */
+export function foldVariants(body, ruleId = '', lockedVariants = null) {
+  if (!HAS_MARKER.test(body) || variantsDefect(body, ruleId) !== null) {
+    return { body, selected: [], changed: false };
+  }
+
+  const selected = [];
+  const kept = [];
+
+  for (const unit of units(body)) {
+    const found = fenced(unit) ? [] : markersIn(unit);
+    if (found.length === 0) {
+      kept.push(unit);
+      continue;
+    }
+    const stripped = stripMarkers(unit);
+    const parsed = parseVariantSpec(found[0], ruleId, stripped);
+    if (parsed.error) {
+      kept.push(stripped);
+      continue;
+    }
+
+    const locked = lookupLockedWinner(lockedVariants, parsed.slotId, parsed.shortId);
+    const hasLockedKey = locked !== null && Object.hasOwn(parsed.variants, locked.winner);
+    const chosenKey = hasLockedKey ? locked.winner : parsed.baseline;
+    const chosenText = parsed.variants[chosenKey];
+
+    kept.push(`${parsed.indent}${parsed.bullet}${chosenText}`);
+    selected.push({
+      slotId: parsed.slotId,
+      winner: chosenKey,
+      baseline: parsed.baseline,
+      locked: hasLockedKey,
+      entry: hasLockedKey ? locked.entry : null,
+    });
+  }
+
+  const next = kept.join('\n');
+  return { body: next, selected, changed: next !== body };
+}