micro-models-agent 0.39.0 → 0.40.0

package/dist/tools/web-browse.js

@@ -1,22 +1,22 @@
-import { t } from '../i18n/index';
-import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
-import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
-import { getSessionSecurityConfig } from '../modules/security/session-isolation';
-import { MAX_PREVIEW_LINES } from './preview';
+import { t } from "../i18n/index";
+import { isUrlAllowed, sanitizeUrl, } from "../modules/security/network-validator";
+import { logNetworkRequest, logSecurityBlock, } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { MAX_PREVIEW_LINES } from "./preview";
 const MAX_CHARS = 3000;
 export const webBrowseTool = {
-    name: 'web_browse',
+    name: "web_browse",
     description: `Fetch and read a web page. Returns the page content as plain text (max ${MAX_PREVIEW_LINES} lines / ${MAX_CHARS} chars).`,
-    tags: ['research'],
+    tags: ["research"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            url: { type: 'string', description: 'URL to fetch' },
+            url: { type: "string", description: "URL to fetch" },
         },
-        required: ['url'],
+        required: ["url"],
     },
     handler: async (ctx, args) => {
-        const url = String(args.url || '');
+        const url = String(args.url || "");
         // Get session-specific security config
         const securityConfig = ctx.sessionContext
             ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
@@ -30,28 +30,57 @@ export const webBrowseTool = {
             };
         }
         try {
-            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000) });
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
+            });
             const text = await response.text();
             const stripped = text
-                .replace(/<script[\s\S]*?<\/script>/gi, '')
-                .replace(/<style[\s\S]*?<\/style>/gi, '')
-                .replace(/<[^>]+>/g, '')
-                .replace(/&[^;]+;/g, ' ')
-                .replace(/\s+/g, ' ')
+                .replace(/<script[\s\S]*?<\/script>/gi, "")
+                .replace(/<style[\s\S]*?<\/style>/gi, "")
+                .replace(/<[^>]+>/g, "")
+                .replace(/&[^;]+;/g, " ")
+                .replace(/\s+/g, " ")
                 .trim();
-            // Log successful network request
             logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
-            const maxLen = securityConfig?.maxResponseSize || MAX_CHARS;
-            let content = stripped.length > maxLen ? stripped.slice(0, maxLen) + t('file.truncated') : stripped;
-            const lines = content.split('\n');
-            if (lines.length > MAX_PREVIEW_LINES) {
-                content = lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
+            const fullChars = stripped.length;
+            const fullLines = stripped.split("\n").length;
+            const maxChars = securityConfig?.maxResponseSize || MAX_CHARS;
+            let content;
+            if (stripped.length > maxChars) {
+                content = stripped.slice(0, maxChars) + t("file.truncated");
             }
-            return { success: true, output: content || t('file.empty_page') };
+            else {
+                content = stripped;
+            }
+            const contentLines = content.split("\n");
+            if (contentLines.length > MAX_PREVIEW_LINES) {
+                content =
+                    contentLines.slice(0, MAX_PREVIEW_LINES).join("\n") +
+                        `\n... (${contentLines.length - MAX_PREVIEW_LINES} more lines)`;
+            }
+            const truncated = stripped.length > maxChars || fullLines > MAX_PREVIEW_LINES
+                ? t("file.truncated").trim()
+                : "";
+            return {
+                success: true,
+                output: content || t("file.empty_page"),
+                display: t("tool.web_browse_result", {
+                    url: sanitizeUrl(url),
+                    chars: String(fullChars),
+                    lines: String(fullLines),
+                    truncated,
+                }),
+            };
         }
         catch (err) {
             logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
-            return { success: false, output: t('error.fetch_url_failed', { url: sanitizeUrl(url), message: err.message }) };
+            return {
+                success: false,
+                output: t("error.fetch_url_failed", {
+                    url: sanitizeUrl(url),
+                    message: err.message,
+                }),
+            };
         }
     },
 };

package/dist/tools/web-fetch.js

