lemura 1.5.0 → 1.5.2

package/dist/index.d.mts

@@ -1,7 +1,7 @@
-import { a as IProviderAdapter, d as TranscriptionRequest, e as TranscriptionResponse, f as SynthesisRequest, A as AudioChunk, V as VisionRequest, g as VisionResponse, h as ImageGenRequest, i as ImageGenResponse, M as ModelInfo, C as ContextWindow, T as Turn, j as ContentBlock, I as IToolDefinition } from './adapters-S96Ka9wt.mjs';
-export { k as CompletionChunk, l as CompletionRequest, m as CompletionResponse, b as IContextStrategy, c as IScratchpadAdapter, n as IStorageAdapter, N as NormalizedMessage, o as STMItem, p as STMRegistryConfig, S as ShortTermMemoryRegistry, q as TokenUsage, r as ToolCall, s as ToolContext, t as ToolResult } from './adapters-S96Ka9wt.mjs';
-import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, M as MCPServerConfig, a as MCPToolDefinition } from './agent-BefjpRHZ.mjs';
-export { b as GoalInjector, c as GoalVerifierResult, d as MCPJsonRpcRequest, e as MCPJsonRpcResponse, f as MCPTransportType, g as MediaConfig, h as ToolDecision, i as ToolExecutionBudget, j as ToolFirewallConfig, k as ToolFirewallRule, l as TraceEvent } from './agent-BefjpRHZ.mjs';
+import { a as IProviderAdapter, d as TranscriptionRequest, e as TranscriptionResponse, f as SynthesisRequest, A as AudioChunk, V as VisionRequest, g as VisionResponse, h as ImageGenRequest, i as ImageGenResponse, M as ModelInfo, C as ContextWindow, T as Turn, j as ContentBlock, I as IToolDefinition } from './adapters-DAzmrg4l.mjs';
+export { k as CompletionChunk, l as CompletionRequest, m as CompletionResponse, b as IContextStrategy, c as IScratchpadAdapter, n as IStorageAdapter, N as NormalizedMessage, o as STMItem, p as STMRegistryConfig, S as ShortTermMemoryRegistry, q as TokenUsage, r as ToolCall, s as ToolContext, t as ToolResult } from './adapters-DAzmrg4l.mjs';
+import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, M as MCPServerConfig, a as MCPToolDefinition } from './agent-DPSUNlK6.mjs';
+export { b as GoalInjector, c as GoalVerifierResult, d as MCPJsonRpcRequest, e as MCPJsonRpcResponse, f as MCPTransportType, g as MediaConfig, h as ToolDecision, i as ToolExecutionBudget, j as ToolFirewallConfig, k as ToolFirewallRule, l as TraceEvent } from './agent-DPSUNlK6.mjs';
 export { LemuraAdapterError, LemuraContextOverflowError, LemuraError, LemuraMCPConnectionError, LemuraMCPError, LemuraMCPTimeoutError, LemuraMaxIterationsError, LemuraSkillInjectionError, LemuraToolNotFoundError, LemuraToolTimeoutError, LemuraToolValidationError } from './types/index.mjs';
 import { I as ILogger } from './logger-DxvKliuk.mjs';
 export { L as LogLevel, a as LogMetadata, S as Severity } from './logger-DxvKliuk.mjs';
