lemura 1.5.2 → 1.5.4

package/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.4] - 2026-05-30
+
+### Fixed
+
+- **Goal verification could not recover an incomplete response** (significant): when the goal verifier returned `achieved: false`, the runtime ran a single **tool-less** `complete()` correction whose output was never re-verified (the run was flagged done after the first check) and, in `stream()`, was never sent to the caller. A response missing a step that required a tool (read a file, write output, …) could therefore never actually be completed. The verifier now re-enters the ReAct loop with a corrective user turn so the model has **full tool access** and the corrected answer is **streamed**, bounded by the new `maxGoalCorrections` budget (default `1`). When the budget is exhausted and the goal is still unmet, a visible Goal Verification Warning is appended/streamed as before. Applies to both `run()` and `stream()`.
+
+### Added
+
+- **`maxGoalCorrections`** (`SessionConfig`, default `1`): maximum goal-verification corrective re-entries per run. Set to `0` to disable corrective re-entry (a warning is surfaced instead).
+- **`goalProgressReconciliation`** (`SessionConfig`, default `false`): when enabled, the agent periodically (every `goalInjectionN` tool rounds) reconciles which decomposed sub-goals are already complete and marks them done, so the re-injected goal block reflects real progress instead of always showing every sub-goal as pending. Counters goal drift on long runs at the cost of one small LLM call per reconciliation. This wires up `GoalInjector.markSubGoalDone()`, which was previously never invoked.
+
+## [1.5.3] - 2026-05-30
+
+### Fixed
+
+- **Tool firewall `ask` decision could execute denied tools** (critical): when a `ToolFirewallConfig.onAsk` handler returned anything other than the exact string `'deny'` — including the boolean `false`, `undefined`, or by throwing — the tool was executed anyway. A user pressing "Stop"/deny could not actually stop the tool call. The `ask` path is now **fail-safe**: only an explicit accept signal (`'accept'` or `true`) allows execution; `'deny'`, `false`, `undefined`, `void`, and thrown errors all block the tool and inject a `Blocked by tool firewall` observation.
+  - `ToolFirewallConfig.onAsk` now accepts `'accept' | 'deny' | boolean | void` (and the `Promise` thereof) for ergonomics. The previous `'accept' | 'deny'` return remains valid.
+
 ## [1.5.2] - 2026-05-30
 
 ### Changed

package/README.md

@@ -1,4 +1,6 @@
+<p align="center">
   <img src="https://raw.githubusercontent.com/rzafiamy/lemura/main/sites/docs/public/lemura-logo.png" alt="lemura logo" width="200" />
+</p>
 
 # lemura
 
@@ -24,10 +26,11 @@
 
 - **🧠 Dynamic Skill Market**: Switch skills on/off at runtime via tags, names, or tool dependencies.
 - **🔌 Native MCP Support**: Connect to any Model Context Protocol server with custom header support (Auth).
-- **🛡️ Tool Firewall**: Fully integrated ask/accept/deny policy layer for secure tool execution.
-- **🎯 Goal Maintenance**: LLM-powered sub-goal decomposition and status tracking across turns.
-- **🧹 Summary Injection**: Automatically compresses history while ensuring the model never "forgets" the context.
-- **🌊 Native Streaming**: Token-by-token completion for smooth, responsive user experiences.
+- **🛡️ Tool Firewall**: Fully integrated ask/accept/deny policy layer for secure tool execution — fail-safe by design.
+- **🎯 Goal Maintenance & Verification**: LLM-powered sub-goal decomposition, progress reconciliation, and post-run goal verification that re-enters the loop with full tool access to finish incomplete answers.
+- **🧹 Context Compression**: Sandwich, history, and summary-injection strategies keep long conversations within budget while ensuring the model never "forgets" the context.
+- **🌊 Native Streaming**: `run()` and `stream()` share one ReAct core — `stream()` completes all tool use and verification, then emits the final answer token-by-token.
+- **📚 RAG Connector**: Pluggable `IRAGAdapter` interface plus a bundled in-memory adapter for ingest → query → context injection.
 - **📊 Observability**: Detailed tracing, token tracking, and structured logging with actionable hints.
 
 ## 🚀 Install
