om-memory-system 4.24.0-next.147 → 4.25.0

package/dist/adapters/opencode/user-prompt.js

@@ -1,6 +1,7 @@
 import { isStructuredSummaryPromptMessage } from "../../core/internal-prompt.js";
 import { isInternalStructuredSession } from "./opencode-provider.js";
 import { userPromptManager } from "../../services/user-prompt/user-prompt-manager.js";
+import { isFullyPrivate, stripPrivateContent } from "../../services/privacy.js";
 export { isStructuredSummaryPromptMessage };
 /** True when a prompt is omms's own internal traffic and must not be recorded or searched. */
 export function isInternalPrompt(sessionID, userMessage) {
@@ -14,6 +15,10 @@ export function isInternalPrompt(sessionID, userMessage) {
 export async function recordUserPrompt(sessionID, messageID, directory, userMessage) {
     if (!userMessage.trim() || isInternalPrompt(sessionID, userMessage))
         return false;
-    await userPromptManager.savePrompt(sessionID, messageID, directory, userMessage);
+    // Profile learning quotes saved prompts as evidence, so <private> text must
+    // never reach the store (the Claude Code hook strips it the same way).
+    if (isFullyPrivate(userMessage))
+        return false;
+    await userPromptManager.savePrompt(sessionID, messageID, directory, stripPrivateContent(userMessage));
     return true;
 }

package/dist/config.d.ts

@@ -1,4 +1,5 @@
 import { isPlaceholderApiKey } from "./services/ai/api-key-placeholder.js";
+import { type KeywordMode } from "./utils/keyword-boost.js";
 interface OmmsConfig {
     storagePath?: string;
     userEmailOverride?: string;
@@ -20,6 +21,10 @@ interface OmmsConfig {
     rerankerModel?: string;
     rerankerApiKey?: string;
     rerankerTimeoutMs?: number;
+    /** Extra similarity for a memory that holds a word of the prompt, 0 to 0.5. 0 turns it off. */
+    keywordBoost?: number;
+    /** How word matches join the results: `boost` (default) or `rrf` (experimental). */
+    keywordMode?: KeywordMode;
     /** Shared budget for automatic memory context in approximate tokens (ceil(UTF-8 bytes / 4)). */
     retrievalMaxTokens?: number;
     maxProfileItems?: number;
@@ -134,6 +139,8 @@ declare function buildConfig(fileConfig: OmmsConfig): {
     rerankerModel: string | undefined;
     rerankerApiKey: string | undefined;
     rerankerTimeoutMs: number;
+    keywordBoost: number;
+    keywordMode: KeywordMode;
     maxMemories: number;
     retrievalMaxTokens: number;
     maxProfileItems: number;
@@ -237,6 +244,8 @@ export declare let CONFIG: {
     rerankerModel: string | undefined;
     rerankerApiKey: string | undefined;
     rerankerTimeoutMs: number;
+    keywordBoost: number;
+    keywordMode: KeywordMode;
     maxMemories: number;
     retrievalMaxTokens: number;
     maxProfileItems: number;

package/dist/config.js

@@ -11,7 +11,9 @@ import { parseBackfillModel } from "./importer/backfill-model.js";
 import { parseIgnoredDirectories, parseImportPathMaps } from "./importer/import-path-maps.js";
 import { checkedMemoryLimit, MEMORY_LIMITS } from "./utils/memory-limits.js";
 import { defaultSimilarityThreshold } from "./utils/threshold-default.js";
-import { RERANKER_TIMEOUT_DEFAULT_MS, RERANKER_TIMEOUT_MAX_MS, RERANKER_TIMEOUT_MIN_MS, } from "./services/request-timeouts.js";
+import { RERANKER_TIMEOUT_DEFAULT_MS } from "./services/request-timeouts.js";
+import { checkedRerankerSettings } from "./utils/reranker-settings.js";
+import { checkedKeywordBoost, checkedKeywordMode, } from "./utils/keyword-boost.js";
 import { resolveDefaultStoragePath, runLegacyStoreMigration, legacyMigrationPaths, } from "./services/legacy-migration.js";
 const OMMS_CONFIG_DIR = join(homedir(), ".config", "omms");
 const DATA_DIR = join(homedir(), ".omms");
@@ -245,49 +247,6 @@ export function normalizeCaptureRetryRetentionHours(value) {
     }
     return Math.min(720, Math.max(0, Math.floor(value)));
 }
-/** The reranker key must be a reference, never a literal secret in the file. */
-function isRerankerKeyReference(value) {
-    return /^(env:\/\/[A-Za-z_][A-Za-z0-9_]*|file:\/\/.+)$/.test(value.trim());
-}
-/**
- * Validate the five opt-in reranker keys when present (openspec change
- * retrieval-threshold-and-reranker). Messages name the setting and its
- * accepted values only; the value is never quoted back.
- */
-function checkedRerankerSettings(fileConfig) {
-    const invalid = (setting, accepted) => new Error(`Invalid ${setting} config (accepted: ${accepted})`);
-    if (fileConfig.rerankerEnabled !== undefined && typeof fileConfig.rerankerEnabled !== "boolean") {
-        throw invalid("rerankerEnabled", "boolean");
-    }
-    for (const key of ["rerankerApiUrl", "rerankerModel"]) {
-        const value = fileConfig[key];
-        if (value === undefined)
-            continue;
-        if (typeof value !== "string" || value.trim().length === 0) {
-            throw invalid(key, "a non-empty string");
-        }
-    }
-    if (fileConfig.rerankerApiUrl !== undefined &&
-        !/^https?:\/\/\S+$/.test(fileConfig.rerankerApiUrl.trim())) {
-        throw invalid("rerankerApiUrl", "an http:// or https:// URL");
-    }
-    if (fileConfig.rerankerApiKey !== undefined) {
-        if (typeof fileConfig.rerankerApiKey !== "string" ||
-            !isRerankerKeyReference(fileConfig.rerankerApiKey)) {
-            throw invalid("rerankerApiKey", "an env:// or file:// secret reference");
-        }
-    }
-    if (fileConfig.rerankerTimeoutMs !== undefined) {
-        const value = fileConfig.rerankerTimeoutMs;
-        const ok = typeof value === "number" &&
-            Number.isSafeInteger(value) &&
-            value >= RERANKER_TIMEOUT_MIN_MS &&
-            value <= RERANKER_TIMEOUT_MAX_MS;
-        if (!ok) {
-            throw invalid("rerankerTimeoutMs", `integers from ${RERANKER_TIMEOUT_MIN_MS} to ${RERANKER_TIMEOUT_MAX_MS}`);
-        }
-    }
-}
 export function normalizeAutoCleanupRetentionDays(value) {
     if (!Number.isSafeInteger(value) || value <= 0) {
         throw new Error(`Invalid autoCleanupRetentionDays config: ${value}`);
@@ -364,6 +323,8 @@ function buildConfig(fileConfig) {
         rerankerModel: fileConfig.rerankerModel?.trim() || undefined,
         rerankerApiKey: fileConfig.rerankerApiKey,
         rerankerTimeoutMs: fileConfig.rerankerTimeoutMs ?? DEFAULTS.rerankerTimeoutMs,
+        keywordBoost: checkedKeywordBoost(fileConfig.keywordBoost),
+        keywordMode: checkedKeywordMode(fileConfig.keywordMode),
         maxMemories,
         retrievalMaxTokens,
         maxProfileItems: fileConfig.maxProfileItems ?? DEFAULTS.maxProfileItems,

package/dist/core/retrieval.js

@@ -26,7 +26,7 @@ export async function buildRetrievalSection(prompt, directory, sessionId, budget
         : search.results;
     if (results.length === 0)
         return null;
-    const memoryContext = await formatContextForPrompt(tags.user.userEmail || null, { results }, budget);
+    const memoryContext = await formatContextForPrompt(tags.user.userEmail || null, { results }, budget, search.queryVector);
     return memoryContext || null;
 }
 /**

package/dist/services/chat/chat-answer.d.ts

@@ -0,0 +1,56 @@
+import type { RetrievedSources } from "./chat-retrieve.js";
+import type { ChatRole, ChatSource } from "./chat-types.js";
+/** Each source is cut to this many characters in the prompt. Stored snapshots keep it whole. */
+export declare const MAX_SOURCE_CHARS = 2000;
+export declare const ANSWER_TOOL: {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "answer";
+        readonly description: "Answer the question from the numbered sources";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly answer: {
+                    readonly type: "string";
+                    readonly description: "The answer, with a marker such as [S1] or [P2] after each claim";
+                };
+                readonly citations: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly insufficient: {
+                    readonly type: "boolean";
+                    readonly description: "True when the sources do not answer the question";
+                };
+            };
+            readonly required: readonly ["answer", "citations", "insufficient"];
+        };
+    };
+};
+export declare function numberSources(found: RetrievedSources): ChatSource[];
+export declare function buildAnswerPrompt(question: string, turns: Array<{
+    role: ChatRole;
+    content: string;
+}>, sources: ChatSource[]): {
+    system: string;
+    user: string;
+};
+/**
+ * Removes `[S9]`-style markers that name a source that was not sent, and lists
+ * the valid ones in order of first use. Other bracketed text is left alone.
+ */
+export declare function validateCitations(answer: string, sentLabels: string[]): {
+    text: string;
+    cited: string[];
+};
+export interface FinalAnswer {
+    text: string;
+    cited: string[];
+    insufficient: boolean;
+    /** True when a full answer cites no valid source; the page shows a note. */
+    uncited: boolean;
+}
+/** The checked answer, or null when the reply holds no answer text. */
+export declare function finaliseAnswer(raw: unknown, sources: ChatSource[]): FinalAnswer | null;

package/dist/services/chat/chat-answer.js

@@ -0,0 +1,88 @@
+import { MAX_PLAN_TURNS, MAX_TURN_CHARS } from "./chat-plan.js";
+/** Each source is cut to this many characters in the prompt. Stored snapshots keep it whole. */
+export const MAX_SOURCE_CHARS = 2000;
+export const ANSWER_TOOL = {
+    type: "function",
+    function: {
+        name: "answer",
+        description: "Answer the question from the numbered sources",
+        parameters: {
+            type: "object",
+            properties: {
+                answer: {
+                    type: "string",
+                    description: "The answer, with a marker such as [S1] or [P2] after each claim",
+                },
+                citations: { type: "array", items: { type: "string" } },
+                insufficient: {
+                    type: "boolean",
+                    description: "True when the sources do not answer the question",
+                },
+            },
+            required: ["answer", "citations", "insufficient"],
+        },
+    },
+};
+const SYSTEM = [
+    "You answer questions about one user's saved memories of past coding sessions and their profile.",
+    "Use only the numbered sources given. Do not use outside knowledge.",
+    "Put the source marker, such as [S1] or [P2], after each claim it supports.",
+    "When the sources do not answer the question, say so briefly and set insufficient to true.",
+    "Write plain, short British English. Call the answer tool.",
+].join(" ");
+export function numberSources(found) {
+    return [
+        ...found.memories.map((source, i) => ({ ...source, label: `S${i + 1}` })),
+        ...found.profile.map((source, i) => ({ ...source, label: `P${i + 1}` })),
+    ];
+}
+function describeSource(source) {
+    const meta = source.kind === "memory"
+        ? [source.projectName, source.tags?.length ? `tags: ${source.tags.join(", ")}` : ""]
+        : [source.section, source.category];
+    const header = meta.filter(Boolean).join("; ");
+    return `[${source.label}] ${source.text.slice(0, MAX_SOURCE_CHARS)}${header ? `\n(${header})` : ""}`;
+}
+export function buildAnswerPrompt(question, turns, sources) {
+    const history = turns
+        .slice(-MAX_PLAN_TURNS)
+        .map((turn) => `${turn.role}: ${turn.content.slice(0, MAX_TURN_CHARS)}`);
+    const user = [
+        history.length ? `Earlier turns:\n${history.join("\n")}` : "",
+        `Sources:\n${sources.map(describeSource).join("\n\n")}`,
+        `Question: ${question}`,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+    return { system: SYSTEM, user };
+}
+const MARKER = /\s*\[([SP]\d+)\]/g;
+/**
+ * Removes `[S9]`-style markers that name a source that was not sent, and lists
+ * the valid ones in order of first use. Other bracketed text is left alone.
+ */
+export function validateCitations(answer, sentLabels) {
+    const sent = new Set(sentLabels);
+    const cited = [];
+    const text = answer
+        .replace(MARKER, (match, label) => {
+        if (!sent.has(label))
+            return "";
+        if (!cited.includes(label))
+            cited.push(label);
+        return match;
+    })
+        .trim();
+    return { text, cited };
+}
+/** The checked answer, or null when the reply holds no answer text. */
+export function finaliseAnswer(raw, sources) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const reply = raw;
+    if (typeof reply.answer !== "string" || !reply.answer.trim())
+        return null;
+    const insufficient = reply.insufficient === true;
+    const { text, cited } = validateCitations(reply.answer, sources.map((source) => source.label));
+    return { text, cited, insufficient, uncited: !insufficient && cited.length === 0 };
+}

package/dist/services/chat/chat-plan.d.ts

@@ -0,0 +1,60 @@
+import type { ChatPlanRecord, ChatRole } from "./chat-types.js";
+export declare const MAX_PLAN_TAGS = 200;
+export declare const MAX_PLAN_TURNS = 6;
+export declare const MAX_TURN_CHARS = 500;
+export declare const MAX_PLAN_QUERIES = 3;
+export interface PlanInput {
+    question: string;
+    turns: Array<{
+        role: ChatRole;
+        content: string;
+    }>;
+    tags: Array<{
+        keyword: string;
+        count: number;
+    }>;
+    categories: string[];
+}
+export declare const PLAN_TOOL: {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "plan_search";
+        readonly description: "Choose how to search the user's stored memories and profile";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly queries: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "1 to 3 short search phrases";
+                };
+                readonly tags: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Tags from the given list that match the question";
+                };
+                readonly profileCategories: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Profile categories from the given list that match the question";
+                };
+            };
+            readonly required: readonly ["queries", "tags", "profileCategories"];
+        };
+    };
+};
+export declare function buildPlanPrompt(input: PlanInput): {
+    system: string;
+    user: string;
+};
+/**
+ * The model's plan with unknown tags and categories removed. A missing or
+ * broken plan searches with the question alone and is marked skipped.
+ */
+export declare function validatePlan(raw: unknown, input: PlanInput): ChatPlanRecord;

