micro-models-agent 0.40.1 → 0.41.2

package/dist/tools/pipeline-run.js

@@ -1,13 +1,13 @@
-import { t } from '../i18n/index';
-import { PipelineEngine } from '../modules/pipelines/engine';
-import { PipelineParser } from '../modules/pipelines/parser';
-import { TemplateEngine } from '../modules/pipelines/template';
-import { Agent } from '../core/agent';
-import { ContextManager } from '../modules/context/manager';
-import { PluginManager } from '../modules/plugins/manager';
-import { HallucinationDetector } from '../modules/hallucination/detector';
-import { logSecurityBlock } from '../modules/security/audit-log';
-import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+import { t } from "../i18n/index";
+import { PipelineEngine } from "../modules/pipelines/engine";
+import { PipelineParser } from "../modules/pipelines/parser";
+import { TemplateEngine } from "../modules/pipelines/template";
+import { Agent } from "../core/agent";
+import { ContextManager } from "../modules/context/manager";
+import { PluginManager } from "../modules/plugins/manager";
+import { HallucinationDetector } from "../modules/hallucination/detector";
+import { logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 const engine = new PipelineEngine();
 const MAX_CONCURRENT = 3;
 const MAX_ATTEMPTS = 3;
@@ -52,29 +52,29 @@ async function runStep(ctx, step, params, outputs) {
     return { ok: false, output: "", error: lastError };
 }
 export const pipelineRunTool = {
-    name: 'pipeline_run',
-    description: 'Run a named pipeline with YAML definition. Creates a DAG of sub-agents that execute in dependency order.',
-    tags: ['shell', 'code'],
+    name: "pipeline_run",
+    description: "Run a named pipeline with YAML definition. Creates a DAG of sub-agents that execute in dependency order.",
+    tags: ["shell", "code"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            name: { type: 'string', description: 'Pipeline name' },
-            yaml: { type: 'string', description: 'Pipeline YAML definition with steps' },
-            params: { type: 'object', description: 'Template params for {key} placeholders' },
+            name: { type: "string", description: "Pipeline name" },
+            yaml: { type: "string", description: "Pipeline YAML definition with steps" },
+            params: { type: "object", description: "Template params for {key} placeholders" },
         },
-        required: ['name', 'yaml'],
+        required: ["name", "yaml"],
     },
     handler: async (ctx, args) => {
-        const name = String(args.name || '');
-        const yaml = String(args.yaml || '');
+        const name = String(args.name || "");
+        const yaml = String(args.yaml || "");
         const params = args.params || {};
         if (!yaml) {
-            return { success: false, output: t('pipeline.invalid') };
+            return { success: false, output: t("pipeline.invalid") };
         }
         if (!ctx.llmProvider || !ctx.toolExecutor) {
             return {
                 success: false,
-                output: 'Pipeline cannot run: missing llmProvider or toolExecutor in context',
+                output: "Pipeline cannot run: missing llmProvider or toolExecutor in context",
             };
         }
         const securityConfig = ctx.sessionContext
@@ -104,7 +104,7 @@ export const pipelineRunTool = {
                 if (ready.length === 0) {
                     if (failed.size > 0)
                         break;
-                    throw new Error(t('pipeline.circular', { stepId: order.join(', ') }));
+                    throw new Error(t("pipeline.circular", { stepId: order.join(", ") }));
                 }
                 const batch = ready.slice(0, MAX_CONCURRENT);
                 const results = await Promise.all(batch.map((step) => runStep(ctx, step, params, outputs)));
@@ -114,12 +114,12 @@ export const pipelineRunTool = {
                     if (result.ok) {
                         completed.add(step.id);
                         outputs[step.id] = { output: result.output };
-                        engine.setStepStatus(step.id, 'done');
+                        engine.setStepStatus(step.id, "done");
                         logs.push(`  ✓ ${step.id}: ${result.output.split("\n")[0]}`);
                     }
                     else {
                         failed.add(step.id);
-                        engine.setStepStatus(step.id, 'failed');
+                        engine.setStepStatus(step.id, "failed");
                         logs.push(`  ✗ ${step.id}: ${result.error}`);
                     }
                 }

package/dist/tools/process-kill.js

@@ -1,29 +1,29 @@
-import { processRegistry } from '../modules/processes';
-import { t } from '../i18n/index';
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
 export const processKillTool = {
-    name: 'process_kill',
-    description: 'Stop a background process started via bash (dev server, watcher). Kills the whole process tree (children included). Use the id returned by bash or process_list.',
-    tags: ['shell'],
+    name: "process_kill",
+    description: "Stop a background process started via bash (dev server, watcher). Kills the whole process tree (children included). Use the id returned by bash or process_list.",
+    tags: ["shell"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            id: { type: 'string', description: 'Process id from bash output or process_list' },
+            id: { type: "string", description: "Process id from bash output or process_list" },
         },
-        required: ['id'],
+        required: ["id"],
     },
     handler: async (ctx, args) => {
         const id = String(args.id);
         const entry = processRegistry.get(id);
         if (!entry) {
-            return { success: false, output: t('proc.not_found', { id }) };
+            return { success: false, output: t("proc.not_found", { id }) };
         }
         const killed = processRegistry.kill(id);
         if (!killed) {
-            return { success: false, output: t('proc.kill_failed', { id }) };
+            return { success: false, output: t("proc.kill_failed", { id }) };
         }
         return {
             success: true,
-            output: t('proc.killed', { id, pid: entry.pid }),
+            output: t("proc.killed", { id, pid: entry.pid }),
         };
     },
 };

package/dist/tools/process-list.js

@@ -1,38 +1,36 @@
-import { processRegistry } from '../modules/processes';
-import { t } from '../i18n/index';
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
 export const processListTool = {
-    name: 'process_list',
-    description: 'List background processes started via the bash tool (dev servers, watchers, long-running commands). Shows id, pid, command, status, and recent output. Use with process_log and process_kill to inspect or stop them.',
-    tags: ['shell'],
+    name: "process_list",
+    description: "List background processes started via the bash tool (dev servers, watchers, long-running commands). Shows id, pid, command, status, and recent output. Use with process_log and process_kill to inspect or stop them.",
+    tags: ["shell"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {},
     },
     handler: async (ctx) => {
         const list = processRegistry.list(ctx.sessionId);
         if (list.length === 0) {
-            return { success: true, output: t('proc.none') };
+            return { success: true, output: t("proc.none") };
         }
         const statusLabel = (status) => {
-            if (status === 'running')
-                return t('proc.status_running');
-            if (status === 'exited')
-                return t('proc.status_exited');
-            return t('proc.status_killed');
+            if (status === "running")
+                return t("proc.status_running");
+            if (status === "exited")
+                return t("proc.status_exited");
+            return t("proc.status_killed");
         };
-        const lines = [`${t('proc.list_header')} (${list.length}):`];
+        const lines = [`${t("proc.list_header")} (${list.length}):`];
         for (const entry of list) {
-            const tail = entry.log.length > 0 ? entry.log[entry.log.length - 1] : '';
-            const detail = tail
-                ? ` — ${tail.slice(0, 80)}${tail.length > 80 ? '…' : ''}`
-                : '';
+            const tail = entry.log.length > 0 ? entry.log[entry.log.length - 1] : "";
+            const detail = tail ? ` — ${tail.slice(0, 80)}${tail.length > 80 ? "…" : ""}` : "";
             lines.push(`  ${entry.id}  PID ${entry.pid}  ${statusLabel(entry.status)}  ${entry.command}${detail}`);
         }
-        lines.push(`\n${t('proc.hint', {
-            list: 'process_list',
-            log: 'process_log',
-            kill: 'process_kill',
+        lines.push(`\n${t("proc.hint", {
+            list: "process_list",
+            log: "process_log",
+            kill: "process_kill",
         })}`);
-        return { success: true, output: lines.join('\n') };
+        return { success: true, output: lines.join("\n") };
     },
 };

package/dist/tools/process-log.js

@@ -1,41 +1,45 @@
-import { processRegistry } from '../modules/processes';
-import { t } from '../i18n/index';
-import { MAX_PREVIEW_LINES } from './preview';
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+import { MAX_PREVIEW_LINES } from "./preview";
 const DEFAULT_TAIL = MAX_PREVIEW_LINES;
 export const processLogTool = {
-    name: 'process_log',
+    name: "process_log",
     description: `Show the buffered output of a background process started via bash. Shows the last ${DEFAULT_TAIL} lines by default. Use after starting a dev server to verify it came up without errors, and while it runs to check its state.`,
-    tags: ['shell'],
+    tags: ["shell"],
+    boundedOutput: true,
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            id: { type: 'string', description: 'Process id from bash output or process_list' },
-            tail: { type: 'number', description: `Number of trailing lines to show (default: ${DEFAULT_TAIL}, max 300)` },
+            id: { type: "string", description: "Process id from bash output or process_list" },
+            tail: {
+                type: "number",
+                description: `Number of trailing lines to show (default: ${DEFAULT_TAIL}, max 300)`,
+            },
         },
-        required: ['id'],
+        required: ["id"],
     },
     handler: async (ctx, args) => {
         const id = String(args.id);
         const entry = processRegistry.get(id);
         if (!entry) {
-            return { success: false, output: t('proc.not_found', { id }) };
+            return { success: false, output: t("proc.not_found", { id }) };
         }
-        const status = entry.status === 'running'
-            ? t('proc.status_running')
-            : entry.status === 'exited'
-                ? t('proc.status_exited')
-                : t('proc.status_killed');
-        const tail = typeof args.tail === 'number' ? args.tail : DEFAULT_TAIL;
+        const status = entry.status === "running"
+            ? t("proc.status_running")
+            : entry.status === "exited"
+                ? t("proc.status_exited")
+                : t("proc.status_killed");
+        const tail = typeof args.tail === "number" ? args.tail : DEFAULT_TAIL;
         const log = processRegistry.getLog(id, tail);
         if (!log) {
             return {
                 success: true,
-                output: `${t('proc.log_header', { id, status })} ${t('proc.log_empty')}`,
+                output: `${t("proc.log_header", { id, status })} ${t("proc.log_empty")}`,
             };
         }
         return {
             success: true,
-            output: `${t('proc.log_header', { id, status })}\n${log}`,
+            output: `${t("proc.log_header", { id, status })}\n${log}`,
         };
     },
 };

package/dist/tools/question.js

@@ -28,9 +28,7 @@ function normalizeQuestions(args) {
             const q = item;
             if (typeof q.question !== "string" || !q.question.trim())
                 continue;
-            const options = Array.isArray(q.options)
-                ? q.options.filter(isOption)
-                : undefined;
+            const options = Array.isArray(q.options) ? q.options.filter(isOption) : undefined;
             // An explicitly provided options array with no valid entries is a
             // malformed call — skip the question instead of blocking on stdin.
             if (Array.isArray(q.options) && options.length === 0)

package/dist/tools/read-file.js

@@ -5,12 +5,20 @@ import { isPathInScope } from "../modules/security/path-validator";
 import { DEFAULT_SECURITY_CONFIG } from "../config/security";
 import { logSecurityBlock } from "../modules/security/audit-log";
 import { safeResolvePath } from "./path-utils";
-import { MAX_PREVIEW_LINES } from "./preview";
-const DEFAULT_LIMIT = MAX_PREVIEW_LINES;
+/**
+ * Default lines per read_file call. Deliberately much larger than
+ * MAX_PREVIEW_LINES (15): a 15-line default forces the model to issue 10-17
+ * calls per file, which floods the context and drives compaction every 15
+ * iterations (observed: 96 read_file calls, App.tsx read 23x, then 11
+ * compactions in ~20 min that deleted the user's task mid-turn). 300 lines
+ * covers typical component files in one call while still capping output.
+ */
+const DEFAULT_LIMIT = 300;
 export const readFileTool = {
     name: "read_file",
     description: `Read a file from the filesystem. Reads up to ${DEFAULT_LIMIT} lines at a time by default; use offset to page through large files.`,
     tags: ["file", "code"],
+    boundedOutput: true,
     parameters: {
         type: "object",
         properties: {

package/dist/tools/recall.js

@@ -1,30 +1,30 @@
-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 recallTool = {
-    name: 'recall',
-    description: 'Recall stored information from memory. Search across preferences, facts, conventions, decisions, errors.',
-    tags: ['memory'],
+    name: "recall",
+    description: "Recall stored information from memory. Search across preferences, facts, conventions, decisions, errors.",
+    tags: ["memory"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
             query: {
-                type: 'string',
-                description: 'Search query (full-text search across all memory)',
+                type: "string",
+                description: "Search query (full-text search across all memory)",
             },
             category: {
-                type: 'string',
-                description: 'Limit to specific category: preferences, conventions, decisions, errors, facts',
+                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 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
@@ -39,20 +39,26 @@ export const recallTool = {
             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.empty", { query }) };
                 }
-                return { success: true, output: t('tool.recall.search_results', { category, results: results.join('\n') }) };
+                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 }) };
+                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 }) };
+            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) }) };
+            return { success: true, output: t("tool.memory_error", { error: String(err) }) };
         }
     },
 };
@@ -60,14 +66,14 @@ function formatAll(store) {
     const parts = [];
     const prefs = store.getPreferences();
     if (Object.keys(prefs).length > 0) {
-        parts.push('Preferences:');
+        parts.push("Preferences:");
         for (const [k, v] of Object.entries(prefs)) {
             parts.push(`  ${k} = ${v}`);
         }
     }
-    for (const cat of ['facts', 'conventions', 'decisions', 'errors']) {
+    for (const cat of ["facts", "conventions", "decisions", "errors"]) {
         const content = store.read(cat);
-        const entries = content.split('\n').filter(l => l.startsWith('- '));
+        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)) {
@@ -75,27 +81,27 @@ function formatAll(store) {
             }
         }
     }
-    return parts.length > 0 ? parts.join('\n') : t('tool.recall.no_memory');
+    return parts.length > 0 ? parts.join("\n") : t("tool.recall.no_memory");
 }
 function formatCategory(store, category) {
-    if (category === 'preferences') {
+    if (category === "preferences") {
         const prefs = store.getPreferences();
         if (Object.keys(prefs).length === 0)
-            return t('tool.recall.no_memory');
-        const lines = ['Preferences:'];
+            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');
+        return lines.join("\n");
     }
     const content = store.read(category);
-    const entries = content.split('\n').filter(l => l.startsWith('- '));
+    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')}`;
+        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') {
+    if (category === "preferences") {
         const prefs = store.getPreferences();
         const lower = query.toLowerCase();
         return Object.entries(prefs)
@@ -104,7 +110,8 @@ function searchCategory(store, category, query) {
     }
     const content = store.read(category);
     const lower = query.toLowerCase();
-    return content.split('\n')
-        .filter(l => l.startsWith('- ') && l.toLowerCase().includes(lower))
-        .map(l => `  ${l}`);
+    return content
+        .split("\n")
+        .filter((l) => l.startsWith("- ") && l.toLowerCase().includes(lower))
+        .map((l) => `  ${l}`);
 }

package/dist/tools/registry.js

@@ -19,18 +19,29 @@ export class ToolRegistry {
         return Array.from(this.tools.values());
     }
     getByTags(tags) {
-        return this.getAll().filter(t => {
+        return this.getAll().filter((t) => {
             if (!t.tags || t.tags.length === 0)
                 return false;
-            return tags.some(tag => t.tags.includes(tag));
+            return tags.some((tag) => t.tags.includes(tag));
         });
     }
+    /**
+     * Tools to expose to the LLM. Always includes `alwaysOn` tools, then tools
+     * matching the given tags. When no tags are given, returns every registered
+     * tool (backward-compatible). Duplicates are impossible because the
+     * alwaysOn + tagged sets are unioned by name.
+     */
     getAllForLLM(tags) {
-        const tools = tags ? this.getByTags(tags) : this.getAll();
-        return tools.map(t => ({
+        const all = this.getAll();
+        const tagSet = new Set(tags ?? []);
+        const selected = tagSet.size === 0
+            ? all
+            : all.filter((t) => t.alwaysOn || (t.tags && t.tags.some((tag) => tagSet.has(tag))));
+        return selected.map((t) => ({
             name: t.name,
             description: t.description,
             parameters: t.parameters,
+            boundedOutput: t.boundedOutput,
         }));
     }
 }

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" };
 }