micro-models-agent 0.41.2 → 0.43.0

package/dist/tools/remember.js

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

package/dist/tools/scope-check.js

@@ -1,30 +1,30 @@
-import { resolve, normalize } from "path";
+import { resolve, normalize } from 'path';
 export function isPathInScope(baseDir, targetPath, scope) {
     const baseResolved = resolve(baseDir);
     const targetResolved = resolve(baseDir, normalize(targetPath));
     if (!targetResolved.startsWith(baseResolved)) {
-        return { allowed: false, reason: "Path is outside the base working directory" };
+        return { allowed: false, reason: 'Path is outside the base working directory' };
     }
     if (!scope)
         return { allowed: true };
-    const isRead = scope.read_only_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
-    const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
+    const isRead = scope.read_only_files.some(f => targetResolved.startsWith(resolve(baseDir, f)));
+    const isWrite = scope.allowed_files.some(f => targetResolved.startsWith(resolve(baseDir, f)));
     if (isWrite)
         return { allowed: true };
     if (isRead)
-        return { allowed: true, reason: "Read-only file" };
-    return { allowed: false, reason: "Path is not within the allowed scope for this sub-agent" };
+        return { allowed: true, reason: 'Read-only file' };
+    return { allowed: false, reason: 'Path is not within the allowed scope for this sub-agent' };
 }
 export function isPathWritable(baseDir, targetPath, scope) {
     const baseResolved = resolve(baseDir);
     const targetResolved = resolve(baseDir, normalize(targetPath));
     if (!targetResolved.startsWith(baseResolved)) {
-        return { allowed: false, reason: "Path is outside the base working directory" };
+        return { allowed: false, reason: 'Path is outside the base working directory' };
     }
     if (!scope)
         return { allowed: true };
-    const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
+    const isWrite = scope.allowed_files.some(f => targetResolved.startsWith(resolve(baseDir, f)));
     if (isWrite)
         return { allowed: true };
-    return { allowed: false, reason: "Path is not within the writable scope for this sub-agent" };
+    return { allowed: false, reason: 'Path is not within the writable scope for this sub-agent' };
 }

package/dist/tools/subagent.js

@@ -5,20 +5,6 @@ import { HallucinationDetector } from "../modules/hallucination/detector";
 import { PluginManager } from "../modules/plugins/manager";
 import { logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-import { ArtifactStore } from "../modules/artifacts/store";
-/** Fixed system prompt (KV-cache friendly when stableSystemPrompt is on). */
-export const SUBAGENT_SYSTEM_PROMPT_TEMPLATE = `You are a sub-agent working on a specific task. You have your own context window and tool set.
-
-Workflow rules:
-- Prefer small, focused steps. Verify your own work (typecheck/tests) before finishing.
-- For large outputs, write the result to a file with write_file instead of reproducing it in your answer.
-- If the task is big and decomposable, delegate parts to the subagent tool instead of doing everything in one context.
-- When you finish, return a concise final answer; do not repeat file contents verbatim if you already wrote them to disk.`;
-function buildSubagentSystemPrompt(context, stable) {
-    if (stable)
-        return SUBAGENT_SYSTEM_PROMPT_TEMPLATE;
-    return `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`;
-}
 export const subagentTool = {
     name: "subagent",
     description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
@@ -61,15 +47,6 @@ export const subagentTool = {
                 items: { type: "string" },
                 description: "Tool tags to expose to the sub-agent",
             },
-            result_mode: {
-                type: "string",
-                enum: ["text", "file"],
-                description: '"file": persist the full result to an artifact and return a path + summary (pass-by-reference). "text" (default): return the full text into context.',
-            },
-            artifact_name: {
-                type: "string",
-                description: "Artifact file name (sanitized). Default: subagent-<timestamp>.",
-            },
         },
         required: ["task"],
     },
