@blockrun/franklin 3.6.2 → 3.6.4

package/dist/agent/compact.js

@@ -22,9 +22,9 @@ Critical rules:
 - Preserve EXACT file paths, function names, line numbers, variable names
 - Preserve EXACT error messages and stack traces (verbatim)
 - Preserve user preferences and corrections (especially "don't do X" instructions)
-- Preserve decisions with their rationale (not just the decision)
+- Preserve decisions WITH their rationale — "changed X to Y because Z was broken" (1-2 sentences per decision)
 - Include full code snippets and function signatures when they are load-bearing
-- DO NOT include reasoning that led to decisions — only the decisions themselves
+- DO NOT include verbose reasoning chains — summarize the WHY in 1-2 sentences, not paragraphs
 - DO NOT include pleasantries, meta-commentary, or apologies
 - Use bullet points inside each section
 - Be specific: "edited src/foo.ts:42 to add error handling" not "made some changes"
@@ -46,7 +46,7 @@ Then produce the summary inside <summary> tags using these exact section headers
 [Any errors encountered, their root causes, and how they were resolved — this prevents re-investigating the same issues]
 
 ## Decisions
-[Key decisions made, each with its rationale]
+[Each decision: what was chosen, why, and what constraint/goal drove it. Format: "Chose X over Y because Z." — losing the WHY causes rework later]
 
 ## Files Modified
 [Each file touched, with a one-line description of what changed and why]

package/dist/agent/loop.js

@@ -405,7 +405,15 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             // Create streaming executor for concurrent tool execution
             const streamExec = new StreamingExecutor({
                 handlers: capabilityMap,
-                scope: { workingDir: workDir, abortSignal: abort.signal, onAskUser: config.onAskUser },
+                scope: {
+                    workingDir: workDir,
+                    abortSignal: abort.signal,
+                    onAskUser: config.onAskUser,
+                    parentContext: {
+                        goal: lastUserInput?.slice(0, 200),
+                        recentFiles: [...readFileCache].slice(-10),
+                    },
+                },
                 permissions,
                 guard: toolGuard,
                 onStart: (id, name, preview) => onEvent({ kind: 'capability_start', id, name, preview }),
@@ -634,18 +642,29 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                         console.error(`[franklin] Max tokens hit — escalating to ${maxTokensOverride}`);
                     }
                 }
-                // Append what we got + a continuation prompt (text already streamed)
+                // Append what we got + a continuation prompt with last-line anchor
                 const partialAssistant = { role: 'assistant', content: responseParts };
+                // Extract last line of output to give the model a concrete resume point
+                const textParts = responseParts.filter(p => p.type === 'text');
+                const lastTextBlock = textParts[textParts.length - 1];
+                let lastLineAnchor = '';
+                if (lastTextBlock && lastTextBlock.type === 'text') {
+                    const lastLine = lastTextBlock.text.split('\n').filter(l => l.trim()).pop() ?? '';
+                    if (lastLine.length > 10) {
+                        lastLineAnchor = `\nYour output ended with: "${lastLine.slice(0, 120)}"\nResume immediately after that point.`;
+                    }
+                }
                 const continuationPrompt = {
                     role: 'user',
                     content: [
-                        'Output token limit hit. Continue with these rules:',
-                        '1. Resume directly — no apology, no recap of what you already said. Pick up mid-sentence if that is where the cut happened.',
-                        '2. Do NOT repeat any text or code that was already output above.',
-                        '3. Break remaining work into smaller pieces — use multiple tool calls if needed instead of one large output.',
-                        '4. Skip extended reasoning for the continuation — focus on executing.',
-                        '5. If you were in the middle of outputting code, finish the code block first.',
-                    ].join('\n'),
+                        'Output token limit hit. Continue:',
+                        '1. Resume exactly where you stopped — your prior output is visible above.',
+                        '2. Do NOT repeat, summarize, or recap anything already output.',
+                        '3. If mid-code-block, continue the same block without restarting.',
+                        '4. Prefer tool calls (Write, Edit) over large text output — they are more token-efficient.',
+                        '5. Be concise — skip explanations, focus on completing the work.',
+                        lastLineAnchor,
+                    ].filter(l => l).join('\n'),
                 };
                 history.push(partialAssistant);
                 persistSessionMessage(partialAssistant);

