@blockrun/franklin 3.8.24 → 3.8.25

package/dist/agent/evaluator.d.ts

@@ -38,6 +38,12 @@ export interface GroundingResult {
  * of this module is to cover read-heavy turns the code verifier misses.
  */
 export declare function shouldCheckGrounding(userInput: string, assistantText: string): boolean;
+/**
+ * Find the `[FRANKLIN HARNESS PREFETCH]` block in the most recent user
+ * message (that's where intent-prefetch injects it). Returns the inner
+ * payload or null if no prefetch happened this turn.
+ */
+export declare function extractPrefetchBlock(history: Dialogue[]): string | null;
 export declare function parseGroundingResponse(raw: string): GroundingResult;
 /** Cheap model for grading. Default matches existing verification.ts
  *  choice so both quality gates have the same cost profile. Override via

package/dist/agent/evaluator.js

@@ -37,11 +37,13 @@ const EVALUATOR_PROMPT = `You are a GROUNDING CHECK agent. Your job is to verify
 
 ### A. Ungrounded claims
 Every **factual claim** in the answer must trace to ONE of:
-  (a) A successful tool call result from this turn, OR
+  (a) A tool call result from this turn (model-initiated OR listed under "Pre-fetched by Franklin harness"), OR
   (b) Explicit acknowledgment of uncertainty ("I'm not sure", "based on older data")
 
+**Harness-prefetched data is evidence.** When the turn includes a "Pre-fetched by Franklin harness" section, the data listed there was fetched live from tools on the assistant's behalf (TradingMarket, ExaAnswer, etc). Treat it identically to a model-initiated tool call — claims that reference prefetched prices, numbers, or news snippets are GROUNDED.
+
 Flag as ungrounded:
-- Specific current-world facts stated with confidence but not backed by any tool call this turn
+- Specific current-world facts stated with confidence but not backed by any tool call this turn (including prefetch)
 - Recommendations or conclusions that depend on unstated data (e.g. "you should sell" without a price lookup)
 - Invented specifics — names, numbers, dates the model produced without a tool call supporting them
 
@@ -102,7 +104,20 @@ function summarizeTurn(userInput, history, assistantText) {
     lines.push(`## User question`);
     lines.push(userInput.trim().slice(0, 800));
     lines.push('');
-    lines.push(`## Tool calls this turn`);
+    // ── Harness prefetch (treated as synthetic tool calls) ──
+    // When intent-prefetch fires, it prepends a [FRANKLIN HARNESS PREFETCH]
+    // block to the user message. The LLM answers based on that data, but
+    // the evaluator previously only looked for tool_use/tool_result pairs
+    // and missed the injection — flagging answers that were actually
+    // grounded in live data as UNGROUNDED. Surface the block explicitly so
+    // the evaluator counts it as evidence.
+    const prefetchBlock = extractPrefetchBlock(history);
+    if (prefetchBlock) {
+        lines.push(`## Pre-fetched by Franklin harness (counts as tool evidence)`);
+        lines.push(prefetchBlock.slice(0, 1200));
+        lines.push('');
+    }
+    lines.push(`## Tool calls this turn (model-initiated)`);
     // Walk from the end of history back to (but not including) the user message.
     // Each assistant tool_use and each user tool_result get condensed to one line.
     let found = 0;
@@ -136,7 +151,7 @@ function summarizeTurn(userInput, history, assistantText) {
         }
     }
     if (toolLines.length === 0) {
-        lines.push('  (none)');
+        lines.push(prefetchBlock ? '  (none — but harness pre-fetched data above)' : '  (none)');
     }
     else {
         lines.push(...toolLines);
@@ -146,6 +161,31 @@ function summarizeTurn(userInput, history, assistantText) {
     lines.push(assistantText.trim().slice(0, 2400));
     return lines.join('\n');
 }
+/**
+ * Find the `[FRANKLIN HARNESS PREFETCH]` block in the most recent user
+ * message (that's where intent-prefetch injects it). Returns the inner
+ * payload or null if no prefetch happened this turn.
+ */
+export function extractPrefetchBlock(history) {
+    for (let i = history.length - 1; i >= 0; i--) {
+        const msg = history[i];
+        if (msg.role !== 'user')
+            continue;
+        const content = typeof msg.content === 'string' ? msg.content : null;
+        if (!content)
+            continue;
+        const startIdx = content.indexOf('[FRANKLIN HARNESS PREFETCH]');
+        if (startIdx < 0)
+            return null; // Most recent user message has no prefetch — we're done
+        // Capture from the marker up to (but not including) the "Original user message:" divider
+        const endMarker = '\nOriginal user message:';
+        const endIdx = content.indexOf(endMarker, startIdx);
+        if (endIdx < 0)
+            return content.slice(startIdx).trim();
+        return content.slice(startIdx, endIdx).trim();
+    }
+    return null;
+}
 // ─── Verdict parser ──────────────────────────────────────────────────────
 export function parseGroundingResponse(raw) {
     const text = raw.trim();

package/dist/agent/loop.js

@@ -717,32 +717,43 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             let routingConfidence;
             let routingSavings;
             if (routingProfile) {
-                // Extract latest user text for classification
-                const lastUser = [...history].reverse().find((m) => m.role === 'user');
-                const userText = typeof lastUser?.content === 'string'
-                    ? lastUser.content
-                    : Array.isArray(lastUser?.content)
+                if (groundingRetryCount > 0 && lastRoutedModel) {
+                    // Grounding retry re-enters the loop with a `[GROUNDING CHECK
+                    // FAILED]` user message that the router would classify as
+                    // SIMPLE on its own — which drops the turn onto a weak model
+                    // mid-task (observed in the CRCL log on 2026-04-22). Pin the
+                    // model the router picked on the first iteration so retries
+                    // stay on the same tier.
+                    resolvedModel = lastRoutedModel;
+                }
+                else {
+                    // Extract latest user text for classification
+                    const lastUser = [...history].reverse().find((m) => m.role === 'user');
+                    const userText = typeof lastUser?.content === 'string'
                         ? lastUser.content
-                            .filter(p => p.type === 'text')
-                            .map(p => p.text ?? '')
-                            .join(' ')
-                        : '';
-                const routing = await routeRequestAsync(userText, routingProfile);
-                resolvedModel = routing.model;
-                routingTier = routing.tier;
-                routingConfidence = routing.confidence;
-                routingSavings = routing.savings;
-                lastRoutedModel = routing.model;
-                lastRoutedCategory = routing.signals[0] || '';
-                // Surface the routing decision so users know which concrete model
-                // just got picked. Without this the status bar reads "auto" and
-                // users have no idea what's actually running — or worse, they
-                // believe they're stuck on the last-seen concrete name.
-                if (loopCount === 1) {
-                    onEvent({
-                        kind: 'text_delta',
-                        text: `*Auto → ${routing.model}*\n\n`,
-                    });
+                        : Array.isArray(lastUser?.content)
+                            ? lastUser.content
+                                .filter(p => p.type === 'text')
+                                .map(p => p.text ?? '')
+                                .join(' ')
+                            : '';
+                    const routing = await routeRequestAsync(userText, routingProfile);
+                    resolvedModel = routing.model;
+                    routingTier = routing.tier;
+                    routingConfidence = routing.confidence;
+                    routingSavings = routing.savings;
+                    lastRoutedModel = routing.model;
+                    lastRoutedCategory = routing.signals[0] || '';
+                    // Surface the routing decision so users know which concrete model
+                    // just got picked. Without this the status bar reads "auto" and
+                    // users have no idea what's actually running — or worse, they
+                    // believe they're stuck on the last-seen concrete name.
+                    if (loopCount === 1) {
+                        onEvent({
+                            kind: 'text_delta',
+                            text: `*Auto → ${routing.model}*\n\n`,
+                        });
+                    }
                 }
             }
             // Update token estimation model for more accurate byte-per-token ratio

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.8.24",
+  "version": "3.8.25",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {