glitool 2.0.4 → 2.1.0

package/dist/agent.js

@@ -1,32 +1,26 @@
 import { writeFileTool, listFilesTool, readFileTool, searchCodeTool, editFileTool, bashTool, readBackgroundOutputTool, webFetchTool, } from "./tools/index.js";
 import { AIMessage, BaseMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { StructuredTool } from "@langchain/core/tools";
 import { createReactAgent } from '@langchain/langgraph/prebuilt';
 import { ChatOpenAI } from '@langchain/openai';
 import { loadSession, loadSummary, saveSession, generateAndSaveSummary } from "./memory.js";
-import { loadConfig } from "./config.js";
 import { loadProjectMemory } from "./projectMemory.js";
 import { config as loadEnv } from 'dotenv';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { route, stripExplicitPrefix } from './llm/router.js';
 import { logRouting } from './llm/telemetry.js';
-import { runAgentGraph } from "./agents/graph.js";
-import { runReviewer } from "./agents/reviewer-agent.js";
 import os from 'os';
 import { cleanupAll } from "./tools/processRegistry.js";
-import { runPlanningAgent } from "./agents/planningAgent.js";
-import { runDebugger } from "./agents/debugger.js";
-import { runRefactorer } from "./agents/refactorer.js";
-import { runGitAgent } from "./agents/git-agent.js";
-import { makeLlm, startNewRequest } from './llm/factory.js';
+import { makeLlm, startNewRequest, getResolvedModelForCurrentRequest } from './llm/factory.js';
 import { emit } from './monitor.js';
+import { runClarifier } from './clarifier.js';
+import { setClarificationHandler } from './clarificationHandler.js';
+import { execSync } from 'child_process';
+import { runExecutor } from "./agents/executor.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 loadEnv({ path: join(os.homedir(), '.glitool', '.env') });
 const MAX_HISTORY_CHARS = 60_000;
-// const simpleLlm = makeLlm('meta-llama/Llama-3.3-70B-Instruct-Turbo');
-// const simpleLlm = makeLlm('meta-llama/Llama-3.3-70B-Instruct-Turbo');
 function createLlm(model) {
     return makeLlm(model);
 }
@@ -37,8 +31,7 @@ function createLlm(model) {
 export function getDefaultLlm() {
     return createLlm('meta-llama/Llama-3.3-70B-Instruct-Turbo');
 }
-// const config = loadConfig();
-const tools = [listFilesTool, readFileTool, searchCodeTool, writeFileTool, editFileTool, bashTool, readBackgroundOutputTool, webFetchTool];
+const chatFallbackTools = [listFilesTool, readFileTool, searchCodeTool, writeFileTool, editFileTool, bashTool, readBackgroundOutputTool, webFetchTool];
 process.on('exit', cleanupAll);
 process.on('SIGINT', () => { cleanupAll(); process.exit(0); });
 process.on('SIGTERM', () => { cleanupAll(); process.exit(0); });
@@ -49,13 +42,28 @@ export function clearSession() {
 }
 const MAX_SUMMARY_CHARS = 2_000;
 const MAX_PROJECT_FACTS_CHARS = 3_000;
+function getGitContext() {
+    try {
+        const status = execSync('git --no-optional-locks status --short --branch', {
+            cwd: process.cwd(),
+            timeout: 3000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).toString().trim();
+        if (!status)
+            return '';
+        return `\n\n## Git State\n${status}`;
+    }
+    catch {
+        return '';
+    }
+}
 function buildSystemPrompt() {
     let summary = loadSummary();
     const project = loadProjectMemory();
     if (!summary) {
         const rawSession = loadSession();
         if (rawSession.length > 4) {
-            generateAndSaveSummary(rawSession, getDefaultLlm());
+            generateAndSaveSummary(rawSession, getDefaultLlm()).catch(() => { });
             summary = loadSummary();
         }
     }
@@ -70,6 +78,8 @@ You can:
 
 Be concise. Default to plain conversation. Only call tools when the request clearly needs them.
 
+For greetings or small talk (e.g. "hi", "hey", "thanks"), reply warmly in one short line and invite the user to say what they're working on. Don't ask them to clarify a "request" — there isn't one.
+
 When the user asks to read, show, or display a specific file → call readFile.
 For "read <name>" shorthand, pass the bare name; the tool searches the project automatically.
 Don't claim a file is missing without verifying via listFiles or readFile first.
@@ -95,6 +105,9 @@ Style:
             : json;
         prompt += `\n\nProject facts:\n${capped}`;
     }
+    const gitContext = getGitContext();
+    if (gitContext)
+        prompt += gitContext;
     return prompt;
 }
 const systemPrompt = await buildSystemPrompt();
@@ -165,14 +178,16 @@ function trimHistory(messages) {
     }
     return kept;
 }
+// Keyed by the model the SERVER actually runs, not the CLI's role hint.
+// Together.ai pricing per million tokens (May 2026).
 const COST_PER_TOKEN = {
-    'gpt-4o-mini': { input: 0.15 / 1_000_000, output: 0.60 / 1_000_000 },
-    'gpt-5.4-mini': { input: 0.75 / 1_000_000, output: 4.50 / 1_000_000 },
-    'gpt-5.4': { input: 2.50 / 1_000_000, output: 15.00 / 1_000_000 },
-    'gpt-5.5': { input: 5.00 / 1_000_000, output: 30.00 / 1_000_000 },
+    'MiniMaxAI/MiniMax-M2.7': { input: 0.30 / 1_000_000, output: 1.20 / 1_000_000 },
+    'deepseek-ai/DeepSeek-V4-Pro': { input: 2.10 / 1_000_000, output: 4.40 / 1_000_000 },
+    'moonshotai/Kimi-K2.6': { input: 1.20 / 1_000_000, output: 4.50 / 1_000_000 },
+    'Qwen/Qwen2.5-7B-Instruct-Turbo': { input: 0.30 / 1_000_000, output: 0.30 / 1_000_000 },
 };
 function estimateCost(model, inputTokens, outputTokens) {
-    const rates = COST_PER_TOKEN[model] ?? COST_PER_TOKEN['gpt-4o-mini'];
+    const rates = COST_PER_TOKEN[model] ?? COST_PER_TOKEN['MiniMaxAI/MiniMax-M2.7'];
     return inputTokens * rates.input + outputTokens * rates.output;
 }
 function extractTarget(args) {
@@ -193,13 +208,33 @@ function extractTarget(args) {
     }
     return String(first ?? '');
 }
-export async function chat(userInput, onToolCall, onStatus, onToken, onEscalation, onUsage, onStageEvent) {
+export async function chat(userInput, onToolCall, onStatus, onToken, onUsage, onStageEvent, onClarificationNeeded) {
     startNewRequest();
     emit('user_prompt', { text: userInput });
     const decision = await route(userInput, sessionMessages.slice(-6));
     emit('router', { domain: decision.domain, tier: decision.tier, model: decision.recommendedModel, reason: decision.reason });
     logRouting(userInput, decision);
     const cleanedInput = decision.source === 'explicit' ? stripExplicitPrefix(userInput) : userInput;
+    // Register the askUser tool callback so the executor can pause mid-execution and ask the user
+    if (onClarificationNeeded) {
+        setClarificationHandler(onClarificationNeeded);
+    }
+    // Fast codebase grep — no LLM, just gives the executor a head start
+    const { codeContext } = await runClarifier(cleanedInput, decision.domain, sessionMessages.length);
+    let finalInput = cleanedInput;
+    if (codeContext) {
+        finalInput = `${cleanedInput}\n\n[Codebase search context]:\n${codeContext}`;
+    }
+    emit('clarifier', { questions: [], skipped: true });
+    emit('memory', {
+        session_messages: sessionMessages.length,
+        has_summary: !!loadSummary(),
+        has_project: !!loadProjectMemory(),
+        recent: sessionMessages.slice(-4).map(m => ({
+            role: m._getType(),
+            text: (typeof m.content === 'string' ? m.content : JSON.stringify(m.content)).slice(0, 150)
+        }))
+    });
     sessionMessages.push(new HumanMessage(cleanedInput));
     const shortcut = await tryDirectReadShortcut(cleanedInput, onToolCall);
     if (shortcut !== null) {
@@ -207,93 +242,37 @@ export async function chat(userInput, onToolCall, onStatus, onToken, onEscalatio
         saveSession(sessionMessages);
         return shortcut;
     }
-    if (decision.domain === 'planning') {
-        emit('agent', { name: 'planning' });
-        onStatus?.('Planning...');
-        const result = await runPlanningAgent(cleanedInput, (inputTokens, outputTokens) => {
-            onUsage?.(inputTokens + outputTokens, estimateCost('gpt-5.4', inputTokens, outputTokens));
-        });
-        sessionMessages.push(new AIMessage(result));
-        saveSession(sessionMessages);
-        return result;
-    }
-    if (decision.domain === 'review') {
-        emit('agent', { name: 'reviewer' });
-        onStageEvent?.({ type: 'stage_start', stage: 'reviewer' });
-        const result = await runReviewer(cleanedInput, (name, args) => {
-            onStageEvent?.({ type: 'tool', stage: 'reviewer', tool: name, target: extractTarget(args) });
-            onToolCall(name, args);
-        }, decision.recommendedModel);
-        onStageEvent?.({ type: 'stage_done', stage: 'reviewer' });
-        sessionMessages.push(new AIMessage(result));
-        saveSession(sessionMessages);
-        return result;
-    }
-    if (decision.domain === 'debugging') {
-        emit('agent', { name: 'debugger' });
-        onStageEvent?.({ type: 'stage_start', stage: 'debugger' });
-        const result = await runDebugger(cleanedInput, (name, args) => {
-            onStageEvent?.({ type: 'tool', stage: 'debugger', tool: name, target: extractTarget(args) });
+    const EXECUTOR_DOMAINS = new Set([
+        'coding', 'debugging', 'refactoring', 'git', 'planning', 'review'
+    ]);
+    if (EXECUTOR_DOMAINS.has(decision.domain)) {
+        emit('agent', { name: `executor:${decision.domain}` });
+        onStageEvent?.({ type: 'stage_start', stage: decision.domain });
+        const result = await runExecutor(finalInput, decision.domain, decision.recommendedModel, (name, args) => {
+            onStageEvent?.({ type: 'tool', stage: decision.domain, tool: name, target: extractTarget(args) });
             onToolCall(name, args);
-        }, decision.recommendedModel);
-        onStageEvent?.({ type: 'stage_done', stage: 'debugger' });
+        }, onStatus, trimHistory(sessionMessages));
+        onStageEvent?.({ type: 'stage_done', stage: decision.domain });
         sessionMessages.push(new AIMessage(result));
         saveSession(sessionMessages);
+        emit('response', { text: result });
+        emit('done', { total_tokens: 0 }); // no token counting in executor path yet
         return result;
     }
-    if (decision.domain === 'refactoring') {
-        emit('agent', { name: 'refactorer' });
-        onStageEvent?.({ type: 'stage_start', stage: 'refactorer' });
-        const result = await runRefactorer(cleanedInput, (name, args) => {
-            onStageEvent?.({ type: 'tool', stage: 'refactorer', tool: name, target: extractTarget(args) });
-            onToolCall(name, args);
-        }, decision.recommendedModel);
-        onStageEvent?.({ type: 'stage_done', stage: 'refactorer' });
-        sessionMessages.push(new AIMessage(result));
-        saveSession(sessionMessages);
-        return result;
-    }
-    if (decision.domain === 'git') {
-        emit('agent', { name: 'git' });
-        onStageEvent?.({ type: 'stage_start', stage: 'git_agent' });
-        const result = await runGitAgent(cleanedInput, (name, args) => {
-            onStageEvent?.({ type: 'tool', stage: 'git_agent', tool: name, target: extractTarget(args) });
-            onToolCall(name, args);
-        }, decision.recommendedModel);
-        onStageEvent?.({ type: 'stage_done', stage: 'git_agent' });
-        sessionMessages.push(new AIMessage(result));
-        saveSession(sessionMessages);
-        return result;
-    }
-    if (decision.domain === 'coding') {
-        emit('agent', { name: 'coder' });
-        const graphResult = await runAgentGraph(cleanedInput, buildSystemPrompt(), onToolCall, onStatus ?? (() => { }), decision, onStageEvent // ← add this
-        );
-        if (graphResult.escalated && onEscalation) {
-            onEscalation({
-                userMessage: graphResult.userMessage,
-                plan: graphResult.plan,
-                trajectory: graphResult.trajectory,
-                finalOutput: graphResult.finalOutput ?? '',
-            });
-        }
-        if (graphResult.finalOutput) {
-            sessionMessages.push(new AIMessage(graphResult.finalOutput));
-            saveSession(sessionMessages);
-            return graphResult.finalOutput;
-        }
-    }
     emit('agent', { name: 'chat' });
+    const chatTools = decision.domain === 'chat' ? [] : chatFallbackTools;
     const simpleAgent = createReactAgent({
         llm: createLlm(decision.recommendedModel),
-        tools,
+        tools: chatTools,
         stateModifier: new SystemMessage(systemPrompt)
     });
     const trimmed = trimHistory(sessionMessages);
+    emit('system_prompt', { agent: 'chat', text: systemPrompt.slice(0, 600) });
     const eventStrem = simpleAgent.streamEvents({ messages: trimmed }, { version: 'v2' });
     let finalResponse = '';
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
+    let resolvedModel = null;
     for await (const { event, data, name: eventName } of eventStrem) {
         if (event === 'on_chat_model_stream') {
             const chunk = data.chunk;
@@ -308,27 +287,49 @@ export async function chat(userInput, onToolCall, onStatus, onToken, onEscalatio
                 onToken?.(token);
                 finalResponse += token;
             }
-            // const token = data.chunk?.content;
-            // if(token && typeof token === 'string'){
-            //     onToken?.(token);
-            //     finalResponse += token;
-            // }
         }
         if (event === 'on_tool_start') {
             onToolCall(eventName, data.input);
             emit('tool_call', { name: eventName, input: data.input });
         }
+        if (event === 'on_tool_end') {
+            const out = typeof data.output === 'string'
+                ? data.output
+                : JSON.stringify(data.output ?? '');
+            emit('tool_response', { name: eventName, output: out.slice(0, 1000) });
+        }
         if (event === 'on_chat_model_end') {
             const usage = data.output?.usage_metadata;
+            // Prefer the X-Glitool-Resolved-Model header (captured via fetch wrapper).
+            // Falls back to LangChain's response_metadata.model_name, which on
+            // ChatOpenAI reports the REQUEST hint (the role), not the resolved name.
+            const fromHeader = getResolvedModelForCurrentRequest();
+            const fromMeta = data.output?.response_metadata?.model_name;
+            if (fromHeader)
+                resolvedModel = fromHeader;
+            else if (fromMeta)
+                resolvedModel = fromMeta;
             if (usage) {
                 totalInputTokens += usage.input_tokens ?? 0;
                 totalOutputTokens += usage.output_tokens ?? 0;
-                emit('llm_call', { tokens_in: usage.input_tokens ?? 0, tokens_out: usage.output_tokens ?? 0 });
+                emit('llm_call', {
+                    tokens_in: usage.input_tokens ?? 0,
+                    tokens_out: usage.output_tokens ?? 0,
+                    model: resolvedModel ?? decision.recommendedModel,
+                });
+            }
+            const output = data.output;
+            let msgText = '';
+            if (typeof output?.content === 'string') {
+                msgText = output.content;
+            }
+            else if (Array.isArray(output?.content)) {
+                msgText = output.content.filter((c) => c.type === 'text').map((c) => c.text ?? '').join('');
             }
-            if (!finalResponse) {
-                const output = data.output;
-                if (typeof output?.content === 'string') {
-                    finalResponse = output.content;
+            if (msgText) {
+                emit('llm_message', { text: msgText.slice(0, 800) });
+                if (!finalResponse) {
+                    finalResponse = msgText;
                     onToken?.(finalResponse);
                 }
             }
@@ -338,7 +339,7 @@ export async function chat(userInput, onToolCall, onStatus, onToken, onEscalatio
         sessionMessages.push(new AIMessage(finalResponse));
     }
     if (onUsage && (totalInputTokens + totalOutputTokens) > 0) {
-        const model = decision.recommendedModel;
+        const model = resolvedModel ?? decision.recommendedModel;
         onUsage(totalInputTokens + totalOutputTokens, estimateCost(model, totalInputTokens, totalOutputTokens));
     }
     saveSession(sessionMessages);

package/dist/agents/coder.js

@@ -2,30 +2,39 @@ import { createReactAgent } from "@langchain/langgraph/prebuilt";
 import { makeLlm } from '../llm/factory.js';
 import { SystemMessage, HumanMessage, BaseMessage } from "@langchain/core/messages";
 import { StructuredTool } from "@langchain/core/tools";
-import { listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool, bashTool } from '../tools/index.js';
+import { listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool, bashTool, readBackgroundOutputTool } from '../tools/index.js';
 import { scoreRisk, getRiskMessage } from "../trust/riskScorer.js";
 import { log } from "../logger.js";
+import { emit } from '../monitor.js';
 export async function runCoder(plan, userMessage, onToolCall, model, onReasoning) {
     const coderLlm = makeLlm(model);
+    emit('system_prompt', { agent: 'coder', text: plan.slice(0, 300) });
+    emit('enhanced_prompt', { text: userMessage.slice(0, 600) });
     const coderAgent = createReactAgent({
         llm: coderLlm,
-        tools: [listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool, bashTool],
+        tools: [listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool, bashTool, readBackgroundOutputTool],
         stateModifier: new SystemMessage(`You are a coding execution agent. Execute the given plan step by step using tools.
 
+Available tools: listFiles, readFile, searchCode, editFile, writeFile, bash, read_background_output. These are the ONLY tools that exist — do not call any other tool name (no "runShell", "exec", "shell", etc.).
+
 GROUNDING RULES — these are not optional:
 
+
 1. BEFORE editing any file, READ it first with readFile to confirm structure.
 2. PREFER searchCode over readFile for navigation. Read whole files only when you'll actually edit them.
 3. For UI features (slash commands, menus, palettes), search src/ui/, src/components/, src/cli/ first — don't trust the plan's filename blindly.
 4. After every editFile, if the tool returned an error, STOP and read the file again. Do not retry with guesses.
-5. You MAY create package.json or tsconfig.json when building a new project from scratch. Never add dependencies to an EXISTING package.json unless explicitly asked. Never run npm install via bash.
-6. Maximum 5 file reads per task. If you need more, you're doing it wrong — use searchCode instead.
-7. If you can't safely complete the task, STOP and return a failure message. Do not invent.
+5. When building a new project from scratch you MAY create package.json/tsconfig.json. Never add dependencies to an EXISTING package.json unless explicitly asked.
+6. Shell commands MUST be non-interactive — you have no keyboard, so any command that opens a prompt/wizard will hang and be killed. For scaffolders, pass flags that skip prompts and use defaults: e.g. "npx create-next-app@latest my-app --yes". Give scaffold/install commands a generous timeout (120000) since they download packages.
+7. When a scaffolder creates a new subdirectory (e.g. "create-next-app my-app" makes ./my-app), ALL subsequent bash commands for that project MUST set cwd to that subdirectory: bash({ command: "npm install", cwd: "my-app" }). Otherwise "npm run dev"/"npm install" run in the parent and fail with "Missing script" or ENOENT.
+8. Maximum 5 file reads per task. If you need more, you're doing it wrong — use searchCode instead.
+9. If you can't safely complete the task, STOP and return a failure message. Do not invent.
 
 Be surgical, not exhaustive. Most tasks need 2-4 tool calls, not 15. The validator will catch broken output — you don't need to over-verify.
 
 Response style:
-- Your final text should be 1-3 sentences summarizing what files you changed and why.
+- REPORT OUTCOMES FAITHFULLY. If a tool returned an error or you could not verify a step worked, say so explicitly. Never claim success for steps that failed, were killed, or you could not confirm. "I tried X but the tool returned <error>" is correct. "X is complete" when you have no proof is a LIE — do not do this.
+- Your final text should be 1-3 sentences summarizing what files you actually changed and why.
 - Do NOT paste file contents in the response — the files are on disk; the user can read them.
 - The validator runs tsc + ESLint after you finish — no need to verify those yourself.
 - If a step is impossible (binary file, command blocked, etc.), say so explicitly and stop.
@@ -37,9 +46,14 @@ Response style:
     for await (const chunk of stream) {
         if (blocked)
             break;
-        // 'updates' mode gives one complete message per graph step.
-        // Agent node = LLM output (reasoning or tool call decision).
-        // Tools node = tool results — no useful trace info, skip.
+        // Tool results node
+        const toolMsgs = chunk.tools?.messages;
+        if (toolMsgs?.length) {
+            for (const msg of toolMsgs) {
+                const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content ?? '');
+                emit('tool_response', { name: msg.name ?? 'tool', output: content.slice(0, 1000) });
+            }
+        }
         const agentMsgs = chunk.agent?.messages;
         if (!agentMsgs?.length) {
             log('coder:chunk', { keys: Object.keys(chunk).join(',') });
@@ -56,15 +70,18 @@ Response style:
                 getRiskMessage(toolCall.name, risk, toolCall.args);
                 if (risk === 'high') {
                     onToolCall(toolCall.name, toolCall.args);
+                    emit('tool_call', { name: toolCall.name, input: toolCall.args });
                     result = `Blocked: I cannot write to sensitive files like ${toolCall.args?.filePath}.`;
                     blocked = true;
                     break;
                 }
                 onToolCall(toolCall.name, toolCall.args);
+                emit('tool_call', { name: toolCall.name, input: toolCall.args });
             }
             else if (text) {
                 onReasoning?.(text);
                 result = text;
+                emit('llm_message', { text: text.slice(0, 800) });
             }
         }
         log('coder:chunk', { keys: Object.keys(chunk).join(',') });

package/dist/agents/debugger.js

@@ -1,6 +1,7 @@
 import { makeLlm } from '../llm/factory.js';
 import { createReactAgent } from '@langchain/langgraph/prebuilt';
 import { SystemMessage, HumanMessage } from '@langchain/core/messages';
+import { emit } from '../monitor.js';
 import { listFilesTool, readFileTool, searchCodeTool, bashTool, editFileTool, } from '../tools/index.js';
 const DEBUG_SYSTEM_PROMPT = `You are a debugging agent. You investigate first, then patch.
 
@@ -83,6 +84,8 @@ export async function runDebugger(userMessage, onToolCall, model) {
         bashTool,
         editFileTool,
     ];
+    emit('system_prompt', { agent: 'debugger', text: DEBUG_SYSTEM_PROMPT.slice(0, 600) });
+    emit('enhanced_prompt', { text: userMessage.slice(0, 600) });
     const agent = createReactAgent({
         llm,
         tools,
@@ -93,17 +96,26 @@ export async function runDebugger(userMessage, onToolCall, model) {
     for await (const { event, data, name: eventName } of stream) {
         if (event === 'on_tool_start') {
             onToolCall(eventName, data.input);
+            emit('tool_call', { name: eventName, input: data.input });
+        }
+        if (event === 'on_tool_end') {
+            const out = typeof data.output === 'string'
+                ? data.output
+                : JSON.stringify(data.output ?? '');
+            emit('tool_response', { name: eventName, output: out.slice(0, 1000) });
         }
         if (event === 'on_chat_model_end') {
             const output = data.output;
+            let content = '';
             if (typeof output?.content === 'string') {
-                finalText = output.content;
+                content = output.content;
             }
             else if (Array.isArray(output?.content)) {
-                finalText = output.content
-                    .filter((c) => c.type === 'text')
-                    .map((c) => c.text ?? '')
-                    .join('');
+                content = output.content.filter((c) => c.type === 'text').map((c) => c.text ?? '').join('');
+            }
+            if (content) {
+                finalText = content;
+                emit('llm_message', { text: content.slice(0, 800) });
             }
         }
     }

package/dist/agents/executor.js

@@ -0,0 +1,144 @@
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { makeLlm } from '../llm/factory.js';
+import { SystemMessage, HumanMessage, BaseMessage } from '@langchain/core/messages';
+import { emit } from '../monitor.js';
+import { listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool, bashTool, readBackgroundOutputTool, webFetchTool, askUserTool, } from '../tools/index.js';
+const DOMAIN_RULES = {
+    debugging: `
+## Debugging Rules
+WORKFLOW — follow in order:
+1. REPRODUCE — run the failing command or read the file mentioned. Start immediately, do not ask first.
+2. DIAGNOSE — before touching anything, output:
+   ## Diagnosis
+   - Root cause: one sentence
+   - Where: file.ts:LINE
+   - Why it fails: short explanation
+3. PATCH — one minimal editFile. Smallest change that fixes the issue.
+4. VERIFY — re-run the exact command from step 1.
+
+STOP CONDITIONS (after you have started investigating):
+- Same tool called twice with identical input → stop and report
+- editFile failed twice for the same file → read the file fresh, try once more or give up
+- 10 tool calls used → wrap up with what you have
+
+Final response format:
+## Diagnosis
+...
+## Fix
+- file.ts:LINE — what changed
+## Verification
+- ran: \`<command>\`
+- result: pass | fail | not verified — [reason]`,
+    coding: `
+## Coding Rules
+1. Read package.json first — understand the project type and available scripts
+2. If you scaffold a new project into a subdirectory, ALL subsequent commands must use cwd pointing to that subdirectory
+3. BEFORE editing any file, READ it first to confirm its structure
+4. Do not add dependencies, helpers, or abstractions beyond what was explicitly asked
+5. Shell commands must be non-interactive — use --yes / --defaults flags for scaffolders
+6. After writing files, run the appropriate check (npx tsc --noEmit, npm run build)
+7. Maximum 5 file reads — use searchCode for navigation instead
+8. Run shell commands ONE AT A TIME — never call bash multiple times in the same step. Wait for each command's output before running the next.
+9. To scaffold Next.js: use \`npx create-next-app@latest <name> --yes\`. Do NOT use --use-app-dir (deprecated in Next.js 14+). The project name must be the first argument before any flags.
+10. For files over ~120 lines, write a SKELETON first with writeFile (just structure + imports + section headers as comments), then add each section with editFile. Never write a 200+ line file in one writeFile call — long generations get truncated mid-string and produce invalid syntax.`,
+    refactoring: `
+## Refactoring Rules
+1. Read ALL files you plan to touch before changing any of them
+2. Make changes one file at a time, run tsc after each
+3. Do not restructure, rename, or clean up anything beyond the stated scope
+4. Preserve all existing behaviour — only change what was asked`,
+    git: `
+## Git Rules
+1. Run git status first — understand current state before acting
+2. Confirm the branch name before any commit or push
+3. Stage specific files by name — never use git add .
+4. Never force push unless explicitly asked
+5. Show the user a diff summary before committing`,
+    planning: `
+## Planning Rules
+Think through the full approach before writing any code.
+Output a clear numbered plan first, then execute it yourself immediately after.
+Do not stop after the plan — carry it out.
+If a step fails, adapt — do not blindly continue to the next step.`,
+    review: `
+## Review Rules
+Read all changed or relevant files. Report findings as:
+- BUG: file.ts:LINE — what the issue is and why it breaks
+- SECURITY: file.ts:LINE — what the vulnerability is
+- COMPLEXITY: file.ts:LINE — what could be simplified and how
+- MISSING: what edge case or error path is unhandled
+Be specific. Do not report style preferences. Only report things that cause real problems.`,
+};
+const BASE_PROMPT = `You are Glitool's execution agent. You solve coding tasks directly using tools.
+
+CORE RULES — not optional:
+1. READ BEFORE WRITING — always read a file before editing it
+2. SEARCH BEFORE READING — use searchCode to locate symbols, read only when you'll edit
+3. VERIFY HONESTLY — if verification failed or wasn't run, say so explicitly. Never claim success without evidence
+4. NO SCOPE CREEP — do not add abstractions, helpers, or cleanup beyond what was asked
+5. DIAGNOSE BEFORE SWITCHING — if a tool fails, understand why before trying something different
+6. NON-INTERACTIVE SHELL — commands that open prompts will hang. Use --yes flags for scaffolders
+7. CWD AWARENESS — if you scaffold a project into a subdirectory, use cwd for all subsequent commands
+8. STOP ON REPEATED FAILURE — if the same tool call fails twice with the same input, stop and report
+9. ACT, DON'T NARRATE — every message you emit MUST either (a) include a tool call, or (b) be your FINAL response after the task is genuinely complete. Mid-task messages with text only and no tool call ("Now let me set up the pages next…", "I'll create the components now…", "Portfolio created! Now let me…") will end the agent IMMEDIATELY — that text becomes the user's final answer and any planned next steps are lost. If you have more steps to do, just do them — call the next tool. Save commentary for ONE final message AFTER the last tool call.
+
+TOOLS AVAILABLE: listFiles, readFile, searchCode, editFile, writeFile, bash, webFetch
+Use bash for: running commands, checking output, starting servers
+Use editFile for: modifying existing files (requires oldString + newString)
+Use writeFile for: creating new files only
+
+RESPONSE FORMAT:
+- 2-4 sentences: what you changed, what command you ran to verify, whether it passed
+- Do NOT paste file contents in your response
+- If something failed, say exactly what failed and why`;
+export async function runExecutor(userMessage, domain, model, onToolCall, onStatus, history = []) {
+    const domainRules = DOMAIN_RULES[domain] ?? '';
+    const systemPrompt = domainRules
+        ? `${BASE_PROMPT}\n\n${domainRules}`
+        : BASE_PROMPT;
+    emit('system_prompt', { agent: `executor:${domain}`, text: systemPrompt.slice(0, 600) });
+    emit('enhanced_prompt', { text: userMessage.slice(0, 600) });
+    onStatus?.(`${domain.charAt(0).toUpperCase() + domain.slice(1)}...`);
+    const llm = makeLlm(model);
+    const agent = createReactAgent({
+        llm,
+        tools: [
+            listFilesTool, readFileTool, searchCodeTool,
+            editFileTool, writeFileTool, bashTool,
+            readBackgroundOutputTool, webFetchTool, askUserTool,
+        ],
+        stateModifier: new SystemMessage(systemPrompt),
+    });
+    const stream = agent.streamEvents({ messages: [...history, new HumanMessage(userMessage)] }, { version: 'v2', recursionLimit: 50 });
+    let finalText = '';
+    for await (const { event, data, name: eventName } of stream) {
+        if (event === 'on_tool_start') {
+            onToolCall(eventName, data.input);
+            emit('tool_call', { name: eventName, input: data.input });
+        }
+        if (event === 'on_tool_end') {
+            const raw = data.output;
+            const out = typeof raw === 'string'
+                ? raw
+                : (raw?.content ?? JSON.stringify(raw ?? ''));
+            emit('tool_response', { name: eventName, output: String(out).slice(0, 1000) });
+        }
+        if (event === 'on_chat_model_end') {
+            const output = data.output;
+            let content = '';
+            if (typeof output?.content === 'string')
+                content = output.content;
+            else if (Array.isArray(output?.content)) {
+                content = output.content
+                    .filter((c) => c.type === 'text')
+                    .map((c) => c.text ?? '')
+                    .join('');
+            }
+            if (content) {
+                finalText = content;
+                emit('llm_message', { text: content.slice(0, 800) });
+            }
+        }
+    }
+    return finalText || 'No output.';
+}