sensemaking 0.9.4 → 0.10.0

package/dist/cjs/cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { parseArgs } from 'node:util';\nimport { COMMANDS, USAGE } from './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/cli/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file. Flags parse\n// per command (each command's own parse() call); this file only handles the bare top-level\n// flags (--version/--help/--list/--config) and dispatch.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  const lines = Object.values(USAGE).map((u) => `       ${name} ${u}`);\n  return [`usage: ${name} <name> [params...] [--format table|json] [--config path]`, ...lines, `       ${name} --list`, `       ${name} --version`].join('\\n');\n}\n\nfunction resolveConfigFor(name: string, configPath: string | undefined) {\n  const cfg = loadConfig(configPath);\n  if (cfg.migratedFrom !== undefined) {\n    console.warn(`${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`);\n  }\n  if (cfg.unknownKeys !== undefined) {\n    console.warn(`${name}: ${cfg.configPath} sets ${cfg.unknownKeys.join(', ')}, which this build does not read (no effect); see schema.json for the keys it does`);\n  }\n  return cfg;\n}\n\n// Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  const first = argv[0];\n\n  // No command word, or the first token looks like a flag: the only flags this level knows.\n  if (!first || first.startsWith('-')) {\n    let values: Record<string, string | boolean | undefined>;\n    try {\n      ({ values } = parseArgs({\n        args: argv,\n        options: {\n          version: { type: 'boolean', default: false, short: 'v' },\n          help: { type: 'boolean', default: false, short: 'h' },\n          list: { type: 'boolean', default: false },\n          config: { type: 'string' },\n        },\n        allowPositionals: true,\n      }));\n    } catch (err) {\n      console.error((err as Error).message);\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    try {\n      if (values.version) {\n        console.log(packageVersion());\n        return;\n      }\n      if (values.help) {\n        console.log(usage(name));\n        return;\n      }\n      if (values.list) {\n        const queries = resolveConfigFor(name, values.config as string | undefined).queries;\n        for (const queryName of Object.keys(queries).sort()) {\n          const entry = queries[queryName];\n          const isSavedSearch = typeof entry === 'object' && entry !== null && 'search' in entry;\n          console.log(isSavedSearch ? `${queryName}  (search)` : queryName);\n        }\n        return;\n      }\n    } catch (err) {\n      console.error((err as Error).message);\n      process.exit(1);\n    }\n\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  // find -> search (breaking rename): one release of a pointer instead of \"unknown query\".\n  if (first === 'find') {\n    console.error(`${name}: find is now search`);\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  const ctx: Ctx = {\n    name,\n    argv: argv.slice(1),\n    resolveConfig: (configPath) => resolveConfigFor(name, configPath),\n    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first);\n  } catch (err) {\n    console.error((err as Error).message);\n    process.exit(1);\n  }\n}\n"],"names":["cli","packageVersion","load","createRequire","rel","pkg","name","version","usage","lines","Object","values","USAGE","map","u","join","resolveConfigFor","configPath","cfg","loadConfig","migratedFrom","undefined","console","warn","SUPPORTED_CONFIG_VERSION","unknownKeys","argv","first","queries","queryName","entry","isSavedSearch","ctx","err","startsWith","parseArgs","args","options","type","default","short","help","list","config","allowPositionals","error","message","process","exit","log","keys","sort","slice","resolveConfig","usageError","COMMANDS"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { parseArgs } from 'node:util';\nimport { COMMANDS, USAGE } from './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only; commands lazy-load from src/cli/, so nothing heavy is imported\n// here. Flags parse per command -- this file handles only --version/--help/--list/--config.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  const lines = Object.values(USAGE).map((u) => `       ${name} ${u}`);\n  return [`usage: ${name} <name> [params...] [--format table|json] [--config path]`, ...lines, `       ${name} --list`, `       ${name} --version`].join('\\n');\n}\n\nfunction resolveConfigFor(name: string, configPath: string | undefined) {\n  const cfg = loadConfig(configPath);\n  if (cfg.migratedFrom !== undefined) {\n    console.warn(`${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`);\n  }\n  if (cfg.unknownKeys !== undefined) {\n    console.warn(`${name}: ${cfg.configPath} sets ${cfg.unknownKeys.join(', ')}, which this build does not read (no effect); see schema.json for the keys it does`);\n  }\n  return cfg;\n}\n\n// Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  const first = argv[0];\n\n  // No command word, or the first token looks like a flag: the only flags this level knows.\n  if (!first || first.startsWith('-')) {\n    let values: Record<string, string | boolean | undefined>;\n    try {\n      ({ values } = parseArgs({\n        args: argv,\n        options: {\n          version: { type: 'boolean', default: false, short: 'v' },\n          help: { type: 'boolean', default: false, short: 'h' },\n          list: { type: 'boolean', default: false },\n          config: { type: 'string' },\n        },\n        allowPositionals: true,\n      }));\n    } catch (err) {\n      console.error((err as Error).message);\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    try {\n      if (values.version) {\n        console.log(packageVersion());\n        return;\n      }\n      if (values.help) {\n        console.log(usage(name));\n        return;\n      }\n      if (values.list) {\n        const queries = resolveConfigFor(name, values.config as string | undefined).queries;\n        for (const queryName of Object.keys(queries).sort()) {\n          // Every entry names its verb, so --list can label both kinds rather than only\n          // marking the exception.\n          console.log(`${queryName}  (${'search' in queries[queryName] ? 'search' : 'sql'})`);\n        }\n        return;\n      }\n    } catch (err) {\n      console.error((err as Error).message);\n      process.exit(1);\n    }\n\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  // Breaking renames get one release of a pointer instead of an \"unknown\" error: find ->\n  // search, and query -> sql (which took its name back from the search sense of \"query\").\n  const RENAMED: Record<string, string> = { find: 'search', query: 'sql' };\n  if (RENAMED[first]) {\n    console.error(`${name}: ${first} is now ${RENAMED[first]}`);\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  const ctx: Ctx = {\n    name,\n    argv: argv.slice(1),\n    resolveConfig: (configPath) => resolveConfigFor(name, configPath),\n    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first);\n  } catch (err) {\n    console.error((err as Error).message);\n    process.exit(1);\n  }\n}\n"],"names":["cli","packageVersion","load","createRequire","rel","pkg","name","version","usage","lines","Object","values","USAGE","map","u","join","resolveConfigFor","configPath","cfg","loadConfig","migratedFrom","undefined","console","warn","SUPPORTED_CONFIG_VERSION","unknownKeys","argv","first","queries","queryName","RENAMED","ctx","err","startsWith","parseArgs","args","options","type","default","short","help","list","config","allowPositionals","error","message","process","exit","log","keys","sort","find","query","slice","resolveConfig","usageError","COMMANDS"],"mappings":"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"}

