lemura 1.4.4 → 1.5.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { a as IProviderAdapter, T as TranscriptionRequest, d as TranscriptionResponse, e as SynthesisRequest, A as AudioChunk, V as VisionRequest, f as VisionResponse, g as ImageGenRequest, h as ImageGenResponse, M as ModelInfo, C as ContextWindow, i as Turn, j as ContentBlock, I as IToolDefinition } from './adapters-CVcfWf85.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-CVcfWf85.js';
-import { S as SessionConfig, I as IToolResponseProcessor, T as ToolResponseEvaluation, M as MCPServerConfig, a as MCPToolDefinition } from './agent-BH_uE2nT.js';
-export { b as MCPJsonRpcRequest, c as MCPJsonRpcResponse, d as MCPTransportType, e as MediaConfig, f as ToolDecision, g as ToolExecutionBudget, h as ToolFirewallConfig, i as ToolFirewallRule, j as TraceEvent } from './agent-BH_uE2nT.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-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';
 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';
@@ -188,67 +188,6 @@ declare class ContinuationPlanner {
     private _advanceIndex;
 }
 
-interface Goal {
-    id: string;
-    statement: string;
-    /** High-level sub-goals decomposed from the main statement */
-    decomposition: string[];
-    successCriteria: string[];
-    injectionFrequency: 'always' | 'every_N_turns' | 'on_compression';
-    injectionPosition: 'system_prompt' | 'pre_turn';
-    /** Sub-goals already completed — updated via `markSubGoalDone()` */
-    completedSubGoals?: string[];
-}
-/**
- * GoalInjector keeps the original task objective visible throughout the ReAct loop,
- * preventing goal drift after many tool calls and context compressions.
- *
- * Usage in SessionManager:
- * - For `system_prompt` position: call `injectInto(prompt)` which appends the goal block.
- * - For `pre_turn` position: call `getFormattedBlock()` and push as a system message.
- */
-declare class GoalInjector {
-    private goal;
-    private turnsSinceInjection;
-    constructor(goal: Goal);
-    /**
-     * Returns the formatted `[CURRENT 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.
-     */
-    getFormattedBlock(): string;
-    /**
-     * Appends the goal block to the given prompt string (for `system_prompt` position).
-     * For `pre_turn` position, use `getFormattedBlock()` directly.
-     *
-     * @param prompt - The existing system prompt to append to.
-     */
-    injectInto(prompt: string): string;
-    /**
-     * Returns true when the goal should be re-injected this turn,
-     * based on `injectionFrequency`.
-     *
-     * @param turnIndex - The current turn index in the ReAct loop (0-based)
-     * @param compressionOccurred - Whether context was compressed this iteration
-     * @param injectionN - The N for 'every_N_turns' frequency (default: 3)
-     */
-    shouldInjectThisTurn(turnIndex: number, compressionOccurred?: boolean, injectionN?: number): boolean;
-    /**
-     * Updates the goal with new sub-goal decomposition and success criteria,
-     * typically populated by the mini-planning LLM call.
-     */
-    updateDecomposition(decomposition: string[], successCriteria?: string[]): void;
-    /**
-     * Marks a sub-goal as completed so it moves to the "completed" section
-     * in subsequent injections.
-     */
-    markSubGoalDone(subGoal: string): void;
-    /** Returns a snapshot of the current goal state (safe to store in context.metadata). */
-    getGoal(): Goal;
-    /** Increments the internal turn counter (used for `every_N_turns` frequency). */
-    incrementTurn(): void;
-}
-
 /**
  * Core entry point for lemura agent sessions.
  *
@@ -449,9 +388,6 @@ declare class SessionManager {
     /**
      * Runs the full ReAct loop for a user message and returns the final assistant response.
      *
-     * When `enableGoalPlanning` is true and no goal has been manually set, a mini-planning
-     * LLM call is made before the first iteration to decompose the task into sub-goals.
-     *
      * @param userMessage - The user's message (string or multimodal content blocks)
      * @returns The assistant's final response string
      * @throws {LemuraMaxIterationsError} When the loop exceeds `maxIterations`
@@ -460,8 +396,8 @@ declare class SessionManager {
     /**
      * Runs the ReAct loop and streams the final assistant response token-by-token.
      *
-     * Tool calls within the loop are still executed synchronously (they must complete
-     * before streaming the conclusion). Only the final LLM text output is streamed.
+     * All tool calls, goal verification, and corrections complete before any token
+     * is yielded — the stream delivers only the clean final response.
      *
      * @param userMessage - The user's message (string or multimodal content blocks)
      * @returns An `AsyncIterable<string>` of delta tokens from the final response
@@ -474,6 +410,29 @@ declare class SessionManager {
      * ```
      */
     stream(userMessage: string | ContentBlock[]): AsyncIterable<string>;
