akm-cli 0.9.2-alpha.1 → 0.9.2-alpha.2

package/dist/storage/repositories/index-entries-repository.js

@@ -18,21 +18,22 @@ import { getStateDbPath, withStateDb } from "../../core/state-db.js";
 import { warn } from "../../core/warn.js";
 import { buildSearchText } from "../../indexer/search/search-fields.js";
 import { ENTRY_COLUMNS, rowToIndexedEntry } from "./index-entry-mapper.js";
+import { deleteFtsEntries, replaceFtsEntry } from "./index-fts-repository.js";
 import { SQLITE_CHUNK_SIZE } from "./index-sql.js";
 import { deleteEntryVectors, isVecAvailable } from "./index-vec-repository.js";
 // ── Entry operations ────────────────────────────────────────────────────────
 /**
- * Insert or update an entry in the `entries` table. Returns the row id.
+ * Insert or update one canonical entry and all synchronously derived search
+ * state. Returns the stable row id.
  *
- * **Important:** This does not update the FTS index. Callers must call
- * `rebuildFts()` after all upserts are complete for full-text search to
- * reflect the changes.
+ * The entries row, FTS projection, and stale-vector invalidation commit as one
+ * SQLite transaction. Callers therefore cannot publish an entry and forget a
+ * second FTS maintenance step.
  */
 export function upsertEntry(db, filePath, entry, searchText, provenance, contentHash) {
     // Hot path during indexing — cache prepared statements per database
     // connection so we don't pay the SQL parse/compile cost on every call.
     const stmts = getUpsertStmts(db);
-    const previous = stmts.findByItemRef.get(provenance.itemRef);
     // Phase 5A / Advantage D5: surface derived memory parent ref into the
     // dedicated `derived_from` column so retrieval-time lookup (parent→child)
     // does not have to scan + JSON-decode every memory row.
@@ -40,18 +41,20 @@ export function upsertEntry(db, filePath, entry, searchText, provenance, content
     // `content_hash` is optional on the LLM-enrichment re-upsert; a missing hash
     // preserves the scan writer's current value.
     const apply = () => {
+        const previous = stmts.findByItemRef.get(provenance.itemRef);
         const result = stmts.upsert.get(provenance.itemRef, provenance.bundleId, provenance.componentId, provenance.conceptId, provenance.adapterId, entry.type, filePath, contentHash ?? null, JSON.stringify(entry), searchText, derivedFrom);
         if (!result)
             throw new Error("upsertEntry: item_ref not found after upsert");
         if (previous?.id === result.id && previous.search_text !== searchText)
             deleteEntryVectors(db, result.id);
-        // Mark this entry as FTS-dirty so `rebuildFts({ incremental: true })`
-        // only revisits entries that actually changed. INSERT OR IGNORE is
-        // idempotent across multiple upserts of the same row.
-        stmts.markDirty.run(result.id);
+        replaceFtsEntry(db, result.id, entry);
         return result.id;
     };
-    return previous && previous.search_text !== searchText ? db.transaction(apply)() : apply();
+    // Always enter the driver's transaction wrapper. Both supported SQLite
+    // drivers lower a transaction opened inside another transaction to a
+    // savepoint, so a caller that catches this mutation's error cannot commit a
+    // partial entries row through its outer transaction.
+    return db.transaction(apply)();
 }
 const upsertStmtsByDb = new WeakMap();
 // item_ref is the sole durable conflict target. `content_hash` COALESCEs so a
@@ -84,7 +87,6 @@ function getUpsertStmts(db) {
       ON CONFLICT(item_ref) DO UPDATE ${UPSERT_SET_CLAUSE}
       RETURNING id
     `),
-        markDirty: db.prepare("INSERT OR IGNORE INTO entries_fts_dirty (entry_id) VALUES (?)"),
         findByItemRef: db.prepare("SELECT id, search_text FROM entries WHERE item_ref = ?"),
     };
     upsertStmtsByDb.set(db, stmts);
@@ -169,8 +171,8 @@ export function getBaseBeliefStatesForDerivedTwins(db, twinIds) {
  * `asset_ref` TEXT and are re-keyed separately by `akm mv` — see
  * the state rekey helper.) `document_json.name` (and `filename`, when
  * present) is patched and `search_text` rebuilt so search reflects the new
- * name; the row is marked FTS-dirty for the caller's
- * `rebuildFts({incremental: true})`.
+ * name. Its FTS projection and stale vector are updated in the same
+ * transaction as the canonical identity.
  *
  * Bundle-qualified `usage_events.entry_ref` rows for the old conceptId are
  * rewritten to the new item ref. Without this, events keep the old
@@ -209,6 +211,7 @@ export function rekeyEntryInPlace(db, opts) {
     // the utility history survives; the next full index heals the JSON.
     let documentJson = row.document_json;
     let searchText = row.search_text;
+    let document;
     try {
         const entry = JSON.parse(row.document_json);
         entry.name = opts.newName;
@@ -218,6 +221,7 @@ export function rekeyEntryInPlace(db, opts) {
             entry.derivedFrom = opts.newDerivedFrom;
         documentJson = JSON.stringify(entry);
         searchText = buildSearchText(entry);
+        document = entry;
     }
     catch {
         /* corrupt document_json — identity/path-only re-key */
@@ -242,7 +246,12 @@ export function rekeyEntryInPlace(db, opts) {
         if (opts.newDerivedFrom !== undefined) {
             db.prepare("UPDATE entries SET derived_from = ? WHERE id = ?").run(opts.newDerivedFrom, row.id);
         }
-        db.prepare("INSERT OR IGNORE INTO entries_fts_dirty (entry_id) VALUES (?)").run(row.id);
+        if (row.search_text !== searchText)
+            deleteEntryVectors(db, row.id);
+        if (document)
+            replaceFtsEntry(db, row.id, document);
+        else
+            deleteFtsEntries(db, [row.id]);
     })();
     // Re-point usage history at the new ref. Chunk-8 WI-8.3: usage_events lives in
     // state.db now, so this is a SEPARATE cross-DB transaction (best-effort — the
@@ -358,6 +367,17 @@ export function deleteEntriesByBundle(db, bundleId) {
         deleteEntryRows(db, rows);
     })();
 }
+/**
+ * Delete the complete regenerable entry generation through the same child-row
+ * authority used by targeted deletes. The caller may retain cross-database
+ * usage events so the finalize pass can relink them to the new row ids.
+ */
+export function deleteAllEntries(db, options = {}) {
+    return db.transaction(() => {
+        const rows = db.prepare("SELECT id FROM entries").all();
+        return deleteEntryRows(db, rows, options);
+    })();
+}
 /**
  * Diff-persist orphan delete: remove every entry under `dirPath` whose durable
  * `item_ref` is not in `keepRefs`.
@@ -382,15 +402,9 @@ function deleteRelatedRows(db, ids, options = {}) {
         return;
     const numericIds = ids.map((r) => r.id);
     const vecAvail = isVecAvailable(db);
-    // Drop matching FTS rows + dirty markers immediately so an incremental
-    // rebuild after a deletion doesn't try to re-index entries that no longer
-    // exist (and so a full scan after deletion sees a consistent FTS).
-    for (let i = 0; i < numericIds.length; i += SQLITE_CHUNK_SIZE) {
-        const chunk = numericIds.slice(i, i + SQLITE_CHUNK_SIZE);
-        const placeholders = chunk.map(() => "?").join(",");
-        bestEffort(() => db.prepare(`DELETE FROM entries_fts WHERE entry_id IN (${placeholders})`).run(...chunk), "fts table may not exist on a brand-new db");
-        bestEffort(() => db.prepare(`DELETE FROM entries_fts_dirty WHERE entry_id IN (${placeholders})`).run(...chunk), "fts dirty table is created lazily by upsertEntry");
-    }
+    // FTS is part of the canonical mutation boundary, not a caller-maintained
+    // dirty queue. Delete it before the parent row inside this transaction.
+    deleteFtsEntries(db, numericIds);
     // Process in chunks to stay within SQLITE_MAX_VARIABLE_NUMBER
     for (let i = 0; i < numericIds.length; i += SQLITE_CHUNK_SIZE) {
         const chunk = numericIds.slice(i, i + SQLITE_CHUNK_SIZE);
@@ -453,10 +467,10 @@ export function deleteUsageEventsByEntryIds(entryIds) {
 }
 /**
  * Delete entries by their primary key IDs, along with all related rows
- * (embeddings, entries_vec, entries_fts, utility_scores, usage_events).
+ * (embeddings, entries_vec, entries_fts, utility scores, usage_events).
  *
- * Used by the `--clean` post-pass to remove stale entries whose source files
- * no longer exist on disk.
+ * Used by explicit `--clean` reconciliation before embeddings and final
+ * verification to remove stale entries whose source files no longer exist.
  */
 export function deleteEntriesByIds(db, ids) {
     if (ids.length === 0)

package/dist/storage/repositories/index-entry-schema.js

@@ -10,7 +10,7 @@
  * serving preflights, and read-only evaluator tooling cannot drift into
  * separate definitions of "current".
  */
-export const CANONICAL_INDEX_DB_VERSION = 21;
+export const CANONICAL_INDEX_DB_VERSION = 22;
 export const CANONICAL_ENTRY_SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS entries (
     id            INTEGER PRIMARY KEY AUTOINCREMENT,

package/dist/storage/repositories/index-fts-repository.js

@@ -2,33 +2,63 @@
 // 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/.
 /**
- * `index.db` FTS5 search + rebuild repository.
+ * `index.db` FTS5 search + materialization repository.
  *
- * Owns the `entries_fts` full-text query path and the incremental/full FTS
- * rebuild.
+ * Owns the `entries_fts` full-text query path, per-entry projections, and the
+ * explicit full recovery rebuild.
  */
 import { warn } from "../../core/warn.js";
-import { buildPrefixQuery, sanitizeFtsQuery } from "../../indexer/search/fts-query.js";
+import { buildLexicalQueryPlan } from "../../indexer/search/fts-query.js";
 import { buildSearchFields } from "../../indexer/search/search-fields.js";
 import { SQLITE_CHUNK_SIZE } from "./index-sql.js";
+const INSERT_FTS_SQL = "INSERT INTO entries_fts (entry_id, name, description, tags, hints, content) VALUES (?, ?, ?, ?, ?, ?)";
+const ftsMutationStatementsByDb = new WeakMap();
+function getFtsMutationStatements(db) {
+    const existing = ftsMutationStatementsByDb.get(db);
+    if (existing)
+        return existing;
+    const statements = {
+        deleteOne: db.prepare("DELETE FROM entries_fts WHERE entry_id = ?"),
+        insert: db.prepare(INSERT_FTS_SQL),
+    };
+    ftsMutationStatementsByDb.set(db, statements);
+    return statements;
+}
+/** Replace one entry's derived FTS projection inside the caller's transaction. */
+export function replaceFtsEntry(db, entryId, entry) {
+    const fields = buildSearchFields(entry);
+    const statements = getFtsMutationStatements(db);
+    statements.deleteOne.run(entryId);
+    statements.insert.run(entryId, fields.name, fields.description, fields.tags, fields.hints, fields.content);
+}
+/** Delete derived FTS projections for canonical entries that are being removed. */
+export function deleteFtsEntries(db, entryIds) {
+    for (let i = 0; i < entryIds.length; i += SQLITE_CHUNK_SIZE) {
+        const chunk = entryIds.slice(i, i + SQLITE_CHUNK_SIZE);
+        const placeholders = chunk.map(() => "?").join(",");
+        db.prepare(`DELETE FROM entries_fts WHERE entry_id IN (${placeholders})`).run(...chunk);
+    }
+}
 export function searchFts(db, query, limit, entryType, excludeTypes) {
-    const ftsQuery = sanitizeFtsQuery(query);
-    if (!ftsQuery)
+    const plan = buildLexicalQueryPlan(query);
+    if (!plan.exact)
         return [];
     // Try the exact AND query first
-    const exactResults = runFtsQuery(db, ftsQuery, limit, entryType, excludeTypes);
+    const exactResults = runFtsQuery(db, plan.exact, "exact", limit, entryType, excludeTypes);
     if (exactResults.length > 0)
         return exactResults;
-    // Exact match returned zero results — try prefix fallback.
-    // Append FTS5 `*` suffix to each token that is >= 3 characters long.
-    // Short tokens (1-2 chars) are excluded from prefix expansion because
-    // they produce too many false positives.
-    const prefixQuery = buildPrefixQuery(ftsQuery);
-    if (!prefixQuery)
-        return [];
-    return runFtsQuery(db, prefixQuery, limit, entryType, excludeTypes);
+    if (plan.exactPrefix) {
+        const prefixResults = runFtsQuery(db, plan.exactPrefix, "prefix", limit, entryType, excludeTypes);
+        if (prefixResults.length > 0)
+            return prefixResults;
+    }
+    // One measured relaxation only after both conjunctive forms miss. This is
+    // still the same FTS table, BM25 weights, candidate collection, and
+    // downstream ranker — merely an OR candidate query for sentence-shaped
+    // input whose filler terms prevented a strict hit.
+    return plan.relaxed ? runFtsQuery(db, plan.relaxed, "relaxed", limit, entryType, excludeTypes) : [];
 }
-function runFtsQuery(db, ftsQuery, limit, entryType, excludeTypes) {
+function runFtsQuery(db, ftsQuery, lexicalMatch, limit, entryType, excludeTypes) {
     // #627 — exclude-type clause. Only applies on the untyped ('any') path; an
     // explicit include filter (entryType) already narrows to a single type, so
     // exclusion is redundant there. An empty list skips the clause entirely
@@ -84,6 +114,7 @@ function runFtsQuery(db, ftsQuery, limit, entryType, excludeTypes) {
                 bundleId: row.bundleId,
                 conceptId: row.conceptId,
                 adapterId: row.adapterId,
+                lexicalMatch,
             });
         }
         return results;
@@ -94,49 +125,20 @@ function runFtsQuery(db, ftsQuery, limit, entryType, excludeTypes) {
     }
 }
 /**
- * Rebuild the FTS5 search index.
- *
- * `incremental` (default `false`): when true, only rebuild rows that
- * `upsertEntry` marked dirty since the last `rebuildFts` call. The full path
- * (default) wipes `entries_fts` and re-inserts every row from `entries` —
- * appropriate for `akm index --full` and version-upgrade rebuilds.
- *
- * Both paths are wrapped in a single transaction so the FTS table is never
- * left in a half-rebuilt state.
+ * Explicitly rebuild the complete FTS5 projection from canonical entries.
+ * Ordinary entry mutations do not call this: `upsertEntry` and the delete
+ * operations publish their FTS state in the same transaction as `entries`.
+ * This remains a recovery/schema-verification primitive for regenerable
+ * `index.db` state.
  *
  * Skipped corrupt-JSON rows are aggregated into one warning instead of
  * spamming stderr per-entry.
  */
-export function rebuildFts(db, options) {
-    const incremental = options?.incremental === true;
+export function rebuildFts(db) {
     db.transaction(() => {
-        let rows;
-        if (incremental) {
-            // Read the dirty queue and join against entries to get the JSON.
-            // Then drop the matching rows from entries_fts so the INSERT below
-            // doesn't double-up. The dirty list is drained at the end.
-            rows = db
-                .prepare(`SELECT e.id AS id, e.document_json AS document_json
-             FROM entries_fts_dirty d
-             JOIN entries e ON e.id = d.entry_id`)
-                .all();
-            if (rows.length === 0)
-                return;
-            const ids = rows.map((r) => r.id);
-            // Delete only the dirty FTS rows — chunk to stay under
-            // SQLITE_MAX_VARIABLE_NUMBER on large dirty queues.
-            for (let i = 0; i < ids.length; i += SQLITE_CHUNK_SIZE) {
-                const chunk = ids.slice(i, i + SQLITE_CHUNK_SIZE);
-                const placeholders = chunk.map(() => "?").join(",");
-                db.prepare(`DELETE FROM entries_fts WHERE entry_id IN (${placeholders})`).run(...chunk);
-            }
-        }
-        else {
-            // Full path: wipe and re-read every row.
-            db.exec("DELETE FROM entries_fts");
-            rows = db.prepare("SELECT id, document_json FROM entries").all();
-        }
-        const insertStmt = db.prepare("INSERT INTO entries_fts (entry_id, name, description, tags, hints, content) VALUES (?, ?, ?, ?, ?, ?)");
+        db.exec("DELETE FROM entries_fts");
+        const rows = db.prepare("SELECT id, document_json FROM entries").all();
+        const insertStmt = db.prepare(INSERT_FTS_SQL);
         let skipped = 0;
         for (const row of rows) {
             let entry;
@@ -154,14 +156,5 @@ export function rebuildFts(db, options) {
         if (skipped > 0) {
             warn(`[db] rebuildFts: skipped ${skipped} entr${skipped === 1 ? "y" : "ies"} with invalid document_json`);
         }
-        // Always drain the dirty queue — both paths converge here. The
-        // incremental path drains it because we just consumed every dirty row;
-        // the full path drains it because a full rebuild covers everything the
-        // dirty list tracks. The table is guaranteed to exist (created by
-        // ensureSchema()).
-        //
-        // BUG-L1: previously the if/else arms ran identical statements — the
-        // duplication has been collapsed.
-        db.exec("DELETE FROM entries_fts_dirty");
     })();
 }

package/dist/storage/repositories/index-schema.js

@@ -14,6 +14,10 @@ import { isVecAvailable, purgeEmbeddings } from "./index-vec-repository.js";
 // entry_type columns. item_ref is the sole conflict key; document_json is the
 // sole stored document projection; bundle provenance and file_path provide the
 // current identity and materialized read path.
+//
+// v21→v22: entry mutations publish FTS synchronously and no dirty queue exists.
+// Discard the old derived generation so stale FTS rows and caller-managed dirty
+// state cannot cross the mutation-authority boundary.
 export const DB_VERSION = CANONICAL_INDEX_DB_VERSION;
 export const EMBEDDING_DIM = 384;
 // #624-P1: graph_files is keyed to (stash_root, file_path, body_hash).
@@ -301,15 +305,6 @@ export function ensureSchema(db, embeddingDim) {
     // child rows are removed when a graph_files row is replaced.
     //
     ensureGraphTables(db);
-    // FTS-dirty queue. Created here (not lazily on first upsert) so the
-    // per-entry write path doesn't issue a CREATE TABLE IF NOT EXISTS on
-    // every call — that DDL would fire thousands of times during a full
-    // index. See `markFtsDirty` and `rebuildFts({ incremental: true })`.
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS entries_fts_dirty (
-      entry_id INTEGER PRIMARY KEY
-    );
-  `);
     // If a generation rebuild could not drop a vec0 table while the extension
     // was unavailable, finish that reset as soon as vec0 can be loaded again.
     if (isVecAvailable(db) && getMeta(db, "vecResetPending") === "1") {

package/dist/storage/repositories/index-vec-repository.js

@@ -12,6 +12,7 @@ import { bestEffort } from "../../core/best-effort.js";
 import { warn } from "../../core/warn.js";
 import { cosineSimilarity } from "../../llm/embedders/types.js";
 import { getMeta, setMeta } from "./index-meta-repository.js";
+import { SQLITE_CHUNK_SIZE } from "./index-sql.js";
 // ── sqlite-vec extension ────────────────────────────────────────────────────
 const vecStatus = new WeakMap();
 /**
@@ -68,6 +69,43 @@ export function isVecFastPathReady(db) {
     // flag, so the read path has to verify the table really exists.
     return hasVecTable(db);
 }
+/**
+ * Verify that the vec fast-path table mirrors the complete durable BLOB set.
+ *
+ * A targeted embedding write preserves the prior readiness decision because
+ * its subset cannot prove an older degraded generation is healed. Global
+ * materialization uses this aggregate check before promoting the persisted
+ * flag; search itself still reads the cheap flag and does not repeat the check
+ * per query.
+ */
+export function isVecFastPathComplete(db) {
+    if (!isVecAvailable(db) || !hasVecTable(db))
+        return false;
+    try {
+        const missingVecRows = db
+            .prepare(`
+        SELECT id FROM embeddings
+        EXCEPT
+        SELECT id FROM entries_vec
+        LIMIT 1
+      `)
+            .all();
+        if (missingVecRows.length > 0)
+            return false;
+        const orphanVecRows = db
+            .prepare(`
+        SELECT id FROM entries_vec
+        EXCEPT
+        SELECT id FROM embeddings
+        LIMIT 1
+      `)
+            .all();
+        return orphanVecRows.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
 const vecTablePresent = new WeakMap();
 /**
  * Whether `entries_vec` exists on this connection, memoized per handle.
@@ -274,13 +312,24 @@ function searchBlobVec(db, queryEmbedding, k) {
  * Return all entries that do not yet have an embedding row.
  * Used by the embedding phase to determine which entries need vectors generated.
  */
-export function getAllEntriesForEmbedding(db) {
-    return db
-        .prepare(`
+export function getAllEntriesForEmbedding(db, entryIds) {
+    const select = `
       SELECT e.id, e.search_text AS searchText, e.item_ref AS itemRef, e.file_path AS filePath FROM entries e
-      WHERE NOT EXISTS (SELECT 1 FROM embeddings b WHERE b.id = e.id)
-    `)
-        .all();
+    `;
+    const missing = "NOT EXISTS (SELECT 1 FROM embeddings b WHERE b.id = e.id)";
+    if (entryIds === undefined) {
+        return db.prepare(`${select} WHERE ${missing} ORDER BY e.id`).all();
+    }
+    const targets = [...new Set(entryIds)].sort((left, right) => left - right);
+    const rows = [];
+    for (let offset = 0; offset < targets.length; offset += SQLITE_CHUNK_SIZE) {
+        const chunk = targets.slice(offset, offset + SQLITE_CHUNK_SIZE);
+        if (chunk.length === 0)
+            continue;
+        const placeholders = chunk.map(() => "?").join(",");
+        rows.push(...db.prepare(`${select} WHERE e.id IN (${placeholders}) AND ${missing} ORDER BY e.id`).all(...chunk));
+    }
+    return rows;
 }
 export function getEmbeddingCount(db) {
     const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();

package/docs/reference/cli.md

@@ -869,10 +869,10 @@ akm bundle remove my-provider --yes        # Skip the confirmation prompt
 
 ### bundle update
 
-Update one remote bundle, or refresh every configured bundle with `--all`.
-Git, npm, and website candidates are staged and audited before they replace the
-active generation; filesystem bundles are reported as skipped because they
-already reflect local files in place.
+Update one bundle, or refresh every configured bundle with `--all`. Git, npm,
+and website candidates are staged and audited before they replace the active
+generation. Filesystem bundles require no hydration; update reconciles their
+current files into the index immediately.
 
 ```sh
 akm bundle update npm:@scope/pkg

package/docs/reference/configuration.md

@@ -288,15 +288,12 @@ bundled.
 
 ## Indexing
 
-`index.indexBodyOpening` defaults to `false`. When enabled, AKM captures the
-first prose paragraph of each Markdown asset body, capped at 280 characters,
-into the lowest-weight search content and embedding text. Secret and env files
-are never read for this field, and session-kind memories are excluded.
-
-Changing this option changes indexed text. Run `akm index --full` after
-toggling it so all entries and embeddings are rebuilt consistently. If the
-setting differs from the state used to build the current index, AKM warns until
-that full rebuild completes.
+AKM-native Markdown contributes a normalized body projection to the
+lowest-weight `content` search field. The projection is capped at 16,384
+characters, removes frontmatter, comments, fenced code, and link destinations,
+and is never produced for secret, env, session, or session-checkpoint assets.
+Embedding input is separately capped at 8,192 characters with structured
+metadata placed before body content.
 
 ## Semantic search
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.2-alpha.1",
+  "version": "0.9.2-alpha.2",
   "type": "module",
   "description": "akm (Agent Knowledge Manager) — a portable, local-first capability library for AI agents. Discover, load, share, and improve reusable skills, scripts, workflows, and knowledge across any shell-capable coding agent, including Claude Code, OpenCode, and Cursor.",
   "keywords": [

package/schemas/akm-config.json

@@ -305,10 +305,6 @@
             }
           },
           "additionalProperties": true
-        },
-        "indexBodyOpening": {
-          "type": "boolean",
-          "description": "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`."
         }
       },
       "additionalProperties": {
@@ -1999,10 +1995,6 @@
                 }
               },
               "additionalProperties": true
-            },
-            "indexBodyOpening": {
-              "type": "boolean",
-              "description": "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`."
             }
           },
           "additionalProperties": {