@@ -1,29 +1,29 @@
-import { t } from '../i18n/index';
-import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
-import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
-import { getSessionSecurityConfig } from '../modules/security/session-isolation';
-import { DEFAULT_SECURITY_CONFIG } from '../config/security';
-import { MAX_PREVIEW_LINES } from './preview';
+import { t } from "../i18n/index";
+import { isUrlAllowed, sanitizeUrl, } from "../modules/security/network-validator";
+import { logNetworkRequest, logSecurityBlock, } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { DEFAULT_SECURITY_CONFIG } from "../config/security";
+import { MAX_PREVIEW_LINES } from "./preview";
 const MAX_CHARS = 5000;
 function stripHtml(html) {
     return html
-        .replace(/<script[\s\S]*?<\/script>/gi, '')
-        .replace(/<style[\s\S]*?<\/style>/gi, '')
-        .replace(/<[^>]+>/g, '')
-        .replace(/&[^;]+;/g, ' ')
-        .replace(/\s+/g, ' ')
+        .replace(/<script[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[\s\S]*?<\/style>/gi, "")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&[^;]+;/g, " ")
+        .replace(/\s+/g, " ")
         .trim();
 }
 export const webFetchTool = {
-    name: 'web_fetch',
-    description: 'Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages.',
-    tags: ['research'],
+    name: "web_fetch",
+    description: "Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages.",
+    tags: ["research"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            url: { type: 'string', description: 'URL to fetch' },
+            url: { type: "string", description: "URL to fetch" },
         },
-        required: ['url'],
+        required: ["url"],
     },
     handler: async (ctx, args) => {
         const url = String(args.url);
@@ -41,32 +41,58 @@ export const webFetchTool = {
             };
         }
         try {
-            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000) });
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
+            });
             if (!response.ok) {
-                return { success: false, output: t('error.http', { status: response.status, statusText: response.statusText }) };
+                return {
+                    success: false,
+                    output: t("error.http", {
+                        status: response.status,
+                        statusText: response.statusText,
+                    }),
+                };
             }
-            const contentType = response.headers.get('content-type') || '';
+            const contentType = response.headers.get("content-type") || "";
             const text = await response.text();
-            const cleaned = contentType.includes('html') ? stripHtml(text) : text;
-            // Log successful network request
+            const cleaned = contentType.includes("html") ? stripHtml(text) : text;
             logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
-            if (cleaned.length > (securityConfig?.maxResponseSize || MAX_CHARS)) {
-                let content = cleaned.slice(0, securityConfig?.maxResponseSize || MAX_CHARS) + t('file.truncated');
-                const lines = content.split('\n');
-                if (lines.length > MAX_PREVIEW_LINES) {
-                    content = lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
-                }
-                return { success: true, output: content };
+            const fullChars = cleaned.length;
+            const fullLines = cleaned.split("\n").length;
+            const maxChars = securityConfig?.maxResponseSize || MAX_CHARS;
+            let content;
+            if (cleaned.length > maxChars) {
+                content = cleaned.slice(0, maxChars) + t("file.truncated");
             }
-            const lines = cleaned.split('\n');
-            if (lines.length > MAX_PREVIEW_LINES) {
-                return { success: true, output: lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)` };
+            else {
+                content = cleaned;
             }
-            return { success: true, output: cleaned || t('file.empty_page') };
+            const contentLines = content.split("\n");
+            if (contentLines.length > MAX_PREVIEW_LINES) {
+                content =
+                    contentLines.slice(0, MAX_PREVIEW_LINES).join("\n") +
+                        `\n... (${contentLines.length - MAX_PREVIEW_LINES} more lines)`;
+            }
+            const truncated = cleaned.length > maxChars || fullLines > MAX_PREVIEW_LINES
+                ? t("file.truncated").trim()
+                : "";
+            return {
+                success: true,
+                output: content || t("file.empty_page"),
+                display: t("tool.web_fetch_result", {
+                    url: sanitizeUrl(url),
+                    chars: String(fullChars),
+                    lines: String(fullLines),
+                    truncated,
+                }),
+            };
         }
         catch (e) {
             logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${e.message}`);
-            return { success: false, output: t('error.fetch_failed', { message: e.message }) };
+            return {
+                success: false,
+                output: t("error.fetch_failed", { message: e.message }),
+            };
         }
     },
 };

package/dist/tools/web-search.js