+    /**
+     * Core ReAct execution loop shared by `run()` and `stream()`.
+     *
+     * Uses `adapter.complete()` exclusively — no streaming occurs here.
+     * Goal verification and silent corrections run inside this method,
+     * fully isolated from the caller's delivery path.
+     *
+     * @returns The final assistant response string
+     * @throws {LemuraMaxIterationsError} When the loop exceeds `maxIterations`
+     */
+    private _executeLoop;
+    /**
+     * Verifies whether the goal was achieved after a `stop` finish.
+     *
+     * Priority:
+     * 1. `config.goalVerifier` callback (Option A — user-supplied)
+     * 2. Built-in LLM check against `successCriteria` (Option C — fallback)
+     *
+     * Returns `null` when verification is skipped (no goal, planning disabled, etc.).
+     *
+     * @since 1.5.0
+     */
+    private _verifyGoal;
     /**
      * Resets the session: clears conversation history, resets iteration counters,
      * tool execution budget tallies, and goal/plan state.
@@ -687,4 +646,4 @@ declare class MCPClientRegistry {
     private _bridge;
 }
 
-export { AudioChunk, ContentBlock, ContextWindow, type ContinuationPlan, ContinuationPlanner, type ContinuationStep, FinalResponseFormatter, type Goal, GoalInjector, ILogger, IProviderAdapter, IToolDefinition, IToolResponseProcessor, ImageGenRequest, ImageGenResponse, MCPClient, MCPClientRegistry, MCPServerConfig, MCPToolDefinition, MediaBridge, ModelInfo, SessionConfig, SessionManager, SkillInjector, type StepCondition, StepCounter, type StepVerifier, type StepVerifierResult, SynthesisRequest, ToolRegistry, ToolResponseEvaluation, ToolResponseProcessor, type ToolResponseProcessorConfig, TranscriptionRequest, TranscriptionResponse, Turn, VisionRequest, VisionResponse };
+export { AudioChunk, ContentBlock, ContextWindow, type ContinuationPlan, ContinuationPlanner, type ContinuationStep, FinalResponseFormatter, Goal, ILogger, IProviderAdapter, IToolDefinition, IToolResponseProcessor, ImageGenRequest, ImageGenResponse, MCPClient, MCPClientRegistry, MCPServerConfig, MCPToolDefinition, MediaBridge, ModelInfo, SessionConfig, SessionManager, SkillInjector, type StepCondition, StepCounter, type StepVerifier, type StepVerifierResult, SynthesisRequest, ToolRegistry, ToolResponseEvaluation, ToolResponseProcessor, type ToolResponseProcessorConfig, TranscriptionRequest, TranscriptionResponse, Turn, VisionRequest, VisionResponse };

package/dist/index.js

@@ -3320,9 +3320,6 @@ ${planStatus}`;
   /**
    * Runs the full ReAct loop for a user message and returns the final assistant response.
    *
-   * When `enableGoalPlanning` is true and no goal has been manually set, a mini-planning
-   * LLM call is made before the first iteration to decompose the task into sub-goals.
-   *
    * @param userMessage - The user's message (string or multimodal content blocks)
    * @returns The assistant's final response string
    * @throws {LemuraMaxIterationsError} When the loop exceeds `maxIterations`
@@ -3330,6 +3327,194 @@ ${planStatus}`;
   async run(userMessage) {
     if (this.mcpReady) await this.mcpReady;
     await this.ensureScratchpadLoaded();
+    return this._executeLoop(userMessage, { label: "run" });
+  }
+  /**
+   * Runs the ReAct loop and streams the final assistant response token-by-token.
+   *
+   * All tool calls, goal verification, and corrections complete before any token
+   * is yielded — the stream delivers only the clean final response.
+   *
+   * @param userMessage - The user's message (string or multimodal content blocks)
+   * @returns An `AsyncIterable<string>` of delta tokens from the final response
+   *
+   * @example
+   * ```typescript
+   * for await (const token of session.stream('Tell me a story')) {
+   *   process.stdout.write(token);
+   * }
+   * ```
+   */
+  async *stream(userMessage) {
+    if (this.mcpReady) await this.mcpReady;
+    await this.ensureScratchpadLoaded();
+    const userMessageStr = Array.isArray(userMessage) ? "[Multimodal Content]" : userMessage;
+    this.logger.info(`Starting streaming session run`, { model: this.config.model, message: userMessageStr });
+    if (this.config.enableGoalPlanning && !this.goalInjector) {
+      this.goalInjector = new GoalInjector({
+        id: "auto",
+        statement: typeof userMessage === "string" ? userMessage : "[multimodal]",
+        decomposition: [],
+        successCriteria: ["The user request is fully answered"],
+        injectionFrequency: this.config.goalInjectionFrequency ?? "always",
+        injectionPosition: this.config.goalInjectionPosition ?? "system_prompt"
+      });
+      this.context.metadata["goal"] = this.goalInjector.getGoal();
+      await this._runMiniPlanningStep(userMessageStr);
+    }
+    this.context.turns.push({
+      role: "user",
+      content: userMessage,
+      tokenCount: Array.isArray(userMessage) ? userMessage.length * 50 : this.adapter.estimateTokens(userMessage),
+      turnIndex: this.context.turns.length,
+      compressed: false
+    });
+    const maxIts = this.config.maxIterations || 10;
+    this.iterations = 0;
+    this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
+    const maxCompletionTokens = this.config.maxCompletionTokens ?? 4e3;
+    while (this.iterations < maxIts) {
+      this.iterations++;
+      this.logger.debug(`[stream] ReAct Iteration ${this.iterations}/${maxIts}`);
+      this.context.tokenCount = this.context.turns.reduce((sum, t) => sum + t.tokenCount, 0) + this.adapter.estimateTokens(this.context.systemPrompt || "");
+      this.context = await this.contextManager.prepare(this.context);
+      const systemPrompt = this.buildSystemPrompt(userMessageStr, this.iterations);
+      const messages = this.buildMessages(systemPrompt, this.iterations);
+      if (this.stepCounter.isMaxReached()) {
+        messages.push({
+          role: "system",
+          content: this.stepCounter.getForcedConclusionPrompt() + "\n\n" + FinalResponseFormatter.getRequiredStructure()
+        });
+      }
+      let response;
+      try {
+        response = await this.adapter.complete({
+          model: this.config.model,
+          messages,
+          tools: this.stepCounter.isMaxReached() ? [] : this.toolRegistry.getAll(),
+          maxTokens: maxCompletionTokens
+        });
+      } catch (err) {
+        this.logger.fatal(`Provider call failed: ${err.message}`);
+        throw err;
+      }
+      if (response.finishReason === "tool_call" && response.toolCalls) {
+        this.logger.info(`[stream] Tool calls: ${response.toolCalls.map((tc) => tc.name).join(", ")}`);
+        this.stepCounter.increment(response.toolCalls.length);
+        const toolResults = [];
+        for (const tc of response.toolCalls) {
+          const ok = await this.passesFirewall(tc.name, tc.arguments, tc.id, toolResults);
+          if (!ok) continue;
+          try {
+            toolResults.push({ toolCallId: tc.id, content: await this.executeSingleToolCall(tc) });
+          } catch (e) {
+            toolResults.push({ toolCallId: tc.id, content: `Error: ${e instanceof Error ? e.message : String(e)}` });
+          }
+        }
+        const assistantTurn = {
+          role: "assistant",
+          content: response.content || "",
+          tokenCount: this.adapter.estimateTokens(response.content || "") + 50,
+          turnIndex: this.context.turns.length,
+          compressed: false,
+          toolCalls: response.toolCalls
+        };
+        this.context.turns.push(assistantTurn);
+        if (this.config.onTurn) this.config.onTurn(assistantTurn);
+        for (const res of toolResults) {
+          const toolTurn = {
+            role: "tool",
+            content: res.content,
+            tokenCount: this.adapter.estimateTokens(res.content),
+            turnIndex: this.context.turns.length,
+            compressed: false,
+            toolResults: [res]
+          };
+          this.context.turns.push(toolTurn);
+          if (this.config.onTurn) this.config.onTurn(toolTurn);
+        }
+        if (this.goalInjector) this.goalInjector.incrementTurn();
+        continue;
+      }
+      this.context.tokenCount = this.context.turns.reduce((sum, t) => sum + t.tokenCount, 0) + this.adapter.estimateTokens(this.context.systemPrompt || "");
+      this.context = await this.contextManager.prepare(this.context);
+      const finalSystemPrompt = this.buildSystemPrompt(userMessageStr, this.iterations);
+      const finalMessages = this.buildMessages(finalSystemPrompt, this.iterations);
+      let accumulated = "";
+      let finalTokenCount = 0;
+      let finalFinishReason;
+      for await (const chunk of this.adapter.stream({
+        model: this.config.model,
+        messages: finalMessages,
+        maxTokens: maxCompletionTokens,
+        stream: true
+      })) {
+        if (chunk.delta) {
+          accumulated += chunk.delta;
+          finalTokenCount += Math.ceil(chunk.delta.length / 4);
+          yield chunk.delta;
+        }
+        if (chunk.finished) {
+          finalFinishReason = chunk.finishReason;
+          if (chunk.usage) this.totalTokens += chunk.usage.totalTokens;
+          this.emitTrace("thinking", "llm_stream_finished", {
+            usage: chunk.usage,
+            totalTokens: this.totalTokens,
+            finishReason: chunk.finishReason
+          });
+        }
+      }
+      const finalTurn = {
+        role: "assistant",
+        content: accumulated,
+        tokenCount: finalTokenCount,
+        turnIndex: this.context.turns.length,
+        compressed: false
+      };
+      this.context.turns.push(finalTurn);
+      if (this.config.onTurn) this.config.onTurn(finalTurn);
+      if (finalFinishReason === "stop") {
+        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}"`);
+          try {
+            const corrMsgs = this.buildMessages(this.buildSystemPrompt(verdict.missing, this.iterations), this.iterations);
+            corrMsgs.push({ role: "user", content: verdict.missing });
+            const correction = await this.adapter.complete({
+              model: this.config.model,
+              messages: corrMsgs,
+              maxTokens: maxCompletionTokens
+            });
+            if (correction.content) {
+              this.context.turns.push({
+                role: "assistant",
+                content: correction.content,
+                tokenCount: correction.usage?.completionTokens ?? this.adapter.estimateTokens(correction.content),
+                turnIndex: this.context.turns.length,
+                compressed: false
+              });
+            }
+          } catch (err) {
+            this.logger.warn(`[GoalVerifier] Correction failed (non-fatal): ${err.message}`);
+          }
+        }
+      }
+      this.logger.info(`[stream] Streaming run completed`);
+      return;
+    }
+    throw new LemuraMaxIterationsError(`Exceeded max iterations of ${maxIts}`);
+  }
+  /**
+   * Core ReAct execution loop shared by `run()` and `stream()`.
+   *
+   * Uses `adapter.complete()` exclusively — no streaming occurs here.
+   * Goal verification and silent corrections run inside this method,
+   * fully isolated from the caller's delivery path.
+   *
+   * @returns The final assistant response string
+   * @throws {LemuraMaxIterationsError} When the loop exceeds `maxIterations`
+   */
+  async _executeLoop(userMessage, opts) {
     const userMessageStr = Array.isArray(userMessage) ? "[Multimodal Content]" : userMessage;
     this.logger.info(`Starting new session run`, {
       model: this.config.model,
@@ -3363,13 +3548,14 @@ ${planStatus}`;
     this.iterations = 0;
     this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
     const maxCompletionTokens = this.config.maxCompletionTokens ?? 4e3;
+    let goalVerificationDone = false;
     while (this.iterations < maxIts) {
       this.iterations++;
-      this.logger.debug(`ReAct Iteration ${this.iterations}/${maxIts}`);
+      this.logger.debug(`[${opts.label}] ReAct Iteration ${this.iterations}/${maxIts}`);
       this.context.tokenCount = this.context.turns.reduce((sum, t) => sum + t.tokenCount, 0) + this.adapter.estimateTokens(this.context.systemPrompt || "");
       this.context = await this.contextManager.prepare(this.context);
       const systemPrompt = this.buildSystemPrompt(userMessageStr, this.iterations);
-      let messages = this.buildMessages(systemPrompt, this.iterations);
+      const messages = this.buildMessages(systemPrompt, this.iterations);
       if (this.stepCounter.isMaxReached()) {
         this.logger.warn(`maxSteps (${this.config.maxSteps ?? 20}) reached \u2014 forcing final response`);
         messages.push({
@@ -3402,9 +3588,7 @@ ${planStatus}`;
         this.emitTrace("error", "llm_call_failed", { error: e.message ?? String(err) });
         throw err;
       }
-      if (response.usage) {
-        this.totalTokens += response.usage.totalTokens;
-      }
+      if (response.usage) this.totalTokens += response.usage.totalTokens;
       this.emitTrace("thinking", "llm_call", {
         model: this.config.model,
         usage: response.usage,
@@ -3499,7 +3683,37 @@ ${planStatus}`;
         };
         this.context.turns.push(finalTurn);
         if (this.config.onTurn) this.config.onTurn(finalTurn);
-        this.logger.info(`Run completed successfully`);
+        if (response.finishReason === "stop" && !goalVerificationDone) {
+          goalVerificationDone = true;
+          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}"`);
+            try {
+              const correctionMessages = this.buildMessages(
+                this.buildSystemPrompt(verdict.missing, this.iterations),
+                this.iterations
+              );
+              correctionMessages.push({ role: "user", content: verdict.missing });
+              const correction = await this.adapter.complete({
+                model: this.config.model,
+                messages: correctionMessages,
+                maxTokens: maxCompletionTokens
+              });
+              if (correction.content) {
+                this.context.turns.push({
+                  role: "assistant",
+                  content: correction.content,
+                  tokenCount: correction.usage?.completionTokens ?? this.adapter.estimateTokens(correction.content),
+                  turnIndex: this.context.turns.length,
+                  compressed: false
+                });
+              }
+            } catch (err) {
+              this.logger.warn(`[GoalVerifier] Correction failed (non-fatal): ${err.message}`);
+            }
+          }
+        }
+        this.logger.info(`[${opts.label}] Run completed successfully`);
         return response.content;
       }
     }
