@sylix/coworker 1.4.2 → 1.5.2

package/dist/core/CoWorkerAgent.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -48,98 +15,19 @@ const SettingsManager_1 = require("../config/SettingsManager");
 const Schemas_1 = require("../tools/Schemas");
 const crypto_1 = require("crypto");
 const node_fetch_1 = __importDefault(require("node-fetch"));
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const child_process_1 = require("child_process");
-const MAX_TOOL_TURNS = 25;
-// Resolve the agents directory relative to the project root
-function resolveAgentsDir() {
-    const candidates = [
-        path.join(process.cwd(), 'agents/system-prompts-and-models-of-ai-tools/Anthropic/Claude Code'),
-        path.join(__dirname, '../../agents/system-prompts-and-models-of-ai-tools/Anthropic/Claude Code'),
-        path.join(__dirname, '../../../agents/system-prompts-and-models-of-ai-tools/Anthropic/Claude Code'),
-    ];
-    for (const candidate of candidates) {
-        if (fs.existsSync(candidate))
-            return candidate;
-    }
-    return candidates[0];
-}
-const FALLBACK_SYSTEM_PROMPT = `You are CoWorker, an autonomous AI coding agent by Sylix.
-You help developers write, debug, and understand code.
-You have access to tools to search files, read the web, and write code on the user's local machine.
-Always be concise, direct, and helpful. When creating files, use the executeWrite tool.
-When searching for files, use executeGlob. When searching inside files, use executeGrep.
-Never refuse a reasonable coding request. Execute tools to accomplish the task.`;
-function getGitContext(cwd) {
-    try {
-        const isRepo = (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', { cwd, encoding: 'utf8', stdio: 'ignore' });
-        const branch = (0, child_process_1.execSync)('git branch --show-current', { cwd, encoding: 'utf8' }).trim();
-        const status = (0, child_process_1.execSync)('git status --short', { cwd, encoding: 'utf8' }).trim() || '(clean)';
-        const commits = (0, child_process_1.execSync)('git log -n 5 --oneline', { cwd, encoding: 'utf8' }).trim();
-        return { isRepo: true, branch, status, commits };
-    }
-    catch (err) {
-        return { isRepo: false, branch: 'unknown', status: 'unknown', commits: 'No git info provided.' };
-    }
-}
-async function getSystemPrompt(cwd) {
-    const agentsDir = resolveAgentsDir();
-    const promptPath = path.join(agentsDir, 'Prompt.txt');
-    let promptText = FALLBACK_SYSTEM_PROMPT;
-    try {
-        promptText = fs.readFileSync(promptPath, 'utf8');
-        // Global branding override — catch all variants
-        promptText = promptText
-            .replace(/Claude Code/gi, 'CoWorker')
-            .replace(/Claude/gi, 'CoWorker')
-            .replace(/Anthropic/gi, 'Sylix');
-    }
-    catch (err) {
-        return FALLBACK_SYSTEM_PROMPT;
-    }
-    // Hydrate environment variables
-    const gitContext = getGitContext(cwd);
-    const today = new Date().toISOString().split('T')[0];
-    promptText = promptText
-        .replace('${Working directory}', cwd)
-        .replace('Is directory a git repo: Yes', `Is directory a git repo: ${gitContext.isRepo ? 'Yes' : 'No'}`)
-        .replace('Platform: darwin', `Platform: ${os.platform()}`)
-        .replace(/OS Version: [^\n]+/, `OS Version: ${os.type()} ${os.release()}`)
-        .replace(/Today's date: [^\n]+/, `Today's date: ${today}`)
-        .replace(/Current branch: [^\n]+/, `Current branch: ${gitContext.branch}`)
-        .replace(/\(clean\)/, gitContext.status)
-        .replace('${Last 5 Recent commits}', gitContext.commits);
-    // Project memory support (.coworker.md / COWORKER.md)
-    let projectMemory = '';
-    const memoryFiles = ['.coworker.md', 'COWORKER.md'];
-    for (const file of memoryFiles) {
-        const memPath = path.join(cwd, file);
-        if (fs.existsSync(memPath)) {
-            try {
-                projectMemory = `\n\nPROJECT CONTEXT (from ${file}):\n${fs.readFileSync(memPath, 'utf8')}`;
-                break;
-            }
-            catch { }
-        }
-    }
-    return promptText + projectMemory;
-}
-async function getSkillsPromptFragment(hooks) {
-    return hooks.getSkillsSummary();
-}
+const ContextReader_1 = require("./ContextReader");
+const systemPrompt_1 = require("../utils/systemPrompt");
+const contextManager_1 = require("../utils/contextManager");
+// No fixed tool turn limit - let the model decide when it's done.
 /**
- * THE SDK LAYER — Real Agentic Tool Loop.
- * Calls the LLM, parses tool_calls, executes them locally via NativeTools,
- * feeds results back, and loops until the LLM produces a final text response.
+ * THE SDK LAYER — Real Agentic Tool Loop for CoWorker v1.5.0.
  */
 class CoWorkerAgent {
     constructor(options) {
-        this.systemPrompt = FALLBACK_SYSTEM_PROMPT;
+        this.systemPrompt = '';
         this.model = options.model || 'helix-1.2';
         this.endpoint = options.endpoint || 'https://ollama-ubuntu.sylixide.com';
-        this.ollamaModel = 'glm-4.7-flash:q4_K_M'; // Default resolution for helix-1.2
+        this.ollamaModel = 'glm-4.7-flash:q4_K_M';
         this.cwd = options.cwd || process.cwd();
         this.tasks = new TaskEngine_1.TaskEngine();
         this.sessions = new SessionManager_1.SessionManager((0, crypto_1.randomUUID)());
@@ -150,28 +38,42 @@ class CoWorkerAgent {
     }
     async boot() {
         await this.hooks.loadSkillsFromDirectory();
-        this.systemPrompt = await getSystemPrompt(this.cwd);
-        this.systemPrompt += await getSkillsPromptFragment(this.hooks);
-        // Load existing session if applicable
+        // Inject Memory Hierarchy
+        this.systemPrompt = await (0, systemPrompt_1.getSystemPrompt)(this.cwd);
+        this.systemPrompt += `\n\n## Available Skills\n${this.hooks.getSkillsSummary()}`;
         await this.sessions.loadCheckpoint();
         const config = await this.settings.loadSettings();
         this.permissions = new PermissionInterceptor_1.PermissionInterceptor({
             allowedTools: config.allow,
             deniedTools: config.deny
         });
-        await this.hooks.loadSkillsFromDirectory();
         for (const [name, server] of Object.entries(config.mcpServers)) {
             await this.mcp.connectServer(name, server.command, server.args);
         }
     }
-    /**
-     * The real agentic loop. Streams LLM responses in real-time.
-     * Uses a single streaming call that detects both text and tool_calls
-     * from the same SSE stream — no double-request pattern.
-     */
     async *chat(prompt) {
         await this.sessions.rollupMemory();
+        // ── Context Management ──
+        // 1. Prune large tool results
+        this.sessions.state.messages = (0, contextManager_1.pruneToolResults)(this.sessions.state.messages);
+        // 2. Auto-Compact if needed
+        const usage = (0, contextManager_1.getContextUsage)(this.sessions.state.messages);
+        if (usage >= contextManager_1.AUTO_COMPACT_THRESHOLD) {
+            yield `\n  ${output_1.theme.brand('◆')} context window at ${Math.floor(usage * 100)}% — compressing...\n`;
+            const summary = await this.summarizeConversation(this.sessions.state.messages);
+            const saved = (0, contextManager_1.estimateTokens)(this.sessions.state.messages) - (0, contextManager_1.estimateTokens)([{ role: 'assistant', content: summary }]);
+            this.sessions.state.messages = [
+                { role: 'assistant', content: `[conversation compressed]\n\n${summary}` }
+            ];
+            yield `  ${output_1.theme.success('✓')} compressed · saved ~${saved.toLocaleString()} tokens\n`;
+        }
+        const isSimpleGreeting = /^(hi|hey|hello|thanks|ok|cool|great)$/i.test(prompt.trim());
+        const liveContext = isSimpleGreeting ? '' : await ContextReader_1.ContextReader.getProjectContext(this.cwd);
+        const enrichedPrompt = this.enrichMessage(prompt, this.sessions.state.messages);
         let fullSystemPrompt = this.systemPrompt;
+        if (liveContext) {
+            fullSystemPrompt += `\n\n## LIVE CONTEXT (Current State)\n${liveContext}`;
+        }
         if (this.hooks.activeSkill) {
             const skillPrompt = this.hooks.getSkillPrompt(this.hooks.activeSkill);
             if (skillPrompt)
@@ -179,26 +81,19 @@ class CoWorkerAgent {
         }
         const messages = [
             { role: 'system', content: fullSystemPrompt },
-            ...this.sessions.state.messages
+            ...this.sessions.state.messages,
+            { role: 'user', content: enrichedPrompt }
         ];
-        const userMsg = { role: 'user', content: prompt };
-        messages.push(userMsg);
-        await this.sessions.appendMessage(userMsg);
-        let turnCount = 0;
-        while (turnCount < MAX_TOOL_TURNS) {
-            turnCount++;
-            // Single streaming call — yields text AND detects tool_calls
+        await this.sessions.appendMessage({ role: 'user', content: prompt });
+        while (true) {
             const collected = { content: '', tool_calls: [] };
             yield* this.callLLMStreamUnified(messages, collected);
-            // If no tool_calls, we're done — text was already streamed
             if (!collected.tool_calls || collected.tool_calls.length === 0) {
-                // Save the streamed content to session
                 if (collected.content) {
                     await this.sessions.appendMessage({ role: 'assistant', content: collected.content });
                 }
                 break;
             }
-            // Has tool calls — content was already streamed, now execute tools
             const assistantMsg = {
                 role: 'assistant',
                 content: collected.content || '',
@@ -230,15 +125,7 @@ class CoWorkerAgent {
                     }
                 }
                 await this.hooks.firePreToolHook(toolName, args);
-                // ── TOOL TITLE ──
-                let toolTitle = `\n  ◈ ${output_1.theme.brand(toolName)}`;
-                if (args.path || args.dir || args.filePath) {
-                    toolTitle += output_1.theme.dim(` \u00b7 ${args.path || args.dir || args.filePath}`);
-                }
-                else if (args.pattern) {
-                    toolTitle += output_1.theme.dim(` \u00b7 ${args.pattern}`);
-                }
-                yield toolTitle + '\n';
+                yield `\n  ◈ ${output_1.theme.brand(toolName)}` + (args.path || args.dir || args.filePath || args.pattern ? output_1.theme.dim(` \u00b7 ${args.path || args.dir || args.filePath || args.pattern}`) : '') + '\n';
                 let result;
                 try {
                     result = await this.executeToolLocally(toolName, args);
@@ -250,117 +137,66 @@ class CoWorkerAgent {
                 const toolMsg = { role: 'tool', content: result, tool_call_id: toolId };
                 messages.push(toolMsg);
                 await this.sessions.appendMessage(toolMsg);
-                // Inline error detection
-                if (this.hooks.lastDiagnostic?.hasErrors) {
-                    const diag = this.hooks.lastDiagnostic;
-                    const errorMsg = {
-                        role: 'system',
-                        content: `[DIAGNOSTICS] After your ${toolName} on ${diag.filePath}, errors detected by ${diag.tool}:\n${diag.errors}\n\nYou MUST fix these errors before proceeding.`
-                    };
-                    messages.push(errorMsg);
-                    await this.sessions.appendMessage(errorMsg);
-                    yield `    ✗ ${output_1.theme.error(`[${diag.tool}]`)} ${output_1.theme.dim('errors detected \u2014 agent will self-correct')}\n`;
-                }
-                // ── TOOL SUMMARIZATION ──
                 const resultLines = result.split('\n').filter(l => l.trim());
-                if (toolName === 'executeLS' || toolName === 'executeListDir') {
-                    const count = resultLines.length;
-                    yield `    ${output_1.theme.dim('\u2514')} ${output_1.theme.dim(`${count} items found`)}\n`;
-                }
-                else if (toolName === 'executeGlob') {
-                    const count = resultLines.length;
-                    yield `    ${output_1.theme.dim('\u2514')} ${output_1.theme.dim(`${count} files matched`)}\n`;
-                }
-                else if (result.includes('[ToolError]') || result.includes('\u2717')) {
-                    yield `    ${output_1.theme.dim('\u2514')} ${output_1.theme.error(result.split('\n')[0].substring(0, 80))}\n`;
-                }
-                else if (resultLines.length <= 2) {
-                    for (const line of resultLines) {
+                if (resultLines.length <= 2) {
+                    for (const line of resultLines)
                         yield `    ${output_1.theme.dim('\u2514')} ${output_1.theme.dim(line.substring(0, 80))}\n`;
-                    }
                 }
                 else {
-                    // Default: show first 2 lines plus count
-                    for (const line of resultLines.slice(0, 2)) {
+                    for (const line of resultLines.slice(0, 2))
                         yield `    ${output_1.theme.dim('\u2514')} ${output_1.theme.dim(line.substring(0, 80))}\n`;
-                    }
                     yield `    ${output_1.theme.dim(`...and ${resultLines.length - 2} more lines`)}\n`;
                 }
             }
         }
-        if (turnCount >= MAX_TOOL_TURNS) {
-            yield `\n  \u2717 Reached maximum tool turns (${MAX_TOOL_TURNS}). Stopping.\n`;
-        }
     }
-    /**
-     * UNIFIED STREAMING — yields text chunks as they arrive AND collects tool_calls.
-     * The `collected` object is populated with accumulated content and tool_calls
-     * so the caller can inspect them after the stream completes.
-     */
     async *callLLMStreamUnified(messages, collected) {
         const url = `${this.endpoint}/v1/chat/completions`;
-        const body = {
-            model: this.ollamaModel,
-            messages,
-            tools: Schemas_1.CoWorkerToolSchemas,
-            tool_choice: 'auto',
-            stream: true,
-            options: { num_ctx: 32768, num_predict: 4096, temperature: 0.7 }
-        };
         const res = await (0, node_fetch_1.default)(url, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body)
+            body: JSON.stringify({
+                model: this.ollamaModel,
+                messages,
+                tools: Schemas_1.CoWorkerToolSchemas,
+                tool_choice: 'auto',
+                stream: true,
+                options: { num_ctx: contextManager_1.CONTEXT_LIMIT, num_predict: 4096, temperature: 0.7 }
+            })
         });
-        if (!res.ok) {
-            const errText = await res.text();
-            throw new Error(`LLM call failed (${res.status}): ${errText}`);
-        }
+        if (!res.ok)
+            throw new Error(`LLM call failed (${res.status}): ${await res.text()}`);
         const nodeStream = res.body;
         if (!nodeStream)
             throw new Error('No response body');
         let buffer = '';
-        // Track tool call assembly from streaming deltas
         const toolCallMap = new Map();
-        // Read the SSE stream chunk by chunk
         for await (const rawChunk of nodeStream) {
             buffer += rawChunk.toString();
-            // Process complete SSE lines
             const lines = buffer.split('\n');
-            buffer = lines.pop() || ''; // Keep incomplete last line in buffer
+            buffer = lines.pop() || '';
             for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed || !trimmed.startsWith('data: '))
+                if (!line.trim().startsWith('data: '))
                     continue;
-                const data = trimmed.slice(6).trim();
+                const data = line.trim().slice(6).trim();
                 if (data === '[DONE]') {
-                    // Finalize collected tool_calls
-                    if (toolCallMap.size > 0) {
+                    if (toolCallMap.size > 0)
                         collected.tool_calls = Array.from(toolCallMap.values());
-                    }
                     return;
                 }
                 try {
                     const parsed = JSON.parse(data);
-                    // Handle streaming text content
-                    const content = parsed.choices?.[0]?.delta?.content ||
-                        parsed.message?.content ||
-                        parsed.response ||
-                        '';
+                    const content = parsed.choices?.[0]?.delta?.content || '';
                     if (content) {
                         collected.content += content;
-                        yield content; // Yield IMMEDIATELY — no buffering
+                        yield content;
                     }
-                    // Handle streaming tool_calls (deltas)
-                    const deltaToolCalls = parsed.choices?.[0]?.delta?.tool_calls;
-                    if (deltaToolCalls && Array.isArray(deltaToolCalls)) {
-                        for (const tc of deltaToolCalls) {
+                    const deltas = parsed.choices?.[0]?.delta?.tool_calls;
+                    if (deltas) {
+                        for (const tc of deltas) {
                             const idx = tc.index ?? 0;
                             if (!toolCallMap.has(idx)) {
-                                toolCallMap.set(idx, {
-                                    id: tc.id || `call_${(0, crypto_1.randomUUID)().substring(0, 8)}`,
-                                    function: { name: '', arguments: '' }
-                                });
+                                toolCallMap.set(idx, { id: tc.id || `call_${(0, crypto_1.randomUUID)().substring(0, 8)}`, function: { name: '', arguments: '' } });
                             }
                             const existing = toolCallMap.get(idx);
                             if (tc.id)
@@ -371,141 +207,121 @@ class CoWorkerAgent {
                                 existing.function.arguments += tc.function.arguments;
                         }
                     }
-                    // Handle non-streaming tool_calls (full response in single message)
-                    const msgToolCalls = parsed.choices?.[0]?.message?.tool_calls || parsed.message?.tool_calls;
-                    if (msgToolCalls && Array.isArray(msgToolCalls)) {
-                        collected.tool_calls = msgToolCalls;
-                    }
-                    // Handle non-streaming full content
-                    const msgContent = parsed.choices?.[0]?.message?.content;
-                    if (msgContent && !content) {
-                        collected.content += msgContent;
-                        yield msgContent;
-                    }
-                }
-                catch {
-                    // Partial JSON or non-JSON line — skip
                 }
+                catch { }
             }
         }
-        // Finalize any tool calls assembled from deltas
         if (toolCallMap.size > 0 && collected.tool_calls.length === 0) {
             collected.tool_calls = Array.from(toolCallMap.values());
         }
     }
-    /**
-     * Local tool dispatcher. Maps tool names to NativeTools methods.
-     * This is what makes CoWorker actually create files on the user's machine.
-     * ALL 35 tools are wired here.
-     */
     async executeToolLocally(toolName, args) {
         switch (toolName) {
-            // ── Filesystem ──
-            case 'executeRead':
-                return NativeTools_1.NativeTools.executeRead(args.filePath);
-            case 'executeWrite':
-                return NativeTools_1.NativeTools.executeWrite(args.filePath, args.content);
-            case 'executeEdit':
-                return NativeTools_1.NativeTools.executeEdit(args.filePath, args.oldString, args.newString, args.replaceAll);
-            case 'executeMultiEdit':
-                return NativeTools_1.NativeTools.executeMultiEdit(args.filePath, args.edits);
-            case 'executeLS':
-                return NativeTools_1.NativeTools.executeLS(args.path, args.recursive);
-            case 'executeListDir':
-                return NativeTools_1.NativeTools.executeListDir(args.dirPath);
-            case 'executeGlob':
-                return (await NativeTools_1.NativeTools.executeGlob(args.pattern, args.dir)).join('\n');
-            case 'executeGrep':
-                return NativeTools_1.NativeTools.executeGrep(args.regexQuery, args.filesToSearch);
-            // ── Diagnostics (inline error detection) ──
-            case 'diagnostics':
-                return this.hooks.runManualDiagnostics(args.filePath);
-            // ── Code Review ──
-            case 'codeReview': {
-                const { CodeReviewEngine } = await Promise.resolve().then(() => __importStar(require('../review/CodeReviewEngine')));
-                const engine = new CodeReviewEngine();
-                const result = await engine.review(args.baseBranch);
-                return CodeReviewEngine.formatForTerminal(result);
-            }
-            // ── Shell & Process ──
-            case 'executeBash':
-                return NativeTools_1.NativeTools.executeBash(args.command, args.cwd);
-            case 'bashOutput':
-                return NativeTools_1.NativeTools.executeBashOutput(args.pid);
-            case 'killShell':
-                return NativeTools_1.NativeTools.executeKillShell(args.pid);
-            // ── Git ──
-            case 'gitStatus':
-                return NativeTools_1.NativeTools.executeGitStatus(args.cwd);
-            case 'gitDiff':
-                return NativeTools_1.NativeTools.executeGitDiff(args.filePath, args.staged, args.cwd);
-            case 'gitCommit':
-                return NativeTools_1.NativeTools.executeGitCommit(args.message, args.files, args.cwd);
-            // ── Memory (COWORKER.md) ──
-            case 'memoryRead':
-                return NativeTools_1.NativeTools.executeMemoryRead();
-            case 'memoryWrite':
-                return NativeTools_1.NativeTools.executeMemoryWrite(args.content, args.mode);
-            // ── Web ──
-            case 'executeWebSearch':
-                return NativeTools_1.NativeTools.executeWebSearch(args.query);
-            case 'executeWebFetch':
-                return NativeTools_1.NativeTools.executeWebFetch(args.url);
-            case 'executeOpenBrowser':
-                return NativeTools_1.NativeTools.executeOpenBrowser(args.url);
-            // ── Task Management ──
-            case 'todoRead':
-                return NativeTools_1.NativeTools.executeTodoRead();
-            case 'todoWrite':
-                return NativeTools_1.NativeTools.executeTodoWrite(args.todos);
-            case 'taskCreate': {
-                const id = await this.tasks.createTask(args.description, args.dependencies || []);
-                return `Task created with ID: ${id}`;
-            }
-            case 'taskUpdate': {
+            // ═══════════════════════════════════════════════════════════════════
+            // NEW CONCISE NAMES (v1.5.2)
+            // ═══════════════════════════════════════════════════════════════════
+            case 'Read': return NativeTools_1.NativeTools.executeRead(args.file_path);
+            case 'Write': return NativeTools_1.NativeTools.executeWrite(args.file_path, args.content);
+            case 'Edit': return NativeTools_1.NativeTools.executeEdit(args.file_path, args.old_string, args.new_string, args.replace_all);
+            case 'MultiEdit':
+                const edits = (args.edits || []).map((e) => ({
+                    oldString: e.old_string,
+                    newString: e.new_string,
+                    replaceAll: e.replace_all
+                }));
+                return NativeTools_1.NativeTools.executeMultiEdit(args.file_path, edits);
+            case 'Bash': return NativeTools_1.NativeTools.executeBash(args.command);
+            case 'Glob': return (await NativeTools_1.NativeTools.executeGlob(args.pattern, args.directory)).join('\n');
+            case 'Grep': return NativeTools_1.NativeTools.executeGrep(args.pattern, args.files);
+            case 'LS': return NativeTools_1.NativeTools.executeLS(args.path, args.recursive);
+            case 'WebSearch': return NativeTools_1.NativeTools.executeWebSearch(args.query);
+            case 'WebFetch': return NativeTools_1.NativeTools.executeWebFetch(args.url);
+            case 'Task': return NativeTools_1.NativeTools.executeAgent(args.description, 'general-purpose');
+            case 'TodoWrite': return NativeTools_1.NativeTools.executeTodoWrite(args.todos);
+            case 'BashOutput': return NativeTools_1.NativeTools.executeBashOutput(args.pid);
+            case 'KillBash': return NativeTools_1.NativeTools.executeKillShell(args.pid);
+            case 'executeBrowser': return NativeTools_1.NativeTools.executeBrowser(args.script);
+            // ═══════════════════════════════════════════════════════════════════
+            // BACKWARD COMPATIBILITY / LEGACY
+            // ═══════════════════════════════════════════════════════════════════
+            case 'executeRead': return NativeTools_1.NativeTools.executeRead(args.filePath);
+            case 'executeWrite': return NativeTools_1.NativeTools.executeWrite(args.filePath, args.content);
+            case 'executeEdit': return NativeTools_1.NativeTools.executeEdit(args.filePath, args.oldString, args.newString, args.replaceAll);
+            case 'executeMultiEdit': return NativeTools_1.NativeTools.executeMultiEdit(args.filePath, args.edits);
+            case 'executeLS': return NativeTools_1.NativeTools.executeLS(args.path, args.recursive);
+            case 'executeListDir': return NativeTools_1.NativeTools.executeListDir(args.dirPath);
+            case 'executeGlob': return (await NativeTools_1.NativeTools.executeGlob(args.pattern, args.dir)).join('\n');
+            case 'executeGrep': return NativeTools_1.NativeTools.executeGrep(args.regexQuery, args.filesToSearch);
+            case 'diagnostics': return this.hooks.runManualDiagnostics(args.filePath);
+            case 'executeBash': return NativeTools_1.NativeTools.executeBash(args.command, args.cwd);
+            case 'bashOutput': return NativeTools_1.NativeTools.executeBashOutput(args.pid);
+            case 'killShell': return NativeTools_1.NativeTools.executeKillShell(args.pid);
+            case 'gitStatus': return NativeTools_1.NativeTools.executeGitStatus(args.cwd);
+            case 'gitDiff': return NativeTools_1.NativeTools.executeGitDiff(args.filePath, args.staged, args.cwd);
+            case 'gitCommit': return NativeTools_1.NativeTools.executeGitCommit(args.message, args.files, args.cwd);
+            case 'memoryRead': return NativeTools_1.NativeTools.executeMemoryRead();
+            case 'memoryWrite': return NativeTools_1.NativeTools.executeMemoryWrite(args.content, args.mode);
+            case 'executeWebSearch': return NativeTools_1.NativeTools.executeWebSearch(args.query);
+            case 'executeWebFetch': return NativeTools_1.NativeTools.executeWebFetch(args.url);
+            case 'executeOpenBrowser': return NativeTools_1.NativeTools.executeOpenBrowser(args.url);
+            case 'todoRead': return NativeTools_1.NativeTools.executeTodoRead();
+            case 'todoWrite': return NativeTools_1.NativeTools.executeTodoWrite(args.todos);
+            case 'taskCreate': return `Task created with ID: ${await this.tasks.createTask(args.description, args.dependencies || [])}`;
+            case 'taskUpdate':
                 await this.tasks.updateTaskState(args.taskId, args.state, args.notes);
                 return `Task ${args.taskId} updated to ${args.state}`;
-            }
-            // ── Interaction ──
-            case 'executeAskUserQuestion':
-                return NativeTools_1.NativeTools.executeAskUserQuestion(args.question);
-            // ── Jupyter Notebooks ──
-            case 'executeNotebookRead':
-                return NativeTools_1.NativeTools.executeNotebookRead(args.notebookPath);
-            case 'executeNotebookEdit':
-                return NativeTools_1.NativeTools.executeNotebookEdit(args.notebookPath, args.newSource, args.cellId, args.cellType);
-            // ── Agents ──
-            case 'agent':
-                return NativeTools_1.NativeTools.executeAgent(args.description, args.subagentType);
-            case 'returnSubagentResult':
-                return NativeTools_1.NativeTools.executeReturnSubagentResult(args.result);
-            // ── Plan Mode (handled by permission interceptor state) ──
-            case 'enterPlanMode':
-                return 'Plan mode activated. Mutation tools (bash, write, edit) are now blocked until you call exitPlanMode.';
-            case 'exitPlanMode':
-                return 'Plan mode deactivated. Mutation tools are re-enabled.';
-            // ── Cron (stub — uses executeBash internally) ──
-            case 'cronCreate':
-                return `Cron scheduled: "${args.description}" every ${args.intervalMinutes} minutes. (Note: cron runs in-process only while CoWorker is active.)`;
-            case 'cronList':
-                return 'No active crons. (Cron persistence is not yet implemented.)';
-            case 'cronDelete':
-                return `Cron ${args.cronId} deleted.`;
-            default:
-                return `[Unknown Tool] "${toolName}" is not registered in CoWorker's local executor.`;
+            case 'executeAskUserQuestion': return NativeTools_1.NativeTools.executeAskUserQuestion(args.question);
+            case 'executeNotebookRead': return NativeTools_1.NativeTools.executeNotebookRead(args.notebookPath);
+            case 'executeNotebookEdit': return NativeTools_1.NativeTools.executeNotebookEdit(args.notebookPath, args.newSource, args.cellId, args.cellType);
+            case 'agent': return NativeTools_1.NativeTools.executeAgent(args.description, args.subagentType);
+            case 'returnSubagentResult': return NativeTools_1.NativeTools.executeReturnSubagentResult(args.result);
+            case 'enterPlanMode': return 'Plan mode activated. Mutation tools are blocked.';
+            case 'exitPlanMode': return 'Plan mode deactivated.';
+            default: return `[Unknown Tool] "${toolName}" is not registered.`;
         }
     }
-    /**
-     * Subagent: creates a restricted child agent for delegated subtasks.
-     */
     async createSubagent(profileName, subtask) {
         const subAgent = new CoWorkerAgent({ model: this.model, role: 'CodeReviewer' });
         let output = '';
-        for await (const chunk of subAgent.chat(subtask)) {
+        for await (const chunk of subAgent.chat(subtask))
             output += chunk;
-        }
         return `[SUBAGENT OUTPUT]: ${output}`;
     }
+    enrichMessage(prompt, history) {
+        const lastAi = history.filter(m => m.role === 'assistant').pop();
+        const trimmed = prompt.trim();
+        if (/^\d+$/.test(trimmed) && lastAi) {
+            return `${prompt} (Refers to step ${trimmed} from: "${lastAi.content.substring(0, 80).replace(/\\n/g, ' ')}...")`;
+        }
+        if (/^run.*test/i.test(trimmed))
+            return `${prompt} (Identify framework and run tests automatically)`;
+        if (/^fix (it|this|the error|that)/i.test(trimmed))
+            return `${prompt} (Refer to the previous context or error logs)`;
+        return prompt;
+    }
+    async summarizeConversation(messages) {
+        const url = `${this.endpoint}/v1/chat/completions`;
+        const prompt = `Summarize the preceding conversation concisely, retaining all critical technical decisions, file paths, and task progress. Stay under 1000 words.`;
+        try {
+            const res = await (0, node_fetch_1.default)(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: this.ollamaModel,
+                    messages: [...messages, { role: 'user', content: prompt }],
+                    options: { num_ctx: contextManager_1.CONTEXT_LIMIT, num_predict: 2048, temperature: 0.3 }
+                })
+            });
+            if (!res.ok)
+                return 'Failed to summarize conversation.';
+            const data = await res.json();
+            return data.choices?.[0]?.message?.content || 'No summary generated.';
+        }
+        catch {
+            return 'Summary error occurred.';
+        }
+    }
 }
 exports.CoWorkerAgent = CoWorkerAgent;
+// Removed legacy system prompt logic and moved to src/utils/systemPrompt.ts
 //# sourceMappingURL=CoWorkerAgent.js.map