@@ -226,6 +226,8 @@ declare class SessionManager {
     private toolResponseProcessor;
     private goalInjector;
     private continuationPlanner;
+    /** Frozen goal/plan injection text keyed by turn index — used when staticSystemPrompt is on */
+    private _turnInjections;
     private mcpRegistry;
     /** Resolves when all MCP servers are connected; awaited by run() and stream() */
     private mcpReady;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { a as IProviderAdapter, d as TranscriptionRequest, e as TranscriptionResponse, f as SynthesisRequest, A as AudioChunk, V as VisionRequest, g as VisionResponse, h as ImageGenRequest, i as ImageGenResponse, M as ModelInfo, C as ContextWindow, T as Turn, j as ContentBlock, I as IToolDefinition } from './adapters-DHQOGl8Y.js';
-export { k as CompletionChunk, l as CompletionRequest, m as CompletionResponse, b as IContextStrategy, c as IScratchpadAdapter, n as IStorageAdapter, N as NormalizedMessage, o as STMItem, p as STMRegistryConfig, S as ShortTermMemoryRegistry, q as TokenUsage, r as ToolCall, s as ToolContext, t as ToolResult } from './adapters-DHQOGl8Y.js';
-import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, M as MCPServerConfig, a as MCPToolDefinition } from './agent-CjoFQGlk.js';
-export { b as GoalInjector, c as GoalVerifierResult, d as MCPJsonRpcRequest, e as MCPJsonRpcResponse, f as MCPTransportType, g as MediaConfig, h as ToolDecision, i as ToolExecutionBudget, j as ToolFirewallConfig, k as ToolFirewallRule, l as TraceEvent } from './agent-CjoFQGlk.js';
+import { a as IProviderAdapter, d as TranscriptionRequest, e as TranscriptionResponse, f as SynthesisRequest, A as AudioChunk, V as VisionRequest, g as VisionResponse, h as ImageGenRequest, i as ImageGenResponse, M as ModelInfo, C as ContextWindow, T as Turn, j as ContentBlock, I as IToolDefinition } from './adapters-CIRkrCHl.js';
+export { k as CompletionChunk, l as CompletionRequest, m as CompletionResponse, b as IContextStrategy, c as IScratchpadAdapter, n as IStorageAdapter, N as NormalizedMessage, o as STMItem, p as STMRegistryConfig, S as ShortTermMemoryRegistry, q as TokenUsage, r as ToolCall, s as ToolContext, t as ToolResult } from './adapters-CIRkrCHl.js';
+import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, M as MCPServerConfig, a as MCPToolDefinition } from './agent-Cq_oRvoc.js';
+export { b as GoalInjector, c as GoalVerifierResult, d as MCPJsonRpcRequest, e as MCPJsonRpcResponse, f as MCPTransportType, g as MediaConfig, h as ToolDecision, i as ToolExecutionBudget, j as ToolFirewallConfig, k as ToolFirewallRule, l as TraceEvent } from './agent-Cq_oRvoc.js';
 export { LemuraAdapterError, LemuraContextOverflowError, LemuraError, LemuraMCPConnectionError, LemuraMCPError, LemuraMCPTimeoutError, LemuraMaxIterationsError, LemuraSkillInjectionError, LemuraToolNotFoundError, LemuraToolTimeoutError, LemuraToolValidationError } from './types/index.js';
 import { I as ILogger } from './logger-DxvKliuk.js';
 export { L as LogLevel, a as LogMetadata, S as Severity } from './logger-DxvKliuk.js';
@@ -226,6 +226,8 @@ declare class SessionManager {
     private toolResponseProcessor;
     private goalInjector;
     private continuationPlanner;
+    /** Frozen goal/plan injection text keyed by turn index — used when staticSystemPrompt is on */
+    private _turnInjections;
     private mcpRegistry;
     /** Resolves when all MCP servers are connected; awaited by run() and stream() */
     private mcpReady;

package/dist/index.js

@@ -234,13 +234,27 @@ var OpenAICompatibleAdapter = class {
       return msg;
     });
   }
+  /**
+   * Returns true for reasoning/o-series models (o1, o3, o4, gpt-5, *-mini variants).
+   * These models use `max_completion_tokens` instead of `max_tokens` and do not
+   * support sampling hyperparameters (temperature, top_p, presence_penalty, frequency_penalty).
+   */
+  isReasoningModel(model) {
+    return /\bo[1-9]\b|\bo[1-9]-|\bgpt-5\b|(?:^|[-_])mini(?:$|[-_])/i.test(model);
+  }
   buildPayload(request) {
+    const model = request.model || this.defaultModel;
+    const reasoning = this.isReasoningModel(model);
     const payload = {
-      model: request.model || this.defaultModel,
+      model,
       messages: this.toOpenAIMessages(request.messages)
     };
-    if (request.maxTokens !== void 0) payload.max_tokens = request.maxTokens;
-    if (request.temperature !== void 0) payload.temperature = request.temperature;
+    if (request.maxTokens !== void 0) {
+      payload[reasoning ? "max_completion_tokens" : "max_tokens"] = request.maxTokens;
+    }
+    if (!reasoning) {
+      if (request.temperature !== void 0) payload.temperature = request.temperature;
+    }
     if (request.stopSequences?.length) payload.stop = request.stopSequences;
     if (request.stream) payload.stream = true;
     if (request.tools && request.tools.length > 0) {
@@ -1039,8 +1053,8 @@ var ToolRegistry = class {
         );
       }
     }
