superdev-cli 0.1.0

package/src/memory/benchmark.mjs

@@ -0,0 +1,171 @@
+// Measure what memory retrieval actually does.
+//
+// Section 15.12 lists eleven things that must be measured before Claude Mem can
+// be dropped as a transitional provider: recall, precision, noise, ranking
+// quality, token reduction, latency, storage growth, stale detection,
+// contradiction detection, cross session resume accuracy and cross agent
+// handoff accuracy. None of it was measured, so DEC-TBD-002 could not be
+// answered even in principle: there was no number to hold a threshold against.
+//
+// This measures. It does not decide. What counts as good enough is the owner's
+// call and section 23 leaves it open; what the numbers are is not a matter of
+// opinion and is answered here.
+//
+// The queries are built from the memories themselves rather than written by
+// hand, so the benchmark grows with the project instead of testing a fixture
+// that stops resembling it. A query is a term drawn from one memory's title,
+// and the memory it came from is the answer it should find.
+
+import { query } from "../db/store.mjs";
+import { recall, tokenize } from "./index.mjs";
+
+/** Words too common to tell one memory from another. */
+const WEAK = new Set([
+  "task", "complete", "completed", "recorded", "moved", "the", "and", "for",
+  "with", "that", "this", "from", "superdev", "project", "feature", "decision",
+]);
+
+/**
+ * Build the questions from the memories.
+ *
+ * Each query is the rarest word in a memory's title, and the memory it came
+ * from is the one answer that query should return. Picking the rarest word is
+ * deliberate: a common word would match everything and measure nothing, and the
+ * point is to find out whether retrieval can single out one entry.
+ */
+async function buildQueries(root, limit) {
+  const entries = await query(root, (db) => db.all(
+    `SELECT id, title, content, kind FROM memory_entries
+      WHERE superseded_by IS NULL ORDER BY id`));
+  if (entries.length < 3) return { entries, queries: [] };
+
+  const frequency = new Map();
+  for (const e of entries) {
+    for (const term of new Set(tokenize(`${e.title} ${e.content}`))) {
+      frequency.set(term, (frequency.get(term) ?? 0) + 1);
+    }
+  }
+
+  const queries = [];
+  for (const e of entries) {
+    const terms = [...new Set(tokenize(e.title))]
+      .filter((t) => t.length > 3 && !WEAK.has(t))
+      .sort((a, b) => (frequency.get(a) ?? 0) - (frequency.get(b) ?? 0));
+    if (!terms.length) continue;
+    queries.push({ text: terms.slice(0, 2).join(" "), expect: e.id });
+    if (queries.length >= limit) break;
+  }
+  return { entries, queries };
+}
+
+/**
+ * Run the benchmark.
+ *
+ * Every number here is observed. Where something cannot be measured from a
+ * single run, it says so rather than producing a figure that looks like a
+ * measurement and is not.
+ */
+export async function benchmark(root, { limit = 40 } = {}) {
+  const { entries, queries } = await buildQueries(root, limit);
+  if (queries.length === 0) {
+    return {
+      measurable: false,
+      why: entries.length < 3
+        ? `Only ${entries.length} memories are stored. Retrieval quality cannot be measured until there is something to retrieve from.`
+        : "No memory title carries a word distinctive enough to query on, so no question can be asked that has one right answer.",
+      entries: entries.length,
+    };
+  }
+
+  let hits = 0;
+  let reciprocalRankTotal = 0;
+  let returnedTotal = 0;
+  let bytesReturned = 0;
+  const latencies = [];
+
+  for (const q of queries) {
+    const started = process.hrtime.bigint();
+    const found = await recall(root, { text: q.text, limit: 5 }).catch(() => []);
+    latencies.push(Number(process.hrtime.bigint() - started) / 1e6);
+
+    const rows = Array.isArray(found) ? found : (found?.entries ?? []);
+    returnedTotal += rows.length;
+    bytesReturned += rows.reduce((n, r) => n + String(r.content ?? "").length, 0);
+
+    const rank = rows.findIndex((r) => r.id === q.expect);
+    if (rank >= 0) {
+      hits += 1;
+      // Mean reciprocal rank: finding the right answer first is worth more than
+      // finding it fifth, which a plain hit rate cannot express.
+      reciprocalRankTotal += 1 / (rank + 1);
+    }
+  }
+
+  const wholeCorpusBytes = entries.reduce((n, e) => n + String(e.content ?? "").length, 0);
+  const storage = await query(root, async (db) => ({
+    terms: Number(Object.values(await db.get("SELECT COUNT(*) AS c FROM memory_search_terms"))[0]),
+    links: Number(Object.values(await db.get("SELECT COUNT(*) AS c FROM memory_links"))[0]),
+    superseded: Number(Object.values(await db.get(
+      "SELECT COUNT(*) AS c FROM memory_entries WHERE superseded_by IS NOT NULL"))[0]),
+    contradicted: Number(Object.values(await db.get(
+      "SELECT COUNT(*) AS c FROM memory_entries WHERE epistemic_status = 'contradicted'"))[0]),
+  }));
+
+  const sorted = [...latencies].sort((a, b) => a - b);
+  const round = (n) => Math.round(n * 100) / 100;
+
+  return {
+    measurable: true,
+    corpus: { entries: entries.length, queries: queries.length },
+    // Section 15.12's list, each answered by something observed.
+    recall: {
+      value: round(hits / queries.length),
+      says: `${hits} of ${queries.length} questions returned the memory they were drawn from within the top five.`,
+    },
+    precision: {
+      value: round(hits / Math.max(1, returnedTotal)),
+      says: `${returnedTotal} entries were returned across ${queries.length} questions to surface ${hits} right answers.`,
+    },
+    noise: {
+      value: round((returnedTotal - hits) / Math.max(1, returnedTotal)),
+      says: "The share of returned entries that were not the one asked for. Some of those are genuinely related, so this is an upper bound on noise rather than a count of wrong answers.",
+    },
+    ranking: {
+      value: round(reciprocalRankTotal / queries.length),
+      says: "Mean reciprocal rank. One means the right answer always came first; a half means it typically came second.",
+    },
+    tokenReduction: {
+      value: round(1 - bytesReturned / Math.max(1, wholeCorpusBytes * queries.length)),
+      says: `Retrieval returned ${bytesReturned} characters where handing over the whole corpus for every question would have been ${wholeCorpusBytes * queries.length}.`,
+    },
+    latencyMs: {
+      median: round(sorted[Math.floor(sorted.length / 2)] ?? 0),
+      worst: round(sorted.at(-1) ?? 0),
+      says: "Wall clock per question, including opening and closing the database, because that is what a caller waits for.",
+    },
+    storageGrowth: {
+      entries: entries.length,
+      searchTerms: storage.terms,
+      links: storage.links,
+      says: `${round(storage.terms / Math.max(1, entries.length))} index terms per memory. Growth is linear in entries, and the index is rebuilt rather than accumulated.`,
+    },
+    staleDetection: {
+      superseded: storage.superseded,
+      says: "Superseding is recorded rather than deleted, so a memory that stopped being true stays readable with what replaced it.",
+    },
+    contradictionDetection: {
+      marked: storage.contradicted,
+      says: "Consolidation marks the earlier of two contradicting statements and keeps both, so recall can warn rather than pick a side.",
+    },
+    // Both of these are journeys rather than queries, which section 20.1 asks
+    // for directly. Saying so beats inventing a number.
+    resumeAccuracy: {
+      measurable: false,
+      says: "Not a query. Run superdev resume in a fresh process and check whether the working state comes back, which is the only honest measurement of it.",
+    },
+    handoffAccuracy: {
+      measurable: false,
+      says: "Not a query. Hand a session to another agent and check what it can answer without the conversation.",
+    },
+  };
+}

