@blockrun/franklin 3.15.96 → 3.15.98

package/dist/agent/commands.js

@@ -177,8 +177,25 @@ const DIRECT_COMMANDS = {
                 if ('type' in part) {
                     if (part.type === 'tool_result') {
                         toolResults++;
-                        const c = typeof part.content === 'string' ? part.content : JSON.stringify(part.content);
-                        totalToolChars += c.length;
+                        // Sibling of PR #54's tokens.ts fix: image base64 must NOT
+                        // count toward the displayed char total — `/context` would
+                        // otherwise show ~70K chars per attached image and confuse
+                        // the user about why the ring is at 1% but "total tool
+                        // chars" is huge.
+                        if (typeof part.content === 'string') {
+                            totalToolChars += part.content.length;
+                        }
+                        else if (Array.isArray(part.content)) {
+                            for (const block of part.content) {
+                                const t = block.type;
+                                if (t === 'text') {
+                                    totalToolChars += (block.text || '').length;
+                                }
+                                else if (t === 'image') {
+                                    totalToolChars += 6000; // ~1500 tokens × 4 chars/tok
+                                }
+                            }
+                        }
                     }
                     if (part.type === 'thinking')
                         thinkingBlocks++;

package/dist/agent/compact.js

@@ -385,7 +385,36 @@ function formatForSummarization(messages) {
                             textParts.push(`[Called tool: ${part.name}(${JSON.stringify(part.input).slice(0, 200)})]`);
                             break;
                         case 'tool_result': {
-                            const content = typeof part.content === 'string' ? part.content : JSON.stringify(part.content);
+                            // Sibling of PR #54's tokens.ts fix: when content is a
+                            // [{text}, {image}] array, JSON.stringify dumps base64
+                            // bytes into the summary prompt — bloats the summarizer's
+                            // input and produces a useless preview ("[Tool result:
+                            // [{\"type\":\"text\",\"text\":\"Image file: ...\"},{\"type\":\"image\",\"source\":{\"type\":\"base64\",\"data\":\"...").
+                            // Build the preview from text blocks only; mark images
+                            // explicitly so the summarizer knows they exist.
+                            let content;
+                            if (typeof part.content === 'string') {
+                                content = part.content;
+                            }
+                            else if (Array.isArray(part.content)) {
+                                const pieces = [];
+                                let imageCount = 0;
+                                for (const block of part.content) {
+                                    const t = block.type;
+                                    if (t === 'text') {
+                                        pieces.push(block.text || '');
+                                    }
+                                    else if (t === 'image') {
+                                        imageCount++;
+                                    }
+                                }
+                                if (imageCount > 0)
+                                    pieces.push(`[${imageCount} image block${imageCount > 1 ? 's' : ''}]`);
+                                content = pieces.join(' ');
+                            }
+                            else {
+                                content = JSON.stringify(part.content);
+                            }
                             const truncated = content.length > 500 ? content.slice(0, 500) + '...' : content;
                             textParts.push(`[Tool result${part.is_error ? ' (ERROR)' : ''}: ${truncated}]`);
                             break;

package/dist/agent/loop.js

@@ -1585,7 +1585,11 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 tier: routingTier,
                 confidence: routingConfidence,
                 savings: routingSavings,
-                contextPct: Math.round(contextUsagePct),
+                // Preserve sub-1% precision: a fresh session at 0.4% would
+                // round to 0 and freeze the renderer's context ring until the
+                // conversation grows past ~1k tokens. Match `/context`'s
+                // `.toFixed(1)` fidelity.
+                contextPct: Math.round(contextUsagePct * 10) / 10,
             });
             // Record usage for stats tracking (franklin stats command).
             // Prefer the real x402 charge from the gateway over a token-catalog

package/dist/agent/reduce.js

@@ -458,7 +458,27 @@ function estimateChars(history) {
                     if (p.type === 'text')
                         total += p.text.length;
                     else if (p.type === 'tool_result') {
-                        total += typeof p.content === 'string' ? p.content.length : JSON.stringify(p.content).length;
+                        // Sibling of PR #54's tokens.ts fix: JSON.stringify-ing a
+                        // [{text}, {image}] array counts the base64 `data` field as
+                        // text and inflates the char count by ~70K per image. That
+                        // skews every reduce-pass decision (when to dedupe, when to
+                        // collapse) toward "save chars by collapsing the image-
+                        // bearing result" — exactly wrong. Walk blocks instead.
+                        if (typeof p.content === 'string') {
+                            total += p.content.length;
+                        }
+                        else if (Array.isArray(p.content)) {
+                            for (const block of p.content) {
+                                if (block.type === 'text') {
+                                    total += (block.text || '').length;
+                                }
+                                else if (block.type === 'image') {
+                                    // Mirror tokens.ts: image ≈ 1500 tokens ≈ ~6K chars
+                                    // at the 4-chars/token rule estimateTokens uses.
+                                    total += 6000;
+                                }
+                            }
+                        }
                     }
                     else if (p.type === 'tool_use') {
                         total += JSON.stringify(p.input).length;

package/dist/agent/streaming-executor.js

@@ -219,7 +219,19 @@ export class StreamingExecutor {
             const execElapsed = Date.now() - execStart;
             if (execElapsed >= 30_000) {
                 const status = result.isError ? 'error' : 'ok';
-                const preview = this.inputPreview(invocation) || '';
+                // Single-line the preview before logging. Bash invocations like
+                // `python3 -c "<heredoc>"` carry embedded newlines that, sliced
+                // raw, break the one-line-per-entry contract of
+                // franklin-debug.log and shred any parser that splits on
+                // `^\[timestamp\]`. Verified 2026-05-04 (and reviewed again
+                // 2026-05-12): a real entry produced
+                //   `Slow tool: Bash ok after 438.4s — cd ... python3 -c "`
+                //   `import subprocess`
+                //   `[2026-05-04T19:25:10] [ERROR] Signature-loop hard stop ...`
+                // where "import subprocess" sat on its own line, untimestamped,
+                // because the preview's first 80 chars contained the heredoc
+                // opener.
+                const preview = (this.inputPreview(invocation) || '').replace(/[\r\n]+/g, ' ');
                 logger.info(`[franklin] Slow tool: ${invocation.name} ${status} after ${(execElapsed / 1000).toFixed(1)}s${preview ? ` — ${preview.slice(0, 80)}` : ''}`);
             }
             // Persist large results to disk with preview.

package/dist/agent/tokens.js

@@ -45,6 +45,11 @@ export function updateActualTokens(inputTokens, outputTokens, messageCount) {
  * More accurate than pure estimation because it's grounded in actual API counts.
  */
 export function getAnchoredTokenCount(history) {
+    // The model that just billed input — used as the denominator below.
+    // _currentModel is set per-turn by setEstimationModel(), so it reflects
+    // whatever the router actually resolved (not just config.model, which
+    // may be a routing profile like blockrun/auto).
+    const contextWindow = _currentModel ? getContextWindow(_currentModel) : 200_000;
     if (lastApiInputTokens > 0 && lastApiMessageCount > 0 && history.length >= lastApiMessageCount) {
         // Sanity check: if history was mutated (compaction, micro-compact), anchor may be stale.
         // Detect by checking if new messages were only appended (length grew), not if content changed.
@@ -60,17 +65,18 @@ export function getAnchoredTokenCount(history) {
             return {
                 estimated: total,
                 apiAnchored: true,
-                contextUsagePct: 0,
+                contextUsagePct: (total / contextWindow) * 100,
             };
         }
         // Too much growth — anchor is unreliable, fall through to estimation
         resetTokenAnchor();
     }
     // No anchor — pure estimation
+    const est = estimateHistoryTokens(history);
     return {
-        estimated: estimateHistoryTokens(history),
+        estimated: est,
         apiAnchored: false,
-        contextUsagePct: 0,
+        contextUsagePct: (est / contextWindow) * 100,
     };
 }
 /**
@@ -115,10 +121,40 @@ function estimateContentPartTokens(part) {
             // +16 tokens for tool_use framing (type, id, name fields, JSON structure)
             return 16 + estimateTokens(part.name) + estimateTokens(JSON.stringify(part.input), 2);
         case 'tool_result': {
-            const content = typeof part.content === 'string'
-                ? part.content
-                : JSON.stringify(part.content);
-            return estimateTokens(content, 2);
+            // String content: count as text directly.
+            if (typeof part.content === 'string') {
+                return estimateTokens(part.content, 2);
+            }
+            // Array content: sum block-by-block. CRITICAL: image blocks must
+            // NOT go through JSON.stringify — their base64 `data` field would
+            // be tokenized as text (a 100KB image → ~70k phantom tokens),
+            // which is what made the context ring read ~86% on a 2-image chat
+            // and triggered premature /compact loops. Anthropic actually
+            // bills (w*h)/750 per image, ≈1100-1500 for typical sizes; a flat
+            // 1500-token estimate is close enough without needing to decode
+            // the image dimensions client-side.
+            let total = 0;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const blocks = part.content;
+            for (const block of blocks) {
+                const blockType = block?.type;
+                if (blockType === 'text') {
+                    total += estimateTokens(block?.text ?? '', 2);
+                }
+                else if (blockType === 'image') {
+                    total += 1500;
+                }
+                else {
+                    // Unknown block — stringify minus any nested base64 data field
+                    // to avoid the same blow-up for future block kinds.
+                    const sanitized = { ...block };
+                    if (sanitized?.source && typeof sanitized.source === 'object' && sanitized.source.data) {
+                        sanitized.source = { ...sanitized.source, data: '<bytes>' };
+                    }
+                    total += estimateTokens(JSON.stringify(sanitized), 2);
+                }
+            }
+            return total;
         }
         case 'thinking':
             return estimateTokens(part.thinking);

package/dist/logger.js

@@ -86,7 +86,22 @@ function writeFile(level, msg) {
             writesSinceRotateProbe = 0;
             maybeRotate();
         }
-        const clean = msg.replace(ANSI_RE, '');
+        // Two-step sanitize, in this order:
+        //   1. Collapse embedded newlines (\n / \r / \r\n) to a literal
+        //      " ↵ " marker so a single logger call always produces one
+        //      physical log line.
+        //   2. Strip ANSI escape sequences.
+        //
+        // Order matters: ANSI_RE strips bare \r (used by progress bars), so
+        // running it first would erase \r-only line breaks and let
+        // "first\rsecond" appear as "firstsecond" in the log. Verified
+        // 2026-05-12 from franklin-debug.log: a `Slow tool: Bash ok ...
+        // python3 -c "` preview leaked `import subprocess` onto its own
+        // untimestamped line because the embedded \n in the bash command
+        // survived the preview slice and broke any parser that splits on
+        // ^\[timestamp\]. Cheaper to enforce one-line-per-entry here than
+        // to police every callsite.
+        const clean = msg.replace(/\r\n|\r|\n/g, ' ↵ ').replace(ANSI_RE, '');
         fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] [${level.toUpperCase()}] ${clean}\n`);
     }
     catch { /* best-effort — never break the agent on log failure */ }

package/package.json

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