qlogicagent 2.13.4 → 2.13.5

package/dist/skills/memory/memory-provider-factory.js

@@ -0,0 +1,79 @@
+/**
+ * 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 { createRequire } from "node:module";
+import { createLocalMemoryProvider } from "./local-memory-provider.js";
+import { getModelRegistry } from "../../runtime/infra/model-registry.js";
+import { getDefaultPathService } from "../../runtime/infra/default-path-service.js";
+import { createProcessConfigPort } from "../../runtime/infra/process-config-port.js";
+import { resolveMemoryProviderConfig, } from "./memory-embedding-config.js";
+// ── Factory ─────────────────────────────────────────────────
+/**
+ * Create the local SQLite memory provider.
+ * Returns null (mode "none") only if better-sqlite3 is not available.
+ */
+export function createMemoryProvider(config) {
+    try {
+        const createDatabase = tryLoadBetterSqlite3();
+        if (createDatabase) {
+            const localConfig = {
+                ownerUserId: config.ownerUserId,
+                userIdPrefix: config.userIdPrefix,
+                embedding: config.embedding,
+                createDatabase,
+            };
+            const provider = createLocalMemoryProvider(localConfig);
+            return { provider, mode: "local" };
+        }
+    }
+    catch (err) {
+        return { provider: null, mode: "none", error: `Local provider failed: ${err.message}` };
+    }
+    return { provider: null, mode: "none", error: "better-sqlite3 not available" };
+}
+// ── SQLite loader ───────────────────────────────────────────
+/**
+ * Attempt to load better-sqlite3 dynamically.
+ * Returns a factory function or null if not available.
+ */
+function tryLoadBetterSqlite3() {
+    try {
+        // ESM has no global `require`; build a real one bound to this module so the
+        // native better-sqlite3 binding resolves both from source (tsx) and the
+        // bundled dist. Interop-normalize in case the bundler wraps the default.
+        const req = createRequire(import.meta.url);
+        const loaded = req("better-sqlite3");
+        const Database = loaded.default ?? loaded;
+        if (typeof Database !== "function")
+            return null;
+        const Ctor = Database;
+        return (dbPath) => new Ctor(dbPath);
+    }
+    catch {
+        return null;
+    }
+}
+// ── Environment resolution ──────────────────────────────────
+/**
+ * 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 function resolveMemoryConfigFromEnv() {
+    return resolveMemoryProviderConfig({
+        config: createProcessConfigPort(),
+        pathService: getDefaultPathService(),
+        modelRegistry: getModelRegistry(),
+    });
+}

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

@@ -0,0 +1,85 @@
+import type { MemoryProvider, MemorySearchResult, MemoryToolLocalProvider, ProjectMemoryStore } from "../../runtime/ports/index.js";
+export declare const MEMORY_TOOL_NAME: "memory";
+export declare const MEMORY_TOOL_LABEL = "Memory";
+export declare const MEMORY_TOOL_ACTIONS: readonly ["add", "replace", "remove", "create_file", "write_file", "read_file", "delete_file", "list_files", "search", "remember", "temporal", "feedback"];
+export type MemoryToolAction = (typeof MEMORY_TOOL_ACTIONS)[number];
+export declare const MEMORY_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: string[];
+            readonly description: string;
+        };
+        readonly content: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly old_text: {
+            readonly type: "string";
+            readonly description: "For 'replace'/'remove': the exact text to find in INDEX.md.";
+        };
+        readonly new_text: {
+            readonly type: "string";
+            readonly description: "For 'replace': the replacement text.";
+        };
+        readonly file: {
+            readonly type: "string";
+            readonly description: "Filename for file operations (e.g. 'project-notes.md', 'lesson-esbuild.md'). Must be kebab-case .md.";
+        };
+        readonly query: {
+            readonly type: "string";
+            readonly description: "For 'search'/'temporal': natural language query to find relevant memories.";
+        };
+        readonly days: {
+            readonly type: "number";
+            readonly description: "For 'temporal': look back N days from today (default: 7).";
+        };
+        readonly memory_ids: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "For 'feedback': IDs of memories to give feedback on.";
+        };
+        readonly signal: {
+            readonly type: "string";
+            readonly enum: readonly ["useful", "irrelevant", "outdated", "wrong"];
+            readonly description: "For 'feedback': the feedback signal to apply.";
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly enum: readonly ["preference", "personal_fact", "lesson", "pattern", "decision", "context"];
+            readonly description: "For 'remember': categorize the memory (helps with future recall precision).";
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export declare const MEMORY_TOOL_DESCRIPTION: string;
+export declare function isMemoryContentSafe(text: string): boolean;
+export interface MemoryToolParams {
+    action: MemoryToolAction;
+    content?: string;
+    old_text?: string;
+    new_text?: string;
+    file?: string;
+    query?: string;
+    days?: number;
+    memory_ids?: string[];
+    signal?: "useful" | "irrelevant" | "outdated" | "wrong";
+    category?: string;
+}
+export interface MemoryToolResult {
+    ok: boolean;
+    message: string;
+    action: string;
+    results?: MemorySearchResult[];
+}
+export interface MemoryToolExecutorDeps {
+    memdir: ProjectMemoryStore;
+    provider?: MemoryProvider;
+    /** Runtime memory provider for temporal/feedback (typed narrow for advanced ops). */
+    localProvider?: MemoryToolLocalProvider;
+    userId: string;
+}
+export declare function executeMemoryTool(params: MemoryToolParams, deps: MemoryToolExecutorDeps): Promise<MemoryToolResult>;

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

