@blockrun/franklin 3.8.24 → 3.8.26

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

@@ -711,22 +711,19 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 sessionId,
             });
             // ── Router: resolve routing profiles to concrete models ──
+            // Classifier always sees the user's ORIGINAL prompt for this turn —
+            // never the `[GROUNDING CHECK FAILED]` / `[VERIFICATION FAILED]` /
+            // pushback-annotated variants the loop injects mid-turn. Same input
+            // across iterations → same tier → stable resolved model. Stops the
+            // failure mode where a retry message classified as SIMPLE dropped
+            // a COMPLEX task down to gemini mid-way.
             const routingProfile = parseRoutingProfile(config.model);
             let resolvedModel = config.model;
             let routingTier;
             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)
-                        ? lastUser.content
-                            .filter(p => p.type === 'text')
-                            .map(p => p.text ?? '')
-                            .join(' ')
-                        : '';
+                const userText = lastUserInput || '';
                 const routing = await routeRequestAsync(userText, routingProfile);
                 resolvedModel = routing.model;
                 routingTier = routing.tier;
@@ -734,10 +731,8 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 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.
+                // Surface the routing decision on the first iteration so the user
+                // sees which concrete model got picked, not just "auto".
                 if (loopCount === 1) {
                     onEvent({
                         kind: 'text_delta',

package/package.json

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