om-memory-system 4.23.0-next.144 → 4.25.0

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

@@ -0,0 +1,16 @@
+export interface ChatSettings {
+    memoryProvider?: string;
+    memoryModel?: string;
+    memoryApiUrl?: string;
+    memoryApiKey?: string;
+}
+export interface ChatStatus {
+    ready: boolean;
+    /** Names of the settings still needed. Never their values. */
+    missing: string[];
+    provider: string;
+    /** The host that receives questions and memory text, so the page can name it. */
+    apiHost: string | null;
+}
+/** Whether chat can call the external memory model. Mirrors `buildMemoryProviderConfig`. */
+export declare function chatStatus(config: ChatSettings): ChatStatus;

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

@@ -0,0 +1,23 @@
+import { isPlaceholderApiKey } from "../ai/api-key-placeholder.js";
+/** Whether chat can call the external memory model. Mirrors `buildMemoryProviderConfig`. */
+export function chatStatus(config) {
+    const provider = config.memoryProvider ?? "openai-chat";
+    const presetEndpoint = provider === "orcarouter";
+    const missing = [];
+    if (!config.memoryModel && !presetEndpoint)
+        missing.push("memoryModel");
+    if (!config.memoryApiUrl && !presetEndpoint)
+        missing.push("memoryApiUrl");
+    if (!config.memoryApiKey || isPlaceholderApiKey(config.memoryApiKey)) {
+        missing.push("memoryApiKey");
+    }
+    return { ready: missing.length === 0, missing, provider, apiHost: hostOf(config.memoryApiUrl) };
+}
+function hostOf(url) {
+    try {
+        return url ? new URL(url).host : null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,60 @@
+import type { TursoDb } from "../turso/turso-db.js";
+import { type ChatConversation, type ChatFolder, type ChatMessage, type ChatNotice, type ChatPlanRecord, type ChatRole, type ChatSource } from "./chat-types.js";
+/** Bump when the tables change, and add the step to `migrate`. */
+export declare const CHAT_SCHEMA_VERSION = 1;
+export declare const FOLDER_NAME_MAX = 80;
+export declare const BULK_DELETE_MAX = 500;
+type GetConnection = (dbPath: string) => Promise<TursoDb>;
+/**
+ * Conversations, messages, and folders in `chats.db`. One instance per file;
+ * every write checks the schema version so a file from a newer OMMS stays
+ * untouched.
+ */
+export declare class ChatStore {
+    private readonly dbPath;
+    private readonly connect;
+    private readOnly;
+    private lastStamp;
+    constructor(dbPath: string, connect?: GetConnection);
+    private db;
+    private now;
+    init(): Promise<void>;
+    isReadOnly(): boolean;
+    private writable;
+    listConversations(): Promise<ChatConversation[]>;
+    getConversation(id: string): Promise<{
+        conversation: ChatConversation;
+        messages: ChatMessage[];
+    } | null>;
+    createConversation(input: {
+        title: string;
+        scopeTag: string | null;
+        folderId?: string | null;
+    }): Promise<ChatConversation>;
+    private updateConversation;
+    renameConversation(id: string, title: string): Promise<void>;
+    setConversationScope(id: string, scopeTag: string | null): Promise<void>;
+    moveConversation(id: string, folderId: string | null): Promise<void>;
+    deleteConversation(id: string): Promise<void>;
+    /** Deletes every id or none: an unknown id fails the whole request. */
+    bulkDeleteConversations(ids: string[]): Promise<number>;
+    appendMessage(conversationId: string, input: {
+        role: ChatRole;
+        content: string;
+        sources?: ChatSource[];
+        plan?: ChatPlanRecord | null;
+        model?: string | null;
+        errorCode?: string | null;
+        notice?: ChatNotice | null;
+    }): Promise<ChatMessage>;
+    deleteMessage(id: string): Promise<void>;
+    countMessages(): Promise<number>;
+    listFolders(): Promise<ChatFolder[]>;
+    private requireFolder;
+    private assertNameFree;
+    createFolder(name: string): Promise<ChatFolder>;
+    renameFolder(id: string, name: string): Promise<void>;
+    /** Deletes the folder and every conversation in it. Returns how many conversations went. */
+    deleteFolder(id: string): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,352 @@
+import { randomUUID } from "node:crypto";
+import { tursoConnectionManager } from "../turso/connection-manager.js";
+import { ChatStoreError, } from "./chat-types.js";
+/** Bump when the tables change, and add the step to `migrate`. */
+export const CHAT_SCHEMA_VERSION = 1;
+export const FOLDER_NAME_MAX = 80;
+export const BULK_DELETE_MAX = 500;
+// The file is copied between computers by hand (ADR-032), so it keeps the
+// default rollback journal: committed data lives in chats.db alone.
+const SCHEMA = [
+    `CREATE TABLE IF NOT EXISTS chat_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
+    `CREATE TABLE IF NOT EXISTS chat_folders (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    name_key TEXT NOT NULL UNIQUE,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS chat_conversations (
+    id TEXT PRIMARY KEY,
+    folder_id TEXT REFERENCES chat_folders(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    scope_tag TEXT,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS chat_messages (
+    id TEXT PRIMARY KEY,
+    conversation_id TEXT NOT NULL REFERENCES chat_conversations(id) ON DELETE CASCADE,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    sources_json TEXT,
+    plan_json TEXT,
+    model TEXT,
+    error_code TEXT,
+    notice TEXT,
+    created_at INTEGER NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS chat_messages_conversation ON chat_messages(conversation_id, created_at)`,
+    `CREATE INDEX IF NOT EXISTS chat_conversations_folder ON chat_conversations(folder_id)`,
+];
+// Only these fields are written, so a source never carries a folder path or an email.
+const SOURCE_FIELDS = [
+    "label",
+    "kind",
+    "id",
+    "text",
+    "projectName",
+    "projectTag",
+    "createdAt",
+    "tags",
+    "score",
+    "section",
+    "category",
+    "evidence",
+];
+function snapshot(source) {
+    const out = {};
+    for (const field of SOURCE_FIELDS) {
+        if (source[field] !== undefined)
+            out[field] = source[field];
+    }
+    return out;
+}
+function parseJson(value, fallback) {
+    if (typeof value !== "string" || !value)
+        return fallback;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+function toConversation(row) {
+    return {
+        id: String(row.id),
+        folderId: row.folder_id == null ? null : String(row.folder_id),
+        title: String(row.title),
+        scopeTag: row.scope_tag == null ? null : String(row.scope_tag),
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+    };
+}
+function toMessage(row) {
+    return {
+        id: String(row.id),
+        conversationId: String(row.conversation_id),
+        role: String(row.role),
+        content: String(row.content),
+        sources: parseJson(row.sources_json, []),
+        plan: parseJson(row.plan_json, null),
+        model: row.model == null ? null : String(row.model),
+        errorCode: row.error_code == null ? null : String(row.error_code),
+        notice: row.notice == null ? null : String(row.notice),
+        createdAt: Number(row.created_at),
+    };
+}
+function folderName(name) {
+    const trimmed = name.trim();
+    if (!trimmed || trimmed.length > FOLDER_NAME_MAX) {
+        throw new ChatStoreError(`Folder names have 1 to ${FOLDER_NAME_MAX} characters`, "invalid");
+    }
+    return { name: trimmed, key: trimmed.toLowerCase() };
+}
+/**
+ * Conversations, messages, and folders in `chats.db`. One instance per file;
+ * every write checks the schema version so a file from a newer OMMS stays
+ * untouched.
+ */
+export class ChatStore {
+    dbPath;
+    connect;
+    readOnly = false;
+    // Strictly increasing timestamps keep "newest first" stable within one millisecond.
+    lastStamp = 0;
+    constructor(dbPath, connect = (path) => tursoConnectionManager.getConnection(path)) {
+        this.dbPath = dbPath;
+        this.connect = connect;
+    }
+    db() {
+        return this.connect(this.dbPath);
+    }
+    now() {
+        this.lastStamp = Math.max(Date.now(), this.lastStamp + 1);
+        return this.lastStamp;
+    }
+    async init() {
+        const db = await this.db();
+        await db.execute(SCHEMA[0]);
+        const row = await db.get("SELECT value FROM chat_meta WHERE key = 'schema_version'");
+        const version = row ? Number(row.value) : 0;
+        if (version > CHAT_SCHEMA_VERSION) {
+            this.readOnly = true;
+            return;
+        }
+        this.readOnly = false;
+        await db.batch(SCHEMA.slice(1).map((sql) => ({ sql })));
+        if (version < CHAT_SCHEMA_VERSION) {
+            await db.run("INSERT INTO chat_meta (key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", [String(CHAT_SCHEMA_VERSION)]);
+        }
+    }
+    isReadOnly() {
+        return this.readOnly;
+    }
+    writable() {
+        if (this.readOnly) {
+            throw new ChatStoreError("chats.db is from a newer OMMS and is read-only", "read_only");
+        }
+    }
+    async listConversations() {
+        const db = await this.db();
+        const rows = await db.all("SELECT * FROM chat_conversations ORDER BY updated_at DESC, created_at DESC");
+        return rows.map(toConversation);
+    }
+    async getConversation(id) {
+        const db = await this.db();
+        const row = await db.get("SELECT * FROM chat_conversations WHERE id = ?", [id]);
+        if (!row)
+            return null;
+        const messages = await db.all("SELECT * FROM chat_messages WHERE conversation_id = ? ORDER BY created_at, rowid", [id]);
+        return { conversation: toConversation(row), messages: messages.map(toMessage) };
+    }
+    async createConversation(input) {
+        this.writable();
+        const db = await this.db();
+        if (input.folderId)
+            await this.requireFolder(input.folderId);
+        const stamp = this.now();
+        const conversation = {
+            id: randomUUID(),
+            folderId: input.folderId ?? null,
+            title: input.title.trim() || "New chat",
+            scopeTag: input.scopeTag,
+            createdAt: stamp,
+            updatedAt: stamp,
+        };
+        await db.run("INSERT INTO chat_conversations (id, folder_id, title, scope_tag, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)", [
+            conversation.id,
+            conversation.folderId,
+            conversation.title,
+            conversation.scopeTag,
+            stamp,
+            stamp,
+        ]);
+        return conversation;
+    }
+    async updateConversation(id, set, args) {
+        this.writable();
+        const db = await this.db();
+        const changed = await db.run(`UPDATE chat_conversations SET ${set}, updated_at = ? WHERE id = ?`, [...args, this.now(), id]);
+        if (changed === 0)
+            throw new ChatStoreError("Conversation not found", "not_found");
+    }
+    async renameConversation(id, title) {
+        const trimmed = title.trim();
+        if (!trimmed)
+            throw new ChatStoreError("A title is required", "invalid");
+        await this.updateConversation(id, "title = ?", [trimmed.slice(0, 200)]);
+    }
+    async setConversationScope(id, scopeTag) {
+        await this.updateConversation(id, "scope_tag = ?", [scopeTag]);
+    }
+    async moveConversation(id, folderId) {
+        if (folderId)
+            await this.requireFolder(folderId);
+        await this.updateConversation(id, "folder_id = ?", [folderId]);
+    }
+    async deleteConversation(id) {
+        this.writable();
+        const db = await this.db();
+        const changed = await db.run("DELETE FROM chat_conversations WHERE id = ?", [id]);
+        if (changed === 0)
+            throw new ChatStoreError("Conversation not found", "not_found");
+    }
+    /** Deletes every id or none: an unknown id fails the whole request. */
+    async bulkDeleteConversations(ids) {
+        this.writable();
+        const unique = [...new Set(ids)];
+        if (unique.length === 0 || unique.length > BULK_DELETE_MAX) {
+            throw new ChatStoreError(`Select 1 to ${BULK_DELETE_MAX} conversations`, "invalid");
+        }
+        const db = await this.db();
+        const marks = unique.map(() => "?").join(",");
+        return db.transaction("write", async (tx) => {
+            const found = await tx.execute({
+                sql: `SELECT COUNT(*) AS n FROM chat_conversations WHERE id IN (${marks})`,
+                args: unique,
+            });
+            if (Number(found.rows[0]?.n) !== unique.length) {
+                throw new ChatStoreError("Conversation not found", "not_found");
+            }
+            const result = await tx.execute({
+                sql: `DELETE FROM chat_conversations WHERE id IN (${marks})`,
+                args: unique,
+            });
+            return Number(result.rowsAffected);
+        });
+    }
+    async appendMessage(conversationId, input) {
+        this.writable();
+        const db = await this.db();
+        const stamp = this.now();
+        const sources = (input.sources ?? []).map(snapshot);
+        const message = {
+            id: randomUUID(),
+            conversationId,
+            role: input.role,
+            content: input.content,
+            sources,
+            plan: input.plan ?? null,
+            model: input.model ?? null,
+            errorCode: input.errorCode ?? null,
+            notice: input.notice ?? null,
+            createdAt: stamp,
+        };
+        await db.batch([
+            {
+                sql: "INSERT INTO chat_messages (id, conversation_id, role, content, sources_json, plan_json, model, error_code, notice, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                args: [
+                    message.id,
+                    conversationId,
+                    message.role,
+                    message.content,
+                    sources.length ? JSON.stringify(sources) : null,
+                    message.plan ? JSON.stringify(message.plan) : null,
+                    message.model,
+                    message.errorCode,
+                    message.notice,
+                    stamp,
+                ],
+            },
+            {
+                sql: "UPDATE chat_conversations SET updated_at = ? WHERE id = ?",
+                args: [stamp, conversationId],
+            },
+        ]);
+        return message;
+    }
+    async deleteMessage(id) {
+        this.writable();
+        const db = await this.db();
+        await db.run("DELETE FROM chat_messages WHERE id = ?", [id]);
+    }
+    async countMessages() {
+        const db = await this.db();
+        const row = await db.get("SELECT COUNT(*) AS n FROM chat_messages");
+        return Number(row?.n ?? 0);
+    }
+    async listFolders() {
+        const db = await this.db();
+        const rows = await db.all(`SELECT f.*, (SELECT COUNT(*) FROM chat_conversations c WHERE c.folder_id = f.id) AS n
+       FROM chat_folders f ORDER BY f.name_key`);
+        return rows.map((row) => ({
+            id: String(row.id),
+            name: String(row.name),
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+            conversationCount: Number(row.n),
+        }));
+    }
+    async requireFolder(id) {
+        const db = await this.db();
+        if (!(await db.get("SELECT id FROM chat_folders WHERE id = ?", [id]))) {
+            throw new ChatStoreError("Folder not found", "not_found");
+        }
+    }
+    async assertNameFree(key, exceptId) {
+        const db = await this.db();
+        const clash = await db.get("SELECT id FROM chat_folders WHERE name_key = ? AND id != ?", [
+            key,
+            exceptId ?? "",
+        ]);
+        if (clash)
+            throw new ChatStoreError("A folder with this name exists", "conflict");
+    }
+    async createFolder(name) {
+        this.writable();
+        const clean = folderName(name);
+        await this.assertNameFree(clean.key);
+        const db = await this.db();
+        const stamp = this.now();
+        const id = randomUUID();
+        await db.run("INSERT INTO chat_folders (id, name, name_key, created_at, updated_at) VALUES (?, ?, ?, ?, ?)", [id, clean.name, clean.key, stamp, stamp]);
+        return { id, name: clean.name, createdAt: stamp, updatedAt: stamp, conversationCount: 0 };
+    }
+    async renameFolder(id, name) {
+        this.writable();
+        const clean = folderName(name);
+        await this.assertNameFree(clean.key, id);
+        const db = await this.db();
+        const changed = await db.run("UPDATE chat_folders SET name = ?, name_key = ?, updated_at = ? WHERE id = ?", [clean.name, clean.key, this.now(), id]);
+        if (changed === 0)
+            throw new ChatStoreError("Folder not found", "not_found");
+    }
+    /** Deletes the folder and every conversation in it. Returns how many conversations went. */
+    async deleteFolder(id) {
+        this.writable();
+        const db = await this.db();
+        return db.transaction("write", async (tx) => {
+            const count = await tx.execute({
+                sql: "SELECT COUNT(*) AS n FROM chat_conversations WHERE folder_id = ?",
+                args: [id],
+            });
+            const result = await tx.execute({ sql: "DELETE FROM chat_folders WHERE id = ?", args: [id] });
+            if (Number(result.rowsAffected) === 0) {
+                throw new ChatStoreError("Folder not found", "not_found");
+            }
+            return Number(count.rows[0]?.n ?? 0);
+        });
+    }
+}

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

@@ -0,0 +1,59 @@
+/** Shared shapes for the web chat: stored conversations, sources, and the search plan. */
+export type ChatRole = "user" | "assistant";
+/** A source as it was sent to the model, saved with the answer so it still opens later. */
+export interface ChatSource {
+    /** `S1`, `S2`, … for memories; `P1`, `P2`, … for profile items. */
+    label: string;
+    kind: "memory" | "profile";
+    id: string;
+    text: string;
+    projectName?: string;
+    projectTag?: string;
+    createdAt?: number;
+    tags?: string[];
+    score?: number;
+    /** Profile sources only. */
+    section?: "preferences" | "patterns" | "workflows";
+    category?: string;
+    evidence?: string[];
+}
+export interface ChatPlanRecord {
+    queries: string[];
+    tags: string[];
+    profileCategories: string[];
+    /** True when the plan call failed or returned nothing usable. */
+    skipped: boolean;
+}
+/** Shown with an assistant message that is not a normal cited answer. */
+export type ChatNotice = "no_sources" | "insufficient" | "uncited";
+export interface ChatMessage {
+    id: string;
+    conversationId: string;
+    role: ChatRole;
+    content: string;
+    sources: ChatSource[];
+    plan: ChatPlanRecord | null;
+    model: string | null;
+    errorCode: string | null;
+    notice: ChatNotice | null;
+    createdAt: number;
+}
+export interface ChatConversation {
+    id: string;
+    folderId: string | null;
+    title: string;
+    scopeTag: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface ChatFolder {
+    id: string;
+    name: string;
+    createdAt: number;
+    updatedAt: number;
+    conversationCount: number;
+}
+export declare class ChatStoreError extends Error {
+    readonly code: "not_found" | "conflict" | "invalid" | "read_only";
+    constructor(message: string, code: "not_found" | "conflict" | "invalid" | "read_only");
+}

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

@@ -0,0 +1,8 @@
+/** Shared shapes for the web chat: stored conversations, sources, and the search plan. */
+export class ChatStoreError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}

package/dist/services/client.d.ts

@@ -22,6 +22,7 @@ export declare class LocalMemoryClient {
         results: import("./turso/types.js").SearchResult[];
         total: number;
         timing: number;
+        queryVector: Float32Array<ArrayBufferLike>;
         error?: undefined;
     } | {
         success: false;

package/dist/services/client.js

@@ -5,6 +5,8 @@ import { tursoConnectionManager } from "./turso/connection-manager.js";
 import { ensureTursoReady } from "./turso/ready.js";
 import { formatTagsForEmbedding } from "./turso/vector-utils.js";
 import { extractScopeFromContainerTag, resolveMemoryScope, } from "./memory-scope.js";
+import { rerankSettingsFrom } from "./reranker.js";
+import { rerankedSearch } from "./retrieval-rerank.js";
 import { CONFIG } from "../config.js";
 import { log } from "./logger.js";
 function safeToISOString(timestamp) {
@@ -86,24 +88,55 @@ export class LocalMemoryClient {
         this.reset();
     }
     async searchMemories(query, containerTag, scope = "project") {
-        // Capture the result count at entry: initialize, embedding, and shard
-        // reads all await, and a config edit during them must not change this
-        // search's limit.
+        // Capture the result count and the reranker settings at entry: initialize,
+        // embedding, and shard reads all await, and a config edit during them must
+        // not change this search's limit or reranker target.
         const maxMemories = CONFIG.maxMemories;
+        const keywordBoost = CONFIG.keywordBoost;
+        const reranker = rerankSettingsFrom(CONFIG);
+        // The reranker path below always uses the boost: it needs a full pool on the similarity scale.
+        const keywordMode = CONFIG.keywordMode;
+        if (CONFIG.rerankerEnabled && !reranker) {
+            // On but incomplete: search must keep working, so treat it as off.
+            log("Reranker enabled without a URL or model; searching without it", {
+                code: "reranker_not_configured",
+            });
+        }
         try {
             await this.initialize();
             const queryVector = await embeddingService.embedWithTimeout(query, { task: "query" });
             const resolved = resolveScopeValue(scope, containerTag);
             const shards = (await Promise.all(resolved.map((ref) => tursoShardManager.getAllShards(ref.scope, ref.hash)))).flat();
             if (shards.length === 0) {
-                return { success: true, results: [], total: 0, timing: 0 };
+                return { success: true, results: [], total: 0, timing: 0, queryVector };
+            }
+            let results;
+            let warnings;
+            if (reranker) {
+                // One shard read with no threshold feeds both the reranker and the
+                // fallback path (retrieval-rerank.ts, design decision 7).
+                ({ results, warnings } = await rerankedSearch({
+                    shards,
+                    queryVector,
+                    containerTag: scope === "all-projects" ? "" : containerTag,
+                    queryText: query,
+                    maxMemories,
+                    similarityThreshold: CONFIG.similarityThreshold,
+                }, reranker, {
+                    search: (shardList, vector, tag, limit, threshold, queryText) => tursoVectorSearch.searchAcrossShards(shardList, vector, tag, limit, threshold, queryText, keywordBoost),
+                    log: (message, meta) => log(message, meta),
+                }));
+            }
+            else {
+                ({ results, warnings } = await tursoVectorSearch.searchAcrossShards(shards, queryVector, scope === "all-projects" ? "" : containerTag, maxMemories, CONFIG.similarityThreshold, query, keywordBoost, keywordMode));
             }
-            const { results, warnings } = await tursoVectorSearch.searchAcrossShards(shards, queryVector, scope === "all-projects" ? "" : containerTag, maxMemories, CONFIG.similarityThreshold, query);
             return {
                 success: true,
                 results,
                 total: results.length,
                 timing: 0,
+                // The embedded prompt, so callers (the profile step) need not embed it again.
+                queryVector,
                 ...(warnings.length > 0 ? { warnings } : {}),
             };
         }

package/dist/services/context.d.ts

@@ -15,5 +15,7 @@ interface MemoriesResponseMinimal {
  * order, and the first oversized memory is shortened with a visible marker.
  * Hosts emit several sections in one request by passing `maxBytes` residuals.
  */
-export declare function formatContextForPrompt(userId: string | null, projectMemories: MemoriesResponseMinimal, budget?: ContextBudgetOptions): Promise<string>;
+export declare function formatContextForPrompt(userId: string | null, projectMemories: MemoriesResponseMinimal, budget?: ContextBudgetOptions, 
+/** The embedded prompt, when there is one. Lets the profile block follow the prompt. */
+queryVector?: ArrayLike<number>): Promise<string>;
 export {};

package/dist/services/context.js

@@ -13,10 +13,12 @@ const HEADER_TEXT = "The following block is reference context injected from the
  * order, and the first oversized memory is shortened with a visible marker.
  * Hosts emit several sections in one request by passing `maxBytes` residuals.
  */
-export async function formatContextForPrompt(userId, projectMemories, budget) {
+export async function formatContextForPrompt(userId, projectMemories, budget, 
+/** The embedded prompt, when there is one. Lets the profile block follow the prompt. */
+queryVector) {
     const blocks = [];
     if (CONFIG.injectProfile && userId) {
-        const profileContext = await getUserProfileContext(userId);
+        const profileContext = await getUserProfileContext(userId, queryVector);
         if (profileContext) {
             blocks.push({
                 prefix: "<user_profile>\n",