sensemaking 0.9.5 → 0.11.0

package/dist/cjs/commands.d.ts

@@ -1,18 +1,21 @@
 import type { DatabaseSync } from 'node:sqlite';
-import type { FeatureName, ResolvedConfig } from './config.js';
+import type { FeatureName, ResolvedConfig, SearchOverrides } from './config.js';
 import type { Row } from './output.js';
 export interface SearchOptions {
     k?: number;
     where?: string;
     preset?: string;
     include?: string[];
-    semantic?: boolean;
+    exclude?: string[];
+    noExclude?: boolean;
 }
 export declare function search(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;
+export declare function scopedPaths(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides): Set<string>;
 export interface PresetCoverage {
     name: string;
     files: number;
     embedded: number;
+    semantic: boolean;
 }
 export declare function presetCoverage(db: DatabaseSync, cfg: ResolvedConfig): PresetCoverage[];
 export interface TreeMap {
@@ -30,11 +33,13 @@ export interface TreeMap {
     hubs: Row[];
     recent: Row[];
 }
-export declare function mapTree(db: DatabaseSync, cfg: ResolvedConfig): TreeMap;
+export declare function mapTree(db: DatabaseSync, cfg: ResolvedConfig, overrides?: SearchOverrides): TreeMap;
+export declare function resolveNote(paths: string[], arg: string): string;
 export interface Peek {
     path: string;
     tokens: number;
     frontmatter: Row;
+    parseError: string | null;
     sections: Row[];
     outbound: string[];
     backlinks: string[];
@@ -45,4 +50,8 @@ export interface Peek {
     unresolvedTotal: number;
     off: FeatureName[];
 }
-export declare function peek(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string): Peek;
+export declare function peek(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string, overrides?: SearchOverrides): Peek;
+export declare function relatedNotes(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{
+    path: string;
+    similarity: number;
+}>>;

package/dist/cjs/commands.js

@@ -18,6 +18,15 @@ _export(exports, {
     get presetCoverage () {
         return presetCoverage;
     },
+    get relatedNotes () {
+        return relatedNotes;
+    },
+    get resolveNote () {
+        return resolveNote;
+    },
+    get scopedPaths () {
+        return scopedPaths;
+    },
     get search () {
         return search;
     }
@@ -226,11 +235,8 @@ function _ts_generator(thisArg, body) {
 // Each returns data; cli.ts renders. All of them degrade when a feature is off.
 var WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0)';
 var RRF_K = 60;
-// FTS5 snippet() re-tokenizes the whole doc per candidate row, superlinearly: measured
-// 2ms at 4KB docs but 189ms at 64KB for one query's pool, and ~10s for a single 1MB doc
-// (plans/performance-findings.md finding A). 16KB keeps the whole pool's snippet cost in
-// the low-ms range; bigger docs get the JS-computed excerpt, linear and only for the rows
-// actually returned.
+// snippet() re-tokenizes each candidate doc, superlinearly: ~10s for one 1MB doc
+// (BENCHMARKING.md). Past this bound, rows get the linear JS excerpt instead.
 var SNIPPET_BOUND = 16384;
 var EXCERPT_WINDOW = 160;
 // Bare terms from an FTS5 query string: strips operators/quoting so the oversized-doc excerpt
@@ -367,8 +373,8 @@ function lineRangeFor(db, path, line) {
     return row ? "L".concat(row.start_line, "-").concat(row.end_line) : null;
 }
 // node:path's matchesGlob is experimental (stable behind an unstable-API flag) as of the
-// engines floor (Node >=22.16); scope filtering only ever needs single-pattern matching, so
-// it's used here in JS rather than pulling fast-glob's directory walk into the query path.
+// engines floor (Node >=22.20); scope filtering only ever needs single-pattern matching, so
+// it's used here in JS rather than running a directory walk in the query path.
 function inScope(path, include, exclude) {
     if (!include.some(function(g) {
         return (0, _nodepath.matchesGlob)(path, g);
@@ -387,7 +393,7 @@ function scopeHasEmbeddings(db, cfg, scopedPaths) {
 }
 function search(_0, _1, _2) {
     return _async_to_generator(function(db, cfg, terms) {
-        var opts, _hits_get, _chunkLines_get, _chunkSimilarity_get, effective, k, include, exclude, allPaths, scopedPaths, scopeActive, fetch, semanticEnabled, scope, whereJoin, whereCond, matchSql, matchRows, hits, oversized, candidates, edges, linked, seeds, ranked, chunkLines, chunkSimilarity, vec, insert, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, path, c, where, similarityCol, rows, bareTerms, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, row, text, _computeExcerpt, excerpt, offset;
+        var opts, _hits_get, _chunkLines_get, _chunkSimilarity_get, effective, k, include, exclude, allPaths, adHocScope, scopedPaths, scopeActive, fetch, wantsVectors, semanticEnabled, scope, whereJoin, whereCond, matchSql, matchRows, hits, oversized, candidates, edges, linked, seeds, ranked, chunkLines, chunkSimilarity, vec, insert, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, path, c, where, similarityCol, rows, bareTerms, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, row, text, _computeExcerpt, excerpt, offset;
         var _arguments = arguments;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -398,11 +404,10 @@ function search(_0, _1, _2) {
                     allPaths = db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
                         return r.path;
                     });
-                    // A preset scope reads preset_files -- the coverage reconcile actually indexed with
-                    // (fast-glob semantics); re-matching globs here with node:path's matchesGlob could
-                    // silently disagree with it. Ad-hoc --include has no persisted coverage, so only that
-                    // path pays the JS glob match.
-                    scopedPaths = opts.include ? new Set(allPaths.filter(function(p) {
+                    // A preset scope reads the coverage reconcile indexed; re-matching globs here could disagree
+                    // with it. Only ad-hoc scope flags, which have no persisted coverage, pay the JS match.
+                    adHocScope = opts.include !== undefined || opts.exclude !== undefined || opts.noExclude === true;
+                    scopedPaths = adHocScope ? new Set(allPaths.filter(function(p) {
                         return inScope(p, include, exclude);
                     })) : new Set(db.prepare('SELECT "path" FROM preset_files WHERE preset = ?').all(effective.presetName).map(function(r) {
                         return r.path;
@@ -412,16 +417,16 @@ function search(_0, _1, _2) {
                     // list that a plain over-fetch wouldn't have reached.
                     scopeActive = scopedPaths.size < allPaths.length;
                     fetch = scopeActive ? Math.max(k * 5, 50) : Math.max(k * 3, 30);
-                    // Semantic participation: vectors run only when the effective setting allows it AND the
-                    // scope actually has embedded files -- a scope covered only by semantic-false presets (or
-                    // by no preset embedding at all) searches lexically, automatically, no error.
-                    semanticEnabled = effective.semantic && scopeHasEmbeddings(db, cfg, scopedPaths);
-                    // Terms pass verbatim to FTS5 MATCH: bare words AND-join, operators are the caller's.
-                    // Invalid syntax propagates as an error, zero matches return zero -- no silent rewrites.
-                    // --where applies inside the candidate query (a post-filter over the top-N would drop
-                    // matches ranked past the pool) and again on the final select for link-derived rows.
-                    // An explicit --where replaces the preset's declared where rather than ANDing with it,
-                    // so a caller can always widen back to the whole scope.
+                    // Asking for vectors without a model is a misconfiguration, not a mode: degrading would make
+                    // the same search answer differently before and after a download. semantic:false never asks.
+                    wantsVectors = effective.semantic && (0, _configts.anyPresetEmbeds)(cfg);
+                    if (wantsVectors && !(0, _embedts.modelPresent)(cfg)) {
+                        throw new _errorsts.SenseError('EMBED_MODEL_MISSING', 'preset "'.concat(effective.presetName, '" searches with vectors, but the embedding model is not available; run `sense download`, or set "semantic": false on that preset to search on words and links'));
+                    }
+                    semanticEnabled = wantsVectors && scopeHasEmbeddings(db, cfg, scopedPaths);
+                    // Terms pass verbatim to MATCH; invalid syntax errors rather than being rewritten. --where
+                    // applies inside the candidate query (a post-filter would drop matches ranked past the pool)
+                    // and again on the final select, for link-derived rows.
                     scope = effective.where;
                     whereJoin = scope ? 'JOIN frontmatter f ON f."path" = content.path' : '';
                     whereCond = scope ? "AND (".concat(scope, ")") : '';
@@ -461,10 +466,8 @@ function search(_0, _1, _2) {
                     });
                     edges = (0, _configts.featureEnabled)(cfg, 'links') && matchRows.length > 0 ? (0, _indexts.linkEdges)(db) : [];
                     if (edges.length > 0) {
-                        // `linked` gates the label only, not the score: PPR restart mass gives every seed a
-                        // nonzero rank even without an incident edge, which is not link evidence — but dropping
-                        // that mass from the score list reweights fusion toward connectivity and measurably
-                        // wrecks ranking on link-dense corpora (FEVER hit@10 0.997 -> 0.907; fusion-tuning.md).
+                        // Gates the label only, not the score: restart mass ranks every seed without an incident
+                        // edge, but dropping it from the score reweights fusion (FEVER hit@10 0.997 -> 0.907).
                         linked = new Set(edges.flat());
                         seeds = new Map(matchRows.map(function(r, i) {
                             return [
@@ -525,9 +528,9 @@ function search(_0, _1, _2) {
                     });
                     _state.label = 2;
                 case 2:
-                    db.exec('DROP TABLE IF EXISTS _find');
-                    db.exec('CREATE TEMP TABLE _find ("path" TEXT PRIMARY KEY, score REAL, via TEXT, hit TEXT, lines TEXT, similarity REAL)');
-                    insert = db.prepare('INSERT INTO _find ("path", score, via, hit, lines, similarity) VALUES (?, ?, ?, ?, ?, ?)');
+                    db.exec('DROP TABLE IF EXISTS _search');
+                    db.exec('CREATE TEMP TABLE _search ("path" TEXT PRIMARY KEY, score REAL, via TEXT, hit TEXT, lines TEXT, similarity REAL)');
+                    insert = db.prepare('INSERT INTO _search ("path", score, via, hit, lines, similarity) VALUES (?, ?, ?, ?, ?, ?)');
                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
                         for(_iterator = candidates[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
@@ -548,15 +551,13 @@ function search(_0, _1, _2) {
                             }
                         }
                     }
-                    // Every candidate list was already filtered to scopedPaths above, so _find only ever holds
-                    // in-scope rows -- the final select just needs --where again, same as before, for rows
-                    // whichever candidate query didn't itself apply it to (link-derived rows never touched
-                    // whereCond above).
+                    // Already scope-filtered above; the final select reapplies --where only for link-derived
+                    // rows, which never passed through whereCond.
                     where = scope ? "WHERE (".concat(scope, ")") : '';
                     // lines is always present now: semantic rows carry their chunk's range, oversized-doc
                     // lexical rows gain one below, everything else stays null. similarity stays semantic-only.
-                    similarityCol = semanticEnabled ? ', _find.similarity' : '';
-                    rows = db.prepare('SELECT f."path" AS path, content.title, content.summary, _find.hit, _find.via, round(_find.score, 4) AS score, _find.lines'.concat(similarityCol, '\n       FROM _find JOIN frontmatter f ON f."path" = _find."path" JOIN content ON content.path = _find."path"\n       ').concat(where, " ORDER BY _find.score DESC LIMIT ?")).all(k);
+                    similarityCol = semanticEnabled ? ', _search.similarity' : '';
+                    rows = db.prepare('SELECT f."path" AS path, content.title, content.summary, _search.hit, _search.via, round(_search.score, 4) AS score, _search.lines'.concat(similarityCol, '\n       FROM _search JOIN frontmatter f ON f."path" = _search."path" JOIN content ON content.path = _search."path"\n       ').concat(where, " ORDER BY _search.score DESC LIMIT ?")).all(k);
                     if (oversized.size > 0) {
                         bareTerms = extractBareTerms(terms);
                         _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
@@ -597,6 +598,27 @@ function search(_0, _1, _2) {
         });
     }).apply(this, arguments);
 }
+function scopedPaths(db, cfg, overrides) {
+    var effective = (0, _configts.resolveSearch)(cfg, overrides);
+    var include = effective.include, exclude = effective.exclude, where = effective.where;
+    var allPaths = db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
+        return r.path;
+    });
+    var adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;
+    var paths = adHocScope ? new Set(allPaths.filter(function(p) {
+        return inScope(p, include, exclude);
+    })) : new Set(db.prepare('SELECT "path" FROM preset_files WHERE preset = ?').all(effective.presetName).map(function(r) {
+        return r.path;
+    }));
+    if (!where) return paths;
+    var whereRows = db.prepare('SELECT "path" FROM frontmatter f WHERE ('.concat(where, ")")).all();
+    var wherePaths = new Set(whereRows.map(function(r) {
+        return r.path;
+    }));
+    return new Set(_to_consumable_array(paths).filter(function(p) {
+        return wherePaths.has(p);
+    }));
+}
 function presetCoverage(db, cfg) {
     var embedActive = (0, _configts.anyPresetEmbeds)(cfg);
     return (0, _configts.presetNames)(cfg).map(function(name) {
@@ -605,7 +627,8 @@ function presetCoverage(db, cfg) {
         return {
             name: name,
             files: files,
-            embedded: embedded
+            embedded: embedded,
+            semantic: (0, _configts.presetSemanticEnabled)(cfg, name)
         };
     });
 }
@@ -613,7 +636,8 @@ var INTERNAL_COLUMNS = new Set([
     'path',
     '_mtime',
     '_size',
-    '_rank'
+    '_rank',
+    '_parse_error'
 ]);
 // A result row is capped at SQLITE_MAX_COLUMN (2000, default); two aggregate expressions
 // per field keeps a chunk's row safely under that regardless of how many fields the tree has.
@@ -623,19 +647,26 @@ function chunk(items, size) {
     for(var i = 0; i < items.length; i += size)out.push(items.slice(i, i + size));
     return out;
 }
+// Materializes the resolved scope into a temp table (same shape as traverse.ts's
+// allowed_nodes) so every mapTree query can join/filter against it cheaply.
+function setupMapScope(db, paths) {
+    db.exec('DROP TABLE IF EXISTS _map_scope');
+    db.exec('CREATE TEMP TABLE _map_scope ("path" TEXT PRIMARY KEY)');
+    db.prepare('INSERT INTO _map_scope SELECT DISTINCT value FROM json_each(?1)').run(JSON.stringify(_to_consumable_array(paths)));
+}
 function mapTree(db, cfg) {
-    var docs = db.prepare('SELECT COUNT(*) AS count, COALESCE(SUM("_size"), 0) AS bytes FROM frontmatter').get();
+    var overrides = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    setupMapScope(db, scopedPaths(db, cfg, overrides));
+    var scopeWhere = 'WHERE "path" IN (SELECT "path" FROM _map_scope)';
+    var scopeAnd = 'AND f."path" IN (SELECT "path" FROM _map_scope)';
+    var docs = db.prepare('SELECT COUNT(*) AS count, COALESCE(SUM("_size"), 0) AS bytes FROM frontmatter '.concat(scopeWhere)).get();
     var columns = db.prepare('PRAGMA table_info(frontmatter)').all().map(function(r) {
         return r.name;
     }).filter(function(name) {
         return !INTERNAL_COLUMNS.has(name);
     });
-    // Observed storage class, not a declared one: these columns are added dynamically and
-    // SQLite types per value, so a field can be text in most notes and numeric in a few.
-    // Listing every distinct type makes both the type and any drift visible.
-    // One aggregate scan per chunk of columns rather than one scan per column: COUNT already
-    // ignores NULL, and FILTER keeps typeof() looking only at the non-null rows COUNT counted,
-    // matching the old per-column `WHERE ... IS NOT NULL` exactly.
+    // Observed types, not declared: SQLite types per value, so a field can be text in most notes
+    // and numeric in a few. One aggregate scan per chunk of columns; FILTER matches COUNT's nulls.
     var allFields = [];
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
@@ -645,7 +676,7 @@ function mapTree(db, cfg) {
                 var quoted = '"'.concat(name.split('"').join('""'), '"');
                 return "COUNT(".concat(quoted, ") AS n").concat(i, ", GROUP_CONCAT(DISTINCT typeof(").concat(quoted, ")) FILTER (WHERE ").concat(quoted, " IS NOT NULL) AS t").concat(i);
             });
-            var result = db.prepare("SELECT ".concat(exprs.join(', '), " FROM frontmatter")).get();
+            var result = db.prepare("SELECT ".concat(exprs.join(', '), " FROM frontmatter ").concat(scopeWhere)).get();
             group.forEach(function(name, i) {
                 var _result_;
                 return allFields.push({
@@ -674,8 +705,8 @@ function mapTree(db, cfg) {
         return b.coverage - a.coverage;
     });
     var fields = allFields.slice(0, 20);
-    var hubs = (0, _configts.featureEnabled)(cfg, 'rank') ? db.prepare('SELECT f."path" AS path, round(f."_rank" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f."path" WHERE f."_rank" IS NOT NULL ORDER BY f."_rank" DESC LIMIT 8').all() : [];
-    var recent = db.prepare('SELECT "path", datetime("_mtime" / 1000, \'unixepoch\') AS modified FROM frontmatter ORDER BY "_mtime" DESC LIMIT 5').all();
+    var hubs = (0, _configts.featureEnabled)(cfg, 'rank') ? db.prepare('SELECT f."path" AS path, round(f."_rank" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f."path" WHERE f."_rank" IS NOT NULL '.concat(scopeAnd, ' ORDER BY f."_rank" DESC LIMIT 8')).all() : [];
+    var recent = db.prepare('SELECT "path", datetime("_mtime" / 1000, \'unixepoch\') AS modified FROM frontmatter '.concat(scopeWhere, ' ORDER BY "_mtime" DESC LIMIT 5')).all();
     return {
         docs: docs,
         fields: fields,
@@ -686,25 +717,29 @@ function mapTree(db, cfg) {
         recent: recent
     };
 }
+function resolveNote(paths, arg) {
+    var exact = paths.find(function(p) {
+        return p === arg;
+    });
+    if (exact) return exact;
+    var base = _posix.default.basename(arg).replace(/\.md$/i, '').toLowerCase();
+    var matches = paths.filter(function(p) {
+        return _posix.default.basename(p).replace(/\.md$/i, '').toLowerCase() === base;
+    });
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) throw new _errorsts.SenseError('NOTE_AMBIGUOUS', '"'.concat(arg, '" is ambiguous: ').concat(matches.join(', ')));
+    throw new _errorsts.SenseError('NOTE_NOT_FOUND', 'no note matches "'.concat(arg, '"'));
+}
 var PEEK_LIST_LIMIT = 20;
 function peek(db, cfg, pathArg) {
-    var _row__size;
+    var overrides = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+    var _row__parse_error, _row__size;
     var paths = db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
         return r.path;
     });
-    var path = paths.find(function(p) {
-        return p === pathArg;
-    });
-    if (!path) {
-        var base = _posix.default.basename(pathArg).replace(/\.md$/i, '').toLowerCase();
-        var matches = paths.filter(function(p) {
-            return _posix.default.basename(p).replace(/\.md$/i, '').toLowerCase() === base;
-        });
-        if (matches.length === 1) path = matches[0];
-        else if (matches.length > 1) throw new _errorsts.SenseError('NOTE_AMBIGUOUS', '"'.concat(pathArg, '" is ambiguous: ').concat(matches.join(', ')));
-        else throw new _errorsts.SenseError('NOTE_NOT_FOUND', 'no note matches "'.concat(pathArg, '"'));
-    }
+    var path = resolveNote(paths, pathArg);
     var row = db.prepare('SELECT * FROM frontmatter WHERE "path" = ?').get(path);
+    var parseError = (_row__parse_error = row._parse_error) !== null && _row__parse_error !== void 0 ? _row__parse_error : null;
     var frontmatter = {};
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
@@ -732,6 +767,7 @@ function peek(db, cfg, pathArg) {
     var backlinks = [];
     var unresolved = [];
     var backlinksTotal = 0;
+    var _allowed = scopedPaths(db, cfg, overrides);
     if ((0, _configts.featureEnabled)(cfg, 'links')) {
         var out = db.prepare('SELECT target, dst FROM links WHERE src = ? ORDER BY target').all(path);
         outbound = _to_consumable_array(new Set(out.filter(function(l) {
@@ -753,6 +789,7 @@ function peek(db, cfg, pathArg) {
         path: path,
         tokens: Math.ceil(((_row__size = row._size) !== null && _row__size !== void 0 ? _row__size : 0) / 4),
         frontmatter: frontmatter,
+        parseError: parseError,
         sections: sections,
         outbound: outbound.slice(0, PEEK_LIST_LIMIT),
         backlinks: backlinks,
@@ -769,4 +806,67 @@ function peek(db, cfg, pathArg) {
         })
     };
 }
+function relatedNotes(db, cfg, pathArg, overrides, k) {
+    return _async_to_generator(function() {
+        var paths, path, outbound, backlinks, exclude, effective, allowed;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    paths = db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
+                        return r.path;
+                    });
+                    path = resolveNote(paths, pathArg);
+                    outbound = db.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL').all(path).map(function(r) {
+                        return r.dst;
+                    });
+                    backlinks = db.prepare('SELECT DISTINCT src FROM links WHERE dst = ?').all(path).map(function(r) {
+                        return r.src;
+                    });
+                    exclude = new Set([
+                        path
+                    ].concat(_to_consumable_array(outbound), _to_consumable_array(backlinks)));
+                    // Vectors are the only signal `related` has, so every way of not having them is an error
+                    // naming the cause. An empty table then means one thing: nothing near in meaning that this
+                    // note does not already link to, which is a real answer.
+                    effective = (0, _configts.resolveSearch)(cfg, overrides);
+                    if (!(0, _configts.embedEnabled)(cfg)) {
+                        throw new _errorsts.SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an "embed" block naming one to sense.config.json, then run `sense download` (search works without it, on words and links)');
+                    }
+                    // search gates on the same flag (see wantsVectors above); reading it here too keeps
+                    // `semantic: false` meaning one thing. Without this, an overlapping semantic-on preset's
+                    // vectors would answer for a scope that declined them.
+                    if (!effective.semantic) {
+                        throw new _errorsts.SenseError('PRESET_NOT_SEMANTIC', 'preset "'.concat(effective.presetName, '" sets "semantic": false, so this scope has no vectors and related has no other signal; search it instead (words and links), or set semantic back on for that preset'));
+                    }
+                    if (!(0, _embedts.modelPresent)(cfg)) {
+                        throw new _errorsts.SenseError('EMBED_MODEL_MISSING', 'related ranks notes by meaning, so it needs the embedding model, which is not downloaded; run `sense download` (search still works without it, on words and links)');
+                    }
+                    allowed = scopedPaths(db, cfg, overrides);
+                    // Top up pending rows before the seed check, or a fresh index reports every note as
+                    // having no indexed text until some search has run.
+                    return [
+                        4,
+                        (0, _embedts.embedPending)(db, cfg, cfg.baseDir)
+                    ];
+                case 1:
+                    _state.sent();
+                    if (!(0, _embedts.hasEmbedding)(db, path)) {
+                        throw new _errorsts.SenseError('NOTE_NOT_EMBEDDED', "".concat(path, " has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning"));
+                    }
+                    if (!scopeHasEmbeddings(db, cfg, allowed)) return [
+                        2,
+                        []
+                    ];
+                    return [
+                        2,
+                        (0, _embedts.similarNotes)(db, cfg, path, {
+                            exclude: exclude,
+                            allowed: allowed,
+                            k: k
+                        })
+                    ];
+            }
+        });
+    })();
+}
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }