@cortask/core 0.2.36 → 0.2.38

package/dist/index.js

@@ -934,6 +934,8 @@ function createProvider(id, apiKey) {
 
 // src/agent/runner.ts
 import crypto2 from "crypto";
+import fs2 from "fs/promises";
+import nodePath from "path";
 
 // src/agent/system-prompt.ts
 function buildSystemPrompt(ctx) {
@@ -960,7 +962,12 @@ Current date and time: ${(/* @__PURE__ */ new Date()).toLocaleString("en-US", {
 - If a task requires multiple steps, break it down and work through each step
 - After creating or generating a file the user would want to download (documents, images, exports, etc.), always call show_file so it appears as a downloadable card in the chat
 - When the user wants to view file contents inline (e.g. "show me the file here"), use the artifact tool with the path parameter to read from disk. NEVER re-output file contents as the content parameter \u2014 use path instead so it loads instantly
-- When the user shares personal info, preferences, or important context, proactively use memory_append to save it. Use global memory for user info (name, preferences), project memory for project-specific context. Don't ask \u2014 just save and briefly acknowledge.
+- **Memory system**: You have two memory mechanisms:
+  - **Pinned notes** (memory.md): A concise, curated summary of the most important context. Read via memory_read, rewritten via memory_save. Keep this short \u2014 it's loaded into every conversation. Use memory_save to consolidate when it grows too long.
+  - **Searchable memory** (database): Individual facts indexed for search. Use memory_append to save a note (appends to pinned notes AND indexes in the database). Use memory_search to recall previously saved context.
+- When the user shares personal info, preferences, or important context, use memory_append to save it. Use global scope for user info (name, preferences), project scope for project-specific context. Don't ask \u2014 just save and briefly acknowledge.
+- When a topic might relate to prior conversations, use memory_search to check for relevant memories before answering.
+- If memory.md gets long, use memory_read then memory_save to consolidate it into a concise summary. Don't let it become a log \u2014 keep it to key facts only.
 
 ## File Organization
 When creating or saving files, organize them into logical subdirectories rather than dumping everything in the workspace root. Choose a clear, descriptive directory structure based on the content. For example:
@@ -1188,12 +1195,13 @@ var AgentRunner = class {
     };
     return buildSystemPrompt(ctx);
   }
-  createToolContext(sessionId, runId) {
+  createToolContext(sessionId, runId, workspaceId) {
     return {
       workspacePath: this.deps.getWorkspacePath(),
       dataDir: this.deps.getDataDir(),
       sessionId,
       runId,
+      workspaceId,
       requestPermission: async (req) => {
         if (this.deps.onPermissionRequest) {
           return this.deps.onPermissionRequest(req);
@@ -1205,22 +1213,53 @@ var AgentRunner = class {
           return this.deps.onQuestionnaireRequest(req);
         }
         return {};
-      }
+      },
+      memoryManager: this.deps.memoryManager
     };
   }
+  async readFileReferences(refs) {
+    if (!refs?.length) return [];
+    const workspacePath = this.deps.getWorkspacePath();
+    const parts = [];
+    const MAX_FILE_SIZE = 50 * 1024;
+    for (const ref of refs) {
+      const fullPath = nodePath.resolve(workspacePath, ref);
+      if (!fullPath.startsWith(nodePath.resolve(workspacePath))) continue;
+      try {
+        const stat = await fs2.stat(fullPath);
+        if (stat.size > MAX_FILE_SIZE) {
+          parts.push({ type: "text", text: `[File: ${ref}]
+(Skipped \u2014 file exceeds 50KB limit)` });
+          continue;
+        }
+        const content = await fs2.readFile(fullPath, "utf-8");
+        parts.push({ type: "text", text: `[File: ${ref}]
+\`\`\`
+${content}
+\`\`\`` });
+      } catch {
+        parts.push({ type: "text", text: `[File: ${ref}]
+(File not found or unreadable)` });
+      }
+    }
+    return parts;
+  }
   async run(params) {
     const runId = crypto2.randomUUID();
     const sessionId = params.sessionId ?? crypto2.randomUUID();
     const { config } = this.deps;
     const messages = await this.deps.getSessionMessages(sessionId);
-    if (params.attachments?.length) {
+    const fileRefParts = await this.readFileReferences(params.fileReferences);
+    const hasMultipart = (params.attachments?.length ?? 0) > 0 || fileRefParts.length > 0;
+    if (hasMultipart) {
       const parts = [
         { type: "text", text: params.prompt },
-        ...params.attachments.map((a) => ({
+        ...fileRefParts,
+        ...params.attachments?.map((a) => ({
           type: "image",
           imageBase64: a.base64,
           mimeType: a.mimeType
-        }))
+        })) ?? []
       ];
       messages.push({ role: "user", content: parts });
     } else {
@@ -1228,7 +1267,7 @@ var AgentRunner = class {
     }
     const systemPrompt = await this.buildSystemPromptText();
     const toolDefs = this.buildToolDefinitions();
-    const toolContext = this.createToolContext(sessionId, runId);
+    const toolContext = this.createToolContext(sessionId, runId, params.workspaceId);
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
     const allToolCalls = [];
@@ -1335,14 +1374,17 @@ var AgentRunner = class {
     const { config } = this.deps;
     const signal = params.signal;
     const messages = await this.deps.getSessionMessages(sessionId);
-    if (params.attachments?.length) {
+    const streamFileRefParts = await this.readFileReferences(params.fileReferences);
+    const streamHasMultipart = (params.attachments?.length ?? 0) > 0 || streamFileRefParts.length > 0;
+    if (streamHasMultipart) {
       const parts = [
         { type: "text", text: params.prompt },
-        ...params.attachments.map((a) => ({
+        ...streamFileRefParts,
+        ...params.attachments?.map((a) => ({
           type: "image",
           imageBase64: a.base64,
           mimeType: a.mimeType
-        }))
+        })) ?? []
       ];
       messages.push({ role: "user", content: parts });
     } else {
@@ -1350,7 +1392,7 @@ var AgentRunner = class {
     }
     const systemPrompt = await this.buildSystemPromptText();
     const toolDefs = this.buildToolDefinitions();
-    const toolContext = this.createToolContext(sessionId, runId);
+    const toolContext = this.createToolContext(sessionId, runId, params.workspaceId);
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
     let finalContent = "";
@@ -1595,7 +1637,7 @@ var AgentRunner = class {
 };
 
 // src/agent/tools/read-file.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 import path2 from "path";
 var readFileTool = {
   definition: {
@@ -1622,7 +1664,7 @@ var readFileTool = {
       };
     }
     try {
-      const content = await fs2.readFile(filePath, "utf-8");
+      const content = await fs3.readFile(filePath, "utf-8");
       return { toolCallId: "", content };
     } catch (err) {
       return {
@@ -1635,7 +1677,7 @@ var readFileTool = {
 };
 
 // src/agent/tools/write-file.ts
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import path3 from "path";
 var writeFileTool = {
   definition: {
@@ -1679,8 +1721,8 @@ var writeFileTool = {
       };
     }
     try {
-      await fs3.mkdir(path3.dirname(filePath), { recursive: true });
-      await fs3.writeFile(filePath, args.content, "utf-8");
+      await fs4.mkdir(path3.dirname(filePath), { recursive: true });
+      await fs4.writeFile(filePath, args.content, "utf-8");
       return {
         toolCallId: "",
         content: `File written: ${args.path}`
@@ -1696,7 +1738,7 @@ var writeFileTool = {
 };
 
 // src/agent/tools/list-files.ts
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import path4 from "path";
 var listFilesTool = {
   definition: {
@@ -1725,7 +1767,7 @@ var listFilesTool = {
       };
     }
     try {
-      const entries = await fs4.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs5.readdir(dirPath, { withFileTypes: true });
       const lines = entries.map((e) => {
         const suffix = e.isDirectory() ? "/" : "";
         return `${e.name}${suffix}`;
@@ -2073,9 +2115,11 @@ var questionnaireTool = {
 };
 
 // src/agent/tools/memory.ts
-import fs5 from "fs/promises";
+import crypto3 from "crypto";
+import fs6 from "fs/promises";
 import path5 from "path";
 var CORTASK_DIR = ".cortask";
+var MEMORY_FILE_WARNING_LINES = 200;
 function getMemoryPath(scope, context) {
   if (scope === "global") {
     return path5.join(context.dataDir, "memory.md");
@@ -2101,7 +2145,7 @@ var memoryReadTool = {
     const scope = args.scope || "project";
     const memoryPath = getMemoryPath(scope, context);
     try {
-      const content = await fs5.readFile(memoryPath, "utf-8");
+      const content = await fs6.readFile(memoryPath, "utf-8");
       return { toolCallId: "", content };
     } catch {
       return {
@@ -2142,8 +2186,8 @@ var memorySaveTool = {
     }
     const scope = args.scope || "project";
     const memoryPath = getMemoryPath(scope, context);
-    await fs5.mkdir(path5.dirname(memoryPath), { recursive: true });
-    await fs5.writeFile(memoryPath, content, "utf-8");
+    await fs6.mkdir(path5.dirname(memoryPath), { recursive: true });
+    await fs6.writeFile(memoryPath, content, "utf-8");
     return {
       toolCallId: "",
       content: `${scope === "global" ? "Global" : "Project"} memory saved (${content.length} chars)`
@@ -2153,7 +2197,7 @@ var memorySaveTool = {
 var memoryAppendTool = {
   definition: {
     name: "memory_append",
-    description: "Append a note to long-term memory. Use scope 'global' for user preferences that apply across all projects, or 'project' (default) for project-specific context.",
+    description: "Append a note to long-term memory. Use scope 'global' for user preferences that apply across all projects, or 'project' (default) for project-specific context. The note is also indexed in the searchable memory database.",
     inputSchema: {
       type: "object",
       properties: {
@@ -2181,24 +2225,104 @@ var memoryAppendTool = {
     }
     const scope = args.scope || "project";
     const memoryPath = getMemoryPath(scope, context);
-    await fs5.mkdir(path5.dirname(memoryPath), { recursive: true });
+    await fs6.mkdir(path5.dirname(memoryPath), { recursive: true });
     let existing = "";
     try {
-      existing = await fs5.readFile(memoryPath, "utf-8");
+      existing = await fs6.readFile(memoryPath, "utf-8");
     } catch {
       existing = scope === "global" ? "# Global Memory\n\nUser preferences and context that apply across all projects.\n" : "# Project Memory\n\nThis file is used by Cortask to remember important context about this project.\n";
     }
     const updated = existing.trimEnd() + "\n\n" + note + "\n";
-    await fs5.writeFile(memoryPath, updated, "utf-8");
+    await fs6.writeFile(memoryPath, updated, "utf-8");
+    if (context.memoryManager && scope === "project") {
+      try {
+        await context.memoryManager.index([
+          {
+            id: crypto3.randomUUID(),
+            content: note,
+            source: "agent",
+            sessionId: context.sessionId,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            metadata: { tool: "memory_append" }
+          }
+        ]);
+      } catch {
+      }
+    }
+    const lineCount = updated.split("\n").length;
+    const warning = lineCount > MEMORY_FILE_WARNING_LINES ? ` Warning: memory.md is now ${lineCount} lines. Consider using memory_save to consolidate and rewrite it as a concise summary.` : "";
     return {
       toolCallId: "",
-      content: `Note appended to ${scope} memory.`
+      content: `Note appended to ${scope} memory.${warning}`
     };
   }
 };
+var memorySearchTool = {
+  definition: {
+    name: "memory_search",
+    description: "Search long-term memory using semantic and keyword search. Returns the most relevant memories matching the query. Use this to recall previously saved context, decisions, or notes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query to find relevant memories."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results to return (default: 5)."
+        }
+      },
+      required: ["query"]
+    }
+  },
+  async execute(args, context) {
+    const query = args.query;
+    if (!query) {
+      return {
+        toolCallId: "",
+        content: "Error: query is required",
+        isError: true
+      };
+    }
+    if (!context.memoryManager) {
+      return {
+        toolCallId: "",
+        content: "Memory search is not available for this workspace."
+      };
+    }
+    const limit = typeof args.limit === "number" ? args.limit : 5;
+    try {
+      const results = await context.memoryManager.search(query, limit);
+      if (results.length === 0) {
+        return {
+          toolCallId: "",
+          content: "No memories found matching the query."
+        };
+      }
+      const formatted = results.map((r, i) => {
+        const date = r.entry.createdAt ? new Date(r.entry.createdAt).toLocaleDateString() : "unknown";
+        return `${i + 1}. [${r.matchType}] (score: ${r.score.toFixed(3)}, ${date})
+${r.entry.content}`;
+      }).join("\n\n");
+      return {
+        toolCallId: "",
+        content: `Found ${results.length} memories:
+
+${formatted}`
+      };
+    } catch (err) {
+      return {
+        toolCallId: "",
+        content: `Memory search error: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
 
 // src/agent/tools/show-file.ts
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import path6 from "path";
 var showFileTool = {
   definition: {
@@ -2229,7 +2353,7 @@ var showFileTool = {
       };
     }
     try {
-      const stat = await fs6.stat(filePath);
+      const stat = await fs7.stat(filePath);
       return {
         toolCallId: "",
         content: JSON.stringify({
@@ -2251,11 +2375,11 @@ var showFileTool = {
 
 // src/agent/tools/data-file.ts
 import path8 from "path";
-import fs8 from "fs";
+import fs9 from "fs";
 import Database from "better-sqlite3";
 
 // src/data/parser.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path7 from "path";
 var MAX_RAW_SIZE = 5e5;
 var MAX_ROWS = 5e4;
@@ -2286,7 +2410,7 @@ function detectColumnTypes(data) {
   });
 }
 function parseCsv(filePath, forceDelimiter) {
-  let raw = fs7.readFileSync(filePath, "utf-8");
+  let raw = fs8.readFileSync(filePath, "utf-8");
   if (raw.length > MAX_RAW_SIZE) {
     raw = raw.slice(0, MAX_RAW_SIZE);
     const lastNewline = raw.lastIndexOf("\n");
@@ -2352,7 +2476,7 @@ function splitCsvLines(text, delimiter) {
   return result;
 }
 function parseJson(filePath) {
-  let raw = fs7.readFileSync(filePath, "utf-8");
+  let raw = fs8.readFileSync(filePath, "utf-8");
   if (raw.length > MAX_RAW_SIZE) {
     throw new Error(
       `JSON file too large (${(raw.length / 1024).toFixed(0)}KB, max ${MAX_RAW_SIZE / 1024}KB). Consider converting to CSV first.`
@@ -2472,7 +2596,7 @@ var dataFileTool = {
         isError: true
       };
     }
-    if (!fs8.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       return {
         toolCallId: "",
         content: `File not found: ${rawPath}`,
@@ -2717,12 +2841,12 @@ function createCronTool(cronService) {
         required: ["action"]
       }
     },
-    execute: async (args, _context) => {
+    execute: async (args, context) => {
       const action = args.action;
       try {
         switch (action) {
           case "list": {
-            const jobs = cronService.list();
+            const jobs = cronService.list(context.workspaceId);
             if (jobs.length === 0) {
               return { toolCallId: "", content: "No cron jobs found." };
             }
@@ -2756,7 +2880,8 @@ function createCronTool(cronService) {
               schedule,
               prompt,
               enabled: args.enabled ?? true,
-              delivery
+              delivery,
+              workspaceId: context.workspaceId
             });
             return {
               toolCallId: "",
@@ -2879,7 +3004,7 @@ function buildSchedule(args) {
 }
 
 // src/agent/tools/artifact.ts
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 import path9 from "path";
 function createArtifactTool(artifactStore) {
   return {
@@ -2932,7 +3057,7 @@ function createArtifactTool(artifactStore) {
           };
         }
         try {
-          content = await fs9.readFile(resolved, "utf-8");
+          content = await fs10.readFile(resolved, "utf-8");
         } catch {
           return {
             toolCallId: "",
@@ -3077,9 +3202,9 @@ async function ensureBrowser() {
     async screenshot() {
       const tmpPath = `${process.env.TEMP || "/tmp"}/ab-screenshot-${Date.now()}.png`;
       await exec2(["screenshot", tmpPath]);
-      const fs20 = await import("fs/promises");
-      const buf = await fs20.readFile(tmpPath);
-      await fs20.unlink(tmpPath).catch(() => {
+      const fs22 = await import("fs/promises");
+      const buf = await fs22.readFile(tmpPath);
+      await fs22.unlink(tmpPath).catch(() => {
       });
       return buf;
     },
@@ -3408,7 +3533,7 @@ ${result.content}`,
 }
 
 // src/agent/tools/subagent.ts
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 
 // src/agent/subagent/types.ts
 var SUBAGENT_DEFAULTS = {
@@ -3545,7 +3670,7 @@ async function executeSpawn(args, context) {
       isError: true
     };
   }
-  const childRunId = crypto3.randomUUID();
+  const childRunId = crypto4.randomUUID();
   const childSessionId = `subagent:${childRunId}`;
   const abortController = new AbortController();
   const record = {
@@ -3675,24 +3800,24 @@ ${lines.join("\n")}` };
 }
 
 // src/agent/tools/skill.ts
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 
 // src/skills/writer.ts
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import path12 from "path";
 
 // src/skills/loader.ts
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 import path11 from "path";
 import matter from "gray-matter";
 
 // src/skills/credential-schema.ts
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 import path10 from "path";
 async function loadCredentialSchema(skillDir) {
   const schemaPath = path10.join(skillDir, "credentials.json");
   try {
-    const raw = await fs10.readFile(schemaPath, "utf-8");
+    const raw = await fs11.readFile(schemaPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.credentials || !Array.isArray(parsed.credentials)) {
       return void 0;
@@ -3775,13 +3900,13 @@ function getEligibleSkills(skills) {
 async function scanSkillDir(dir, source) {
   const skills = [];
   try {
-    const entries = await fs11.readdir(dir, { withFileTypes: true });
+    const entries = await fs12.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const skillDir = path11.join(dir, entry.name);
       const skillMdPath = path11.join(skillDir, "SKILL.md");
       try {
-        const raw = await fs11.readFile(skillMdPath, "utf-8");
+        const raw = await fs12.readFile(skillMdPath, "utf-8");
         const parsed = matter(raw);
         const manifest = parsed.data;
         if (!manifest.name) {
@@ -3792,13 +3917,13 @@ async function scanSkillDir(dir, source) {
         }
         let skillSource = source;
         try {
-          await fs11.access(path11.join(skillDir, ".origin"));
+          await fs12.access(path11.join(skillDir, ".origin"));
           skillSource = "git";
         } catch {
         }
         let hasCodeTools = false;
         try {
-          await fs11.access(path11.join(skillDir, "index.js"));
+          await fs12.access(path11.join(skillDir, "index.js"));
           hasCodeTools = true;
         } catch {
         }
@@ -3945,13 +4070,13 @@ async function createSkill(skillsDir, name, rawContent) {
   if (nameErr) throw new Error(nameErr);
   const skillDir = path12.join(skillsDir, name);
   try {
-    await fs12.access(skillDir);
+    await fs13.access(skillDir);
     throw new Error(`Skill "${name}" already exists`);
   } catch (err) {
     if (err.message.includes("already exists")) throw err;
   }
-  await fs12.mkdir(skillDir, { recursive: true });
-  await fs12.writeFile(path12.join(skillDir, "SKILL.md"), rawContent, "utf-8");
+  await fs13.mkdir(skillDir, { recursive: true });
+  await fs13.writeFile(path12.join(skillDir, "SKILL.md"), rawContent, "utf-8");
   clearSkillCache();
   return { name, path: skillDir };
 }
@@ -3959,17 +4084,17 @@ async function updateSkill(skillsDir, name, rawContent) {
   const skillDir = path12.join(skillsDir, name);
   const skillMdPath = path12.join(skillDir, "SKILL.md");
   try {
-    await fs12.access(skillMdPath);
+    await fs13.access(skillMdPath);
   } catch {
     throw new Error(`Skill "${name}" not found`);
   }
-  await fs12.writeFile(skillMdPath, rawContent, "utf-8");
+  await fs13.writeFile(skillMdPath, rawContent, "utf-8");
   clearSkillCache();
 }
 async function readSkillFile(skillsDir, name) {
   const skillMdPath = path12.join(skillsDir, name, "SKILL.md");
   try {
-    return await fs12.readFile(skillMdPath, "utf-8");
+    return await fs13.readFile(skillMdPath, "utf-8");
   } catch {
     throw new Error(`Skill "${name}" not found`);
   }
@@ -3977,10 +4102,10 @@ async function readSkillFile(skillsDir, name) {
 
 // src/skills/installer.ts
 import { execFile as execFile2 } from "child_process";
-import fs13 from "fs/promises";
+import fs14 from "fs/promises";
 import path13 from "path";
 async function installSkillFromGit(gitUrl, skillsDir) {
-  await fs13.mkdir(skillsDir, { recursive: true });
+  await fs14.mkdir(skillsDir, { recursive: true });
   const repoName = gitUrl.split("/").pop()?.replace(/\.git$/, "");
   if (!repoName) {
     throw new Error(`Invalid git URL: ${gitUrl}`);
@@ -3990,27 +4115,27 @@ async function installSkillFromGit(gitUrl, skillsDir) {
   }
   const targetDir = path13.join(skillsDir, repoName);
   try {
-    await fs13.access(targetDir);
+    await fs14.access(targetDir);
     throw new Error(`Skill "${repoName}" is already installed`);
   } catch (err) {
     if (err.message.includes("already installed")) throw err;
   }
   await execFileAsync("git", ["clone", "--depth", "1", gitUrl, targetDir]);
   try {
-    await fs13.access(path13.join(targetDir, "SKILL.md"));
+    await fs14.access(path13.join(targetDir, "SKILL.md"));
   } catch {
-    await fs13.rm(targetDir, { recursive: true, force: true });
+    await fs14.rm(targetDir, { recursive: true, force: true });
     throw new Error(
       `Invalid skill: no SKILL.md found in ${repoName}`
     );
   }
-  await fs13.writeFile(
+  await fs14.writeFile(
     path13.join(targetDir, ".origin"),
     gitUrl,
     "utf-8"
   );
   try {
-    await fs13.rm(path13.join(targetDir, ".git"), {
+    await fs14.rm(path13.join(targetDir, ".git"), {
       recursive: true,
       force: true
     });
@@ -4023,11 +4148,11 @@ async function installSkillFromGit(gitUrl, skillsDir) {
 async function removeSkill(skillName, skillsDir) {
   const targetDir = path13.join(skillsDir, skillName);
   try {
-    await fs13.access(targetDir);
+    await fs14.access(targetDir);
   } catch {
     throw new Error(`Skill "${skillName}" not found`);
   }
-  await fs13.rm(targetDir, { recursive: true, force: true });
+  await fs14.rm(targetDir, { recursive: true, force: true });
   clearSkillCache();
   logger.info(`Removed skill "${skillName}"`, "skills");
 }
@@ -4119,7 +4244,7 @@ function createSkillTool(userSkillsDir, bundledSkillNames) {
           }
           case "list": {
             try {
-              const entries = await fs14.readdir(userSkillsDir, {
+              const entries = await fs15.readdir(userSkillsDir, {
                 withFileTypes: true
               });
               const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
@@ -4186,22 +4311,23 @@ var builtinTools = [
   memoryReadTool,
   memorySaveTool,
   memoryAppendTool,
+  memorySearchTool,
   showFileTool,
   dataFileTool
 ];
 
 // src/credentials/store.ts
-import crypto4 from "crypto";
-import fs15 from "fs/promises";
+import crypto5 from "crypto";
+import fs16 from "fs/promises";
 import path14 from "path";
 function deriveKey(secret, salt) {
-  return crypto4.scryptSync(secret, salt, 32);
+  return crypto5.scryptSync(secret, salt, 32);
 }
 function encrypt(text, secret) {
-  const salt = crypto4.randomBytes(16);
+  const salt = crypto5.randomBytes(16);
   const key = deriveKey(secret, salt);
-  const iv = crypto4.randomBytes(12);
-  const cipher = crypto4.createCipheriv("aes-256-gcm", key, iv);
+  const iv = crypto5.randomBytes(12);
+  const cipher = crypto5.createCipheriv("aes-256-gcm", key, iv);
   const encrypted = Buffer.concat([
     cipher.update(text, "utf-8"),
     cipher.final()
@@ -4219,7 +4345,7 @@ function decrypt(enc, secret) {
   const key = deriveKey(secret, salt);
   const iv = Buffer.from(enc.iv, "hex");
   const tag = Buffer.from(enc.tag, "hex");
-  const decipher = crypto4.createDecipheriv("aes-256-gcm", key, iv);
+  const decipher = crypto5.createDecipheriv("aes-256-gcm", key, iv);
   decipher.setAuthTag(tag);
   const decrypted = Buffer.concat([
     decipher.update(Buffer.from(enc.data, "hex")),
@@ -4238,7 +4364,7 @@ var EncryptedCredentialStore = class {
   async load() {
     if (this.store) return this.store;
     try {
-      const raw = await fs15.readFile(this.filePath, "utf-8");
+      const raw = await fs16.readFile(this.filePath, "utf-8");
       this.store = JSON.parse(raw);
     } catch {
       this.store = { version: 1, entries: {} };
@@ -4247,13 +4373,13 @@ var EncryptedCredentialStore = class {
   }
   async save() {
     if (!this.store) return;
-    await fs15.mkdir(path14.dirname(this.filePath), { recursive: true });
+    await fs16.mkdir(path14.dirname(this.filePath), { recursive: true });
     const tmp = `${this.filePath}.${process.pid}.tmp`;
-    await fs15.writeFile(tmp, JSON.stringify(this.store, null, 2), {
+    await fs16.writeFile(tmp, JSON.stringify(this.store, null, 2), {
       encoding: "utf-8",
       mode: 384
     });
-    await fs15.rename(tmp, this.filePath);
+    await fs16.rename(tmp, this.filePath);
   }
   async get(key) {
     const store = await this.load();
@@ -4289,11 +4415,11 @@ async function getOrCreateSecret(dataDir) {
   if (secretFromEnv) return secretFromEnv;
   const keyPath = path14.join(dataDir, "master.key");
   try {
-    return await fs15.readFile(keyPath, "utf-8");
+    return await fs16.readFile(keyPath, "utf-8");
   } catch {
-    const key = crypto4.randomBytes(32).toString("hex");
-    await fs15.mkdir(path14.dirname(keyPath), { recursive: true });
-    await fs15.writeFile(keyPath, key, { mode: 384 });
+    const key = crypto5.randomBytes(32).toString("hex");
+    await fs16.mkdir(path14.dirname(keyPath), { recursive: true });
+    await fs16.writeFile(keyPath, key, { mode: 384 });
     return key;
   }
 }
@@ -4303,7 +4429,7 @@ function credentialKey(category, ...parts) {
 
 // src/config/schema.ts
 import { z } from "zod";
-import fs16 from "fs/promises";
+import fs17 from "fs/promises";
 import path15 from "path";
 var providerConfigSchema = z.object({
   model: z.string().optional()
@@ -4329,6 +4455,10 @@ var spendingLimitSchema = z.object({
   maxCostUsd: z.number().nonnegative().optional(),
   period: z.enum(["daily", "weekly", "monthly"]).default("monthly")
 });
+var memoryConfigSchema = z.object({
+  embeddingProvider: z.enum(["local", "openai", "google", "ollama"]).default("local"),
+  embeddingModel: z.string().optional()
+});
 var serverConfigSchema = z.object({
   port: z.number().int().min(1).max(65535).default(3777),
   host: z.string().default("127.0.0.1")
@@ -4353,11 +4483,12 @@ var cortaskConfigSchema = z.object({
   spending: spendingLimitSchema.default({}),
   channels: channelsConfigSchema.default({}),
   skills: skillsConfigSchema.default({}),
+  memory: memoryConfigSchema.default({}),
   server: serverConfigSchema.default({})
 });
 async function loadConfig(configPath) {
   try {
-    const raw = await fs16.readFile(configPath, "utf-8");
+    const raw = await fs17.readFile(configPath, "utf-8");
     const resolved = raw.replace(/\$\{(\w+)\}/g, (_, name) => {
       return process.env[name] ?? "";
     });
@@ -4377,14 +4508,14 @@ async function loadConfig(configPath) {
 }
 async function saveConfig(configPath, config) {
   const dir = path15.dirname(configPath);
-  await fs16.mkdir(dir, { recursive: true });
+  await fs17.mkdir(dir, { recursive: true });
   if (configPath.endsWith(".yaml") || configPath.endsWith(".yml")) {
     const { stringify } = await import("yaml").catch(() => ({
       stringify: (obj) => JSON.stringify(obj, null, 2)
     }));
-    await fs16.writeFile(configPath, stringify(config), "utf-8");
+    await fs17.writeFile(configPath, stringify(config), "utf-8");
   } else {
-    await fs16.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+    await fs17.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
   }
 }
 function getDataDir() {
@@ -4437,7 +4568,7 @@ function getDefaultModel(type) {
 }
 
 // src/workspace/manager.ts
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 import path16 from "path";
 import Database2 from "better-sqlite3";
 var CORTASK_DIR2 = ".cortask";
@@ -4506,12 +4637,12 @@ var WorkspaceManager = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const absPath = rootPath ? path16.resolve(rootPath) : path16.join(this.dataDir, "projects", id);
     const cortaskDir = path16.join(absPath, CORTASK_DIR2);
-    await fs17.mkdir(cortaskDir, { recursive: true });
+    await fs18.mkdir(cortaskDir, { recursive: true });
     const memoryPath = path16.join(cortaskDir, "memory.md");
     try {
-      await fs17.access(memoryPath);
+      await fs18.access(memoryPath);
     } catch {
-      await fs17.writeFile(
+      await fs18.writeFile(
         memoryPath,
         "# Project Memory\n\nThis file is used by Cortask to remember important context about this project.\n",
         "utf-8"
@@ -4576,27 +4707,27 @@ var WorkspaceManager = class {
   async readMemory(workspacePath) {
     const memoryPath = path16.join(workspacePath, CORTASK_DIR2, "memory.md");
     try {
-      return await fs17.readFile(memoryPath, "utf-8");
+      return await fs18.readFile(memoryPath, "utf-8");
     } catch {
       return void 0;
     }
   }
   async writeMemory(workspacePath, content) {
     const memoryPath = path16.join(workspacePath, CORTASK_DIR2, "memory.md");
-    await fs17.mkdir(path16.dirname(memoryPath), { recursive: true });
-    await fs17.writeFile(memoryPath, content, "utf-8");
+    await fs18.mkdir(path16.dirname(memoryPath), { recursive: true });
+    await fs18.writeFile(memoryPath, content, "utf-8");
   }
   async readGlobalMemory(dataDir) {
     const memoryPath = path16.join(dataDir, "memory.md");
     try {
-      return await fs17.readFile(memoryPath, "utf-8");
+      return await fs18.readFile(memoryPath, "utf-8");
     } catch {
       return void 0;
     }
   }
   async writeGlobalMemory(dataDir, content) {
-    await fs17.mkdir(dataDir, { recursive: true });
-    await fs17.writeFile(path16.join(dataDir, "memory.md"), content, "utf-8");
+    await fs18.mkdir(dataDir, { recursive: true });
+    await fs18.writeFile(path16.join(dataDir, "memory.md"), content, "utf-8");
   }
   getSessionDbPath(workspacePath) {
     return path16.join(workspacePath, CORTASK_DIR2, "sessions.db");
@@ -4715,9 +4846,9 @@ var SessionStore = class {
 
 // src/session/migrate.ts
 import Database4 from "better-sqlite3";
-import fs18 from "fs";
+import fs19 from "fs";
 function migrateSessionDatabase(dbPath) {
-  if (!fs18.existsSync(dbPath)) {
+  if (!fs19.existsSync(dbPath)) {
     logger.debug(`Session database does not exist yet: ${dbPath}`, "migration");
     return;
   }
@@ -4799,7 +4930,7 @@ function migrateAllWorkspaces(workspaces) {
 }
 
 // src/skills/tools.ts
-import fs19 from "fs/promises";
+import fs20 from "fs/promises";
 import path17 from "path";
 async function buildSkillTools(skills, credentialStore) {
   const toolDefs = [];
@@ -4930,12 +5061,12 @@ async function executeHttpTool(template, args, skill, credentialStore, workspace
       };
     }
     const tempDir = path17.join(workspacePath, "_temp");
-    await fs19.mkdir(tempDir, { recursive: true });
+    await fs20.mkdir(tempDir, { recursive: true });
     const isJson = looksLikeJson(content);
     const ext = isJson ? "json" : "txt";
     const filename = `${template.name}_${Date.now()}.${ext}`;
     const filePath = path17.join(tempDir, filename);
-    await fs19.writeFile(filePath, content, "utf-8");
+    await fs20.writeFile(filePath, content, "utf-8");
     const summary = buildResponseSummary(content, isJson);
     return {
       toolCallId: "",
@@ -5120,7 +5251,7 @@ async function revokeSkillOAuth2(skillName, credentialId, credentialStore) {
 }
 
 // src/cron/service.ts
-import crypto5 from "crypto";
+import crypto6 from "crypto";
 import Database5 from "better-sqlite3";
 var MAX_TIMER_DELAY_MS = 6e4;
 var MIN_REFIRE_GAP_MS = 2e3;
@@ -5288,7 +5419,7 @@ var CronService = class {
   }
   // CRUD
   add(input) {
-    const id = crypto5.randomUUID();
+    const id = crypto6.randomUUID();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const job = {
       id,
@@ -5460,13 +5591,13 @@ function rowToJob(row) {
 }
 
 // src/artifacts/store.ts
-import crypto6 from "crypto";
+import crypto7 from "crypto";
 var TTL_MS = 24 * 60 * 60 * 1e3;
 var ArtifactStore = class {
   store = /* @__PURE__ */ new Map();
   create(type, title, content) {
     this.pruneExpired();
-    const id = crypto6.randomUUID();
+    const id = crypto7.randomUUID();
     const mimeType = getMimeType(type);
     const artifact = {
       id,
@@ -5765,6 +5896,449 @@ var TemplateStore = class {
     this.db.prepare("DELETE FROM prompt_templates WHERE id = ?").run(id);
   }
 };
+
+// src/memory/manager.ts
+import crypto9 from "crypto";
+
+// src/memory/store.ts
+import fs21 from "fs";
+import path18 from "path";
+import Database9 from "better-sqlite3";
+var MemoryStore = class {
+  db;
+  ftsAvailable = false;
+  constructor(dbPath) {
+    const dir = path18.dirname(dbPath);
+    if (!fs21.existsSync(dir)) {
+      fs21.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database9(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.init();
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS chunks (
+        id TEXT PRIMARY KEY,
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'manual',
+        session_id TEXT,
+        created_at TEXT NOT NULL,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        provider_model TEXT
+      );
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS embedding_cache (
+        content_hash TEXT PRIMARY KEY,
+        provider_model TEXT NOT NULL,
+        embedding BLOB NOT NULL,
+        created_at TEXT NOT NULL
+      );
+    `);
+    try {
+      this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+          id UNINDEXED,
+          content,
+          source UNINDEXED,
+          content='chunks',
+          content_rowid='rowid'
+        );
+      `);
+      this.ftsAvailable = true;
+    } catch {
+      this.ftsAvailable = false;
+    }
+    if (this.ftsAvailable) {
+      this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+          INSERT INTO chunks_fts(rowid, id, content, source)
+          VALUES (new.rowid, new.id, new.content, new.source);
+        END;
+        CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+          INSERT INTO chunks_fts(chunks_fts, rowid, id, content, source)
+          VALUES ('delete', old.rowid, old.id, old.content, old.source);
+        END;
+        CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
+          INSERT INTO chunks_fts(chunks_fts, rowid, id, content, source)
+          VALUES ('delete', old.rowid, old.id, old.content, old.source);
+          INSERT INTO chunks_fts(rowid, id, content, source)
+          VALUES (new.rowid, new.id, new.content, new.source);
+        END;
+      `);
+    }
+  }
+  insertChunk(chunk) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO chunks (id, content, source, session_id, created_at, metadata, provider_model)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      chunk.id,
+      chunk.content,
+      chunk.source,
+      chunk.session_id,
+      chunk.created_at,
+      chunk.metadata,
+      chunk.provider_model
+    );
+  }
+  insertChunks(chunks) {
+    const insert = this.db.prepare(
+      `INSERT OR REPLACE INTO chunks (id, content, source, session_id, created_at, metadata, provider_model)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    );
+    const tx = this.db.transaction((items) => {
+      for (const chunk of items) {
+        insert.run(
+          chunk.id,
+          chunk.content,
+          chunk.source,
+          chunk.session_id,
+          chunk.created_at,
+          chunk.metadata,
+          chunk.provider_model
+        );
+      }
+    });
+    tx(chunks);
+  }
+  searchFTS(query, limit) {
+    if (!this.ftsAvailable) return [];
+    const sanitized = query.replace(/[^\w\s]/g, " ").trim();
+    if (!sanitized) return [];
+    const ftsQuery = sanitized.split(/\s+/).filter(Boolean).map((w) => `"${w}"`).join(" OR ");
+    try {
+      return this.db.prepare(
+        `SELECT id, content, source, rank
+           FROM chunks_fts
+           WHERE chunks_fts MATCH ?
+           ORDER BY rank
+           LIMIT ?`
+      ).all(ftsQuery, limit);
+    } catch {
+      return [];
+    }
+  }
+  getChunk(id) {
+    return this.db.prepare("SELECT * FROM chunks WHERE id = ?").get(id) ?? null;
+  }
+  listRecent(limit) {
+    return this.db.prepare("SELECT * FROM chunks ORDER BY created_at DESC LIMIT ?").all(limit);
+  }
+  getAllChunks() {
+    return this.db.prepare("SELECT * FROM chunks").all();
+  }
+  deleteChunk(id) {
+    this.db.prepare("DELETE FROM chunks WHERE id = ?").run(id);
+  }
+  clearAll() {
+    this.db.exec("DELETE FROM chunks");
+    if (this.ftsAvailable) {
+      this.db.exec("DELETE FROM chunks_fts");
+    }
+    this.db.exec("DELETE FROM embedding_cache");
+  }
+  clearEmbeddings() {
+    this.db.exec("DELETE FROM embedding_cache");
+  }
+  getCachedEmbedding(contentHash, providerModel) {
+    const row = this.db.prepare(
+      "SELECT embedding FROM embedding_cache WHERE content_hash = ? AND provider_model = ?"
+    ).get(contentHash, providerModel);
+    if (!row) return null;
+    return Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4));
+  }
+  setCachedEmbedding(contentHash, providerModel, embedding) {
+    const buffer = Buffer.from(new Float32Array(embedding).buffer);
+    this.db.prepare(
+      `INSERT OR REPLACE INTO embedding_cache (content_hash, provider_model, embedding, created_at)
+         VALUES (?, ?, ?, ?)`
+    ).run(contentHash, providerModel, buffer, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  get isFTSAvailable() {
+    return this.ftsAvailable;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/memory/embeddings.ts
+import crypto8 from "crypto";
+var DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+var EmbeddingService = class {
+  apiProvider;
+  localProvider;
+  model;
+  store;
+  constructor(opts) {
+    this.apiProvider = opts.apiProvider ?? null;
+    this.localProvider = opts.localProvider ?? null;
+    this.model = opts.model ?? DEFAULT_EMBEDDING_MODEL;
+    this.store = opts.store;
+  }
+  get providerId() {
+    if (this.localProvider) return "local";
+    return this.apiProvider?.id ?? "unknown";
+  }
+  async embed(texts) {
+    const results = new Array(texts.length).fill(null);
+    const toEmbed = [];
+    for (let i = 0; i < texts.length; i++) {
+      const hash = this.hashContent(texts[i]);
+      const cached = this.store.getCachedEmbedding(hash, this.providerModel);
+      if (cached) {
+        results[i] = cached;
+      } else {
+        toEmbed.push({ index: i, text: texts[i] });
+      }
+    }
+    if (toEmbed.length > 0) {
+      const embeddings = await this.generateEmbeddings(
+        toEmbed.map((t) => t.text)
+      );
+      for (let i = 0; i < toEmbed.length; i++) {
+        const embedding = embeddings[i];
+        const entry = toEmbed[i];
+        results[entry.index] = embedding;
+        const hash = this.hashContent(entry.text);
+        this.store.setCachedEmbedding(hash, this.providerModel, embedding);
+      }
+    }
+    return results;
+  }
+  async embedSingle(text) {
+    const [result] = await this.embed([text]);
+    return result;
+  }
+  async generateEmbeddings(texts) {
+    if (this.localProvider) {
+      return this.localProvider.embedBatch(texts);
+    }
+    if (this.apiProvider) {
+      const result = await this.apiProvider.embed({
+        model: this.model,
+        inputs: texts
+      });
+      return result.embeddings;
+    }
+    throw new Error("No embedding provider available");
+  }
+  get providerModel() {
+    if (this.localProvider) {
+      return `local:${this.localProvider.model}`;
+    }
+    return `${this.apiProvider?.id ?? "unknown"}:${this.model}`;
+  }
+  hashContent(content) {
+    return crypto8.createHash("sha256").update(content).digest("hex");
+  }
+};
+
+// src/memory/search.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+function bm25RankToScore(rank) {
+  return 1 / (1 + Math.abs(rank));
+}
+async function hybridSearch(store, embeddingService, query, limit) {
+  const resultMap = /* @__PURE__ */ new Map();
+  const ftsResults = store.searchFTS(query, limit * 2);
+  for (const fts of ftsResults) {
+    const entry = chunkToEntry(store.getChunk(fts.id));
+    if (!entry) continue;
+    resultMap.set(fts.id, {
+      entry,
+      score: bm25RankToScore(fts.rank),
+      matchType: "fts"
+    });
+  }
+  if (embeddingService) {
+    try {
+      const queryEmbedding = await embeddingService.embedSingle(query);
+      const allChunks = store.getAllChunks();
+      if (allChunks.length > 0) {
+        const chunkTexts = allChunks.map((c) => c.content);
+        const embeddings = await embeddingService.embed(chunkTexts);
+        const scored = [];
+        for (let i = 0; i < allChunks.length; i++) {
+          scored.push({
+            id: allChunks[i].id,
+            score: cosineSimilarity(queryEmbedding, embeddings[i])
+          });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        for (const item of scored.slice(0, limit * 2)) {
+          const existing = resultMap.get(item.id);
+          if (existing) {
+            existing.score = Math.max(existing.score, item.score);
+            existing.matchType = "hybrid";
+          } else {
+            const entry = chunkToEntry(store.getChunk(item.id));
+            if (entry) {
+              resultMap.set(item.id, {
+                entry,
+                score: item.score,
+                matchType: "vector"
+              });
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(resultMap.values()).sort((a, b) => b.score - a.score).slice(0, limit);
+}
+function chunkToEntry(chunk) {
+  if (!chunk) return null;
+  return {
+    id: chunk.id,
+    content: chunk.content,
+    source: chunk.source,
+    sessionId: chunk.session_id ?? void 0,
+    createdAt: chunk.created_at,
+    metadata: JSON.parse(chunk.metadata)
+  };
+}
+
+// src/memory/manager.ts
+var MemoryManager = class {
+  store;
+  embeddingService = null;
+  constructor(opts) {
+    this.store = new MemoryStore(opts.dbPath);
+    if (opts.localProvider) {
+      this.embeddingService = new EmbeddingService({
+        localProvider: opts.localProvider,
+        store: this.store
+      });
+    } else if (opts.apiProvider) {
+      this.embeddingService = new EmbeddingService({
+        apiProvider: opts.apiProvider,
+        model: opts.embeddingModel,
+        store: this.store
+      });
+    }
+  }
+  async index(entries) {
+    const chunks = entries.map((e) => ({
+      id: e.id || crypto9.randomUUID(),
+      content: e.content,
+      source: e.source,
+      session_id: e.sessionId ?? null,
+      created_at: e.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: JSON.stringify(e.metadata || {}),
+      provider_model: null
+    }));
+    this.store.insertChunks(chunks);
+    if (this.embeddingService && chunks.length > 0) {
+      try {
+        await this.embeddingService.embed(chunks.map((c) => c.content));
+      } catch {
+      }
+    }
+  }
+  async search(query, limit = 5) {
+    return hybridSearch(this.store, this.embeddingService, query, limit);
+  }
+  async list(limit = 20) {
+    const rows = this.store.listRecent(limit);
+    return rows.map((row) => ({
+      id: row.id,
+      content: row.content,
+      source: row.source,
+      sessionId: row.session_id ?? void 0,
+      createdAt: row.created_at,
+      metadata: JSON.parse(row.metadata)
+    }));
+  }
+  async delete(id) {
+    this.store.deleteChunk(id);
+  }
+  async clearEmbeddings() {
+    this.store.clearEmbeddings();
+  }
+  async clear() {
+    this.store.clearAll();
+  }
+  close() {
+    this.store.close();
+  }
+};
+
+// src/memory/embeddings-local.ts
+var DEFAULT_LOCAL_MODEL = "hf:ggml-org/embeddinggemma-300m-qat-q8_0-GGUF/embeddinggemma-300m-qat-Q8_0.gguf";
+function normalizeEmbedding(vec) {
+  const sanitized = vec.map((v) => Number.isFinite(v) ? v : 0);
+  const magnitude = Math.sqrt(
+    sanitized.reduce((sum, v) => sum + v * v, 0)
+  );
+  if (magnitude < 1e-10) return sanitized;
+  return sanitized.map((v) => v / magnitude);
+}
+async function createLocalEmbeddingProvider(modelPath) {
+  const resolvedPath = modelPath?.trim() || DEFAULT_LOCAL_MODEL;
+  const { getLlama, resolveModelFile, LlamaLogLevel } = await import("node-llama-cpp");
+  let llama = null;
+  let model = null;
+  let context = null;
+  const ensureContext = async () => {
+    if (!llama) {
+      llama = await getLlama({ logLevel: LlamaLogLevel.error });
+    }
+    if (!model) {
+      const resolved = await resolveModelFile(resolvedPath);
+      model = await llama.loadModel({ modelPath: resolved });
+    }
+    if (!context) {
+      context = await model.createEmbeddingContext();
+    }
+    return context;
+  };
+  return {
+    id: "local",
+    model: resolvedPath,
+    async embedQuery(text) {
+      const ctx = await ensureContext();
+      const embedding = await ctx.getEmbeddingFor(text);
+      return normalizeEmbedding(Array.from(embedding.vector));
+    },
+    async embedBatch(texts) {
+      const ctx = await ensureContext();
+      const results = await Promise.all(
+        texts.map(async (text) => {
+          const embedding = await ctx.getEmbeddingFor(text);
+          return normalizeEmbedding(Array.from(embedding.vector));
+        })
+      );
+      return results;
+    },
+    dispose() {
+      if (context) {
+        context.dispose?.();
+        context = null;
+      }
+      if (model) {
+        model.dispose?.();
+        model = null;
+      }
+      llama = null;
+    }
+  };
+}
 export {
   AVAILABLE_PROVIDERS,
   AgentRunner,
@@ -5775,6 +6349,7 @@ export {
   GoogleProvider,
   GrokProvider,
   MODEL_DEFINITIONS,
+  MemoryManager,
   MiniMaxProvider,
   ModelStore,
   MoonshotProvider,
@@ -5802,6 +6377,7 @@ export {
   createArtifactTool,
   createBrowserTool,
   createCronTool,
+  createLocalEmbeddingProvider,
   createProvider,
   createSkill,
   createSkillTool,