@deepseek-insight/dsi 0.5.5

package/build/server/chunks/chunks/db2.js-DBltVUGg.js

@@ -0,0 +1,717 @@
+import { D as DSI_CONFIG_PATH } from './insight-config.js-CfMPTA6Z.js';
+import { mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+/**
+* Resolve the library path: explicit argument → `DSI_PROMPTS_DB` env →
+* sibling of DSI_CONFIG_PATH (`~/.dsi/prompts.sqlite`).
+*/
+function resolvePromptsDbPath(path) {
+	return process.env["DSI_PROMPTS_DB"] ?? join(dirname(DSI_CONFIG_PATH), "prompts.sqlite");
+}
+/** Degrade-contract logger — server has no logger module (a2a precedent
+*  swallows silently); this feature's contract says failures LOG and
+*  return empty/false, so a prefixed console.warn is the honest floor. */
+function warn(msg, e) {
+	console.warn(`[prompts-db] ${msg}`, e instanceof Error ? e.message : e);
+}
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS prompts (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  label        TEXT,
+  text         TEXT NOT NULL,
+  use_count    INTEGER NOT NULL DEFAULT 1,
+  macro        INTEGER NOT NULL DEFAULT 0,
+  last_used_at TEXT NOT NULL DEFAULT (datetime('now')),
+  created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(text)
+);
+CREATE INDEX IF NOT EXISTS idx_prompts_text ON prompts(text);
+CREATE INDEX IF NOT EXISTS idx_prompts_prune
+  ON prompts(use_count, last_used_at);
+`;
+/** Hard row cap — overflow prunes oldest one-use rows (ADR D13). */
+var MAX_ROWS = 5e3;
+/** FTS5 external-content trigram index + sync triggers (schema v2, ADR v1.2
+*  F3). Applied by migrate(), NOT in SCHEMA: `CREATE VIRTUAL TABLE` has no
+*  IF NOT EXISTS and SCHEMA is exec'd on every open — migrate re-enters via
+*  DROP IF EXISTS, safe because external content makes the index disposable
+*  (rebuildable at any time from the source-of-truth table). */
+var FTS_SCHEMA = `
+CREATE VIRTUAL TABLE prompts_fts USING fts5(
+  label, text,
+  content='prompts', content_rowid='id',
+  tokenize='trigram'
+);
+CREATE TRIGGER prompts_ai AFTER INSERT ON prompts BEGIN
+  INSERT INTO prompts_fts(rowid, label, text) VALUES (new.id, new.label, new.text);
+END;
+CREATE TRIGGER prompts_ad AFTER DELETE ON prompts BEGIN
+  INSERT INTO prompts_fts(prompts_fts, rowid, label, text)
+  VALUES ('delete', old.id, old.label, old.text);
+END;
+CREATE TRIGGER prompts_au AFTER UPDATE OF label, text ON prompts BEGIN
+  INSERT INTO prompts_fts(prompts_fts, rowid, label, text)
+  VALUES ('delete', old.id, old.label, old.text);
+  INSERT INTO prompts_fts(rowid, label, text) VALUES (new.id, new.label, new.text);
+END;
+`;
+/** Schema version tracked via PRAGMA user_version (ADR D11).
+*  v0: original table — text/use_count/last_used_at only (label-less).
+*  v1: adds label, created_at, prune index, UNIQUE(text) upsert semantics.
+*  v2: adds prompts_fts trigram index + sync triggers (ADR v1.2 F3).
+*  v3: adds the macro flag column (0 = ordinary, 1 = macro). */
+var SCHEMA_VERSION = 3;
+var defaultDb = null;
+/**
+* Open (creating if needed) the library DB and ensure schema. Idempotent:
+* DDL re-runs safely, migrate is version-gated. An explicit `path` always
+* returns a FRESH handle (test/tmp isolation); the no-arg form memoizes
+* one default handle per process — routes and the finder share it.
+* Never throws: on failure logs and returns null — the feature degrades
+* silently (no strip, no recording; the app is otherwise fine).
+*/
+function openPromptsDb(path) {
+	if (defaultDb !== null) try {
+		defaultDb.prepare("SELECT 1").get();
+		return defaultDb;
+	} catch {
+		try {
+			defaultDb.close();
+		} catch {}
+		defaultDb = null;
+	}
+	const file = resolvePromptsDbPath();
+	try {
+		mkdirSync(dirname(file), { recursive: true });
+		const db = new DatabaseSync(file);
+		db.exec(SCHEMA);
+		migrate(db);
+		if (path === void 0) defaultDb = db;
+		return db;
+	} catch (e) {
+		warn(`Failed to open ${file}:`, e);
+		return null;
+	}
+}
+/**
+* Idempotent in-place migration (ADR D11). CREATE TABLE IF NOT EXISTS does
+* not evolve an existing table — a prompts.sqlite created by the pre-label
+* build lacks the label/created_at columns, and every query against them
+* fails. Bump-then-alter: read PRAGMA user_version, add missing columns +
+* indexes, set new version. Failure logs and leaves user_version where it
+* is — the DB still opens, prefix/contains LIKE search keeps working, and
+* the next open retries.
+*/
+function migrate(db) {
+	const current = db.prepare("PRAGMA user_version").get().user_version;
+	if (current >= SCHEMA_VERSION) return;
+	try {
+		if (current < 1) {
+			const cols = db.prepare("PRAGMA table_info(prompts)").all().map((c) => c.name);
+			if (!cols.includes("label")) db.exec("ALTER TABLE prompts ADD COLUMN label TEXT");
+			if (!cols.includes("created_at")) {
+				db.exec("ALTER TABLE prompts ADD COLUMN created_at TEXT");
+				db.exec("UPDATE prompts SET created_at = datetime('now') WHERE created_at IS NULL");
+			}
+			db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_prompts_text_unique ON prompts(text)");
+			db.exec("UPDATE prompts SET use_count = MAX(use_count, 1) WHERE use_count < 1");
+		}
+		if (current < 2) {
+			db.exec("DROP TABLE IF EXISTS prompts_fts");
+			db.exec("DROP TRIGGER IF EXISTS prompts_ai");
+			db.exec("DROP TRIGGER IF EXISTS prompts_ad");
+			db.exec("DROP TRIGGER IF EXISTS prompts_au");
+			db.exec(FTS_SCHEMA);
+			db.exec("INSERT INTO prompts_fts(rowid, label, text) SELECT id, label, text FROM prompts");
+		}
+		if (current < 3) {
+			const want = [
+				"id",
+				"label",
+				"text",
+				"use_count",
+				"macro",
+				"last_used_at",
+				"created_at"
+			];
+			let cols = db.prepare("PRAGMA table_info(prompts)").all().map((c) => c.name);
+			if (!cols.includes("macro")) {
+				db.exec("ALTER TABLE prompts ADD COLUMN macro INTEGER NOT NULL DEFAULT 0");
+				cols = db.prepare("PRAGMA table_info(prompts)").all().map((c) => c.name);
+			}
+			if (JSON.stringify(cols) !== JSON.stringify(want)) {
+				db.exec("DROP TABLE IF EXISTS prompts_fts");
+				db.exec("DROP TRIGGER IF EXISTS prompts_ai");
+				db.exec("DROP TRIGGER IF EXISTS prompts_ad");
+				db.exec("DROP TRIGGER IF EXISTS prompts_au");
+				db.exec("DROP INDEX IF EXISTS idx_prompts_text");
+				db.exec("DROP INDEX IF EXISTS idx_prompts_text_unique");
+				db.exec("DROP INDEX IF EXISTS idx_prompts_prune");
+				db.exec("DROP INDEX IF EXISTS idx_prompts_label");
+				db.exec(`CREATE TABLE prompts_new (
+					id           INTEGER PRIMARY KEY AUTOINCREMENT,
+					label        TEXT,
+					text         TEXT NOT NULL,
+					use_count    INTEGER NOT NULL DEFAULT 1,
+					macro        INTEGER NOT NULL DEFAULT 0,
+					last_used_at TEXT NOT NULL DEFAULT (datetime('now')),
+					created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+					UNIQUE(text)
+				)`);
+				db.exec(`INSERT INTO prompts_new (id, label, text, use_count, macro, last_used_at, created_at)
+					SELECT id, label, text, use_count, COALESCE(macro, 0), last_used_at,
+						COALESCE(created_at, datetime('now'))
+					FROM prompts`);
+				db.exec("DROP TABLE prompts");
+				db.exec("ALTER TABLE prompts_new RENAME TO prompts");
+				db.exec("CREATE INDEX IF NOT EXISTS idx_prompts_text ON prompts(text)");
+				db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_prompts_text_unique ON prompts(text)");
+				db.exec("CREATE INDEX IF NOT EXISTS idx_prompts_prune ON prompts(use_count, last_used_at)");
+				db.exec(FTS_SCHEMA);
+				db.exec("INSERT INTO prompts_fts(rowid, label, text) SELECT id, label, text FROM prompts");
+			}
+		}
+		db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_prompts_label ON prompts(label) WHERE label IS NOT NULL");
+		db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+	} catch (e) {
+		warn("migration failed:", e);
+	}
+}
+var SELECT_COLS = "id, label, text, use_count, macro, last_used_at, created_at";
+/** Find a prompt by exact (trimmed) text. Null on miss/failure. */
+function findPromptByText(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	const db = openPromptsDb();
+	if (!db) return null;
+	try {
+		return db.prepare(`SELECT ${SELECT_COLS} FROM prompts WHERE text = ?`).get(trimmed) ?? null;
+	} catch (e) {
+		warn("findPromptByText failed:", e);
+		return null;
+	}
+}
+/**
+* Record a sent prompt (ADR D5/D15): insert on first send, increment
+* use_count + refresh last_used_at afterwards. Enforces the row cap.
+* Returns the updated record, or null on failure (DB unavailable/empty text).
+*/
+function recordPromptUse(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	const db = openPromptsDb();
+	if (!db) return null;
+	try {
+		db.prepare(`INSERT INTO prompts (label, text, use_count, last_used_at, created_at)
+       VALUES (NULL, ?, 1, datetime('now'), datetime('now'))
+       ON CONFLICT(text) DO UPDATE SET
+         use_count = use_count + 1,
+         last_used_at = datetime('now')`).run(trimmed);
+		pruneIfNeeded(db);
+		return db.prepare(`SELECT ${SELECT_COLS} FROM prompts WHERE text = ?`).get(trimmed) ?? null;
+	} catch (e) {
+		warn("recordPromptUse failed:", e);
+		return null;
+	}
+}
+/**
+* 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);
+	}
+}
+/**
+* Search prompts. Ranked by use_count DESC, last_used_at DESC.
+*
+* `?` contains/fuzzy mode (ADR v1.2 F2, schema v2): opts.mode ===
+* 'contains' dispatches tiered search —
+*   tier 0: key < 3 chars → LIKE '%q%' table scan (trigram index unusable)
+*   tier 1: ≥ 3 chars → FTS MATCH '"key"' (index-accelerated contains)
+*   tier 2: tier-1 empty AND key ≥ FUZZY_MIN_LEN(4) → per-term best-line
+*           Dice, min-combine (Semicolon Search S3): union of per-term
+*           trigram pools (bm25 cap 50, union cap 100) re-ranked by
+*           min-over-terms of max-over-lines score (label = first line;
+*           word-aware — a term scores against each word of a line as
+*           well as the whole line), floored at 0.3 per term.
+* Tier 1 always fully outranks tier 2 — tiers never mix in one response.
+* Default (no mode) keeps the OCI prefix contract: label OR text prefix,
+* case-insensitive — DSI drops the ghost-only single-line filter (the
+* ghost is out, ADR §6).
+*/
+function searchPrompts(prefix, limit = 5, opts) {
+	const db = openPromptsDb();
+	if (!db) return [];
+	const trimmed = prefix.trim();
+	if (!trimmed) return [];
+	try {
+		if (opts?.mode === "contains") return searchContains(db, trimmed, limit, opts.macro);
+		return db.prepare(`SELECT ${SELECT_COLS} FROM prompts
+         WHERE (label LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\')${macroCond(opts?.macro)}
+         ORDER BY use_count DESC, last_used_at DESC
+         LIMIT ?`).all(`${escLike(trimmed)}%`, `${escLike(trimmed)}%`, limit);
+	} catch (e) {
+		warn("searchPrompts failed:", e);
+		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): split on `;` and
+* whitespace, trim, drop empties, dedupe (case-insensitive, first spelling
+* wins). `load;skill;feature-spec` → [load, skill, feature-spec];
+* `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) {
+	return `"${term.replace(/"/g, "\"\"")}"`;
+}
+/**
+* Tier dispatch for `?` queries: tier 0 LIKE / tier 1 FTS contains /
+* tier 2 fuzzy. Any FTS failure degrades to tier-0 LIKE — search never
+* throws (callers get an empty array or LIKE results, per ADR F3).
+*
+*  Multi-keyword (S1+S2): a `;`/whitespace-split key with ≥2 terms takes
+*  the AND path — every keyword must appear somewhere in the row (each
+*  anywhere, order-free); more keywords narrow the result. Tier 1 runs an
+*  AND-of-phrases FTS MATCH on indexable (≥3 char) terms with sub-3-char
+*  terms re-verified by LIKE post-filter over the FTS row set; the
+*  self-echo row (a previously recorded query whose text starts with the
+*  key as sent) is suppressed when it is the ONLY hit; tier 2 is per-term
+*  best-line Dice, min-combine (S3). FTS failure degrades to LIKE-AND
+*  across ALL terms (AND is absolute in both tiers). A single term keeps
+*  the exact v1.2 path.
+*/
+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);
+	try {
+		const contains = ftsContains(db, single, limit, macro);
+		if (contains.length > 0) return contains;
+		if (single.length < 4) return [];
+		return fuzzyReRank(db, terms, limit, macro);
+	} catch {
+		return containsLike(db, single, limit, macro);
+	}
+}
+/** Echo guard: the query row itself — text starts with the `?`-key as the
+*  operator sent it (queries ARE recorded when sent, so the query's own
+*  row can be the only tier-1 hit; G3). Case-insensitive: LIKE matching
+*  is case-insensitive for ASCII, and trigram FTS is ASCII case-folding —
+*  the echo row can reach tier 1 through a case variant too. */
+function isQueryEcho(text, keyAsSent) {
+	return text.toLowerCase().startsWith(keyAsSent.toLowerCase());
+}
+/**
+* Multi-keyword `?` search (S1+S2): AND semantics.
+* Tier 1: FTS MATCH '"t1" AND "t2" AND …' over indexable terms (≥3 chars);
+* sub-3-char terms can't use the trigram index, so they're enforced via
+* post-filter LIKE over the FTS row set (AND preserved). The self-echo
+* row is dropped when it's the only tier-1 hit. Tier 2 is per-term
+* best-line Dice, min-combine (S3) — unified with the single-term path.
+* 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);
+	try {
+		let rows;
+		if (indexable.length > 0) {
+			rows = ftsAndContains(db, indexable, limit, macro);
+			const shortTerms = terms.filter((t) => t.lower.length < CONTAINS_MIN_FTS);
+			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 = [];
+		if (rows.length > 0) return rows;
+		if (key.length < 4) return [];
+		const fuzzy = fuzzyReRank(db, terms, limit, macro);
+		if (fuzzy.length === 1 && isQueryEcho(fuzzy[0].text, key)) return [];
+		return fuzzy;
+	} catch {
+		return likeAndContains(db, terms, limit, macro);
+	}
+}
+/** Tier 1 (multi-term) — AND-of-phrases MATCH: every keyword somewhere,
+*  order-free, index-accelerated. Phrases quote-escaped via ftsPhrase. */
+function ftsAndContains(db, terms, limit, macro) {
+	const expr = terms.map((t) => ftsPhrase(t.lower)).join(" AND ");
+	return db.prepare(`SELECT ${SELECT_COLS} FROM prompts
+       WHERE id IN (SELECT rowid FROM prompts_fts WHERE prompts_fts MATCH ?)${macroCond(macro)}
+       ORDER BY use_count DESC, last_used_at DESC
+       LIMIT ?`).all(expr, limit);
+}
+/** LIKE-AND across all terms (multi-term tier-0 and FTS degrade path):
+*  case-insensitive contains for EVERY term in label-or-text. Trigram
+*  FTS is ASCII case-folding — toLowerCase() keeps LIKE equivalent. */
+function likeAndContains(db, terms, limit, macro) {
+	const conds = terms.map(() => "(label LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\')");
+	const params = [];
+	for (const t of terms) {
+		const like = `%${escLike(t.lower)}%`;
+		params.push(like, like);
+	}
+	return db.prepare(`SELECT ${SELECT_COLS} FROM prompts
+       WHERE ${conds.join(" AND ")}${macroCond(macro)}
+       ORDER BY use_count DESC, last_used_at DESC
+       LIMIT ?`).all(...params, limit);
+}
+/** Tier 1 — index-accelerated contains via trigram phrase MATCH. */
+function ftsContains(db, key, limit, macro) {
+	const expr = ftsPhrase(key.toLowerCase());
+	if (!key) return containsLike(db, key, limit, macro);
+	return db.prepare(`SELECT ${SELECT_COLS} FROM prompts
+       WHERE id IN (SELECT rowid FROM prompts_fts WHERE prompts_fts MATCH ?)${macroCond(macro)}
+       ORDER BY use_count DESC, last_used_at DESC
+       LIMIT ?`).all(expr, limit);
+}
+/** Tier 0 — LIKE table scan (short keys; FTS degrade path shares it). */
+function containsLike(db, key, limit, macro) {
+	const like = `%${escLike(key)}%`;
+	return db.prepare(`SELECT ${SELECT_COLS} FROM prompts
+       WHERE (label LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\')${macroCond(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);
+}
+/**
+* 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 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 < 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 {}
+	}
+	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
+* matching and display; passing null clears it. Fails (returns false) if
+* another prompt already claims the label (unique partial index).
+*/
+function renamePromptLabel(id, label) {
+	const db = openPromptsDb();
+	if (!db) return false;
+	try {
+		const clean = label === null ? null : label.trim().slice(0, 60) || null;
+		return db.prepare("UPDATE prompts SET label = ? WHERE id = ?").run(clean, id).changes > 0;
+	} catch (e) {
+		warn("renamePromptLabel failed:", e);
+		return false;
+	}
+}
+/** Delete a prompt row. Returns true when a row was removed. */
+function deletePrompt(id) {
+	const db = openPromptsDb();
+	if (!db) return false;
+	try {
+		return db.prepare("DELETE FROM prompts WHERE id = ?").run(id).changes > 0;
+	} catch (e) {
+		warn("deletePrompt failed:", e);
+		return false;
+	}
+}
+/** Sort param → ORDER BY clause (col + direction). */
+var SORT_MAP = {
+	uses: {
+		col: "use_count",
+		asc: "use_count ASC",
+		desc: "use_count DESC"
+	},
+	last_used: {
+		col: "last_used_at",
+		asc: "last_used_at ASC",
+		desc: "last_used_at DESC"
+	},
+	created: {
+		col: "created_at",
+		asc: "created_at ASC",
+		desc: "created_at DESC"
+	},
+	display: {
+		col: "COALESCE(label, text)",
+		asc: "COALESCE(label, text) ASC",
+		desc: "COALESCE(label, text) DESC"
+	}
+};
+/**
+* List prompts for the manager (ADR E4). Supports optional prefix filter,
+*  sort, and offset paging. Returns rows + total count (for cap-footer UX).
+*/
+function listPrompts(opts) {
+	const db = openPromptsDb();
+	if (!db) return {
+		rows: [],
+		total: 0
+	};
+	const limit = Math.min(Math.max(opts.limit ?? 200, 1), 500);
+	const offset = Math.max(opts.offset ?? 0, 0);
+	const sortKey = opts.sort && SORT_MAP[opts.sort] ? opts.sort : "last_used";
+	const dir = opts.dir === "asc" ? "asc" : "desc";
+	const orderBy = SORT_MAP[sortKey][dir];
+	const q = opts.q?.trim();
+	try {
+		if (q) {
+			const like = `${escLike(q)}%`;
+			return {
+				rows: db.prepare(`SELECT ${SELECT_COLS} FROM prompts
+           WHERE label LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\'
+           ORDER BY ${orderBy}
+           LIMIT ? OFFSET ?`).all(like, like, limit, offset),
+				total: db.prepare(`SELECT COUNT(*) AS n FROM prompts
+             WHERE label LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\'`).get(like, like).n
+			};
+		}
+		return {
+			rows: db.prepare(`SELECT ${SELECT_COLS} FROM prompts ORDER BY ${orderBy} LIMIT ? OFFSET ?`).all(limit, offset),
+			total: db.prepare("SELECT COUNT(*) AS n FROM prompts").get().n
+		};
+	} catch (e) {
+		warn("listPrompts failed:", e);
+		return {
+			rows: [],
+			total: 0
+		};
+	}
+}
+/**
+* Create a prompt manually (ADR E4). If text already exists, returns the
+* existing row as a 409-info object instead of inserting. Manual create ≠
+* upsert — never silently bumps use_count.
+*/
+function createPrompt(text, label) {
+	const trimmed = text.trim();
+	if (!trimmed) return {
+		ok: false,
+		existing: null
+	};
+	const db = openPromptsDb();
+	if (!db) return {
+		ok: false,
+		existing: null
+	};
+	try {
+		const existing = db.prepare(`SELECT ${SELECT_COLS} FROM prompts WHERE text = ?`).get(trimmed);
+		if (existing) return {
+			ok: false,
+			existing
+		};
+		const cleanLabel = label ? label.trim().slice(0, 60) || null : null;
+		db.prepare(`INSERT INTO prompts (label, text, use_count, last_used_at, created_at)
+       VALUES (?, ?, 1, datetime('now'), datetime('now'))`).run(cleanLabel, trimmed);
+		pruneIfNeeded(db);
+		return {
+			ok: true,
+			record: db.prepare(`SELECT ${SELECT_COLS} FROM prompts WHERE text = ?`).get(trimmed)
+		};
+	} catch (e) {
+		warn("createPrompt failed:", e);
+		return {
+			ok: false,
+			existing: null
+		};
+	}
+}
+/**
+* Update a prompt's text, label, and/or use_count (ADR E4 PATCH extend).
+* `use_count` is floored at 1 (reset). Returns the updated row or null.
+*/
+function updatePrompt(id, fields) {
+	const db = openPromptsDb();
+	if (!db) return null;
+	try {
+		const sets = [];
+		const args = [];
+		if (fields.text !== void 0) {
+			const trimmed = fields.text.trim();
+			if (!trimmed) return null;
+			sets.push("text = ?");
+			args.push(trimmed);
+		}
+		if (fields.label !== void 0) {
+			const clean = fields.label === null ? null : fields.label.trim().slice(0, 60) || null;
+			sets.push("label = ?");
+			args.push(clean);
+		}
+		if (fields.use_count !== void 0) {
+			sets.push("use_count = ?");
+			args.push(Math.max(1, Math.floor(fields.use_count)));
+		}
+		if (fields.macro !== void 0) {
+			sets.push("macro = ?");
+			args.push(fields.macro ? 1 : 0);
+		}
+		if (sets.length === 0) return null;
+		args.push(id);
+		if (db.prepare(`UPDATE prompts SET ${sets.join(", ")} WHERE id = ?`).run(...args).changes === 0) return null;
+		return db.prepare(`SELECT ${SELECT_COLS} FROM prompts WHERE id = ?`).get(id);
+	} catch (e) {
+		warn("updatePrompt failed:", e);
+		return null;
+	}
+}
+
+export { renamePromptLabel as a, createPrompt as c, deletePrompt as d, findPromptByText as f, listPrompts as l, recordPromptUse as r, searchPrompts as s, updatePrompt as u };
+//# sourceMappingURL=db2.js-DBltVUGg.js.map