@deepseek-insight/dsi 0.6.12 → 0.6.14

package/build/client/_app/version.json

@@ -1 +1 @@
-{"version":"1791369987011"}
+{"version":"1791706063586"}

package/build/handler.js

@@ -2,9 +2,9 @@ import './shims.js';
 import 'node:fs';
 import 'node:path';
 import 'node:process';
-export { h as handler } from './server/chunks/handler-Bx2fbkEJ.js';
-import './server/chunks/index.js-BldXQ38P.js';
-import './server/chunks/manifest.js-Du-9DaEd.js';
+export { h as handler } from './server/chunks/handler-XuK3Ihhf.js';
+import './server/chunks/index.js-D2FEiD0I.js';
+import './server/chunks/manifest.js-B_kahcFI.js';
 import './env.js';
 import 'node:buffer';
 import 'node:crypto';
@@ -16,8 +16,9 @@ import './server/chunks/chunks/shared.js-HQ0rfhm4.js';
 import './server/chunks/chunks/uneval.js-BJ9Qq2SF.js';
 import './server/chunks/chunks/utils.js-CAdNO8Tu.js';
 import 'node:url';
-import './server/chunks/chunks/internal.js-D_QJoxN-.js';
-import './server/chunks/chunks/server.js-11-pxAWV.js';
-import './server/chunks/chunks/internal2.js-BcS47nI-.js';
+import './server/chunks/chunks/index-server.js-CV2lq-ha.js';
+import './server/chunks/chunks/server.js-DqHGsQU2.js';
+import './server/chunks/chunks/internal.js-BcS47nI-.js';
+import './server/chunks/chunks/internal2.js-DAPn3Vk8.js';
 import './server/chunks/chunks/exports.js-DH_tjtdv.js';
 //# sourceMappingURL=handler.js.map

package/build/index.js

@@ -1,7 +1,7 @@
 import http from 'node:http';
 import fs__default from 'node:fs';
 import process from 'node:process';
-import { p as polka, h as handler, f as format_listening_address } from './server/chunks/handler-Bx2fbkEJ.js';
+import { p as polka, h as handler, f as format_listening_address } from './server/chunks/handler-XuK3Ihhf.js';
 import { env, timeout_env } from './env.js';
 import { rm } from 'node:fs/promises';
 import './shims.js';
@@ -14,12 +14,13 @@ import 'node:stream';
 import './server/chunks/chunks/shared.js-HQ0rfhm4.js';
 import './server/chunks/chunks/uneval.js-BJ9Qq2SF.js';
 import './server/chunks/chunks/utils.js-CAdNO8Tu.js';
-import './server/chunks/index.js-BldXQ38P.js';
-import './server/chunks/chunks/internal.js-D_QJoxN-.js';
-import './server/chunks/chunks/server.js-11-pxAWV.js';
-import './server/chunks/chunks/internal2.js-BcS47nI-.js';
+import './server/chunks/index.js-D2FEiD0I.js';
+import './server/chunks/chunks/index-server.js-CV2lq-ha.js';
+import './server/chunks/chunks/server.js-DqHGsQU2.js';
+import './server/chunks/chunks/internal.js-BcS47nI-.js';
+import './server/chunks/chunks/internal2.js-DAPn3Vk8.js';
 import './server/chunks/chunks/exports.js-DH_tjtdv.js';
-import './server/chunks/manifest.js-Du-9DaEd.js';
+import './server/chunks/manifest.js-B_kahcFI.js';
 import 'node:url';
 
 const path = env('SOCKET_PATH', false);

package/build/server/chunks/chunks/{app-config.svelte.js-BW7TwbBy.js → app-config.svelte.js-D7wkLUkK.js}

@@ -328,5 +328,5 @@ function appConfig() {
 	return config;
 }
 
-export { appConfig as a, textPreviewOf as b, shouldRecordPrompt as c, parseTagWords as d, getTrigger as g, isValidTagWord as i, previewSegments as p, searchKey as s, triggerMode as t };
-//# sourceMappingURL=app-config.svelte.js-BW7TwbBy.js.map
+export { appConfig as a, parseTagWords as b, searchKey as c, textPreviewOf as d, getTrigger as g, isValidTagWord as i, previewSegments as p, shouldRecordPrompt as s, triggerMode as t };
+//# sourceMappingURL=app-config.svelte.js-D7wkLUkK.js.map

