@sylix/coworker 1.5.3 → 2.0.1

package/dist/core/CoWorkerAgent.js

@@ -1,4 +1,37 @@
 "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 };
 };
@@ -18,6 +51,11 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
 const ContextReader_1 = require("./ContextReader");
 const systemPrompt_1 = require("../utils/systemPrompt");
 const contextManager_1 = require("../utils/contextManager");
+const SnapshotManager_1 = require("../snapshot/SnapshotManager");
+const HookEngine_1 = require("../hooks/HookEngine");
+const SubagentLoader_1 = require("../agents/SubagentLoader");
+const AutoMemory_1 = require("../memory/AutoMemory");
+const readline = __importStar(require("readline"));
 // No fixed tool turn limit - let the model decide when it's done.
 /**
  * THE SDK LAYER — Real Agentic Tool Loop for CoWorker v1.5.0.
@@ -25,9 +63,14 @@ const contextManager_1 = require("../utils/contextManager");
 class CoWorkerAgent {
     constructor(options) {
         this.systemPrompt = '';
+        this.protocol = 'build';
+        this.recentToolCalls = [];
+        this.DOOM_LOOP_THRESHOLD = 3;
+        this.MAX_RETRIES = 3;
+        this.RETRY_BASE_DELAY_MS = 1000;
         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';
+        this.ollamaModel = 'qwen3.5:35b-a3b-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)());
@@ -35,37 +78,118 @@ class CoWorkerAgent {
         this.hooks = new HookAndSkillManager_1.HookAndSkillManager();
         this.settings = new SettingsManager_1.SettingsManager();
         this.permissions = new PermissionInterceptor_1.PermissionInterceptor();
+        this.snapshots = new SnapshotManager_1.SnapshotManager(options.cwd || process.cwd());
+        this.hookEngine = new HookEngine_1.HookEngine();
+        this.subagentLoader = new SubagentLoader_1.SubagentLoader();
+        this.autoMemory = new AutoMemory_1.AutoMemory();
+        // Lazy initialize LSP to save resources if not used
+        this.lspClient = null;
     }
     async boot() {
         await this.hooks.loadSkillsFromDirectory();
+        this.hooks.registerHooks(this.hookEngine);
+        // Initialize the snapshot system
+        await this.snapshots.init();
+        // Load subagent definitions
+        await this.subagentLoader.load();
         // Inject Memory Hierarchy
         this.systemPrompt = await (0, systemPrompt_1.getSystemPrompt)(this.cwd);
+        // Load auto-memory (persistent cross-session learnings)
+        const autoMem = await this.autoMemory.load(this.cwd);
+        if (autoMem) {
+            this.systemPrompt += `\n\n## Auto-Learned Context (from previous sessions)\n${autoMem}`;
+        }
         this.systemPrompt += `\n\n## Available Skills\n${this.hooks.getSkillsSummary()}`;
+        // List available subagents in system prompt
+        const agents = this.subagentLoader.list();
+        if (agents.length > 0) {
+            this.systemPrompt += `\n\n## Available Subagents\n`;
+            for (const a of agents) {
+                this.systemPrompt += `- **${a.name}**: ${a.description} (tools: ${a.tools?.join(', ') || 'all'}, max ${a.maxTurns} turns)\n`;
+            }
+        }
         await this.sessions.loadCheckpoint();
         const config = await this.settings.loadSettings();
+        // Initialize Advanced Permission System (Claude Code Parity)
         this.permissions = new PermissionInterceptor_1.PermissionInterceptor({
+            mode: 'default', // TODO: allow override from settings
+            rules: config.rules,
             allowedTools: config.allow,
             deniedTools: config.deny
         });
+        // Load hooks from settings
+        if (config.hooks) {
+            this.hookEngine.loadFromConfig(config.hooks);
+        }
         for (const [name, server] of Object.entries(config.mcpServers)) {
             await this.mcp.connectServer(name, server.command, server.args);
         }
+        // Fire SessionStart event
+        await this.hookEngine.fire('SessionStart', {
+            event: 'SessionStart',
+            sessionId: this.sessions.currentSessionId,
+            cwd: this.cwd,
+        });
     }
     async *chat(prompt) {
         await this.sessions.rollupMemory();
+        // Fire UserPromptSubmit hook (can modify or block prompt)
+        const promptHook = await this.hookEngine.fireBlocking('UserPromptSubmit', {
+            event: 'UserPromptSubmit',
+            prompt,
+            cwd: this.cwd,
+        });
+        if (!promptHook.allow) {
+            yield `\n  [WARNING] Prompt blocked by hook: ${promptHook.reason || 'no reason'}\n`;
+            return;
+        }
+        if (promptHook.modifiedPrompt) {
+            prompt = promptHook.modifiedPrompt;
+        }
+        // Protocol Handling
+        if (prompt.startsWith('/explore ')) {
+            this.protocol = 'explore';
+            prompt = prompt.replace('/explore ', '');
+        }
+        else if (prompt.startsWith('/plan ')) {
+            this.protocol = 'plan';
+            prompt = prompt.replace('/plan ', '');
+        }
+        else {
+            this.protocol = 'build';
+        }
+        // Update permission mode based on protocol
+        if (this.protocol === 'explore') {
+            this.permissions['settings'].mode = 'explore';
+        }
+        else if (this.protocol === 'plan') {
+            this.permissions['settings'].mode = 'plan';
+        }
+        else {
+            this.permissions['settings'].mode = 'default';
+        }
         // ── Context Management ──
         // 1. Prune large tool results
         this.sessions.state.messages = (0, contextManager_1.pruneToolResults)(this.sessions.state.messages);
-        // 2. Auto-Compact if needed
+        // 2. Auto-Compact if needed (Context 2.0)
         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`;
+            await this.hookEngine.fire('PreCompact', { event: 'PreCompact', cwd: this.cwd });
+            yield `\n  [SYSTEM] context window at ${Math.floor(usage * 100)}% — optimizing memory...\n`;
+            const result = await this.sessions.performTwoPhaseCompaction(async (content) => this.summarizeChunk(content), 10 // Keep last 10 messages raw
+            );
+            if (result.savedTokens > 0) {
+                yield `  [DONE] optimized · saved ~${result.savedTokens.toLocaleString()} tokens\n`;
+            }
+            else {
+                // Fallback: if tool pruning wasn't enough, do a full summary
+                const summary = await this.summarizeConversation(this.sessions.state.messages);
+                await this.sessions.compactMessages(summary);
+                yield `  [DONE] deep compression completed\n`;
+            }
+            await this.hookEngine.fire('PostCompact', { event: 'PostCompact', cwd: this.cwd });
+            // AUTO-REPLAY
+            yield `  [RETRY] resuming session...\n`;
         }
         const isSimpleGreeting = /^(hi|hey|hello|thanks|ok|cool|great)$/i.test(prompt.trim());
         const liveContext = isSimpleGreeting ? '' : await ContextReader_1.ContextReader.getProjectContext(this.cwd);
@@ -79,6 +203,17 @@ class CoWorkerAgent {
             if (skillPrompt)
                 fullSystemPrompt += skillPrompt;
         }
+        if (this.protocol === 'explore') {
+            fullSystemPrompt += `\n\n## PROTOCOL: EXPLORE (Read-Only)
+- You are in READ-ONLY mode.
+- You may NOT use: executeWrite, executeEdit, executeMultiEdit, executeBash (for mutations).
+- Focus on understanding the codebase, architecture, and flows.`;
+        }
+        else if (this.protocol === 'plan') {
+            fullSystemPrompt += `\n\n## PROTOCOL: PLAN (Strict Planning)
+- You MUST use TodoWrite to plan your actions first.
+- Do NOT modify any code until the plan is finalized and approved.`;
+        }
         const messages = [
             { role: 'system', content: fullSystemPrompt },
             ...this.sessions.state.messages,
@@ -111,7 +246,7 @@ class CoWorkerAgent {
                 catch {
                     const errMsg = `[ToolError] Failed to parse arguments for ${toolName}`;
                     messages.push({ role: 'tool', content: errMsg, tool_call_id: toolId });
-                    yield `\n  ✗ ${errMsg}\n`;
+                    yield `\n  [ERROR] ${errMsg}\n`;
                     continue;
                 }
                 const mutationTools = ['executeWrite', 'run_terminal_command', 'executeBash'];
@@ -124,8 +259,47 @@ class CoWorkerAgent {
                         continue;
                     }
                 }
-                await this.hooks.firePreToolHook(toolName, args);
-                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';
+                // ── Doom Loop Detection ──
+                // If the same tool is called 3+ times with identical args, BLOCK and ask permission
+                const currentCall = { toolName, args };
+                this.recentToolCalls.push(currentCall);
+                if (this.recentToolCalls.length > this.DOOM_LOOP_THRESHOLD) {
+                    this.recentToolCalls.shift();
+                }
+                if (this.recentToolCalls.length === this.DOOM_LOOP_THRESHOLD) {
+                    const lastThree = this.recentToolCalls;
+                    const isDoomLoop = lastThree.every(c => c.toolName === toolName && JSON.stringify(c.args) === JSON.stringify(args));
+                    if (isDoomLoop) {
+                        yield `\n  ${output_1.theme.warning('⚠')} DOOM LOOP DETECTED — ${output_1.theme.dim(toolName)} ×${this.DOOM_LOOP_THRESHOLD}\n`;
+                        yield `    ${output_1.theme.dim('The agent is repeating the same tool call. This usually indicates it is stuck.')}\n`;
+                        // BLOCK execution and ask user permission to continue
+                        const shouldContinue = await this.askUserDoomLoop(toolName);
+                        if (!shouldContinue) {
+                            const blocked = `[DOOM LOOP BLOCKED] User stopped repeated ${toolName} calls. Try a different approach.`;
+                            messages.push({ role: 'tool', content: blocked, tool_call_id: toolId });
+                            yield `    [BLOCKED] ${output_1.theme.warning('Blocked — agent must try a different approach')}\n`;
+                            this.recentToolCalls = [];
+                            continue;
+                        }
+                        this.recentToolCalls = [];
+                    }
+                }
+                // Capture working tree state BEFORE tool execution for undo
+                await this.snapshots.track(this.cwd, `Before ${toolName}`);
+                // Fire PreToolUse hook (can block)
+                const preHook = await this.hookEngine.fireBlocking('PreToolUse', {
+                    event: 'PreToolUse',
+                    toolName,
+                    args,
+                    cwd: this.cwd,
+                });
+                if (!preHook.allow) {
+                    const blocked = `[Hook Blocked] ${preHook.reason || 'denied by hook'}`;
+                    messages.push({ role: 'tool', content: blocked, tool_call_id: toolId });
+                    yield `\n  ✗ ${blocked}\n`;
+                    continue;
+                }
+                yield `\n  [TOOL] ${output_1.theme.brand(toolName)}` + (args.path || args.dir || args.filePath || args.pattern ? output_1.theme.dim(` : ${args.path || args.dir || args.filePath || args.pattern}`) : '') + '\n';
                 let result;
                 try {
                     result = await this.executeToolLocally(toolName, args);
@@ -176,72 +350,154 @@ class CoWorkerAgent {
                         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`;
                 }
+                // Fire PostToolUse hooks
+                await this.hookEngine.fire('PostToolUse', {
+                    event: 'PostToolUse',
+                    toolName,
+                    args,
+                    result: processedResult,
+                    cwd: this.cwd,
+                });
             }
         }
-    }
-    async *callLLMStreamUnified(messages, collected) {
-        const url = `${this.endpoint}/v1/chat/completions`;
-        const res = await (0, node_fetch_1.default)(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            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 }
-            })
+        // ── Turn Completion ──
+        // Fire SessionEnd and extract learnings for AutoMemory
+        await this.hookEngine.fire('SessionEnd', {
+            event: 'SessionEnd',
+            sessionId: this.sessions.currentSessionId,
+            cwd: this.cwd,
         });
-        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 = '';
-        const toolCallMap = new Map();
-        for await (const rawChunk of nodeStream) {
-            buffer += rawChunk.toString();
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.trim().startsWith('data: '))
-                    continue;
-                const data = line.trim().slice(6).trim();
-                if (data === '[DONE]') {
-                    if (toolCallMap.size > 0)
-                        collected.tool_calls = Array.from(toolCallMap.values());
-                    return;
+        // Optionally extract learnings if the conversation was substantial (>2 turns)
+        if (this.sessions.getMessageCount() > 4) {
+            const learningPrompt = this.autoMemory.getExtractionPrompt();
+            const learningMessages = [
+                ...this.sessions.state.messages,
+                { role: 'user', content: learningPrompt }
+            ];
+            try {
+                const learningContent = { content: '', tool_calls: [] };
+                // Run extraction in background (don't yield to user)
+                for await (const _ of this.callLLMStreamUnified(learningMessages, learningContent)) { }
+                if (learningContent.content.trim()) {
+                    await this.autoMemory.append(this.cwd, learningContent.content.trim());
+                    if (process.env.CW_VERBOSE)
+                        console.log(`[AutoMemory] Persisted learnings for ${this.cwd}`);
                 }
-                try {
-                    const parsed = JSON.parse(data);
-                    const content = parsed.choices?.[0]?.delta?.content || '';
-                    if (content) {
-                        collected.content += content;
-                        yield content;
+            }
+            catch (e) {
+                if (process.env.CW_VERBOSE)
+                    console.warn(`[AutoMemory] Extraction failed: ${e.message}`);
+            }
+        }
+    }
+    /**
+     * Retryable HTTP status codes (rate limits, server errors, network issues).
+     */
+    isRetryableError(status) {
+        return status === 429 || status === 500 || status === 502 || status === 503 || status === 504 || status === 0;
+    }
+    async sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(resolve, ms);
+            signal?.addEventListener('abort', () => {
+                clearTimeout(timeout);
+                reject(new Error('sleep aborted'));
+            });
+        });
+    }
+    async *callLLMStreamUnified(messages, collected, signal) {
+        let attempt = 0;
+        while (true) {
+            attempt++;
+            try {
+                const url = `${this.endpoint}/v1/chat/completions`;
+                const res = await (0, node_fetch_1.default)(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    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 }
+                    }),
+                    signal,
+                });
+                if (!res.ok) {
+                    const errorText = await res.text().catch(() => '');
+                    const status = res.status;
+                    if (this.isRetryableError(status) && attempt < this.MAX_RETRIES) {
+                        const delay = this.RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                        yield `\n  ${output_1.theme.warning('⚠')} ${status} error — retrying in ${delay / 1000}s... (${attempt}/${this.MAX_RETRIES})\n`;
+                        await this.sleep(delay, signal);
+                        continue;
                     }
-                    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: '' } });
+                    throw new Error(`LLM call failed (${status}): ${errorText}`);
+                }
+                const nodeStream = res.body;
+                if (!nodeStream)
+                    throw new Error('No response body');
+                let buffer = '';
+                const toolCallMap = new Map();
+                for await (const rawChunk of nodeStream) {
+                    buffer += rawChunk.toString();
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.trim().startsWith('data: '))
+                            continue;
+                        const data = line.trim().slice(6).trim();
+                        if (data === '[DONE]') {
+                            if (toolCallMap.size > 0)
+                                collected.tool_calls = Array.from(toolCallMap.values());
+                            return;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            const content = parsed.choices?.[0]?.delta?.content || '';
+                            if (content) {
+                                collected.content += content;
+                                yield content;
+                            }
+                            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: '' } });
+                                    }
+                                    const existing = toolCallMap.get(idx);
+                                    if (tc.id)
+                                        existing.id = tc.id;
+                                    if (tc.function?.name)
+                                        existing.function.name += tc.function.name;
+                                    if (tc.function?.arguments)
+                                        existing.function.arguments += tc.function.arguments;
+                                }
                             }