package/dist/agent/types.d.ts

@@ -67,6 +67,11 @@ export interface ExecutionScope {
     onProgress?: (text: string) => void;
     /** Routes AskUser questions through ink UI input to avoid raw-mode stdin conflict */
     onAskUser?: (question: string, options?: string[]) => Promise<string>;
+    /** Context from parent agent — helps sub-agents avoid duplicate work */
+    parentContext?: {
+        goal?: string;
+        recentFiles?: string[];
+    };
 }
 export interface StreamTextDelta {
     kind: 'text_delta';

package/dist/tools/edit.js

@@ -93,7 +93,7 @@ async function execute(input, ctx) {
             const searchTerms = oldStr.split('\n').map(l => l.trim()).filter(l => l.length > 3);
             const matchedLines = [];
             if (searchTerms.length > 0) {
-                for (let i = 0; i < lines.length && matchedLines.length < 5; i++) {
+                for (let i = 0; i < lines.length && matchedLines.length < 8; i++) {
                     if (searchTerms.some(term => lines[i].includes(term))) {
                         matchedLines.push({ num: i + 1, text: lines[i] });
                     }
@@ -101,12 +101,18 @@ async function execute(input, ctx) {
             }
             let hint;
             if (matchedLines.length > 0) {
-                const preview = matchedLines.map(m => `${m.num}\t${m.text}`).join('\n');
-                hint = `\n\nSimilar lines found:\n${preview}\n\nCheck for whitespace or formatting differences.`;
+                // Show matched lines with 1 line of context above for better orientation
+                const preview = matchedLines.map(m => {
+                    const above = m.num > 1 ? `  ${m.num - 1}\t${lines[m.num - 2].slice(0, 80)}\n` : '';
+                    return `${above}→ ${m.num}\t${m.text}`;
+                }).join('\n');
+                hint = `\n\nLines containing fragments of your old_string (${matchedLines.length} found):\n${preview}\n\nThe old_string must match EXACTLY — check indentation, quotes, and whitespace. Use Read to see the full region.`;
             }
             else {
-                const preview = lines.slice(0, 10).map((l, i) => `${i + 1}\t${l}`).join('\n');
-                hint = `\n\nFirst 10 lines of file:\n${preview}`;
+                // No matches — show the middle of the file (more useful than first 10 lines)
+                const mid = Math.max(0, Math.floor(lines.length / 2) - 5);
+                const preview = lines.slice(mid, mid + 12).map((l, i) => `${mid + i + 1}\t${l}`).join('\n');
+                hint = `\n\nNo matching fragments found in ${lines.length}-line file. Lines ${mid + 1}-${mid + 12}:\n${preview}\n\nUse Read to find the correct text.`;
             }
             return {
                 output: `Error: old_string not found in ${resolved}.${hint}`,

package/dist/tools/subagent.js

@@ -24,7 +24,22 @@ async function execute(input, ctx) {
     }
     const toolDefs = subTools.map(c => c.spec);
     const systemInstructions = assembleInstructions(ctx.workingDir);
-    const systemPrompt = systemInstructions.join('\n\n');
+    // Inject parent context so sub-agent avoids duplicate work
+    let parentContextSection = '';
+    if (ctx.parentContext) {
+        const parts = [];
+        if (ctx.parentContext.goal) {
+            parts.push(`Parent task: ${ctx.parentContext.goal}`);
+        }
+        if (ctx.parentContext.recentFiles && ctx.parentContext.recentFiles.length > 0) {
+            parts.push(`Files already read by parent: ${ctx.parentContext.recentFiles.join(', ')}`);
+            parts.push('Do not re-read these files unless you need to verify a change.');
+        }
+        if (parts.length > 0) {
+            parentContextSection = '\n\n# Parent Agent Context\n' + parts.join('\n');
+        }
+    }
+    const systemPrompt = systemInstructions.join('\n\n') + parentContextSection;
     const history = [
         { role: 'user', content: prompt },
     ];

package/dist/tools/task.js

@@ -58,7 +58,25 @@ async function execute(input, _ctx) {
                         blocker.blocks.push(task.id);
                 }
             }
-            return { output: `Updated task #${task.id} status` };
+            // Rich feedback: show status transition and dependency impact
+            let feedback = `Updated task #${task.id}`;
+            if (status) {
+                feedback += ` → ${status}`;
+                // If completed, show which tasks are now unblocked
+                if (status === 'completed' && task.blocks.length > 0) {
+                    const nowUnblocked = task.blocks
+                        .map(id => tasks.find(t => t.id === id))
+                        .filter(t => t && t.blockedBy.every(bid => {
+                        const blocker = tasks.find(bt => bt.id === bid);
+                        return blocker?.status === 'completed';
+                    }))
+                        .map(t => `#${t.id} ${t.subject}`);
+                    if (nowUnblocked.length > 0) {
+                        feedback += ` — unblocked: ${nowUnblocked.join(', ')}`;
+                    }
+                }
+            }
+            return { output: feedback };
         }
         case 'list': {
             if (tasks.length === 0) {

package/dist/tools/websearch.js

@@ -91,6 +91,31 @@ function parseDuckDuckGoResults(html, maxResults) {
             snippet: stripTags(snippet?.[1] || '').trim(),
         });
     }
+    // Last resort: if both parsers failed, extract ANY external links from the page
+    // Partial results are better than "No results found" when the page loaded OK
+    if (results.length === 0) {
+        const allLinks = /<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+        let match;
+        while ((match = allLinks.exec(html)) !== null && results.length < maxResults) {
+            let url = match[1] || '';
+            const text = stripTags(match[2]).trim();
+            // Must be a real external URL with meaningful text
+            if (!text || text.length < 4)
+                continue;
+            if (url.startsWith('/') || url.includes('duckduckgo.com'))
+                continue;
+            // Extract from DDG redirect wrapper
+            const uddg = url.match(/uddg=([^&]+)/);
+            if (uddg)
+                url = decodeURIComponent(uddg[1]);
+            if (!url.startsWith('http'))
+                continue;
+            if (seenUrls.has(url))
+                continue;
+            seenUrls.add(url);
+            results.push({ title: text, url, snippet: '' });
+        }
+    }
     return results;
 }
 function stripTags(html) {

package/dist/ui/app.js

@@ -395,19 +395,22 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
         turnSavingsRef.current = undefined;
         onSubmit(trimmed);
     }, [ready, currentModel, totalCost, onSubmit, onModelChange, onAbort, onExit, exit, lastPrompt, inputHistory, showStatus]);
-    // Mouse support — enable tracking and handle clicks on tool results
+    // Mouse support — clicks toggle tool results, drag selects text
     useEffect(() => {
         const cleanup = mouse.enable();
         const handleClick = (_event) => {
-            // Click anywhere toggles the expandable tool (if one exists)
-            // This is intentionally simple — we don't track exact coordinates of components.
-            // The expandable tool is always the most recent tool result, so any click is a
-            // reasonable toggle target. Tab key remains the precise alternative.
+            // Click: toggle expandable tool
             setExpandableTool(prev => prev ? { ...prev, expanded: !prev.expanded } : null);
         };
+        const handleCopied = (info) => {
+            // Show status when text is copied via drag-select
+            showStatus(`Copied ${info.length} chars to clipboard`, 'success', 2000);
+        };
         mouse.on('click', handleClick);
+        mouse.on('copied', handleCopied);
         return () => {
             mouse.removeListener('click', handleClick);
+            mouse.removeListener('copied', handleCopied);
             cleanup();
         };
     }, []);

package/dist/ui/mouse.d.ts

@@ -1,23 +1,37 @@
 /**
  * Mouse event support for Ink terminal UI.
- * Enables SGR extended mouse tracking (DECSET 1000+1006) and parses events from stdin.
- * Lightweight — only handles clicks, not drag/hover/selection.
+ * - SGR extended mouse tracking (DECSET 1000+1002+1006)
+ * - Click detection (left click → 'click' event)
+ * - Drag detection with text selection (press → motion → release)
+ * - Stdout interception for screen text buffer
+ * - Clipboard copy on drag-select
  */
 import { EventEmitter } from 'node:events';
 export interface MouseEvent {
     button: 'left' | 'middle' | 'right' | 'wheel-up' | 'wheel-down';
-    action: 'press' | 'release';
+    action: 'press' | 'release' | 'drag';
     col: number;
     row: number;
 }
+export interface Selection {
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+    text: string;
+}
 declare class MouseManager extends EventEmitter {
     private enabled;
     private stdinListener;
+    private screen;
+    private dragState;
+    private pressPos;
+    private dragPos;
     /**
-     * Enable mouse tracking. Call once on app startup.
-     * Returns cleanup function to call on unmount.
+     * Enable mouse tracking + screen buffer. Returns cleanup function.
      */
     enable(): () => void;
+    private handleLeftButton;
     /**
      * Disable mouse tracking and clean up.
      */

package/dist/ui/mouse.js

@@ -1,34 +1,162 @@
 /**
  * Mouse event support for Ink terminal UI.
- * Enables SGR extended mouse tracking (DECSET 1000+1006) and parses events from stdin.
- * Lightweight — only handles clicks, not drag/hover/selection.
+ * - SGR extended mouse tracking (DECSET 1000+1002+1006)
+ * - Click detection (left click → 'click' event)
+ * - Drag detection with text selection (press → motion → release)
+ * - Stdout interception for screen text buffer
+ * - Clipboard copy on drag-select
  */
 import { EventEmitter } from 'node:events';
+import { execSync } from 'node:child_process';
 // ─── Terminal escape sequences ────────────────────────────────────────────
 const ENABLE_MOUSE = '\x1b[?1000h' + // Normal mouse tracking (clicks + wheel)
+    '\x1b[?1002h' + // Button-motion tracking (drag events)
     '\x1b[?1006h'; // SGR extended format (readable coordinates)
 const DISABLE_MOUSE = '\x1b[?1006l' +
+    '\x1b[?1002l' +
     '\x1b[?1000l';
 // SGR mouse event format: ESC [ < button ; col ; row M (press) or m (release)
 const SGR_MOUSE_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
-// ─── Mouse Manager ───────────────────────────────────────────────────────
+// Strip ANSI escape sequences to get plain text
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?\x07|\x1b[()][012AB]|\x1b\[[\?=]?\d*[hlJKHfABCDEFGSTm]/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_RE, '');
+}
+// ─── Screen Buffer ───────────────────────────────────────────────────────
+// Lightweight stdout interceptor that captures rendered text lines.
+// Doesn't parse ANSI cursor movement — just stores line content as written.
+class ScreenBuffer {
+    lines = [];
+    maxLines = 500; // ring buffer
+    originalWrite = null;
+    capturing = false;
+    start() {
+        if (this.capturing)
+            return;
+        this.capturing = true;
+        this.lines = [];
+        // Intercept stdout.write to capture rendered text
+        this.originalWrite = process.stdout.write.bind(process.stdout);
+        const self = this;
+        process.stdout.write = function (chunk, ...args) {
+            // Capture the text
+            const text = typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+            self.addText(text);
+            // Pass through to original
+            return self.originalWrite(chunk, ...args);
+        };
+    }
+    stop() {
+        if (!this.capturing)
+            return;
+        this.capturing = false;
+        if (this.originalWrite) {
+            process.stdout.write = this.originalWrite;
+            this.originalWrite = null;
+        }
+    }
+    addText(text) {
+        // Split into lines and store plain text (ANSI stripped)
+        const plain = stripAnsi(text);
+        const newLines = plain.split('\n');
+        for (const line of newLines) {
+            if (line.length > 0) {
+                this.lines.push(line);
+            }
+        }
+        // Cap ring buffer
+        if (this.lines.length > this.maxLines) {
+            this.lines = this.lines.slice(-this.maxLines);
+        }
+    }
+    /**
+     * Get text between two screen coordinates.
+     * Uses the stored text buffer — approximate but good enough for selection.
+     */
+    getTextInRange(startRow, startCol, endRow, endCol) {
+        // Normalize direction
+        let r1 = startRow, c1 = startCol, r2 = endRow, c2 = endCol;
+        if (r1 > r2 || (r1 === r2 && c1 > c2)) {
+            [r1, c1, r2, c2] = [r2, c2, r1, c1];
+        }
+        // Map screen rows to buffer lines
+        // Screen rows are relative to current viewport. Our buffer stores
+        // recent lines. We use terminal rows to estimate offset.
+        const termRows = process.stdout.rows || 24;
+        const bufLen = this.lines.length;
+        // Last N lines correspond to the visible screen
+        const startIdx = Math.max(0, bufLen - termRows + r1);
+        const endIdx = Math.max(0, bufLen - termRows + r2);
+        if (startIdx >= bufLen)
+            return '';
+        const selected = [];
+        for (let i = startIdx; i <= Math.min(endIdx, bufLen - 1); i++) {
+            const line = this.lines[i] || '';
+            if (i === startIdx && i === endIdx) {
+                // Single line selection
+                selected.push(line.slice(c1, c2 + 1));
+            }
+            else if (i === startIdx) {
+                selected.push(line.slice(c1));
+            }
+            else if (i === endIdx) {
+                selected.push(line.slice(0, c2 + 1));
+            }
+            else {
+                selected.push(line);
+            }
+        }
+        return selected.join('\n').trim();
+    }
+}
+// ─── Clipboard ───────────────────────────────────────────────────────────
+function copyToClipboard(text) {
+    if (!text)
+        return false;
+    try {
+        if (process.platform === 'darwin') {
+            execSync('pbcopy', { input: text, timeout: 2000 });
+        }
+        else if (process.platform === 'linux') {
+            // Try xclip first, then xsel
+            try {
+                execSync('xclip -selection clipboard', { input: text, timeout: 2000 });
+            }
+            catch {
+                execSync('xsel --clipboard --input', { input: text, timeout: 2000 });
+            }
+        }
+        else if (process.platform === 'win32') {
+            execSync('clip', { input: text, timeout: 2000 });
+        }
+        else {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 class MouseManager extends EventEmitter {
     enabled = false;
     stdinListener = null;
+    screen = new ScreenBuffer();
+    // Drag state machine
+    dragState = 'idle';
+    pressPos = { row: 0, col: 0 };
+    dragPos = { row: 0, col: 0 };
     /**
-     * Enable mouse tracking. Call once on app startup.
-     * Returns cleanup function to call on unmount.
+     * Enable mouse tracking + screen buffer. Returns cleanup function.
      */
     enable() {
         if (this.enabled)
             return () => { };
         this.enabled = true;
+        // Start screen buffer capture
+        this.screen.start();
         // Write enable sequences
         process.stdout.write(ENABLE_MOUSE);
-        // Listen on stdin for mouse sequences
-        // We use 'data' event at a higher priority than Ink's handler.
-        // Mouse sequences that we parse are still passed to Ink (we can't consume them),
-        // but Ink will ignore unrecognized escape sequences.
         this.stdinListener = (data) => {
             const str = data.toString('utf-8');
             let match;
@@ -41,6 +169,7 @@ class MouseManager extends EventEmitter {
                 // Decode button
                 const baseBtn = btnCode & 0x03;
                 const isWheel = (btnCode & 0x40) !== 0;
+                const isMotion = (btnCode & 0x20) !== 0; // Bit 5 = motion
                 let button;
                 if (isWheel) {
                     button = baseBtn === 0 ? 'wheel-up' : 'wheel-down';
@@ -48,22 +177,70 @@ class MouseManager extends EventEmitter {
                 else {
                     button = baseBtn === 0 ? 'left' : baseBtn === 1 ? 'middle' : 'right';
                 }
-                const event = {
-                    button,
-                    action: isPress ? 'press' : 'release',
-                    col,
-                    row,
-                };
+                const action = isMotion ? 'drag' : (isPress ? 'press' : 'release');
+                const event = { button, action, col, row };
                 this.emit('mouse', event);
-                // Emit convenience events
-                if (button === 'left' && isPress) {
-                    this.emit('click', event);
+                // ── Drag state machine (left button only) ──
+                if (button === 'left') {
+                    this.handleLeftButton(action, row, col);
                 }
             }
         };
         process.stdin.on('data', this.stdinListener);
         return () => this.disable();
     }
+    handleLeftButton(action, row, col) {
+        switch (this.dragState) {
+            case 'idle':
+                if (action === 'press') {
+                    this.dragState = 'pressing';
+                    this.pressPos = { row, col };
+                    this.dragPos = { row, col };
+                }
+                break;
+            case 'pressing':
+                if (action === 'drag') {
+                    // Movement detected — it's a drag, not a click
+                    const dist = Math.abs(row - this.pressPos.row) + Math.abs(col - this.pressPos.col);
+                    if (dist >= 2) { // Threshold to distinguish drag from click
+                        this.dragState = 'dragging';
+                        this.dragPos = { row, col };
+                        this.emit('drag-start', { ...this.pressPos });
+                    }
+                }
+                else if (action === 'release') {
+                    // Press → release without drag = click
+                    this.dragState = 'idle';
+                    this.emit('click', { button: 'left', action: 'press', col, row });
+                }
+                break;
+            case 'dragging':
+                if (action === 'drag') {
+                    this.dragPos = { row, col };
+                    this.emit('drag-move', { row, col });
+                }
+                else if (action === 'release') {
+                    // Drag complete — extract text and copy to clipboard
+                    const text = this.screen.getTextInRange(this.pressPos.row, this.pressPos.col, row, col);
+                    this.dragState = 'idle';
+                    if (text.length > 0) {
+                        const copied = copyToClipboard(text);
+                        const selection = {
+                            startRow: this.pressPos.row,
+                            startCol: this.pressPos.col,
+                            endRow: row,
+                            endCol: col,
+                            text,
+                        };
+                        this.emit('selection', selection);
+                        if (copied) {
+                            this.emit('copied', { text, length: text.length });
+                        }
+                    }
+                }
+                break;
+        }
+    }
     /**
      * Disable mouse tracking and clean up.
      */
@@ -71,16 +248,17 @@ class MouseManager extends EventEmitter {
         if (!this.enabled)
             return;
         this.enabled = false;
+        this.dragState = 'idle';
         if (this.stdinListener) {
             process.stdin.removeListener('data', this.stdinListener);
             this.stdinListener = null;
         }
-        // Best-effort: disable mouse tracking
+        this.screen.stop();
         try {
             process.stdout.write(DISABLE_MOUSE);
         }
         catch {
-            // Ignore write errors during cleanup (stdout may be closed)
+            // Ignore write errors during cleanup
         }
     }
     isEnabled() { return this.enabled; }

package/package.json

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