-    const toolTimeoutMs = tool["timeoutMs"];
-    const timeoutMs = typeof toolTimeoutMs === "number" ? toolTimeoutMs : this.defaultTimeoutMs;
+    const timeoutMs = tool.timeoutMs ?? this.defaultTimeoutMs;
+    const startMs = Date.now();
     const executionPromise = tool.execute(params, context);
     const timeoutPromise = new Promise((_, reject) => {
       const id = setTimeout(() => {
@@ -1051,12 +1065,26 @@ var ToolRegistry = class {
       }, timeoutMs);
     });
     try {
-      return await Promise.race([executionPromise, timeoutPromise]);
+      const result = await Promise.race([executionPromise, timeoutPromise]);
+      context.logger.debug(`Tool '${name}' completed in ${Date.now() - startMs}ms`);
+      return result;
     } catch (err) {
-      if (err instanceof LemuraToolValidationError || err instanceof LemuraToolTimeoutError) {
+      const elapsedMs = Date.now() - startMs;
+      if (err instanceof LemuraToolTimeoutError) {
+        context.logger.error(`Tool '${name}' timed out after ${elapsedMs}ms (limit: ${timeoutMs}ms)`, {
+          problem: `Tool '${name}' did not respond within its timeout.`,
+          hints: [
+            `Increase the tool's timeoutMs (currently ${timeoutMs}ms) or optimise its implementation.`,
+            `Check whether the external service the tool depends on is healthy.`
+          ]
+        });
+        throw err;
+      }
+      if (err instanceof LemuraToolValidationError) {
         throw err;
       }
       const message = err instanceof Error ? err.message : String(err);
+      context.logger.error(`Tool '${name}' failed after ${elapsedMs}ms: ${message}`);
       throw new LemuraToolValidationError(
         `Tool '${name}' execution failed: ${message}`
       );
@@ -1287,8 +1315,9 @@ var SkillInjector = class {
       if (!content) continue;
       const tierLabel = skill.tier ?? "standard";
       const skillEntry = `
-[Skill: ${skill.name} (Tier: ${tierLabel})]
+<lemura:skill name="${skill.name}" tier="${tierLabel}">
 ${content}
+</lemura:skill>
 `;
       const skillTokens = Math.ceil(skillEntry.length / 4);
       if (tokenBudget !== void 0 && usedTokens + skillTokens > tokenBudget) {
@@ -1825,7 +1854,7 @@ var GoalInjector = class {
     };
   }
   /**
-   * Returns the formatted `[CURRENT GOAL]` block string — without caring about
+   * Returns the formatted `<lemura:goal>` block string — without caring about
    * where it will be placed. Callers decide whether to append to a system prompt
    * or push as a separate message.
    */
@@ -1833,27 +1862,28 @@ var GoalInjector = class {
     const { statement, successCriteria, decomposition, completedSubGoals = [] } = this.goal;
     const pending = decomposition.filter((sg) => !completedSubGoals.includes(sg));
     const completed = decomposition.filter((sg) => completedSubGoals.includes(sg));
-    let block = `[CURRENT GOAL]
-${statement}
+    let block = `<lemura:goal>
+<lemura:statement>${statement}</lemura:statement>
 `;
     if (successCriteria.length > 0) {
-      block += `
-Success criteria:
-${successCriteria.map((c) => `- ${c}`).join("\n")}`;
+      block += `<lemura:criteria>
+${successCriteria.map((c) => `- ${c}`).join("\n")}
+</lemura:criteria>
+`;
     }
     if (pending.length > 0) {
-      block += `
-
-Sub-goals remaining:
-${pending.map((sg) => `- ${sg} \u2190 pending`).join("\n")}`;
+      block += `<lemura:subgoals status="pending">
+${pending.map((sg) => `- ${sg}`).join("\n")}
+</lemura:subgoals>
+`;
     }
     if (completed.length > 0) {
-      block += `
-
-Sub-goals completed:
-${completed.map((sg) => `- \u2705 ${sg}`).join("\n")}`;
+      block += `<lemura:subgoals status="done">
+${completed.map((sg) => `- \u2705 ${sg}`).join("\n")}
+</lemura:subgoals>
+`;
     }
-    block += "\n[/CURRENT GOAL]";
+    block += "</lemura:goal>";
     return block;
   }
   /**
@@ -1942,14 +1972,17 @@ var ContinuationPlanner = class {
   }
   /** Returns a human-readable status string with icons (injected before each iteration) */
   getPlanStatusString() {
-    let result = `[CONTINUATION PLAN \u2014 Step ${this.plan.currentStepIndex + 1}/${this.plan.steps.length}]
+    const current = this.plan.currentStepIndex + 1;
+    const total = this.plan.steps.length;
+    let result = `<lemura:plan step="${current}" total="${total}">
 `;
     for (const step of this.plan.steps) {
       const icon = this._icon(step.status);
       const statusText = step.status === "pending" && step.dependsOn.length > 0 ? `Waiting on Step ${step.dependsOn.join(", ")}` : step.status.charAt(0).toUpperCase() + step.status.slice(1);
-      result += `${icon} Step ${step.stepId} (${step.toolName}): ${statusText}
+      result += `<lemura:step id="${step.stepId}" tool="${step.toolName}" status="${step.status}">${icon} ${statusText}</lemura:step>
 `;
     }
+    result += "</lemura:plan>";
     return result;
   }
   _icon(status) {
@@ -2161,7 +2194,31 @@ var MCPClient = class {
       method: "tools/call",
       params: { name: toolName, arguments: args }
     };
-    const response = await this._rpc(request);
+    const startMs = Date.now();
+    let response;
+    try {
+      response = await this._rpc(request);
+    } catch (err) {
+      const elapsedMs = Date.now() - startMs;
+      if (err instanceof LemuraMCPTimeoutError) {
+        this.logger.error(
+          `[MCP:${this._serverName}] Tool '${toolName}' timed out after ${elapsedMs}ms (limit: ${this.timeoutMs}ms)`,
+          {
+            problem: `MCP server '${this._serverName}' did not respond to tool '${toolName}' in time.`,
+            hints: [
+              `Increase 'timeoutMs' in the MCPServerConfig for '${this._serverName}' (currently ${this.timeoutMs}ms).`,
+              `Check whether the MCP server process is healthy and not blocked.`
+            ]
+          }
+        );
+      } else {
+        this.logger.error(
+          `[MCP:${this._serverName}] Tool '${toolName}' RPC failed after ${elapsedMs}ms: ${err.message}`
+        );
+      }
+      throw err;
+    }
+    this.logger.debug(`[MCP:${this._serverName}] Tool '${toolName}' completed in ${Date.now() - startMs}ms`);
     this._assertNoError(response, `tool '${toolName}'`);
     const result = response.result;
     if (result && Array.isArray(result["content"])) {
@@ -2579,6 +2636,8 @@ var SessionManager = class {
   toolResponseProcessor;
   goalInjector = null;
   continuationPlanner = null;
+  /** Frozen goal/plan injection text keyed by turn index — used when staticSystemPrompt is on */
+  _turnInjections = /* @__PURE__ */ new Map();
   // MCP
   mcpRegistry = null;
   /** Resolves when all MCP servers are connected; awaited by run() and stream() */
@@ -2947,8 +3006,12 @@ Respond ONLY with valid JSON (no markdown, no explanations):
         messages: [{ role: "user", content: planningPrompt }],
         maxTokens: this.config.maxCompletionTokens ?? 4e3
       });
-      const raw = response.content.replace(/```json|```/g, "").trim();
-      const parsed = JSON.parse(raw);
+      const stripped = response.content.replace(/```json|```/g, "").trim();
+      const jsonMatch = stripped.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        throw new Error(`No JSON object found in mini-planning response: "${stripped.slice(0, 200)}"`);
+      }
+      const parsed = JSON.parse(jsonMatch[0]);
       if (this.goalInjector && Array.isArray(parsed.subGoals)) {
         this.goalInjector.updateDecomposition(
           parsed.subGoals,
@@ -2971,7 +3034,8 @@ Respond ONLY with valid JSON (no markdown, no explanations):
   /** Builds the system prompt, injecting skills and goal if configured. */
   buildSystemPrompt(userMessage, iteration = 0) {
     let prompt = this.context.systemPrompt || "";
-    if (this.goalInjector && this.config.goalInjectionPosition !== "pre_turn") {
+    const isStatic = this.config.staticSystemPrompt === true;
+    if (!isStatic && this.goalInjector && this.config.goalInjectionPosition !== "pre_turn") {
       const shouldInject = this.goalInjector.shouldInjectThisTurn(
         iteration,
         false,
@@ -2985,7 +3049,7 @@ Respond ONLY with valid JSON (no markdown, no explanations):
         });
       }
     }
-    if (this.continuationPlanner && this.config.enableContinuationPlanning) {
+    if (!isStatic && this.continuationPlanner && this.config.enableContinuationPlanning) {
       const planStatus = this.continuationPlanner.getPlanStatusString();
       prompt += `
 
@@ -3011,7 +3075,7 @@ ${planStatus}`;
     if (systemPrompt) {
       messages.unshift({ role: "system", content: systemPrompt });
     }
-    if (this.goalInjector && this.config.goalInjectionPosition === "pre_turn") {
+    if (!this.config.staticSystemPrompt && this.goalInjector && this.config.goalInjectionPosition === "pre_turn") {
       const shouldInject = this.goalInjector.shouldInjectThisTurn(
         iteration,
         false,
@@ -3023,6 +3087,52 @@ ${planStatus}`;
         this.emitTrace("planning", "goal_injected", { position: "pre_turn", iteration });
       }
     }
+    if (this.config.staticSystemPrompt) {
+      const totalTurns = this.context.turns.length;
+      for (let i = 0; i < totalTurns; i++) {
+        const msgIndex = i + 1;
+        if (msgIndex >= messages.length) continue;
+        const msg = messages[msgIndex];
+        if (msg.role !== "user" && msg.role !== "tool") continue;
+        let injectionBlock;
+        if (i === totalTurns - 1) {
+          const blocks = [];
+          if (this.goalInjector) {
+            const shouldInject = this.goalInjector.shouldInjectThisTurn(
+              iteration,
+              false,
+              this.config.goalInjectionN ?? 3
+            );
+            if (shouldInject) blocks.push(this.goalInjector.getFormattedBlock());
+          }
+          if (this.continuationPlanner && this.config.enableContinuationPlanning) {
+            blocks.push(this.continuationPlanner.getPlanStatusString());
+          }
+          injectionBlock = blocks.length > 0 ? `
+
+<lemura:agent-state>
+${blocks.join("\n\n")}
+</lemura:agent-state>` : "";
+          this._turnInjections.set(i, injectionBlock);
+          if (injectionBlock) {
+            this.emitTrace("planning", "goal_injected", { position: "frozen_turn", turnIndex: i, iteration });
+          }
+        } else {
+          injectionBlock = this._turnInjections.get(i) ?? "";
+        }
+        if (!injectionBlock) continue;
+        if (Array.isArray(msg.content)) {
+          messages[msgIndex] = {
+            ...msg,
+            content: msg.content.map(
+              (item) => item.type === "text" ? { ...item, text: item.text + injectionBlock } : item
+            )
+          };
+        } else {
+          messages[msgIndex] = { ...msg, content: (msg.content ?? "") + injectionBlock };
+        }
+      }
+    }
     return messages;
   }
   /** Checks the tool execution budget and throws descriptively if exceeded. */
@@ -3477,6 +3587,10 @@ ${planStatus}`;
         const verdict = await this._verifyGoal(this.context.turns);
         if (verdict && !verdict.achieved && verdict.missing) {
           this.logger.info(`[GoalVerifier] Incomplete \u2014 running silent correction: "${verdict.missing}"`);
+          this.emitTrace("verification", "goal_correction_start", {
+            missing: verdict.missing,
+            reason: verdict.reason
+          });
           try {
             const corrMsgs = this.buildMessages(this.buildSystemPrompt(verdict.missing, this.iterations), this.iterations);
             corrMsgs.push({ role: "user", content: verdict.missing });
@@ -3493,9 +3607,37 @@ ${planStatus}`;
                 turnIndex: this.context.turns.length,
                 compressed: false
               });
+              this.emitTrace("verification", "goal_correction_done", {
+                missing: verdict.missing,
+                correctionTokens: correction.usage?.completionTokens
+              });
             }
           } catch (err) {
-            this.logger.warn(`[GoalVerifier] Correction failed (non-fatal): ${err.message}`);
+            const errMsg = err.message;
+            this.logger.warn(`[GoalVerifier] Correction failed (non-fatal): ${errMsg}`);
+            this.emitTrace("error", "goal_correction_failed", { error: errMsg }, null, null, "error");
+          }
+          const finalVerdict = await this._verifyGoal(this.context.turns);
+          if (finalVerdict && !finalVerdict.achieved) {
+            this.logger.warn(`[GoalVerifier] Final verification failed: ${finalVerdict.reason}`);
+            this.emitTrace("verification", "goal_verification_result", {
+              achieved: false,
+              reason: finalVerdict.reason,
+              missing: finalVerdict.missing
+            }, null, null, "error");
+            const warningBlock = `
+
+---
+
+\u26A0\uFE0F **Goal Verification Warning**
+* **Status:** Success criteria not fully met.
+* **Reason:** ${finalVerdict.reason ?? "Unknown"}
+* **Missing:** ${finalVerdict.missing ?? "Not specified"}
+
+`;
+            yield warningBlock;
+            const lastTurn = [...this.context.turns].reverse().find((t) => t.role === "assistant");
+            if (lastTurn) lastTurn.content = lastTurn.content + warningBlock;
           }
         }
       }
