qlogicagent 2.13.4 → 2.13.5

package/dist/skills/memory/memory-consolidation.d.ts

@@ -0,0 +1,43 @@
+import { LocalMemoryStore } from "./local-store.js";
+/** A pre-extracted memory item ready to be stored (no LLM needed). */
+export interface ExtractedMemoryItem {
+    text: string;
+    category?: string;
+    importance?: number;
+    speaker?: string;
+    event_date?: string;
+    tags?: string[];
+    /** Ids of already-uploaded attachments to link to this memory on commit. */
+    attachmentIds?: string[];
+}
+export interface MemoryConsolidationOptions {
+    source?: string;
+    sessionId?: string;
+}
+export interface MemoryConsolidationResult {
+    observationsAdded: number;
+    proposalsAdded: number;
+    claimsAdded: number;
+    conflictsAdded: number;
+    memoriesAdded: number;
+    observationIds: string[];
+    proposalIds: string[];
+    claimIds: string[];
+    conflictIds: string[];
+}
+export declare class MemoryConsolidator {
+    private readonly store;
+    private readonly embed;
+    constructor(store: LocalMemoryStore, embed: (text: string) => Promise<Float32Array | undefined>);
+    observe(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
+    proposeExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
+    commitExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
+    /**
+     * Find an existing active memory that is a near-duplicate of `text`.
+     * Token containment (Latin/digit words + CJK bigrams) against recent
+     * memories; digit-bearing token mismatches veto the match because numbers
+     * and ids are precise facts, not phrasing variance.
+     */
+    private findNearDuplicateMemory;
+}
+export declare function sourcePriorityOf(source: string): number;

package/dist/skills/memory/memory-consolidation.js

@@ -0,0 +1,462 @@
+const EMPTY_RESULT = {
+    observationsAdded: 0,
+    proposalsAdded: 0,
+    claimsAdded: 0,
+    conflictsAdded: 0,
+    memoriesAdded: 0,
+    observationIds: [],
+    proposalIds: [],
+    claimIds: [],
+    conflictIds: [],
+};
+export class MemoryConsolidator {
+    store;
+    embed;
+    constructor(store, embed) {
+        this.store = store;
+        this.embed = embed;
+    }
+    async observe(items, userId, options) {
+        const source = normalizeSource(options?.source);
+        const sourcePriority = sourcePriorityOf(source);
+        const result = cloneEmptyResult();
+        for (const item of items) {
+            const text = item.text?.trim();
+            if (!text)
+                continue;
+            const observationId = this.store.insertObservation({
+                userId,
+                text,
+                source,
+                sourcePriority,
+                sessionId: options?.sessionId ?? "",
+                evidenceType: "text",
+                payload: { category: item.category, importance: item.importance, tags: item.tags ?? [] },
+            });
+            result.observationsAdded++;
+            result.observationIds.push(observationId);
+        }
+        return result;
+    }
+    async proposeExtracted(items, userId, options) {
+        const source = normalizeSource(options?.source);
+        const sourcePriority = sourcePriorityOf(source);
+        const result = cloneEmptyResult();
+        for (const item of items) {
+            const text = item.text?.trim();
+            if (!text)
+                continue;
+            const observationId = this.store.insertObservation({
+                userId,
+                text,
+                source,
+                sourcePriority,
+                sessionId: options?.sessionId ?? "",
+                evidenceType: "text",
+                payload: {
+                    category: item.category,
+                    importance: item.importance,
+                    eventDate: item.event_date,
+                    tags: item.tags ?? [],
+                },
+            });
+            result.observationsAdded++;
+            result.observationIds.push(observationId);
+            const normalized = normalizeClaim(text, item, source);
+            const proposalId = this.store.insertProposal({
+                userId,
+                observationIds: [observationId],
+                text,
+                category: item.category ?? "general",
+                importance: clamp(item.importance ?? 0.5, 0.1, 1),
+                confidence: normalized.confidence,
+                source,
+                sourcePriority,
+                entity: normalized.entity,
+                predicate: normalized.predicate,
+                value: normalized.value,
+                validTime: normalized.validTime,
+                tags: item.tags ?? [],
+                status: "pending",
+            });
+            result.proposalsAdded++;
+            result.proposalIds.push(proposalId);
+        }
+        return result;
+    }
+    async commitExtracted(items, userId, options) {
+        const source = normalizeSource(options?.source);
+        const sourcePriority = sourcePriorityOf(source);
+        const result = cloneEmptyResult();
+        for (const item of items) {
+            const text = item.text?.trim();
+            if (!text)
+                continue;
+            const observationId = this.store.insertObservation({
+                userId,
+                text,
+                source,
+                sourcePriority,
+                sessionId: options?.sessionId ?? "",
+                evidenceType: "text",
+                payload: {
+                    category: item.category,
+                    importance: item.importance,
+                    eventDate: item.event_date,
+                    tags: item.tags ?? [],
+                },
+            });
+            result.observationsAdded++;
+            result.observationIds.push(observationId);
+            const normalized = normalizeClaim(text, item, source);
+            const proposalId = this.store.insertProposal({
+                userId,
+                observationIds: [observationId],
+                text,
+                category: item.category ?? "general",
+                importance: clamp(item.importance ?? 0.5, 0.1, 1),
+                confidence: normalized.confidence,
+                source,
+                sourcePriority,
+                entity: normalized.entity,
+                predicate: normalized.predicate,
+                value: normalized.value,
+                validTime: normalized.validTime,
+                tags: item.tags ?? [],
+                status: "pending",
+            });
+            result.proposalsAdded++;
+            result.proposalIds.push(proposalId);
+            const existing = this.store.findClaimsByFact(userId, normalized.entity, normalized.predicate, normalized.validTime);
+            const same = existing.find((claim) => sameSemanticValue(claim.value, normalized.value));
+            if (same) {
+                this.store.mergeClaimEvidence(same.id, [observationId], Math.max(same.confidence, normalized.confidence), clamp(item.importance ?? same.importance, 0.1, 1));
+                this.store.updateProposalStatus(proposalId, "merged", [same.id]);
+                result.claimIds.push(same.id);
+                continue;
+            }
+            // Conflict detection only applies to STRUCTURED facts (single-slot
+            // predicates like contract_amount). Free-text fallback claims use
+            // predicate=category and value=the whole text — two different texts in
+            // the same category are simply two different memories, not a factual
+            // contradiction. Treating them as conflicts silently shelves every new
+            // memory once an entity/category slot exists (fail-quiet data loss).
+            const activeConflictTarget = STRUCTURED_PREDICATES.has(normalized.predicate)
+                ? existing.find((claim) => claim.status === "active" || claim.status === "pending_confirmation")
+                : undefined;
+            if (activeConflictTarget) {
+                const claimId = this.store.insertClaim({
+                    userId,
+                    entity: normalized.entity,
+                    predicate: normalized.predicate,
+                    value: normalized.value,
+                    text,
+                    category: item.category ?? "general",
+                    importance: clamp(item.importance ?? 0.5, 0.1, 1),
+                    confidence: normalized.confidence,
+                    source,
+                    sourcePriority,
+                    status: "conflicted",
+                    validTime: normalized.validTime,
+                    evidenceIds: [observationId],
+                });
+                const conflictId = this.store.insertConflict({
+                    userId,
+                    claimAId: activeConflictTarget.id,
+                    claimBId: claimId,
+                    reason: `same entity + same predicate + different value: ${normalized.entity}.${normalized.predicate}`,
+                });
+                this.store.updateProposalStatus(proposalId, "conflicted", [activeConflictTarget.id, claimId]);
+                result.claimsAdded++;
+                result.conflictsAdded++;
+                result.claimIds.push(claimId);
+                result.conflictIds.push(conflictId);
+                continue;
+            }
+            // Write-time near-duplicate gate (no embeddings): a semantically
+            // near-identical text variant must not double-store. Digit-bearing
+            // tokens are salient facts — when they differ, the texts are NOT
+            // duplicates (e.g. ids, amounts, markers).
+            const duplicate = this.findNearDuplicateMemory(userId, text);
+            if (duplicate) {
+                this.store.updateProposalStatus(proposalId, "merged", []);
+                continue;
+            }
+            const status = initialClaimStatus(source, normalized.confidence);
+            const memoryId = status === "active"
+                ? this.store.insert({
+                    text,
+                    userId,
+                    category: item.category ?? "general",
+                    importance: clamp(item.importance ?? 0.5, 0.1, 1),
+                    confidence: normalized.confidence,
+                    source,
+                    sessionId: options?.sessionId ?? "",
+                    eventDate: item.event_date ?? "",
+                    tags: item.tags ?? [],
+                    embedding: await this.embed(text),
+                })
+                : "";
+            // Link uploaded attachments to the freshly committed memory (素材随记忆落地).
+            if (memoryId && item.attachmentIds?.length) {
+                this.store.linkAttachments(memoryId, item.attachmentIds, userId);
+            }
+            const claimId = this.store.insertClaim({
+                userId,
+                memoryId,
+                entity: normalized.entity,
+                predicate: normalized.predicate,
+                value: normalized.value,
+                text,
+                category: item.category ?? "general",
+                importance: clamp(item.importance ?? 0.5, 0.1, 1),
+                confidence: normalized.confidence,
+                source,
+                sourcePriority,
+                status,
+                validTime: normalized.validTime,
+                evidenceIds: [observationId],
+            });
+            this.store.updateProposalStatus(proposalId, status === "active" ? "accepted" : "pending", [claimId]);
+            result.claimsAdded++;
+            result.memoriesAdded += memoryId ? 1 : 0;
+            result.claimIds.push(claimId);
+        }
+        return result;
+    }
+    /**
+     * Find an existing active memory that is a near-duplicate of `text`.
+     * Token containment (Latin/digit words + CJK bigrams) against recent
+     * memories; digit-bearing token mismatches veto the match because numbers
+     * and ids are precise facts, not phrasing variance.
+     */
+    findNearDuplicateMemory(userId, text) {
+        const tokens = dedupTokens(text);
+        if (tokens.size < MIN_DEDUP_TOKENS)
+            return null;
+        const recent = this.store.listByUser(userId, 1, 200, true);
+        for (const record of recent) {
+            const other = dedupTokens(record.text);
+            if (other.size < MIN_DEDUP_TOKENS)
+                continue;
+            let intersection = 0;
+            for (const token of tokens) {
+                if (other.has(token))
+                    intersection++;
+            }
+            const containment = intersection / Math.min(tokens.size, other.size);
+            if (containment < NEAR_DUPLICATE_CONTAINMENT)
+                continue;
+            if (digitTokensDiffer(tokens, other))
+                continue;
+            return record;
+        }
+        return null;
+    }
+}
+/** Containment threshold above which two texts count as the same memory. */
+const NEAR_DUPLICATE_CONTAINMENT = 0.82;
+/** Texts shorter than this many tokens are too small for overlap statistics. */
+const MIN_DEDUP_TOKENS = 6;
+/** Latin/digit words plus CJK character bigrams from normalized text. */
+function dedupTokens(text) {
+    const normalized = normalizeText(text);
+    const tokens = new Set();
+    for (const match of normalized.matchAll(/[a-z0-9][a-z0-9_\-.]*/g)) {
+        tokens.add(match[0]);
+    }
+    const runs = normalized.replace(/[^一-龥]/g, "").split("").filter(Boolean);
+    for (const run of runs) {
+        if (run.length === 1)
+            tokens.add(run);
+        for (let i = 0; i + 1 < run.length; i++) {
+            tokens.add(run.slice(i, i + 2));
+        }
+    }
+    return tokens;
+}
+/** True when either side has a digit-bearing token the other side lacks. */
+function digitTokensDiffer(a, b) {
+    for (const token of a) {
+        if (/\d/.test(token) && !b.has(token))
+            return true;
+    }
+    for (const token of b) {
+        if (/\d/.test(token) && !a.has(token))
+            return true;
+    }
+    return false;
+}
+/**
+ * Predicates produced by structured parsers (normalizeClaim) where a single
+ * fact slot exists and differing values genuinely contradict each other.
+ * Only these participate in conflict detection.
+ */
+const STRUCTURED_PREDICATES = new Set(["contract_amount", "progress_update_schedule"]);
+export function sourcePriorityOf(source) {
+    const normalized = normalizeSource(source);
+    if (normalized === "manual" || normalized === "user_edit")
+        return 100;
+    // auto-extract only fires on EXPLICIT user "remember ..." intent (regex-gated
+    // in memory-hooks), so it carries the same authority as explicit sources.
+    if (normalized === "explicit" || normalized === "agent-remember" || normalized === "agent" || normalized === "auto-extract")
+        return 90;
+    if (normalized === "document" || normalized === "image" || normalized === "video")
+        return 70;
+    if (normalized === "auto" || normalized === "turn")
+        return 45;
+    if (normalized === "dream" || normalized === "dream-consolidation" || normalized === "profile-extraction")
+        return 20;
+    return 40;
+}
+function initialClaimStatus(source, confidence) {
+    const priority = sourcePriorityOf(source);
+    if (priority >= 45 && confidence >= 0.55)
+        return "active";
+    return "pending_confirmation";
+}
+function normalizeClaim(text, item, source) {
+    const normalizedText = normalizeText(text);
+    const tags = (item.tags ?? []).join(" ");
+    const entity = detectEntity(text, tags);
+    const contractAmount = parseContractAmount(text);
+    if (contractAmount) {
+        return {
+            entity,
+            predicate: "contract_amount",
+            value: contractAmount,
+            validTime: normalizeValidMonth(item.event_date),
+            confidence: confidenceFor(source, 0.92),
+        };
+    }
+    const schedule = parseProgressSchedule(text);
+    if (schedule) {
+        return {
+            entity,
+            predicate: "progress_update_schedule",
+            value: schedule,
+            validTime: "",
+            confidence: confidenceFor(source, 0.86),
+        };
+    }
+    const category = normalizePredicate(item.category ?? "general");
+    return {
+        entity,
+        predicate: category,
+        value: { text: normalizedText },
+        validTime: normalizeValidMonth(item.event_date),
+        confidence: confidenceFor(source, 0.7),
+    };
+}
+function confidenceFor(source, base) {
+    const priority = sourcePriorityOf(source);
+    if (priority >= 90)
+        return clamp(base + 0.04, 0.1, 0.99);
+    if (priority <= 20)
+        return clamp(base - 0.18, 0.1, 0.95);
+    return clamp(base, 0.1, 0.98);
+}
+function detectEntity(text, tags) {
+    const haystack = `${text} ${tags}`;
+    if (/Galaxy\s*Tech|Galaxy/i.test(haystack))
+        return "Galaxy Tech";
+    const capitalized = haystack.match(/\b[A-Z][A-Za-z0-9]*(?:\s+[A-Z][A-Za-z0-9]*){0,3}\b/);
+    if (capitalized?.[0])
+        return capitalized[0].trim();
+    const chineseOrg = haystack.match(/([\u4e00-\u9fa5A-Za-z0-9]{2,18})(?:公司|客户|合同|项目)/);
+    if (chineseOrg?.[1])
+        return chineseOrg[1];
+    return "user";
+}
+function parseContractAmount(text) {
+    if (!/(合同|contract)/i.test(text))
+        return null;
+    const k = text.match(/(\d+(?:\.\d+)?)\s*k\b/i);
+    if (k)
+        return { amount: Math.round(Number(k[1]) * 1000), currency: inferCurrency(text) };
+    const wan = text.match(/(\d+(?:\.\d+)?)\s*万/);
+    if (wan)
+        return { amount: Math.round(Number(wan[1]) * 10000), currency: inferCurrency(text) };
+    const direct = text.match(/(?:金额|amount)[^\d]*(\d{5,})/i);
+    if (direct)
+        return { amount: Number(direct[1]), currency: inferCurrency(text) };
+    if (/一十八万/.test(text))
+        return { amount: 180000, currency: inferCurrency(text) };
+    return null;
+}
+function parseProgressSchedule(text) {
+    if (!/(提醒|进展|更新|progress|schedule|每周)/i.test(text))
+        return null;
+    const weekday = /周一|星期一|Monday/i.test(text)
+        ? "monday"
+        : /周二|星期二|Tuesday/i.test(text)
+            ? "tuesday"
+            : /周三|星期三|Wednesday/i.test(text)
+                ? "wednesday"
+                : /周四|星期四|Thursday/i.test(text)
+                    ? "thursday"
+                    : /周五|星期五|Friday/i.test(text)
+                        ? "friday"
+                        : /周六|星期六|Saturday/i.test(text)
+                            ? "saturday"
+                            : /周日|周天|星期日|星期天|Sunday/i.test(text)
+                                ? "sunday"
+                                : "";
+    if (!weekday)
+        return null;
+    const hour = text.match(/(?:上午|早上)?\s*(\d{1,2})\s*点/);
+    return {
+        cadence: "weekly",
+        weekday,
+        hour: hour ? Number(hour[1]) : null,
+    };
+}
+function sameSemanticValue(a, b) {
+    return stableJson(a) === stableJson(b);
+}
+function stableJson(value) {
+    const keys = Object.keys(value).sort();
+    return JSON.stringify(keys.reduce((acc, key) => {
+        acc[key] = value[key];
+        return acc;
+    }, {}));
+}
+function inferCurrency(text) {
+    if (/[¥￥]|人民币|CNY/i.test(text))
+        return "CNY";
+    if (/\$|USD/i.test(text))
+        return "USD";
+    return "unknown";
+}
+function normalizePredicate(value) {
+    const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_\-\u4e00-\u9fa5]+/g, "_");
+    return normalized || "general";
+}
+function normalizeValidMonth(value) {
+    if (!value)
+        return "";
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+function normalizeText(text) {
+    return text.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function normalizeSource(source) {
+    return source?.trim() || "agent";
+}
+function clamp(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    return Math.max(min, Math.min(max, value));
+}
+function cloneEmptyResult() {
+    return {
+        ...EMPTY_RESULT,
+        observationIds: [],
+        proposalIds: [],
+        claimIds: [],
+        conflictIds: [],
+    };
+}

package/dist/skills/memory/memory-db-path.d.ts

@@ -0,0 +1,13 @@
+import type { PathService } from "../../runtime/ports/index.js";
+/**
+ * Resolve the database file path for L2 vector memory storage.
+ * L2 vector memory is cross-project for one owner, but physically isolated by
+ * profile at ~/.qlogicagent/profiles/<owner_user_id>/memory/.
+ */
+export declare function resolveMemoryDbPath(ownerUserId?: string, pathService?: PathService): string;
+/**
+ * Persistent attachment directory for long-term memory, beside the memory DB:
+ * ~/.qlogicagent/profiles/<owner_user_id>/memory/attachments/
+ * Files here live as long as the memories that reference them (no expiry).
+ */
+export declare function resolveMemoryAttachmentsDir(ownerUserId?: string, pathService?: PathService): string;

package/dist/skills/memory/memory-db-path.js

@@ -0,0 +1,27 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getDefaultPathService } from "../../runtime/infra/default-path-service.js";
+/**
+ * Resolve the database file path for L2 vector memory storage.
+ * L2 vector memory is cross-project for one owner, but physically isolated by
+ * profile at ~/.qlogicagent/profiles/<owner_user_id>/memory/.
+ */
+export function resolveMemoryDbPath(ownerUserId = getDefaultPathService().resolveActiveOwnerUserId(), pathService = getDefaultPathService()) {
+    const base = pathService.getProfileMemoryDir(ownerUserId);
+    if (!fs.existsSync(base)) {
+        fs.mkdirSync(base, { recursive: true });
+    }
+    return path.join(base, "memories.db");
+}
+/**
+ * Persistent attachment directory for long-term memory, beside the memory DB:
+ * ~/.qlogicagent/profiles/<owner_user_id>/memory/attachments/
+ * Files here live as long as the memories that reference them (no expiry).
+ */
+export function resolveMemoryAttachmentsDir(ownerUserId = getDefaultPathService().resolveActiveOwnerUserId(), pathService = getDefaultPathService()) {
+    const dir = path.join(pathService.getProfileMemoryDir(ownerUserId), "attachments");
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}

package/dist/skills/memory/memory-embedding-config.d.ts

@@ -0,0 +1,31 @@
+import type { ConfigPort, PathService } from "../../runtime/ports/index.js";
+import type { LocalEmbeddingConfig } from "./local-embedding.js";
+export interface MemoryProviderFactoryConfig {
+    /** Active owner profile. All local memory files are physically scoped here. */
+    ownerUserId: string;
+    /** User ID prefix. */
+    userIdPrefix?: string;
+    /** Embedding config for local provider. */
+    embedding?: LocalEmbeddingConfig;
+}
+export interface MemoryEmbeddingModelBinding {
+    provider: string;
+    apiKey: string;
+    model: string;
+    baseUrl?: string;
+    keyHandle: {
+        release(result: {
+            success: boolean;
+        }): void;
+    };
+}
+export interface MemoryEmbeddingModelRegistry {
+    getActiveModel(purpose: "embedding"): MemoryEmbeddingModelBinding | null;
+}
+export interface MemoryConfigResolutionDeps {
+    config: ConfigPort;
+    pathService: PathService;
+    modelRegistry: MemoryEmbeddingModelRegistry;
+}
+export declare function resolveMemoryProviderConfig(deps: MemoryConfigResolutionDeps): MemoryProviderFactoryConfig;
+export type { LocalEmbeddingConfig };

package/dist/skills/memory/memory-embedding-config.js

@@ -0,0 +1,66 @@
+import { resolveProviderEmbeddingConfig } from "./local-embedding.js";
+export function resolveMemoryProviderConfig(deps) {
+    const ownerUserId = deps.pathService.resolveActiveOwnerUserId();
+    const userIdPrefix = deps.config.get("QMEMORY_USER_PREFIX") || undefined;
+    const embResolved = deps.modelRegistry.getActiveModel("embedding");
+    if (embResolved) {
+        const primary = buildEmbeddingApiConfig({
+            provider: embResolved.provider,
+            apiKey: embResolved.apiKey,
+            model: embResolved.model || "text-embedding-3-small",
+            baseUrl: embResolved.baseUrl,
+            timeoutMs: resolveEmbeddingTimeoutMs(deps.config),
+        });
+        embResolved.keyHandle.release({ success: true });
+        return {
+            ownerUserId,
+            userIdPrefix,
+            embedding: { api: primary },
+        };
+    }
+    const llmrouterEmbedding = resolveLlmrouterDefaultEmbeddingConfig(deps.config);
+    return {
+        ownerUserId,
+        userIdPrefix,
+        embedding: llmrouterEmbedding ? { api: llmrouterEmbedding } : undefined,
+    };
+}
+function resolveLlmrouterDefaultEmbeddingConfig(config) {
+    const baseUrl = normalizeBaseUrl(config.get("QLOGIC_LLMROUTER_BASE_URL"));
+    if (!baseUrl)
+        return undefined;
+    const apiKey = config.get("QLOGIC_LLMROUTER_ACCESS_TOKEN")?.trim();
+    if (!apiKey)
+        return undefined;
+    const dimensions = parseInt(config.get("QLOGIC_LLMROUTER_EMBEDDING_DIMENSIONS") || config.get("QMEMORY_EMBEDDING_DIMENSIONS") || "1024", 10);
+    return {
+        baseUrl,
+        apiKey,
+        model: config.get("QLOGIC_LLMROUTER_EMBEDDING_MODEL") || "BAAI/bge-m3",
+        dimensions: Number.isFinite(dimensions) ? dimensions : 1024,
+        format: "openai",
+        timeoutMs: resolveEmbeddingTimeoutMs(config),
+    };
+}
+function buildEmbeddingApiConfig(opts) {
+    const known = resolveProviderEmbeddingConfig(opts.provider, opts.apiKey, {
+        model: opts.model,
+        baseUrl: opts.baseUrl,
+    });
+    return {
+        ...(known ?? {
+            baseUrl: normalizeBaseUrl(opts.baseUrl) || "",
+            apiKey: opts.apiKey,
+            model: opts.model,
+            format: "openai",
+        }),
+        timeoutMs: opts.timeoutMs,
+    };
+}
+function normalizeBaseUrl(value) {
+    return value?.trim().replace(/\/+$/, "") ?? "";
+}
+function resolveEmbeddingTimeoutMs(config) {
+    const parsed = parseInt(config.get("QMEMORY_EMBEDDING_TIMEOUT_MS") || "1500", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1500;
+}

package/dist/skills/memory/memory-provider-factory.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Memory Provider Factory — creates local SQLite memory provider.
+ *
+ * No remote/cloud memory service exists. Memory is always local.
+ * This factory is the single integration point for stdio-server.ts.
+ */
+import type { LocalMemoryProvider } from "./local-memory-provider.js";
+import { type MemoryProviderFactoryConfig } from "./memory-embedding-config.js";
+export type { MemoryProviderFactoryConfig } from "./memory-embedding-config.js";
+export interface MemoryProviderFactoryResult {
+    provider: LocalMemoryProvider | null;
+    mode: "local" | "none";
+    error?: string;
+}
+/**
+ * Create the local SQLite memory provider.
+ * Returns null (mode "none") only if better-sqlite3 is not available.
+ */
+export declare function createMemoryProvider(config: MemoryProviderFactoryConfig): MemoryProviderFactoryResult;
+/**
+ * Build MemoryProviderFactoryConfig from environment variables.
+ * Used by stdio-server to auto-configure memory.
+ *
+ * Environment variables:
+ *   QMEMORY_EMBEDDING_TIMEOUT_MS — embedding request timeout (default: 1500)
+ *   QMEMORY_USER_PREFIX        — user ID prefix for multi-tenant
+ *
+ * Fixed embedding resolution:
+ *   Layer 0: Explicit ModelRegistry "embedding" binding
+ *   Layer 1: LLM Router default embedding endpoint (BAAI/bge-m3)
+ *   Layer 2: FTS5 pure text (NullEmbeddingProvider)
+ */
+export declare function resolveMemoryConfigFromEnv(): MemoryProviderFactoryConfig;