micro-models-agent 0.16.8 → 0.18.0

package/dist/cli/repl.js

@@ -161,17 +161,16 @@ export class Repl {
                     const { resolve } = await import("path");
                     let dataUrl;
                     let label;
-                    let warning;
                     if (source.toLowerCase() === "clipboard") {
-                        const clipPath = await readClipboardImage();
-                        if (!clipPath) {
+                        const clipBuf = await readClipboardImage();
+                        if (!clipBuf) {
                             console.log(pc.yellow(t("image.clipboard_empty")));
                             return;
                         }
-                        const result = loadFileAsDataUrl(clipPath);
+                        const { bufferToDataUrl } = await import("../llm/image-utils");
+                        const result = await bufferToDataUrl(clipBuf);
                         dataUrl = result.dataUrl;
                         label = "clipboard";
-                        warning = result.warning;
                     }
                     else if (source.startsWith("http://") || source.startsWith("https://")) {
                         const result = await loadUrlAsDataUrl(source);
@@ -184,10 +183,9 @@ export class Repl {
                             console.log(pc.red(t("image.not_found", { path: source })));
                             return;
                         }
-                        const result = loadFileAsDataUrl(absPath);
+                        const result = await loadFileAsDataUrl(absPath);
                         dataUrl = result.dataUrl;
                         label = source;
-                        warning = result.warning;
                     }
                     // Store the image data on the agent's context manager for the next message
                     const contextManager = this.agent.contextManager;
@@ -201,8 +199,6 @@ export class Repl {
                     });
                     const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
                     console.log(pc.green(t("image.attached", { source: label, size: `${sizeKb} KB` })));
-                    if (warning)
-                        console.log(pc.yellow(`  ${warning}`));
                 }
                 catch (err) {
                     console.log(pc.red(t("image.error", { message: err.message })));
@@ -760,15 +756,13 @@ export class Repl {
                 // Ctrl+V: try to paste image from clipboard
                 if (key.ctrl && key.name === "v" && !this.agentRunning) {
                     try {
-                        const { readClipboardImage, loadFileAsDataUrl } = await import("../llm/image-utils");
-                        const clipPath = await readClipboardImage();
-                        if (clipPath) {
-                            const { dataUrl, warning } = loadFileAsDataUrl(clipPath);
+                        const { readClipboardImage, bufferToDataUrl } = await import("../llm/image-utils");
+                        const clipBuf = await readClipboardImage();
+                        if (clipBuf) {
+                            const { dataUrl } = await bufferToDataUrl(clipBuf);
                             this.pendingClipboardImage = dataUrl;
                             const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
                             console.log(pc.green(`\n${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
-                            if (warning)
-                                console.log(pc.yellow(`  ${warning}`));
                             this.rl.prompt();
                         }
                     }

package/dist/core/bootstrap.js

@@ -19,6 +19,7 @@ import { SkillsLoader, SkillsMatcher, SkillsModule, } from "../modules/skills/in
 import { BrowserModule } from "../modules/browser/index";
 import { IndexerModule } from "../modules/indexer/index";
 import { MCPModule } from "../modules/mcp/index";
+import { MemoryModule } from "../modules/memory/module";
 import { setLocale } from "../i18n/index";
 import { Agent } from "./agent";
 import { homedir } from "os";
@@ -202,6 +203,8 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     const mcpModule = new MCPModule(config);
     await mcpModule.initialize();
     moduleRegistry.register(mcpModule);
+    const memoryModule = new MemoryModule(join(dir, 'memory'));
+    moduleRegistry.register(memoryModule);
     if (config.browser.enabled) {
         const browserModule = new BrowserModule();
         moduleRegistry.register(browserModule);

package/dist/i18n/en.json

@@ -120,6 +120,7 @@
     "tool.no_history": "No history entries matching \"{query}\"",
     "tool.no_sessions_dir": "No sessions directory found at {dir}",
     "tool.history_error": "Error searching history: {error}",
+    "tool.memory_error": "Memory error: {error}",
     "tool.screenshot_unavailable": "[Screenshot captured \u2014 image not available for text-only model]",
     "tool.timeout": "Tool {name} timed out after {seconds} seconds",
     "tool.interactive_disabled": "Interactive tool is disabled in exit-on-complete mode. Proceed without asking the user.",
@@ -447,5 +448,14 @@
     "image.error": "Failed to load image: {message}",
     "tool.friendly.attach_image": "Attach image",
     "repl.image": "Attach image",
-    "repl.image_usage": "/image <path|url|clipboard> — attach an image to the next message"
+    "repl.image_usage": "/image <path|url|clipboard> — attach an image to the next message",
+    "tool.friendly.remember": "Remember",
+    "tool.friendly.recall": "Recall",
+    "tool.remember.preference": "Remembered: {key} = {value}",
+    "tool.remember.entry": "Remembered: {category} — \"{entry}\"",
+    "tool.remember.key_required": "Key is required for preferences",
+    "tool.remember.entry_required": "Entry text is required",
+    "tool.recall.empty": "Nothing found for \"{query}\"",
+    "tool.recall.no_memory": "Memory is empty",
+    "tool.recall.search_results": "{category} results:\n{results}"
 }

package/dist/i18n/ru.json

@@ -120,6 +120,7 @@
     "tool.no_history": "Нет записей истории по \"{query}\"",
     "tool.no_sessions_dir": "Каталог сессий не найден по {dir}",
     "tool.history_error": "Ошибка поиска истории: {error}",
+    "tool.memory_error": "Ошибка памяти: {error}",
     "tool.screenshot_unavailable": "[Скриншот сделан — изображение недоступно для текстовой модели]",
     "tool.timeout": "Инструмент {name} превысил таймаут ({seconds} сек)",
     "tool.interactive_disabled": "Интерактивный инструмент отключён в режиме exit-on-complete. Продолжай без вопроса пользователю.",
@@ -447,5 +448,14 @@
     "image.error": "Не удалось загрузить изображение: {message}",
     "tool.friendly.attach_image": "Прикрепить изображение",
     "repl.image": "Прикрепить изображение",
-    "repl.image_usage": "/image <путь|URL|clipboard> — прикрепить изображение к следующему сообщению"
+    "repl.image_usage": "/image <путь|URL|clipboard> — прикрепить изображение к следующему сообщению",
+    "tool.friendly.remember": "Запомнить",
+    "tool.friendly.recall": "Вспомнить",
+    "tool.remember.preference": "Запомнено: {key} = {value}",
+    "tool.remember.entry": "Запомнено: {category} — \"{entry}\"",
+    "tool.remember.key_required": "Для preferences требуется ключ (key)",
+    "tool.remember.entry_required": "Требуется текст записи",
+    "tool.recall.empty": "Ничего не найдено по \"{query}\"",
+    "tool.recall.no_memory": "Память пуста",
+    "tool.recall.search_results": "Результаты {category}:\n{results}"
 }

package/dist/llm/image-utils.js

@@ -9,97 +9,136 @@ const MIME_MAP = {
     ".bmp": "image/bmp",
     ".svg": "image/svg+xml",
 };
-/**
- * Detect MIME type from file extension.
- */
+/** Detect MIME type from file extension. */
 export function detectMime(filePath) {
     const ext = extname(filePath).toLowerCase();
     return MIME_MAP[ext] ?? "image/png";
 }
 /**
- * Load an image from a file path and return as base64 data URL.
- * Resizes if raw data exceeds maxBytes. Default max: 50KB (~16K tokens in base64).
+ * Read image from system clipboard using Bun.Image (macOS/Windows).
+ * Falls back to platform-specific commands on Linux.
+ * Returns null if clipboard has no image.
  */
-export function loadFileAsDataUrl(filePath, maxBytes = 50 * 1024) {
-    const mime = detectMime(filePath);
-    let buf = readFileSync(filePath);
-    let resized = false;
-    let warning;
-    if (buf.length > maxBytes) {
-        const ratio = maxBytes / buf.length;
-        warning = `Image ${Math.round(buf.length / 1024)}KB exceeds ${Math.round(maxBytes / 1024)}KB limit — resized to ~${Math.round(maxBytes / 1024)}KB (quality may reduce). Tip: crop the image before pasting.`;
-        buf = buf.subarray(0, maxBytes); // naive truncation — better than nothing
-        resized = true;
+export async function readClipboardImage() {
+    // Bun.Image.fromClipboard() works on macOS and Windows
+    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+        try {
+            const img = Bun.Image.fromClipboard();
+            if (img) {
+                const buf = await img
+                    .resize(800, 800, { fit: "inside" })
+                    .jpeg({ quality: 60 })
+                    .buffer();
+                return Buffer.from(buf);
+            }
+        }
+        catch {
+            // Bun.Image.fromClipboard() failed — fall through to platform fallback
+        }
     }
+    // Linux fallback: xclip/wl-paste → temp file → read
+    return readClipboardFallback();
+}
+async function readClipboardFallback() {
+    const { platform } = await import("os");
+    const { execSync } = await import("child_process");
+    const { readFileSync, unlinkSync } = await import("fs");
+    const { join } = await import("path");
+    const tmpPath = join(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
+    try {
+        if (platform() === "linux") {
+            execSync(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, { timeout: 5000 });
+        }
+        else {
+            return null; // macOS/Windows should use Bun.Image
+        }
+        const buf = readFileSync(tmpPath);
+        unlinkSync(tmpPath);
+        return buf.length > 0 ? buf : null;
+    }
+    catch {
+        try {
+            unlinkSync(tmpPath);
+        }
+        catch { }
+        return null;
+    }
+}
+/**
+ * Load an image from a file path, resize via Bun.Image, return as JPEG data URL.
+ * Target: ~800px wide, JPEG quality 60 — typically 5-15KB (~2-4K tokens).
+ */
+export async function loadFileAsDataUrl(filePath) {
+    const buf = readFileSync(filePath);
+    // Use Bun.Image if available — resize + convert to JPEG
+    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+        try {
+            const img = new Bun.Image(buf);
+            const { width } = await img.metadata();
+            const targetWidth = Math.min(800, width || 800);
+            const dataUrl = await img
+                .resize(targetWidth, 800, { fit: "inside" })
+                .jpeg({ quality: 60 })
+                .dataurl();
+            return { dataUrl };
+        }
+        catch {
+            // Bun.Image failed — fall through to raw base64
+        }
+    }
+    // Fallback: raw base64 (no resize)
     const b64 = buf.toString("base64");
-    return { dataUrl: `data:${mime};base64,${b64}`, mime, resized, warning };
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    const mime = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "webp" ? "image/webp" : "image/png";
+    return { dataUrl: `data:${mime};base64,${b64}` };
 }
 /**
- * Load an image from a URL, return as base64 data URL.
+ * Load an image from a URL, resize, return as JPEG data URL.
  */
 export async function loadUrlAsDataUrl(url) {
     const resp = await fetch(url);
     if (!resp.ok) {
         throw new Error(`Failed to fetch image: ${resp.status} ${resp.statusText}`);
     }
-    const contentType = resp.headers.get("content-type") ?? "image/png";
-    const mime = contentType.split(";")[0].trim();
     const buf = Buffer.from(await resp.arrayBuffer());
+    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+        try {
+            const img = new Bun.Image(buf);
+            const { width } = await img.metadata();
+            const targetWidth = Math.min(800, width || 800);
+            const dataUrl = await img
+                .resize(targetWidth, 800, { fit: "inside" })
+                .jpeg({ quality: 60 })
+                .dataurl();
+            return { dataUrl };
+        }
+        catch {
+            // fall through
+        }
+    }
     const b64 = buf.toString("base64");
-    return { dataUrl: `data:${mime};base64,${b64}`, mime };
+    return { dataUrl: `data:image/png;base64,${b64}` };
 }
 /**
- * Read image from system clipboard (platform-specific).
- * Returns null if clipboard has no image.
+ * Process a clipboard buffer (already resized by readClipboardImage)
+ * into a data URL. Used by Ctrl+V handler.
  */
-export async function readClipboardImage() {
-    const { platform } = await import("os");
-    if (platform() === "win32") {
-        return readClipboardWindows();
-    }
-    if (platform() === "darwin") {
-        return readClipboardMacos();
-    }
-    return readClipboardLinux();
-}
-async function readClipboardWindows() {
-    try {
-        const { execSync } = await import("child_process");
-        const tmpPath = `${process.env.TEMP || process.env.TMP || "/tmp"}\\mma-clip-${Date.now()}.png`;
-        // Use single quotes in PowerShell to avoid backslash issues
-        const psScript = `Add-Type -AssemblyName System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img -ne $null) { $img.Save('${tmpPath}'); Write-Output 'OK' } else { Write-Output 'EMPTY' }`;
-        const out = execSync(`powershell -NoProfile -Command "${psScript}"`, {
-            timeout: 5000,
-            encoding: "utf-8",
-        });
-        if (out.includes("OK")) {
-            return tmpPath;
+export async function bufferToDataUrl(buf) {
+    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+        try {
+            const img = new Bun.Image(buf);
+            const { width } = await img.metadata();
+            const targetWidth = Math.min(800, width || 800);
+            const dataUrl = await img
+                .resize(targetWidth, 800, { fit: "inside" })
+                .jpeg({ quality: 60 })
+                .dataurl();
+            return { dataUrl };
+        }
+        catch {
+            // fall through
         }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-async function readClipboardMacos() {
-    try {
-        const { execSync } = await import("child_process");
-        const tmpPath = `/tmp/mma-clip-${Date.now()}.png`;
-        execSync(`pngpaste "${tmpPath}"`, { timeout: 5000 });
-        return tmpPath;
-    }
-    catch {
-        return null;
-    }
-}
-async function readClipboardLinux() {
-    try {
-        const { execSync } = await import("child_process");
-        const tmpPath = `/tmp/mma-clip-${Date.now()}.png`;
-        execSync(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, { timeout: 5000 });
-        return tmpPath;
-    }
-    catch {
-        return null;
     }
+    const b64 = buf.toString("base64");
+    return { dataUrl: `data:image/png;base64,${b64}` };
 }

package/dist/modules/memory/module.js

@@ -0,0 +1,48 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { MemoryStore } from './store';
+import { rememberTool } from '../../tools/remember';
+import { recallTool } from '../../tools/recall';
+export class MemoryModule {
+    name = 'memory';
+    store;
+    constructor(memoryDir) {
+        const dir = memoryDir || join(homedir(), '.mma', 'memory');
+        this.store = new MemoryStore(dir);
+    }
+    getSystemPromptBlock() {
+        const prefs = this.store.getPreferences();
+        if (Object.keys(prefs).length === 0)
+            return null;
+        const prefStr = Object.entries(prefs)
+            .map(([k, v]) => `${k}=${v}`)
+            .join(', ');
+        return {
+            content: `User preferences: ${prefStr}`,
+            priority: 'normal',
+            essential: false,
+            estimatedTokens: Math.ceil(prefStr.length / 4) + 10,
+        };
+    }
+    getToolDefinitions() {
+        return [rememberTool, recallTool];
+    }
+    getPlugin() {
+        return {
+            name: 'memory',
+            isBuiltin: true,
+            onBuildPrompt: () => {
+                const prefs = this.store.getPreferences();
+                if (Object.keys(prefs).length === 0)
+                    return null;
+                const prefStr = Object.entries(prefs)
+                    .map(([k, v]) => `${k}=${v}`)
+                    .join(', ');
+                return `User preferences: ${prefStr}`;
+            },
+        };
+    }
+    getStore() {
+        return this.store;
+    }
+}

package/dist/modules/memory/search.js

@@ -1,6 +1,6 @@
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
-const MEMORY_FILES = ['conventions', 'decisions', 'errors'];
+const MEMORY_FILES = ['conventions', 'decisions', 'errors', 'facts'];
 export class MemorySearch {
     memoryDir;
     constructor(memoryDir) {
@@ -21,6 +21,20 @@ export class MemorySearch {
                 }
             }
         }
+        // Search preferences.json
+        const prefsPath = join(this.memoryDir, 'preferences.json');
+        if (existsSync(prefsPath)) {
+            try {
+                const prefs = JSON.parse(readFileSync(prefsPath, 'utf-8'));
+                for (const [key, value] of Object.entries(prefs)) {
+                    const searchStr = `${key}=${value}`;
+                    if (searchStr.toLowerCase().includes(lowerQuery)) {
+                        results.push({ file: 'preferences', match: `${key} = ${value}` });
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
         return results;
     }
 }

package/dist/modules/memory/store.js

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { MemorySearch } from './search';
-const MEMORY_FILES = ['conventions', 'decisions', 'errors'];
+const MEMORY_FILES = ['conventions', 'decisions', 'errors', 'facts'];
 export class MemoryStore {
     memoryDir;
     constructor(memoryDir) {
@@ -35,4 +35,31 @@ export class MemoryStore {
         const searchModule = new MemorySearch(this.memoryDir);
         return searchModule.query(query);
     }
+    prefsPath() {
+        return join(this.memoryDir, 'preferences.json');
+    }
+    getPreferences() {
+        const path = this.prefsPath();
+        if (!existsSync(path))
+            return {};
+        try {
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    setPreference(key, value) {
+        const prefs = this.getPreferences();
+        prefs[key] = value;
+        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), 'utf-8');
+    }
+    deletePreference(key) {
+        const prefs = this.getPreferences();
+        if (!(key in prefs))
+            return false;
+        delete prefs[key];
+        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), 'utf-8');
+        return true;
+    }
 }

package/dist/tools/attach-image.js

@@ -1,9 +1,8 @@
 import { existsSync } from "fs";
 import { resolve } from "path";
 import { t } from "../i18n/index";
-import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage } from "../llm/image-utils";
+import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage, bufferToDataUrl } from "../llm/image-utils";
 import { logSecurityBlock } from "../modules/security/audit-log";
-const MAX_IMAGE_BYTES = 10 * 1024 * 1024; // 10 MB
 export const attachImageTool = {
     name: "attach_image",
     description: "Attach an image to the conversation from a file path, URL, or clipboard. The image will be included in the next message sent to the model. Supports PNG, JPEG, GIF, WebP.",
@@ -26,14 +25,14 @@ export const attachImageTool = {
         try {
             let dataUrl;
             if (source.toLowerCase() === "clipboard") {
-                const clipPath = await readClipboardImage();
-                if (!clipPath) {
+                const clipBuf = await readClipboardImage();
+                if (!clipBuf) {
                     return {
                         success: false,
                         output: t("image.clipboard_empty"),
                     };
                 }
-                const result = loadFileAsDataUrl(clipPath, MAX_IMAGE_BYTES);
+                const result = await bufferToDataUrl(clipBuf);
                 dataUrl = result.dataUrl;
             }
             else if (source.startsWith("http://") || source.startsWith("https://")) {
@@ -60,7 +59,7 @@ export const attachImageTool = {
                         };
                     }
                 }
-                const result = loadFileAsDataUrl(absPath, MAX_IMAGE_BYTES);
+                const result = await loadFileAsDataUrl(absPath);
                 dataUrl = result.dataUrl;
             }
             // Add the image as a pending content part on the context manager

package/dist/tools/index.js

@@ -24,11 +24,13 @@ import { createLoadSkillTool } from './load-skill';
 import { pipelineRunTool } from './pipeline-run';
 import { mcpCallTool } from './mcp-call';
 import { searchHistoryTool } from './search-history';
+import { rememberTool } from './remember';
+import { recallTool } from './recall';
 import { createBrowserTool } from './browser';
 import { attachImageTool } from './attach-image';
 export { ToolRegistry, ToolExecutor };
 export { filterToolsByTags } from './filter-tools';
-export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, createBrowserTool, attachImageTool, };
+export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, };
 export function registerAllTools(registry, skillsModule) {
     const tools = [
         readFileTool, writeFileTool, editFileTool,

package/dist/tools/recall.js

@@ -0,0 +1,110 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { t } from '../i18n/index';
+import { MemoryStore } from '../modules/memory/store';
+const CATEGORIES = ['preferences', 'conventions', 'decisions', 'errors', 'facts'];
+export const recallTool = {
+    name: 'recall',
+    description: 'Recall stored information from memory. Search across preferences, facts, conventions, decisions, errors.',
+    tags: ['memory'],
+    parameters: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Search query (full-text search across all memory)',
+            },
+            category: {
+                type: 'string',
+                description: 'Limit to specific category: preferences, conventions, decisions, errors, facts',
+                enum: CATEGORIES,
+            },
+        },
+    },
+    handler: async (_ctx, args) => {
+        const query = args.query ? String(args.query) : '';
+        const category = args.category ? String(args.category) : '';
+        const memoryDir = join(homedir(), '.mma', 'memory');
+        const store = new MemoryStore(memoryDir);
+        try {
+            // No query, no category → show everything
+            if (!query && !category) {
+                return { success: true, output: formatAll(store) };
+            }
+            // Category only → show that category
+            if (!query && category) {
+                return { success: true, output: formatCategory(store, category) };
+            }
+            // Query with optional category → search
+            if (category) {
+                const results = searchCategory(store, category, query);
+                if (results.length === 0) {
+                    return { success: true, output: t('tool.recall.empty', { query }) };
+                }
+                return { success: true, output: t('tool.recall.search_results', { category, results: results.join('\n') }) };
+            }
+            // Query across all
+            const results = store.search(query);
+            if (results.length === 0) {
+                return { success: true, output: t('tool.recall.empty', { query }) };
+            }
+            const formatted = results.map(r => `[${r.file}] ${r.match}`).join('\n');
+            return { success: true, output: t('tool.recall.search_results', { category: 'all', results: formatted }) };
+        }
+        catch (err) {
+            return { success: true, output: t('tool.memory_error', { error: String(err) }) };
+        }
+    },
+};
+function formatAll(store) {
+    const parts = [];
+    const prefs = store.getPreferences();
+    if (Object.keys(prefs).length > 0) {
+        parts.push('Preferences:');
+        for (const [k, v] of Object.entries(prefs)) {
+            parts.push(`  ${k} = ${v}`);
+        }
+    }
+    for (const cat of ['facts', 'conventions', 'decisions', 'errors']) {
+        const content = store.read(cat);
+        const entries = content.split('\n').filter(l => l.startsWith('- '));
+        if (entries.length > 0) {
+            parts.push(`\n${cat.charAt(0).toUpperCase() + cat.slice(1)} (last 5):`);
+            for (const e of entries.slice(-5)) {
+                parts.push(`  ${e}`);
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join('\n') : t('tool.recall.no_memory');
+}
+function formatCategory(store, category) {
+    if (category === 'preferences') {
+        const prefs = store.getPreferences();
+        if (Object.keys(prefs).length === 0)
+            return t('tool.recall.no_memory');
+        const lines = ['Preferences:'];
+        for (const [k, v] of Object.entries(prefs)) {
+            lines.push(`  ${k} = ${v}`);
+        }
+        return lines.join('\n');
+    }
+    const content = store.read(category);
+    const entries = content.split('\n').filter(l => l.startsWith('- '));
+    if (entries.length === 0)
+        return t('tool.recall.no_memory');
+    return `${category.charAt(0).toUpperCase() + category.slice(1)} (${entries.length} entries):\n${entries.join('\n')}`;
+}
+function searchCategory(store, category, query) {
+    if (category === 'preferences') {
+        const prefs = store.getPreferences();
+        const lower = query.toLowerCase();
+        return Object.entries(prefs)
+            .filter(([k, v]) => k.toLowerCase().includes(lower) || v.toLowerCase().includes(lower))
+            .map(([k, v]) => `  ${k} = ${v}`);
+    }
+    const content = store.read(category);
+    const lower = query.toLowerCase();
+    return content.split('\n')
+        .filter(l => l.startsWith('- ') && l.toLowerCase().includes(lower))
+        .map(l => `  ${l}`);
+}

package/dist/tools/remember.js

@@ -0,0 +1,67 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { t } from '../i18n/index';
+import { MemoryStore } from '../modules/memory/store';
+const CATEGORIES = ['preferences', 'conventions', 'decisions', 'errors', 'facts'];
+export const rememberTool = {
+    name: 'remember',
+    description: 'Remember information across sessions. Use for user preferences, facts, conventions, decisions, or errors.',
+    tags: ['memory'],
+    parameters: {
+        type: 'object',
+        properties: {
+            category: {
+                type: 'string',
+                description: 'Memory category: preferences, conventions, decisions, errors, facts',
+                enum: CATEGORIES,
+            },
+            key: {
+                type: 'string',
+                description: 'Key name (required for preferences, e.g. "color", "language")',
+            },
+            value: {
+                type: 'string',
+                description: 'Value to store (required for preferences)',
+            },
+            entry: {
+                type: 'string',
+                description: 'Text entry to append (for conventions, decisions, errors, facts)',
+            },
+        },
+        required: ['category'],
+    },
+    handler: async (_ctx, args) => {
+        const category = String(args.category || '');
+        if (!CATEGORIES.includes(category)) {
+            return { success: false, output: t('tool.invalid_params') };
+        }
+        const memoryDir = join(homedir(), '.mma', 'memory');
+        const store = new MemoryStore(memoryDir);
+        try {
+            if (category === 'preferences') {
+                const key = String(args.key || '');
+                const value = String(args.value || '');
+                if (!key) {
+                    return { success: false, output: t('tool.remember.key_required') };
+                }
+                store.setPreference(key, value);
+                return {
+                    success: true,
+                    output: t('tool.remember.preference', { key, value }),
+                };
+            }
+            const entry = String(args.entry || '');
+            if (!entry) {
+                return { success: false, output: t('tool.remember.entry_required') };
+            }
+            store.append(category, entry);
+            return {
+                success: true,
+                output: t('tool.remember.entry', { category, entry }),
+            };
+        }
+        catch (err) {
+            return { success: true, output: t('tool.memory_error', { error: String(err) }) };
+        }
+    },
+};

package/package.json

@@ -1,43 +1,44 @@
-{
-  "name": "micro-models-agent",
-  "version": "0.16.8",
-  "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
-  "type": "module",
-  "bin": {
-    "mma": "bin/mma.mjs"
-  },
-  "files": [
-    "dist/",
-    "bin/"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "mma": "bun run src/cli/main.ts",
-    "build": "bun run build:tsc && bun run build:copy-assets",
-    "build:tsc": "tsc -p tsconfig.build.json",
-    "build:copy-assets": "powershell -Command \"Copy-Item -Recurse -Force 'src/modules/skills/builtin' 'dist/skills/builtin'\"",
-    "build:prod": "bun run 'build:bundle' && bun run 'build:copy-assets'",
-    "build:clean": "cmd /c \"if exist dist rmdir /s /q dist\"",
-    "build:bundle": "bun build ./src/cli/main.ts --outfile ./dist/main.js --target node --format esm --external playwright",
-    "dev": "bun --watch src/cli/main.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:integration": "vitest run --config vitest.integration.config.ts"
-  },
-  "dependencies": {
-    "commander": "^12.0.0",
-    "js-tiktoken": "^1.0.0",
-    "jsonrepair": "^3.15.0",
-    "picocolors": "^1.1.1",
-    "playwright": "^1.62.0",
-    "string-width": "^8.2.2"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.8.0",
-    "vitest": "^3.0.0"
-  }
-}
+{
+  "name": "micro-models-agent",
+  "version": "0.18.0",
+  "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
+  "type": "module",
+  "bin": {
+    "mma": "bin/mma.mjs"
+  },
+  "files": [
+    "dist/",
+    "bin/"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "mma": "bun run src/cli/main.ts",
+    "build": "bun run build:tsc && bun run build:copy-assets",
+    "build:tsc": "tsc -p tsconfig.build.json",
+    "build:copy-assets": "powershell -Command \"Copy-Item -Recurse -Force 'src/modules/skills/builtin' 'dist/skills/builtin'\"",
+    "build:prod": "bun run 'build:bundle' && bun run 'build:copy-assets'",
+    "build:clean": "cmd /c \"if exist dist rmdir /s /q dist\"",
+    "build:bundle": "bun build ./src/cli/main.ts --outfile ./dist/main.js --target node --format esm --external playwright",
+    "dev": "bun --watch src/cli/main.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run --config vitest.integration.config.ts"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "js-tiktoken": "^1.0.0",
+    "jsonrepair": "^3.15.0",
+    "picocolors": "^1.1.1",
+    "playwright": "^1.62.0",
+    "string-width": "^8.2.2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.0.0"
+  }
+}