sensemaking 0.25.1 → 0.26.0

package/dist/cjs/store/builder.js

@@ -8,17 +8,35 @@ Object.defineProperty(exports, "createBuilder", {
         return createBuilder;
     }
 });
+var _nodediagnostics_channel = require("node:diagnostics_channel");
 var _indexts = require("../config/index.js");
+var _errorsts = require("../errors.js");
 var _embedts = require("../features/embed.js");
 var _indexts1 = require("../features/index.js");
 var _rankts = require("../features/rank.js");
 var _indexts2 = require("../scan/index.js");
 var _poolts = require("../scan/pool.js");
 var _reparsets = require("../scan/reparse.js");
+var _embedscopets = require("./embed-scope.js");
 var _featurescopets = require("./feature-scope.js");
+var _presetscopets = require("./preset-scope.js");
+var _readinessts = require("./readiness.js");
 var _reconcilets = require("./reconcile.js");
 var _sharedts = require("./shared.js");
+var _signaturets = require("./signature.js");
 var _transactionts = require("./transaction.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return self;
+}
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -45,6 +63,87 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) return call;
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -144,434 +243,482 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-// 'model': the provider or model name moved but chunk boundaries did not, so only the vector
-// values are stale. No reparse, and no table but embeddings is touched.
-function nullEmbedVectors(conn, dialect) {
-    return _async_to_generator(function() {
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    return [
-                        4,
-                        (0, _transactionts.withTransaction)(conn, function() {
-                            return conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL');
-                        }, dialect.beginMode())
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        2,
-                        {
-                            parsed: 0
-                        }
-                    ];
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) {
+        return m.call(o);
+    }
+    if (o && typeof o.length === "number") {
+        return {
+            next: function() {
+                if (o && i >= o.length) {
+                    o = void 0;
+                }
+                return {
+                    value: o && o[i++],
+                    done: !o
+                };
+            }
+        };
+    }
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") throw new TypeError("Super expression must either be null or a function");
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
             }
         });
-    })();
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
 }