@@ -0,0 +1,326 @@
+// ============================================================
+// Memory ToolMEMDIR-based agent memory system (CC-aligned).
+//
+// Architecture:
+//   INDEX.md: always in system prompt (agent notes, preferences)
+//   Topic files: on-demand read via tool actions
+//   QMemory: semantic long-term search (cross-session)
+//
+// Actions:
+//   add      Append a note to INDEX.md (quick notes)
+//   replace  str_replace in INDEX.md
+//   remove   Remove text from INDEX.md
+//   create_fileCreate a topic file + auto-index entry
+//   write_file Overwrite a topic file
+//   read_file  Read a topic file on demand
+//   delete_fileDelete a topic file + remove index entry
+//   list_files List all memory topic files
+//   search     Search QMemory + local keyword match
+//
+// Reference: claude-code src/memdir/
+// ============================================================
+// Constants
+export const MEMORY_TOOL_NAME = "memory";
+export const MEMORY_TOOL_LABEL = "Memory";
+export const MEMORY_TOOL_ACTIONS = [
+    "add", "replace", "remove",
+    "create_file", "write_file", "read_file", "delete_file", "list_files",
+    "search", "remember", "temporal", "feedback",
+];
+// Tool schema
+export const MEMORY_TOOL_SCHEMA = {
+    type: "object",
+    properties: {
+        action: {
+            type: "string",
+            enum: MEMORY_TOOL_ACTIONS,
+            description: [
+                "Operation to perform:",
+                "",
+                "INDEX.md operations (project-level notes, always visible in system prompt):",
+                "- 'add' - Append a note to INDEX.md",
+                "- 'replace' - Replace text in INDEX.md (str_replace semantics)",
+                "- 'remove' - Remove text from INDEX.md",
+                "",
+                "Topic file operations (project-level, on-demand, for longer content):",
+                "- 'create_file' - Create a new .md topic file",
+                "- 'write_file' - Overwrite an existing topic file",
+                "- 'read_file' - Read a topic file",
+                "- 'delete_file' - Delete a topic file",
+                "- 'list_files' - List all memory topic files",
+                "",
+                "Long-term memory (user-level, persists across projects):",
+                "- 'remember' - Submit a fact/preference/lesson to the memory consolidation pipeline",
+                "- 'search' - Search long-term memory + local keyword match",
+                "- 'temporal' - Query memories by time range ('what happened last week')",
+                "",
+                "Feedback:",
+                "- 'feedback' - Mark memories as useful/irrelevant/outdated/wrong",
+            ].join("\n"),
+        },
+        content: {
+            type: "string",
+            description: [
+                "Content for add/replace/create_file/write_file.",
+                "For INDEX.md notes: write concise, factual statements.",
+                "For topic files: can be longer (up to 8KB), use markdown formatting.",
+            ].join("\n"),
+        },
+        old_text: {
+            type: "string",
+            description: "For 'replace'/'remove': the exact text to find in INDEX.md.",
+        },
+        new_text: {
+            type: "string",
+            description: "For 'replace': the replacement text.",
+        },
+        file: {
+            type: "string",
+            description: "Filename for file operations (e.g. 'project-notes.md', 'lesson-esbuild.md'). Must be kebab-case .md.",
+        },
+        query: {
+            type: "string",
+            description: "For 'search'/'temporal': natural language query to find relevant memories.",
+        },
+        days: {
+            type: "number",
+            description: "For 'temporal': look back N days from today (default: 7).",
+        },
+        memory_ids: {
+            type: "array",
+            items: { type: "string" },
+            description: "For 'feedback': IDs of memories to give feedback on.",
+        },
+        signal: {
+            type: "string",
+            enum: ["useful", "irrelevant", "outdated", "wrong"],
+            description: "For 'feedback': the feedback signal to apply.",
+        },
+        category: {
+            type: "string",
+            enum: ["preference", "personal_fact", "lesson", "pattern", "decision", "context"],
+            description: "For 'remember': categorize the memory (helps with future recall precision).",
+        },
+    },
+    required: ["action"],
+};
+export const MEMORY_TOOL_DESCRIPTION = [
+    "Manage persistent memory across sessions. Two distinct systems with clear roles:",
+    "",
+    "## Project memory (INDEX.md + topic files)",
+    "Scope: current project / workspace. Visible every turn.",
+    "Use for: architecture decisions, file conventions, build commands, known issues, task logs.",
+    "Actions: add, replace, remove, create_file, write_file, read_file, delete_file, list_files.",
+    "",
+    "## Long-term memory (QMemory)",
+    "Scope: user-level, persists across all projects. Searched on demand.",
+    "Use for: user preferences, personal facts, recurring lessons, communication style, past insights.",
+    "Actions: remember, search, temporal, feedback.",
+    "",
+    "## When to store (guidelines):",
+    "- User explicitly says 'remember this' or 'note that' -> submit a high-priority memory candidate",
+    "- User states a preference (style, format, tools, habits) -> remember (long-term)",
+    "- Project-specific decision or fact -> add/create_file (project memory)",
+    "- A debugging lesson or insight that applies broadly -> remember (long-term)",
+    "- DO NOT store: trivial/obvious info, one-off questions, transient state",
+    "- DO NOT store: information the user did not share or confirm",
+    "",
+    "## When to recall:",
+    "- Use 'search' when you suspect relevant past context exists for the current task",
+    "- Use 'temporal' to find what happened in a specific time period",
+    "- Memory is auto-recalled each turn - manual search is for deeper queries",
+].join("\n");
+// Content safety (exported for Memdir)
+const BLOCKED_PATTERNS = [
+    /ignore\s+(previous|all|above|prior)\s+instructions/i,
+    /you\s+are\s+now\s+/i,
+    /do\s+not\s+tell\s+the\s+user/i,
+    /system\s+prompt\s+override/i,
+];
+export function isMemoryContentSafe(text) {
+    return !BLOCKED_PATTERNS.some((pattern) => pattern.test(text));
+}
+export async function executeMemoryTool(params, deps) {
+    const { action } = params;
+    const { memdir } = deps;
+    // INDEX.md: add
+    if (action === "add") {
+        const content = params.content?.trim();
+        if (!content) {
+            return { ok: false, message: "content is required for 'add'.", action };
+        }
+        const result = await memdir.addToIndex(content);
+        return { ok: result.ok, message: result.message, action };
+    }
+    // INDEX.md: replace
+    if (action === "replace") {
+        const oldText = params.old_text?.trim();
+        const newText = params.new_text?.trim() || params.content?.trim();
+        if (!oldText) {
+            return { ok: false, message: "old_text is required for 'replace'.", action };
+        }
+        if (!newText) {
+            return { ok: false, message: "new_text (or content) is required for 'replace'.", action };
+        }
+        const result = await memdir.replaceInIndex(oldText, newText);
+        return { ok: result.ok, message: result.message, action };
+    }
+    // INDEX.md: remove
+    if (action === "remove") {
+        const oldText = params.old_text?.trim();
+        if (!oldText) {
+            return { ok: false, message: "old_text is required for 'remove'.", action };
+        }
+        const result = await memdir.removeFromIndex(oldText);
+        return { ok: result.ok, message: result.message, action };
+    }
+    // Topic files: create_file
+    if (action === "create_file") {
+        const file = params.file?.trim();
+        const content = params.content?.trim();
+        if (!file) {
+            return { ok: false, message: "file is required for 'create_file'.", action };
+        }
+        if (!content) {
+            return { ok: false, message: "content is required for 'create_file'.", action };
+        }
+        const result = await memdir.createFile(file, content);
+        return { ok: result.ok, message: result.message, action };
+    }
+    // Topic files: write_file
+    if (action === "write_file") {
+        const file = params.file?.trim();
+        const content = params.content?.trim();
+        if (!file) {
+            return { ok: false, message: "file is required for 'write_file'.", action };
+        }
+        if (!content) {
+            return { ok: false, message: "content is required for 'write_file'.", action };
+        }
+        const result = await memdir.writeFile(file, content);
+        return { ok: result.ok, message: result.message, action };
+    }
+    // Topic files: read_file
+    if (action === "read_file") {
+        const file = params.file?.trim();
+        if (!file) {
+            return { ok: false, message: "file is required for 'read_file'.", action };
+        }
+        const result = await memdir.readFile(file);
+        if (!result.ok) {
+            return { ok: false, message: result.message, action };
+        }
+        return { ok: true, message: result.content, action };
+    }
+    // Topic files: delete_file
+    if (action === "delete_file") {
+        const file = params.file?.trim();
+        if (!file) {
+            return { ok: false, message: "file is required for 'delete_file'.", action };
+        }
+        const result = await memdir.deleteFile(file);
+        return { ok: result.ok, message: result.message, action };
+    }
+    // Topic files: list_files
+    if (action === "list_files") {
+        const files = await memdir.listFiles();
+        if (files.length === 0) {
+            return { ok: true, message: "No topic files yet. Use 'create_file' to create one.", action };
+        }
+        const listing = files.map(f => {
+            const sizeKB = (f.size / 1024).toFixed(1);
+            const date = f.modifiedAt.slice(0, 10);
+            return `--${f.name} (${sizeKB}KB, ${date})${f.preview ? "" + f.preview : ""}`;
+        }).join("\n");
+        return { ok: true, message: `Memory files (${files.length}):\n${listing}`, action };
+    }
+    // Search: QMemory + local keyword
+    if (action === "search") {
+        const query = params.query?.trim();
+        if (!query) {
+            return { ok: false, message: "query is required for 'search'.", action };
+        }
+        const sections = [];
+        let qmemoryResults;
+        // 1. Local keyword search across all memory files
+        try {
+            const localResults = await memdir.searchLocal(query);
+            if (localResults.length > 0) {
+                sections.push("## Local Memory\n" + localResults.map(r => `--[${r.file}] ${r.snippet}`).join("\n"));
+            }
+        }
+        catch { /* degrade */ }
+        // 2. QMemory semantic search
+        if (deps.provider) {
+            try {
+                const results = await deps.provider.search(query, deps.userId, { limit: 10 });
+                qmemoryResults = results;
+                if (results.length > 0) {
+                    sections.push("## Long-term Memory (QMemory)\n" + results.map((r, i) => `${i + 1}. ${r.text}`).join("\n"));
+                }
+            }
+            catch { /* degrade */ }
+        }
+        if (sections.length === 0) {
+            return { ok: true, message: "No matching memories found.", action, results: [] };
+        }
+        return { ok: true, message: sections.join("\n\n"), action, results: qmemoryResults };
+    }
+    // Temporal query: time-range memory recall
+    if (action === "remember") {
+        if (!deps.localProvider) {
+            return { ok: false, message: "Long-term memory requires local memory provider.", action };
+        }
+        const content = params.content?.trim();
+        if (!content) {
+            return { ok: false, message: "content is required for 'remember'.", action };
+        }
+        if (!isMemoryContentSafe(content)) {
+            return { ok: false, message: "Content blocked by safety filter.", action };
+        }
+        // Quality gate: reject trivially short or overly long content
+        if (content.length < 10) {
+            return { ok: false, message: "Memory too short - provide a meaningful fact or insight (>=10 chars).", action };
+        }
+        if (content.length > 2000) {
+            return { ok: false, message: "Memory too long (max 2000 chars). Condense the insight.", action };
+        }
+        try {
+            await deps.localProvider.addText(content, deps.userId, {
+                source: "agent-remember",
+                category: params.category ?? "lesson",
+                importance: 0.7,
+            });
+            return { ok: true, message: `Stored to long-term memory: "${content.slice(0, 80)}${content.length > 80 ? "..." : ""}"`, action };
+        }
+        catch (err) {
+            return { ok: false, message: `Failed to store: ${err instanceof Error ? err.message : String(err)}`, action };
+        }
+    }
+    if (action === "temporal") {
+        if (!deps.localProvider) {
+            return { ok: false, message: "Temporal query requires local memory provider.", action };
+        }
+        const days = params.days ?? 7;
+        const startMs = Date.now() - days * 86_400_000;
+        const timeline = deps.localProvider.synthesizeTimeline(deps.userId, startMs, Date.now());
+        return { ok: true, message: timeline, action };
+    }
+    // Feedback: mark memories as useful/irrelevant/outdated/wrong
+    if (action === "feedback") {
+        if (!deps.localProvider) {
+            return { ok: false, message: "Feedback requires local memory provider.", action };
+        }
+        const memoryIds = params.memory_ids;
+        const signal = params.signal;
+        if (!memoryIds || memoryIds.length === 0) {
+            return { ok: false, message: "memory_ids is required for 'feedback'.", action };
+        }
+        if (!signal) {
+            return { ok: false, message: "signal is required for 'feedback' (useful/irrelevant/outdated/wrong).", action };
+        }
+        const result = await deps.localProvider.feedback(memoryIds, signal);
+        return { ok: true, message: `Feedback '${signal}' applied to ${result.affected} memories.`, action };
+    }
+    return { ok: false, message: `Unknown action: "${action}".`, action };
+}