@@ -3514,165 +3728,93 @@ ${planStatus}`;
     throw maxItsErr;
   }
   /**
-   * Runs the ReAct loop and streams the final assistant response token-by-token.
+   * Verifies whether the goal was achieved after a `stop` finish.
    *
-   * Tool calls within the loop are still executed synchronously (they must complete
-   * before streaming the conclusion). Only the final LLM text output is streamed.
+   * Priority:
+   * 1. `config.goalVerifier` callback (Option A — user-supplied)
+   * 2. Built-in LLM check against `successCriteria` (Option C — fallback)
    *
-   * @param userMessage - The user's message (string or multimodal content blocks)
-   * @returns An `AsyncIterable<string>` of delta tokens from the final response
+   * Returns `null` when verification is skipped (no goal, planning disabled, etc.).
    *
-   * @example
-   * ```typescript
-   * for await (const token of session.stream('Tell me a story')) {
-   *   process.stdout.write(token);
-   * }
-   * ```
+   * @since 1.5.0
    */
-  async *stream(userMessage) {
-    if (this.mcpReady) await this.mcpReady;
-    await this.ensureScratchpadLoaded();
-    const userMessageStr = Array.isArray(userMessage) ? "[Multimodal Content]" : userMessage;
-    this.logger.info(`Starting streaming session run`, {
-      model: this.config.model,
-      message: userMessageStr
-    });
-    if (this.config.enableGoalPlanning && !this.goalInjector) {
-      this.goalInjector = new GoalInjector({
-        id: "auto",
-        statement: typeof userMessage === "string" ? userMessage : "[multimodal]",
-        decomposition: [],
-        successCriteria: ["The user request is fully answered"],
-        injectionFrequency: this.config.goalInjectionFrequency ?? "always",
-        injectionPosition: this.config.goalInjectionPosition ?? "system_prompt"
-      });
-      this.context.metadata["goal"] = this.goalInjector.getGoal();
-      await this._runMiniPlanningStep(userMessageStr);
-    }
-    this.context.turns.push({
-      role: "user",
-      content: userMessage,
-      tokenCount: Array.isArray(userMessage) ? userMessage.length * 50 : this.adapter.estimateTokens(userMessage),
-      turnIndex: this.context.turns.length,
-      compressed: false
-    });
-    const maxIts = this.config.maxIterations || 10;
-    this.iterations = 0;
-    this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
-    const maxCompletionTokens = this.config.maxCompletionTokens ?? 4e3;
-    while (this.iterations < maxIts) {
-      this.iterations++;
-      this.logger.debug(`[stream] ReAct Iteration ${this.iterations}/${maxIts}`);
-      this.context.tokenCount = this.context.turns.reduce((sum, t) => sum + t.tokenCount, 0) + this.adapter.estimateTokens(this.context.systemPrompt || "");
-      this.context = await this.contextManager.prepare(this.context);
-      const systemPrompt = this.buildSystemPrompt(userMessageStr, this.iterations);
-      const messages = this.buildMessages(systemPrompt, this.iterations);
-      if (this.stepCounter.isMaxReached()) {
-        messages.push({
-          role: "system",
-          content: this.stepCounter.getForcedConclusionPrompt() + "\n\n" + FinalResponseFormatter.getRequiredStructure()
+  async _verifyGoal(turns) {
+    if (!this.config.enableGoalPlanning || !this.goalInjector) return null;
+    if (this.config.enableGoalVerification === false) return null;
+    const goal = this.goalInjector.getGoal();
+    if (!goal.statement) return null;
+    this.emitTrace("verification", "goal_verification_start", { goalStatement: goal.statement });
+    try {
+      if (this.config.goalVerifier) {
+        const result = await this.config.goalVerifier(goal, turns);
+        this.emitTrace("verification", "goal_verification_result", {
+          achieved: result.achieved,
+          reason: result.reason,
+          missing: result.missing,
+          source: "custom"
         });
-      }
-      let response;
-      try {
-        response = await this.adapter.complete({
+        return result;
+      }
+      const GENERIC_CRITERION = "The user request is fully answered";
+      const meaningfulCriteria = goal.successCriteria?.filter((c) => c !== GENERIC_CRITERION) ?? [];
+      if (meaningfulCriteria.length > 0) {
+        const recentTurns = turns.slice(-6).map((t) => {
+          const text = typeof t.content === "string" ? t.content : JSON.stringify(t.content);
+          return `[${t.role}]: ${text.slice(0, 400)}`;
+        }).join("\n\n");
+        const criteriaList = meaningfulCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n");
+        const response = await this.adapter.complete({
           model: this.config.model,
-          messages,
-          tools: this.stepCounter.isMaxReached() ? [] : this.toolRegistry.getAll(),
-          maxTokens: maxCompletionTokens
+          temperature: 0,
+          maxTokens: 256,
+          messages: [
+            {
+              role: "system",
+              content: 'You are a strict goal-completion verifier. Respond ONLY with a valid JSON object \u2014 no markdown, no prose:\n{"achieved": true|false, "reason": "<short explanation>", "missing": "<what is still needed, or empty string>"}'
+            },
+            {
+              role: "user",
+              content: `Goal: ${goal.statement}
+
+Success criteria:
+${criteriaList}
+
+Recent conversation:
+${recentTurns}
+
+Were ALL success criteria met?`
+            }
+          ]
         });
-      } catch (err) {
-        this.logger.fatal(`Provider call failed: ${err.message}`);
-        throw err;
-      }
-      if (response.finishReason === "tool_call" && response.toolCalls) {
-        this.logger.info(`[stream] Tool calls: ${response.toolCalls.map((tc) => tc.name).join(", ")}`);
-        this.stepCounter.increment(response.toolCalls.length);
-        const toolResults = [];
-        for (const tc of response.toolCalls) {
-          const ok = await this.passesFirewall(tc.name, tc.arguments, tc.id, toolResults);
-          if (!ok) continue;
-          try {
-            const content = await this.executeSingleToolCall(tc);
-            toolResults.push({ toolCallId: tc.id, content });
-          } catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            toolResults.push({ toolCallId: tc.id, content: `Error: ${msg}` });
+        let verdict = null;
+        try {
+          const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+          if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            verdict = {
+              achieved: parsed.achieved === true,
+              ...typeof parsed.reason === "string" && { reason: parsed.reason },
+              ...typeof parsed.missing === "string" && { missing: parsed.missing }
+            };
           }
+        } catch {
+          this.logger.warn("[GoalVerifier] Failed to parse built-in verifier response \u2014 skipping");
         }
-        const assistantTurn = {
-          role: "assistant",
-          content: response.content || "",
-          tokenCount: this.adapter.estimateTokens(response.content || "") + 50,
-          turnIndex: this.context.turns.length,
-          compressed: false,
-          toolCalls: response.toolCalls
-        };
-        this.context.turns.push(assistantTurn);
-        if (this.config.onTurn) this.config.onTurn(assistantTurn);
-        for (const res of toolResults) {
-          const toolTurn = {
-            role: "tool",
-            content: res.content,
-            tokenCount: this.adapter.estimateTokens(res.content),
-            turnIndex: this.context.turns.length,
-            compressed: false,
-            toolResults: [res]
-          };
-          this.context.turns.push(toolTurn);
-          if (this.config.onTurn) this.config.onTurn(toolTurn);
-        }
-        if (this.goalInjector) this.goalInjector.incrementTurn();
-        continue;
-      }
-      this.context.tokenCount = this.context.turns.reduce((sum, t) => sum + t.tokenCount, 0) + this.adapter.estimateTokens(this.context.systemPrompt || "");
-      this.context = await this.contextManager.prepare(this.context);
-      const finalSystemPrompt = this.buildSystemPrompt(userMessageStr, this.iterations);
-      const finalMessages = this.buildMessages(finalSystemPrompt, this.iterations);
-      let accumulated = "";
-      let finalFinishReason = void 0;
-      let finalTokenCount = 0;
-      for await (const chunk of this.adapter.stream({
-        model: this.config.model,
-        messages: finalMessages,
-        maxTokens: maxCompletionTokens,
-        stream: true
-      })) {
-        if (chunk.delta) {
-          accumulated += chunk.delta;
-          finalTokenCount += Math.ceil(chunk.delta.length / 4);
-          yield chunk.delta;
-        }
-        if (chunk.finished) {
-          finalFinishReason = chunk.finishReason;
-          if (chunk.usage) {
-            this.totalTokens += chunk.usage.totalTokens;
-          }
-          this.emitTrace("thinking", "llm_stream_finished", {
-            usage: chunk.usage,
-            totalTokens: this.totalTokens,
-            finishReason: chunk.finishReason
+        if (verdict) {
+          this.emitTrace("verification", "goal_verification_result", {
+            achieved: verdict.achieved,
+            reason: verdict.reason,
+            missing: verdict.missing,
+            source: "built_in"
           });
+          return verdict;
         }
       }
-      const finalTurn = {
-        role: "assistant",
-        content: accumulated,
-        tokenCount: finalTokenCount,
-        turnIndex: this.context.turns.length,
-        compressed: false
-      };
-      this.context.turns.push(finalTurn);
-      if (this.config.onTurn) this.config.onTurn(finalTurn);
-      this.logger.info(`[stream] Streaming run completed (finishReason: ${finalFinishReason ?? "stop"})`);
-      return;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.warn(`[GoalVerifier] Verification step failed (non-fatal): ${msg}`);
     }
-    const maxItsErr = new LemuraMaxIterationsError(`Exceeded max iterations of ${maxIts}`);
-    this.logger.fatal(maxItsErr.message, {
-      problem: "The streaming agent loop exceeded its max iterations.",
-      hints: ["Increase maxIterations or reduce task complexity."]
-    });
-    throw maxItsErr;
+    return null;
   }
   /**
    * Resets the session: clears conversation history, resets iteration counters,