package/src/memory/capture.mjs

@@ -0,0 +1,135 @@
+// Capture memory from the events worth remembering.
+//
+// Section 15.6 lists when capture should happen: task start, task completion,
+// decision acceptance and supersession, blocker creation and resolution, a
+// failed approach, successful verification, session handoff, documentation
+// acceptance, material product change. remember() existed and nothing called
+// it, so after a night of work the memory system held nothing and section 12.8's
+// memory show and memory verify had nothing to show or verify.
+//
+// What is captured is deliberately narrow. Section 15.2 says memory must avoid
+// storing an agent's own unverified output as fact, so an outcome is only
+// recorded when evidence backs it, and its epistemic status says which: a
+// completion with passing evidence is confirmed, everything else is inferred.
+//
+// Capture is idempotent because section 15.6 requires it. Every entry carries a
+// dedupe key built from the event it came from, so a hook that fires twice, a
+// retried command and a replayed session all produce one memory.
+
+import { remember, linkMemory } from "./index.mjs";
+import { query } from "../db/store.mjs";
+
+/** What each lifecycle moment becomes, in the vocabulary the schema allows. */
+const KIND = {
+  task_completed: "outcome",
+  task_blocked: "blocker",
+  task_unblocked: "outcome",
+  decision_recorded: "decision",
+  decision_superseded: "decision",
+  verification_passed: "outcome",
+  verification_failed: "learned_fact",
+  question_answered: "learned_fact",
+  change_recorded: "learned_fact",
+  assumption_recorded: "unresolved_question",
+};
+
+/**
+ * Record one moment, once.
+ *
+ * Failure never propagates. Memory is recall, not authority, and losing a
+ * recall entry must not fail the work that produced it: a task that completed
+ * has completed whether or not anything remembered it.
+ */
+export async function capture(root, event = {}) {
+  try {
+    const kind = KIND[event.type];
+    if (!kind) return null;
+    const title = String(event.title ?? "").trim();
+    const content = String(event.content ?? "").trim();
+    if (!title || !content) return null;
+
+    const entry = await remember(root, {
+      kind,
+      title: title.slice(0, 200),
+      content: content.slice(0, 2000),
+      // Confirmed only when something was observed. An agent saying a thing
+      // happened is inferred, and section 15.2 forbids treating that as fact.
+      epistemicStatus: event.confirmed ? "confirmed" : "inferred",
+      sourceRef: event.sourceRef ?? null,
+      // The event identity, not the wording. Two different observations can be
+      // worded alike and collapsing those would lose real information.
+      dedupeKey: event.dedupeKey ?? `${event.type}:${event.subjectId ?? title}`,
+      taskId: event.taskId ?? null,
+      featureId: event.featureId ?? null,
+      sessionId: event.sessionId ?? null,
+    });
+
+    // Section 15.4 says long-term memory must use stable links to the records
+    // it concerns, and 14.2 says a memory link cannot reference a missing one.
+    for (const link of event.links ?? []) {
+      if (!link?.type || !link?.id) continue;
+      await linkMemory(root, entry.id, link.type, link.id, link.relationship ?? "concerns").catch(() => {});
+    }
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Sweep the activity trail for moments that were never remembered.
+ *
+ * Capture is wired into the lifecycle from here on, but a project that ran
+ * before it existed has a history full of moments and no memory of any of them.
+ * This reads that history and records what it finds, which is also the recovery
+ * path if capture is ever switched off and back on.
+ *
+ * Only events that carry a claim are taken. An activity trail holds every file
+ * touch and every regeneration, and remembering those would bury the handful of
+ * things worth recalling.
+ */
+export async function captureFromHistory(root, { limit = 500, apply = false } = {}) {
+  const events = await query(root, (db) => db.all(
+    `SELECT e.*, t.name AS task_name, t.status AS task_status
+       FROM activity_events e
+       LEFT JOIN tasks t ON t.id = e.task_id
+      WHERE e.event_type IN ('task_completed', 'task_blocked', 'decision_recorded',
+                             'verification_attached', 'question_answered', 'scope_changed')
+      ORDER BY e.sequence DESC LIMIT ?`, limit));
+
+  const worth = [];
+  for (const e of events) {
+    const summary = String(e.summary ?? "");
+    if (e.event_type === "verification_attached" && !/^Passing/.test(summary)) continue;
+    // A scope change is only worth remembering when it says what moved, and
+    // most of them are routine record writes during setup.
+    if (e.event_type === "scope_changed" && !/decision|superseded|cancelled|removed/i.test(summary)) continue;
+    worth.push(e);
+  }
+
+  const plan = { found: events.length, worthRemembering: worth.length, recorded: 0 };
+  if (!apply) return plan;
+
+  for (const e of worth) {
+    const type = e.event_type === "verification_attached" ? "verification_passed" : e.event_type;
+    const made = await capture(root, {
+      type,
+      title: String(e.summary ?? "").slice(0, 120),
+      content: String(e.summary ?? ""),
+      // Read from the trail rather than asserted now: the event is the record
+      // that it happened, which is what makes this confirmed rather than
+      // inferred.
+      confirmed: type === "verification_passed" || type === "task_completed",
+      sourceRef: e.id,
+      dedupeKey: `event:${e.id}`,
+      taskId: e.task_id ?? null,
+      featureId: e.feature_id ?? null,
+      links: [
+        e.task_id ? { type: "task", id: e.task_id } : null,
+        e.feature_id ? { type: "feature", id: e.feature_id } : null,
+      ].filter(Boolean),
+    });
+    if (made) plan.recorded += 1;
+  }
+  return plan;
+}

package/src/memory/consolidate.mjs

@@ -0,0 +1,255 @@
+// Keeping memory worth reading.
+//
+// Section 15.9 asks the memory system to periodically merge duplicates, connect
+// related memories, supersede outdated statements, discard low value noise,
+// detect contradictions, preserve provenance and recalculate retrieval
+// metadata. Without that, memory grows until recall returns everything and
+// therefore nothing.
+//
+// Nothing here deletes a memory that carries a claim. Superseding keeps the
+// statement and marks what replaced it, because a memory that was believed and
+// turned out wrong is itself worth knowing. Only memories that carry no claim,
+// the operational noise section 15.9 names, are removed outright.
+//
+// Every judgement is structural rather than semantic: identical content, an
+// exact contradiction of an earlier statement, a link to a record that no
+// longer exists. A consolidation pass that guessed at meaning would quietly
+// rewrite what the project believes.
+
+import { mutate, query } from "../db/store.mjs";
+import { tokenize } from "./index.mjs";
+
+/** Memory kinds that carry a claim worth keeping even once superseded. */
+const CLAIM_KINDS = new Set(["decision", "learned_fact", "outcome", "blocker", "unresolved_question"]);
+
+/** How stale a session-scoped summary has to be before it is noise. */
+const NOISE_AFTER_DAYS = 30;
+
+const DAY = 86_400_000;
+
+/**
+ * Run a consolidation pass.
+ *
+ * Without `apply` nothing changes, which makes this safe to run at any time and
+ * is the mode worth putting in front of a person: it says what would be merged
+ * and what contradicts what, without changing the answer.
+ */
+export async function consolidate(root, { apply = false, now = Date.now() } = {}) {
+  const state = await query(root, async (db) => ({
+    entries: await db.all(
+      `SELECT id, project_id, kind, title, content, content_hash, epistemic_status,
+              superseded_by, created_at, session_id, task_id, feature_id
+         FROM memory_entries ORDER BY created_at, id`),
+    links: await db.all("SELECT memory_id, target_type, target_id FROM memory_links"),
+    terms: await db.all("SELECT memory_id, COUNT(*) n FROM memory_search_terms GROUP BY memory_id"),
+  }));
+
+  const live = state.entries.filter((e) => !e.superseded_by);
+  const termCount = new Map(state.terms.map((t) => [t.memory_id, t.n]));
+
+  // Duplicates: the same content said twice. The earliest is kept because it is
+  // the one other records may already point at, and the later ones are marked
+  // as superseded by it rather than deleted.
+  const byHash = new Map();
+  const duplicates = [];
+  for (const entry of live) {
+    const key = entry.content_hash || `${entry.kind}:${String(entry.content ?? "").trim()}`;
+    if (!key) continue;
+    if (byHash.has(key)) duplicates.push({ duplicate: entry, keep: byHash.get(key) });
+    else byHash.set(key, entry);
+  }
+
+  // Contradictions: two live memories about the same records saying opposite
+  // things. Detected structurally, by one statement negating another that
+  // shares its subject, never by judging which is true.
+  const linksByMemory = new Map();
+  for (const l of state.links) {
+    if (!linksByMemory.has(l.memory_id)) linksByMemory.set(l.memory_id, new Set());
+    linksByMemory.get(l.memory_id).add(`${l.target_type}:${l.target_id}`);
+  }
+  const contradictions = [];
+  for (let i = 0; i < live.length; i += 1) {
+    for (let j = i + 1; j < live.length; j += 1) {
+      const a = live[i];
+      const b = live[j];
+      const sharedTargets = [...(linksByMemory.get(a.id) ?? [])]
+        .filter((t) => (linksByMemory.get(b.id) ?? new Set()).has(t));
+      if (sharedTargets.length === 0) continue;
+      if (!negates(a.content, b.content)) continue;
+      contradictions.push({ earlier: a.id, later: b.id, about: sharedTargets[0] });
+    }
+  }
+
+  // Noise: a session summary old enough that its session is long over, carrying
+  // no claim and linked to nothing. Section 15.9 asks for these to be
+  // discarded, and they are the only thing here that is.
+  const linked = new Set(state.links.map((l) => l.memory_id));
+  const noise = live.filter((e) =>
+    !CLAIM_KINDS.has(e.kind)
+    && !linked.has(e.id)
+    && now - Date.parse(e.created_at || 0) > NOISE_AFTER_DAYS * DAY);
+
+  // Retrieval metadata that was never built. A memory with no search terms
+  // cannot be found lexically, which is the first retrieval stage 15.7 names.
+  const missingTerms = live.filter((e) => !termCount.get(e.id));
+
+  // Links pointing at records that no longer exist. Section 14.2 says memory
+  // links cannot reference missing records.
+  const danglingLinks = await query(root, async (db) => {
+    const out = [];
+    const tables = {
+      goal: "goals", milestone: "milestones", module: "modules", feature: "features",
+      workflow: "workflows", task: "tasks", decision: "decisions", data_entity: "data_entities",
+      surface: "surfaces", api_operation: "api_operations", integration: "integrations",
+      change: "changes", assumption: "assumptions", question: "questions",
+    };
+    for (const l of state.links) {
+      const table = tables[l.target_type];
+      if (!table) continue;
+      const hit = await db.get(`SELECT 1 AS ok FROM ${table} WHERE id = ?`, l.target_id);
+      if (!hit) out.push(l);
+    }
+    return out;
+  });
+
+  const plan = {
+    applied: apply,
+    live: live.length,
+    duplicatesMerged: duplicates.length,
+    contradictionsFound: contradictions.length,
+    noiseDiscarded: noise.length,
+    retrievalTermsRebuilt: missingTerms.length,
+    danglingLinksRemoved: danglingLinks.length,
+    contradictions: contradictions.slice(0, 10),
+  };
+
+  if (!apply) return plan;
+
+  await mutate(root, async (db) => {
+    const at = new Date().toISOString();
+
+    for (const { duplicate, keep } of duplicates) {
+      await db.run("UPDATE memory_entries SET superseded_by = ? WHERE id = ?", keep.id, duplicate.id);
+    }
+
+    // A contradiction is not resolved here. Both statements stay, and the
+    // earlier one is marked contradicted so recall can warn rather than pick a
+    // side, which is what 15.8 asks of a recalled memory.
+    for (const c of contradictions) {
+      await db.run("UPDATE memory_entries SET epistemic_status = ? WHERE id = ?", "contradicted", c.earlier);
+    }
+
+    for (const entry of noise) {
+      await db.run("DELETE FROM memory_search_terms WHERE memory_id = ?", entry.id);
+      await db.run("DELETE FROM memory_entries WHERE id = ?", entry.id);
+    }
+
+    for (const entry of missingTerms) {
+      if (noise.some((n) => n.id === entry.id)) continue;
+      await indexTerms(db, entry);
+    }
+
+    for (const l of danglingLinks) {
+      await db.run(
+        "DELETE FROM memory_links WHERE memory_id = ? AND target_type = ? AND target_id = ?",
+        l.memory_id, l.target_type, l.target_id);
+    }
+
+    const project = await db.get("SELECT id FROM projects LIMIT 1");
+    if (project) {
+      await db.run(
+        `INSERT INTO activity_events (id, project_id, actor_label, event_type, summary, created_at, sequence)
+         VALUES ((SELECT 'EVT-' || printf('%04d', COALESCE(MAX(CAST(SUBSTR(id, 5) AS INTEGER)), 0) + 1) FROM activity_events),
+                 ?, ?, ?, ?, ?,
+                 (SELECT COALESCE(MAX(sequence), 0) + 1 FROM activity_events))`,
+        project.id, "superdev", "memory_consolidated",
+        `Memory consolidated: ${duplicates.length} duplicates merged, ${contradictions.length} contradictions marked, ${noise.length} discarded.`,
+        at,
+      );
+    }
+  });
+
+  return plan;
+}
+
+/** Rebuild the lexical index for one entry, which is retrieval stage three. */
+async function indexTerms(db, entry) {
+  const fields = [["title", entry.title, 3], ["content", entry.content, 1]];
+  const counts = new Map();
+  for (const [field, text, weight] of fields) {
+    for (const term of tokenize(text ?? "")) {
+      const key = `${field}:${term}`;
+      counts.set(key, { field, term, weight, n: (counts.get(key)?.n ?? 0) + 1 });
+    }
+  }
+  for (const { field, term, weight, n } of counts.values()) {
+    await db.run(
+      `INSERT OR REPLACE INTO memory_search_terms (memory_id, term, field, frequency, field_weight)
+       VALUES (?, ?, ?, ?, ?)`,
+      entry.id, term, field, n, weight,
+    );
+  }
+}
+
+/**
+ * Does one statement negate another?
+ *
+ * Structural only: the same words with a negation on one side and not the
+ * other. This finds "the service holds the lock" against "the service does not
+ * hold the lock" and finds nothing clever, which is the intent. Judging meaning
+ * would let a consolidation pass rewrite what the project believes.
+ */
+function negates(a, b) {
+  const NEG = /\b(not|never|no longer|cannot|does not|is not|was not)\b/i;
+  const strip = (t) => String(t ?? "").toLowerCase().replace(NEG, " ").replace(/\s+/g, " ").trim();
+  const aNeg = NEG.test(String(a ?? ""));
+  const bNeg = NEG.test(String(b ?? ""));
+  if (aNeg === bNeg) return false;
+  const sa = strip(a);
+  const sb = strip(b);
+  if (!sa || !sb) return false;
+  // The remaining words have to be substantially the same statement, not merely
+  // on the same topic.
+  const wa = new Set(sa.split(" ").filter((w) => w.length > 3));
+  const wb = new Set(sb.split(" ").filter((w) => w.length > 3));
+  if (wa.size < 3 || wb.size < 3) return false;
+  const shared = [...wa].filter((w) => wb.has(w)).length;
+  return shared / Math.max(wa.size, wb.size) > 0.7;
+}
+
+/**
+ * What the memory system currently holds, and what it cannot do.
+ *
+ * Section 15.11 requires saying plainly that semantic retrieval is a bounded
+ * scan when the engine has no vector index, and never describing it as indexed
+ * vector search. That sentence is here rather than in a comment because it is
+ * the answer to a question a person asks this command.
+ */
+export async function memoryStatus(root) {
+  const s = await query(root, async (db) => ({
+    total: (await db.get("SELECT COUNT(*) n FROM memory_entries")).n,
+    live: (await db.get("SELECT COUNT(*) n FROM memory_entries WHERE superseded_by IS NULL")).n,
+    superseded: (await db.get("SELECT COUNT(*) n FROM memory_entries WHERE superseded_by IS NOT NULL")).n,
+    byKind: await db.all("SELECT kind, COUNT(*) n FROM memory_entries WHERE superseded_by IS NULL GROUP BY kind ORDER BY n DESC"),
+    byStatus: await db.all("SELECT epistemic_status, COUNT(*) n FROM memory_entries WHERE superseded_by IS NULL GROUP BY epistemic_status ORDER BY n DESC"),
+    links: (await db.get("SELECT COUNT(*) n FROM memory_links")).n,
+    terms: (await db.get("SELECT COUNT(*) n FROM memory_search_terms")).n,
+    indexed: (await db.get("SELECT COUNT(DISTINCT memory_id) n FROM memory_search_terms")).n,
+    embeddings: (await db.get("SELECT COUNT(*) n FROM memory_embeddings")).n,
+    oldest: (await db.get("SELECT MIN(created_at) t FROM memory_entries")).t,
+    newest: (await db.get("SELECT MAX(created_at) t FROM memory_entries")).t,
+  }));
+
+  return {
+    ...s,
+    notIndexedForSearch: Math.max(0, s.live - s.indexed),
+    retrieval: {
+      // Section 15.7's stages, and which of them this actually performs.
+      stages: ["structured filters", "record relationships", "lexical retrieval", "recency",
+               "memory type weighting", "epistemic status weighting"],
+      semantic: s.embeddings > 0
+        ? "A bounded scan over stored vectors. The local engine has no vector index, so this is not indexed vector search."
+        : "Not in use. No embeddings are stored, and section 15.11 leaves the provider undecided.",
+    },
+  };
+}