@blockrun/franklin 3.7.3 → 3.7.5

package/dist/agent/loop.js

@@ -31,6 +31,29 @@ import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions,
 function replaceHistory(target, replacement) {
     target.splice(0, target.length, ...replacement);
 }
+// ─── Pushback detection ───────────────────────────────────────────────────
+// Cheap models plough forward when users correct them. This detects common
+// correction patterns so the agent can explicitly reset its approach.
+const PUSHBACK_PATTERNS = [
+    /^(but|however|actually|wait|no+\b|hmm)\b/i,
+    /\b(that'?s?\s+(wrong|incorrect|not\s+right)|you'?re?\s+wrong)\b/i,
+    /\b(i\s+(said|told\s+you)|not\s+(what|that))\b/i,
+    /\b(we\s+are\s+using|the\s+correct|the\s+actual)\b/i,
+    /^(stop|no,|wrong|incorrect|try\s+again)\b/i,
+    /^(不对|不是|错了|再试|但是|其实|等等|停|重来)/,
+];
+function detectPushback(input, history) {
+    // Only count as pushback if there's a prior assistant turn to push back against.
+    if (history.length === 0)
+        return false;
+    const hasPriorAssistant = history.some((m) => m.role === 'assistant');
+    if (!hasPriorAssistant)
+        return false;
+    const trimmed = input.trim();
+    if (trimmed.length === 0 || trimmed.length > 500)
+        return false;
+    return PUSHBACK_PATTERNS.some((re) => re.test(trimmed));
+}
 /**
  * Sanitize history: fix orphaned tool results AND inject missing results.
  *
@@ -310,11 +333,19 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     input = cmdResult.rewritten;
             }
         }
+        // ── Pushback detection ──
+        // When the user corrects us ("no", "but", "actually", "wrong"), we must throw
+        // away the previous plan and reconsider — not continue the failing approach.
+        // Without this signal, cheap models tend to plough forward with the same bad idea.
+        const pushbackSignal = detectPushback(input, history);
+        const effectiveInput = pushbackSignal
+            ? `${input}\n\n[SYSTEM NOTE] The user is correcting you. Your previous response was wrong or off-target. Do NOT continue the previous approach. Re-read the conversation, identify what specifically the user is correcting, and change your strategy. If the user pointed out a fact (e.g. "we are using X"), treat that fact as ground truth and rebuild your answer around it.`
+            : input;
         lastUserInput = input;
-        history.push({ role: 'user', content: input });
+        history.push({ role: 'user', content: effectiveInput });
         turnCount++;
         toolGuard.startTurn();
-        persistSessionMessage({ role: 'user', content: input });
+        persistSessionMessage({ role: 'user', content: effectiveInput });
         // ── Model recovery: try original model at the start of each new turn ──
         // If we fell back to a free model last turn due to a transient error, try original again.
         // But DON'T reset if the original model had a payment failure — it will just fail again.

package/dist/agent/tool-guard.d.ts

@@ -14,9 +14,15 @@ export declare class SessionToolGuard {
     private recentFetches;
     private pendingFetches;
     private toolErrorCounts;
+    private recentGreps;
+    private recentGlobs;
     startTurn(): void;
     beforeExecute(invocation: CapabilityInvocation, scope: ExecutionScope): Promise<CapabilityResult | null>;
+    private beforeGrep;
+    private beforeGlob;
     afterExecute(invocation: CapabilityInvocation, result: CapabilityResult): void;
+    private afterGrep;
+    private afterGlob;
     cancelInvocation(invocationId: string): void;
     private beforeWebSearch;
     private beforeRead;

package/dist/agent/tool-guard.js

@@ -90,6 +90,10 @@ export class SessionToolGuard {
     recentFetches = new Map();
     pendingFetches = new Map();
     toolErrorCounts = new Map();
+    // Session-level dedup for code-search tools — agents love grep'ing the same pattern
+    // five times in a row when they're confused. Tell them once that it already failed.
+    recentGreps = new Map();
+    recentGlobs = new Map();
     startTurn() {
         this.turn++;
         this.webSearchesThisTurn = 0;
@@ -115,10 +119,46 @@ export class SessionToolGuard {
                 return this.beforeRead(invocation, scope);
             case 'WebFetch':
                 return this.beforeWebFetch(invocation);
+            case 'Grep':
+                return this.beforeGrep(invocation);
+            case 'Glob':
+                return this.beforeGlob(invocation);
             default:
                 return null;
         }
     }
+    beforeGrep(invocation) {
+        const pattern = String(invocation.input.pattern ?? '').trim();
+        const path = String(invocation.input.path ?? '').trim();
+        const glob = String(invocation.input.glob ?? '').trim();
+        const type = String(invocation.input.type ?? '').trim();
+        if (!pattern)
+            return null;
+        const key = `${pattern}::${path}::${glob}::${type}`;
+        const cached = this.recentGreps.get(key);
+        if (cached) {
+            return {
+                output: `That exact Grep was already run this session and returned:\n${cached.preview}\n\n` +
+                    'Do not re-run the same pattern. If you need different information, change the pattern, path, or try a different tool (Glob to list files, Read to see full content).',
+            };
+        }
+        return null;
+    }
+    beforeGlob(invocation) {
+        const pattern = String(invocation.input.pattern ?? '').trim();
+        const path = String(invocation.input.path ?? '').trim();
+        if (!pattern)
+            return null;
+        const key = `${pattern}::${path}`;
+        const cached = this.recentGlobs.get(key);
+        if (cached) {
+            return {
+                output: `That exact Glob was already run this session and returned:\n${cached.preview}\n\n` +
+                    'Do not re-run the same pattern. Use Grep to search within those files, or Read them directly.',
+            };
+        }
+        return null;
+    }
     afterExecute(invocation, result) {
         // Track per-tool error counts across the session
         if (result.isError) {
@@ -135,10 +175,42 @@ export class SessionToolGuard {
             case 'WebFetch':
                 this.afterWebFetch(invocation, result);
                 break;
+            case 'Grep':
+                this.afterGrep(invocation, result);
+                break;
+            case 'Glob':
+                this.afterGlob(invocation, result);
+                break;
             default:
                 break;
         }
     }
+    afterGrep(invocation, result) {
+        const pattern = String(invocation.input.pattern ?? '').trim();
+        const path = String(invocation.input.path ?? '').trim();
+        const glob = String(invocation.input.glob ?? '').trim();
+        const type = String(invocation.input.type ?? '').trim();
+        if (!pattern)
+            return;
+        const key = `${pattern}::${path}::${glob}::${type}`;
+        const output = String(result.output ?? '');
+        const preview = output.length > MAX_PREVIEW_CHARS
+            ? output.slice(0, MAX_PREVIEW_CHARS) + '…'
+            : output;
+        this.recentGreps.set(key, { preview, turn: this.turn });
+    }
+    afterGlob(invocation, result) {
+        const pattern = String(invocation.input.pattern ?? '').trim();
+        const path = String(invocation.input.path ?? '').trim();
+        if (!pattern)
+            return;
+        const key = `${pattern}::${path}`;
+        const output = String(result.output ?? '');
+        const preview = output.length > MAX_PREVIEW_CHARS
+            ? output.slice(0, MAX_PREVIEW_CHARS) + '…'
+            : output;
+        this.recentGlobs.set(key, { preview, turn: this.turn });
+    }
     cancelInvocation(invocationId) {
         this.pendingSearches.delete(invocationId);
         this.pendingReads.delete(invocationId);

package/dist/router/index.js

@@ -33,22 +33,24 @@ function loadLearnedWeights() {
     return null;
 }
 // ─── Tier Model Configs ───
+// Agent-first defaults. Claude Sonnet 4.6 is the industry standard for multi-step
+// tool-use agent work; cheap models keep derailing on simple agent loops.
 const AUTO_TIERS = {
     SIMPLE: {
         primary: 'google/gemini-2.5-flash',
-        fallback: ['deepseek/deepseek-chat', 'nvidia/nemotron-ultra-253b'],
+        fallback: ['moonshot/kimi-k2.5', 'deepseek/deepseek-chat'],
     },
     MEDIUM: {
-        primary: 'moonshot/kimi-k2.5',
-        fallback: ['google/gemini-2.5-flash', 'minimax/minimax-m2.7'],
+        primary: 'anthropic/claude-sonnet-4.6',
+        fallback: ['openai/gpt-5.4', 'google/gemini-3.1-pro'],
     },
     COMPLEX: {
-        primary: 'google/gemini-3.1-pro',
-        fallback: ['anthropic/claude-sonnet-4.6', 'google/gemini-2.5-pro'],
+        primary: 'anthropic/claude-sonnet-4.6',
+        fallback: ['openai/gpt-5.4', 'anthropic/claude-opus-4.6'],
     },
     REASONING: {
-        primary: 'xai/grok-4-1-fast-reasoning',
-        fallback: ['deepseek/deepseek-reasoner', 'openai/o4-mini'],
+        primary: 'anthropic/claude-opus-4.6',
+        fallback: ['openai/o3', 'xai/grok-4-1-fast-reasoning'],
     },
 };
 const ECO_TIERS = {
@@ -266,6 +268,13 @@ export function routeRequest(prompt, profile = 'auto') {
             savings: 1.0,
         };
     }
+    // Auto profile bypasses learned routing. The learned Elo scores grow with
+    // usage volume rather than pure quality, which biased the router toward
+    // cheap/weak models on agentic work. Classic AUTO_TIERS defaults are
+    // agent-tuned (Claude Sonnet as backbone) and more predictable for users.
+    if (profile === 'auto') {
+        return classicRouteRequest(prompt, profile);
+    }
     // ── Learned routing (if weights available) ──
     const weights = loadLearnedWeights();
     if (weights) {

package/package.json

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