package/dist/skills/memory/memory-vector-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeVector(vec: Float32Array): Float32Array;
+export declare function dotProduct(a: Float32Array, b: Float32Array): number;

package/dist/skills/memory/memory-vector-utils.js

@@ -0,0 +1,19 @@
+export function normalizeVector(vec) {
+    let norm = 0;
+    for (let i = 0; i < vec.length; i++)
+        norm += vec[i] * vec[i];
+    norm = Math.sqrt(norm);
+    if (norm === 0)
+        return vec;
+    const result = new Float32Array(vec.length);
+    for (let i = 0; i < vec.length; i++)
+        result[i] = vec[i] / norm;
+    return result;
+}
+export function dotProduct(a, b) {
+    let sum = 0;
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++)
+        sum += a[i] * b[i];
+    return sum;
+}

package/dist/skills/memory/recall-category-filter.d.ts

@@ -0,0 +1 @@
+export * from "../../runtime/memory/recall-category-filter.js";

package/dist/skills/memory/recall-category-filter.js

@@ -0,0 +1 @@
+export * from "../../runtime/memory/recall-category-filter.js";

package/dist/skills/memory/sqlite-memory-mappers.d.ts

@@ -0,0 +1,6 @@
+import type { MemoryClaimRecord, MemoryConflictRecord, MemoryRecord } from "./local-store-records.js";
+export declare function rowToRecord(row: unknown): MemoryRecord;
+export declare function rowToClaimRecord(row: unknown): MemoryClaimRecord;
+export declare function rowToConflictRecord(row: unknown): MemoryConflictRecord;
+export declare function parseJsonObject(raw: unknown): Record<string, unknown>;
+export declare function parseJsonArray(raw: unknown): string[];