package/dist/services/chat/chat-plan.js

@@ -0,0 +1,92 @@
+export const MAX_PLAN_TAGS = 200;
+export const MAX_PLAN_TURNS = 6;
+export const MAX_TURN_CHARS = 500;
+export const MAX_PLAN_QUERIES = 3;
+export const PLAN_TOOL = {
+    type: "function",
+    function: {
+        name: "plan_search",
+        description: "Choose how to search the user's stored memories and profile",
+        parameters: {
+            type: "object",
+            properties: {
+                queries: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "1 to 3 short search phrases",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Tags from the given list that match the question",
+                },
+                profileCategories: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Profile categories from the given list that match the question",
+                },
+            },
+            required: ["queries", "tags", "profileCategories"],
+        },
+    },
+};
+const SYSTEM = [
+    "You plan a search over one user's saved memories of past coding sessions and their profile.",
+    "Return 1 to 3 short search phrases that would find memories answering the question.",
+    "Resolve follow-up questions with the earlier turns, so each phrase stands alone.",
+    "Pick tags and profile categories only from the lists given. Pick none when none fit.",
+    "Call plan_search. Do not answer the question.",
+].join(" ");
+function topTags(tags) {
+    return [...tags].sort((a, b) => b.count - a.count).slice(0, MAX_PLAN_TAGS);
+}
+export function buildPlanPrompt(input) {
+    const turns = input.turns
+        .slice(-MAX_PLAN_TURNS)
+        .map((turn) => `${turn.role}: ${turn.content.slice(0, MAX_TURN_CHARS)}`);
+    const tags = topTags(input.tags).map((tag) => `${tag.keyword} (${tag.count})`);
+    const categories = [...new Set(input.categories)];
+    const user = [
+        turns.length ? `Earlier turns:\n${turns.join("\n")}` : "Earlier turns: none",
+        `Tags (count): ${tags.length ? tags.join(", ") : "none"}`,
+        `Profile categories: ${categories.length ? categories.join(", ") : "none"}`,
+        `Question: ${input.question}`,
+    ].join("\n\n");
+    return { system: SYSTEM, user };
+}
+function strings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+/** Keep the picks that exist in `allowed`, ignoring case, in the stored spelling. */
+function known(picks, allowed) {
+    const byKey = new Map(allowed.map((value) => [value.toLowerCase(), value]));
+    const out = [];
+    for (const pick of picks) {
+        const match = byKey.get(pick.toLowerCase());
+        if (match && !out.includes(match))
+            out.push(match);
+    }
+    return out;
+}
+/**
+ * The model's plan with unknown tags and categories removed. A missing or
+ * broken plan searches with the question alone and is marked skipped.
+ */
+export function validatePlan(raw, input) {
+    const plan = raw && typeof raw === "object" ? raw : {};
+    const queries = strings(plan.queries).slice(0, MAX_PLAN_QUERIES);
+    if (queries.length === 0) {
+        return { queries: [input.question], tags: [], profileCategories: [], skipped: true };
+    }
+    return {
+        queries,
+        tags: known(strings(plan.tags), topTags(input.tags).map((tag) => tag.keyword)),
+        profileCategories: known(strings(plan.profileCategories), input.categories),
+        skipped: false,
+    };
+}