@@ -1,21 +1,24 @@
-import { t } from '../i18n/index';
-import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
-import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
-import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+import { t } from "../i18n/index";
+import { isUrlAllowed, sanitizeUrl, } from "../modules/security/network-validator";
+import { logNetworkRequest, logSecurityBlock, } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 export const webSearchTool = {
-    name: 'web_search',
-    description: 'Search the web for information. Returns search results with titles and snippets.',
-    tags: ['research'],
+    name: "web_search",
+    description: "Search the web for information. Returns search results with titles and snippets.",
+    tags: ["research"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            query: { type: 'string', description: 'Search query' },
-            numResults: { type: 'number', description: 'Number of results (default 5)' },
+            query: { type: "string", description: "Search query" },
+            numResults: {
+                type: "number",
+                description: "Number of results (default 5)",
+            },
         },
-        required: ['query'],
+        required: ["query"],
     },
     handler: async (ctx, args) => {
-        const query = String(args.query || '');
+        const query = String(args.query || "");
         const numResults = Number(args.numResults) || 5;
         // Build search URL
         const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
@@ -32,28 +35,44 @@ export const webSearchTool = {
             };
         }
         try {
-            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 10000) });
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 10000),
+            });
             const html = await response.text();
             const results = [];
-            const snippetRegex = /<a[^>]+class="result__a"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+            const snippetRegex = /<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
             let match;
             let count = 0;
             while ((match = snippetRegex.exec(html)) !== null && count < numResults) {
-                const title = match[1].replace(/<[^>]+>/g, '').trim();
-                const snippet = match[2].replace(/<[^>]+>/g, '').trim();
-                results.push(`${title}: ${snippet}`);
+                const href = match[1].trim();
+                const title = match[2].replace(/<[^>]+>/g, "").trim();
+                const snippet = match[3].replace(/<[^>]+>/g, "").trim();
+                results.push(`${count + 1}. ${title}\n   URL: ${href}\n   ${snippet}`);
                 count++;
             }
             // Log successful network request
             logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Results: ${results.length}`);
             if (results.length === 0) {
-                return { success: true, output: t('tool.no_results', { query }) };
+                return { success: true, output: t("tool.no_results", { query }) };
             }
-            return { success: true, output: t('tool.search_results', { query, results: results.join('\n') }) };
+            return {
+                success: true,
+                output: t("tool.search_results", {
+                    query,
+                    results: results.join("\n"),
+                }),
+                display: t("tool.web_search_result", {
+                    query,
+                    count: String(results.length),
+                }),
+            };
         }
         catch (err) {
             logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
-            return { success: false, output: t('error.search_failed', { message: err.message }) };
+            return {
+                success: false,
+                output: t("error.search_failed", { message: err.message }),
+            };
         }
     },
 };

package/dist/tools/write-file.js

@@ -47,15 +47,19 @@ export const writeFileTool = {
                 output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
             };
         }
-        // Check content for dangerous patterns
+        // Check content for dangerous patterns — only when security is enabled.
+        // contentScan has its own `enabled` flag, but it must NOT fire while the
+        // global security switch is off (false positives on ordinary CLI code).
         const content = String(args.content);
-        const scanResult = scanContent(content, path, ctx.config.security?.contentScan);
-        if (!scanResult.allowed) {
-            logSecurityBlock(ctx.sessionId, "file_write", scanResult.reason || "Content contains dangerous patterns", path);
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] ${scanResult.reason}`,
-            };
+        if (securityConfig?.enabled && securityConfig?.contentScan?.enabled) {
+            const scanResult = scanContent(content, path, securityConfig.contentScan);
+            if (!scanResult.allowed) {
+                logSecurityBlock(ctx.sessionId, "file_write", scanResult.reason || "Content contains dangerous patterns", path);
+                return {
+                    success: false,
+                    output: `[SECURITY BLOCKED] ${scanResult.reason}`,
+                };
+            }
         }
         const dir = dirname(resolved);
         if (!existsSync(dir)) {
@@ -73,8 +77,7 @@ export const writeFileTool = {
         // Increment file operations counter
         ctx.fileOperationsCount = currentCount + 1;
         // Log successful file write
-        logFileWrite(ctx.sessionId, path, true, `File ${fileExists ? 'updated' : 'created'}`);
-        ctx.trackCreatedPath?.(path);
+        logFileWrite(ctx.sessionId, path, true, `File ${fileExists ? "updated" : "created"}`);
         return { success: true, output: t("file.written", { path }), diff };
     },
 };

package/dist/ui/diff.js