@@ -142,13 +145,29 @@ Explore the architecture and advanced capabilities of `lemura` at [lemura.makix.
 
 | Export | Description |
 |---|---|
-| `SessionManager` | The main entry point orchestrating the ReAct loop and tools. |
-| `ContextManager` | Manages the conversation history using compression strategies. |
-| `OpenAICompatibleAdapter` | Reference adapter for OpenAI, Groq, Together, etc. |
-| `ToolRegistry` | Registers and executes tools for the agent. |
+| `SessionManager` | The main entry point orchestrating the ReAct loop, tools, goals, and streaming. |
+| `ContextManager` | Manages the conversation history using pluggable compression strategies. |
+| `OpenAICompatibleAdapter` | Reference adapter for OpenAI, Groq, Together, Ollama, and any OpenAI-compatible endpoint. |
+| `ToolRegistry` | Registers, validates, and executes tools with timeout and budget enforcement. |
 | `SkillInjector` | Loads and formats YAML/Markdown skills into system prompts. |
+| `MCPClient` / `MCPClientRegistry` | Connect to Model Context Protocol servers and register their tools. |
+| `InMemoryRAGAdapter` | Self-contained RAG adapter for testing the ingest → query round-trip. |
 | `DefaultLogger` | Colorized logger with Problem/Hints metadata support. |
 
+### Subpath Exports
+
+Each layer is independently importable so consumers only bundle what they use:
+
+```ts
+import { SandwichCompressionStrategy } from 'lemura/context';
+import { OpenAICompatibleAdapter }      from 'lemura/adapters';
+import { ToolRegistry }                 from 'lemura/tools';
+import { SkillInjector }                from 'lemura/skills';
+import { InMemoryRAGAdapter }           from 'lemura/rag';
+import { MCPClient }                    from 'lemura/mcp';
+import { DefaultLogger }                from 'lemura/logger';
+```
+
 ## 🪵 Logging and Tracing
 
 `lemura` features a premium, structured logging system designed for developer experience. It provides colorized output and actionable hints for errors.
@@ -190,7 +209,7 @@ When an error occurs (like an invalid API key), `lemura` provides beautiful, str
 
 ## 🤝 Contributing
 
-We welcome contributions! Please read our [Internal Rules](./.cursor/rules/Project.md) and [Documentation Guidelines](./.cursor/rules/Documentation.md) before submitting a PR.
+We welcome contributions! Please read our [Internal Rules](./.agent/rules/Project.md) and [Documentation Guidelines](./.agent/rules/Documentation.md) before submitting a PR.
 
 ## 📄 License
 

package/dist/{agent-Cq_oRvoc.d.ts → agent-CknicweT.d.ts}

@@ -199,9 +199,14 @@ interface ToolFirewallConfig {
     rules?: ToolFirewallRule[];
     /**
      * Called when a tool hits the 'ask' decision.
-     * Return 'accept' or 'deny'. If omitted, 'ask' behaves like 'deny'.
+     *
+     * Return `'accept'` (or `true`) to allow the tool to run; return `'deny'`
+     * (or `false`) to block it. The decision is **fail-safe**: only an explicit
+     * accept signal allows execution — any other value (`'deny'`, `false`,
+     * `undefined`, `null`, a thrown error) blocks the tool. If `onAsk` is
+     * omitted entirely, an `'ask'` decision behaves like `'deny'`.
      */
-    onAsk?: (toolName: string, argsJson: string) => Promise<'accept' | 'deny'> | 'accept' | 'deny';
+    onAsk?: (toolName: string, argsJson: string) => Promise<'accept' | 'deny' | boolean | void> | 'accept' | 'deny' | boolean | void;
 }
 /**
  * Execution budget constraints for tool calls within a session.
@@ -299,6 +304,24 @@ interface SessionConfig {
      * @since 1.5.0
      */
     enableGoalVerification?: boolean;
+    /**
+     * Maximum number of goal-verification corrections per run. When verification
+     * finds the response incomplete, the agent re-enters the ReAct loop (with full
+     * tool access) up to this many times to actually resolve what is missing,
+     * rather than emitting a tool-less one-shot rewrite. Defaults to 1.
+     * Set to 0 to disable corrective re-entry (a warning is surfaced instead).
+     * @since 1.5.4
+     */
+    maxGoalCorrections?: number;
+    /**
+     * When true, the agent periodically reconciles which decomposed sub-goals are
+     * already complete (one small LLM call every `goalInjectionN` tool rounds) and
+     * marks them done, so the re-injected goal block reflects real progress instead
+     * of always showing every sub-goal as pending. Counters goal drift on long runs.
+     * Defaults to false (no extra calls). Requires `enableGoalPlanning`.
+     * @since 1.5.4
+     */
+    goalProgressReconciliation?: boolean;
     goalInjectionFrequency?: 'always' | 'every_N_turns' | 'on_compression';
     goalInjectionPosition?: 'system_prompt' | 'pre_turn';
     /** Skill budget — max tokens the skill injection block may consume */

package/dist/{agent-DPSUNlK6.d.mts → agent-UBaqufhp.d.mts}

@@ -199,9 +199,14 @@ interface ToolFirewallConfig {
     rules?: ToolFirewallRule[];
     /**
      * Called when a tool hits the 'ask' decision.
-     * Return 'accept' or 'deny'. If omitted, 'ask' behaves like 'deny'.
+     *
+     * Return `'accept'` (or `true`) to allow the tool to run; return `'deny'`
+     * (or `false`) to block it. The decision is **fail-safe**: only an explicit
+     * accept signal allows execution — any other value (`'deny'`, `false`,
+     * `undefined`, `null`, a thrown error) blocks the tool. If `onAsk` is
+     * omitted entirely, an `'ask'` decision behaves like `'deny'`.
      */
-    onAsk?: (toolName: string, argsJson: string) => Promise<'accept' | 'deny'> | 'accept' | 'deny';
+    onAsk?: (toolName: string, argsJson: string) => Promise<'accept' | 'deny' | boolean | void> | 'accept' | 'deny' | boolean | void;
 }
 /**
  * Execution budget constraints for tool calls within a session.
@@ -299,6 +304,24 @@ interface SessionConfig {
      * @since 1.5.0
      */
     enableGoalVerification?: boolean;
+    /**
+     * Maximum number of goal-verification corrections per run. When verification
+     * finds the response incomplete, the agent re-enters the ReAct loop (with full
+     * tool access) up to this many times to actually resolve what is missing,
+     * rather than emitting a tool-less one-shot rewrite. Defaults to 1.
+     * Set to 0 to disable corrective re-entry (a warning is surfaced instead).
+     * @since 1.5.4
+     */
+    maxGoalCorrections?: number;
+    /**
+     * When true, the agent periodically reconciles which decomposed sub-goals are
+     * already complete (one small LLM call every `goalInjectionN` tool rounds) and
+     * marks them done, so the re-injected goal block reflects real progress instead
+     * of always showing every sub-goal as pending. Counters goal drift on long runs.
+     * Defaults to false (no extra calls). Requires `enableGoalPlanning`.
+     * @since 1.5.4
+     */
+    goalProgressReconciliation?: boolean;
     goalInjectionFrequency?: 'always' | 'every_N_turns' | 'on_compression';
     goalInjectionPosition?: 'system_prompt' | 'pre_turn';
     /** Skill budget — max tokens the skill injection block may consume */

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-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';
+import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, M as MCPServerConfig, a as MCPToolDefinition } from './agent-UBaqufhp.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-UBaqufhp.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';
@@ -365,6 +365,15 @@ declare class SessionManager {
      * manually set via `setGoal()`.
      */
     private _runMiniPlanningStep;
+    /**
+     * Reconciles sub-goal completion against the recent conversation so the
+     * re-injected goal block reflects real progress (anti-drift). Runs only when
+     * `goalProgressReconciliation` is enabled, and is a no-op when there are no
+     * pending sub-goals. One small, non-fatal LLM call; failures are swallowed.
+     *
+     * @since 1.5.4
+     */
+    private _reconcileSubGoals;
     /** Builds the system prompt, injecting skills and goal if configured. */
     private buildSystemPrompt;
     /** Builds the messages array for the provider from the current context. */

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-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';
+import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, M as MCPServerConfig, a as MCPToolDefinition } from './agent-CknicweT.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-CknicweT.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';
@@ -365,6 +365,15 @@ declare class SessionManager {
      * manually set via `setGoal()`.
      */
     private _runMiniPlanningStep;
+    /**
+     * Reconciles sub-goal completion against the recent conversation so the
+     * re-injected goal block reflects real progress (anti-drift). Runs only when
+     * `goalProgressReconciliation` is enabled, and is a no-op when there are no
+     * pending sub-goals. One small, non-fatal LLM call; failures are swallowed.
+     *
+     * @since 1.5.4
+     */
+    private _reconcileSubGoals;
     /** Builds the system prompt, injecting skills and goal if configured. */
     private buildSystemPrompt;
     /** Builds the messages array for the provider from the current context. */

package/dist/index.js

@@ -3028,6 +3028,64 @@ Respond ONLY with valid JSON (no markdown, no explanations):
       this.logger.warn(`[GoalInjector] Mini-planning step failed: ${err.message ?? String(err)}`);
     }
   }