@@ -3624,6 +3766,12 @@ ${planStatus}`;
                   const msg = e instanceof Error ? e.message : String(e);
                   const isTimeout = e instanceof LemuraToolTimeoutError;
                   this.logger.error(`Tool ${tc.name} ${isTimeout ? "timed out" : "failed"}: ${msg}`);
+                  this.emitTrace("error", isTimeout ? "tool_timeout" : "tool_error", {
+                    toolName: tc.name,
+                    id: tc.id,
+                    error: msg,
+                    timeoutMs: isTimeout ? this.config.toolRegistryTimeoutMs ?? 3e4 : void 0
+                  }, null, null, "error");
                   return { toolCallId: tc.id, content: `Error: ${msg}` };
                 }
               })
@@ -3644,6 +3792,12 @@ ${planStatus}`;
                 problem: `Tool ${tc.name} ${isTimeout ? "timed out" : "failed to execute"}.`,
                 hints: isTimeout ? ["Increase toolRegistryTimeoutMs or optimise the tool implementation."] : ["Check the tool parameters and ensure required services are running."]
               });
+              this.emitTrace("error", isTimeout ? "tool_timeout" : "tool_error", {
+                toolName: tc.name,
+                id: tc.id,
+                error: msg,
+                timeoutMs: isTimeout ? this.config.toolRegistryTimeoutMs ?? 3e4 : void 0
+              }, null, null, "error");
               toolResults.push({ toolCallId: tc.id, content: `Error: ${msg}` });
             }
           }