@@ -110,10 +110,10 @@ function formatLine(line, maxNumWidth) {
     const num = line.type === "remove" ? line.oldNum : line.newNum;
     const numStr = num !== null ? String(num).padStart(maxNumWidth) : " ".repeat(maxNumWidth);
     if (line.type === "remove") {
-        return pc.red(`${pc.bgRed(`${numStr} - ${line.content}`)}`);
+        return `${numStr} ${pc.red("-")} ${line.content}`;
     }
     else if (line.type === "add") {
-        return pc.green(`${pc.bgGreen(`${numStr} + ${line.content}`)}`);
+        return `${numStr} ${pc.green("+")} ${line.content}`;
     }
     else if (line.content === "...") {
         return pc.dim(`  ${" ".repeat(maxNumWidth)}...`);
@@ -127,17 +127,13 @@ export function generateDiff(oldContent, newContent) {
         return "";
     const oldLines = oldContent.split("\n");
     const newLines = newContent.split("\n");
-    if (oldLines.length === 1 &&
-        oldLines[0] === "" &&
-        newLines.length === 1 &&
-        newLines[0] === "") {
-        return "";
-    }
     const diff = buildDiff(oldLines, newLines);
     if (diff.length === 0)
         return "";
-    const maxOldNum = Math.max(...diff.filter((l) => l.oldNum !== null).map((l) => l.oldNum));
-    const maxNewNum = Math.max(...diff.filter((l) => l.newNum !== null).map((l) => l.newNum));
+    const oldNums = diff.filter((l) => l.oldNum !== null).map((l) => l.oldNum);
+    const newNums = diff.filter((l) => l.newNum !== null).map((l) => l.newNum);
+    const maxOldNum = oldNums.length > 0 ? Math.max(...oldNums) : 0;
+    const maxNewNum = newNums.length > 0 ? Math.max(...newNums) : 0;
     const maxNumWidth = Math.max(String(maxOldNum).length, String(maxNewNum).length, 3);
     let lines = diff.map((l) => formatLine(l, maxNumWidth));
     if (lines.length > MAX_DIFF_LINES) {
@@ -153,7 +149,7 @@ export function generateNewFileDiff(content) {
     const diffLines = [];
     for (let i = 0; i < lines.length; i++) {
         const numStr = String(i + 1).padStart(maxNumWidth);
-        diffLines.push(pc.green(`${pc.bgGreen(`${numStr} + ${lines[i]}`)}`));
+        diffLines.push(`${numStr} ${pc.green("+")} ${lines[i]}`);
     }
     if (diffLines.length > MAX_DIFF_LINES) {
         const truncated = diffLines.slice(0, MAX_DIFF_LINES);
@@ -168,7 +164,7 @@ export function generateDeleteDiff(content) {
     const diffLines = [];
     for (let i = 0; i < lines.length; i++) {
         const numStr = String(i + 1).padStart(maxNumWidth);
-        diffLines.push(pc.red(`${pc.bgRed(`${numStr} - ${lines[i]}`)}`));
+        diffLines.push(`${numStr} ${pc.red("-")} ${lines[i]}`);
     }
     if (diffLines.length > MAX_DIFF_LINES) {
         const truncated = diffLines.slice(0, MAX_DIFF_LINES);
@@ -178,8 +174,5 @@ export function generateDeleteDiff(content) {
     return diffLines.join("\n");
 }
 export function generateMoveDiff(fromPath, toPath) {
-    return [
-        pc.red(`  - ${fromPath}`),
-        pc.green(`  + ${toPath}`),
-    ].join("\n");
+    return [pc.red(`  - ${fromPath}`), pc.green(`  + ${toPath}`)].join("\n");
 }

package/dist/ui/renderer.js

@@ -1,9 +1,32 @@
 import { pc } from "./colors";
 import { FormattingStream } from "./md-formatter";
 import { Spinner } from "./spinner";
-import { box } from "./box";
+import { box, divider } from "./box";
 import { getTerminalWidth } from "./table";
 import { t } from "../i18n/index";
+const GUTTER = "  ";
+/** opencode-like leading marker per tool category. */
+export function toolMarker(tool) {
+    switch (tool) {
+        case "write_file":
+        case "edit_file":
+        case "create_dir":
+        case "move_file":
+        case "delete_file":
+            return "←";
+        case "read_file":
+        case "list_dir":
+        case "file_info":
+            return "→";
+        case "glob":
+        case "grep":
+            return "✱";
+        case "bash":
+            return "$";
+        default:
+            return "⚙";
+    }
+}
 export function isRichTerminal() {
     return Boolean(process.stdout.isTTY) && !process.env.CI;
 }
@@ -38,12 +61,14 @@ export class Renderer {
     out;
     err;
     width;
+    toolStyle;
     card = null;
     constructor(opts = {}) {
         this.rich = opts.rich ?? isRichTerminal();
         this.out = opts.out ?? process.stdout;
         this.err = opts.err ?? process.stderr;
         this.width = opts.width ?? getTerminalWidth();
+        this.toolStyle = opts.toolStyle ?? "inline";
         this.spinner = new Spinner({
             enabled: this.rich && (opts.spinner ?? true),
             stream: this.err,
@@ -61,12 +86,25 @@ export class Renderer {
     meta(chunk) {
         this.spinner.stop();
         if (this.card) {
-            this.card.body.push(chunk);
+            if (this.toolStyle === "inline") {
+                this.writeInlineBody(chunk);
+            }
+            else {
+                this.card.body.push(chunk);
+            }
         }
         else {
             this.out.write(chunk);
         }
     }
+    /** Stream tool body lines with the gutter prefix, skipping blank lines. */
+    writeInlineBody(chunk) {
+        for (const line of chunk.split("\n")) {
+            if (line.trim() === "")
+                continue;
+            this.out.write(`${GUTTER}${line}\n`);
+        }
+    }
     /** Dimmed reasoning stream (already colored by the agent). */
     reasoning(chunk) {
         this.spinner.stop();
@@ -89,15 +127,41 @@ export class Renderer {
             return;
         }
         this.card = { tool, args, body: [], start: Date.now() };
+        if (this.toolStyle === "inline") {
+            const marker = toolMarker(tool);
+            this.out.write(`\n${pc.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}\n`);
+            return;
+        }
         this.spinner.start(`${pc.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}`);
     }
-    toolEnd(_tool, duration, error) {
+    toolEnd(_tool, duration, error, ctxDelta) {
         this.spinner.stop();
-        if (!this.rich)
+        if (!this.rich) {
+            if (ctxDelta !== undefined && ctxDelta !== 0) {
+                const deltaStr = ctxDelta > 0
+                    ? pc.green(`+${ctxDelta}`)
+                    : pc.yellow(`${ctxDelta} ↓`);
+                this.out.write(`${pc.dim("ctx")} ${deltaStr}\n`);
+            }
             return;
+        }
         if (!this.card)
             return;
         const { tool, args, body } = this.card;
+        const marker = error ? pc.red("✗") : pc.green("✓");
+        let footer = `${marker} ${pc.dim(`${duration}ms`)}`;
+        if (ctxDelta !== undefined && ctxDelta !== 0) {
+            const deltaStr = ctxDelta > 0
+                ? pc.green(`+${ctxDelta}`)
+                : pc.yellow(`${ctxDelta} ↓`);
+            footer += `  ${pc.dim("ctx")} ${deltaStr}`;
+        }
+        if (this.toolStyle === "inline") {
+            this.out.write(`${GUTTER}${footer}\n`);
+            this.out.write(`${divider(this.width)}\n`);
+            this.card = null;
+            return;
+        }
         const lines = [];
         const summary = summarizeArgs(args);
         if (summary)
@@ -108,8 +172,7 @@ export class Renderer {
                     lines.push(line);
             }
         }
-        const marker = error ? pc.red("✗") : pc.green("✓");
-        lines.push(`${marker} ${pc.dim(`${duration}ms`)}`);
+        lines.push(footer);
         const title = `${marker} ${friendlyTool(tool)}`;
         for (const line of box(lines, { title, width: this.width })) {
             this.out.write(`${line}\n`);

package/package.json

@@ -1,45 +1,48 @@
-{
-  "name": "micro-models-agent",
-  "version": "0.39.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": "bun run scripts/copy-assets.ts",
-    "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": "bun test",
-    "test:watch": "bun test --watch",
-    "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",
-    "yaml": "^2.9.0"
-  },
-  "devDependencies": {
-    "@types/bun": "^1.3.14",
-    "@types/node": "^22.20.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.10"
-  }
-}
+{
+  "name": "micro-models-agent",
+  "version": "0.40.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": "bun run scripts/copy-assets.ts",
+    "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": "bun test",
+    "test:watch": "bun test --watch",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "format": "prettier --write \"src/**/*.{ts,js,mjs,json}\" \"tests/**/*.{ts,js,json}\" \"scripts/**/*.ts\" \"*.{ts,json}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,js,mjs,json}\" \"tests/**/*.{ts,js,json}\" \"scripts/**/*.ts\" \"*.{ts,json}\""
+  },
+  "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",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^22.20.1",
+    "prettier": "^3.9.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
+  }
+}