+  /**
+   * Reconciles sub-goal completion against the recent conversation so the
+   * re-injected goal block reflects real progress (anti-drift). Runs only when
+   * `goalProgressReconciliation` is enabled, and is a no-op when there are no
+   * pending sub-goals. One small, non-fatal LLM call; failures are swallowed.
+   *
+   * @since 1.5.4
+   */
+  async _reconcileSubGoals() {
+    if (!this.config.goalProgressReconciliation) return;
+    if (!this.goalInjector) return;
+    const goal = this.goalInjector.getGoal();
+    const completed = new Set(goal.completedSubGoals ?? []);
+    const pending = (goal.decomposition ?? []).filter((sg) => !completed.has(sg));
+    if (pending.length === 0) return;
+    const recentTurns = this.context.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 pendingList = pending.map((sg, i) => `${i + 1}. ${sg}`).join("\n");
+    try {
+      const response = await this.adapter.complete({
+        model: this.config.model,
+        temperature: 0,
+        maxTokens: 256,
+        messages: [
+          {
+            role: "system",
+            content: 'You track sub-goal progress. Given pending sub-goals and the recent conversation, return ONLY the 1-based indices of sub-goals that are now fully completed. Respond with valid JSON only, no prose: {"completed": number[]}'
+          },
+          {
+            role: "user",
+            content: `Pending sub-goals:
+${pendingList}
+
+Recent conversation:
+${recentTurns}
+
+Which pending sub-goals are now fully completed?`
+          }
+        ]
+      });
+      const match = response.content.match(/\{[\s\S]*\}/);
+      if (!match) return;
+      const parsed = JSON.parse(match[0]);
+      if (!Array.isArray(parsed.completed)) return;
+      for (const idx of parsed.completed) {
+        const sg = pending[idx - 1];
+        if (sg) {
+          this.goalInjector.markSubGoalDone(sg);
+          this.emitTrace("planning", "subgoal_done", { subGoal: sg });
+        }
+      }
+      this.context.metadata["goal"] = this.goalInjector.getGoal();
+    } catch (err) {
+      this.logger.warn(`[GoalInjector] Sub-goal reconciliation failed (non-fatal): ${err.message ?? String(err)}`);
+    }
+  }
   // -----------------------------------------------------------------------
   // Internal helpers
   // -----------------------------------------------------------------------