package/dist/skills/memory/sqlite-memory-mappers.js

@@ -0,0 +1,104 @@
+export function rowToRecord(row) {
+    const r = asRow(row);
+    const embedding = r.embedding instanceof Buffer ? r.embedding : null;
+    return {
+        id: stringValue(r.id),
+        text: stringValue(r.text),
+        userId: stringValue(r.user_id),
+        category: stringValue(r.category, "general"),
+        importance: numberValue(r.importance, 0.5),
+        confidence: numberValue(r.confidence, 1.0),
+        source: stringValue(r.source, "agent"),
+        sessionId: stringValue(r.session_id),
+        eventDate: stringValue(r.event_date),
+        tags: parseJsonArray(r.tags),
+        embedding: embedding
+            ? new Float32Array(embedding.buffer, embedding.byteOffset, embedding.byteLength / 4)
+            : null,
+        createdAt: numberValue(r.created_at),
+        updatedAt: numberValue(r.updated_at),
+        accessCount: numberValue(r.access_count),
+        lastAccessedAt: numberValue(r.last_accessed_at),
+        isArchived: Boolean(r.is_archived),
+    };
+}
+export function rowToClaimRecord(row) {
+    const r = asRow(row);
+    return {
+        id: stringValue(r.id),
+        memoryId: stringValue(r.memory_id),
+        userId: stringValue(r.user_id),
+        entity: stringValue(r.entity),
+        predicate: stringValue(r.predicate),
+        value: parseJsonObject(r.value_json),
+        text: stringValue(r.text),
+        category: stringValue(r.category, "general"),
+        importance: numberValue(r.importance, 0.5),
+        confidence: numberValue(r.confidence, 0.5),
+        source: stringValue(r.source, "agent"),
+        sourcePriority: numberValue(r.source_priority),
+        status: claimStatusValue(r.status),
+        validTime: stringValue(r.valid_time),
+        evidenceIds: parseJsonArray(r.evidence_ids),
+        supersedesClaimId: stringValue(r.supersedes_claim_id),
+        conflictGroupId: stringValue(r.conflict_group_id),
+        createdAt: numberValue(r.created_at),
+        updatedAt: numberValue(r.updated_at),
+    };
+}
+export function rowToConflictRecord(row) {
+    const r = asRow(row);
+    return {
+        id: stringValue(r.id),
+        userId: stringValue(r.user_id),
+        claimAId: stringValue(r.claim_a_id),
+        claimBId: stringValue(r.claim_b_id),
+        reason: stringValue(r.reason),
+        status: conflictStatusValue(r.status),
+        createdAt: numberValue(r.created_at),
+        updatedAt: numberValue(r.updated_at),
+    };
+}
+export function parseJsonObject(raw) {
+    if (typeof raw !== "string" || !raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function parseJsonArray(raw) {
+    if (typeof raw !== "string" || !raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+function asRow(row) {
+    return row && typeof row === "object" ? row : {};
+}
+function stringValue(value, fallback = "") {
+    return typeof value === "string" ? value : fallback;
+}
+function numberValue(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function claimStatusValue(value) {
+    return value === "active" ||
+        value === "superseded" ||
+        value === "conflicted" ||
+        value === "archived" ||
+        value === "pending_confirmation"
+        ? value
+        : "active";
+}
+function conflictStatusValue(value) {
+    return value === "open" || value === "resolved" || value === "dismissed" ? value : "open";
+}

package/dist/skills/memory/sqlite-memory-schema.d.ts

@@ -0,0 +1,3 @@
+import type { SqliteDatabase } from "./local-store-records.js";
+export declare const MEMORY_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS memories (\n  id TEXT PRIMARY KEY,\n  text TEXT NOT NULL,\n  user_id TEXT NOT NULL,\n  category TEXT NOT NULL DEFAULT 'general',\n  importance REAL NOT NULL DEFAULT 0.5,\n  confidence REAL NOT NULL DEFAULT 1.0,\n  source TEXT NOT NULL DEFAULT 'agent',\n  session_id TEXT NOT NULL DEFAULT '',\n  event_date TEXT NOT NULL DEFAULT '',\n  tags TEXT NOT NULL DEFAULT '[]',\n  embedding BLOB,\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL,\n  access_count INTEGER NOT NULL DEFAULT 0,\n  last_accessed_at INTEGER NOT NULL DEFAULT 0,\n  is_archived INTEGER NOT NULL DEFAULT 0\n);\n\nCREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id);\nCREATE INDEX IF NOT EXISTS idx_memories_user_category ON memories(user_id, category);\nCREATE INDEX IF NOT EXISTS idx_memories_user_importance ON memories(user_id, importance DESC);\nCREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at DESC);\n\nCREATE TABLE IF NOT EXISTS memory_observations (\n  id TEXT PRIMARY KEY,\n  user_id TEXT NOT NULL,\n  text TEXT NOT NULL,\n  source TEXT NOT NULL,\n  source_priority INTEGER NOT NULL DEFAULT 0,\n  session_id TEXT NOT NULL DEFAULT '',\n  evidence_type TEXT NOT NULL DEFAULT 'text',\n  payload TEXT NOT NULL DEFAULT '{}',\n  created_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_observations_user_created ON memory_observations(user_id, created_at DESC);\nCREATE INDEX IF NOT EXISTS idx_memory_observations_source ON memory_observations(user_id, source);\n\nCREATE TABLE IF NOT EXISTS memory_proposals (\n  id TEXT PRIMARY KEY,\n  user_id TEXT NOT NULL,\n  observation_ids TEXT NOT NULL DEFAULT '[]',\n  text TEXT NOT NULL,\n  category TEXT NOT NULL DEFAULT 'general',\n  importance REAL NOT NULL DEFAULT 0.5,\n  confidence REAL NOT NULL DEFAULT 0.5,\n  source TEXT NOT NULL DEFAULT 'agent',\n  source_priority INTEGER NOT NULL DEFAULT 0,\n  entity TEXT NOT NULL DEFAULT '',\n  predicate TEXT NOT NULL DEFAULT '',\n  value_json TEXT NOT NULL DEFAULT '{}',\n  valid_time TEXT NOT NULL DEFAULT '',\n  tags TEXT NOT NULL DEFAULT '[]',\n  status TEXT NOT NULL DEFAULT 'pending',\n  related_claim_ids TEXT NOT NULL DEFAULT '[]',\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_proposals_user_status ON memory_proposals(user_id, status);\nCREATE INDEX IF NOT EXISTS idx_memory_proposals_fact ON memory_proposals(user_id, entity, predicate, valid_time);\n\nCREATE TABLE IF NOT EXISTS memory_claims (\n  id TEXT PRIMARY KEY,\n  memory_id TEXT NOT NULL DEFAULT '',\n  user_id TEXT NOT NULL,\n  entity TEXT NOT NULL DEFAULT '',\n  predicate TEXT NOT NULL DEFAULT '',\n  value_json TEXT NOT NULL DEFAULT '{}',\n  text TEXT NOT NULL,\n  category TEXT NOT NULL DEFAULT 'general',\n  importance REAL NOT NULL DEFAULT 0.5,\n  confidence REAL NOT NULL DEFAULT 0.5,\n  source TEXT NOT NULL DEFAULT 'agent',\n  source_priority INTEGER NOT NULL DEFAULT 0,\n  status TEXT NOT NULL DEFAULT 'active',\n  valid_time TEXT NOT NULL DEFAULT '',\n  evidence_ids TEXT NOT NULL DEFAULT '[]',\n  supersedes_claim_id TEXT NOT NULL DEFAULT '',\n  conflict_group_id TEXT NOT NULL DEFAULT '',\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_claims_user_status ON memory_claims(user_id, status);\nCREATE INDEX IF NOT EXISTS idx_memory_claims_memory ON memory_claims(memory_id);\nCREATE INDEX IF NOT EXISTS idx_memory_claims_fact ON memory_claims(user_id, entity, predicate, valid_time);\n\nCREATE TABLE IF NOT EXISTS memory_conflicts (\n  id TEXT PRIMARY KEY,\n  user_id TEXT NOT NULL,\n  claim_a_id TEXT NOT NULL,\n  claim_b_id TEXT NOT NULL,\n  reason TEXT NOT NULL,\n  status TEXT NOT NULL DEFAULT 'open',\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_conflicts_user_status ON memory_conflicts(user_id, status);\n\nCREATE TABLE IF NOT EXISTS memory_attachments (\n  id TEXT PRIMARY KEY,\n  memory_id TEXT NOT NULL DEFAULT '',\n  user_id TEXT NOT NULL,\n  kind TEXT NOT NULL DEFAULT 'file',\n  filename TEXT NOT NULL DEFAULT '',\n  mime_type TEXT NOT NULL DEFAULT '',\n  size INTEGER NOT NULL DEFAULT 0,\n  rel_path TEXT NOT NULL,\n  extracted_text TEXT NOT NULL DEFAULT '',\n  created_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_attachments_memory ON memory_attachments(memory_id);\nCREATE INDEX IF NOT EXISTS idx_memory_attachments_orphan ON memory_attachments(user_id, memory_id, created_at);\n\nCREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(\n  id UNINDEXED,\n  user_id UNINDEXED,\n  text,\n  category,\n  tags,\n  content=memories,\n  content_rowid=rowid,\n  tokenize='unicode61 remove_diacritics 2'\n);\n\nCREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN\n  INSERT INTO memories_fts(rowid, id, user_id, text, category, tags)\n  VALUES (new.rowid, new.id, new.user_id, new.text, new.category, new.tags);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN\n  INSERT INTO memories_fts(memories_fts, rowid, id, user_id, text, category, tags)\n  VALUES ('delete', old.rowid, old.id, old.user_id, old.text, old.category, old.tags);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN\n  INSERT INTO memories_fts(memories_fts, rowid, id, user_id, text, category, tags)\n  VALUES ('delete', old.rowid, old.id, old.user_id, old.text, old.category, old.tags);\n  INSERT INTO memories_fts(rowid, id, user_id, text, category, tags)\n  VALUES (new.rowid, new.id, new.user_id, new.text, new.category, new.tags);\nEND;\n";
+export declare function initializeMemorySchema(db: SqliteDatabase): void;