@blockrun/franklin 3.7.4 → 3.7.6

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/planner.js

@@ -17,25 +17,29 @@ const MULTI_STEP_PATTERN = /first.*then|step\s+\d|\d+\.\s|and\s+then|after\s+tha
  * the overhead of an extra planning call.
  */
 export function shouldPlan(tier, profile, userText, ultrathink, planDisabled) {
-    // Gate 1: only COMPLEX or REASONING tiers benefit from planning
-    if (tier !== 'COMPLEX' && tier !== 'REASONING')
-        return false;
-    // Gate 2: only auto or premium profiles (eco/free already cost-optimized)
-    if (profile !== 'auto' && profile !== 'premium')
-        return false;
-    // Gate 3: skip short queries — planning overhead not worth it
-    if (userText.length < 80)
+    // User disabled planning for this session
+    if (planDisabled)
         return false;
-    // Gate 4: ultrathink already provides deep reasoning
+    // Ultrathink already provides deep reasoning
     if (ultrathink)
         return false;
-    // Gate 5: user disabled planning for this session
-    if (planDisabled)
+    // Only auto or premium profiles (eco/free are cost-constrained)
+    if (profile !== 'auto' && profile !== 'premium')
         return false;
-    // Gate 6: must have agentic or multi-step signals
-    const hasAgenticKeyword = AGENTIC_KEYWORDS.test(userText);
-    const hasMultiStep = MULTI_STEP_PATTERN.test(userText);
-    return hasAgenticKeyword || hasMultiStep;
+    // Explicit multi-step language always plans, regardless of tier / length
+    // ("first ... then ...", "step 1 ... step 2 ...", numbered lists, etc.)
+    if (MULTI_STEP_PATTERN.test(userText))
+        return true;
+    // Planning is high-ROI on COMPLEX / REASONING tiers for agentic verbs,
+    // even when the prompt is short ("refactor the wallet module", "migrate to TS")
+    if (tier === 'COMPLEX' || tier === 'REASONING') {
+        return AGENTIC_KEYWORDS.test(userText) || userText.length >= 60;
+    }
+    // On MEDIUM tier: plan only if long AND agentic
+    if (tier === 'MEDIUM' && userText.length >= 120 && AGENTIC_KEYWORDS.test(userText)) {
+        return true;
+    }
+    return false;
 }
 // ─── Planning Prompt ─────────────────────────────────────────────────────
 /**

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

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

package/dist/agent/tool-guard.js

@@ -90,6 +90,11 @@ 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();
+    recentBash = new Map();
     startTurn() {
         this.turn++;
         this.webSearchesThisTurn = 0;
@@ -115,10 +120,69 @@ 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);
+            case 'Bash':
+                return this.beforeBash(invocation);
             default:
                 return null;
         }
     }
+    beforeBash(invocation) {
+        const cmd = String(invocation.input.command ?? '').trim();
+        if (!cmd)
+            return null;
+        // Only dedup deterministic read-only commands. Skip anything writing/network/long-running.
+        const writeKeywords = /\b(rm|mv|cp|mkdir|touch|chmod|chown|write|install|build|publish|push|pull|curl|wget|fetch|npm|pnpm|yarn|pip|cargo|go\s+(build|run|test)|docker|kubectl|tar|zip|unzip|tee|>\s|>>\s)\b/;
+        if (writeKeywords.test(cmd))
+            return null;
+        const key = cmd;
+        const cached = this.recentBash.get(key);
+        if (cached) {
+            const lead = cached.isError
+                ? 'That exact Bash command was already run this session and FAILED:'
+                : 'That exact Bash command was already run this session and returned:';
+            return {
+                output: `${lead}\n${cached.preview}\n\n` +
+                    'Do not re-run the same command. If the output was insufficient, run a different command or use a dedicated tool (Read for files, Grep/Glob for searching).',
+            };
+        }
+        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 +199,58 @@ export class SessionToolGuard {
             case 'WebFetch':
                 this.afterWebFetch(invocation, result);
                 break;
+            case 'Grep':
+                this.afterGrep(invocation, result);
+                break;
+            case 'Glob':
+                this.afterGlob(invocation, result);
+                break;
+            case 'Bash':
+                this.afterBash(invocation, result);
+                break;
             default:
                 break;
         }
     }
+    afterBash(invocation, result) {
+        const cmd = String(invocation.input.command ?? '').trim();
+        if (!cmd)
+            return;
+        const writeKeywords = /\b(rm|mv|cp|mkdir|touch|chmod|chown|write|install|build|publish|push|pull|curl|wget|fetch|npm|pnpm|yarn|pip|cargo|go\s+(build|run|test)|docker|kubectl|tar|zip|unzip|tee|>\s|>>\s)\b/;
+        if (writeKeywords.test(cmd))
+            return;
+        const output = String(result.output ?? '');
+        const preview = output.length > MAX_PREVIEW_CHARS
+            ? output.slice(0, MAX_PREVIEW_CHARS) + '…'
+            : output;
+        this.recentBash.set(cmd, { preview, turn: this.turn, isError: !!result.isError });
+    }
+    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/package.json

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