@@ -3688,6 +3842,10 @@ ${planStatus}`;
           const verdict = await this._verifyGoal(this.context.turns);
           if (verdict && !verdict.achieved && verdict.missing) {
             this.logger.info(`[GoalVerifier] Incomplete \u2014 running silent correction: "${verdict.missing}"`);
+            this.emitTrace("verification", "goal_correction_start", {
+              missing: verdict.missing,
+              reason: verdict.reason
+            });
             try {
               const correctionMessages = this.buildMessages(
                 this.buildSystemPrompt(verdict.missing, this.iterations),
@@ -3707,11 +3865,40 @@ ${planStatus}`;
                   turnIndex: this.context.turns.length,
                   compressed: false
                 });
+                this.emitTrace("verification", "goal_correction_done", {
+                  missing: verdict.missing,
+                  correctionTokens: correction.usage?.completionTokens
+                });
               }
             } catch (err) {
-              this.logger.warn(`[GoalVerifier] Correction failed (non-fatal): ${err.message}`);
+              const errMsg = err.message;
+              this.logger.warn(`[GoalVerifier] Correction failed (non-fatal): ${errMsg}`);
+              this.emitTrace("error", "goal_correction_failed", { error: errMsg }, null, null, "error");
             }
           }
+          const finalVerdict = await this._verifyGoal(this.context.turns);
+          if (finalVerdict && !finalVerdict.achieved) {
+            this.logger.warn(`[GoalVerifier] Final verification failed: ${finalVerdict.reason}`);
+            this.emitTrace("verification", "goal_verification_result", {
+              achieved: false,
+              reason: finalVerdict.reason,
+              missing: finalVerdict.missing
+            }, null, null, "error");
+            const warningBlock = `
+
+---
+
+\u26A0\uFE0F **Goal Verification Warning**
+* **Status:** Success criteria not fully met.
+* **Reason:** ${finalVerdict.reason ?? "Unknown"}
+* **Missing:** ${finalVerdict.missing ?? "Not specified"}
+
+`;
+            const lastTurn = [...this.context.turns].reverse().find((t) => t.role === "assistant");
+            if (lastTurn) lastTurn.content = lastTurn.content + warningBlock;
+            this.logger.info(`[${opts.label}] Run completed with goal warning`);
+            return lastTurn?.content ?? response.content;
+          }
         }
         this.logger.info(`[${opts.label}] Run completed successfully`);
         return response.content;