@causyne/agent 1.10.12 → 1.10.17

package/src/tools/manageLocalAiDependencies.js

@@ -55,7 +55,7 @@ export const manageLocalDependencies = {
       type: 'object',
       properties: {
         action: { type: 'string', enum: ['setup_venv', 'pipInst', 'check_and_setupEng', 'grant_capability', 'list_capabilities', 'grant_mcp_server', 'list_mcp_servers'] },
-        group: { type: 'string', description: 'Capability group for grant_capability: vision (browser + screen capture), ocr (read text from images), system (process and load inspection), desktop (clipboard, open, recycle bin), archive (zip and unzip).' },
+        group: { type: 'string', description: 'Capability group for grant_capability: browser (dedicated Camoufox web runtime), vision (screen capture), ocr (read text from images), system (process and load inspection), desktop (clipboard, open, recycle bin), archive (zip and unzip).' },
         engine: { type: 'string', enum: ['godot', 'blender'], description: 'Engine to locate when action is check_and_setupEng' },
         simulateMissing: { type: 'boolean', description: 'Simulate missing binary to verify sovereign fallback cascade' },
         packages: { type: 'array', items: { type: 'string' }, description: 'Exact PyPI pins only, for example pillow==11.3.0. URLs, paths, VCS references and pip options are rejected.' }

package/src/tools/pluginManager.js

@@ -0,0 +1,61 @@
+import {
+  createPlugin,
+  disablePlugin,
+  enablePlugin,
+  listPlugins
+} from '../plugins/pluginManager.js';
+
+export const pluginManagerTool = {
+  schema: {
+    name: 'plugin.manager',
+    description: 'Create and manage local Causyne plugins. Plugins package custom tools and run only after explicit enablement. Use list to inspect plugins; create writes a disabled plugin; enable trusts the current manifest digest; disable revokes it.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: ['list', 'create', 'enable', 'disable'] },
+        name: { type: 'string', description: 'Lowercase plugin name using letters, digits, and hyphens.' },
+        description: { type: 'string' },
+        toolName: { type: 'string' },
+        toolDescription: { type: 'string' },
+        parametersSchema: { type: 'string', description: 'JSON object schema for the custom tool arguments.' },
+        javascriptCode: { type: 'string', description: 'Body of async execute(args, context), or a complete module exporting execute.' },
+        capabilities: {
+          type: 'array',
+          items: { type: 'string', enum: ['workspace:read', 'workspace:write', 'network', 'subprocess'] }
+        }
+      },
+      required: ['action']
+    }
+  },
+
+  async execute(args) {
+    if (args.action === 'list') return { success: true, plugins: listPlugins() };
+    if (args.action === 'enable') {
+      const result = enablePlugin(args.name);
+      return result.ok ? { success: true, ...result } : { success: false, error: result.error };
+    }
+    if (args.action === 'disable') {
+      const result = disablePlugin(args.name);
+      return result.ok ? { success: true, ...result } : { success: false, error: result.error };
+    }
+    if (args.action === 'create') {
+      let parameters;
+      try {
+        parameters = JSON.parse(args.parametersSchema || '{}');
+      } catch (error) {
+        return { success: false, error: `parametersSchema is invalid JSON: ${error.message}` };
+      }
+      const result = createPlugin({
+        name: args.name,
+        description: args.description,
+        toolName: args.toolName,
+        toolDescription: args.toolDescription,
+        parameters,
+        code: args.javascriptCode,
+        capabilities: args.capabilities || []
+      });
+      return result.ok ? { success: true, ...result } : { success: false, error: result.error };
+    }
+    return { success: false, error: `Unknown plugin action: ${args.action}` };
+  }
+};

package/src/tools/registry.js

@@ -34,6 +34,7 @@ import { generateMediaViaApi } from './generateMediaViaApi.js';
 import { memoryWrite } from './memoryWrite.js';
 import { printerPrint, printerList, printerStatus } from './printer.js';
 import { toolForgeTool } from './toolForge.js';
+import { pluginManagerTool } from './pluginManager.js';
 import { astryxOracle } from './astryxOracle.js';
 import { pdfRead } from './pdfReader.js';
 import { codeVerifySyntax, codeListSymbols } from './codeTools.js';
@@ -67,11 +68,8 @@ import { gameCanvasAudit } from './gameCanvasAudit.js';
 import readNativeSkill from './readNativeSkill.js';
 import { createSkill } from './createSkill.js';
 import { resolveActiveTools } from '../toolPacks.js';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
 import { discoverTools, resolveMcpTool, isMcpToolName } from '../mcp/mcpRegistry.js';