-// 'chunk': chunkTokens or the chunk version moved, so chunk boundaries genuinely changed. Rebuilds
-// every embedding row through the embed feature's own remove/store, touching no other table.
-function rebuildEmbeddings(conn, cfg, baseDir, dialect, pool) {
+var StaleBuildPlan = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(StaleBuildPlan, Error1);
+    function StaleBuildPlan() {
+        _class_call_check(this, StaleBuildPlan);
+        return _call_super(this, StaleBuildPlan, arguments);
+    }
+    return StaleBuildPlan;
+}(_wrap_native_super(Error));
+var buildPlan = (0, _nodediagnostics_channel.channel)('sensemaking.store.build-plan');
+var SCHEMA_VERSION_META_KEY = 'schema_version';
+function readCoreBaseline(conn) {
     return _async_to_generator(function() {
-        var existingStmt, existingPaths, _, files, docs, paths, delta;
+        var _stmt, _values_get, _values_get1, _values_get2, _values_get3, keys, stmt, values, _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
+                    keys = [
+                        SCHEMA_VERSION_META_KEY,
+                        _readinessts.FEATURE_SIGNATURE_META_KEY,
+                        _readinessts.CORE_READY_META_KEY,
+                        _readinessts.CORE_GENERATION_META_KEY
+                    ];
                     return [
                         4,
-                        conn.prepare('SELECT "path" FROM frontmatter')
+                        conn.prepare("SELECT key, value FROM meta WHERE key IN (".concat(keys.map(function() {
+                            return '?';
+                        }).join(', '), ")"))
                     ];
                 case 1:
-                    existingStmt = _state.sent();
-                    _ = Set.bind;
+                    stmt = _state.sent();
+                    _ = Map.bind;
                     return [
                         4,
-                        existingStmt.all()
+                        (_stmt = stmt).all.apply(_stmt, _to_consumable_array(keys))
                     ];
                 case 2:
-                    existingPaths = new (_.apply(Set, [
+                    values = new (_.apply(Map, [
                         void 0,
-                        _state.sent().map(function(r) {
-                            return r.path;
+                        _state.sent().map(function(row) {
+                            return [
+                                row.key,
+                                row.value
+                            ];
                         })
                     ]));
-                    // A file added since the last build has no row yet; leaving it for build() to insert avoids a
-                    // primary-key collision between this INSERT and build()'s own insert for the same new file.
-                    files = (0, _indexts2.listFiles)(cfg, baseDir).filter(function(f) {
-                        return f.embed && existingPaths.has(f.relPath);
-                    });
-                    if (files.length === 0) return [
-                        2,
-                        {
-                            parsed: 0
-                        }
-                    ];
-                    return [
-                        4,
-                        (0, _reparsets.reparseFiles)(files, [
-                            _embedts.embed
-                        ], cfg, new Set(), undefined, {
-                            pool: pool
-                        })
-                    ];
-                case 3:
-                    docs = _state.sent().docs;
-                    paths = docs.map(function(d) {
-                        return d.relPath;
-                    });
-                    delta = {
-                        files: files,
-                        reparsed: paths,
-                        added: [],
-                        vanished: []
-                    };
-                    return [
-                        4,
-                        (0, _transactionts.withTransaction)(conn, function() {
-                            return _async_to_generator(function() {
-                                var _embed_remove, _embed_store;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            return [
-                                                4,
-                                                (_embed_remove = _embedts.embed.remove) === null || _embed_remove === void 0 ? void 0 : _embed_remove.call(_embedts.embed, conn, paths, delta)
-                                            ];
-                                        case 1:
-                                            _state.sent();
-                                            return [
-                                                4,
-                                                (_embed_store = _embedts.embed.store) === null || _embed_store === void 0 ? void 0 : _embed_store.call(_embedts.embed, conn, docs.map(function(d) {
-                                                    return {
-                                                        path: d.relPath,
-                                                        extracted: d.extracted.embed
-                                                    };
-                                                }), delta)
-                                            ];
-                                        case 2:
-                                            _state.sent();
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            })();
-                        }, dialect.beginMode())
-                    ];
-                case 4:
-                    _state.sent();
                     return [
                         2,
                         {
-                            parsed: docs.length
+                            schemaVersion: (_values_get = values.get(SCHEMA_VERSION_META_KEY)) !== null && _values_get !== void 0 ? _values_get : null,
+                            features: (_values_get1 = values.get(_readinessts.FEATURE_SIGNATURE_META_KEY)) !== null && _values_get1 !== void 0 ? _values_get1 : null,
+                            ready: (_values_get2 = values.get(_readinessts.CORE_READY_META_KEY)) !== null && _values_get2 !== void 0 ? _values_get2 : null,
+                            generation: (_values_get3 = values.get(_readinessts.CORE_GENERATION_META_KEY)) !== null && _values_get3 !== void 0 ? _values_get3 : null
                         }
                     ];
             }
         });
     })();
 }
-// One feature's own table, dropped and (turning on) fully re-derived across every indexed file.
-// Rows left over from before this feature was disabled are untrustworthy by construction (files
-// added, edited, or deleted got no remove/store for it), so this never diffs against them --
-// dropping every row and reparsing the whole tree is the only safe path back to consistent state.
-function invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle) {
+function sameBaseline(a, b) {
+    return a.schemaVersion === b.schemaVersion && a.features === b.features && a.ready === b.ready && a.generation === b.generation;
+}
+function nextGeneration(value) {
+    var current = value === null ? 0 : Number(value);
+    if (!Number.isSafeInteger(current) || current < 0 || current === Number.MAX_SAFE_INTEGER) throw new _errorsts.SenseError('INDEX_NOT_READY', "the durable core generation is invalid (".concat(value !== null && value !== void 0 ? value : 'missing', "); run sense build --force to recreate the derived index"));
+    return String(current + 1);
+}
+function readPlanningSnapshot(conn, timing) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            return [
+                2,
+                (0, _transactionts.withTransaction)(conn, function() {
+                    return _async_to_generator(function() {
+                        var baseline, reconcile, tablesStmt, tables, _;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    return [
+                                        4,
+                                        readCoreBaseline(conn)
+                                    ];
+                                case 1:
+                                    baseline = _state.sent();
+                                    return [
+                                        4,
+                                        (0, _reconcilets.readReconcileSnapshot)(conn, timing)
+                                    ];
+                                case 2:
+                                    reconcile = _state.sent();
+                                    return [
+                                        4,
+                                        conn.prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
+                                    ];
+                                case 3:
+                                    tablesStmt = _state.sent();
+                                    _ = Set.bind;
+                                    return [
+                                        4,
+                                        tablesStmt.all()
+                                    ];
+                                case 4:
+                                    tables = new (_.apply(Set, [
+                                        void 0,
+                                        _state.sent().map(function(row) {
+                                            return row.name;
+                                        })
+                                    ]));
+                                    return [
+                                        2,
+                                        {
+                                            baseline: baseline,
+                                            reconcile: reconcile,
+                                            tables: tables
+                                        }
+                                    ];
+                            }
+                        });
+                    })();
+                })
+            ];
+        });
+    })();
+}
+function activeSchemaMissing(snapshot, cfg) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = _indexts1.FEATURES[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var feature = _step.value;
+            if (!(0, _indexts.featureEnabled)(cfg, feature.name)) continue;
+            if (feature.name === 'rank') {
+                if (!snapshot.reconcile.seenColumns.has('_rank')) return true;
+                continue;
+            }
+            var table = feature.name === 'embed' ? 'embeddings' : _featurescopets.NARROW_FEATURE_TABLE[feature.name];
+            if (table && !snapshot.tables.has(table)) return true;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return false;
+}
+function classifyBuild(snapshot, cfg, paths, wanted) {
+    var before = snapshot.baseline.features;
+    var recover = snapshot.baseline.ready === '0';
+    var messages = [];
+    if (recover) messages.push('sense: recovering an incomplete index generation in place');
+    if (!recover && before !== null && before === wanted && activeSchemaMissing(snapshot, cfg)) {
+        messages.push('sense: recovering missing feature schema in place');
+        return {
+            embedKind: null,
+            featureToggles: [],
+            fullRebuild: true,
+            messages: messages
+        };
+    }
+    if (recover || before === null || before === wanted) return {
+        embedKind: null,
+        featureToggles: [],
+        fullRebuild: recover,
+        messages: messages
+    };
+    var changedKeys = (0, _signaturets.changedSignatureKeys)(before, wanted);
+    if (changedKeys.size === 1 && changedKeys.has('embed') && (0, _signaturets.embedIdentityAdopted)(before, wanted)) {
+        messages.push("sense: recorded the embedding model's resolved identity; vectors are unaffected");
+        return {
+            embedKind: null,
+            featureToggles: [],
+            fullRebuild: false,
+            messages: messages
+        };
+    }
+    var embedKind = changedKeys.size === 1 && changedKeys.has('embed') ? (0, _embedscopets.classifyEmbedChange)(before, wanted) : null;
+    if (embedKind !== null) {
+        messages.push(embedKind === 'model' ? 'sense: config change (embed settings) invalidates only the stale vectors' : 'sense: config change (embed settings) rebuilds only the embeddings it affects');
+        return {
+            embedKind: embedKind,
+            featureToggles: [],
+            fullRebuild: false,
+            messages: messages
+        };
+    }
+    var presetForced = (0, _presetscopets.isPresetOnlyChange)(changedKeys) ? (0, _presetscopets.forcedPresetPaths)(cfg, paths.rootDir, before, changedKeys) : null;
+    if (presetForced !== null) {
+        messages.push("sense: config change (".concat((0, _signaturets.signatureDiff)(before, wanted), ") reparses only the files it affects"));
+        return {
+            embedKind: null,
+            featureToggles: [],
+            forcedPaths: presetForced,
+            fullRebuild: false,
+            messages: messages
+        };
+    }
+    var toggles = (0, _featurescopets.isFeatureOnlyChange)(changedKeys) ? (0, _featurescopets.classifyFeatureToggles)(before, wanted, changedKeys) : null;
+    if (toggles !== null) {
+        messages.push("sense: config change (".concat((0, _signaturets.signatureDiff)(before, wanted), ") reparses only the feature it affects"));
+        return {
+            embedKind: null,
+            featureToggles: toggles,
+            fullRebuild: false,
+            messages: messages
+        };
+    }
+    messages.push("sense: config change (".concat((0, _signaturets.signatureDiff)(before, wanted), ") rebuilds the index"));
+    return {
+        embedKind: null,
+        featureToggles: [],
+        fullRebuild: true,
+        messages: messages
+    };
+}
+function prepareEmbedInvalidation(kind, snapshot, cfg, paths, pool) {
     return _async_to_generator(function() {
-        var table, feature, files, docs, docsForFeature, paths, delta;
+        var existing, files, docs, pathsChanged, delta;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    table = _featurescopets.NARROW_FEATURE_TABLE[toggle.name];
-                    feature = _indexts1.FEATURES.find(function(f) {
-                        return f.name === toggle.name;
+                    if (kind === 'model') {
+                        return [
+                            2,
+                            {
+                                mutated: true,
+                                parsed: 0,
+                                apply: function apply(conn) {
+                                    return conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL');
+                                }
+                            }
+                        ];
+                    }
+                    existing = new Set(snapshot.reconcile.existingRows.map(function(row) {
+                        return row.path;
+                    }));
+                    files = (0, _indexts2.listFiles)(cfg, paths.rootDir).filter(function(file) {
+                        return file.embed && existing.has(file.relPath);
                     });
-                    if (!feature) throw new Error('invalidateFeatureTable: no registered feature named "'.concat(toggle.name, '"'));
-                    if (!!toggle.turnedOn) return [
-                        3,
-                        2
-                    ];
-                    return [
-                        4,
-                        (0, _transactionts.withTransaction)(conn, function() {
-                            return conn.exec("DELETE FROM ".concat(table));
-                        }, dialect.beginMode())
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        2,
-                        {
-                            parsed: 0
-                        }
-                    ];
-                case 2:
-                    files = (0, _indexts2.listFiles)(cfg, baseDir);
                     return [
                         4,
                         (0, _reparsets.reparseFiles)(files, [
-                            feature
+                            _embedts.embed
                         ], cfg, new Set(), undefined, {
                             pool: pool
                         })
                     ];
-                case 3:
+                case 1:
                     docs = _state.sent().docs;
-                    docsForFeature = docs.map(function(d) {
-                        return {
-                            path: d.relPath,
-                            extracted: d.extracted[feature.name]
-                        };
-                    });
-                    paths = docs.map(function(d) {
-                        return d.relPath;
+                    pathsChanged = docs.map(function(doc) {
+                        return doc.relPath;
                     });
-                    // Every path counts as added, not just touched: nothing stale to diff against. Links resolves
-                    // dst inside store() itself when added.length equals files.length (a cold build).
                     delta = {
                         files: files,
-                        reparsed: paths,
-                        added: paths,
+                        reparsed: pathsChanged,
+                        added: [],
                         vanished: []
                     };
-                    return [
-                        4,
-                        (0, _transactionts.withTransaction)(conn, function() {
-                            return _async_to_generator(function() {
-                                var _feature_store, _feature_afterReconcile;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            return [
-                                                4,
-                                                conn.exec("DELETE FROM ".concat(table))
-                                            ];
-                                        case 1:
-                                            _state.sent();
-                                            return [
-                                                4,
-                                                (_feature_store = feature.store) === null || _feature_store === void 0 ? void 0 : _feature_store.call(feature, conn, docsForFeature, delta)
-                                            ];
-                                        case 2:
-                                            _state.sent();
-                                            return [
-                                                4,
-                                                (_feature_afterReconcile = feature.afterReconcile) === null || _feature_afterReconcile === void 0 ? void 0 : _feature_afterReconcile.call(feature, conn, delta)
-                                            ];
-                                        case 3:
-                                            _state.sent();
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            })();
-                        }, dialect.beginMode())
-                    ];
-                case 4:
-                    _state.sent();
                     return [
                         2,
                         {
-                            parsed: docs.length
+                            mutated: true,
+                            parsed: docs.length,
+                            apply: function apply(conn) {
+                                return _async_to_generator(function() {
+                                    var _embed_store;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                if (!(pathsChanged.length > 0)) return [
+                                                    3,
+                                                    2
+                                                ];
+                                                return [
+                                                    4,
+                                                    conn.runBatch('DELETE FROM embeddings WHERE "path" = ?', pathsChanged.map(function(path) {
+                                                        return [
+                                                            path
+                                                        ];
+                                                    }))
+                                                ];
+                                            case 1:
+                                                _state.sent();
+                                                _state.label = 2;
+                                            case 2:
+                                                return [
+                                                    4,
+                                                    (_embed_store = _embedts.embed.store) === null || _embed_store === void 0 ? void 0 : _embed_store.call(_embedts.embed, conn, docs.map(function(doc) {
+                                                        return {
+                                                            path: doc.relPath,
+                                                            extracted: doc.extracted.embed
+                                                        };
+                                                    }), delta)
+                                                ];
+                                            case 3:
+                                                _state.sent();
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            }
                         }
                     ];
             }
         });
     })();
 }
-// rank has no table of its own: frontmatter._rank is the only state it owns. Guarded on column
-// presence, since links can toggle off while rank has never been enabled for this tree.
-function nullRank(conn, dialect) {
-    return _async_to_generator(function() {
-        var columns;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    return [
-                        4,
-                        (0, _sharedts.getColumns)(conn)
-                    ];
-                case 1:
-                    columns = _state.sent();
-                    if (!columns.has('_rank')) return [
-                        2
-                    ];
-                    return [
-                        4,
-                        (0, _transactionts.withTransaction)(conn, function() {
-                            return conn.exec('UPDATE frontmatter SET "_rank" = NULL');
-                        }, dialect.beginMode())
-                    ];
-                case 2:
-                    _state.sent();
-                    return [
-                        2
-                    ];
-            }
-        });
-    })();
-}
-// Whole-tree and reparse-free: PageRank is computed from the links table, not from files, so
-// turning rank back on needs no reparseFiles pass at all.
-function rerunRank(conn, dialect) {
+function prepareFeatureInvalidation(toggles, snapshot, cfg, paths, pool) {
     return _async_to_generator(function() {
-        var delta;
+        var prepared, parsed, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err, applyTable, nullRank;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    delta = {
-                        files: [],
-                        reparsed: [],
-                        added: [],
-                        vanished: []
-                    };
-                    return [
-                        4,
-                        (0, _transactionts.withTransaction)(conn, function() {
-                            return _async_to_generator(function() {
-                                var _rank_afterReconcile;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            return [
-                                                4,
-                                                (_rank_afterReconcile = _rankts.rank.afterReconcile) === null || _rank_afterReconcile === void 0 ? void 0 : _rank_afterReconcile.call(_rankts.rank, conn, delta)
-                                            ];
-                                        case 1:
-                                            _state.sent();
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            })();
-                        }, dialect.beginMode())
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        2
+                    if (toggles.length === 0) return [
+                        2,
+                        {
+                            mutated: false,
+                            parsed: 0,
+                            apply: function apply() {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        return [
+                                            2
+                                        ];
+                                    });
+                                })();
+                            }
+                        }
                     ];
-            }
-        });
-    })();
-}
-function invalidateFeatureToggles(conn, cfg, baseDir, dialect, pool, toggles) {
-    return _async_to_generator(function() {
-        var byName, parsed, linksToggle, rankToggle, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, toggle, err;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    byName = new Map(toggles.map(function(toggle) {
-                        return [
-                            toggle.name,
-                            toggle
-                        ];
-                    }));
+                    prepared = new Map();
                     parsed = 0;
-                    // links first, if present: rank's rerun below (whether from its own toggle or the co-change
-                    // rankToggle carries) must read the links table after it is back in its new state.
-                    linksToggle = byName.get('links');
-                    if (!linksToggle) return [
-                        3,
-                        3
-                    ];
-                    return [
-                        4,
-                        invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, linksToggle)
-                    ];
-                case 1:
-                    parsed = parsed + _state.sent().parsed;
-                    if (!!linksToggle.turnedOn) return [
-                        3,
-                        3
-                    ];
-                    return [
-                        4,
-                        nullRank(conn, dialect)
-                    ];
-                case 2:
-                    _state.sent();
-                    _state.label = 3;
-                case 3:
-                    // rank's effective on/off (featureEnabled's links dependency) only appears as a changed
-                    // `feature:rank` segment when it actually flips -- whether that's rank's own config or a
-                    // links toggle taking it along -- so honoring it here is complete on its own.
-                    rankToggle = byName.get('rank');
-                    if (!rankToggle) return [
-                        3,
-                        7
-                    ];
-                    if (!rankToggle.turnedOn) return [
-                        3,
-                        5
-                    ];
-                    return [
-                        4,
-                        rerunRank(conn, dialect)
-                    ];
-                case 4:
-                    _state.sent();
-                    return [
-                        3,
-                        7
-                    ];
-                case 5:
-                    return [
-                        4,
-                        nullRank(conn, dialect)
-                    ];
-                case 6:
-                    _state.sent();
-                    _state.label = 7;
-                case 7:
                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                    _state.label = 8;
-                case 8:
+                    _state.label = 1;
+                case 1:
                     _state.trys.push([
-                        8,
-                        13,
-                        14,
-                        15
+                        1,
+                        6,
+                        7,
+                        8
                     ]);
+                    _loop = function() {
+                        var toggle, feature, files, docs;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    toggle = _step.value;
+                                    if (!toggle.turnedOn || toggle.name === 'rank') return [
+                                        2,
+                                        "continue"
+                                    ];
+                                    feature = _indexts1.FEATURES.find(function(candidate) {
+                                        return candidate.name === toggle.name;
+                                    });
+                                    if (!feature) throw new Error('prepareFeatureInvalidation: no registered feature named "'.concat(toggle.name, '"'));
+                                    files = (0, _indexts2.listFiles)(cfg, paths.rootDir);
+                                    return [
+                                        4,
+                                        (0, _reparsets.reparseFiles)(files, [
+                                            feature
+                                        ], cfg, new Set(), undefined, {
+                                            pool: pool
+                                        })
+                                    ];
+                                case 1:
+                                    docs = _state.sent().docs;
+                                    parsed += docs.length;
+                                    prepared.set(toggle.name, {
+                                        feature: feature,
+                                        docs: docs,
+                                        files: files
+                                    });
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    };
                     _iterator = toggles[Symbol.iterator]();
-                    _state.label = 9;
-                case 9:
+                    _state.label = 2;
+                case 2:
                     if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                         3,
-                        12
-                    ];
-                    toggle = _step.value;
-                    if (toggle.name === 'links' || toggle.name === 'rank') return [
-                        3,
-                        11
+                        5
                     ];
                     return [
-                        4,
-                        invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle)
+                        5,
+                        _ts_values(_loop())
                     ];