package/build/server/chunks/chunks/{db.js-BylhmazO.js → db.js-DRhjT6xK.js}

@@ -1,4 +1,4 @@
-import { D as DSI_CONFIG_PATH } from './insight-config.js-XUD5BN0g.js';
+import { D as DSI_CONFIG_PATH } from './insight-config.js-CA-iT3lB.js';
 import { mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -117,4 +117,4 @@ function pruneTerminalBefore(cutoffMs, db = openA2aDb()) {
 }
 
 export { listRecent as a, getRow as g, insertWaiting as i, listWaiting as l, openA2aDb as o, pruneTerminalBefore as p, settleRow as s };
-//# sourceMappingURL=db.js-BylhmazO.js.map
+//# sourceMappingURL=db.js-DRhjT6xK.js.map

package/build/server/chunks/chunks/{db2.js-Cm8FBINY.js → db2.js-DUta2B-n.js}

@@ -1,36 +1,21 @@
-import { d as readPromptsConfig, D as DSI_CONFIG_PATH, j as joinTagWords, p as parseTagWords } from './insight-config.js-XUD5BN0g.js';
+import { d as readPromptsConfig, D as DSI_CONFIG_PATH, j as joinTagWords, p as parseTagWords } from './insight-config.js-CA-iT3lB.js';
 import { mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { homedir } from 'node:os';
 
-//#region src/lib/server/prompts/db.ts
+//#region src/lib/server/prompts/connection.ts
 /**
-* prompts-db (2026-08-28) — the Shelf: one global store of operator prompt
-* habits behind the DSI composer's `?` finder. Every admitted ordinary
-* send is recorded (first send creates the row, later sends increment);
-* search matches label/text prefix (legacy) or contains/fuzzy (`?`,
-* tier waterfall); ranking is use_count DESC, last_used_at DESC. Table is
-* capped at 5,000 rows — overflow prunes the oldest use_count=1 rows
-* (LRU of one-offs; multi-use rows are never pruned). A disposable FTS5
-* trigram index (schema v2) shadows the table for `?` search; any FTS
-* failure degrades to LIKE — never blocks open, never throws to a route.
+* prompts-db connection (2026-10-10) — lifecycle half of the Shelf, moved
+* WHOLE from db.ts (ADR-0019 standard, ADR-0022 W1). Path resolution
+* (explicit arg -> DSI_PROMPTS_DB env -> settings dbPath -> ~/.dsi default,
+* ~/ expanded), version-gated migrate, the cached default handle, and the
+* close/reset test seams. Degrade contract: never throws to a route —
+* failures are warned and return null/false.
 *
-* Spec: dev/specs/2026-08-28 - DSI Suggest Strip (PRD Module Map
-*      "prompts-db"; Tasks 1.1). Reference: OCI src/lib/server/prompts/db.ts
-*      (behavioral reference — semantics ported, names/seams DSI-native).
-*
-* Storage: node:sqlite DatabaseSync, zero new npm deps. File lives at
-* `~/.dsi/prompts.sqlite` by default (DSI_CONFIG_PATH sibling, same trust
-* boundary as a2a.sqlite — operator-copied 2026-08-28 with 30 seeded
-* rows); `prompts.dbPath` in settings.yaml moves it (~/ expanded), and
-* `DSI_PROMPTS_DB` env override is the test seam (each
-* node-env-globed test file points it at a tmp path before first open).
-*
-* Module boundary (PRD communication map): this module imports the
-* config layer only (for the directory) — never dsh-connection, never
-* dsh-rpc (D10), never the client suggest service (fuzzy math is
-* server-local so the client never crosses into $lib/server).
+* Moved verbatim from db.ts by line range; private helpers widened to
+* default-public where siblings import them (sanctioned seam, no signature
+* changes).
 */
 /** Library filename under `~/.dsi/`. */
 var PROMPTS_DB_FILENAME = "prompts.sqlite";
@@ -237,51 +222,167 @@ function migrate(db) {
 		warn("migration failed:", e);
 	}
 }
+/** The canonical projection of a prompts row (every query selects this). */
 var SELECT_COLS = "id, label, text, use_count, macro, last_used_at, created_at, tags";
+/** SQL fragment filtering the macro flag — empty when unfiltered (the
+*  finder shows macros and ordinary prompts alike; the manager filters). */
+function macroCond(macro) {
+	return macro === void 0 ? "" : ` AND macro = ${macro}`;
+}
+/** Dice similarity floor for tier-2 inclusion — PER TERM (min-combine,
+*  S3): a row is only as strong as its weakest keyword. Below = noise; the
+*  ADR word-share decoy scores 0.174 — excluded. */
+var FUZZY_DICE_FLOOR = .3;
 /**
-* Count-only use recording (The Prompt Tags ADR, 2026-09-14, D7): bump
-* use_count + refresh last_used_at for an EXISTING row; unknown text
-* returns { counted: false } and inserts NOTHING — the wire's only path
-* to a row is an operator save. Null on failure (DB unavailable/empty text).
+* Split a `?`-search key into keyword terms (ADR S1; separator charset
+* widened by ADR-0014 D2): split on `,`, `;`, `+`, or whitespace, trim,
+* drop empties, dedupe (case-insensitive, first spelling wins).
+* `adr, spec + task` → [adr, spec, task]; `load;;skill;` → [load, skill];
+* single term → array of one — the caller decides which path runs.
+* Empty/blank key → []. Pure; exported for tests.
 */
-function countPromptUse(text) {
-	const trimmed = text.trim();
-	if (!trimmed) return null;
-	const db = openPromptsDb();
-	if (!db) return null;
-	try {
-		if (db.prepare(`UPDATE prompts
-       SET use_count = use_count + 1, last_used_at = datetime('now')
-       WHERE text = ?`).run(trimmed).changes === 0) return { counted: false };
-		const row = db.prepare(`SELECT ${SELECT_COLS} FROM prompts WHERE text = ?`).get(trimmed);
-		return row ? {
-			counted: true,
-			record: row
-		} : null;
-	} catch (e) {
-		warn("countPromptUse failed:", e);
-		return null;
+function splitQueryTerms(key) {
+	const seen = /* @__PURE__ */ new Set();
+	const terms = [];
+	for (const frag of key.split(/[,;+\s]+/)) {
+		const raw = frag.trim();
+		if (!raw) continue;
+		const lower = raw.toLowerCase();
+		if (seen.has(lower)) continue;
+		seen.add(lower);
+		terms.push({
+			raw,
+			lower
+		});
+	}
+	return terms;
+}
+/** Dice coefficient over character trigrams (case handled by callers). */
+function diceSimilarity(a, b) {
+	const grams = /* @__PURE__ */ new Map();
+	for (let i = 0; i + 3 <= a.length; i++) {
+		const g = a.slice(i, 3 + i);
+		grams.set(g, (grams.get(g) ?? 0) + 1);
+	}
+	if (grams.size === 0) return 0;
+	let bCount = 0;
+	let shared = 0;
+	for (let i = 0; i + 3 <= b.length; i++) {
+		bCount++;
+		const g = b.slice(i, 3 + i);
+		const have = grams.get(g) ?? 0;
+		if (have > 0) {
+			shared++;
+			if (have === 1) grams.delete(g);
+			else grams.set(g, have - 1);
+		}
 	}
+	if (bCount === 0) return 0;
+	const aCount = a.length - 2;
+	return 2 * shared / (aCount + bCount);
 }
 /**
-* Cap enforcement (ADR D13): if rows > MAX_ROWS, delete the oldest
-* use_count=1 rows until at cap. Multi-use prompts are never pruned.
+* Word-level similarity: max of Dice and normalized edit distance — Dice is
+* meaningless for words shorter than 3 trigrams/chars, edit covers them
+* ("lod" vs "load": Dice 0, edit 0.75 → 0.75). Exported for tests.
 */
-function pruneIfNeeded(db) {
-	try {
-		const overflow = db.prepare("SELECT COUNT(*) AS n FROM prompts").get().n - MAX_ROWS;
-		if (overflow <= 0) return;
-		db.prepare(`DELETE FROM prompts
-       WHERE id IN (
-         SELECT id FROM prompts
-         WHERE use_count <= 1
-         ORDER BY last_used_at ASC, id ASC
-         LIMIT ?
-       )`).run(overflow);
-	} catch (e) {
-		warn("prune failed:", e);
+function wordSimilarity(a, b) {
+	const edit = 1 - levenshtein(a, b) / Math.max(a.length, b.length);
+	return Math.max(diceSimilarity(a, b), edit);
+}
+/** Wagner–Fischer edit distance (two-row DP), case handled by callers. */
+function levenshtein(a, b) {
+	if (a === b) return 0;
+	if (!a.length) return b.length;
+	if (!b.length) return a.length;
+	let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i++) {
+		const cur = [i];
+		for (let j = 1; j <= b.length; j++) cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+		prev = cur;
+	}
+	return prev[b.length];
+}
+/** Lines a row offers to line-level Dice (S3): label counts as the FIRST
+*  line — the user-chosen handle deserves line parity with text lines. */
+function rowLines(row) {
+	return row.label !== null ? [row.label, ...row.text.split("\n")] : row.text.split("\n");
+}
+/** Best-line score for ONE term (S3): max over the row's lines, where a
+*  line's score is the best of whole-line Dice and word-level similarity
+*  over the line's words (max of Dice and normalized edit distance — Dice
+*  is meaningless for words shorter than 3 trigrams, edit covers them:
+*  typo'd "lod" vs "load" clears the floor at word level while line-level
+*  trigram dilution would sink it). The word-aware allowance is what keeps
+*  typo'd short terms reachable under min-combine as part of a multi-term
+*  key. Localizing to the best line kills the body tax: a 400-char body
+*  diluting full-text Dice can no longer sink a term that matches its own
+*  line cleanly. */
+function termLineScore(term, row) {
+	let best = 0;
+	for (const line of rowLines(row)) {
+		const l = line.toLowerCase();
+		if (l.includes(term)) {
+			best = 1;
+			break;
+		}
+		let lineScore = diceSimilarity(term, l);
+		for (const word of l.split(/\s+/)) {
+			if (!word) continue;
+			lineScore = Math.max(lineScore, wordSimilarity(term, word));
+		}
+		best = Math.max(best, lineScore);
+	}
+	return best;
+}
+/** FTS5 trigram set for a single term (S3): grams of the lowercased term
+*  only — never extracted across separators, so no junk grams bridge
+*  `;`-split keywords. Deduped; null for <3-char terms (no grams). */
+function termTrigramExpr(term) {
+	const k = term.toLowerCase();
+	const grams = [];
+	for (let i = 0; i + 3 <= k.length && grams.length < 64; i++) {
+		const g = k.slice(i, 3 + i);
+		if (!grams.includes(g)) grams.push(g);
+	}
+	return grams.length ? grams.map((g) => `"${g}"`).join(" OR ") : null;
+}
+/** Tier 2 — per-term best-line Dice, min-combine (S3, Semicolon Search).
+*  Candidate pool: per-term trigram OR + bm25 cap 50, UNION of per-term
+*  pools capped 100 — a row matching ANY term fuzzily enters the pool;
+*  per-term scoring then enforces the AND. Row score = MIN over terms of
+*  (max Dice over the row's lines, label counts as first line); any term
+*  under the 0.3 floor excludes the row entirely. Ordering: score DESC,
+*  use_count DESC, last_used_at DESC. Never mixes with tier 1 (only runs
+*  when tier 1 returned empty). */
+function fuzzyReRank(db, terms, limit, macro) {
+	const pool = /* @__PURE__ */ new Map();
+	for (const term of terms) {
+		if (term.lower.length < 3) continue;
+		const expr = termTrigramExpr(term.lower);
+		if (!expr) continue;
+		try {
+			const rows = db.prepare(`SELECT ${SELECT_COLS} FROM prompts
+           WHERE id IN (
+             SELECT rowid FROM prompts_fts WHERE prompts_fts MATCH ?
+             ORDER BY bm25(prompts_fts) LIMIT 50
+           )${macroCond(macro)}`).all(expr);
+			for (const r of rows) {
+				if (pool.size >= 100) break;
+				if (!pool.has(r.id)) pool.set(r.id, r);
+			}
+		} catch {}
 	}
+	if (pool.size === 0) return [];
+	return [...pool.values()].map((row) => {
+		return {
+			row,
+			score: terms.reduce((min, t) => Math.min(min, termLineScore(t.lower, row)), 1)
+		};
+	}).filter((s) => s.score >= FUZZY_DICE_FLOOR).sort((a, b) => b.score - a.score || b.row.use_count - a.row.use_count || (b.row.last_used_at < a.row.last_used_at ? 1 : b.row.last_used_at > a.row.last_used_at ? -1 : 0)).slice(0, limit).map((s) => s.row);
 }
+//#endregion
+//#region src/lib/server/prompts/search.ts
 /**
 * Search prompts. Ranked by use_count DESC, last_used_at DESC.
 *
@@ -316,48 +417,10 @@ function searchPrompts(prefix, limit = 5, opts) {
 		return [];
 	}
 }
-/** SQL fragment filtering the macro flag — empty when unfiltered (the
-*  value is a server-internal 0|1, never user text, so inlining is safe). */
-function macroCond(macro) {
-	return macro === void 0 ? "" : ` AND macro = ${macro}`;
-}
 /** Escape LIKE wildcards in user input so the prefix matches literally. */
 function escLike(s) {
 	return s.replace(/[\\%_]/g, (c) => `\\${c}`);
 }
-/** Trigram index needs ≥3-char keys; below this tier 0 falls back to LIKE. */
-var CONTAINS_MIN_FTS = 3;
-/** Candidate-pool caps: per-term pool (bm25) and the union budget (S3). */
-var FUZZY_CANDIDATE_LIMIT = 50;
-var FUZZY_UNION_LIMIT = 100;
-/** Dice similarity floor for tier-2 inclusion — PER TERM (min-combine,
-*  S3): a row is only as strong as its weakest keyword. Below = noise; the
-*  ADR word-share decoy scores 0.174 — excluded. */
-var FUZZY_DICE_FLOOR = .3;
-/**
-* Split a `?`-search key into keyword terms (ADR S1; separator charset
-* widened by ADR-0014 D2): split on `,`, `;`, `+`, or whitespace, trim,
-* drop empties, dedupe (case-insensitive, first spelling wins).
-* `adr, spec + task` → [adr, spec, task]; `load;;skill;` → [load, skill];
-* single term → array of one — the caller decides which path runs.
-* Empty/blank key → []. Pure; exported for tests.
-*/
-function splitQueryTerms(key) {
-	const seen = /* @__PURE__ */ new Set();
-	const terms = [];
-	for (const frag of key.split(/[,;+\s]+/)) {
-		const raw = frag.trim();
-		if (!raw) continue;
-		const lower = raw.toLowerCase();
-		if (seen.has(lower)) continue;
-		seen.add(lower);
-		terms.push({
-			raw,
-			lower
-		});
-	}
-	return terms;
-}
 /** Build an FTS5 phrase string from one term: `"` doubled per FTS5
 *  phrase quoting. */
 function ftsPhrase(term) {
@@ -383,7 +446,7 @@ function searchContains(db, key, limit, macro) {
 	const terms = splitQueryTerms(key);
 	if (terms.length > 1) return searchContainsMulti(db, key, terms, limit, macro);
 	const single = terms.length === 1 ? terms[0].raw : key;
-	if (single.length < CONTAINS_MIN_FTS) return containsLike(db, single, limit, macro);
+	if (single.length < 3) return containsLike(db, single, limit, macro);
 	try {
 		const contains = ftsContains(db, single, limit, macro);
 		if (contains.length > 0) return contains;
@@ -411,12 +474,12 @@ function isQueryEcho(text, keyAsSent) {
 * Any FTS failure degrades to LIKE-AND across all terms — never throws.
 */
 function searchContainsMulti(db, key, terms, limit, macro) {
-	const indexable = terms.filter((t) => t.lower.length >= CONTAINS_MIN_FTS);
+	const indexable = terms.filter((t) => t.lower.length >= 3);
 	try {
 		let rows;
 		if (indexable.length > 0) {
 			rows = ftsAndContains(db, indexable, limit, macro);
-			const shortTerms = terms.filter((t) => t.lower.length < CONTAINS_MIN_FTS);
+			const shortTerms = terms.filter((t) => t.lower.length < 3);
 			if (shortTerms.length > 0) rows = rows.filter((row) => shortTerms.every((t) => `${row.label ?? ""}\n${row.text}`.toLowerCase().includes(t.lower)));
 		} else rows = likeAndContains(db, terms, limit, macro);
 		if (rows.length === 1 && isQueryEcho(rows[0].text, key)) rows = [];
@@ -470,129 +533,51 @@ function containsLike(db, key, limit, macro) {
        ORDER BY use_count DESC, last_used_at DESC
        LIMIT ?`).all(like, like, limit);
 }
-/** Dice coefficient over character trigrams (case handled by callers). */
-function diceSimilarity(a, b) {
-	const grams = /* @__PURE__ */ new Map();
-	for (let i = 0; i + 3 <= a.length; i++) {
-		const g = a.slice(i, 3 + i);
-		grams.set(g, (grams.get(g) ?? 0) + 1);
-	}
-	if (grams.size === 0) return 0;
-	let bCount = 0;
-	let shared = 0;
-	for (let i = 0; i + 3 <= b.length; i++) {
-		bCount++;
-		const g = b.slice(i, 3 + i);
-		const have = grams.get(g) ?? 0;
-		if (have > 0) {
-			shared++;
-			if (have === 1) grams.delete(g);
-			else grams.set(g, have - 1);
-		}
-	}
-	if (bCount === 0) return 0;
-	const aCount = a.length - 2;
-	return 2 * shared / (aCount + bCount);
-}
+//#endregion
+//#region src/lib/server/prompts/crud.ts
 /**
-* Word-level similarity: max of Dice and normalized edit distance — Dice is
-* meaningless for words shorter than 3 trigrams/chars, edit covers them
-* ("lod" vs "load": Dice 0, edit 0.75 → 0.75). Exported for tests.
+* Count-only use recording (The Prompt Tags ADR, 2026-09-14, D7): bump
+* use_count + refresh last_used_at for an EXISTING row; unknown text
+* returns { counted: false } and inserts NOTHING — the wire's only path
+* to a row is an operator save. Null on failure (DB unavailable/empty text).
 */
-function wordSimilarity(a, b) {
-	const edit = 1 - levenshtein(a, b) / Math.max(a.length, b.length);
-	return Math.max(diceSimilarity(a, b), edit);
-}
-/** Wagner–Fischer edit distance (two-row DP), case handled by callers. */
-function levenshtein(a, b) {
-	if (a === b) return 0;
-	if (!a.length) return b.length;
-	if (!b.length) return a.length;
-	let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
-	for (let i = 1; i <= a.length; i++) {
-		const cur = [i];
-		for (let j = 1; j <= b.length; j++) cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-		prev = cur;
-	}
-	return prev[b.length];
-}
-/** Lines a row offers to line-level Dice (S3): label counts as the FIRST
-*  line — the user-chosen handle deserves line parity with text lines. */
-function rowLines(row) {
-	return row.label !== null ? [row.label, ...row.text.split("\n")] : row.text.split("\n");
-}
-/** Best-line score for ONE term (S3): max over the row's lines, where a
-*  line's score is the best of whole-line Dice and word-level similarity
-*  over the line's words (max of Dice and normalized edit distance — Dice
-*  is meaningless for words shorter than 3 trigrams, edit covers them:
-*  typo'd "lod" vs "load" clears the floor at word level while line-level
-*  trigram dilution would sink it). The word-aware allowance is what keeps
-*  typo'd short terms reachable under min-combine as part of a multi-term
-*  key. Localizing to the best line kills the body tax: a 400-char body
-*  diluting full-text Dice can no longer sink a term that matches its own
-*  line cleanly. */
-function termLineScore(term, row) {
-	let best = 0;
-	for (const line of rowLines(row)) {
-		const l = line.toLowerCase();
-		if (l.includes(term)) {
-			best = 1;
-			break;
-		}
-		let lineScore = diceSimilarity(term, l);
-		for (const word of l.split(/\s+/)) {
-			if (!word) continue;
-			lineScore = Math.max(lineScore, wordSimilarity(term, word));
-		}
-		best = Math.max(best, lineScore);
-	}
-	return best;
-}
-/** FTS5 trigram set for a single term (S3): grams of the lowercased term
-*  only — never extracted across separators, so no junk grams bridge
-*  `;`-split keywords. Deduped; null for <3-char terms (no grams). */
-function termTrigramExpr(term) {
-	const k = term.toLowerCase();
-	const grams = [];
-	for (let i = 0; i + 3 <= k.length && grams.length < 64; i++) {
-		const g = k.slice(i, 3 + i);
-		if (!grams.includes(g)) grams.push(g);
+function countPromptUse(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	const db = openPromptsDb();
+	if (!db) return null;
+	try {
+		if (db.prepare(`UPDATE prompts
+       SET use_count = use_count + 1, last_used_at = datetime('now')
+       WHERE text = ?`).run(trimmed).changes === 0) return { counted: false };
+		const row = db.prepare(`SELECT ${SELECT_COLS} FROM prompts WHERE text = ?`).get(trimmed);
+		return row ? {
+			counted: true,
+			record: row
+		} : null;
+	} catch (e) {
+		warn("countPromptUse failed:", e);
+		return null;
 	}
-	return grams.length ? grams.map((g) => `"${g}"`).join(" OR ") : null;
 }
-/** Tier 2 — per-term best-line Dice, min-combine (S3, Semicolon Search).
-*  Candidate pool: per-term trigram OR + bm25 cap 50, UNION of per-term
-*  pools capped 100 — a row matching ANY term fuzzily enters the pool;
-*  per-term scoring then enforces the AND. Row score = MIN over terms of
-*  (max Dice over the row's lines, label counts as first line); any term
-*  under the 0.3 floor excludes the row entirely. Ordering: score DESC,
-*  use_count DESC, last_used_at DESC. Never mixes with tier 1 (only runs
-*  when tier 1 returned empty). */
-function fuzzyReRank(db, terms, limit, macro) {
-	const pool = /* @__PURE__ */ new Map();
-	for (const term of terms) {
-		if (term.lower.length < CONTAINS_MIN_FTS) continue;
-		const expr = termTrigramExpr(term.lower);
-		if (!expr) continue;
-		try {
-			const rows = db.prepare(`SELECT ${SELECT_COLS} FROM prompts
-           WHERE id IN (
-             SELECT rowid FROM prompts_fts WHERE prompts_fts MATCH ?
-             ORDER BY bm25(prompts_fts) LIMIT ${FUZZY_CANDIDATE_LIMIT}
-           )${macroCond(macro)}`).all(expr);
-			for (const r of rows) {
-				if (pool.size >= FUZZY_UNION_LIMIT) break;
-				if (!pool.has(r.id)) pool.set(r.id, r);
-			}
-		} catch {}
+/**
+* Cap enforcement (ADR D13): if rows > MAX_ROWS, delete the oldest
+* use_count=1 rows until at cap. Multi-use prompts are never pruned.
+*/
+function pruneIfNeeded(db) {
+	try {
+		const overflow = db.prepare("SELECT COUNT(*) AS n FROM prompts").get().n - MAX_ROWS;
+		if (overflow <= 0) return;
+		db.prepare(`DELETE FROM prompts
+       WHERE id IN (
+         SELECT id FROM prompts
+         WHERE use_count <= 1
+         ORDER BY last_used_at ASC, id ASC
+         LIMIT ?
+       )`).run(overflow);
+	} catch (e) {
+		warn("prune failed:", e);
 	}
-	if (pool.size === 0) return [];
-	return [...pool.values()].map((row) => {
-		return {
-			row,
-			score: terms.reduce((min, t) => Math.min(min, termLineScore(t.lower, row)), 1)
-		};
-	}).filter((s) => s.score >= FUZZY_DICE_FLOOR).sort((a, b) => b.score - a.score || b.row.use_count - a.row.use_count || (b.row.last_used_at < a.row.last_used_at ? 1 : b.row.last_used_at > a.row.last_used_at ? -1 : 0)).slice(0, limit).map((s) => s.row);
 }
 /**
 * Rename a prompt's label (ADR D3). Label is the one-line handle used for
@@ -777,4 +762,4 @@ function updatePrompt(id, fields) {
 }
 
 export { countPromptUse as a, renamePromptLabel as b, createPrompt as c, deletePrompt as d, listPrompts as l, resolvePromptsDbPath as r, searchPrompts as s, updatePrompt as u };
-//# sourceMappingURL=db2.js-Cm8FBINY.js.map
+//# sourceMappingURL=db2.js-DUta2B-n.js.map