@jmtrin/opencode-kevin 1.0.0 → 1.1.0

package/dist/plugin/columns.js

@@ -0,0 +1,54 @@
+const cache = new WeakMap();
+export function hasColumn(store, table, column) {
+    const byStore = cache.get(store);
+    const key = `${table}.${column}`;
+    if (byStore?.get(key) === true)
+        return true;
+    try {
+        store.prepare(`SELECT ${column} FROM ${table} LIMIT 0`).get();
+        let m = byStore;
+        if (!m) {
+            m = new Map();
+            cache.set(store, m);
+        }
+        m.set(key, true);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// v1.1.0 (K11-011 / plan §5.5, D11-06) — named helpers delegating to the registry
+export function hasIgnoredColumn(store) {
+    return hasColumn(store, "memories", "ignored");
+}
+export function hasCuratedColumn(store) {
+    return hasColumn(store, "memories", "curated");
+}
+export function hasTruthColumns(store) {
+    return hasColumn(store, "memories", "truth_penalty");
+}
+export function hasRepoIdColumn(store) {
+    return hasColumn(store, "memories", "repo_id");
+}
+export function hasLayerColumn(store) {
+    return hasColumn(store, "memories", "layer");
+}
+export function hasRecurrenceColumn(store) {
+    return hasColumn(store, "memories", "recurrence_count");
+}
+export function hasArchivedColumn(store) {
+    return hasColumn(store, "memories", "archived_at");
+}
+export function hasFeedbackColumns(store) {
+    return hasColumn(store, "memories", "feedback_positive");
+}
+export function hasFeedbackTable(store) {
+    try {
+        store.prepare("SELECT COUNT(*) FROM memory_feedback LIMIT 0").get();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plugin/contract.d.ts

@@ -28,6 +28,14 @@ export declare const CONTRACT_TOOL_ADDITIONS: readonly {
     name: string;
     since: string;
 }[];
+/**
+ * v1.1.0 (K11-007 / plan §5.1, D11-01) — metric keys added after the freeze,
+ * each carrying the `since` the deprecation policy requires (C-05).
+ */
+export declare const CONTRACT_METRIC_ADDITIONS: readonly {
+    name: string;
+    since: string;
+}[];
 /**
  * v1.0.0 (K10-027 / plan §5.7) — the C-09 boundary addition. Stored is
  * not trusted: anything reaching an artifact or a prompt is escaped at

package/dist/plugin/contract.js

@@ -41,8 +41,18 @@ export const CONTRACT_TOOL_NAMES = [
  * added_bare.
  */
 export const CONTRACT_TOOL_ADDITIONS = [
-    { name: "kevin_contract", since: "1.0.0" },
     { name: "kevin_bench", since: "1.0.0" },
+    { name: "kevin_contract", since: "1.0.0" },
+    { name: "kevin_forget", since: "1.1.0" },
+];
+/**
+ * v1.1.0 (K11-007 / plan §5.1, D11-01) — metric keys added after the freeze,
+ * each carrying the `since` the deprecation policy requires (C-05).
+ */
+export const CONTRACT_METRIC_ADDITIONS = [
+    { name: "bench_regression_failures", since: "1.1.0" },
+    { name: "forget_requests_total", since: "1.1.0" },
+    { name: "forget_tombstones_published", since: "1.1.0" },
 ];
 /**
  * v1.0.0 (K10-027 / plan §5.7) — the C-09 boundary addition. Stored is
@@ -76,12 +86,17 @@ export function describeContract(_input) {
     // Derive clause values from live source wherever possible (plan §5.1).
     // C-03 members added after the freeze carry their `since` as objects;
     // the original frozen set stays plain strings.
-    const additions = [...CONTRACT_TOOL_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
+    const toolAdditions = [...CONTRACT_TOOL_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
     const toolValue = {
-        tools: [[...CONTRACT_TOOL_NAMES].sort(), additions].flat(),
+        tools: [[...CONTRACT_TOOL_NAMES].sort(), toolAdditions].flat(),
     };
     const settingValue = { keys: [...KEVIN_CONFIG_KEYS].sort() };
-    const metricValue = { keys: Object.keys(METRIC_KEY_LABELS).sort() };
+    // v1.1.0 — metric keys added after freeze carry `since` (C-05)
+    const metricAdditions = [...CONTRACT_METRIC_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
+    const baseMetricKeys = Object.keys(METRIC_KEY_LABELS)
+        .filter((k) => !metricAdditions.some((a) => a.name === k))
+        .sort();
+    const metricValue = { keys: [...baseMetricKeys, ...metricAdditions].flat() };
     const clauses = [
         {
             id: "C-01",
@@ -149,7 +164,7 @@ export function describeContract(_input) {
             stability: "forward-only",
             since: "0.1.0",
             value: {
-                schema_version: "011",
+                schema_version: "012",
                 migrations_forward_only: true,
             },
         },

package/dist/plugin/index.d.ts

@@ -19,7 +19,7 @@ export interface KevinPluginOptions {
 export declare const KEVIN_CONFIG_KEYS: readonly ["quality_gate_enabled", "lesson_snippet_injection", "patternminer_enabled", "cross_project_enabled", "llm_reflection_enabled", "tool_calls_dedup_enabled", "deterministic_retrieval", "pre_prompt_budget_tokens", "archive_after_days", "curation_enabled", "agents_md_path", "skill_emission_enabled", "reference_emission_enabled", "injection_confidence_floor", "repo_truth_enabled", "convention_mining_enabled", "conflict_detection_enabled", "error_lesson_mode", "shared_layer_enabled", "okf_path", "share_requires_approval", "author_identity_mode", "shared_confidence_floor", "hook_liveness_enabled", "native_registration_enabled", "host_probe_history_enabled", "dead_hook_report_threshold", "perf_enabled", "perf_ring_capacity", "perf_flush_on_idle", "contract_report_enabled"];
 export declare const ERROR_LESSON_MODE_VALUES: readonly ["all", "triage_only"];
 /** Plugin release version — stamped into generated files (K8-021/027). */
-export declare const KEVIN_VERSION = "1.0.0";
+export declare const KEVIN_VERSION = "1.1.0";
 export interface RekeyCounts {
     memories: number;
     shared_entries: number;

package/dist/plugin/index.js

@@ -34,6 +34,7 @@ import { executeKevinConflicts } from "./kevin_conflicts.js";
 import { buildKevinContract } from "./kevin_contract.js";
 import { buildDoctor } from "./kevin_doctor.js";
 import { buildKevinFacts } from "./kevin_facts.js";
+import { handleForget } from "./kevin_forget.js";
 import { handleNative } from "./kevin_native.js";
 import { kevinPropose } from "./kevin_propose.js";
 import { kevinPublish } from "./kevin_publish.js";
@@ -112,6 +113,7 @@ export const KEVIN_CONFIG_KEYS = [
     "perf_flush_on_idle",
     "contract_report_enabled",
 ];
+// v1.1.0 (K11-007 / D11-08) — no new settings in 1.1.0; thresholds are constants (D11-03)
 // v0.7.0 (K7-003 / plan §5.6, D7-12) — the explicit VALUE domain for
 // `error_lesson_mode`. The setting is TEXT and must be compared with
 // `=== "triage_only"`, never by truthiness; the domain here is enforced by
@@ -120,7 +122,7 @@ export const KEVIN_CONFIG_KEYS = [
 // behaviour on the next reflection.
 export const ERROR_LESSON_MODE_VALUES = ["all", "triage_only"];
 /** Plugin release version — stamped into generated files (K8-021/027). */
-export const KEVIN_VERSION = "1.0.0";
+export const KEVIN_VERSION = "1.1.0";
 function resolveMigrationsDir() {
     const here = dirname(fileURLToPath(import.meta.url));
     return join(here, "..", "migrations");
@@ -870,8 +872,9 @@ export const KevinPlugin = async (input, options) => {
                             // monotone across releases; K6-024 extends this
                             // block with the remaining v0.6 fields. v0.8.0
                             // (K8-025) — 18 v0.7 + kevin_project +
-                            // kevin_native = 23.
-                            tool_count: 23,
+                            // kevin_native = 23. v1.0.0 (K10-018) — +kevin_contract +kevin_bench = 25.
+                            // v1.1.0 (K11-007) — +kevin_forget = 26.
+                            tool_count: 26,
                             v07,
                             memories_reflector: memoriesReflector,
                             memories_agent: memoriesAgent,
@@ -1461,6 +1464,24 @@ export const KevinPlugin = async (input, options) => {
                     };
                 },
             }),
+            // v1.1.0 (K11-007 / plan §5.1, D11-02) — kevin_forget: closes the sharing lifecycle.
+            kevin_forget: tool({
+                description: "Olvida memorias y publica tombstones en la capa compartida (v1.1.0, K11-005/006 / plan §5.1): dry-run por defecto — sin confirm no muta nada y devuelve el plan (archived, tombstone planned); con confirm:true archiva localmente (status='archived') y, cuando la memoria proyecta a la capa compartida (layer='shared' o shared_entry_id), publica un tombstone via el unico write path (SharedLayer.applyExport, D8-08). Segunda invocacion identica reporta noop.",
+                args: {
+                    ids: tool.schema.array(tool.schema.string()).min(1),
+                    confirm: tool.schema.boolean().optional(),
+                },
+                async execute(args) {
+                    const okfPath = join(projectRoot, memoryService.getSetting("okf_path", ".kevin/knowledge.okf"));
+                    const result = handleForget({ ids: args.ids, confirm: args.confirm }, { store, memoryService, sharedLayer, okfPath, metrics });
+                    return {
+                        title: result.dry_run
+                            ? "Plan de olvido (dry-run)"
+                            : "Olvido aplicado",
+                        output: JSON.stringify(result),
+                    };
+                },
+            }),
             kevin_approve: tool({
                 description: "Aprueba o rechaza una propuesta de curacion (v0.6.0). reject: marca rejected, nada toca disco. approve: aplica el diff (unico call site de ArtifactWriter.apply, D6-01), marca applied y cura las memorias contribuyentes. Solo acepta propuestas pending.",
                 args: {

package/dist/plugin/kevin_forget.d.ts

@@ -0,0 +1,33 @@
+import type { MemoryService } from "./MemoryService.js";
+import type { SharedLayer } from "./SharedLayer.js";
+import type { Store } from "./Store.js";
+import type { Metrics } from "./metrics.js";
+export interface ForgetInput {
+    ids: string[];
+    confirm?: boolean;
+}
+export interface Deps {
+    store: Store;
+    memoryService: MemoryService;
+    sharedLayer: SharedLayer;
+    okfPath: string;
+    metrics: Metrics;
+}
+export interface ForgetResult {
+    action: "forget";
+    ok: boolean;
+    dry_run: boolean;
+    per_id: Array<{
+        id: string;
+        archived: boolean;
+        reason?: string;
+        tombstone?: {
+            entry_id: string;
+            planned: boolean;
+            applied: boolean;
+        };
+    }>;
+    noop?: boolean;
+    reason?: string;
+}
+export declare function handleForget(input: ForgetInput, deps: Deps): ForgetResult;

package/dist/plugin/kevin_forget.js

@@ -0,0 +1,260 @@
+import { computeEntryId } from "./okf.js";
+export function handleForget(input, deps) {
+    // v1.1.0 — every invocation counts, including dry runs and refusals (K11-005)
+    try {
+        deps.metrics.incr("forget_requests_total", 1);
+    }
+    catch {
+        // best-effort
+    }
+    if (!input.ids || input.ids.length === 0) {
+        return {
+            action: "forget",
+            ok: false,
+            dry_run: input.confirm !== true,
+            per_id: [],
+            reason: "no_ids",
+        };
+    }
+    const isDry = input.confirm !== true;
+    const per_id = [];
+    let anyChange = false;
+    let anyTombstonePlanned = false;
+    // Helper to compute entry_id for a memory row
+    const getEntryId = (row) => {
+        if (row.shared_entry_id)
+            return row.shared_entry_id;
+        return computeEntryId(row.type, row.content, row.scope);
+    };
+    // For dry_run: just plan, mutate nothing
+    if (isDry) {
+        for (const id of input.ids) {
+            const row = deps.store
+                .prepare("SELECT id, type, content, scope, status, layer, shared_entry_id FROM memories WHERE id = ?")
+                .get(id);
+            if (!row) {
+                per_id.push({ id, archived: false, reason: "not_found" });
+                continue;
+            }
+            if (row.status === "archived") {
+                // Idempotence: already archived
+                const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+                if (isShared) {
+                    const entryId = getEntryId(row);
+                    try {
+                        const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+                        const planned = plan.write.outcome !== "refused" && plan.entriesAdded > 0;
+                        // Already archived implies tombstone already applied, so planned should be false (noop)
+                        per_id.push({
+                            id,
+                            archived: false,
+                            reason: "already_archived",
+                            tombstone: { entry_id: entryId, planned: false, applied: false },
+                        });
+                        void plan;
+                        void planned;
+                    }
+                    catch {
+                        per_id.push({
+                            id,
+                            archived: false,
+                            reason: "already_archived",
+                            tombstone: { entry_id: entryId, planned: false, applied: false },
+                        });
+                    }
+                }
+                else {
+                    per_id.push({ id, archived: false, reason: "already_archived" });
+                }
+                continue;
+            }
+            // Would archive
+            anyChange = true;
+            const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+            if (isShared) {
+                const entryId = getEntryId(row);
+                let planned = false;
+                try {
+                    const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+                    // planTombstone returns ExportPlan with write outcome; if refused, planned false
+                    planned = plan.write.outcome !== "refused";
+                    anyTombstonePlanned = anyTombstonePlanned || planned;
+                    per_id.push({
+                        id,
+                        archived: true,
+                        tombstone: { entry_id: entryId, planned, applied: false },
+                    });
+                }
+                catch {
+                    per_id.push({
+                        id,
+                        archived: true,
+                        tombstone: { entry_id: entryId, planned: false, applied: false },
+                    });
+                }
+            }
+            else {
+                per_id.push({ id, archived: true });
+            }
+        }
+        const noop = !anyChange;
+        return {
+            action: "forget",
+            ok: true,
+            dry_run: true,
+            per_id,
+            ...(noop ? { noop: true } : {}),
+        };
+    }
+    // Apply mode: confirm === true
+    // We need to archive locally and publish tombstones through applyExport
+    let partial = false;
+    let appliedTombstones = 0;
+    for (const id of input.ids) {
+        const row = deps.store
+            .prepare("SELECT id, type, content, scope, status, layer, shared_entry_id FROM memories WHERE id = ?")
+            .get(id);
+        if (!row) {
+            per_id.push({ id, archived: false, reason: "not_found" });
+            continue;
+        }
+        if (row.status === "archived") {
+            const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+            if (isShared) {
+                const entryId = getEntryId(row);
+                per_id.push({
+                    id,
+                    archived: false,
+                    reason: "already_archived",
+                    tombstone: { entry_id: entryId, planned: false, applied: false },
+                });
+            }
+            else {
+                per_id.push({ id, archived: false, reason: "already_archived" });
+            }
+            continue;
+        }
+        // Archive locally in a transaction
+        let archived = false;
+        try {
+            deps.store.transaction(() => {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'archived', archived_at = datetime('now'), updated_at = datetime('now') WHERE id = ? AND status != 'archived'`)
+                    .run(id);
+                const changes = deps.store.prepare("SELECT changes() AS c").get();
+                if (changes.c > 0)
+                    archived = true;
+            });
+        }
+        catch (e) {
+            per_id.push({ id, archived: false, reason: "db_error" });
+            partial = true;
+            continue;
+        }
+        anyChange = anyChange || archived;
+        const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+        if (!isShared) {
+            per_id.push({ id, archived });
+            continue;
+        }
+        const entryId = getEntryId(row);
+        // Plan tombstone
+        let plan;
+        try {
+            plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+        }
+        catch (e) {
+            // plan failure: rollback DB archive for this id (best-effort)
+            try {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'active', archived_at = NULL WHERE id = ?`)
+                    .run(id);
+            }
+            catch { }
+            per_id.push({
+                id,
+                archived: false,
+                reason: "plan_failed",
+                tombstone: { entry_id: entryId, planned: false, applied: false },
+            });
+            partial = true;
+            continue;
+        }
+        if (plan.write.outcome === "refused") {
+            // Refusal reasons are reused verbatim (repo_mismatch, unknown_entry)
+            const reason = plan.write.reason ?? "refused";
+            per_id.push({
+                id,
+                archived,
+                reason,
+                tombstone: { entry_id: entryId, planned: false, applied: false },
+            });
+            // DB archive already done; keep it (local archive is independent of shared refusal)
+            continue;
+        }
+        // Apply through single write funnel
+        try {
+            const applied = deps.sharedLayer.applyExport(plan);
+            const wasWritten = applied.applied === "written";
+            const wasNoop = applied.applied === "noop";
+            if (wasWritten)
+                appliedTombstones++;
+            // per_id tombstone: planned true if not refused, applied true only if written
+            per_id.push({
+                id,
+                archived,
+                tombstone: {
+                    entry_id: entryId,
+                    planned: true,
+                    applied: wasWritten,
+                },
+            });
+            void wasNoop;
+        }
+        catch (e) {
+            // v1.1.0 — failure mid-way: transaction rollback restores DB; already-applied OKF write is reported honestly
+            // For this id, DB was already archived, but file write failed. We attempt to rollback DB for this id.
+            try {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'active', archived_at = NULL WHERE id = ?`)
+                    .run(id);
+                archived = false;
+            }
+            catch { }
+            per_id.push({
+                id,
+                archived: false,
+                reason: "partial",
+                tombstone: { entry_id: entryId, planned: true, applied: false },
+            });
+            partial = true;
+            // Continue to next id? According spec, failure mid-way reports ok:false reason partial
+            // We keep processing remaining ids? For now we continue but mark partial.
+        }
+    }
+    // Metrics: increment forget_tombstones_published by applied count (only when written, not noop)
+    if (appliedTombstones > 0) {
+        try {
+            deps.metrics.incr("forget_tombstones_published", appliedTombstones);
+        }
+        catch { }
+    }
+    const noop = !anyChange && per_id.every((p) => p.archived === false);
+    if (partial) {
+        return {
+            action: "forget",
+            ok: false,
+            dry_run: false,
+            per_id,
+            reason: "partial",
+            ...(noop ? { noop: true } : {}),
+        };
+    }
+    return {
+        action: "forget",
+        ok: true,
+        dry_run: false,
+        per_id,
+        ...(noop ? { noop: true } : {}),
+    };
+}

package/dist/plugin/kevin_why.js

@@ -1,24 +1,7 @@
 import { TS_CODE_RULES } from "./Reflector.js";
+import { hasFeedbackColumns } from "./columns.js";
 import { computeConfidence } from "./confidence.js";
 import { toMatchClause, tokenizeQuery } from "./query-tokenizer.js";
-// v0.5.0 (K5-010 / plan §5.3) — pre-006 DBs lack the feedback columns;
-// kevin_why must not reference them (it degrades via the try/catch below,
-// which is for missing ROWS, not missing COLUMNS). Probe once per store.
-const feedbackColumnCache = new WeakMap();
-function hasFeedbackColumns(store) {
-    const cached = feedbackColumnCache.get(store);
-    if (cached !== undefined)
-        return cached;
-    try {
-        store.prepare("SELECT feedback_positive FROM memories LIMIT 1").get();
-        feedbackColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        feedbackColumnCache.set(store, false);
-        return false;
-    }
-}
 export function kevinWhy(store, query) {
     // v0.3.0 fix (bug #7) — the old code wrapped the WHOLE query in a
     // single quoted phrase, so it only matched the exact full-string

package/dist/plugin/metrics.d.ts

@@ -6,7 +6,7 @@ import type { Store } from "./Store.js";
  * underlying table is empty (e.g., before 003 is applied, on a fresh
  * :memory: test DB, or after a manual wipe).
  */
-export declare const METRIC_KEYS: readonly ["tokens_injected_pre_prompt", "tokens_injected_compacting", "reflections_throttled", "duplicate_suppressions", "tool_calls_deduped", "patterns_mined", "patterns_causal", "causal_links", "memories_superseded", "injections_total", "injections_effective", "injections_ineffective", "patterns_promoted_new", "injections_inconclusive", "injections_blocked_seen", "injections_blocked_weak", "injections_blocked_recurrence", "injections_blocked_stale", "injections_blocked_ignored", "feedback_positive_total", "feedback_negative_total", "memories_archived", "proposals_created", "proposals_approved", "proposals_rejected", "artifact_writes_total", "artifact_writes_noop", "injections_blocked_confidence", "repo_facts_scanned", "memories_contradicted", "conventions_mined", "conflicts_detected", "error_lessons_suppressed", "shared_entries_total", "shared_entries_imported", "shared_entries_exported", "okf_merge_folds", "rekey_events", "injections_from_shared"];
+export declare const METRIC_KEYS: readonly ["tokens_injected_pre_prompt", "tokens_injected_compacting", "reflections_throttled", "duplicate_suppressions", "tool_calls_deduped", "patterns_mined", "patterns_causal", "causal_links", "memories_superseded", "injections_total", "injections_effective", "injections_ineffective", "patterns_promoted_new", "injections_inconclusive", "injections_blocked_seen", "injections_blocked_weak", "injections_blocked_recurrence", "injections_blocked_stale", "injections_blocked_ignored", "feedback_positive_total", "feedback_negative_total", "memories_archived", "proposals_created", "proposals_approved", "proposals_rejected", "artifact_writes_total", "artifact_writes_noop", "injections_blocked_confidence", "repo_facts_scanned", "memories_contradicted", "conventions_mined", "conflicts_detected", "error_lessons_suppressed", "shared_entries_total", "shared_entries_imported", "shared_entries_exported", "okf_merge_folds", "rekey_events", "injections_from_shared", "bench_regression_failures", "forget_requests_total", "forget_tombstones_published"];
 export type MetricKey = (typeof METRIC_KEYS)[number];
 /**
  * Cheap token estimate used when bumping the `tokens_injected_*` counters.

package/dist/plugin/metrics.js

@@ -57,6 +57,10 @@ export const METRIC_KEYS = [
     "okf_merge_folds",
     "rekey_events",
     "injections_from_shared",
+    // v1.1.0 (K11-001 / plan §4, D11-01) — drift metrics; order matches 012 seed.
+    "bench_regression_failures",
+    "forget_requests_total",
+    "forget_tombstones_published",
 ];
 const DEFAULT_FLUSH_MS = 1000;
 function zeroCache() {

package/dist/plugin/query-tokenizer.js

@@ -4,68 +4,116 @@
  * Injection recall ORs the quoted tokens (`"t1" OR "t2"`) while
  * `kevin_why` ANDs them (`"t1" AND "t2"`).
  */
+// v1.1.0 (K11-012 / plan §5.5, D11-05) — single source for STOP_WORDS (union of three lists)
 export const STOP_WORDS = new Set([
     "a",
+    "about",
+    "after",
+    "again",
+    "all",
+    "also",
     "an",
     "and",
+    "any",
     "are",
+    "as",
     "at",
     "be",
     "been",
+    "before",
+    "being",
     "but",
     "by",
+    "can",
+    "como",
+    "con",
+    "could",
+    "de",
     "did",
     "do",
     "does",
     "el",
+    "en",
     "eso",
     "for",
+    "from",
+    "had",
+    "has",
+    "have",
+    "he",
+    "her",
+    "his",
     "how",
     "i",
     "if",
     "in",
+    "into",
     "is",
     "it",
+    "its",
     "la",
     "las",
     "los",
+    "may",
     "mi",
+    "might",
+    "more",
+    "most",
+    "must",
     "my",
+    "not",
     "o",
     "of",
     "on",
+    "one",
     "or",
+    "our",
     "para",
+    "per",
     "por",
     "que",
+    "shall",
     "she",
+    "sin",
+    "so",
     "su",
+    "than",
     "that",
     "the",
+    "their",
+    "them",
+    "then",
+    "there",
+    "these",
+    "they",
     "this",
+    "those",
+    "through",
     "to",
+    "too",
     "tu",
     "un",
     "una",
+    "under",
+    "up",
+    "us",
+    "via",
+    "was",
     "we",
     "were",
     "what",
     "when",
     "where",
     "which",
+    "while",
     "who",
     "why",
+    "will",
     "with",
+    "would",
     "y",
     "you",
-    "como",
-    "con",
-    "de",
-    "en",
-    "he",
-    "they",
-    "was",
-    "sin",
+    "your",
 ]);
 /** Lowercase, split on whitespace, drop stopwords. Returns raw tokens. */
 export function tokenizeQuery(query) {

package/dist/plugin/time-ms.d.ts

@@ -0,0 +1 @@
+export declare function toMs(legacyValue: string | null | undefined, msValue: number | null | undefined): number | null;