package/dist/services/chat/chat-retrieve.d.ts

@@ -0,0 +1,36 @@
+import type { ChatPlanRecord, ChatSource } from "./chat-types.js";
+export declare const MAX_MEMORY_SOURCES = 12;
+export declare const MAX_PROFILE_SOURCES = 6;
+/** A profile item outside the chosen categories joins only when it is at least this close. */
+export declare const PROFILE_MIN_SIMILARITY = 0.35;
+/** One search result, as `memoryClient.searchMemories` returns it. */
+export interface MemoryHit {
+    id: string;
+    memory: string;
+    similarity: number;
+    tags?: string[];
+    createdAt?: number;
+    projectName?: string;
+    containerTag?: string;
+}
+export interface ProfileCandidate {
+    section: "preferences" | "patterns" | "workflows";
+    index: number;
+    category?: string;
+    description: string;
+    evidence?: string[] | string;
+    centroid?: number[];
+}
+export interface RetrieveDeps {
+    /** `scopeTag` null searches every project. */
+    searchMemories: (query: string, scopeTag: string | null) => Promise<MemoryHit[]>;
+    embed: (text: string) => Promise<ArrayLike<number>>;
+    profileItems: () => Promise<ProfileCandidate[]>;
+}
+/** Sources still need labels; `numberSources` in chat-answer.ts gives them. */
+export interface RetrievedSources {
+    memories: ChatSource[];
+    profile: ChatSource[];
+}
+/** Memory and profile sources for one question, searched in parallel. */
+export declare function retrieveSources(question: string, plan: ChatPlanRecord, scopeTag: string | null, deps: RetrieveDeps): Promise<RetrievedSources>;