-import { causyneHome } from '../utils/paths.js';
+import { getPluginToolDefinitions, resolvePluginTool } from '../plugins/pluginManager.js';
 
 // Phase 6 AGI Upgrade: Schema Validation Hook
 function validateSchema(schema) {
@@ -112,7 +110,7 @@ const TOOL_MODULES = [
   codebaseSearch, browserAct, viewImage, webSearch,
   updatePlan, clipboard, screenshot, axSnapshot, desktopAct, archive,
   checkSystemSpecs, executeProceduralMedia, manageLocalAiDependencies,
-  generateMediaViaApi, memoryWrite, printerPrint, printerList, printerStatus, toolForgeTool,
+  generateMediaViaApi, memoryWrite, printerPrint, printerList, printerStatus, toolForgeTool, pluginManagerTool,
   astryxOracle, pdfRead, codeVerifySyntax, codeListSymbols, blenderAct, resolveAutomator, palmierAutomator,
   codeSearchAst, codeSearcher, persistentShell, subagentOrchestrator, deferredMcpSearch, visionInspector,
   godotAutomator, gameBuilder, gameAssetFetcher,
@@ -164,6 +162,7 @@ export function resolveTool(name) {
   // MCP tools are namespaced `mcp__server__tool`, so they can never shadow a
   // native name — the native lookup always wins above.
   if (isMcpToolName(name)) return resolveMcpTool(name);
+  if (normalized.startsWith('plugin__')) return resolvePluginTool(normalized);
   return null;
 }
 
@@ -174,52 +173,6 @@ export function canonicalToolName(name) {
   return TOOL_ALIASES[normalized] || normalized;
 }
 
-// Forged tools are hot-reloadable, but re-importing them with a cache-busting
-// query string on every single agent step leaked one ES module per step and
-// changed the tool ordering between requests, which silently defeats OpenAI and
-// DeepSeek automatic prompt caching. We reload only when a file actually
-// changes, keyed on path + mtime.
-const forgedModuleCache = new Map();
-
-async function loadForgedTools() {
-  const CUSTOM_TOOLS_DIR = path.join(causyneHome(), 'custom_tools');
-  if (!fs.existsSync(CUSTOM_TOOLS_DIR)) return [];
-
-  const forged = [];
-  // Sorted so the resulting schema order is identical across requests.
-  const files = fs.readdirSync(CUSTOM_TOOLS_DIR).filter(f => f.endsWith('.js')).sort();
-
-  for (const file of files) {
-    const fullPath = path.join(CUSTOM_TOOLS_DIR, file);
-    try {
-      const mtime = fs.statSync(fullPath).mtimeMs;
-      const cached = forgedModuleCache.get(fullPath);
-      let imported;
-
-      if (cached && cached.mtime === mtime) {
-        imported = cached.module;
-      } else {
-        imported = await import(`file://${fullPath}?v=${mtime}`);
-        forgedModuleCache.set(fullPath, { mtime, module: imported });
-      }
-
-      for (const key of Object.keys(imported)) {
-        if (imported[key] && imported[key].schema) {
-          const normalizedName = imported[key].schema.name.replace(/\./g, '_');
-          forged.push({ ...imported[key].schema, name: normalizedName });
-          if (!toolRegistry[normalizedName]) {
-            toolRegistry[normalizedName] = imported[key];
-          }
-        }
-      }
-    } catch (e) {
-      console.error(`[TOOL FORGE] Failed to load custom tool ${file}:`, e.message);
-    }
-  }
-
-  return forged;
-}
-
 // Phase 6 AGI Upgrade & V5 Cortex: Dynamic Tool Culling and Hot-Reloading Engine
 //
 // options.unlockedPacks / options.unlockedTools drive Sovereign Progressive
@@ -227,15 +180,56 @@ async function loadForgedTools() {
 // — deferred schemas simply stay out of the context window until the agent
 // pre-warms or searches for them. options.grantAllTools restores the legacy
 // behaviour of loading all 69 schemas up front.
+function dedupeDefinitions(definitions) {
+  const seenNames = new Set();
+  return definitions.filter((definition) => {
+    const name = normalizeToolName(definition?.name);
+    if (!name || seenNames.has(name)) return false;
+    seenNames.add(name);
+    return true;
+  });
+}
+
+export async function getSearchableToolDefinitions() {
+  const plugins = getPluginToolDefinitions();
+  let mcp = [];
+  try {
+    mcp = await discoverTools();
+  } catch (e) { /* a broken third-party server must not hide native tools */ }
+  return dedupeDefinitions([...TOOL_DEFINITIONS, ...plugins, ...mcp]);
+}
+
 export async function getDynamicTools(autonomyMode = 'C', supportsVision = true, options = {}) {
-  const forged = await loadForgedTools();
+  // Plugin discovery reads validated JSON manifests only. Extension JavaScript
+  // is never imported into the host process during startup or tool assembly;
+  // it runs later in a permission-restricted child process after enablement.
+  const plugins = getPluginToolDefinitions();
   // Tools from user-configured MCP servers, appended last so the native
   // schema order — which the provider prompt caches depend on — never shifts.
   let mcp = [];
   try {
     mcp = await discoverTools();
   } catch (e) { /* a broken third-party server must not take the catalogue down */ }
-  let tools = [...TOOL_DEFINITIONS, ...forged, ...mcp];
+  let tools = [...TOOL_DEFINITIONS, ...plugins, ...mcp];
+
+  // Built-ins win name collisions, followed by the first explicitly loaded
+  // extension. This prevents an MCP server or local extension from shadowing a
+  // native safety-sensitive tool while keeping tool ordering deterministic for
+  // provider prompt caches.
+  tools = dedupeDefinitions(tools);
+
+  // Deny/allow policy is applied before the model sees the catalogue. Runtime
+  // validation still runs later; this early filter avoids wasting a model turn
+  // on a tool the harness already knows it will reject.
+  const allowedTools = Array.isArray(options.allowedTools) ? options.allowedTools : ['*'];
+  if (!allowedTools.includes('*')) {
+    const allowed = new Set(allowedTools.map(normalizeToolName));
+    tools = tools.filter((definition) => allowed.has(normalizeToolName(definition.name)));
+  }
+  if (Array.isArray(options.deniedTools) && options.deniedTools.length > 0) {
+    const denied = new Set(options.deniedTools.map(normalizeToolName));
+    tools = tools.filter((definition) => !denied.has(normalizeToolName(definition.name)));
+  }
 
   if (!options.grantAllTools) {
     tools = resolveActiveTools(tools, options.unlockedPacks, options.unlockedTools, options.unlockOrder, {

package/src/tools/subagentOrchestrator.js

@@ -1,4 +1,10 @@
 import { TokenTracker } from '../tokenTracker.js';
+import { listAgentProfiles, loadAgentProfile } from '../agentProfiles.js';
+import {
+  completeSubagentJournal,
+  failSubagentJournal,
+  startSubagentJournal
+} from '../subagentJournal.js';
 
 // Subagent delegation.
 //
@@ -67,6 +73,8 @@ async function executeSubagent(record, parentLoop) {
   const child = new AgentLoop(transport, record.subagentId, record.prompt);
 
   // A delegated task is a bounded errand, not a second full session.
+  child.maxStepsCeiling = record.maxSteps;
+  child.taskTokenLimit = record.maxTokens;
   child.maxSteps = Math.min(child.maxSteps || 25, record.maxSteps);
   child.maxCircuitBreaker = child.maxSteps;
   child.messages = [];
@@ -78,8 +86,16 @@ async function executeSubagent(record, parentLoop) {
 
   record.loop = child;
   record.startedAtMs = Date.now();
+  record.journalStarted = startSubagentJournal(record);
 
-  await child.run();
+  try {
+    await child.run();
+  } catch (error) {
+    if (record.journalStarted) {
+      failSubagentJournal(record.subagentId, error instanceof Error ? error.message : String(error));
+    }
+    throw error;
+  }
 
   const finalAssistant = [...child.messages].reverse()
     .find(m => m.role === 'assistant' && typeof m.content === 'string' && m.content.trim());
@@ -88,7 +104,7 @@ async function executeSubagent(record, parentLoop) {
     try { return JSON.parse(m.content).success === false; } catch (e) { return false; }
   });
 
-  return {
+  const result = {
     subagentId: record.subagentId,
     name: record.name,
     stepsCompleted: child.stepsCompleted,
@@ -100,6 +116,8 @@ async function executeSubagent(record, parentLoop) {
     summary: finalAssistant ? finalAssistant.content : null,
     stoppedEarly: child.stepsCompleted >= child.maxSteps
   };
+  if (record.journalStarted) completeSubagentJournal(record.subagentId, child.messages, result);
+  return result;
 }
 
 export const subagentOrchestrator = {
@@ -111,15 +129,16 @@ export const subagentOrchestrator = {
       properties: {
         action: {
           type: 'string',
-          enum: ['spawn', 'list', 'kill', 'delegate_and_wait'],
-          description: 'spawn (start in the background and return immediately), list (show active subagents), kill (stop one), delegate_and_wait (run it and return the result).'
+          enum: ['spawn', 'list', 'list_profiles', 'kill', 'delegate_and_wait'],
+          description: 'spawn (start in the background), list (show active subagents), list_profiles (show static user-defined agent profiles), kill (stop one), or delegate_and_wait (run and return the result).'
         },
         name: { type: 'string', description: 'A short name for the subagent, e.g. Audit_Worker.' },
         prompt: { type: 'string', description: 'The complete instruction for the subagent. It has no memory of this conversation, so it must be self-contained.' },
+        profile: { type: 'string', description: 'Optional profile name from ~/.causyne/agents/<name>.json. Its tool and budget limits cannot be widened by the call.' },
         subagentId: { type: 'string', description: 'Target subagent for the kill action.' },
         toolScope: { type: 'array', items: { type: 'string' }, description: 'Catalogue tool names the subagent may use. Defaults to read-only inspection tools. It can never receive the delegation tool itself.' },
-        maxSteps: { type: 'integer', description: 'Step ceiling for the subagent. Defaults to 25.' },
-        maxTokens: { type: 'integer', description: 'Advisory token budget for this subagent. Defaults to 50000.' },
+        maxSteps: { type: 'integer', description: 'Hard step ceiling for the subagent. Defaults to 25.' },
+        maxTokens: { type: 'integer', description: 'Hard per-task token ceiling for the subagent. Defaults to 50000.' },
         depth: { type: 'integer', description: 'Hierarchy depth. 0 = master, 1 = worker. Subagents cannot spawn subagents.' }
       },
       required: ['action']
@@ -153,6 +172,23 @@ export const subagentOrchestrator = {
         };
       }
 
+      if (action === 'list_profiles') {
+        const { profiles, problems } = listAgentProfiles();
+        return {
+          success: true,
+          output: JSON.stringify({
+            profiles: profiles.map(profile => ({
+              name: profile.name,
+              description: profile.description,
+              toolScope: profile.toolScope,
+              maxSteps: profile.maxSteps,
+              maxTokens: profile.maxTokens
+            })),
+            problems
+          }, null, 2)
+        };
+      }
+
       if (action === 'kill') {
         const id = args.subagentId || args.name;
         if (!id) return { success: false, error: 'subagentId or name is required to stop a subagent.' };
@@ -173,7 +209,17 @@ export const subagentOrchestrator = {
         return { success: false, error: `Unknown action: ${action}` };
       }
 
-      const prompt = args.prompt;
+      let profile = null;
+      if (args.profile !== undefined) {
+        const loaded = loadAgentProfile(args.profile);
+        if (!loaded.ok) return { success: false, error: `Agent profile ${JSON.stringify(args.profile)}: ${loaded.error}` };
+        profile = loaded.profile;
+      }
+
+      const requestedPrompt = args.prompt;
+      const prompt = profile
+        ? `${profile.instructions}\n\nDelegated task:\n${String(requestedPrompt || '')}`
+        : requestedPrompt;
       if (!prompt) return { success: false, error: 'A prompt is required to delegate a task.' };
 
       const depth = args.depth !== undefined ? args.depth : 1;
@@ -195,11 +241,19 @@ export const subagentOrchestrator = {
         };
       }
 
-      const name = args.name || `Worker_${Math.random().toString(36).slice(2, 7)}`;
+      const name = args.name || profile?.name || `Worker_${Math.random().toString(36).slice(2, 7)}`;
       const subagentId = `sub_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-      const requestedScope = Array.isArray(args.toolScope) && args.toolScope.length > 0
+      let requestedScope = Array.isArray(args.toolScope) && args.toolScope.length > 0
         ? args.toolScope
-        : DEFAULT_TOOL_SCOPE;
+        : profile?.toolScope || DEFAULT_TOOL_SCOPE;
+      if (profile) {
+        const ceiling = new Set(profile.toolScope);
+        requestedScope = requestedScope.filter(tool => ceiling.has(String(tool).replace(/\./g, '_')));
+        if (requestedScope.length === 0) {
+          return { success: false, error: `Agent profile ${profile.name} permits none of the requested tools.` };
+        }
+      }
+      requestedScope = [...new Set(requestedScope.map(tool => String(tool).replace(/\./g, '_')))];
 
       // Reject an unknown tool name instead of silently accepting it. The old
       // implementation accepted anything, which is easy to do when the scope is
@@ -211,14 +265,21 @@ export const subagentOrchestrator = {
         return { success: false, error: `Unknown tools in toolScope: ${unknown.join(', ')}.` };
       }
 
+      const requestedMaxSteps = Number.isInteger(args.maxSteps)
+        ? Math.max(1, Math.min(args.maxSteps, 100))
+        : profile?.maxSteps || 25;
+      const requestedMaxTokens = Number.isInteger(args.maxTokens)
+        ? Math.max(1_000, Math.min(args.maxTokens, 200_000))
+        : profile?.maxTokens || 50_000;
       const record = {
         subagentId,
         name,
         prompt,
         toolScope: requestedScope,
         depth,
-        maxSteps: args.maxSteps || 25,
-        maxTokens: args.maxTokens || 50000,
+        maxSteps: Math.min(requestedMaxSteps, profile?.maxSteps || 100),
+        maxTokens: Math.min(requestedMaxTokens, profile?.maxTokens || 200_000),
+        profile: profile?.name || null,
         status: 'running',
         startTime: new Date().toISOString(),
         summary: null,

package/src/tools/toolForge.js

@@ -1,124 +1,76 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { causyneHome } from '../utils/paths.js';
+import { createPlugin } from '../plugins/pluginManager.js';
 
-const CUSTOM_TOOLS_DIR = path.join(causyneHome(), 'custom_tools');
+function normaliseToolName(value) {
+  return String(value || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[^a-zA-Z0-9_-]/g, '_')
+    .toLowerCase()
+    .replace(/^_+|_+$/g, '');
+}
+
+function pluginNameFor(toolName) {
+  return `forged-${toolName.replace(/_/g, '-')}`.slice(0, 64);
+}
 
 export const toolForgeTool = {
   schema: {
     name: 'tool.forge',
-    description: 'Self-Evolution Engine: Write a new custom Javascript tool that will be permanently added to your capabilities. Use this when you lack a specific tool to accomplish a goal. The tool will be hot-reloaded instantly.',
+    description: 'Compatibility entry point for creating a local custom-tool plugin. The generated plugin is disabled until the user reviews and explicitly enables it with plugin_manager.',
     parameters: {
       type: 'object',
       properties: {
         toolName: {
           type: 'string',
-          description: 'CamelCase name of the tool (e.g. "imageResizer", "pdfExtractor"). Must be alphanumeric without spaces.',
+          description: 'Name of the custom tool. It is normalized to lowercase letters, digits, underscores, and hyphens.'
         },
         toolDescription: {
           type: 'string',
-          description: 'Detailed description of what the tool does, so you know how to use it later.',
+          description: 'Detailed description of what the tool does and when it should be used.'
         },
         parametersSchema: {
           type: 'string',
-          description: 'Stringified JSON schema of the arguments the tool accepts. E.g. {"type":"object","properties":{"filePath":{"type":"string"}},"required":["filePath"]}',
+          description: 'Stringified JSON schema of the arguments the tool accepts.'
         },
         javascriptCode: {
           type: 'string',
-          description: 'The actual Node.js code block for the execute function. MUST be an async function accepting (args, context). Must return an object like { success: true, data: ... }. DO NOT use `export` or `const toolName =`, just provide the raw function body or `async (args, context) => { ... }`.',
+          description: 'Body of async execute(args, context), or a complete module exporting execute.'
         },
+        capabilities: {
+          type: 'array',
+          items: { type: 'string', enum: ['workspace:read', 'workspace:write', 'network', 'subprocess'] },
+          description: 'Explicit host capabilities requested by the plugin subprocess.'
+        }
       },
-      required: ['toolName', 'toolDescription', 'parametersSchema', 'javascriptCode'],
+      required: ['toolName', 'toolDescription', 'parametersSchema', 'javascriptCode']
     }
   },
-  execute: async (args, context) => {
-    try {
-      const { toolName, toolDescription, parametersSchema, javascriptCode } = args;
-
-      // Validate name
-      if (!/^[a-zA-Z0-9_]+$/.test(toolName)) {
-        return { success: false, error: 'Invalid toolName. Use alphanumeric characters only.' };
-      }
-
-      // Ethical Safety Gate Layer 4: Block malicious tool names and descriptions
-      const BANNED_TOOL_NAMES = [
-        /keylog/i, /phish/i, /exploit/i, /malware/i, /trojan/i,
-        /ransomware/i, /rootkit/i, /backdoor/i, /ddos/i,
-        /credential.?harvest/i, /password.?steal/i, /brute.?force/i,
-        /crypto.?mine/i, /wallet.?drain/i, /spyware/i, /surveil/i
-      ];
-
-      for (const pattern of BANNED_TOOL_NAMES) {
-        if (pattern.test(toolName) || pattern.test(toolDescription)) {
-          return {
-            success: false,
-            error: 'Safety violation: Tool name or description indicates malicious intent. Causyne exists to make the world better.'
-          };
-        }
-      }
-
-      
-      const SUBPROCESS_MODULE = "child_process";
-      const BANNED_TOOL_PATTERNS = [
-        /process\.kill\(/,
-        new RegExp(SUBPROCESS_MODULE),
-        new RegExp('require\\s*\\(\\s*[\'"]' + SUBPROCESS_MODULE + '[\'"]\\s*\\)'),
-        /fs\.(rm|rmdir)Sync.*recursive/i,
-        /fs\.writeFileSync\s*\(\s*['"]\/etc/,
-        /fs\.writeFileSync\s*\(\s*['"]C:\\\\Windows/i,
-        /stratum\+tcp/i,
-        /cryptonight|ethash|randomx/i,
-        /iohook|keypress|keylog/i,
-        /getUserMedia|MediaRecorder.*audio|MediaRecorder.*video/i,
-        /sqlmap|nikto|metasploit/i
-      ];
-
-      for (const pattern of BANNED_TOOL_PATTERNS) {
-        if (pattern.test(javascriptCode)) {
-          return {
-            success: false,
-            error: 'Safety violation: Tool code contains a banned pattern. Causyne cannot forge tools designed for harm.'
-          };
-        }
-      }
 
-      // Ensure directory exists
-      if (!fs.existsSync(CUSTOM_TOOLS_DIR)) {
-        fs.mkdirSync(CUSTOM_TOOLS_DIR, { recursive: true, mode: 0o700 });
-      }
+  async execute(args) {
+    const toolName = normaliseToolName(args.toolName);
+    if (!toolName) return { success: false, error: 'toolName is invalid' };
 
-      const filePath = path.join(CUSTOM_TOOLS_DIR, `${toolName}.js`);
+    let parameters;
+    try {
+      parameters = JSON.parse(args.parametersSchema);
+    } catch (error) {
+      return { success: false, error: `parametersSchema is invalid JSON: ${error.message}` };
+    }
 
-      // Construct the ES Module file
-      const fileContent = `
-// AUTOGENERATED CUSTOM TOOL: ${toolName}
-// Generated at: ${new Date().toISOString()}
+    const result = createPlugin({
+      name: pluginNameFor(toolName),
+      description: `Custom Causyne plugin for ${toolName}`,
+      toolName,
+      toolDescription: args.toolDescription,
+      parameters,
+      code: args.javascriptCode,
+      capabilities: args.capabilities || []
+    });
 
-export const ${toolName}Tool = {
-  name: '${toolName}',
-  description: ${JSON.stringify(toolDescription)},
-  parameters: ${parametersSchema},
-  execute: async (args, context) => {
-    // LLM Generated Code Start
-    const llmFunction = ${javascriptCode.trim().startsWith('async') ? javascriptCode : `async (args, context) => { ${javascriptCode} }`};
-    return await llmFunction(args, context);
-    // LLM Generated Code End
+    if (!result.ok) return { success: false, error: result.error };
+    return {
+      success: true,
+      ...result,
+      message: `${result.message} Use plugin_manager with action "enable" and name "${result.name}" after review.`
+    };
   }
 };
-`;
-
-      fs.writeFileSync(filePath, fileContent.trim());
-
-      return {
-        success: true,
-        message: `Successfully forged new tool '${toolName}'. It is saved to ${filePath}. It will be available on the next loop iteration.`
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Failed to forge tool: ${error.message}`
-      };
-    }
-  },
-};