-                            const existing = toolCallMap.get(idx);
-                            if (tc.id)
-                                existing.id = tc.id;
-                            if (tc.function?.name)
-                                existing.function.name += tc.function.name;
-                            if (tc.function?.arguments)
-                                existing.function.arguments += tc.function.arguments;
                         }
+                        catch { }
                     }
                 }
-                catch { }
+                if (toolCallMap.size > 0 && collected.tool_calls.length === 0) {
+                    collected.tool_calls = Array.from(toolCallMap.values());
+                }
+                return; // success
+            }
+            catch (e) {
+                if (e.message === 'sleep aborted')
+                    return;
+                if (e.message.includes('fetch failed') || e.message.includes('network') || this.isRetryableError(0)) {
+                    if (attempt < this.MAX_RETRIES) {
+                        const delay = this.RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                        yield `\n  ${output_1.theme.warning('⚠')} Network error — retrying in ${delay / 1000}s... (${attempt}/${this.MAX_RETRIES})\n`;
+                        await this.sleep(delay, signal);
+                        continue;
+                    }
+                }
+                throw e; // non-retryable or max retries reached
             }
-        }
-        if (toolCallMap.size > 0 && collected.tool_calls.length === 0) {
-            collected.tool_calls = Array.from(toolCallMap.values());
         }
     }
     async executeToolLocally(toolName, args) {
@@ -269,7 +525,25 @@ class CoWorkerAgent {
             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);
+            case 'executeBrowser':
+                return await NativeTools_1.NativeTools.executeBrowser(args.script);
+            // ── LSP Tools (Vision 2.0) ──
+            case 'LSP_Definition':
+            case 'LSP_References': {
+                if (!this.lspClient) {
+                    const { LSPClient } = await Promise.resolve().then(() => __importStar(require('../tools/LSPTool')));
+                    this.lspClient = new LSPClient(this.cwd);
+                    await this.lspClient.start();
+                }
+                if (toolName === 'LSP_Definition') {
+                    const res = await this.lspClient.gotoDefinition(args.file_path || args.filePath, args.line, args.character);
+                    return JSON.stringify(res || { error: 'No definition found' });
+                }
+                else {
+                    const res = await this.lspClient.findReferences(args.file_path || args.filePath, args.line, args.character);
+                    return JSON.stringify(res || { error: 'No references found' });
+                }
+            }
             // ═══════════════════════════════════════════════════════════════════
             // BACKWARD COMPATIBILITY / LEGACY
             // ═══════════════════════════════════════════════════════════════════
@@ -328,9 +602,51 @@ class CoWorkerAgent {
             return `${prompt} (Refer to the previous context or error logs)`;
         return prompt;
     }
+    /**
+     * Summarize a specific chunk of tool output (for Context 2.0).
+     */
+    async summarizeChunk(content) {
+        const url = `${this.endpoint}/v1/chat/completions`;
+        const prompt = `Summarize the following tool output in 50 words or less. Focus on the final result and any errors:\n\n${content}`;
+        try {
+            const res = await (0, node_fetch_1.default)(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: this.ollamaModel,
+                    messages: [{ role: 'user', content: prompt }],
+                    options: { num_ctx: 4096, num_predict: 200, temperature: 0.2 }
+                })
+            });
+            if (!res.ok)
+                return '[summarization failed]';
+            const data = await res.json();
+            return (data.choices?.[0]?.message?.content || '[no summary]').trim();
+        }
+        catch {
+            return '[summarization error]';
+        }
+    }
     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.`;
+        const prompt = `You are a conversation compaction agent. Summarize the conversation into the following structured format. Be concise but preserve ALL critical information:
+
+## Goal
+[What the user is trying to accomplish — the primary objective]
+
+## Instructions  
+[Any specific user instructions, preferences, or constraints mentioned]
+
+## Discoveries
+[Key technical facts learned during the conversation — file paths, APIs, patterns, architecture decisions]
+
+## Accomplished
+[What work has been completed, what is in progress, and what remains]
+
+## Relevant Files / Directories
+[List of files and directories that are relevant to the ongoing work]
+
+Stay under 800 words. Focus on actionable information.`;
         try {
             const res = await (0, node_fetch_1.default)(url, {
                 method: 'POST',
@@ -350,7 +666,34 @@ class CoWorkerAgent {
             return 'Summary error occurred.';
         }
     }
+    /**
+     * Ask the user whether to continue after a doom loop detection.
+     * Blocks execution until user responds.
+     */
+    async askUserDoomLoop(toolName) {
+        if (!process.stdin.isTTY) {
+            // Headless mode — auto-block doom loops
+            return false;
+        }
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            rl.question(`  ${output_1.theme.warning('Continue anyway?')} ${output_1.theme.dim('[y/N]')} `, (answer) => {
+                rl.close();
+                resolve(answer.trim().toLowerCase() === 'y');
+            });
+        });
+    }
+    /**
+     * Resolve the Ollama model name from the CoWorker model alias.
+     */
+    resolveOllamaModel(model) {
+        const modelMap = {
+            'helix-1.2': 'qwen3.5:35b-a3b-q4_K_M',
+            'helix-1.0': 'qwen3.5:35b-a3b-q4_K_M',
+            'helix-fast': 'qwen3.5:35b-a3b-q4_K_M',
+        };
+        return modelMap[model] || model;
+    }
 }
 exports.CoWorkerAgent = CoWorkerAgent;
-// Removed legacy system prompt logic and moved to src/utils/systemPrompt.ts
 //# sourceMappingURL=CoWorkerAgent.js.map