package/dist/services/chat/chat-retrieve.js

@@ -0,0 +1,82 @@
+export const MAX_MEMORY_SOURCES = 12;
+export const MAX_PROFILE_SOURCES = 6;
+/** A profile item outside the chosen categories joins only when it is at least this close. */
+export const PROFILE_MIN_SIMILARITY = 0.35;
+function cosine(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    return na && nb ? dot / Math.sqrt(na * nb) : 0;
+}
+async function memorySources(plan, scopeTag, deps) {
+    const queries = [...plan.queries];
+    if (plan.tags.length)
+        queries.push(plan.tags.join(" "));
+    const batches = await Promise.all(queries.map((query) => deps.searchMemories(query, scopeTag)));
+    const best = new Map();
+    for (const hit of batches.flat()) {
+        const seen = best.get(hit.id);
+        if (!seen || hit.similarity > seen.similarity)
+            best.set(hit.id, hit);
+    }
+    return [...best.values()]
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, MAX_MEMORY_SOURCES)
+        .map((hit) => ({
+        label: "",
+        kind: "memory",
+        id: hit.id,
+        text: hit.memory,
+        projectName: hit.projectName,
+        projectTag: hit.containerTag,
+        createdAt: hit.createdAt,
+        tags: hit.tags,
+        score: hit.similarity,
+    }));
+}
+async function profileSources(question, plan, deps) {
+    const items = await deps.profileItems();
+    if (items.length === 0)
+        return [];
+    const chosen = new Set(plan.profileCategories.map((c) => c.toLowerCase()));
+    const vector = items.some((item) => item.centroid) ? await deps.embed(question) : null;
+    return items
+        .map((item) => {
+        const closeness = vector && item.centroid ? cosine(vector, item.centroid) : 0;
+        const inCategory = !!item.category && chosen.has(item.category.toLowerCase());
+        // Chosen categories rank above everything found by vector alone.
+        return { item, closeness, inCategory, rank: (inCategory ? 1 : 0) + closeness };
+    })
+        .filter((entry) => entry.inCategory || entry.closeness >= PROFILE_MIN_SIMILARITY)
+        .sort((a, b) => b.rank - a.rank)
+        .slice(0, MAX_PROFILE_SOURCES)
+        .map(({ item, closeness }) => ({
+        label: "",
+        kind: "profile",
+        id: `${item.section}:${item.index}`,
+        text: item.description,
+        section: item.section,
+        category: item.category,
+        evidence: Array.isArray(item.evidence)
+            ? item.evidence
+            : item.evidence
+                ? [item.evidence]
+                : undefined,
+        score: closeness,
+    }));
+}
+/** Memory and profile sources for one question, searched in parallel. */
+export async function retrieveSources(question, plan, scopeTag, deps) {
+    const [memories, profile] = await Promise.all([
+        memorySources(plan, scopeTag, deps),
+        profileSources(question, plan, deps),
+    ]);
+    return { memories, profile };
+}

package/dist/services/chat/chat-routes.d.ts

@@ -0,0 +1,12 @@
+import { type ChatRuntimeConfig } from "./chat-runtime.js";
+export interface RouteResult {
+    status: number;
+    body: unknown;
+}
+type Body = Record<string, unknown>;
+/**
+ * The chat routes under `/api/chat/`. Returns undefined for any other path.
+ * Store errors map to 400, 404 or 409; anything else is logged by code only.
+ */
+export declare function routeChat(path: string, method: string, readBody: () => Promise<Body>, config: ChatRuntimeConfig): Promise<RouteResult | undefined>;
+export {};