@@ -3260,8 +3318,17 @@ ${blocks.join("\n\n")}
     }
     if (firewall.decision === "ask") {
       if (this.config.toolFirewall?.onAsk) {
-        const userDecision = await this.config.toolFirewall.onAsk(toolName, argsJson);
-        if (userDecision === "deny") {
+        let accepted = false;
+        try {
+          const userDecision = await this.config.toolFirewall.onAsk(toolName, argsJson);
+          accepted = userDecision === "accept" || userDecision === true;
+        } catch (e) {
+          this.logger.warn(`Tool firewall onAsk handler threw \u2014 treating as deny: ${toolName}`, {
+            error: e instanceof Error ? e.message : String(e)
+          });
+          accepted = false;
+        }
+        if (!accepted) {
           this.logger.warn(`Tool blocked by firewall (ask \u2192 deny): ${toolName}`, { reason: firewall.reason });
           toolResults.push({ toolCallId, content: `Blocked by tool firewall: ${firewall.reason}` });
           return false;
@@ -3483,6 +3550,7 @@ ${blocks.join("\n\n")}
     this.iterations = 0;
     this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
     const maxCompletionTokens = this.config.maxCompletionTokens ?? 4e3;
+    let correctionsRemaining = this.config.maxGoalCorrections ?? 1;
     while (this.iterations < maxIts) {
       this.iterations++;
       this.logger.debug(`[stream] ReAct Iteration ${this.iterations}/${maxIts}`);
@@ -3544,6 +3612,9 @@ ${blocks.join("\n\n")}
           if (this.config.onTurn) this.config.onTurn(toolTurn);
         }
         if (this.goalInjector) this.goalInjector.incrementTurn();
+        if (this.config.goalProgressReconciliation && this.iterations % (this.config.goalInjectionN ?? 3) === 0) {
+          await this._reconcileSubGoals();
+        }
         continue;
       }
       this.context.tokenCount = this.context.turns.reduce((sum, t) => sum + t.tokenCount, 0) + this.adapter.estimateTokens(this.context.systemPrompt || "");
@@ -3585,60 +3656,47 @@ ${blocks.join("\n\n")}
       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}"`);
+        if (verdict && !verdict.achieved && verdict.missing && correctionsRemaining > 0 && this.iterations < maxIts) {
+          correctionsRemaining--;
+          this.logger.info(`[GoalVerifier] Incomplete \u2014 re-entering loop with tools to correct: "${verdict.missing}" (${correctionsRemaining} correction(s) left)`);
           this.emitTrace("verification", "goal_correction_start", {
             missing: verdict.missing,
-            reason: verdict.reason
+            reason: verdict.reason,
+            correctionsRemaining
           });
-          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
-              });
-              this.emitTrace("verification", "goal_correction_done", {
-                missing: verdict.missing,
-                correctionTokens: correction.usage?.completionTokens
-              });
-            }
-          } catch (err) {
-            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 = `
+          const directive = `[Goal verification found the previous response incomplete. Continue working \u2014 use tools as needed \u2014 to address what is still missing, then provide the complete final answer.]
+
+Still missing: ${verdict.missing}`;
+          this.context.turns.push({
+            role: "user",
+            content: directive,
+            tokenCount: this.adapter.estimateTokens(directive),
+            turnIndex: this.context.turns.length,
+            compressed: false
+          });
+          if (this.goalInjector) this.goalInjector.incrementTurn();
+          continue;
+        }
+        if (verdict && !verdict.achieved) {
+          this.logger.warn(`[GoalVerifier] Goal still unmet after corrections: ${verdict.reason}`);
+          this.emitTrace("verification", "goal_verification_result", {
+            achieved: false,
+            reason: verdict.reason,
+            missing: verdict.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"}
+* **Reason:** ${verdict.reason ?? "Unknown"}
+* **Missing:** ${verdict.missing ?? "Not specified"}
 
 `;
-            yield warningBlock;
-            const lastTurn = [...this.context.turns].reverse().find((t) => t.role === "assistant");
-            if (lastTurn) lastTurn.content = lastTurn.content + warningBlock;
-          }
+          yield warningBlock;
+          const lastTurn = [...this.context.turns].reverse().find((t) => t.role === "assistant");
+          if (lastTurn) lastTurn.content = lastTurn.content + warningBlock;
         }
       }
       this.logger.info(`[stream] Streaming run completed`);