-                case 10:
-                    parsed = parsed + _state.sent().parsed;
-                    _state.label = 11;
-                case 11:
+                case 3:
+                    _state.sent();
+                    _state.label = 4;
+                case 4:
                     _iteratorNormalCompletion = true;
                     return [
                         3,
-                        9
+                        2
                     ];
-                case 12:
+                case 5:
                     return [
                         3,
-                        15
+                        8
                     ];
-                case 13:
+                case 6:
                     err = _state.sent();
                     _didIteratorError = true;
                     _iteratorError = err;
                     return [
                         3,
-                        15
+                        8
                     ];
-                case 14:
+                case 7:
                     try {
                         if (!_iteratorNormalCompletion && _iterator.return != null) {
                             _iterator.return();
@@ -584,157 +731,649 @@ function invalidateFeatureToggles(conn, cfg, baseDir, dialect, pool, toggles) {
                     return [
                         7
                     ];
-                case 15:
+                case 8:
+                    applyTable = function applyTable(conn, toggle) {
+                        return _async_to_generator(function() {
+                            var _plan_feature_store, _plan_feature, _plan_feature_afterReconcile, _plan_feature1, table, plan, pathsChanged, delta;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        table = _featurescopets.NARROW_FEATURE_TABLE[toggle.name];
+                                        if (!table) return [
+                                            2
+                                        ];
+                                        if (!!toggle.turnedOn) return [
+                                            3,
+                                            3
+                                        ];
+                                        if (!snapshot.tables.has(table)) return [
+                                            3,
+                                            2
+                                        ];
+                                        return [
+                                            4,
+                                            conn.exec("DELETE FROM ".concat(table))
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        _state.label = 2;
+                                    case 2:
+                                        return [
+                                            2
+                                        ];
+                                    case 3:
+                                        plan = prepared.get(toggle.name);
+                                        if (!plan) throw new Error('prepareFeatureInvalidation: missing prepared feature "'.concat(toggle.name, '"'));
+                                        pathsChanged = plan.docs.map(function(doc) {
+                                            return doc.relPath;
+                                        });
+                                        delta = {
+                                            files: plan.files,
+                                            reparsed: pathsChanged,
+                                            added: pathsChanged,
+                                            vanished: []
+                                        };
+                                        return [
+                                            4,
+                                            conn.exec("DELETE FROM ".concat(table))
+                                        ];
+                                    case 4:
+                                        _state.sent();
+                                        return [
+                                            4,
+                                            (_plan_feature_store = (_plan_feature = plan.feature).store) === null || _plan_feature_store === void 0 ? void 0 : _plan_feature_store.call(_plan_feature, conn, plan.docs.map(function(doc) {
+                                                return {
+                                                    path: doc.relPath,
+                                                    extracted: doc.extracted[plan.feature.name]
+                                                };
+                                            }), delta)
+                                        ];
+                                    case 5:
+                                        _state.sent();
+                                        return [
+                                            4,
+                                            (_plan_feature_afterReconcile = (_plan_feature1 = plan.feature).afterReconcile) === null || _plan_feature_afterReconcile === void 0 ? void 0 : _plan_feature_afterReconcile.call(_plan_feature1, conn, delta)
+                                        ];
+                                    case 6:
+                                        _state.sent();
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    };
+                    nullRank = function nullRank(conn) {
+                        return _async_to_generator(function() {
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        if (!snapshot.reconcile.seenColumns.has('_rank')) return [
+                                            3,
+                                            2
+                                        ];
+                                        return [
+                                            4,
+                                            conn.exec('UPDATE frontmatter SET "_rank" = NULL')
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        _state.label = 2;
+                                    case 2:
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    };
                     return [
                         2,
                         {
-                            parsed: parsed
+                            mutated: true,
+                            parsed: parsed,
+                            apply: function apply(conn) {
+                                return _async_to_generator(function() {
+                                    var byName, linksToggle, rankToggle, _rank_afterReconcile, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, toggle, err;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                byName = new Map(toggles.map(function(toggle) {
+                                                    return [
+                                                        toggle.name,
+                                                        toggle
+                                                    ];
+                                                }));
+                                                linksToggle = byName.get('links');
+                                                if (!linksToggle) return [
+                                                    3,
+                                                    3
+                                                ];
+                                                return [
+                                                    4,
+                                                    applyTable(conn, linksToggle)
+                                                ];
+                                            case 1:
+                                                _state.sent();
+                                                if (!!linksToggle.turnedOn) return [
+                                                    3,
+                                                    3
+                                                ];
+                                                return [
+                                                    4,
+                                                    nullRank(conn)
+                                                ];
+                                            case 2:
+                                                _state.sent();
+                                                _state.label = 3;
+                                            case 3:
+                                                rankToggle = byName.get('rank');
+                                                if (!rankToggle) return [
+                                                    3,
+                                                    7
+                                                ];
+                                                if (!rankToggle.turnedOn) return [
+                                                    3,
+                                                    5
+                                                ];
+                                                return [
+                                                    4,
+                                                    (_rank_afterReconcile = _rankts.rank.afterReconcile) === null || _rank_afterReconcile === void 0 ? void 0 : _rank_afterReconcile.call(_rankts.rank, conn, {
+                                                        files: [],
+                                                        reparsed: [],
+                                                        added: [],
+                                                        vanished: []
+                                                    })
+                                                ];
+                                            case 4:
+                                                _state.sent();
+                                                return [
+                                                    3,
+                                                    7
+                                                ];
+                                            case 5:
+                                                return [
+                                                    4,
+                                                    nullRank(conn)
+                                                ];
+                                            case 6:
+                                                _state.sent();
+                                                _state.label = 7;
+                                            case 7:
+                                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                                _state.label = 8;
+                                            case 8:
+                                                _state.trys.push([
+                                                    8,
+                                                    13,
+                                                    14,
+                                                    15
+                                                ]);
+                                                _iterator = toggles[Symbol.iterator]();
+                                                _state.label = 9;
+                                            case 9:
+                                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                                    3,
+                                                    12
+                                                ];
+                                                toggle = _step.value;
+                                                if (!(toggle.name !== 'links' && toggle.name !== 'rank')) return [
+                                                    3,
+                                                    11
+                                                ];
+                                                return [
+                                                    4,
+                                                    applyTable(conn, toggle)
+                                                ];
+                                            case 10:
+                                                _state.sent();
+                                                _state.label = 11;
+                                            case 11:
+                                                _iteratorNormalCompletion = true;
+                                                return [
+                                                    3,
+                                                    9
+                                                ];
+                                            case 12:
+                                                return [
+                                                    3,
+                                                    15
+                                                ];
+                                            case 13:
+                                                err = _state.sent();
+                                                _didIteratorError = true;
+                                                _iteratorError = err;
+                                                return [
+                                                    3,
+                                                    15
+                                                ];
+                                            case 14:
+                                                try {
+                                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                        _iterator.return();
+                                                    }
+                                                } finally{
+                                                    if (_didIteratorError) {
+                                                        throw _iteratorError;
+                                                    }
+                                                }
+                                                return [
+                                                    7
+                                                ];
+                                            case 15:
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            }
                         }
                     ];
             }
         });
     })();
 }
-function recoverIncomplete(conn, cfg, paths, dialect, pool) {
+function recoveryToggles(cfg, snapshot) {
+    var toggles = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = _indexts1.FEATURES[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var feature = _step.value;
+            var table = _featurescopets.NARROW_FEATURE_TABLE[feature.name];
+            if (table && !(0, _indexts.featureEnabled)(cfg, feature.name) && snapshot.tables.has(table)) toggles.push({
+                name: feature.name,
+                turnedOn: false
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return toggles;
+}
+function prepareInvalidation(classification, snapshot, cfg, paths, pool) {
     return _async_to_generator(function() {
-        var disabled, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, feature, err, toggles, embeddingsTable, forcedPaths;
+        var plans, _, _1, _2;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    disabled = _indexts1.FEATURES.filter(function(feature) {
-                        return !(0, _indexts.featureEnabled)(cfg, feature.name);
-                    });
-                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                    _state.label = 1;
+                    plans = [];
+                    if (!classification.embedKind) return [
+                        3,
+                        2
+                    ];
+                    _ = plans.push;
+                    return [
+                        4,
+                        prepareEmbedInvalidation(classification.embedKind, snapshot, cfg, paths, pool)
+                    ];
                 case 1:
-                    _state.trys.push([
-                        1,
-                        6,
-                        7,
-                        8
+                    _.apply(plans, [
+                        _state.sent()
                     ]);
-                    _iterator = disabled[Symbol.iterator]();
                     _state.label = 2;
                 case 2:
-                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
-                        3,
-                        5
-                    ];
-                    feature = _step.value;
-                    if (!(feature.name !== 'embed')) return [
+                    if (!(classification.featureToggles.length > 0)) return [
                         3,
                         4
                     ];
+                    _1 = plans.push;
                     return [
                         4,
-                        feature.schema(conn)
+                        prepareFeatureInvalidation(classification.featureToggles, snapshot, cfg, paths, pool)
                     ];
                 case 3:
-                    _state.sent();
+                    _1.apply(plans, [
+                        _state.sent()
+                    ]);
                     _state.label = 4;
                 case 4:
-                    _iteratorNormalCompletion = true;
-                    return [
+                    if (!classification.fullRebuild) return [
                         3,
-                        2
+                        6
                     ];
-                case 5:
+                    _2 = plans.push;
                     return [
-                        3,
-                        8
+                        4,
+                        prepareFeatureInvalidation(recoveryToggles(cfg, snapshot), snapshot, cfg, paths, pool)
                     ];
+                case 5:
+                    _2.apply(plans, [
+                        _state.sent()
+                    ]);
+                    // Full rebuild and recovery must not reuse vectors from the prior generation.
+                    if (snapshot.tables.has('embeddings')) {
+                        plans.push({
+                            mutated: true,
+                            parsed: 0,
+                            apply: function apply(conn) {
+                                return conn.exec('DELETE FROM embeddings');
+                            }
+                        });
+                    }
+                    if (!(0, _indexts.featureEnabled)(cfg, 'rank') && snapshot.reconcile.seenColumns.has('_rank')) {
+                        plans.push({
+                            mutated: true,
+                            parsed: 0,
+                            apply: function apply(conn) {
+                                return conn.exec('UPDATE frontmatter SET "_rank" = NULL');
+                            }
+                        });
+                    }
+                    _state.label = 6;
                 case 6:
-                    err = _state.sent();
-                    _didIteratorError = true;
-                    _iteratorError = err;
                     return [
-                        3,
-                        8
-                    ];
-                case 7:
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
+                        2,
+                        {
+                            mutated: plans.some(function(plan) {
+                                return plan.mutated;
+                            }),
+                            parsed: plans.reduce(function(sum, plan) {
+                                return sum + plan.parsed;
+                            }, 0),
+                            apply: function apply(conn) {
+                                return _async_to_generator(function() {
+                                    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plan, err;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                                _state.label = 1;
+                                            case 1:
+                                                _state.trys.push([
+                                                    1,
+                                                    6,
+                                                    7,
+                                                    8
+                                                ]);
+                                                _iterator = plans[Symbol.iterator]();
+                                                _state.label = 2;
+                                            case 2:
+                                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                                    3,
+                                                    5
+                                                ];
+                                                plan = _step.value;
+                                                return [
+                                                    4,
+                                                    plan.apply(conn)
+                                                ];
+                                            case 3:
+                                                _state.sent();
+                                                _state.label = 4;
+                                            case 4:
+                                                _iteratorNormalCompletion = true;
+                                                return [
+                                                    3,
+                                                    2
+                                                ];
+                                            case 5:
+                                                return [
+                                                    3,
+                                                    8
+                                                ];
+                                            case 6:
+                                                err = _state.sent();
+                                                _didIteratorError = true;
+                                                _iteratorError = err;
+                                                return [
+                                                    3,
+                                                    8
+                                                ];
+                                            case 7:
+                                                try {
+                                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                        _iterator.return();
+                                                    }
+                                                } finally{
+                                                    if (_didIteratorError) {
+                                                        throw _iteratorError;
+                                                    }
+                                                }
+                                                return [
+                                                    7
+                                                ];
+                                            case 8:
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            }
                         }
-                    }
-                    return [
-                        7
                     ];
-                case 8:
-                    toggles = disabled.filter(function(feature) {
-                        return feature.name !== 'embed';
-                    }).map(function(feature) {
-                        return {
-                            name: feature.name,
-                            turnedOn: false
-                        };
-                    });
+            }
+        });
+    })();
+}
+function forcedPaths(classification, snapshot) {
+    if (!classification.fullRebuild) return classification.forcedPaths;
+    // New paths are reparsed by definition. Forcing every previously indexed path makes every
+    // survivor a reparse without a second filesystem scan outside prepareReconcile's one listing.
+    return new Set(snapshot.reconcile.existingRows.map(function(row) {
+        return row.path;
+    }));
+}
+function publishAttempt(conn, liveCfg, dialect, pool, ensureFeatureSchema, timing, attempt) {
+    return _async_to_generator(function() {
+        var _cfg_rootDir, _cfg_configDir, cfg, configIdentity, paths, wanted, snapshot, classification, invalidation, reconcile, mutated, txStart, txMs;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    cfg = structuredClone(liveCfg);
+                    configIdentity = JSON.stringify(cfg);
+                    paths = {
+                        rootDir: (_cfg_rootDir = cfg.rootDir) !== null && _cfg_rootDir !== void 0 ? _cfg_rootDir : cfg.baseDir,
+                        configDir: (_cfg_configDir = cfg.configDir) !== null && _cfg_configDir !== void 0 ? _cfg_configDir : cfg.baseDir
+                    };
+                    wanted = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
                     return [
                         4,
-                        invalidateFeatureToggles(conn, cfg, paths.rootDir, dialect, pool, toggles)
+                        readPlanningSnapshot(conn, timing)
                     ];
-                case 9:
-                    _state.sent();
-                    if (!disabled.some(function(feature) {
-                        return feature.name === 'embed';
-                    })) return [
-                        3,
-                        13
+                case 1:
+                    snapshot = _state.sent();
+                    classification = classifyBuild(snapshot, cfg, paths, wanted);
+                    return [
+                        4,
+                        prepareInvalidation(classification, snapshot, cfg, paths, pool)
                     ];
+                case 2:
+                    invalidation = _state.sent();
                     return [
                         4,
-                        conn.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'embeddings'")
+                        (0, _reconcilets.prepareReconcile)(snapshot.reconcile, cfg, paths, dialect, timing, pool, forcedPaths(classification, snapshot))
                     ];
-                case 10:
-                    embeddingsTable = _state.sent();
+                case 3:
+                    reconcile = _state.sent();
+                    mutated = classification.fullRebuild || invalidation.mutated || reconcile.mutated || snapshot.baseline.features !== wanted || snapshot.baseline.ready !== '1';
+                    if (buildPlan.hasSubscribers) buildPlan.publish({
+                        attempt: attempt,
+                        baseline: snapshot.baseline,
+                        wantedSignature: wanted
+                    });
+                    txStart = Date.now();
+                    _state.label = 4;
+                case 4:
+                    _state.trys.push([
+                        4,
+                        ,
+                        6,
+                        7
+                    ]);
                     return [
                         4,
-                        embeddingsTable.all()
+                        (0, _transactionts.withTransaction)(conn, function() {
+                            return _async_to_generator(function() {
+                                var current, currentWanted, publishedWanted;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                readCoreBaseline(conn)
+                                            ];
+                                        case 1:
+                                            current = _state.sent();
+                                            currentWanted = (0, _indexts.featureSignature)(liveCfg, _indexts1.FEATURES);
+                                            if (!sameBaseline(current, snapshot.baseline) || JSON.stringify(liveCfg) !== configIdentity || currentWanted !== wanted) {
+                                                throw new StaleBuildPlan('core generation or configuration changed while this build was planning');
+                                            }
+                                            if (!mutated) return [
+                                                2
+                                            ];
+                                            return [
+                                                4,
+                                                ensureFeatureSchema(cfg)
+                                            ];
+                                        case 2:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                invalidation.apply(conn)
+                                            ];
+                                        case 3:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                reconcile.apply(conn)
+                                            ];
+                                        case 4:
+                                            _state.sent();
+                                            publishedWanted = (0, _indexts.featureSignature)(liveCfg, _indexts1.FEATURES);
+                                            if (JSON.stringify(liveCfg) !== configIdentity || publishedWanted !== wanted) throw new StaleBuildPlan('configuration changed while this build was publishing');
+                                            return [
+                                                4,
+                                                (0, _sharedts.setMeta)(conn, _readinessts.FEATURE_SIGNATURE_META_KEY, wanted)
+                                            ];
+                                        case 5:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                (0, _sharedts.setMeta)(conn, _readinessts.CORE_READY_META_KEY, '1')
+                                            ];
+                                        case 6:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                (0, _sharedts.setMeta)(conn, _readinessts.CORE_GENERATION_META_KEY, nextGeneration(snapshot.baseline.generation))
+                                            ];
+                                        case 7:
+                                            _state.sent();
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        }, dialect.beginMode())
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        3,
+                        7
+                    ];
+                case 6:
+                    txMs = Date.now() - txStart;
+                    timing.txMs += txMs;
+                    return [
+                        7
                     ];
-                case 11:
-                    if (!(_state.sent().length > 0)) return [
+                case 7:
+                    if (!reconcile.mutated) return [
                         3,
-                        13
+                        9
                     ];
                     return [
                         4,
-                        (0, _transactionts.withTransaction)(conn, function() {
-                            return conn.exec('DELETE FROM embeddings');
-                        }, dialect.beginMode())
+                        reconcile.record(conn, txMs)
                     ];
-                case 12:
+                case 8:
                     _state.sent();
-                    _state.label = 13;
-                case 13:
-                    forcedPaths = new Set((0, _indexts2.listFiles)(cfg, paths.rootDir).map(function(file) {
-                        return file.relPath;
-                    }));
+                    _state.label = 9;
+                case 9:
                     return [
                         2,
-                        (0, _reconcilets.reconcile)(conn, cfg, paths, dialect, pool, forcedPaths)
+                        {
+                            parsed: invalidation.parsed + reconcile.parsed,
+                            warnings: reconcile.warnings,
+                            stages: reconcile.finish(timing.txMs),
+                            messages: classification.messages
+                        }
                     ];
             }
         });
     })();
 }
-function createBuilder(conn, cfg, paths, dialect) {
+function createBuilder(conn, cfg, dialect, ensureFeatureSchema) {
     var pool = new _poolts.ParsePool();
     return {
-        build: function build(forcedPaths) {
-            return (0, _reconcilets.reconcile)(conn, cfg, paths, dialect, pool, forcedPaths);
-        },
-        recover: function recover() {
-            return recoverIncomplete(conn, cfg, paths, dialect, pool);
-        },
-        invalidate: function invalidate(kind) {
-            return kind === 'model' ? nullEmbedVectors(conn, dialect) : rebuildEmbeddings(conn, cfg, paths.rootDir, dialect, pool);
-        },
-        invalidateFeatures: function invalidateFeatures(toggles) {
-            return invalidateFeatureToggles(conn, cfg, paths.rootDir, dialect, pool, toggles);
+        build: function build() {
+            return _async_to_generator(function() {
+                var timing, attempt, err;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // One clock and recorder span both bounded attempts. Baseline/catalog reads and feature
+                            // invalidation preparation are included in totalMs but remain intentionally unlabelled;
+                            // existing/list/parse and publication stages accumulate under their established labels.
+                            timing = (0, _reconcilets.createReconcileTiming)(cfg);
+                            attempt = 0;
+                            _state.label = 1;
+                        case 1:
+                            if (!(attempt < 2)) return [
+                                3,
+                                6
+                            ];
+                            _state.label = 2;
+                        case 2:
+                            _state.trys.push([
+                                2,
+                                4,
+                                ,
+                                5
+                            ]);
+                            return [
+                                4,
+                                publishAttempt(conn, cfg, dialect, pool, ensureFeatureSchema, timing, attempt)
+                            ];
+                        case 3:
+                            return [
+                                2,
+                                _state.sent()
+                            ];
+                        case 4:
+                            err = _state.sent();
+                            if (!_instanceof(err, StaleBuildPlan)) throw err;
+                            if (attempt === 1) throw new _errorsts.SenseError('STORE_BUSY', 'the index changed during both bounded publication attempts; wait for the competing build to finish and retry');
+                            return [
+                                3,
+                                5
+                            ];
+                        case 5:
+                            attempt++;
+                            return [
+                                3,
+                                1
+                            ];
+                        case 6:
+                            throw new Error('unreachable build attempt state');
+                    }
+                });
+            })();
         },
         close: function close() {
             return pool.close();