xibecode 0.7.6 → 0.9.1

package/dist/core/agent.js

@@ -5,16 +5,20 @@ import { EventEmitter } from 'events';
 import { MODE_CONFIG, createModeState, transitionMode, ModeOrchestrator, parseModeRequest, stripModeRequests, parseTaskComplete, stripTaskComplete } from './modes.js';
 import { NeuralMemory } from './memory.js';
 import { PROVIDER_CONFIGS } from '../utils/config.js';
+import { PermissionManager } from './permissions.js';
+import { ToolOrchestrator } from './tool-orchestrator.js';
+import { compactConversation } from './context-compactor.js';
 export class LoopDetector {
     history = [];
     maxRepeats = 3;
     timeWindow = 10000;
     check(toolName, toolInput) {
-        const signature = JSON.stringify({ tool: toolName, input: toolInput });
+        const signature = this.makeSignature(toolName, toolInput);
+        const coarse = this.makeCoarseSignature(toolName, toolInput);
         const now = Date.now();
-        this.history.push({ tool: toolName, input: signature, timestamp: now });
+        this.history.push({ tool: toolName, signature, coarse, timestamp: now });
         this.history = this.history.filter(h => now - h.timestamp < this.timeWindow);
-        const recentDuplicates = this.history.filter(h => h.input === signature);
+        const recentDuplicates = this.history.filter(h => h.signature === signature);
         if (recentDuplicates.length >= this.maxRepeats) {
             return {
                 allowed: false,
@@ -22,7 +26,21 @@ export class LoopDetector {
             };
         }
         const sameTool = this.history.filter(h => h.tool === toolName);
+        const sameCoarse = this.history.filter(h => h.coarse === coarse);
+        if (sameCoarse.length >= this.maxRepeats + 2) {
+            return {
+                allowed: false,
+                reason: `Loop detected: repeated ${toolName} attempts with near-identical input patterns`,
+            };
+        }
         if (sameTool.length >= this.maxRepeats * 2) {
+            const uniquePatterns = new Set(sameTool.map(h => h.coarse)).size;
+            if (uniquePatterns <= 2) {
+                return {
+                    allowed: false,
+                    reason: `Loop detected: ${toolName} repeated ${sameTool.length} times with low-variation inputs`,
+                };
+            }
             return {
                 allowed: true,
                 reason: `Warning: ${toolName} called ${sameTool.length} times recently`,
@@ -33,6 +51,34 @@ export class LoopDetector {
     reset() {
         this.history = [];
     }
+    makeSignature(toolName, input) {
+        return JSON.stringify({
+            tool: toolName,
+            input: this.canonicalize(input),
+        });
+    }
+    makeCoarseSignature(toolName, input) {
+        const canonical = this.canonicalize(input);
+        if (!canonical || typeof canonical !== 'object' || Array.isArray(canonical)) {
+            return `${toolName}:primitive`;
+        }
+        const keys = Object.keys(canonical).sort();
+        return `${toolName}:${keys.join(',')}`;
+    }
+    canonicalize(value) {
+        if (Array.isArray(value)) {
+            return value.map((item) => this.canonicalize(item));
+        }
+        if (value && typeof value === 'object') {
+            const inObj = value;
+            const out = {};
+            for (const key of Object.keys(inObj).sort()) {
+                out[key] = this.canonicalize(inObj[key]);
+            }
+            return out;
+        }
+        return value;
+    }
 }
 // ─── Think-tag streaming filter ───────────────────────────────
 class ThinkTagFilter {
@@ -142,6 +188,9 @@ export class EnhancedAgent extends EventEmitter {
     contextHintFiles = [];
     mindsetAdaptive = false;
     currentMindset = 'convergent';
+    permissionManager;
+    toolOrchestrator;
+    evidenceTrail = [];
     injectMessage(message) {
         this.injectedMessages.push(message);
     }
@@ -151,6 +200,97 @@ export class EnhancedAgent extends EventEmitter {
     clearInjectedMessages() {
         this.injectedMessages = [];
     }
+    recordEvidence(kind, detail) {
+        this.evidenceTrail.push({ kind, detail, ts: Date.now() });
+        if (this.evidenceTrail.length > 80) {
+            this.evidenceTrail = this.evidenceTrail.slice(-80);
+        }
+    }
+    estimateMessageTokens(message) {
+        const text = (() => {
+            if (typeof message.content === 'string')
+                return message.content;
+            if (!Array.isArray(message.content))
+                return '';
+            return message.content
+                .map((block) => {
+                if (block?.type === 'text')
+                    return String(block.text || '');
+                if (block?.type === 'tool_use') {
+                    const input = block.input ? JSON.stringify(block.input) : '{}';
+                    return `[tool_use:${String(block.name || 'unknown')}] ${input}`;
+                }
+                if (block?.type === 'tool_result') {
+                    return `[tool_result:${String(block.tool_use_id || 'unknown')}] ${String(block.content || '')}`;
+                }
+                return String(block?.content ?? '');
+            })
+                .join('\n');
+        })();
+        // Rough estimate for modern tokenizers across mixed text/code.
+        return Math.ceil(text.length / 4);
+    }
+    estimateConversationTokens() {
+        return this.messages.reduce((sum, message) => sum + this.estimateMessageTokens(message), 0);
+    }
+    hasRecentGroundedEvidence(windowMs = 5 * 60 * 1000) {
+        const threshold = Date.now() - windowMs;
+        return this.evidenceTrail.some((entry) => entry.ts >= threshold);
+    }
+    shouldEnforceCompletionEvidence() {
+        if (this.config.completionEvidenceMode === 'off')
+            return false;
+        // Allow single-turn informational answers without tools.
+        if (this.toolCallCount === 0 && this.filesChanged.size === 0 && this.iterationCount <= 1) {
+            return false;
+        }
+        return true;
+    }
+    async postEditVerify(toolExecutor, toolUse, result) {
+        if (this.config.postEditVerification === 'off') {
+            return { ok: true, message: 'disabled' };
+        }
+        if (!['write_file', 'edit_file', 'edit_lines', 'verified_edit'].includes(toolUse.name)) {
+            return { ok: true, message: 'not-applicable' };
+        }
+        const input = (toolUse.input ?? {});
+        const path = (typeof result?.path === 'string' && result.path) ||
+            (typeof input.path === 'string' && input.path) ||
+            '';
+        if (!path) {
+            const strict = this.config.postEditVerification === 'strict';
+            return {
+                ok: !strict,
+                message: strict ? 'post-edit verification failed: missing path' : 'post-edit verification skipped: missing path',
+            };
+        }
+        const readArgs = { path };
+        if (typeof input.start_line === 'number' && typeof input.end_line === 'number') {
+            readArgs.start_line = input.start_line;
+            readArgs.end_line = input.end_line;
+        }
+        const check = await toolExecutor.execute('read_file', readArgs);
+        if (check?.error || check?.success === false) {
+            return {
+                ok: false,
+                message: `post-edit verification failed: could not read ${path}`,
+            };
+        }
+        if (typeof input.new_content === 'string' && input.new_content.trim().length > 0) {
+            const observed = typeof check?.content === 'string' ? check.content : '';
+            const expected = input.new_content.trim();
+            const normalize = (v) => v.replace(/\s+/g, ' ').trim();
+            const expectedNeedle = normalize(expected).slice(0, 180);
+            if (expectedNeedle && !normalize(observed).includes(expectedNeedle)) {
+                return {
+                    ok: this.config.postEditVerification !== 'strict',
+                    message: `post-edit verification warning: updated content was not confidently observed in ${path}`,
+                };
+            }
+        }
+        this.recordEvidence('post_edit_verify', path);
+        return { ok: true, message: `verified ${path}` };
+    }
     // Pricing per 1M tokens (input/output) — Claude models
     static PRICING = {
         'claude-sonnet-4-5-20250929': { input: 3, output: 15 },
@@ -174,6 +314,7 @@ export class EnhancedAgent extends EventEmitter {
             mode: config.mode ?? 'agent',
             provider: config.provider ?? this.detectProvider(config.model),
             customProviderFormat: config.customProviderFormat ?? 'openai',
+            requestFormat: config.requestFormat ?? 'auto',
             planFirst: config.planFirst ?? false,
             sessionMemory: config.sessionMemory,
             contextHintFiles: config.contextHintFiles ?? [],
@@ -181,13 +322,18 @@ export class EnhancedAgent extends EventEmitter {
             executionModel: config.executionModel,
             mindsetAdaptive: config.mindsetAdaptive ?? false,
             strictTextOnlyCompletion: config.strictTextOnlyCompletion ?? false,
+            completionEvidenceMode: config.completionEvidenceMode ?? 'balanced',
+            postEditVerification: config.postEditVerification ?? 'balanced',
+            memoryRecallMinScore: config.memoryRecallMinScore ?? 2,
         };
         this.defaultSkillsPrompt = config.defaultSkillsPrompt ?? '';
         this.mindsetAdaptive = this.config.mindsetAdaptive ?? false;
         // Initialize mode state and orchestrator
         this.modeState = createModeState(this.config.mode);
+        this.permissionManager = new PermissionManager(this.config.mode);
+        this.toolOrchestrator = new ToolOrchestrator();
         this.modeOrchestrator = new ModeOrchestrator({
-            autoApprovalPolicy: 'always', // Allow AI to switch modes autonomously
+            autoApprovalPolicy: 'prompt-only',
             allowAutoEscalation: true,
         });
         // Prefer explicit provider override from config, otherwise auto-detect
@@ -243,18 +389,21 @@ export class EnhancedAgent extends EventEmitter {
         this.iterationCount = 0;
         this.toolCallCount = 0;
         this.loopDetector.reset();
+        this.evidenceTrail = [];
         this.messages.push({
             role: 'user',
             content: initialPrompt,
         });
         // ─── Neural Memory Recall ───
         try {
-            const memories = await this.memory.retrieve(initialPrompt);
+            const memories = await this.memory.retrieve(initialPrompt, 5, this.config.memoryRecallMinScore);
             if (memories.length > 0) {
                 const memoryContext = memories.map(m => `- [${new Date(m.timestamp).toISOString().split('T')[0]}] ${m.trigger} -> ${m.action} (${m.outcome})`).join('\n');
                 this.messages.push({
                     role: 'user',
-                    content: `\n\n[Neural Memory Recall]\nI found some relevant past experiences that might help:\n${memoryContext}\n\nUser Prompt: ${initialPrompt}`
+                    content: `\n\n[Neural Memory Recall — UNVERIFIED HINTS]\n` +
+                        `These are recall hints, not guaranteed facts. Verify with read_file / grep_code / tests before relying on them.\n` +
+                        `${memoryContext}\n\nUser Prompt: ${initialPrompt}`
                 });
                 this.emit('thinking', { message: `Recalled ${memories.length} relevant memories` });
             }
@@ -354,15 +503,29 @@ export class EnhancedAgent extends EventEmitter {
                         this.sessionCost += (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000;
                     }
                 }
-                // Auto-compact: if conversation exceeds 80 messages, compact older ones
-                if (this.messages.length > 80) {
-                    const preserved = this.messages.slice(-12);
-                    const compactNotice = {
-                        role: 'assistant',
-                        content: 'Earlier conversation was auto-compacted to save context window space. Recent messages are preserved.',
-                    };
-                    this.messages = [compactNotice, ...preserved];
-                    this.emit('warning', { message: 'Auto-compacted conversation to save context (kept last 12 messages)' });
+                // Auto-compact by estimated token budget (OpenClaude-style), not raw message count.
+                const compactionThreshold = 120_000;
+                const compactionTarget = 90_000;
+                let estimatedTokens = this.estimateConversationTokens();
+                if (estimatedTokens > compactionThreshold) {
+                    const beforeCount = this.messages.length;
+                    const compacted = compactConversation(this.messages, 24);
+                    this.messages = compacted.messages;
+                    estimatedTokens = this.estimateConversationTokens();
+                    this.emit('warning', {
+                        message: `${compacted.summaryNotice || 'Auto-compacted conversation to save context'} ` +
+                            `(estimated tokens: ${estimatedTokens})`,
+                    });
+                    // If still above target, compact once more with tighter window.
+                    if (estimatedTokens > compactionTarget && this.messages.length < beforeCount) {
+                        const compactedAgain = compactConversation(this.messages, 16);
+                        this.messages = compactedAgain.messages;
+                        estimatedTokens = this.estimateConversationTokens();
+                        this.emit('warning', {
+                            message: `${compactedAgain.summaryNotice || 'Second compaction pass applied'} ` +
+                                `(estimated tokens: ${estimatedTokens})`,
+                        });
+                    }
                 }
                 // Process response
                 const content = response.content;
@@ -384,10 +547,13 @@ export class EnhancedAgent extends EventEmitter {
                         this.modeState = this.modeOrchestrator.requestModeChange(this.modeState, modeRequest.mode, modeRequest.reason, 'model');
                         // Evaluate the request
                         const evaluation = this.modeOrchestrator.evaluateModeChangeRequest(this.modeState);
-                        if (evaluation.approved) {
+                        const permissionEvaluation = this.permissionManager.evaluateModeTransition(this.modeState.current, modeRequest.mode);
+                        const approvedByPermission = permissionEvaluation.approved;
+                        if (evaluation.approved && approvedByPermission) {
                             // Auto-approved - switch immediately
                             const oldMode = this.modeState.current;
                             this.modeState = transitionMode(this.modeState, modeRequest.mode, modeRequest.reason);
+                            this.permissionManager.setMode(modeRequest.mode);
                             // Update tool executor mode
                             if (toolExecutor.setMode) {
                                 toolExecutor.setMode(modeRequest.mode);
@@ -406,7 +572,7 @@ export class EnhancedAgent extends EventEmitter {
                                 to: modeRequest.mode,
                                 reason: modeRequest.reason,
                                 requiresConfirmation: evaluation.requiresConfirmation,
-                                message: evaluation.reason,
+                                message: permissionEvaluation.reason ?? evaluation.reason,
                             });
                         }
                     }
@@ -415,6 +581,7 @@ export class EnhancedAgent extends EventEmitter {
                     if (taskComplete) {
                         // Switch back to team_leader mode
                         this.modeState = transitionMode(this.modeState, 'team_leader', 'Task completed: ' + taskComplete.summary);
+                        this.permissionManager.setMode('team_leader');
                         this.emit('mode_changed', {
                             from: this.modeState.previous,
                             to: 'team_leader',
@@ -445,9 +612,27 @@ export class EnhancedAgent extends EventEmitter {
                 }
                 // If no tools, we're done (unless run-pr-style strict completion requires TASK_COMPLETE)
                 if (toolUseBlocks.length === 0) {
+                    const hasTaskComplete = textBlocks.some((b) => parseTaskComplete(b.text) != null);
+                    const hasEvidence = this.hasRecentGroundedEvidence();
+                    if (this.shouldEnforceCompletionEvidence()) {
+                        const needsTaskComplete = this.config.completionEvidenceMode === 'strict' || this.toolCallCount > 0;
+                        if ((needsTaskComplete && !hasTaskComplete) || !hasEvidence) {
+                            const reason = !hasEvidence
+                                ? 'no recent grounded evidence'
+                                : 'missing [[TASK_COMPLETE | summary=...]]';
+                            this.emit('warning', {
+                                message: `Completion evidence gate blocked finalize: ${reason}.`,
+                            });
+                            this.messages.push({
+                                role: 'user',
+                                content: '[SYSTEM] Completion gate: before finishing, provide grounded evidence from tool results/tests and then emit ' +
+                                    '[[TASK_COMPLETE | summary=<brief summary> | evidence=<paths/tests/tool proof>]]. Continue working until this is satisfied.',
+                            });
+                            continue;
+                        }
+                    }
                     if (this.config.strictTextOnlyCompletion &&
                         this.iterationCount < this.config.maxIterations) {
-                        const hasTaskComplete = textBlocks.some((b) => parseTaskComplete(b.text) != null);
                         if (!hasTaskComplete) {
                             this.emit('warning', {
                                 message: 'Assistant returned no tool calls without [[TASK_COMPLETE | summary=...]]; nudging to continue.',
@@ -468,69 +653,17 @@ export class EnhancedAgent extends EventEmitter {
                 }
                 // Execute tools
                 const toolResults = [];
-                for (let i = 0; i < toolUseBlocks.length; i++) {
-                    const toolUse = toolUseBlocks[i];
-                    this.toolCallCount++;
-                    // Loop detection
-                    const loopCheck = this.loopDetector.check(toolUse.name, toolUse.input);
-                    if (!loopCheck.allowed) {
-                        this.emit('warning', { message: loopCheck.reason });
-                        toolResults.push({
-                            type: 'tool_result',
-                            tool_use_id: toolUse.id,
-                            content: `Error: ${loopCheck.reason}. Try a different approach.`,
-                            is_error: true,
-                        });
-                        continue;
-                    }
-                    if (loopCheck.reason) {
-                        this.emit('warning', { message: loopCheck.reason });
-                    }
-                    // Emit tool call
-                    this.emit('tool_call', {
-                        name: toolUse.name,
-                        input: toolUse.input,
-                        index: i + 1,
+                const updates = await this.toolOrchestrator.executeBatches(toolUseBlocks, async (toolUse, i) => this.executeSingleToolUse(toolExecutor, toolUse, i));
+                for (const update of updates) {
+                    const payload = typeof update.result === 'string'
+                        ? update.result
+                        : JSON.stringify(update.result, null, 2);
+                    toolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: update.toolUse.id,
+                        content: payload,
+                        ...(update.success ? {} : { is_error: true }),
                     });
-                    // Execute
-                    try {
-                        const result = await toolExecutor.execute(toolUse.name, toolUse.input);
-                        // Track file changes
-                        if (['write_file', 'edit_file', 'edit_lines', 'verified_edit'].includes(toolUse.name)) {
-                            const input = toolUse.input;
-                            if (typeof input?.path === 'string')
-                                this.filesChanged.add(input.path);
-                        }
-                        const success = !result.error && result.success !== false;
-                        this.emit('tool_result', {
-                            name: toolUse.name,
-                            result,
-                            success,
-                        });
-                        if (this.sessionMemory) {
-                            const msg = typeof result === 'object' && result?.message != null ? String(result.message) : undefined;
-                            this.sessionMemory.recordAttempt(toolUse.name, success, msg);
-                        }
-                        const payload = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
-                        toolResults.push({
-                            type: 'tool_result',
-                            tool_use_id: toolUse.id,
-                            content: payload,
-                            ...(success ? {} : { is_error: true }),
-                        });
-                    }
-                    catch (error) {
-                        this.emit('error', {
-                            tool: toolUse.name,
-                            error: error.message,
-                        });
-                        toolResults.push({
-                            type: 'tool_result',
-                            tool_use_id: toolUse.id,
-                            content: `Error: ${error.message}`,
-                            is_error: true,
-                        });
-                    }
                 }
                 // Add injected messages if any exist
                 if (this.injectedMessages.length > 0) {
@@ -562,19 +695,103 @@ export class EnhancedAgent extends EventEmitter {
             });
         }
     }
+    /**
+     * Call the model with streaming (fallback to non-streaming).
+     */
+    async executeSingleToolUse(toolExecutor, toolUse, index) {
+        this.toolCallCount++;
+        const loopCheck = this.loopDetector.check(toolUse.name, toolUse.input);
+        if (!loopCheck.allowed) {
+            this.emit('warning', { message: loopCheck.reason });
+            return {
+                toolUse,
+                index,
+                result: `Error: ${loopCheck.reason}. Try a different approach.`,
+                success: false,
+            };
+        }
+        if (loopCheck.reason) {
+            this.emit('warning', { message: loopCheck.reason });
+        }
+        this.emit('tool_call', {
+            name: toolUse.name,
+            input: toolUse.input,
+            index: index + 1,
+        });
+        this.recordEvidence('tool_call', toolUse.name);
+        try {
+            let result = await toolExecutor.execute(toolUse.name, toolUse.input);
+            if (['write_file', 'edit_file', 'edit_lines', 'verified_edit'].includes(toolUse.name)) {
+                const input = toolUse.input;
+                if (typeof input?.path === 'string')
+                    this.filesChanged.add(input.path);
+            }
+            const verification = await this.postEditVerify(toolExecutor, toolUse, result);
+            if (!verification.ok) {
+                const currentMessage = typeof result?.message === 'string' && result.message
+                    ? `${result.message}; ${verification.message}`
+                    : verification.message;
+                if (result && typeof result === 'object') {
+                    result = { ...result, message: currentMessage, success: false, error: true, postVerify: verification.message };
+                }
+                else {
+                    result = { success: false, error: true, message: currentMessage, result };
+                }
+            }
+            else if (result && typeof result === 'object') {
+                result = { ...result, postVerify: verification.message };
+            }
+            const success = !result?.error && result?.success !== false;
+            this.emit('tool_result', {
+                name: toolUse.name,
+                result,
+                success,
+            });
+            this.recordEvidence(success ? 'tool_result_ok' : 'tool_result_error', `${toolUse.name}:${success ? 'ok' : 'error'}`);
+            if (this.sessionMemory) {
+                const msg = typeof result === 'object' && result?.message != null ? String(result.message) : undefined;
+                this.sessionMemory.recordAttempt(toolUse.name, success, msg);
+            }
+            return {
+                toolUse,
+                index,
+                result,
+                success,
+            };
+        }
+        catch (error) {
+            this.emit('error', {
+                tool: toolUse.name,
+                error: error.message,
+            });
+            return {
+                toolUse,
+                index,
+                result: `Error: ${error.message}`,
+                success: false,
+            };
+        }
+    }
     /**
      * Call the model with streaming (fallback to non-streaming).
      */
     async callModel(tools) {
         // Route to provider-specific implementation
         // Check if the provider uses the Anthropic format or OpenAI format
-        // Check if the provider uses the Anthropic format or OpenAI format
         let isAnthropicFormat = false;
-        if (this.provider !== 'custom') {
-            isAnthropicFormat = PROVIDER_CONFIGS[this.provider]?.format === 'anthropic';
+        const rf = this.config.requestFormat ?? 'auto';
+        if (rf === 'openai') {
+            isAnthropicFormat = false;
+        }
+        else if (rf === 'anthropic') {
+            isAnthropicFormat = true;
+        }
+        else if (this.provider !== 'custom') {
+            isAnthropicFormat =
+                PROVIDER_CONFIGS[this.provider]?.format ===
+                    'anthropic';
         }
-        // If custom provider, check specific format config
-        if (this.provider === 'custom') {
+        else {
             isAnthropicFormat = this.config.customProviderFormat === 'anthropic';
         }
         // If it's NOT Anthropic format, use the OpenAI-compatible client
@@ -727,27 +944,29 @@ export class EnhancedAgent extends EventEmitter {
      * Uses streaming (SSE) when available, with a non-streaming fallback.
      * Supports tools: sends them when provided and normalizes tool_calls in the response to Anthropic-style content blocks.
      */
-    async callOpenAI(tools) {
-        if (!this.config.apiKey) {
-            // Try to get from specifics if generic is missing, though ConfigManager should have handled this
-            // strict check might remain here
-            // throw new Error('API key is required for OpenAI-compatible provider');
-        }
-        // Determine Base URL: Config -> Provider Default -> OpenAI Default
+    /**
+     * OpenAI-compatible chat completions URL. Only appends `/chat/completions` to the
+     * configured base — do not inject an extra `/v1` segment (base URL must already
+     * include any API version prefix the user expects).
+     */
+    buildOpenAIChatCompletionsUrl() {
         let base = this.config.baseUrl;
         if (!base && this.provider && this.provider !== 'custom' && PROVIDER_CONFIGS[this.provider]) {
             base = PROVIDER_CONFIGS[this.provider].baseUrl;
         }
-        base = (base || 'https://api.openai.com').replace(/\/+$/, '');
-        let url;
-        // Special handling for some providers that strictly follow /v1 or not
-        if (base.endsWith('/v1') || base.endsWith('/v4')) {
-            // Z.ai ends in /v4, others /v1. If already included, just append chat/completions
-            url = `${base}/chat/completions`;
+        base = (base || 'https://api.openai.com/v1').replace(/\/+$/, '');
+        if (/\/chat\/completions$/i.test(base)) {
+            return base;
         }
-        else {
-            url = `${base}/v1/chat/completions`;
+        return `${base}/chat/completions`;
+    }
+    async callOpenAI(tools) {
+        if (!this.config.apiKey) {
+            // Try to get from specifics if generic is missing, though ConfigManager should have handled this
+            // strict check might remain here
+            // throw new Error('API key is required for OpenAI-compatible provider');
         }
+        const url = this.buildOpenAIChatCompletionsUrl();
         const openAiMessages = this.buildOpenAIMessages();
         const baseBody = {
             model: this.getModelForTier(),
@@ -1346,6 +1565,7 @@ When you complete the task, provide a comprehensive summary including:
 - Any trade-offs or design decisions made
 - Potential improvements or follow-up tasks
 - Test results and validation performed
+- If you used tools, finish with [[TASK_COMPLETE | summary=<brief summary> | evidence=<tool/test proof>]] only when work is actually complete.
 
 ${this.sessionMemory ? this.sessionMemory.getSummary() : ''}
 ${this.mindsetAdaptive ? `\n## Current reasoning mindset: ${this.currentMindset.toUpperCase()}\n${this.currentMindset === 'convergent' ? 'Focus on one solution; narrow options and commit. Use [[SET_MINDSET: divergent]] to explore alternatives, or [[SET_MINDSET: algorithmic]] for step-by-step.' : this.currentMindset === 'divergent' ? 'Explore alternatives; brainstorm. Use [[SET_MINDSET: convergent]] to narrow, or [[SET_MINDSET: algorithmic]] for step-by-step.' : 'Reason step-by-step; formal. Use [[SET_MINDSET: convergent]] to commit, or [[SET_MINDSET: divergent]] to explore.'}\n` : ''}