@@ -109,10 +86,8 @@ export const subagentTool = {
         // Defensive guard: if the caller requested specific tool tags but none of the
         // registered tools match, the sub-agent would have zero tools and would
         // hallucinate instead of acting. Warn the caller so it can correct the tags.
-        // Uses getByTags (not getAllForLLM) because alwaysOn tools always match the
-        // latter — the guard must test real tag coverage, not schema presence.
         if (toolTags && toolTags.length > 0) {
-            const matched = ctx.toolExecutor.getRegistry().getByTags(toolTags);
+            const matched = ctx.toolExecutor.getToolDefinitions(toolTags);
             if (matched.length === 0) {
                 return {
                     success: false,
@@ -129,10 +104,10 @@ export const subagentTool = {
             const parentScope = ctx.scope;
             ctx.toolExecutor.setScope(scope || { allowed_files: [], read_only_files: [] });
             const systemPrompt = {
-                content: buildSubagentSystemPrompt(context, ctx.config.subagent?.stableSystemPrompt !== false),
+                content: `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`,
                 priority: "critical",
                 essential: true,
-                estimatedTokens: 150,
+                estimatedTokens: 100,
             };
             const subDeps = {
                 config: ctx.config,
@@ -153,35 +128,15 @@ export const subagentTool = {
             let scopeRestored = false;
             try {
                 const result = await subAgent.run(fullTask);
-                if (!result.success) {
-                    return {
+                return result.success
+                    ? {
+                        success: true,
+                        output: `Sub-agent completed:\n${result.text}\n\nIterations: ${result.iterationCount}`,
+                    }
+                    : {
                         success: false,
                         output: `Sub-agent failed: ${result.error}\nPartial output: ${result.text}`,
                     };
-                }
-                const resultMode = args.result_mode || ctx.config.subagent?.resultMode || "text";
-                if (resultMode === "file") {
-                    const store = new ArtifactStore({
-                        baseDir: ctx.baseDir,
-                        sessionId: ctx.sessionId || "default",
-                        artifactsDir: ctx.config.subagent?.artifactsDir,
-                    });
-                    const abs = store.save(args.artifact_name || `subagent-${Date.now()}`, result.text, "md");
-                    const summary = store.summary(result.text, ctx.config.subagent?.maxSummaryChars ?? 2000);
-                    ctx.logger.debug(`subagent result persisted to artifact ${abs} (${result.text.length} chars, ${result.iterationCount} iterations)`);
-                    return {
-                        success: true,
-                        output: t("tool.subagent_artifact", {
-                            path: abs,
-                            iterations: String(result.iterationCount),
-                            summary,
-                        }),
-                    };
-                }
-                return {
-                    success: true,
-                    output: `Sub-agent completed:\n${result.text}\n\nIterations: ${result.iterationCount}`,
-                };
             }
             finally {
                 if (!scopeRestored) {

package/dist/tools/user-input.js

@@ -82,7 +82,7 @@ export async function askChoice(question, options, opts = {}) {
             const answer = await promptLine(rl, choicePrompt(entryCount, multiple));
             const parsed = parseSelection(answer, entryCount, multiple);
             if (parsed) {
-                return parsed.map((i) => (opts.allowCustom && i === customEntry ? CUSTOM_INDEX : i));
+                return parsed.map((i) => opts.allowCustom && i === customEntry ? CUSTOM_INDEX : i);
             }
             console.log(t("tool.user_input.invalid"));
         }

package/dist/tools/web-browse.js

@@ -1,12 +1,12 @@
 import { t } from "../i18n/index";
-import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
-import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
+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",
-    description: `Fetch and read a web page. Returns the page content as plain text (max ${MAX_PREVIEW_LINES} lines / ${MAX_CHARS} chars). This is a plain HTTP request — it does NOT execute JavaScript, so JS-rendered single-page apps (weather sites, dashboards, modern SPAs) return empty or near-empty content. For such pages use the "browser" tool instead.`,
+    description: `Fetch and read a web page. Returns the page content as plain text (max ${MAX_PREVIEW_LINES} lines / ${MAX_CHARS} chars).`,
     tags: ["research"],
     parameters: {
         type: "object",

package/dist/tools/web-fetch.js

@@ -1,6 +1,6 @@
 import { t } from "../i18n/index";
-import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
-import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
+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";
@@ -16,7 +16,7 @@ function stripHtml(html) {
 }
 export const webFetchTool = {
     name: "web_fetch",
-    description: 'Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages. This is a plain HTTP request without a browser engine — it does NOT run JavaScript, so JS-rendered single-page apps (weather sites, dashboards, modern SPAs) return empty or near-empty content; use the "browser" tool for those.',
+    description: "Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages.",
     tags: ["research"],
     parameters: {
         type: "object",

package/dist/tools/web-search.js

@@ -1,10 +1,10 @@
 import { t } from "../i18n/index";
-import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
-import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
+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. Use this for search queries instead of opening search engines (Google/Yandex/Bing) in the browser — they block headless browsers.",
+    description: "Search the web for information. Returns search results with titles and snippets.",
     tags: ["research"],
     parameters: {
         type: "object",

package/dist/tools/write-file.js

@@ -71,7 +71,9 @@ export const writeFileTool = {
             oldContent = readFileSync(resolved, "utf-8");
         }
         writeFileSync(resolved, content, "utf-8");
-        const diff = fileExists ? generateDiff(oldContent, content) : generateNewFileDiff(content);
+        const diff = fileExists
+            ? generateDiff(oldContent, content)
+            : generateNewFileDiff(content);
         // Increment file operations counter
         ctx.fileOperationsCount = currentCount + 1;
         // Log successful file write

package/dist/ui/box.js

@@ -65,7 +65,11 @@ export function box(lines, opts = {}) {
         out.push(pc.dim(`┌${"─".repeat(width - 2)}┐`));
     }
     for (const line of wrapped) {
-        out.push(pc.dim("│") + " ".repeat(pad) + padTo(line, inner) + " ".repeat(pad) + pc.dim("│"));
+        out.push(pc.dim("│") +
+            " ".repeat(pad) +
+            padTo(line, inner) +
+            " ".repeat(pad) +
+            pc.dim("│"));
     }
     out.push(pc.dim(`└${"─".repeat(width - 2)}┘`));
     return out;

package/dist/ui/index.js

@@ -1,6 +1,6 @@
-export { formatMarkdown, formatError, formatSuccess, formatWarning, FormattingStream, } from "./md-formatter";
-export { writeOutput, writeError, writeSuccess, writeWarning } from "./output";
-export { formatTable, splitRow, isSeparatorRow, getTerminalWidth } from "./table";
-export { box, divider, wrapText } from "./box";
-export { Spinner, isSpinnerSupported } from "./spinner";
-export { Renderer, isRichTerminal, summarizeArgs } from "./renderer";
+export { formatMarkdown, formatError, formatSuccess, formatWarning, FormattingStream } from './md-formatter';
+export { writeOutput, writeError, writeSuccess, writeWarning } from './output';
+export { formatTable, splitRow, isSeparatorRow, getTerminalWidth } from './table';
+export { box, divider, wrapText } from './box';
+export { Spinner, isSpinnerSupported } from './spinner';
+export { Renderer, isRichTerminal, summarizeArgs } from './renderer';

package/dist/ui/md-formatter.js

@@ -1,6 +1,6 @@
-import { pc } from "./colors";
-import { t } from "../i18n/index";
-import { formatTable, getTerminalWidth } from "./table";
+import { pc } from './colors';
+import { t } from '../i18n/index';
+import { formatTable, getTerminalWidth } from './table';
 const KW = /\b(import|export|from|const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|class|extends|implements|interface|type|enum|namespace|module|declare|abstract|async|await|yield|throw|try|catch|finally|typeof|instanceof|in|of|as|is|keyof|readonly|static|private|public|protected|get|set|constructor|this|super|void|never|any|unknown|boolean|string|number|symbol|object|true|false|null|undefined|default)\b/g;
 const STRING = /('[^']*'|"[^"]*"|`[^`]*`)/g;
 const COMMENT = /(\/\/[^\n]*|\/\*[\s\S]*?\*\/|#[^\n]*)/g;
@@ -8,21 +8,21 @@ const NUMBER = /\b(\d+\.?\d*)\b/g;
 const TAG = /<\/?([A-Z][a-zA-Z0-9]*|[a-z][a-zA-Z0-9-]*)/g;
 const ATTR = /\b([a-zA-Z-]+=)"([^"]*)"/g;
 function highlight(code, lang) {
-    if (lang === "html" || lang === "xml" || lang === "svg") {
+    if (lang === 'html' || lang === 'xml' || lang === 'svg') {
         code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
-        code = code.replace(ATTR, (_m, attr, val) => pc.yellow(attr) + "=" + pc.green('"' + val + '"'));
-        code = code.replace(TAG, (_m, tag) => "<" + pc.cyan(tag));
+        code = code.replace(ATTR, (_m, attr, val) => pc.yellow(attr) + '=' + pc.green('"' + val + '"'));
+        code = code.replace(TAG, (_m, tag) => '<' + pc.cyan(tag));
     }
-    else if (lang === "css" || lang === "scss" || lang === "less") {
+    else if (lang === 'css' || lang === 'scss' || lang === 'less') {
         code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
         code = code.replace(STRING, (m) => pc.green(m));
         code = code.replace(NUMBER, (m) => pc.yellow(m));
     }
-    else if (lang === "bash" || lang === "sh" || lang === "shell" || lang === "zsh") {
+    else if (lang === 'bash' || lang === 'sh' || lang === 'shell' || lang === 'zsh') {
         code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
         code = code.replace(STRING, (m) => pc.green(m));
     }
-    else if (lang === "json") {
+    else if (lang === 'json') {
         code = code.replace(STRING, (m) => pc.green(m));
         code = code.replace(NUMBER, (m) => pc.yellow(m));
     }
@@ -37,7 +37,7 @@ function highlight(code, lang) {
 }
 function isTableRow(line) {
     const trimmed = line.trim();
-    if (!trimmed.startsWith("|"))
+    if (!trimmed.startsWith('|'))
         return false;
     const pipes = trimmed.match(/\|/g);
     return (pipes?.length ?? 0) >= 2;
@@ -46,9 +46,9 @@ function isHorizontalRule(line) {
     return /^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trim());
 }
 export class FormattingStream {
-    buffer = "";
+    buffer = '';
     inCodeBlock = false;
-    codeLang = "";
+    codeLang = '';
     codeLines = [];
     tableBuffer = [];
     onWrite;
@@ -60,7 +60,7 @@ export class FormattingStream {
     write(chunk) {
         this.buffer += chunk;
         let idx;
-        while ((idx = this.buffer.indexOf("\n")) !== -1) {
+        while ((idx = this.buffer.indexOf('\n')) !== -1) {
             const line = this.buffer.slice(0, idx);
             this.buffer = this.buffer.slice(idx + 1);
             this.processLine(line);
@@ -75,8 +75,8 @@ export class FormattingStream {
         }
         if (this.buffer.length > 0) {
             const line = this.buffer;
-            this.buffer = "";
-            if (line.trim() === "```" || line.trim().startsWith("```")) {
+            this.buffer = '';
+            if (line.trim() === '```' || line.trim().startsWith('```')) {
                 if (this.codeLines.length > 0) {
                     this.emitCodeBlock();
                 }
@@ -86,7 +86,7 @@ export class FormattingStream {
         }
     }
     processLine(line) {
-        if (line.trim() === "```" || line.trim().startsWith("```")) {
+        if (line.trim() === '```' || line.trim().startsWith('```')) {
             if (this.inCodeBlock) {
                 this.emitCodeBlock();
             }
@@ -128,18 +128,18 @@ export class FormattingStream {
     emitCodeBlock() {
         this.inCodeBlock = false;
         if (this.codeLines.length > 0) {
-            const code = this.codeLines.join("\n");
+            const code = this.codeLines.join('\n');
             const highlighted = highlight(code, this.codeLang);
-            const lang = this.codeLang ? ` ${this.codeLang} ` : " ";
-            const top = pc.dim(`┌─${lang}${"─".repeat(Math.max(0, this.width - 3 - lang.length))}┐`);
+            const lang = this.codeLang ? ` ${this.codeLang} ` : ' ';
+            const top = pc.dim(`┌─${lang}${'─'.repeat(Math.max(0, this.width - 3 - lang.length))}┐`);
             this.onWrite(top);
-            for (const l of highlighted.split("\n")) {
-                this.onWrite(pc.dim("│ ") + l);
+            for (const l of highlighted.split('\n')) {
+                this.onWrite(pc.dim('│ ') + l);
             }
-            this.onWrite(pc.dim(`└${"─".repeat(Math.max(0, this.width - 1))}┘`));
+            this.onWrite(pc.dim(`└${'─'.repeat(Math.max(0, this.width - 1))}┘`));
         }
         this.codeLines = [];
-        this.codeLang = "";
+        this.codeLang = '';
     }
     formatLine(line) {
         let result = line;
@@ -152,18 +152,18 @@ export class FormattingStream {
             return pc.cyan(pc.bold(content));
         }
         if (isHorizontalRule(result)) {
-            return pc.dim("─".repeat(Math.max(0, Math.min(this.width, 60))));
+            return pc.dim('─'.repeat(Math.max(0, Math.min(this.width, 60))));
         }
         const quote = result.match(/^(>+)\s?(.*)$/);
         if (quote) {
             const depth = Math.min(quote[1].length, 4);
-            const marker = pc.dim("▍".repeat(depth));
+            const marker = pc.dim('▍'.repeat(depth));
             return `${marker} ${this.formatInline(quote[2])}`;
         }
         const checkbox = result.match(/^[-*]\s+\[([ xX])\]\s+(.+)$/);
         if (checkbox) {
-            const checked = checkbox[1].toLowerCase() === "x";
-            const mark = checked ? pc.green("✓") : pc.dim("☐");
+            const checked = checkbox[1].toLowerCase() === 'x';
+            const mark = checked ? pc.green('✓') : pc.dim('☐');
             return `  ${mark} ${this.formatInline(checkbox[2])}`;
         }
         const ordered = result.match(/^(\d+)[.)]\s+(.+)$/);
@@ -172,7 +172,7 @@ export class FormattingStream {
         }
         const bullet = result.match(/^[-*]\s+(.+)$/);
         if (bullet) {
-            return ` ${pc.dim("•")} ${this.formatInline(bullet[1])}`;
+            return ` ${pc.dim('•')} ${this.formatInline(bullet[1])}`;
         }
         return this.formatInline(result);
     }
@@ -187,7 +187,7 @@ export class FormattingStream {
         result = result.replace(/\*([^*]+)\*/g, (_, s) => pc.italic(s));
         result = result.replace(/(^|\s)_([^_\n]+)_(?=\s|$)/g, (_m, pre, s) => pre + pc.italic(s));
         result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => {
-            const short = url.length > 80 ? url.slice(0, 77) + "…" : url;
+            const short = url.length > 80 ? url.slice(0, 77) + '…' : url;
             return `${pc.cyan(label)} ${pc.dim(`(${short})`)}`;
         });
         result = result.replace(/\u0000(\d+)\u0000/g, (_m, i) => codeSpans[Number(i)]);
@@ -199,14 +199,14 @@ export function formatMarkdown(text) {
     const stream = new FormattingStream((l) => lines.push(l));
     stream.write(text);
     stream.flush();
-    return lines.join("\n");
+    return lines.join('\n');
 }
 export function formatError(text) {
-    return pc.red(pc.bold(t("ui.error_prefix")) + text);
+    return pc.red(pc.bold(t('ui.error_prefix')) + text);
 }
 export function formatSuccess(text) {
-    return pc.green(pc.bold(t("ui.success_prefix")) + text);
+    return pc.green(pc.bold(t('ui.success_prefix')) + text);
 }
 export function formatWarning(text) {
-    return pc.yellow(pc.bold(t("ui.warning_prefix")) + text);
+    return pc.yellow(pc.bold(t('ui.warning_prefix')) + text);
 }

package/dist/ui/output.js

@@ -1,13 +1,13 @@
-import { formatMarkdown, formatError, formatSuccess, formatWarning } from "./md-formatter";
+import { formatMarkdown, formatError, formatSuccess, formatWarning } from './md-formatter';
 export function writeOutput(text) {
-    process.stdout.write(formatMarkdown(text) + "\n");
+    process.stdout.write(formatMarkdown(text) + '\n');
 }
 export function writeError(text) {
-    process.stderr.write(formatError(text) + "\n");
+    process.stderr.write(formatError(text) + '\n');
 }
 export function writeSuccess(text) {
-    process.stdout.write(formatSuccess(text) + "\n");
+    process.stdout.write(formatSuccess(text) + '\n');
 }
 export function writeWarning(text) {
-    process.stdout.write(formatWarning(text) + "\n");
+    process.stdout.write(formatWarning(text) + '\n');
 }

package/dist/ui/renderer.js

@@ -118,36 +118,29 @@ export class Renderer {
     thinkingEnd() {
         this.spinner.stop();
     }
-    toolStart(tool, args, stepContext) {
+    toolStart(tool, args) {
         this.endCard();
         this.spinner.stop();
         const summary = summarizeArgs(args);
-        const step = stepContext ? ` ${pc.cyan(`← ${stepContext}`)}` : "";
         if (!this.rich) {
-            this.out.write(`\n${pc.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}\n`);
+            this.out.write(`\n${pc.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}\n`);
             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)}` : ""}${step}\n`);
+            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)}` : ""}${step}`);
-    }
-    /** Live plan checklist — prints the plan block as-is (already colored). */
-    planBlock(lines) {
-        this.endCard();
-        this.spinner.stop();
-        for (const line of lines) {
-            this.out.write(`${line}\n`);
-        }
+        this.spinner.start(`${pc.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}`);
     }
     toolEnd(_tool, duration, error, ctxDelta) {
         this.spinner.stop();
         if (!this.rich) {
             if (ctxDelta !== undefined && ctxDelta !== 0) {
-                const deltaStr = ctxDelta > 0 ? pc.green(`+${ctxDelta}`) : pc.yellow(`${ctxDelta} ↓`);
+                const deltaStr = ctxDelta > 0
+                    ? pc.green(`+${ctxDelta}`)
+                    : pc.yellow(`${ctxDelta} ↓`);
                 this.out.write(`${pc.dim("ctx")} ${deltaStr}\n`);
             }
             return;
@@ -158,7 +151,9 @@ export class Renderer {
         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} ↓`);
+            const deltaStr = ctxDelta > 0
+                ? pc.green(`+${ctxDelta}`)
+                : pc.yellow(`${ctxDelta} ↓`);
             footer += `  ${pc.dim("ctx")} ${deltaStr}`;
         }
         if (this.toolStyle === "inline") {

package/dist/ui/table.js

@@ -106,7 +106,7 @@ export function formatTable(tableLines, opts = {}) {
         for (let c = 0; c < columnCount; c++) {
             const raw = row[c] ?? "";
             const cell = truncate(raw, widths[c]);
-            const a = isHeader && align[c] === undefined ? "center" : (align[c] ?? "left");
+            const a = isHeader && align[c] === undefined ? "center" : align[c] ?? "left";
             cells.push(pad(cell, widths[c], a));
         }
         const content = cells.map((c) => pc.dim("│ ") + c).join("") + pc.dim("│");