package/dist/cjs/commands.d.cts

@@ -1,14 +1,17 @@
 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;
+    probe?: 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;
@@ -30,7 +33,8 @@ 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;
@@ -45,4 +49,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.d.ts

@@ -1,14 +1,17 @@
 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;
+    probe?: 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;
@@ -30,7 +33,8 @@ 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;
@@ -45,4 +49,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 = !opts.probe && 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) {
@@ -623,19 +645,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 +674,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 +703,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,24 +715,27 @@ 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 overrides = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
     var _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 frontmatter = {};
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
@@ -732,6 +764,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) {
@@ -769,4 +802,51 @@ function peek(db, cfg, pathArg) {
         })
     };
 }
+function relatedNotes(db, cfg, pathArg, overrides, k) {
+    return _async_to_generator(function() {
+        var paths, path, outbound, backlinks, exclude, 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)));
+                    allowed = scopedPaths(db, cfg, overrides);
+                    if (!scopeHasEmbeddings(db, cfg, allowed)) return [
+                        2,
+                        []
+                    ];
+                    // Vectors are the only signal, so [] would read as "nothing is related" rather than "no
+                    // model". Top up pending rows too, or a fresh index answers 0 until some search runs.
+                    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)');
+                    }
+                    return [
+                        4,
+                        (0, _embedts.embedPending)(db, cfg, cfg.baseDir)
+                    ];
+                case 1:
+                    _state.sent();
+                    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; }