@@ -3690,7 +3748,7 @@ ${blocks.join("\n\n")}
     this.iterations = 0;
     this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
     const maxCompletionTokens = this.config.maxCompletionTokens ?? 4e3;
-    let goalVerificationDone = false;
+    let correctionsRemaining = this.config.maxGoalCorrections ?? 1;
     while (this.iterations < maxIts) {
       this.iterations++;
       this.logger.debug(`[${opts.label}] ReAct Iteration ${this.iterations}/${maxIts}`);
@@ -3825,6 +3883,9 @@ ${blocks.join("\n\n")}
           if (this.config.onTurn) this.config.onTurn(toolTurn);
         }
         if (this.goalInjector) this.goalInjector.incrementTurn();
+        if (this.config.goalProgressReconciliation && this.iterations % (this.config.goalInjectionN ?? 3) === 0) {
+          await this._reconcileSubGoals();
+        }
         continue;
       }
       if (response.finishReason === "stop" || response.finishReason === "max_tokens" || response.finishReason === "error") {
@@ -3837,52 +3898,35 @@ ${blocks.join("\n\n")}
         };
         this.context.turns.push(finalTurn);
         if (this.config.onTurn) this.config.onTurn(finalTurn);
-        if (response.finishReason === "stop" && !goalVerificationDone) {
-          goalVerificationDone = true;
+        if (response.finishReason === "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}"`);
+          if (verdict && !verdict.achieved && verdict.missing && correctionsRemaining > 0 && this.iterations < maxIts) {
+            correctionsRemaining--;
+            this.logger.info(`[GoalVerifier] Incomplete \u2014 re-entering loop with tools to correct: "${verdict.missing}" (${correctionsRemaining} correction(s) left)`);
             this.emitTrace("verification", "goal_correction_start", {
               missing: verdict.missing,
-              reason: verdict.reason
+              reason: verdict.reason,
+              correctionsRemaining
             });
-            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
-                });
-                this.emitTrace("verification", "goal_correction_done", {
-                  missing: verdict.missing,
-                  correctionTokens: correction.usage?.completionTokens
-                });
-              }
-            } catch (err) {
-              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 directive = `[Goal verification found the previous response incomplete. Continue working \u2014 use tools as needed \u2014 to address what is still missing, then provide the complete final answer.]
+
+Still missing: ${verdict.missing}`;
+            this.context.turns.push({
+              role: "user",
+              content: directive,
+              tokenCount: this.adapter.estimateTokens(directive),
+              turnIndex: this.context.turns.length,
+              compressed: false
+            });
+            if (this.goalInjector) this.goalInjector.incrementTurn();
+            continue;
           }
-          const finalVerdict = await this._verifyGoal(this.context.turns);
-          if (finalVerdict && !finalVerdict.achieved) {
-            this.logger.warn(`[GoalVerifier] Final verification failed: ${finalVerdict.reason}`);
+          if (verdict && !verdict.achieved) {
+            this.logger.warn(`[GoalVerifier] Goal still unmet after corrections: ${verdict.reason}`);
             this.emitTrace("verification", "goal_verification_result", {
               achieved: false,
-              reason: finalVerdict.reason,
-              missing: finalVerdict.missing
+              reason: verdict.reason,
+              missing: verdict.missing
             }, null, null, "error");
             const warningBlock = `
 
@@ -3890,8 +3934,8 @@ ${blocks.join("\n\n")}
 
 \u26A0\uFE0F **Goal Verification Warning**
 * **Status:** Success criteria not fully met.
-* **Reason:** ${finalVerdict.reason ?? "Unknown"}
-* **Missing:** ${finalVerdict.missing ?? "Not specified"}
+* **Reason:** ${verdict.reason ?? "Unknown"}
+* **Missing:** ${verdict.missing ?? "Not specified"}
 
 `;
             const lastTurn = [...this.context.turns].reverse().find((t) => t.role === "assistant");