@blockrun/franklin 3.2.3 → 3.3.0

package/dist/agent/commands.js

@@ -198,7 +198,7 @@ const DIRECT_COMMANDS = {
                 `  **Analysis:** /security /lint /optimize /todo /deps /clean /migrate /doc\n` +
                 `  **Session:** /plan /ultraplan /execute /compact /retry /sessions /resume /context /tasks\n` +
                 `  **Power:** /ultrathink [query] /ultraplan /dump\n` +
-                `  **Info:** /model /wallet /cost /tokens /mcp /doctor /version /bug /help\n` +
+                `  **Info:** /model /wallet /cost /tokens /learnings /mcp /doctor /version /bug /help\n` +
                 `  **UI:** /clear /exit\n` +
                 (ultrathinkOn ? `\n  Ultrathink: ON\n` : '')
         });
@@ -513,6 +513,34 @@ export async function handleSlashCommand(input, ctx) {
         emitDone(ctx);
         return { handled: true };
     }
+    // /learnings — view or clear per-user learnings
+    if (input === '/learnings' || input.startsWith('/learnings ')) {
+        const { loadLearnings, decayLearnings, saveLearnings } = await import('../learnings/store.js');
+        const arg = input.slice('/learnings'.length).trim();
+        if (arg === 'clear') {
+            saveLearnings([]);
+            ctx.onEvent({ kind: 'text_delta', text: 'All learnings cleared.\n' });
+        }
+        else {
+            let learnings = loadLearnings();
+            if (learnings.length === 0) {
+                ctx.onEvent({ kind: 'text_delta', text: 'No learnings yet. Franklin learns your preferences over time.\n' });
+            }
+            else {
+                learnings = decayLearnings(learnings);
+                const sorted = [...learnings].sort((a, b) => (b.confidence * b.times_confirmed) - (a.confidence * a.times_confirmed));
+                let text = `**Personal Learnings** (${sorted.length})\n\n`;
+                for (const l of sorted) {
+                    const conf = l.confidence >= 0.8 ? 'high' : l.confidence >= 0.5 ? 'mid' : 'low';
+                    text += `  [${conf}] ${l.learning} (×${l.times_confirmed})\n`;
+                }
+                text += '\nUse `/learnings clear` to reset.\n';
+                ctx.onEvent({ kind: 'text_delta', text });
+            }
+        }
+        emitDone(ctx);
+        return { handled: true };
+    }
     // /model — show current model or switch with /model <name>
     if (input === '/model' || input.startsWith('/model ')) {
         if (input === '/model') {
@@ -523,6 +551,7 @@ export async function handleSlashCommand(input, ctx) {
         else {
             const newModel = resolveModel(input.slice(7).trim());
             ctx.config.model = newModel;
+            ctx.config.onModelChange?.(newModel);
             ctx.onEvent({ kind: 'text_delta', text: `Model → **${newModel}**\n` });
         }
         emitDone(ctx);

package/dist/agent/context.js

@@ -5,6 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
+import { loadLearnings, decayLearnings, saveLearnings, formatForPrompt } from '../learnings/store.js';
 // ─── System Instructions Assembly ──────────────────────────────────────────
 const BASE_INSTRUCTIONS = `You are runcode, an AI coding agent that helps users with software engineering tasks.
 You have access to tools for reading, writing, editing files, running shell commands, searching codebases, web browsing, and more.
@@ -57,6 +58,18 @@ export function assembleInstructions(workingDir) {
     if (gitInfo) {
         parts.push(`# Git Context\n\n${gitInfo}`);
     }
+    // Inject per-user learnings from self-evolution system
+    try {
+        let learnings = loadLearnings();
+        if (learnings.length > 0) {
+            learnings = decayLearnings(learnings);
+            saveLearnings(learnings);
+            const personalContext = formatForPrompt(learnings);
+            if (personalContext)
+                parts.push(personalContext);
+        }
+    }
+    catch { /* learnings are optional — never block startup */ }
     _instructionCache.set(workingDir, parts);
     return parts;
 }

package/dist/agent/permissions.js

@@ -8,12 +8,12 @@ import readline from 'node:readline';
 import chalk from 'chalk';
 import { BLOCKRUN_DIR } from '../config.js';
 // ─── Default Rules ─────────────────────────────────────────────────────────
-const READ_ONLY_TOOLS = new Set(['Read', 'Glob', 'Grep', 'WebSearch', 'Task', 'AskUser', 'ImageGen']);
+const READ_ONLY_TOOLS = new Set(['Read', 'Glob', 'Grep', 'WebSearch', 'Task', 'AskUser', 'ImageGen', 'TradingSignal', 'TradingMarket', 'SearchX']);
 const DESTRUCTIVE_TOOLS = new Set(['Write', 'Edit', 'Bash']);
 const DEFAULT_RULES = {
-    allow: ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task', 'AskUser', 'ImageGen'],
+    allow: ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task', 'AskUser', 'ImageGen', 'TradingSignal', 'TradingMarket', 'SearchX'],
     deny: [],
-    ask: ['Write', 'Edit', 'Bash', 'Agent'],
+    ask: ['Write', 'Edit', 'Bash', 'Agent', 'PostToX'],
 };
 // ─── Permission Manager ────────────────────────────────────────────────────
 export class PermissionManager {

package/dist/banner.js

@@ -2,47 +2,38 @@ import chalk from 'chalk';
 // ─── Ben Franklin portrait ─────────────────────────────────────────────────
 //
 // Generated once, at build time, from the Joseph Duplessis 1785 oil painting
-// of Benjamin Franklin (same source used for the engraving on the US $100
-// bill). Public domain image from Wikimedia Commons:
+// of Benjamin Franklin (same source as the portrait on the US $100 bill).
+// Public domain image from Wikimedia Commons:
 //   https://commons.wikimedia.org/wiki/File:BenFranklinDuplessis.jpg
 //
 // Pipeline:
-//   1. Crop the 2403×2971 original to a 1400×1400 square centred on the face
-//      (sips --cropToHeightWidth 1400 1400 --cropOffset 400 500)
-//   2. Convert with ascii-image-converter in braille mode:
-//      ascii-image-converter ben-face.jpg --dimensions 34,16 --braille \
-//        --threshold 110
+//   1. Crop the 800×989 thumb to a 500×500 square centred on the face
+//      (sips --cropToHeightWidth 500 500 --cropOffset 140 150)
+//   2. Convert via chafa:
+//      chafa --size=16x8 --symbols=block --colors=full ben-face.jpg
+//   3. Strip cursor visibility control codes (\x1b[?25l / \x1b[?25h)
+//   4. Paste here as hex-escaped string array (readable + diff-friendly)
 //
-// Braille characters (U+2800..U+28FF) encode 2×4 dot matrices per cell, so
-// a 34×16 braille output gives 68×64 = 4,352 effective "pixels" — 2.7× the
-// resolution of chafa half-block mode at the same visible size. For a face,
-// which is all about silhouette + key features, this is a massive win.
+// Visible dimensions: ~16 characters wide × 8 rows tall.
 //
-// The output is pure Unicode — no ANSI escape codes, no color tinting baked
-// in — which means it's trivial to wrap in chalk.hex() at render time for
-// brand tinting, and it ships as a clean readable TS array.
+// Rendered best in a 256-color or truecolor terminal. Degrades gracefully
+// on ancient terminals — but those are long gone and we don't support them.
 const BEN_PORTRAIT_ROWS = [
-    '⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣤⣴⣶⣶⣦⣤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣿⣿⠁⣀⠀⠉⣿⣿⣿⠋⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⢀⠀⢠⣿⣿⣿⣾⣤⣴⣴⣿⣿⣷⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⢠⡄⠀⠀⠁⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄⢾⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠸⡔⠂⠀⠀⠘⣿⣿⣿⣿⣿⣿⣿⣿⣛⣛⠛⠁⠈⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣿⣿⣿⣿⣿⣿⢿⣿⠿⢷⠄⠀⠙⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣿⣿⡿⣿⡿⣿⣏⠛⠛⠙⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⠀⠀⡴⠺⠖⢒⣂⢄⡀⣹⣿⣿⣿⣶⣙⠂⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⣶⣤⣄⡀⠈⠻⠿⡙⠗⠸⡻⣿⡻⣿⣿⣷⣦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⣿⡟⠻⣿⣦⡀⠀⢁⡆⠀⠹⢿⣿⣮⣟⠿⣿⠏⠀⠀⣀⣴⣶⣦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀',
-    '⣿⣷⣄⠈⠿⣷⡀⣾⣿⡀⢦⢸⣿⡹⣿⣿⡆⣤⡐⠻⡻⣿⣿⣿⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀',
+    '\x1b[0m\x1b[38;2;7;0;0;48;2;8;0;0m▔ \x1b[38;2;9;1;0m▂\x1b[38;2;56;36;15;48;2;11;2;0m▗\x1b[38;2;100;73;36;48;2;31;16;6m▅\x1b[38;2;189;141;75;48;2;117;87;43m▅\x1b[38;2;217;162;85;48;2;152;111;51m▆\x1b[38;2;164;122;64;48;2;215;158;85m▔\x1b[38;2;124;90;46;48;2;217;160;93m▔\x1b[38;2;185;136;75;48;2;77;48;20m▅\x1b[38;2;100;61;24;48;2;39;18;4m▖\x1b[38;2;48;26;9;48;2;32;13;3m▃\x1b[38;2;39;18;4;48;2;30;11;2m▄\x1b[38;2;38;17;4;48;2;32;13;3m▄\x1b[38;2;40;20;5;48;2;35;15;2m▃\x1b[38;2;41;21;5;48;2;36;16;3m▂\x1b[0m',
+    '\x1b[7m\x1b[38;2;8;0;0m \x1b[0m\x1b[38;2;0;0;0;48;2;8;0;0m \x1b[38;2;13;2;1;48;2;45;26;10m▊\x1b[38;2;61;40;17;48;2;87;63;31m▎\x1b[38;2;88;61;29;48;2;134;94;42m▋\x1b[38;2;182;132;66;48;2;223;172;93m▏\x1b[38;2;140;91;38;48;2;233;193;106m▂\x1b[38;2;135;82;35;48;2;229;178;106m▂\x1b[38;2;201;145;78;48;2;223;166;95m▂\x1b[38;2;133;88;46;48;2;198;148;86m▁\x1b[38;2;144;96;47;48;2;96;57;21m▍\x1b[38;2;66;42;15;48;2;58;33;11m▗\x1b[38;2;59;36;13;48;2;47;25;9m▆\x1b[38;2;57;35;11;48;2;46;24;7m▅\x1b[38;2;58;36;11;48;2;50;29;8m▖\x1b[38;2;53;32;8;48;2;48;26;7m▃\x1b[0m',
+    '\x1b[38;2;12;3;3;48;2;9;0;0m▁\x1b[38;2;102;76;40;48;2;19;8;4m▗\x1b[38;2;110;83;45;48;2;56;35;15m▄\x1b[38;2;91;67;37;48;2;105;79;45m▌\x1b[38;2;96;64;31;48;2;186;135;70m▊\x1b[38;2;226;169;101;48;2;217;162;91m▗\x1b[38;2;216;159;89;48;2;144;93;44m▅\x1b[38;2;195;145;83;48;2;112;62;24m▅\x1b[38;2;233;178;110;48;2;206;151;81m▆\x1b[38;2;207;155;92;48;2;105;61;30m▎\x1b[38;2;145;94;46;48;2;94;50;19m▖\x1b[38;2;90;48;17;48;2;52;26;8m▎\x1b[38;2;59;33;9;48;2;64;40;14m▖\x1b[38;2;63;39;13;48;2;65;41;13m▊\x1b[38;2;58;36;11;48;2;64;40;14m▝\x1b[38;2;60;38;13;48;2;57;35;10m▍\x1b[0m',
+    '\x1b[38;2;37;22;12;48;2;11;2;2m▕\x1b[38;2;52;32;16;48;2;94;67;32m▘\x1b[38;2;77;53;21;48;2;125;96;52m▗\x1b[38;2;44;15;6;48;2;83;48;21m▞\x1b[38;2;122;73;33;48;2;195;138;72m▍\x1b[38;2;209;149;77;48;2;223;160;89m▋\x1b[38;2;228;157;84;48;2;234;173;98m▆\x1b[38;2;207;140;80;48;2;225;167;96m▝\x1b[38;2;213;151;88;48;2;193;135;79m▏\x1b[38;2;164;111;60;48;2;104;54;21m▍\x1b[38;2;175;110;52;48;2;136;78;32m▘\x1b[38;2;93;47;15;48;2;26;5;2m▎\x1b[38;2;39;13;4;48;2;54;28;8m▍\x1b[38;2;63;40;13;48;2;67;44;16m▔\x1b[38;2;68;44;15;48;2;65;41;16m▊\x1b[38;2;60;36;11;48;2;63;39;14m▝\x1b[0m',
+    '\x1b[38;2;12;1;0;48;2;55;33;13m▌\x1b[38;2;92;63;32;48;2;68;43;17m▝\x1b[38;2;75;51;24;48;2;93;65;34m▗\x1b[38;2;88;61;30;48;2;42;18;8m▘\x1b[38;2;62;35;18;48;2;191;150;83m▍\x1b[38;2;186;140;75;48;2;194;138;63m▁\x1b[38;2;189;130;61;48;2;219;157;79m▄\x1b[38;2;191;132;70;48;2;217;159;87m▂\x1b[38;2;179;105;60;48;2;207;146;83m▔\x1b[38;2;171;106;51;48;2;135;79;32m▋\x1b[38;2;64;30;8;48;2;120;69;27m▗\x1b[38;2;56;26;8;48;2;39;13;5m▂\x1b[38;2;44;18;7;48;2;72;44;16m▘\x1b[38;2;72;47;18;48;2;69;44;14m▖\x1b[38;2;70;46;14;48;2;68;44;14m▁\x1b[38;2;65;41;12;48;2;65;41;14m▘\x1b[0m',
+    '\x1b[38;2;77;56;35;48;2;22;8;3m▂\x1b[38;2;126;100;69;48;2;59;36;15m▃\x1b[38;2;131;105;70;48;2;80;54;27m▄\x1b[38;2;128;103;68;48;2;57;33;14m▄\x1b[38;2;191;174;117;48;2;125;103;69m▝\x1b[38;2;191;164;108;48;2;236;227;160m▞\x1b[38;2;220;202;137;48;2;173;123;63m▃\x1b[38;2;130;85;43;48;2;164;111;58m▄\x1b[38;2;117;68;26;48;2;185;116;58m▆\x1b[38;2;135;80;33;48;2;94;52;15m▘\x1b[38;2;51;28;9;48;2;80;50;16m▂\x1b[38;2;62;33;9;48;2;76;46;14m▘\x1b[38;2;75;50;16;48;2;74;47;15m▗\x1b[38;2;71;46;14;48;2;72;47;15m▝\x1b[38;2;73;48;16;48;2;69;44;14m▏\x1b[38;2;65;41;11;48;2;66;41;15m▆\x1b[0m',
+    '\x1b[38;2;125;101;70;48;2;159;129;87m▔\x1b[38;2;145;114;71;48;2;124;100;70m▆\x1b[38;2;152;123;81;48;2;121;100;69m▃\x1b[38;2;117;95;60;48;2;129;106;70m▖\x1b[38;2;115;91;61;48;2;131;105;69m▗\x1b[38;2;166;145;103;48;2;140;113;71m▔\x1b[38;2;162;135;87;48;2;231;217;147m▅\x1b[38;2;133;107;71;48;2;199;171;110m▂\x1b[38;2;131;100;59;48;2;107;75;37m▍\x1b[38;2;166;139;88;48;2;67;40;14m▃\x1b[38;2;204;179;121;48;2;39;19;8m▄\x1b[38;2;137;112;73;48;2;52;28;10m▖\x1b[38;2;54;32;10;48;2;76;49;16m▅\x1b[38;2;56;33;9;48;2;74;48;15m▃\x1b[38;2;60;37;10;48;2;70;47;14m▁\x1b[38;2;66;43;12;48;2;64;40;11m▅\x1b[0m',
+    '\x1b[38;2;157;128;85;48;2;167;138;98m▝\x1b[38;2;141;111;71;48;2;166;136;98m▝\x1b[38;2;149;119;83;48;2;126;96;60m▞\x1b[38;2;157;129;93;48;2;139;113;81m▅\x1b[38;2;144;117;79;48;2;117;92;58m▋\x1b[38;2;130;102;62;48;2;169;138;87m▋\x1b[38;2;171;141;87;48;2;143;117;77m▖\x1b[38;2;144;117;79;48;2;122;96;63m▊\x1b[38;2;132;105;68;48;2;144;117;82m▖\x1b[38;2;153;127;92;48;2;140;115;83m▞\x1b[38;2;134;108;71;48;2;217;193;135m▅\x1b[38;2;176;150;98;48;2;129;105;66m▋\x1b[38;2;118;94;61;48;2;54;32;14m▂\x1b[38;2;44;23;8;48;2;59;37;13m▃\x1b[38;2;62;41;16;48;2;48;26;9m▖\x1b[38;2;46;24;6;48;2;66;42;15m▖\x1b[0m',
 ];
 // ─── FRANKLIN text banner (gold → emerald gradient) ────────────────────────
 //
-// Kept from v3.1.0. 6 block-letter rows, each tinted with an interpolated
-// colour between GOLD_START and EMERALD_END for a smooth vertical gradient.
+// Kept from v3.1.0. The text is laid out as 6 block-letter rows. Each row
+// is tinted with a color interpolated between GOLD_START and EMERALD_END,
+// giving the smooth vertical gradient that's been Franklin's banner since
+// v3.1.0.
 const FRANKLIN_ART = [
     ' ███████╗██████╗  █████╗ ███╗   ██╗██╗  ██╗██╗     ██╗███╗   ██╗',
     ' ██╔════╝██╔══██╗██╔══██╗████╗  ██║██║ ██╔╝██║     ██║████╗  ██║',
@@ -72,19 +63,23 @@ function interpolateHex(start, end, t) {
 }
 // ─── Banner layout ─────────────────────────────────────────────────────────
 // Minimum terminal width to show the side-by-side portrait + text layout.
-// Portrait: 34 cols braille, FRANKLIN text: ~65 cols, gap: 3 cols,
-// total: ~102 cols. Add a 3-col margin of safety → 105.
-const MIN_WIDTH_FOR_PORTRAIT = 105;
+// The portrait is ~16 chars, the FRANKLIN text is ~65 chars, plus a 3-char
+// gap = 84 chars. We round up to 85 cols as the threshold.
+const MIN_WIDTH_FOR_PORTRAIT = 85;
 /**
- * Pad a line to an exact visual width. Braille characters have no ANSI
- * escape codes and are all 1 cell wide, so this is a straightforward
- * codepoint count.
+ * Pad a line to an exact visual width, ignoring ANSI escape codes when
+ * measuring. Used to align the portrait's right edge before the text block.
  */
-function padBraillePortrait(s, targetWidth) {
-    const current = [...s].length;
+function padVisible(s, targetWidth) {
+    // Strip ANSI color codes to measure visible length
+    // eslint-disable-next-line no-control-regex
+    const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+    // Unicode block characters are width 1 (they're half-blocks, not double-width)
+    const current = [...visible].length;
     if (current >= targetWidth)
         return s;
-    return s + ' '.repeat(targetWidth - current);
+    // Append a reset + padding so background colors don't bleed into the gap
+    return s + '\x1b[0m' + ' '.repeat(targetWidth - current);
 }
 export function printBanner(version) {
     const termWidth = process.stdout.columns ?? 80;
@@ -97,42 +92,30 @@ export function printBanner(version) {
     }
 }
 /**
- * Full layout: Ben Franklin braille portrait on the left, FRANKLIN gradient
- * text on the right. Portrait is 16 rows × 34 cols, text is 6 rows + 1-row
- * tagline. Text starts at portrait row 5 so the FRANKLIN block aligns with
- * Ben's face region (head at rows 1-4, face at rows 5-10, shoulders 11-16),
- * giving the classic "portrait and nameplate" composition.
+ * Full layout: Ben Franklin portrait on the left, FRANKLIN text block on the
+ * right. Portrait is 8 rows × ~16 chars, text is 6 rows — text is vertically
+ * centred inside the portrait with 1 row of padding above.
  *
- *   row  1   ⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣤⣴⣶⣶⣦⣤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
- *   row  2   ⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣿⣿⣿⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀
- *   row  3   ⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠀⠀⠀⠀⠀⠀⠀
- *   row  4   ⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡆⠀⠀⠀⠀⠀⠀
- *   row  5   ⠀⠀⠀⠀⠀⠀⠀⢀⣿⣿⣿⠁...         ███████╗██████╗  █████╗ ...
- *   row  6   ⠀⠀⠀⠀⠀⠀⠀⢠⣿⣿⣿⣾...         ██╔════╝██╔══██╗██╔══██╗...
- *   row  7   ⠀⠀⠀⢠⡄⠀⠀⠀⢀⣾⣿...            █████╗  ██████╔╝███████║...
- *   row  8   ⠀⠀⠀⠸⡔⠂⠀⠀⠘⣿⣿...            ██╔══╝  ██╔══██╗██╔══██║...
- *   row  9   ⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣿...            ██║     ██║  ██║██║  ██║...
- *   row 10   ⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿...            ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝...
- *   row 11   ⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣿...            blockrun.ai · The AI agent with a wallet · vX
- *   row 12   ⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣿...
- *   row 13-16: neck, collar, body
+ *   [portrait row 1]                (empty)
+ *   [portrait row 2]   ███████╗██████╗  █████╗ ...
+ *   [portrait row 3]   ██╔════╝██╔══██╗██╔══██╗...
+ *   [portrait row 4]   █████╗  ██████╔╝███████║...
+ *   [portrait row 5]   ██╔══╝  ██╔══██╗██╔══██║...
+ *   [portrait row 6]   ██║     ██║  ██║██║  ██║...
+ *   [portrait row 7]   ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝...
+ *   [portrait row 8]   blockrun.ai · The AI agent with a wallet · vX
  */
 function printSideBySide(version) {
-    const TEXT_TOP_OFFSET = 4; // text block starts at portrait row 5 (0-indexed row 4)
-    const PORTRAIT_WIDTH = 35; // 34 cols braille + 1 trailing space
-    const GAP = '  ';
+    const TEXT_TOP_OFFSET = 1; // rows of portrait above the text
+    const PORTRAIT_WIDTH = 17; // columns (char width) of the portrait + 1 pad
+    const GAP = '  '; // gap between portrait and text
     const portraitRows = BEN_PORTRAIT_ROWS;
     const textRows = FRANKLIN_ART.length;
     const totalRows = Math.max(portraitRows.length, TEXT_TOP_OFFSET + textRows + 2);
-    // Tint the braille portrait in dim white for a "pencil portrait" feel.
-    // Braille chars carry no colour on their own — chalk wraps them in an
-    // ANSI colour sequence at render time.
-    const portraitTint = chalk.hex('#E8E8E8');
     for (let i = 0; i < totalRows; i++) {
-        const rawPortraitLine = i < portraitRows.length
-            ? padBraillePortrait(portraitRows[i], PORTRAIT_WIDTH)
+        const portraitLine = i < portraitRows.length
+            ? padVisible(portraitRows[i], PORTRAIT_WIDTH)
             : ' '.repeat(PORTRAIT_WIDTH);
-        const portraitLine = portraitTint(rawPortraitLine);
         // Text column content
         let textCol = '';
         const textIdx = i - TEXT_TOP_OFFSET;
@@ -144,21 +127,24 @@ function printSideBySide(version) {
         }
         else if (textIdx === textRows) {
             // Tagline row sits right under the FRANKLIN block.
-            // The big block-letter FRANKLIN above already says the product name
-            // — the tagline uses that line for the parent brand URL
-            // (blockrun.ai — a real live domain; see v3.1.0 notes for why
-            // franklin.run is explicitly NOT used here).
+            // The big block-letter "FRANKLIN" above already says the product
+            // name — the tagline uses that real estate for the parent brand URL
+            // (blockrun.ai, which is a real live domain — unlike franklin.run
+            // which we own but haven't deployed yet, see v3.1.0 changelog).
             textCol =
                 chalk.bold.hex(GOLD_START)('  blockrun.ai') +
                     chalk.dim('  ·  The AI agent with a wallet  ·  v' + version);
         }
-        process.stdout.write(portraitLine + GAP + textCol + '\n');
+        // Write with a reset at the very start to prevent stray bg from the
+        // previous line bleeding into the current row's portrait column.
+        process.stdout.write('\x1b[0m' + portraitLine + GAP + textCol + '\x1b[0m\n');
     }
+    // Trailing blank line for breathing room
     process.stdout.write('\n');
 }
 /**
  * Compact layout for narrow terminals: just the FRANKLIN text block with
- * its gradient, no portrait.
+ * its gradient, no portrait. Matches the v3.1.0 banner exactly.
  */
 function printTextOnly(version) {
     const textRows = FRANKLIN_ART.length;

package/dist/commands/start.js

@@ -53,13 +53,22 @@ export async function startCommand(options) {
     printBanner(version);
     const workDir = process.cwd();
     // Show session info immediately, fetch balance in background
-    console.log(chalk.dim(`  Model:  ${model}`));
+    // Model is shown in the live status bar — no static line needed.
     console.log(chalk.dim(`  Wallet: ${walletAddress || 'not set'}`));
     console.log(chalk.dim(`  Dir:    ${workDir}`));
     // First-run tip: show if no config file exists yet
     if (!configModel && !options.model) {
         console.log(chalk.dim(`\n  Tip: /model to switch models · /compact to save tokens · /help for all commands`));
     }
+    // Welcome message — show things Hermes/OpenClaw can't do.
+    // Only on first run or when no model is configured (new user indicator).
+    // After the user's first session, the tip fades and they go straight to the prompt.
+    console.log('');
+    console.log(chalk.dim('  Try something only Franklin can do:'));
+    console.log(chalk.dim('    ') + chalk.hex('#FFD700')('"what\'s BTC looking like today?"') + chalk.dim('       ← live market signal'));
+    console.log(chalk.dim('    ') + chalk.hex('#10B981')('"find X posts about ai agent"') + chalk.dim(' ← social growth'));
+    console.log(chalk.dim('    ') + chalk.hex('#60A5FA')('"generate a hero image for my app"') + chalk.dim('      ← AI image gen'));
+    console.log(chalk.dim('  Or just code — 55+ models ready, no API keys needed.'));
     console.log('');
     // Balance fetcher — used at startup and after each turn
     const fetchBalance = async () => {
@@ -130,6 +139,14 @@ export async function startCommand(options) {
         permissionMode: (options.trust || !process.stdin.isTTY) ? 'trust' : 'default',
         debug: options.debug,
     };
+    // Bootstrap learnings from Claude Code config on first run (async, non-blocking)
+    Promise.all([
+        import('../learnings/extractor.js'),
+        import('../agent/llm.js'),
+    ]).then(([{ bootstrapFromClaudeConfig }, { ModelClient }]) => {
+        const client = new ModelClient({ apiUrl, chain });
+        bootstrapFromClaudeConfig(client).catch(() => { });
+    }).catch(() => { });
     // Use Ink UI if TTY, fallback to basic readline for piped input
     if (process.stdin.isTTY) {
         await runWithInkUI(agentConfig, model, workDir, version, walletInfo, (cb) => {
@@ -167,8 +184,9 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
             fetchBalance().then(bal => ui.updateBalance(bal)).catch(() => { });
         });
     }
+    let sessionHistory;
     try {
-        await interactiveSession(agentConfig, async () => {
+        sessionHistory = await interactiveSession(agentConfig, async () => {
             const input = await ui.waitForInput();
             if (input === null)
                 return null;
@@ -184,6 +202,19 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     }
     ui.cleanup();
     flushStats();
+    // Extract learnings from the session (async, 10s timeout, never blocks exit)
+    if (sessionHistory && sessionHistory.length >= 4) {
+        try {
+            const { extractLearnings } = await import('../learnings/extractor.js');
+            const { ModelClient } = await import('../agent/llm.js');
+            const client = new ModelClient({ apiUrl: agentConfig.apiUrl, chain: agentConfig.chain });
+            await Promise.race([
+                extractLearnings(sessionHistory, `session-${new Date().toISOString()}`, client),
+                new Promise(resolve => setTimeout(resolve, 10_000)),
+            ]);
+        }
+        catch { /* extraction is best-effort */ }
+    }
     await disconnectMcpServers();
     console.log(chalk.dim('\nGoodbye.\n'));
 }

package/dist/events/bridge.d.ts

@@ -0,0 +1 @@
+export declare function initBridge(): void;

package/dist/events/bridge.js

@@ -0,0 +1,24 @@
+import { bus } from './bus.js';
+import { addSignal, addPost } from '../narrative/state.js';
+export function initBridge() {
+    bus.on('signal.detected', (event) => {
+        const e = event;
+        addSignal({
+            asset: e.data.asset,
+            direction: e.data.direction,
+            confidence: e.data.confidence,
+            summary: e.data.summary,
+            ts: e.ts,
+        });
+    });
+    bus.on('post.published', (event) => {
+        const e = event;
+        addPost({
+            platform: e.data.platform,
+            url: e.data.url,
+            text: e.data.text,
+            referencesAssets: e.data.referencesAssets,
+            ts: e.ts,
+        });
+    });
+}

package/dist/events/bus.d.ts

@@ -0,0 +1,17 @@
+import type { FranklinEvent } from './types.js';
+type Handler = (event: FranklinEvent) => void | Promise<void>;
+export declare class EventBus {
+    private handlers;
+    private logEnabled;
+    private logPath;
+    constructor(opts?: {
+        log?: boolean;
+    });
+    on(type: FranklinEvent['type'], handler: Handler): void;
+    off(type: FranklinEvent['type'], handler: Handler): void;
+    emit(event: FranklinEvent): Promise<void>;
+    clear(): void;
+    private appendLog;
+}
+export declare const bus: EventBus;
+export {};

package/dist/events/bus.js

@@ -0,0 +1,55 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+export class EventBus {
+    handlers = new Map();
+    logEnabled;
+    logPath;
+    constructor(opts = {}) {
+        this.logEnabled = opts.log ?? false;
+        this.logPath = path.join(os.homedir(), '.blockrun', 'events.jsonl');
+    }
+    on(type, handler) {
+        let set = this.handlers.get(type);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(type, set);
+        }
+        set.add(handler);
+    }
+    off(type, handler) {
+        this.handlers.get(type)?.delete(handler);
+    }
+    async emit(event) {
+        if (this.logEnabled) {
+            this.appendLog(event);
+        }
+        const set = this.handlers.get(event.type);
+        if (!set)
+            return;
+        const promises = [];
+        for (const handler of set) {
+            const result = handler(event);
+            if (result)
+                promises.push(result);
+        }
+        if (promises.length)
+            await Promise.all(promises);
+    }
+    clear() {
+        this.handlers.clear();
+    }
+    appendLog(event) {
+        try {
+            const dir = path.dirname(this.logPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.appendFileSync(this.logPath, JSON.stringify(event) + '\n');
+        }
+        catch {
+            // best-effort logging — don't crash the agent
+        }
+    }
+}
+export const bus = new EventBus();

package/dist/events/types.d.ts

@@ -0,0 +1,49 @@
+export interface BaseEvent {
+    id: string;
+    type: string;
+    ts: string;
+    source: 'trading' | 'social' | 'core';
+    costUsd?: number;
+    correlationId?: string;
+}
+export interface SignalDetectedEvent extends BaseEvent {
+    type: 'signal.detected';
+    data: {
+        asset: string;
+        direction: 'bullish' | 'bearish' | 'neutral';
+        confidence: number;
+        indicators: Record<string, number>;
+        summary: string;
+    };
+}
+export interface PostPublishedEvent extends BaseEvent {
+    type: 'post.published';
+    data: {
+        platform: 'x' | 'reddit' | (string & {});
+        url: string;
+        text: string;
+        referencesAssets?: string[];
+    };
+}
+export interface MentionReceivedEvent extends BaseEvent {
+    type: 'mention.received';
+    data: {
+        platform: string;
+        url: string;
+        text: string;
+        author: string;
+        sentiment?: 'positive' | 'negative' | 'neutral';
+        mentionsAsset?: string;
+    };
+}
+export interface BudgetExceededEvent extends BaseEvent {
+    type: 'budget.exceeded';
+    data: {
+        category: 'llm' | 'data' | 'gas';
+        spent: number;
+        cap: number;
+        blockedAction: string;
+    };
+}
+export type FranklinEvent = SignalDetectedEvent | PostPublishedEvent | MentionReceivedEvent | BudgetExceededEvent;
+export declare function makeEvent<T extends FranklinEvent>(props: Omit<T, 'id' | 'ts'>): T;

package/dist/events/types.js

@@ -0,0 +1,8 @@
+import crypto from 'node:crypto';
+export function makeEvent(props) {
+    return {
+        id: crypto.randomUUID(),
+        ts: new Date().toISOString(),
+        ...props,
+    };
+}

package/dist/learnings/extractor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Extract user preferences from a completed session trace.
+ * Uses a cheap model to analyze the conversation and produce learnings.
+ */
+import { ModelClient } from '../agent/llm.js';
+import type { Dialogue } from '../agent/types.js';
+/**
+ * Scan for Claude Code configuration and bootstrap learnings from it.
+ * Only runs once — skips if learnings already exist.
+ */
+export declare function bootstrapFromClaudeConfig(client: ModelClient): Promise<number>;
+/**
+ * Extract learnings from a completed session.
+ * Runs asynchronously — caller should fire-and-forget.
+ */
+export declare function extractLearnings(history: Dialogue[], sessionId: string, client: ModelClient): Promise<void>;