@castlemilk/omega 0.6.19 → 0.6.20

package/dist/server/node_modules/@omega/agent/dist/executor.js

@@ -1,15 +1,49 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { createProvider } from '@omega/providers';
 import { selectProvider } from '@omega/router';
 import { createPlan } from './planner.js';
 import { executeTool } from './tools.js';
 import { validateProject } from './validator.js';
 import { publishOmega } from './publisher.js';
-import { buildTaskPrompt, buildToolResultPrompt, buildSystemPrompt, buildTextToolsSystemPrompt, FORCE_ACTION_PROMPT, } from './prompts.js';
+import { buildTaskPrompt, buildToolResultPrompt, buildSystemPrompt, buildTextToolsSystemPrompt, buildReflectionPrompt, FORCE_ACTION_PROMPT, } from './prompts.js';
 import { buildPromptContext } from './prompt-context.js';
+import { resolveSkills, formatSkillContext } from './skill-resolver.js';
+import { createClients } from './lsp/index.js';
+import { setLspClients } from './tools.js';
+import { loadCurrentPrompts, hashPrompts } from './prompt-versioning.js';
 import { AGENT_TOOLS } from './tool-definitions.js';
 import { logger } from './logger.js';
 import { Tracer } from './tracer.js';
-import { getCurrentBranch, getCurrentCommit, createBranch, hasChanges, stageFiles, commit, getDiff, checkoutBranch, stashAll, popStash, } from './git.js';
+import { getCurrentBranch, getCurrentCommit, createBranch, hasChanges, stageFiles, commit, getDiff, checkoutBranch, stashAll, popStash, createWorktree, removeWorktree, } from './git.js';
+function maxStepsForComplexity(complexity) {
+    switch (complexity) {
+        case 'simple':
+            return 30;
+        case 'medium':
+            return 80;
+        case 'complex':
+            return 120;
+        default:
+            return 60;
+    }
+}
+const execFileAsync = promisify(execFile);
+const API_SURFACE_HINTS = [
+    /\bexpose\b/i,
+    /\bpublic\s+(?:API|method|function|property)\b/i,
+    /\blogic\.[a-zA-Z_$][\w$]*\s*\(/,
+    /\btypeof\s+\w+\s*===?\s*['"]function['"]/,
+    /\bmust\s+(?:be|expose|provide|return)\b/i,
+    /\bshould\s+(?:be|expose|provide|return)\b/i,
+    /\bselectorHealth\b/i,
+];
+function taskMentionsPublicApi(task) {
+    const text = `${task.title} ${task.description ?? ''}`;
+    return API_SURFACE_HINTS.some((pattern) => pattern.test(text));
+}
 function toCoreTask(row) {
     return {
         id: row.id,
@@ -64,21 +98,98 @@ export async function runAgentTask(prisma, taskId, options) {
         const stashResult = await stashAll(options.projectPath);
         stashed = stashResult.success;
     }
-    const branchResult = await createBranch(options.projectPath, branch, baseCommit.output);
-    if (!branchResult.success) {
-        // Branch may already exist; try to checkout.
-        await checkoutBranch(options.projectPath, branch);
+    const isolated = options.isolated ?? false;
+    let worktreePath;
+    let effectiveProjectPath = options.projectPath;
+    if (isolated) {
+        worktreePath = path.join(options.projectPath, '.omega', 'worktrees', `${options.projectName}-${task.id}`);
+        const worktreeResult = await createWorktree(options.projectPath, worktreePath, branch, baseCommit.output);
+        if (worktreeResult.success) {
+            effectiveProjectPath = worktreePath;
+        }
+        else {
+            logger.warn('Worktree creation failed, falling back to in-repo run', {
+                projectPath: options.projectPath,
+                worktreePath,
+                error: worktreeResult.output,
+            });
+            const branchResult = await createBranch(options.projectPath, branch, baseCommit.output);
+            if (!branchResult.success) {
+                await checkoutBranch(options.projectPath, branch);
+            }
+        }
+    }
+    else {
+        const branchResult = await createBranch(options.projectPath, branch, baseCommit.output);
+        if (!branchResult.success) {
+            await checkoutBranch(options.projectPath, branch);
+        }
     }
+    // Isolated worktrees often lack node_modules. Install dependencies so validation and LSP work.
+    try {
+        await fs.access(path.join(effectiveProjectPath, 'node_modules'));
+    }
+    catch {
+        logger.info('Installing dependencies in worktree', { projectPath: effectiveProjectPath });
+        try {
+            await execFileAsync('pnpm', ['install'], { cwd: effectiveProjectPath, timeout: 300_000 });
+        }
+        catch (err) {
+            logger.warn('Dependency install failed', {
+                projectPath: effectiveProjectPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    const promptContext = await buildPromptContext(prisma, task.projectId, {
+        lookbackRuns: 5,
+        taskDescription: task.description,
+    });
+    const skills = await resolveSkills(prisma, effectiveProjectPath, task.description);
+    const skillContext = formatSkillContext(skills);
+    const combinedContext = [promptContext.text, skillContext].filter(Boolean).join('\n\n');
+    const systemPrompt = buildSystemPrompt(combinedContext);
+    const currentPrompts = await loadCurrentPrompts(skillContext);
+    const promptHash = hashPrompts({
+        systemPrompt: currentPrompts.systemPrompt,
+        textToolsPrompt: currentPrompts.textToolsPrompt,
+        planningPrompt: currentPrompts.planningPrompt,
+        skillContext,
+    });
+    const promptVersion = (await prisma.promptVersion.findFirst({ where: { hash: promptHash } })) ??
+        (await prisma.promptVersion.create({
+            data: {
+                name: currentPrompts.name,
+                sourcePath: currentPrompts.sourcePath,
+                systemPrompt: currentPrompts.systemPrompt,
+                textToolsPrompt: currentPrompts.textToolsPrompt,
+                planningPrompt: currentPrompts.planningPrompt ?? null,
+                skillContext: skillContext || null,
+                hash: promptHash,
+            },
+        }));
     const agentRun = await prisma.agentRun.create({
         data: {
             taskId,
             branch,
             baseCommit: baseCommit.output,
             resultStatus: 'running',
+            promptVersionId: promptVersion.id,
         },
     });
-    const promptContext = await buildPromptContext(prisma, task.projectId, { lookbackRuns: 5 });
-    const systemPrompt = buildSystemPrompt(promptContext.text);
+    const lspClients = createClients(effectiveProjectPath);
+    setLspClients(lspClients);
+    for (const client of new Set(lspClients.values())) {
+        try {
+            await client.start();
+        }
+        catch (err) {
+            logger.warn('LSP client failed to start', {
+                command: client,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
     const tracer = new Tracer(prisma, taskId, taskId);
     const rootSpan = tracer.startSpan('agent.task');
     rootSpan.setAttributes({
@@ -86,13 +197,14 @@ export async function runAgentTask(prisma, taskId, options) {
         provider: provider.config.name,
         model: selection.model,
         autoPublish: options.autoPublish ?? false,
-        promptContextUsed: promptContext.text.length > 0,
+        promptContextUsed: combinedContext.length > 0,
         runsAnalysed: promptContext.runsAnalysed,
+        skillsInjected: skills.map((s) => s.name),
     });
     const ctx = {
         prisma,
         task: toCoreTask(task),
-        projectPath: options.projectPath,
+        projectPath: effectiveProjectPath,
         projectName: options.projectName,
         provider,
         model: selection.model,
@@ -100,12 +212,21 @@ export async function runAgentTask(prisma, taskId, options) {
         baseCommit: baseCommit.output,
         agentRunId: agentRun.id,
         autoPublish: options.autoPublish ?? false,
-        maxSteps: options.maxSteps ?? 30,
+        maxSteps: options.maxSteps ?? maxStepsForComplexity(task.complexity),
         modifiedFiles: new Set(),
+        recentCommands: new Set(),
+        recentReads: new Map(),
+        consecutiveThinks: 0,
+        explorationCount: 0,
+        editCount: 0,
+        editsSinceVerify: 0,
+        explorationAtLastEdit: 0,
         tracer,
         rootSpan,
         systemPrompt,
-        promptContext: promptContext.text,
+        promptContext: combinedContext,
+        usage: {},
+        apiSurfaceVerified: false,
     };
     logger.info('Agent task started', {
         taskId: ctx.task.id,
@@ -146,63 +267,185 @@ export async function runAgentTask(prisma, taskId, options) {
         throw err;
     }
     finally {
-        await checkoutBranch(options.projectPath, baseBranch.output);
+        for (const client of new Set(lspClients.values())) {
+            try {
+                await client.stop();
+            }
+            catch {
+                // ignore shutdown errors
+            }
+        }
+        setLspClients(new Map());
+        if (worktreePath) {
+            const removeResult = await removeWorktree(options.projectPath, worktreePath);
+            if (!removeResult.success) {
+                logger.warn('Failed to remove worktree', {
+                    worktreePath,
+                    error: removeResult.output,
+                });
+            }
+        }
+        else {
+            await checkoutBranch(options.projectPath, baseBranch.output);
+        }
         if (stashed) {
             await popStash(options.projectPath);
         }
     }
 }
+async function reflectOnTrace(ctx, maxTurns) {
+    const recentTraces = await ctx.prisma.taskTrace.findMany({
+        where: { taskId: ctx.task.id },
+        orderBy: { createdAt: 'desc' },
+        take: maxTurns * 3,
+    });
+    if (recentTraces.length === 0)
+        return undefined;
+    const summary = recentTraces
+        .reverse()
+        .map((t) => {
+        const prefix = `[${t.role}]`;
+        const content = (t.content ?? '').slice(0, 400);
+        return `${prefix} ${content}`;
+    })
+        .join('\n');
+    const reflectionSpan = ctx.tracer.startSpan('agent.reflect', ctx.rootSpan.toContext());
+    try {
+        const raw = await ctx.provider.send(buildReflectionPrompt(ctx.task, summary), { system: ctx.systemPrompt, model: ctx.model });
+        reflectionSpan.addEvent('reflection.received');
+        const parsed = parseProviderResponse(raw);
+        const thinkCall = parsed.toolCalls
+            ? parseToolCalls(parsed.toolCalls).find((c) => c.name === 'think')
+            : undefined;
+        const thinkThought = thinkCall &&
+            typeof thinkCall.arguments === 'object' &&
+            'thought' in thinkCall.arguments &&
+            typeof thinkCall.arguments.thought === 'string'
+            ? thinkCall.arguments.thought
+            : undefined;
+        const critique = parsed.content?.trim() ?? thinkThought;
+        await reflectionSpan.end('ok');
+        return critique && critique.length > 0 ? critique : undefined;
+    }
+    catch (err) {
+        reflectionSpan.recordError(err);
+        await reflectionSpan.end('error');
+        return undefined;
+    }
+}
+async function checkpointCommit(ctx) {
+    if (ctx.modifiedFiles.size === 0 && !(await hasChanges(ctx.projectPath)))
+        return;
+    await stageFiles(ctx.projectPath, Array.from(ctx.modifiedFiles));
+    await commit(ctx.projectPath, `agent checkpoint: ${ctx.task.title}`);
+}
 async function executeAgentLoop(ctx) {
     // Initial planning trace
     await addTrace(ctx, 'system', ctx.systemPrompt);
     await addTrace(ctx, 'user', buildTaskPrompt(ctx.task.title, ctx.task.description ?? undefined));
     const planSpan = ctx.tracer.startSpan('agent.plan', ctx.rootSpan.toContext());
-    const plan = await createPlan(ctx.provider, ctx.task.title, ctx.task.description ?? undefined, ctx.promptContext);
+    const plan = await createPlan(ctx.provider, ctx.task.title, ctx.task.description ?? undefined, ctx.promptContext, (usage) => {
+        recordUsage(ctx, usage);
+    });
     planSpan.setAttributes({ planSteps: plan.plan.length });
     planSpan.addEvent('plan.created');
     await planSpan.end('ok');
     await addTrace(ctx, 'assistant', `Plan: ${JSON.stringify(plan)}`);
-    // Record plan as steps
-    for (let i = 0; i < plan.plan.length; i++) {
-        await ctx.prisma.taskStep.create({
-            data: {
-                taskId: ctx.task.id,
-                idx: i,
-                name: plan.plan[i].name,
-                status: 'pending',
-                input: plan.plan[i].tool ? JSON.stringify(plan.plan[i].input) : undefined,
-            },
-        });
-    }
+    // Steps are recorded dynamically as the agent actually invokes tools, so the
+    // persisted sequence matches real execution rather than the initial plan.
     let stepIndex = 0;
     let finished = false;
     let success = false;
     let summary = '';
     let noActionCount = 0;
-    // Start the first turn with a think/plan step.
-    let prompt = `Plan created: ${JSON.stringify(plan)}\n\nExecute the plan. Use tools to make changes and run validation.`;
+    let turnCount = 0;
+    let lastTurnHadFailure = false;
+    // Maintain a full conversation transcript so the model remembers prior tool outputs.
+    const messages = [
+        { role: 'system', content: ctx.systemPrompt },
+        { role: 'user', content: buildTaskPrompt(ctx.task.title, ctx.task.description ?? undefined) },
+        { role: 'assistant', content: `Plan: ${JSON.stringify(plan)}` },
+    ];
     while (stepIndex < ctx.maxSteps && !finished) {
-        const response = await sendToProvider(ctx, prompt);
-        await addTrace(ctx, 'assistant', response.content ?? '', response.toolCalls);
+        turnCount++;
+        const response = await sendToProvider(ctx, messages);
         if (!response.toolCalls || response.toolCalls.length === 0) {
             noActionCount++;
             if (noActionCount >= 2) {
-                prompt = FORCE_ACTION_PROMPT;
+                const reflection = await reflectOnTrace(ctx, 8);
+                messages.push({
+                    role: 'user',
+                    content: reflection ? `${FORCE_ACTION_PROMPT}\n\n${reflection}` : FORCE_ACTION_PROMPT,
+                });
             }
             else {
-                prompt = 'No tool calls detected. Please respond with a JSON object containing tool_calls.';
+                messages.push({
+                    role: 'user',
+                    content: 'No tool calls detected. Please respond with a JSON object containing tool_calls.',
+                });
             }
             continue;
         }
         noActionCount = 0;
-        const toolCalls = parseToolCalls(response.toolCalls);
+        const toolCalls = parseToolCalls(response.toolCalls).map((c, i) => ({
+            ...c,
+            id: c.id && c.id.length > 0 ? c.id : `tool-${String(stepIndex)}-${String(i)}`,
+        }));
+        const assistantToolCalls = toolCalls.map((c) => ({
+            id: c.id,
+            type: 'function',
+            function: { name: c.name, arguments: JSON.stringify(c.arguments) },
+        }));
+        messages.push({
+            role: 'assistant',
+            content: response.content ?? undefined,
+            tool_calls: assistantToolCalls,
+        });
+        await addTrace(ctx, 'assistant', response.content ?? '', response.toolCalls);
         const toolResults = [];
+        let turnHadFailure = false;
         for (const call of toolCalls) {
-            const step = await ctx.prisma.taskStep.findFirst({
-                where: { taskId: ctx.task.id, idx: stepIndex },
+            const input = call.name === 'run_command'
+                ? call.arguments.command
+                : call.name === 'read_file' || call.name === 'write_file' || call.name === 'edit_file'
+                    ? call.arguments.path
+                    : JSON.stringify(call.arguments);
+            const step = await ctx.prisma.taskStep.create({
+                data: {
+                    taskId: ctx.task.id,
+                    idx: stepIndex,
+                    name: call.name,
+                    status: 'pending',
+                    input,
+                },
             });
-            const stepId = step?.id;
+            const stepId = step.id;
             if (call.name === 'finish') {
+                const finishingWithFailure = call.arguments.success === false;
+                const earlyFailure = finishingWithFailure && stepIndex < ctx.maxSteps - 5;
+                if (earlyFailure) {
+                    const message = `finish rejected: you are declaring failure too early (step ${String(stepIndex)} of ${String(ctx.maxSteps)}). Continue diagnosing and fixing the issue instead of giving up.`;
+                    turnHadFailure = true;
+                    await ctx.prisma.taskStep.update({
+                        where: { id: stepId },
+                        data: { status: 'failed', output: message },
+                    });
+                    toolResults.push({ toolCallId: call.id, output: message });
+                    messages.push({ role: 'tool', tool_call_id: call.id, content: message });
+                    break;
+                }
+                const requiresApiCheck = taskMentionsPublicApi(ctx.task);
+                if (requiresApiCheck && !ctx.apiSurfaceVerified) {
+                    const message = 'finish rejected: the task describes public API requirements. Call verify_api_surface first to confirm required methods/properties are exposed.';
+                    turnHadFailure = true;
+                    await ctx.prisma.taskStep.update({
+                        where: { id: stepId },
+                        data: { status: 'failed', output: message },
+                    });
+                    toolResults.push({ toolCallId: call.id, output: message });
+                    messages.push({ role: 'tool', tool_call_id: call.id, content: message });
+                    break;
+                }
                 finished = true;
                 success = Boolean(call.arguments.success);
                 const summaryArg = typeof call.arguments.summary === 'string'
@@ -211,14 +454,13 @@ async function executeAgentLoop(ctx) {
                         ? call.arguments.message
                         : '';
                 summary = summaryArg;
-                if (stepId) {
-                    await ctx.prisma.taskStep.update({
-                        where: { id: stepId },
-                        data: { status: success ? 'done' : 'failed', output: summary },
-                    });
-                }
+                await ctx.prisma.taskStep.update({
+                    where: { id: stepId },
+                    data: { status: success ? 'done' : 'failed', output: summary },
+                });
                 ctx.rootSpan.addEvent('agent.finish', { success, summary });
                 toolResults.push({ toolCallId: call.id, output: summary });
+                messages.push({ role: 'tool', tool_call_id: call.id, content: summary });
                 break;
             }
             if (call.name === 'publish') {
@@ -236,34 +478,127 @@ async function executeAgentLoop(ctx) {
                     publishSpan.setAttributes({ publishedVersion: publishResult.version ?? 'none' });
                 }
                 await publishSpan.end(validation.allPassed ? 'ok' : 'error');
-                toolResults.push({
-                    toolCallId: call.id,
-                    output: JSON.stringify({ validation, publish: publishResult }),
+                const output = JSON.stringify({ validation, publish: publishResult });
+                toolResults.push({ toolCallId: call.id, output });
+                messages.push({ role: 'tool', tool_call_id: call.id, content: output });
+                await ctx.prisma.taskStep.update({
+                    where: { id: stepId },
+                    data: {
+                        status: validation.allPassed ? 'done' : 'failed',
+                        output,
+                    },
                 });
-                if (stepId) {
-                    await ctx.prisma.taskStep.update({
-                        where: { id: stepId },
-                        data: {
-                            status: validation.allPassed ? 'done' : 'failed',
-                            output: JSON.stringify({ validation, publish: publishResult }),
-                        },
-                    });
-                }
-                if (validation.allPassed) {
+                if (!validation.allPassed) {
                     finished = true;
-                    success = true;
-                    summary = 'Validation passed';
+                    success = false;
+                    summary = 'Validation failed';
                 }
-                // If validation failed, keep the loop running so the agent can fix the issue.
                 break;
             }
             if (call.name === 'write_file' && typeof call.arguments.path === 'string') {
                 ctx.modifiedFiles.add(call.arguments.path);
+                ctx.recentReads.delete(call.arguments.path);
+            }
+            if (call.name === 'edit_file' && typeof call.arguments.path === 'string') {
+                ctx.modifiedFiles.add(call.arguments.path);
+                ctx.recentReads.delete(call.arguments.path);
+            }
+            const explorationTools = ['think', 'read_file', 'list_files', 'search', 'run_command', 'lsp_diagnostics', 'lsp_hover', 'lsp_symbol'];
+            const editTools = ['edit_file', 'write_file'];
+            const verifyTools = ['run_command', 'verify_api_surface', 'publish'];
+            const isExploration = explorationTools.includes(call.name);
+            const isEdit = editTools.includes(call.name);
+            if (isExploration)
+                ctx.explorationCount++;
+            if (isEdit) {
+                ctx.editCount++;
+                ctx.editsSinceVerify++;
+                ctx.explorationAtLastEdit = ctx.explorationCount;
+                if (ctx.editCount % 5 === 0) {
+                    await checkpointCommit(ctx);
+                }
+            }
+            if (verifyTools.includes(call.name)) {
+                ctx.editsSinceVerify = 0;
             }
             const toolSpan = ctx.tracer.startSpan(`agent.tool.${call.name}`, ctx.rootSpan.toContext());
             toolSpan.setAttributes({ tool: call.name });
-            const result = await executeTool(ctx.projectPath, call.name, call.arguments);
+            let result;
+            const stuckWithoutEdits = ctx.editCount === 0 && stepIndex >= 30 && !editTools.includes(call.name) && call.name !== 'finish' && call.name !== 'publish';
+            const explorationBudgetExhausted = ctx.editCount === 0 && ctx.explorationCount > 20 && isExploration;
+            const wanderingAfterEdits = ctx.editCount > 0 && ctx.explorationCount - ctx.explorationAtLastEdit > 20 && isExploration;
+            const needsVerifyAfterEdits = ctx.editsSinceVerify >= 3 && editTools.includes(call.name);
+            if (stuckWithoutEdits || explorationBudgetExhausted) {
+                result = {
+                    success: false,
+                    output: `Forcing action: you have used ${String(ctx.explorationCount)} exploration steps and made ${String(ctx.editCount)} edits. Stop exploring and use edit_file or write_file to advance the task.`,
+                };
+            }
+            else if (wanderingAfterEdits) {
+                result = {
+                    success: false,
+                    output: `Forcing action: you have used ${String(ctx.explorationCount - ctx.explorationAtLastEdit)} exploration steps since your last edit. Stop exploring and make another concrete edit, or run the test command to verify your changes.`,
+                };
+            }
+            else if (needsVerifyAfterEdits) {
+                result = {
+                    success: false,
+                    output: `Edit rejected: you have made ${String(ctx.editsSinceVerify)} edits since the last verification command. Run the project's test command (e.g. pnpm test) and review the output before editing again.`,
+                };
+            }
+            else if (call.name === 'think') {
+                ctx.consecutiveThinks++;
+                if (ctx.consecutiveThinks > 2) {
+                    result = {
+                        success: false,
+                        output: `Think rejected: you have already thought ${String(ctx.consecutiveThinks - 1)} times in a row. Stop planning and execute the next concrete step using read_file, run_command, or edit_file.`,
+                    };
+                }
+                else {
+                    result = await executeTool(ctx.projectPath, call.name, call.arguments);
+                }
+            }
+            else if (call.name === 'read_file' && typeof call.arguments.path === 'string') {
+                ctx.consecutiveThinks = 0;
+                const filePath = call.arguments.path.trim();
+                const lastRead = ctx.recentReads.get(filePath);
+                if (lastRead !== undefined && stepIndex - lastRead < 10) {
+                    result = {
+                        success: false,
+                        output: `Duplicate read rejected: "${filePath}" was already read at step ${String(lastRead)}. Use the previous content or move on to the next concrete step.`,
+                    };
+                }
+                else {
+                    ctx.recentReads.set(filePath, stepIndex);
+                    result = await executeTool(ctx.projectPath, call.name, call.arguments);
+                }
+            }
+            else if (call.name === 'run_command' && typeof call.arguments.command === 'string') {
+                ctx.consecutiveThinks = 0;
+                const command = call.arguments.command.trim();
+                if (ctx.recentCommands.has(command)) {
+                    result = {
+                        success: false,
+                        output: `Duplicate command rejected: "${command}" was already run in this session. Do not repeat commands. Use the previous output or move on to the next concrete step.`,
+                    };
+                }
+                else {
+                    ctx.recentCommands.add(command);
+                    result = await executeTool(ctx.projectPath, call.name, call.arguments);
+                }
+            }
+            else {
+                ctx.consecutiveThinks = 0;
+                result = await executeTool(ctx.projectPath, call.name, call.arguments);
+            }
+            const TOOL_OUTPUT_LIMIT = 6_000;
+            const displayOutput = result.output.length > TOOL_OUTPUT_LIMIT
+                ? `${result.output.slice(0, TOOL_OUTPUT_LIMIT)}\n... [truncated]`
+                : result.output;
             toolSpan.setAttributes({ success: result.success });
+            if (call.name === 'verify_api_surface' && result.success) {
+                ctx.apiSurfaceVerified = true;
+            }
             logger.info(`Tool ${call.name} executed`, {
                 taskId: ctx.task.id,
                 agentRunId: ctx.agentRunId,
@@ -273,38 +608,35 @@ async function executeAgentLoop(ctx) {
                 success: result.success,
             });
             await toolSpan.end(result.success ? 'ok' : 'error');
-            if (stepId) {
-                await ctx.prisma.taskStep.update({
-                    where: { id: stepId },
-                    data: {
-                        status: result.success ? 'done' : 'failed',
-                        output: result.output,
-                        error: result.success ? null : result.output,
-                    },
-                });
+            if (!result.success) {
+                turnHadFailure = true;
             }
+            await ctx.prisma.taskStep.update({
+                where: { id: stepId },
+                data: {
+                    status: result.success ? 'done' : 'failed',
+                    output: result.output,
+                    error: result.success ? null : result.output,
+                },
+            });
             await addTrace(ctx, 'tool', result.output, undefined, stepId);
-            toolResults.push({ toolCallId: call.id, output: result.output });
+            toolResults.push({ toolCallId: call.id, output: displayOutput });
+            messages.push({ role: 'tool', tool_call_id: call.id, content: displayOutput });
             stepIndex++;
-            // Auto-validate after edits or file creation. If validation passes, finish immediately.
-            if (result.success && (call.name === 'edit_file' || call.name === 'write_file')) {
-                const autoValidateSpan = ctx.tracer.startSpan('agent.auto_validate', ctx.rootSpan.toContext());
-                const validation = await validateProject(ctx.projectPath);
-                await ctx.prisma.agentRun.update({
-                    where: { id: ctx.agentRunId },
-                    data: { validationSummary: JSON.stringify(validation) },
-                });
-                autoValidateSpan.setAttributes({ allPassed: validation.allPassed });
-                await autoValidateSpan.end(validation.allPassed ? 'ok' : 'error');
-                if (validation.allPassed) {
-                    finished = true;
-                    success = true;
-                    summary = 'Validation passed';
-                    break;
-                }
+        }
+        const shouldReflect = turnHadFailure || lastTurnHadFailure || (turnCount > 0 && turnCount % 8 === 0);
+        lastTurnHadFailure = turnHadFailure;
+        let nextPrompt = buildToolResultPrompt(ctx.task, toolResults);
+        if (shouldReflect && !finished) {
+            const reflection = await reflectOnTrace(ctx, 6);
+            if (reflection) {
+                await addTrace(ctx, 'assistant', `Reflection: ${reflection}`);
+                nextPrompt = `Reflection: ${reflection}\n\n${nextPrompt}`;
             }
         }
-        prompt = buildToolResultPrompt(ctx.task, toolResults);
+        if (!finished) {
+            messages.push({ role: 'user', content: nextPrompt });
+        }
     }
     // Capture diff
     if (ctx.modifiedFiles.size > 0 || (await hasChanges(ctx.projectPath))) {
@@ -333,34 +665,115 @@ async function executeAgentLoop(ctx) {
     });
     await ctx.prisma.agentRun.update({
         where: { id: ctx.agentRunId },
-        data: { resultStatus: success ? 'done' : 'failed' },
+        data: {
+            resultStatus: success ? 'done' : 'failed',
+            promptTokens: ctx.usage.promptTokens,
+            completionTokens: ctx.usage.completionTokens,
+            totalTokens: ctx.usage.totalTokens,
+        },
     });
     return {
         task: toCoreTask(updatedTask),
         agentRunId: ctx.agentRunId,
     };
 }
-async function sendToProvider(ctx, prompt) {
+function recordUsage(ctx, usage) {
+    if (usage.promptTokens !== undefined) {
+        ctx.usage.promptTokens = (ctx.usage.promptTokens ?? 0) + usage.promptTokens;
+    }
+    if (usage.completionTokens !== undefined) {
+        ctx.usage.completionTokens = (ctx.usage.completionTokens ?? 0) + usage.completionTokens;
+    }
+    if (usage.totalTokens !== undefined) {
+        ctx.usage.totalTokens = (ctx.usage.totalTokens ?? 0) + usage.totalTokens;
+    }
+    else if (usage.promptTokens !== undefined && usage.completionTokens !== undefined) {
+        ctx.usage.totalTokens = (ctx.usage.totalTokens ?? 0) + usage.promptTokens + usage.completionTokens;
+    }
+}
+function truncateMessages(messages, maxTotal = 40, fullWindow = 10, truncateLength = 500) {
+    // Drop the system message from the transcript; the provider will prepend the
+    // full system prompt separately. This keeps the context window smaller.
+    const cleaned = messages.filter((m) => m.role !== 'system');
+    // Helper: return a copy of a message with content truncated.
+    const trimContent = (m) => {
+        if (!m.content || m.content.length <= truncateLength)
+            return m;
+        return { ...m, content: `${m.content.slice(0, truncateLength)}\n... [truncated]` };
+    };
+    // If we need to drop messages, drop whole assistant+tool+prompt turns from the
+    // start so that we never leave orphaned tool messages without their matching
+    // assistant tool_calls (OpenAI/Kimi rejects those conversations).
+    let working = cleaned;
+    if (cleaned.length > maxTotal) {
+        const toDrop = cleaned.length - maxTotal;
+        let keepFrom = toDrop;
+        while (keepFrom < cleaned.length) {
+            const m = cleaned[keepFrom];
+            if (m.role === 'assistant' && (keepFrom === 0 || cleaned[keepFrom - 1].role === 'user')) {
+                break;
+            }
+            keepFrom++;
+        }
+        working = cleaned.slice(keepFrom);
+    }
+    const windowStart = Math.max(0, working.length - fullWindow);
+    return working.map((m, idx) => {
+        if (idx >= windowStart)
+            return m;
+        return trimContent(m);
+    });
+}
+async function sendToProvider(ctx, messages, prompt) {
     const span = ctx.tracer.startSpan('provider.send', ctx.rootSpan.toContext());
     span.setAttributes({ provider: ctx.provider.config.name, model: ctx.model });
     const provider = ctx.provider;
+    const onUsage = (usage) => {
+        recordUsage(ctx, usage);
+        span.setAttributes({
+            promptTokens: usage.promptTokens,
+            completionTokens: usage.completionTokens,
+            totalTokens: usage.totalTokens,
+        });
+    };
+    const baseMessages = truncateMessages(messages);
     try {
-        // Prefer native tool calls when the provider supports them (including Kimi).
+        // Prefer native tool calls when the provider supports them.
         if (typeof provider.sendWithTools === 'function') {
-            const raw = await provider.sendWithTools(prompt, AGENT_TOOLS, {
+            const sendMessages = prompt ? [...baseMessages, { role: 'user', content: prompt }] : baseMessages;
+            const raw = await provider.sendWithTools(prompt ?? 'Execute the next step.', AGENT_TOOLS, {
                 system: ctx.systemPrompt,
                 model: ctx.model,
                 temperature: 0.3,
+                onUsage,
+                messages: sendMessages,
             });
             span.addEvent('provider.response.received');
             const parsed = parseProviderResponse(raw);
             await span.end('ok');
             return parsed;
         }
-        // Fallback to text-mode JSON tool calls for providers without native tool support.
-        const raw = await provider.send(prompt, {
+        // Fallback to text-mode JSON tool calls. Build a plain transcript so providers
+        // that do not support tool roles still see the full context.
+        const sendMessages = prompt ? [...baseMessages, { role: 'user', content: prompt }] : baseMessages;
+        const transcript = sendMessages
+            .map((m) => {
+            if (m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0) {
+                const calls = m.tool_calls
+                    .map((tc) => `  - ${tc.function?.name ?? ''}(${tc.function?.arguments ?? ''})`)
+                    .join('\n');
+                return `[assistant] ${m.content ?? ''}\nTool calls:\n${calls}`;
+            }
+            if (m.role === 'tool') {
+                return `[tool result for ${m.tool_call_id ?? ''}]\n${m.content ?? ''}`;
+            }
+            return `[${m.role}] ${m.content ?? ''}`;
+        })
+            .join('\n\n');
+        const raw = await provider.send(transcript, {
             system: buildTextToolsSystemPrompt(ctx.promptContext),
             model: ctx.model,
+            onUsage,
         });
         span.addEvent('provider.response.received');
         const parsed = parseProviderResponse(raw);