funolio-agent 1.0.52 → 1.0.75

package/dist/message-loop.d.ts

@@ -41,6 +41,10 @@ export declare class MessageLoop {
     /** Priority queue for commands when agent is busy */
     private commandQueue;
     private processing;
+    /** Idempotency guardrails */
+    private commandState;
+    private commandCompletedAt;
+    private static readonly COMMAND_DEDUPE_TTL_MS;
     /** Timeout for scheduled tasks (5 minutes) */
     private static readonly SCHEDULED_TASK_TIMEOUT_MS;
     private scheduledTaskTimer;
@@ -58,6 +62,8 @@ export declare class MessageLoop {
     /** Stop the idle detection timer */
     destroy(): void;
     isBusy(): boolean;
+    private pruneCommandDedupeCache;
+    private publishDuplicateIgnored;
     /**
      * Public entry point: enqueue or execute a command based on priority.
      * High-priority (user) commands execute immediately.

package/dist/message-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message-loop.d.ts","sourceRoot":"","sources":["../src/message-loop.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAe,MAAM,eAAe,CAAC;AAM3E,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAmB,cAAc,EAAqF,MAAM,YAAY,CAAC;AAGhJ,OAAO,EAAoB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAQpE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,eAAe,CAAC;IAC5B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA4ED,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,sBAAsB,CAAsB;IACpD,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,eAAe,CAAkB;IAEzC,sCAAsC;IACtC,OAAO,CAAC,sBAAsB,CAAS;IACvC,OAAO,CAAC,mBAAmB,CAAS;IAEpC,qDAAqD;IACrD,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,UAAU,CAAS;IAE3B,8CAA8C;IAC9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAiB;IAClE,OAAO,CAAC,kBAAkB,CAA8C;IAExE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAkB;gBAE/C,OAAO,EAAE,kBAAkB;IAkFvC;;;;;OAKG;YACW,qBAAqB;IA2CnC,iEAAiE;YACnD,gBAAgB;IAiB9B,oCAAoC;IACpC,OAAO,IAAI,IAAI;IAOf,MAAM,IAAI,OAAO;IAIjB;;;;OAIG;IACG,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BzD,4CAA4C;YAC9B,UAAU;IAOxB,iEAAiE;YACnD,iBAAiB;YAejB,eAAe;IAkqB7B,oEAAoE;IACpE,OAAO,CAAC,yBAAyB;YA0EnB,YAAY;IAW1B,yEAAyE;IACzE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAkBjC"}
+{"version":3,"file":"message-loop.d.ts","sourceRoot":"","sources":["../src/message-loop.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAe,MAAM,eAAe,CAAC;AAM3E,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAmB,cAAc,EAAiC,MAAM,YAAY,CAAC;AAG5F,OAAO,EAAoB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AASpE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,eAAe,CAAC;IAC5B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAqFD,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,sBAAsB,CAAsB;IACpD,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,eAAe,CAAkB;IAEzC,sCAAsC;IACtC,OAAO,CAAC,sBAAsB,CAAS;IACvC,OAAO,CAAC,mBAAmB,CAAS;IAEpC,qDAAqD;IACrD,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,UAAU,CAAS;IAE3B,6BAA6B;IAC7B,OAAO,CAAC,YAAY,CAAoE;IACxF,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAkB;IAE/D,8CAA8C;IAC9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAiB;IAClE,OAAO,CAAC,kBAAkB,CAA8C;IAExE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAkB;gBAE/C,OAAO,EAAE,kBAAkB;IAkFvC;;;;;OAKG;YACW,qBAAqB;IA2CnC,iEAAiE;YACnD,gBAAgB;IAiB9B,oCAAoC;IACpC,OAAO,IAAI,IAAI;IAOf,MAAM,IAAI,OAAO;IAIjB,OAAO,CAAC,uBAAuB;YAYjB,uBAAuB;IAWrC;;;;OAIG;IACG,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA2CzD,4CAA4C;YAC9B,UAAU;IAOxB,iEAAiE;YACnD,iBAAiB;YAejB,eAAe;IAozB7B,oEAAoE;IACpE,OAAO,CAAC,yBAAyB;YAuDnB,YAAY;IAW1B,yEAAyE;IACzE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAkBjC"}

package/dist/message-loop.js

@@ -52,6 +52,7 @@ const clerk_model_1 = require("./clerk-model");
 const local_funnel_1 = require("./local-funnel");
 const auto_organizer_1 = require("./auto-organizer");
 const tool_permissions_1 = require("./tool-permissions");
+const response_guard_1 = require("./response-guard");
 const data = __importStar(require("./local-data"));
 /** Determine priority from an AgentCommand */
 function getCommandPriority(command) {
@@ -117,6 +118,15 @@ function normalizeMcpToolNames(toolNames) {
         .filter(Boolean);
     return [...new Set(trimmed)];
 }
+function isFastPathEnvKeyCheck(prompt) {
+    const text = String(prompt || '').toLowerCase();
+    if (!text)
+        return false;
+    const asksOpenAiKey = /(openai[_\s-]*api[_\s-]*key|openai key)/i.test(text);
+    const asksPresence = /(is|check|whether|exists|set|available|configured|have access)/i.test(text);
+    const asksEnv = /(env|environment|variable|local)/i.test(text);
+    return asksOpenAiKey && (asksPresence || asksEnv);
+}
 class MessageLoop {
     options;
     llmProvider;
@@ -137,6 +147,10 @@ class MessageLoop {
     /** Priority queue for commands when agent is busy */
     commandQueue = [];
     processing = false;
+    /** Idempotency guardrails */
+    commandState = new Map();
+    commandCompletedAt = new Map();
+    static COMMAND_DEDUPE_TTL_MS = 30 * 60 * 1000;
     /** Timeout for scheduled tasks (5 minutes) */
     static SCHEDULED_TASK_TIMEOUT_MS = 5 * 60 * 1000;
     scheduledTaskTimer = null;
@@ -284,6 +298,27 @@ class MessageLoop {
     isBusy() {
         return this.processing || this.activeCommandId !== null;
     }
+    pruneCommandDedupeCache() {
+        const cutoff = Date.now() - MessageLoop.COMMAND_DEDUPE_TTL_MS;
+        for (const [commandId, completedAt] of this.commandCompletedAt.entries()) {
+            if (completedAt < cutoff) {
+                this.commandCompletedAt.delete(commandId);
+                if (this.commandState.get(commandId) === 'completed') {
+                    this.commandState.delete(commandId);
+                }
+            }
+        }
+    }
+    async publishDuplicateIgnored(command, reason) {
+        await this.options.mqttClient.publishResult({
+            commandId: command.id,
+            type: 'status',
+            phase: 'duplicate_ignored',
+            detail: reason,
+            status: 'duplicate_ignored',
+            timestamp: Date.now(),
+        });
+    }
     /**
      * Public entry point: enqueue or execute a command based on priority.
      * High-priority (user) commands execute immediately.
@@ -302,6 +337,18 @@ class MessageLoop {
         if (command.type === 'ping' || command.type === 'cancel') {
             return this._executeCommand(command);
         }
+        this.pruneCommandDedupeCache();
+        const existingState = this.commandState.get(command.id);
+        if (existingState === 'queued' || existingState === 'running') {
+            console.log(chalk_1.default.yellow(`  ↺ Duplicate command ignored ${command.id.slice(0, 8)}... (state=${existingState})`));
+            await this.publishDuplicateIgnored(command, `Command already ${existingState}`);
+            return;
+        }
+        if (existingState === 'completed' || existingState === 'failed') {
+            console.log(chalk_1.default.yellow(`  ↺ Duplicate command ignored ${command.id.slice(0, 8)}... (recently ${existingState})`));
+            await this.publishDuplicateIgnored(command, `Command already ${existingState}`);
+            return;
+        }
         const priority = getCommandPriority(command);
         // If not busy, execute directly
         if (!this.processing) {
@@ -310,6 +357,7 @@ class MessageLoop {
         // If busy but incoming is high priority and current is not high, queue current? No — just queue incoming.
         // Simple approach: queue everything when busy, drain by priority when done.
         console.log(chalk_1.default.yellow(`  ⏳ Agent busy, queuing command ${command.id.slice(0, 8)}... (priority: ${priority})`));
+        this.commandState.set(command.id, 'queued');
         this.commandQueue.push({ command, priority, queuedAt: Date.now() });
         // Sort: high first, then medium, then low
         this.commandQueue.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
@@ -359,6 +407,8 @@ class MessageLoop {
             return;
         }
         if (!command.prompt) {
+            this.commandState.set(command.id, 'failed');
+            this.commandCompletedAt.set(command.id, Date.now());
             await this.publishError(command.id, 'No prompt provided');
             return;
         }
@@ -424,14 +474,19 @@ class MessageLoop {
         this.toolDefinitions = (0, index_2.getAllToolDefinitions)(this._mcpManager);
         this.activeCommandId = command.id;
         this.activeCommandSource = command.source || 'user';
+        this.commandState.set(command.id, 'running');
         this.processing = true;
         this.lastMessageAt = Date.now();
         const commandStartMs = Date.now();
         let totalToolCalls = 0;
+        let totalToolErrors = 0; // Phase 3.3: track errors for step_progress events
+        let commandFailed = false;
         // Set timeout for scheduled tasks (5 minutes)
         if (command.source === 'scheduled') {
             this.scheduledTaskTimer = setTimeout(() => {
                 console.log(chalk_1.default.red(`  ⏰ Scheduled task ${command.id.slice(0, 8)} timed out after 5 minutes`));
+                this.commandState.set(command.id, 'failed');
+                this.commandCompletedAt.set(command.id, Date.now());
                 this.activeCommandId = null;
                 this.processing = false;
                 this.publishTaskResult(command, 'Task timed out after 5 minutes', false);
@@ -492,21 +547,23 @@ class MessageLoop {
             // Resolve the selected bot profile — from command.bot, conversation bot_id, or default
             const selectedBotId = command.bot?.id || activeConversation?.bot_id || localAgentId;
             const activeProfile = selectedBotId ? localData?.getAgentProfile(selectedBotId) : null;
-            if (activeProfile?.role_class === 'orchestrator' && localFirst) {
-                const clerk = (0, clerk_model_1.getClerk)();
-                if (!clerk) {
-                    // Do not silently fall through to direct chat — report error
-                    await this.publishError(command.id, 'Orchestrator mode requires a clerk model. Please add a provider connection in Settings.');
-                    this.activeCommandId = null;
-                    this.processing = false;
-                    this.drainQueue();
-                    return;
-                }
+            if (localFirst && (activeProfile?.role_class === 'orchestrator' || localData?.isClerkOrchestratorEnabled?.())) {
                 {
-                    const { OrchestratorAgent } = await Promise.resolve().then(() => __importStar(require('./orchestrator')));
+                    const { OrchestratorAgent, buildLocalDesktopOrchestratorRuntime } = await Promise.resolve().then(() => __importStar(require('./orchestrator')));
                     const { getWorkflowEngine } = await Promise.resolve().then(() => __importStar(require('./workflow-engine')));
                     const workflowEngine = getWorkflowEngine(this.options.projectDir);
-                    const orchestrator = new OrchestratorAgent(clerk, workflowEngine);
+                    let orchestratorRuntime;
+                    try {
+                        orchestratorRuntime = buildLocalDesktopOrchestratorRuntime(activeProfile || undefined);
+                    }
+                    catch (runtimeErr) {
+                        await this.publishError(command.id, runtimeErr?.message || 'Orchestrator mode is not configured correctly.');
+                        this.activeCommandId = null;
+                        this.processing = false;
+                        this.drainQueue();
+                        return;
+                    }
+                    const orchestrator = new OrchestratorAgent(orchestratorRuntime, workflowEngine);
                     try {
                         const response = await orchestrator.handleUserMessage(command.prompt, localConvId || '', {
                             projectDir: this.options.projectDir,
@@ -524,7 +581,7 @@ class MessageLoop {
                         });
                         // Save O's response to local DB
                         if (localConvId && localData) {
-                            localData.addMessage(localConvId, 'assistant', response, undefined, undefined, activeProfile.id, 'Project Manager');
+                            localData.addMessage(localConvId, 'assistant', response, undefined, undefined, activeProfile?.id, 'Project Manager');
                         }
                         // Publish final response and complete
                         await this.options.mqttClient.publishResult({
@@ -555,6 +612,81 @@ class MessageLoop {
                     return;
                 }
             }
+            // Fast-path: simple environment API-key presence checks for Claude CLI.
+            // This avoids full LLM/tool orchestration latency for common operational asks.
+            if (provider === 'claude-cli' && isFastPathEnvKeyCheck(command.prompt)) {
+                await this.options.mqttClient.publishResult({
+                    commandId: command.id,
+                    type: 'status',
+                    phase: 'thinking',
+                    detail: 'Checking local environment…',
+                    timestamp: Date.now(),
+                });
+                const checkCommand = `if [ -n "${'$'}OPENAI_API_KEY" ]; then echo "OPENAI_API_KEY=set"; else echo "OPENAI_API_KEY=not_set"; fi; if [ -f .env ]; then if grep -q '^OPENAI_API_KEY=' .env; then echo ".env_OPENAI_API_KEY=present"; else echo ".env_OPENAI_API_KEY=absent"; fi; else echo ".env=missing"; fi`;
+                const rawResult = await (0, tools_1.executeToolWithMCP)({ id: `fastpath-${Date.now()}`, name: 'run_command', arguments: { command: checkCommand, cwd: this.options.projectDir } }, commandToolContext, this.options.mcpManager);
+                const verified = await (0, verification_1.verifyToolResult)(rawResult, { command: checkCommand, cwd: this.options.projectDir }, commandToolContext);
+                const output = verified.success ? verified.output : `ERROR: ${verified.error || 'Unknown error'}`;
+                const keySet = /OPENAI_API_KEY=set/.test(output);
+                const envFilePresent = /\.env_OPENAI_API_KEY=present/.test(output);
+                const final = keySet || envFilePresent
+                    ? 'OPENAI_API_KEY is set (environment and/or .env).'
+                    : 'No OPENAI_API_KEY is set in the current environment or .env file.';
+                await this.options.mqttClient.publishResult({
+                    commandId: command.id,
+                    type: 'tool_call',
+                    toolCall: {
+                        id: `fastpath-${Date.now()}`,
+                        name: 'run_command',
+                        arguments: { command: 'check OPENAI_API_KEY presence' },
+                        classification: 'command_run',
+                        summary: 'Fast-path env key presence check',
+                        cwd: this.options.projectDir,
+                        importance: 'low',
+                    },
+                    timestamp: Date.now(),
+                });
+                await this.options.mqttClient.publishResult({
+                    commandId: command.id,
+                    type: 'tool_result',
+                    toolResult: {
+                        callId: `fastpath-${Date.now()}`,
+                        output: output.slice(0, 500),
+                        isError: !verified.success,
+                        success: verified.success,
+                        summary: summarizeToolResult(output, !verified.success),
+                        cwd: this.options.projectDir,
+                    },
+                    timestamp: Date.now(),
+                });
+                await this.options.mqttClient.publishResult({
+                    commandId: command.id,
+                    type: 'chunk',
+                    content: final,
+                    timestamp: Date.now(),
+                });
+                await this.options.mqttClient.publishResult({
+                    commandId: command.id,
+                    type: 'complete',
+                    content: '',
+                    finalContent: final,
+                    finalContentLength: final.length,
+                    timestamp: Date.now(),
+                });
+                if (localFirst && localConvId && localData) {
+                    try {
+                        localData.addMessage(localConvId, 'assistant', final, model);
+                    }
+                    catch { }
+                }
+                this.activeCommandId = null;
+                this.processing = false;
+                if (this.scheduledTaskTimer) {
+                    clearTimeout(this.scheduledTaskTimer);
+                    this.scheduledTaskTimer = null;
+                }
+                this.drainQueue();
+                return;
+            }
             // Build messages from context
             const messages = [];
             // Add previous conversation context
@@ -617,6 +749,8 @@ TOOL EFFICIENCY RULES:
             let iteration = 0;
             const MAX_ITERATIONS = Infinity;
             let totalTokensUsed = 0;
+            let forcedFinalizationPass = false;
+            const llmTimingSamples = [];
             while (iteration < MAX_ITERATIONS && this.activeCommandId === command.id) {
                 iteration++;
                 // Send a separator between agentic loop iterations so streamed text
@@ -656,6 +790,28 @@ TOOL EFFICIENCY RULES:
                     console.log(chalk_1.default.gray(`  [tool-filter] ${filteredTools.length}/${this.toolDefinitions.length} tools selected`));
                 }
                 let response;
+                const llmCallStartMs = Date.now();
+                let firstChunkLatencyMs = null;
+                await this.options.mqttClient.publishResult({
+                    commandId: command.id,
+                    type: 'status',
+                    phase: 'thinking',
+                    detail: iteration === 1 ? 'Working on it…' : `Continuing… (pass ${iteration})`,
+                    timestamp: Date.now(),
+                });
+                let emittedSlowStatus = false;
+                const slowStatusTimer = setTimeout(() => {
+                    if (this.activeCommandId !== command.id || firstChunkLatencyMs !== null)
+                        return;
+                    emittedSlowStatus = true;
+                    this.options.mqttClient.publishResult({
+                        commandId: command.id,
+                        type: 'status',
+                        phase: 'thinking',
+                        detail: 'Still working…',
+                        timestamp: Date.now(),
+                    }).catch(() => { });
+                }, 2000);
                 try {
                     response = await llm.chat({
                         messages,
@@ -665,6 +821,9 @@ TOOL EFFICIENCY RULES:
                         onChunk: async (chunk) => {
                             if (this.activeCommandId !== command.id)
                                 return;
+                            if (firstChunkLatencyMs === null) {
+                                firstChunkLatencyMs = Date.now() - llmCallStartMs;
+                            }
                             await this.options.mqttClient.publishResult({
                                 commandId: command.id,
                                 type: 'chunk',
@@ -673,8 +832,12 @@ TOOL EFFICIENCY RULES:
                             });
                         },
                     });
+                    clearTimeout(slowStatusTimer);
+                    const llmTotalMs = Date.now() - llmCallStartMs;
+                    llmTimingSamples.push(`iter${iteration}:firstChunkMs=${firstChunkLatencyMs ?? llmTotalMs},totalMs=${llmTotalMs},selectedTools=${filteredTools.length},slowStatus=${emittedSlowStatus ? 1 : 0}`);
                 }
                 catch (llmError) {
+                    clearTimeout(slowStatusTimer);
                     const msg = llmError?.message || String(llmError);
                     const isAuthError = /401|403|unauthorized|forbidden|authentication/i.test(msg);
                     if (isAuthError) {
@@ -703,9 +866,14 @@ TOOL EFFICIENCY RULES:
                     });
                     for (const toolCall of response.toolCalls) {
                         totalToolCalls++;
+                        await this.options.mqttClient.publishResult({
+                            commandId: command.id,
+                            type: 'status',
+                            phase: 'calling_tool',
+                            detail: `Running ${toolCall.name}...`,
+                            timestamp: Date.now(),
+                        });
                         console.log(chalk_1.default.cyan(`  🔧 Tool: ${toolCall.name}(${JSON.stringify(toolCall.arguments).slice(0, 60)}...)`));
-                        const toolSummary = (0, approval_1.generateToolSummary)(toolCall.name, toolCall.arguments);
-                        const toolLocation = extractToolLocation(toolCall.name, toolCall.arguments, commandToolContext.projectDir);
                         // Check permission before execution
                         const permMode = this.options.permissionMode || 'autopilot';
                         const allowedToolNames = this.options.enabledTools !== undefined || this.options.enabledMcpTools !== undefined
@@ -715,29 +883,17 @@ TOOL EFFICIENCY RULES:
                         // If not auto-approved, request interactive approval via MQTT
                         if (!approval.approved && permMode !== 'autopilot') {
                             console.log(chalk_1.default.yellow(`  🔐 Requesting user approval for: ${toolCall.name}`));
-                            approval = await this.approvalManager.requestApproval(command.id, toolCall.name, toolCall.arguments, {
-                                onRequest: async (request) => {
-                                    await this.options.mqttClient.publishResult({
-                                        commandId: command.id,
-                                        type: 'approval_request',
-                                        requestId: request.requestId,
-                                        riskLevel: request.riskLevel,
-                                        summary: request.summary,
-                                        toolCall: {
-                                            id: toolCall.id,
-                                            name: toolCall.name,
-                                            arguments: toolCall.arguments,
-                                            classification: classifyToolName(toolCall.name),
-                                            summary: toolSummary,
-                                            path: toolLocation.path,
-                                            cwd: toolLocation.cwd,
-                                            url: toolLocation.url,
-                                            importance: request.riskLevel === 'destructive' ? 'high' : 'medium',
-                                        },
-                                        timestamp: Date.now(),
-                                    });
+                            await this.options.mqttClient.publishResult({
+                                commandId: command.id,
+                                type: 'approval_request',
+                                toolCall: {
+                                    id: toolCall.id,
+                                    name: toolCall.name,
+                                    arguments: toolCall.arguments,
                                 },
+                                timestamp: Date.now(),
                             });
+                            approval = await this.approvalManager.requestApproval(command.id, toolCall.name, toolCall.arguments);
                             // If user chose "always allow", persist it
                             if (approval.approved && approval.remember) {
                                 (0, approval_1.rememberTool)(toolCall.name);
@@ -746,26 +902,19 @@ TOOL EFFICIENCY RULES:
                         }
                         if (!approval.approved) {
                             console.log(chalk_1.default.yellow(`  ⚠ Tool denied: ${approval.reason}`));
-                            const deniedOutput = `PERMISSION_DENIED: ${approval.reason}`;
                             await this.options.mqttClient.publishResult({
                                 commandId: command.id,
                                 type: 'tool_result',
                                 toolResult: {
                                     callId: toolCall.id,
-                                    output: deniedOutput,
+                                    output: `PERMISSION_DENIED: ${approval.reason}`,
                                     isError: true,
-                                    success: false,
-                                    summary: summarizeToolResult(deniedOutput, true),
-                                    path: toolLocation.path,
-                                    cwd: toolLocation.cwd,
-                                    url: toolLocation.url,
-                                    pathsTouched: toolLocation.path ? [toolLocation.path] : [],
                                 },
                                 timestamp: Date.now(),
                             });
                             messages.push({
                                 role: 'tool',
-                                content: deniedOutput,
+                                content: `PERMISSION_DENIED: ${approval.reason}`,
                                 toolCallId: toolCall.id,
                                 toolName: toolCall.name,
                             });
@@ -778,12 +927,6 @@ TOOL EFFICIENCY RULES:
                                 id: toolCall.id,
                                 name: toolCall.name,
                                 arguments: toolCall.arguments,
-                                classification: classifyToolName(toolCall.name),
-                                summary: toolSummary,
-                                path: toolLocation.path,
-                                cwd: toolLocation.cwd,
-                                url: toolLocation.url,
-                                importance: (0, approval_1.getRiskLevel)(toolCall.name) === 'destructive' ? 'high' : 'medium',
                             },
                             timestamp: Date.now(),
                         });
@@ -793,6 +936,9 @@ TOOL EFFICIENCY RULES:
                         const resultOutput = toolResult.success
                             ? toolResult.output
                             : `ERROR: ${toolResult.error || 'Unknown error'}`;
+                        // Phase 3.3: Track tool errors
+                        if (!toolResult.success)
+                            totalToolErrors++;
                         console.log(chalk_1.default.gray(`    Result: ${toolResult.success ? '✓' : '✗'} ${resultOutput.slice(0, 100)}${resultOutput.length > 100 ? '...' : ''}`));
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
@@ -801,16 +947,37 @@ TOOL EFFICIENCY RULES:
                                 callId: toolCall.id,
                                 output: resultOutput,
                                 isError: !toolResult.success,
-                                success: toolResult.success,
-                                summary: summarizeToolResult(resultOutput, !toolResult.success),
-                                path: toolLocation.path,
-                                cwd: toolLocation.cwd,
-                                url: toolLocation.url,
-                                pathsTouched: toolLocation.path ? [toolLocation.path] : [],
-                                exitCode: typeof toolResult.exit_code === 'number' ? toolResult.exit_code : undefined,
                             },
                             timestamp: Date.now(),
                         });
+                        // Phase 3.3: Emit structured step_progress event for watchdog consumption
+                        if (command.taskId) {
+                            try {
+                                await this.options.mqttClient.publishResult({
+                                    commandId: command.id,
+                                    type: 'tool_result',
+                                    toolResult: {
+                                        callId: `step_progress_${toolCall.id}`,
+                                        output: JSON.stringify({
+                                            type: 'step_progress',
+                                            taskId: command.taskId,
+                                            toolName: toolCall.name,
+                                            arguments: toolCall.arguments,
+                                            success: toolResult.success,
+                                            errorMessage: toolResult.success ? undefined : (toolResult.error || 'Unknown error'),
+                                            totalToolCalls,
+                                            errorCount: totalToolErrors,
+                                            timestamp: Date.now(),
+                                        }),
+                                        isError: false,
+                                    },
+                                    timestamp: Date.now(),
+                                });
+                            }
+                            catch {
+                                // Best effort — don't break the main loop for progress reporting
+                            }
+                        }
                         // Add tool result to messages using proper 'tool' role for provider formatting
                         messages.push({
                             role: 'tool',
@@ -895,13 +1062,27 @@ TOOL EFFICIENCY RULES:
                     continue;
                 }
                 // No tool calls - final response.
+                const candidate = (response.content || '').trim();
+                if (!forcedFinalizationPass && (0, response_guard_1.isLikelyDeferredReply)(candidate)) {
+                    forcedFinalizationPass = true;
+                    messages.push({ role: 'assistant', content: candidate });
+                    messages.push({
+                        role: 'user',
+                        content: 'Provide the final answer now. Do not say you will check later. Either provide concrete results or explicitly say what is unavailable.',
+                    });
+                    console.log(chalk_1.default.yellow('  [response-guard] Deferred-style reply detected; forcing finalization pass'));
+                    continue;
+                }
                 // DEDUP FIX: Content was already streamed via onChunk callbacks above.
-                // The 'complete' message signals end-of-response; we send empty content
-                // to avoid the receiver concatenating streamed chunks + full content.
+                // The 'complete' message signals end-of-response; include finalContent
+                // metadata so clients can reconcile if stream chunks were truncated.
+                const finalResponseText = (response.content || '').trim();
                 await this.options.mqttClient.publishResult({
                     commandId: command.id,
                     type: 'complete',
-                    content: '',
+                    content: finalResponseText,
+                    finalContent: finalResponseText,
+                    finalContentLength: finalResponseText.length,
                     timestamp: Date.now(),
                 });
                 // Local-first: save assistant response to SQLite + trigger funnel
@@ -922,15 +1103,17 @@ TOOL EFFICIENCY RULES:
                 }
                 console.log(chalk_1.default.white(`  Response: ${response.content?.slice(0, 200)}${(response.content?.length || 0) > 200 ? '...' : ''}`));
                 const latencyMs = Date.now() - commandStartMs;
-                console.log(`[agent-metrics] commandId=${command.id} contextSections=${contextSectionCount} toolCallsMade=${totalToolCalls} iterations=${iteration} totalTokens=${totalTokensUsed} latencyMs=${latencyMs}`);
+                console.log(`[agent-metrics] commandId=${command.id} contextSections=${contextSectionCount} toolCallsMade=${totalToolCalls} iterations=${iteration} totalTokens=${totalTokensUsed} latencyMs=${latencyMs} llmTimings="${llmTimingSamples.join(' | ')}"`);
                 console.log(chalk_1.default.green(`  Command completed: ${iteration} iterations, ${totalToolCalls} tool calls, ~${totalTokensUsed} tokens`));
                 break;
             }
             if (iteration >= MAX_ITERATIONS) {
+                commandFailed = true;
                 await this.publishError(command.id, `Max iterations (${MAX_ITERATIONS}) reached`);
             }
         }
         catch (error) {
+            commandFailed = true;
             console.error(chalk_1.default.red(`  ✗ Error: ${error.message}`));
             await this.publishError(command.id, error.message);
         }
@@ -938,6 +1121,8 @@ TOOL EFFICIENCY RULES:
             this.activeCommandId = null;
             this.activeCommandSource = null;
             this.processing = false;
+            this.commandState.set(command.id, commandFailed ? 'failed' : 'completed');
+            this.commandCompletedAt.set(command.id, Date.now());
             // Clear scheduled task timeout
             if (this.scheduledTaskTimer) {
                 clearTimeout(this.scheduledTaskTimer);
@@ -957,7 +1142,6 @@ TOOL EFFICIENCY RULES:
             || this.options.systemPrompt
             || 'You are a Funolio AI agent running locally on the user\'s machine. You have access to their project files and can execute code.';
         systemPrompt += '\n\nIMPORTANT: When the user references a project, topic, or past work, use the relevant memory/facts provided below. If no relevant facts are available, say so honestly rather than guessing. Use your tools (file browsing, commands) to find project files on the local machine.';
-        systemPrompt += '\n\nIMPORTANT: If a Workspace Manifest or Recent Operational State section is present, use it before repeating discovery work. Check known local files and directories before fetching from external sources. Do not re-fetch from Drive, GitHub, or the web if the state context shows the artifact is already local unless the user explicitly asks for a fresh external copy.';
         systemPrompt += '\n\nDo not end with a deferred promise (for example: "Let me check..."). Return a final answer in this turn, or state exactly what is unavailable.';
         systemPrompt += '\n\n' + (0, clerk_model_1.buildTodoInstructions)(this.options.agentName || 'LLM');
         // Inject model self-switch info
@@ -1002,32 +1186,6 @@ When a user asks to "use Opus" or "switch to GPT-4o", identify the right model I
         if (command.context?.files?.length) {
             systemPrompt += '\n\nRelevant files: ' + command.context.files.join(', ');
         }
-        if (command.context?.stateContext?.summaryText) {
-            systemPrompt += '\n\n[Recent Operational State]\n' + command.context.stateContext.summaryText;
-        }
-        if (command.context?.workspaceManifest) {
-            const manifestLines = [];
-            const manifest = command.context.workspaceManifest;
-            if (manifest.projectRoot)
-                manifestLines.push(`- Project root: ${manifest.projectRoot}`);
-            if (manifest.likelyWorkingDirectory)
-                manifestLines.push(`- Likely working directory: ${manifest.likelyWorkingDirectory}`);
-            if (manifest.recentlyReadFiles?.length)
-                manifestLines.push(`- Recently read files: ${manifest.recentlyReadFiles.join(', ')}`);
-            if (manifest.recentlyWrittenFiles?.length)
-                manifestLines.push(`- Recently written files: ${manifest.recentlyWrittenFiles.join(', ')}`);
-            if (manifest.recentlyScannedDirectories?.length)
-                manifestLines.push(`- Recently scanned directories: ${manifest.recentlyScannedDirectories.join(', ')}`);
-            if (manifest.recentDownloads?.length)
-                manifestLines.push(`- Recent downloads: ${manifest.recentDownloads.join(', ')}`);
-            if (manifest.recentFailures?.length)
-                manifestLines.push(`- Recent failures: ${manifest.recentFailures.join(' | ')}`);
-            if (manifest.startHereHints?.length)
-                manifestLines.push(`- Start here: ${manifest.startHereHints.join(', ')}`);
-            if (manifestLines.length) {
-                systemPrompt += '\n\n[Workspace Manifest]\n' + manifestLines.join('\n');
-            }
-        }
         return systemPrompt;
     }
     async publishError(commandId, error) {