@blockrun/franklin 3.2.4 → 3.3.1

package/dist/agent/commands.js

@@ -196,9 +196,9 @@ const DIRECT_COMMANDS = {
                 `  **Coding:** /commit /review /test /fix /debug /explain /search /find /refactor /scaffold\n` +
                 `  **Git:** /push /pr /undo /status /diff /log /branch /stash /unstash\n` +
                 `  **Analysis:** /security /lint /optimize /todo /deps /clean /migrate /doc\n` +
-                `  **Session:** /plan /ultraplan /execute /compact /retry /sessions /resume /context /tasks\n` +
+                `  **Session:** /plan /ultraplan /execute /compact /retry /sessions /resume /session-search /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` : '')
         });
@@ -350,11 +350,12 @@ const DIRECT_COMMANDS = {
             for (const s of sessions.slice(0, 10)) {
                 const date = new Date(s.updatedAt).toLocaleString();
                 const dir = s.workDir ? ` — ${s.workDir.split('/').pop()}` : '';
-                text += `  ${s.id}  ${s.model}  ${s.turnCount} turns  ${date}${dir}\n`;
+                const current = s.id === ctx.sessionId ? '  (current)' : '';
+                text += `  ${s.id}  ${s.model}  ${s.turnCount} turns  ${date}${dir}${current}\n`;
             }
             if (sessions.length > 10)
                 text += `  ... and ${sessions.length - 10} more\n`;
-            text += '\nUse /resume <session-id> to continue a session.\n';
+            text += '\nUse /resume to restore the latest session, or /resume <session-id> for a specific one.\n';
             ctx.onEvent({ kind: 'text_delta', text });
         }
         emitDone(ctx);
@@ -486,13 +487,17 @@ export async function handleSlashCommand(input, ctx) {
         await DIRECT_COMMANDS[input](ctx);
         return { handled: true };
     }
-    // /search <query> — full-text search past sessions
-    if (input === '/search' || input.startsWith('/search ')) {
-        const query = input === '/search' ? '' : input.slice('/search '.length).trim();
+    // /session-search <query> — full-text search past sessions
+    if (input === '/session-search' ||
+        input.startsWith('/session-search ') ||
+        input === '/ssearch' ||
+        input.startsWith('/ssearch ')) {
+        const prefix = input.startsWith('/ssearch') ? '/ssearch' : '/session-search';
+        const query = input === prefix ? '' : input.slice(prefix.length + 1).trim();
         if (!query) {
-            ctx.onEvent({ kind: 'text_delta', text: 'Usage: /search <query>\n' +
+            ctx.onEvent({ kind: 'text_delta', text: 'Usage: /session-search <query>\n' +
                     'Finds past sessions whose messages match the query.\n' +
-                    'Use quotes for phrase search: /search "payment loop"\n'
+                    'Use quotes for phrase search: /session-search "payment loop"\n'
             });
             emitDone(ctx);
             return { handled: true };
@@ -513,6 +518,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 +556,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);
@@ -604,9 +638,16 @@ export async function handleSlashCommand(input, ctx) {
         emitDone(ctx);
         return { handled: true };
     }
-    // /resume <id>
-    if (input.startsWith('/resume ')) {
-        const targetId = input.slice(8).trim();
+    // /resume or /resume <id>
+    if (input === '/resume' || input.startsWith('/resume ')) {
+        const targetId = input === '/resume'
+            ? listSessions().find((session) => session.id !== ctx.sessionId)?.id ?? ''
+            : input.slice(8).trim();
+        if (!targetId) {
+            ctx.onEvent({ kind: 'text_delta', text: 'No previous session available to resume.\n' });
+            emitDone(ctx);
+            return { handled: true };
+        }
         const restored = loadSessionHistory(targetId);
         if (restored.length === 0) {
             ctx.onEvent({ kind: 'text_delta', text: `Session "${targetId}" not found or empty.\n` });
@@ -636,7 +677,7 @@ export async function handleSlashCommand(input, ctx) {
         ...Object.keys(DIRECT_COMMANDS),
         ...Object.keys(REWRITE_COMMANDS),
         ...ARG_COMMANDS.map(c => c.prefix.trim()),
-        '/branch', '/resume', '/model', '/wallet', '/cost', '/help', '/clear', '/retry', '/exit',
+        '/branch', '/resume', '/model', '/wallet', '/cost', '/help', '/clear', '/retry', '/exit', '/session-search', '/ssearch',
     ];
     const cmd = input.split(/\s/)[0];
     const close = allCommands.filter(c => {

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.
@@ -32,7 +33,24 @@ You have access to tools for reading, writing, editing files, running shell comm
 - **Batch bash**: combine sequential shell commands into one Bash call with && or a script. Only split when you need to inspect intermediate output.
 - **AskUser**: Only use AskUser when you are about to perform a destructive action (deleting files, dropping databases) and need explicit confirmation. NEVER use AskUser to ask what the user wants — just answer their message directly. If their request is vague, make a reasonable assumption and proceed.
 - Never write to /etc, /usr, ~/.ssh, ~/.aws. Don't commit secrets.
-- Type /help to see all slash commands.`;
+- Type /help to see all slash commands.
+
+# Missing Access
+Always deliver results first using whatever tools work (WebSearch, WebFetch, etc.). Never let missing access block you.
+After delivering results, if a better data source exists, add one line at the end:
+"Tip: run franklin social setup && franklin social login x for live X data."
+Do NOT check access before acting. Do NOT explain what you tried. Just deliver, then tip.
+
+# X / Social Marketing
+When the user asks about X posts, trending topics, or social growth:
+1. Search and find relevant posts immediately (WebSearch or SearchX).
+2. Present results as a numbered list of SUGGESTIONS, not actions. Each item must include:
+   - The post author and a short snippet
+   - A clickable link (https://x.com/...)
+   - A suggested reply draft (2-3 sentences, natural tone, not salesy)
+3. End with: "Reply to any of these? Give me the number."
+4. Do NOT auto-post. Do NOT explain how the social system works. Do NOT dump config JSON.
+5. If the user asks to set up X access, ask them simple questions one at a time (handle? product? keywords?) and write the config yourself. Never show raw JSON to the user.`;
 // Cache assembled instructions per workingDir — avoids re-running git commands
 // when sub-agents are spawned (common in parallel tool use patterns).
 const _instructionCache = new Map();
@@ -57,6 +75,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/loop.js

@@ -42,7 +42,21 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     const sessionId = createSessionId();
     let turnCount = 0;
     let tokenBudgetWarned = false; // Emit token budget warning at most once per session
+    let lastSessionActivity = Date.now();
+    const persistSessionMeta = () => {
+        updateSessionMeta(sessionId, {
+            model: config.model,
+            workDir,
+            turnCount,
+            messageCount: history.length,
+        });
+    };
+    const persistSessionMessage = (message) => {
+        appendToSession(sessionId, message);
+        persistSessionMeta();
+    };
     pruneOldSessions(sessionId); // Cleanup old sessions on start, protect current
+    persistSessionMeta();
     while (true) {
         let input = await getUserInput();
         if (input === null)
@@ -72,23 +86,28 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         }
         lastUserInput = input;
         history.push({ role: 'user', content: input });
-        appendToSession(sessionId, { role: 'user', content: input });
         turnCount++;
+        persistSessionMessage({ role: 'user', content: input });
         const abort = new AbortController();
         onAbortReady?.(() => abort.abort());
         let loopCount = 0;
         let recoveryAttempts = 0;
         let compactFailures = 0;
         let maxTokensOverride;
-        let lastActivity = Date.now();
+        const turnIdleReference = lastSessionActivity;
+        lastSessionActivity = Date.now();
         // Agent loop for this user message
         while (loopCount < maxTurns) {
             loopCount++;
+            // Signal UI that a new LLM round is starting (shows spinner between tool results and next response)
+            if (loopCount > 1) {
+                onEvent({ kind: 'thinking_delta', text: '' });
+            }
             // ── Token optimization pipeline ──
             // 1. Strip thinking, budget tool results, time-based cleanup (always — cheap)
             const optimized = optimizeHistory(history, {
                 debug: config.debug,
-                lastActivityTimestamp: lastActivity,
+                lastActivityTimestamp: loopCount === 1 ? turnIdleReference : lastSessionActivity,
             });
             if (optimized !== history) {
                 history.length = 0;
@@ -185,9 +204,12 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 if (err.name === 'AbortError' || abort.signal.aborted) {
                     // Save any partial response that was streamed before abort
                     if (responseParts && responseParts.length > 0) {
-                        history.push({ role: 'assistant', content: responseParts });
-                        appendToSession(sessionId, { role: 'assistant', content: responseParts });
+                        const partialAssistant = { role: 'assistant', content: responseParts };
+                        history.push(partialAssistant);
+                        persistSessionMessage(partialAssistant);
                     }
+                    lastSessionActivity = Date.now();
+                    persistSessionMeta();
                     onEvent({ kind: 'turn_done', reason: 'aborted' });
                     break;
                 }
@@ -249,6 +271,8 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     reason: 'error',
                     error: `[${classified.label}] ${errMsg}${suggestion}`,
                 });
+                lastSessionActivity = Date.now();
+                persistSessionMeta();
                 break;
             }
             // When API doesn't return input tokens (some models return 0), estimate from history
@@ -278,11 +302,16 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     }
                 }
                 // Append what we got + a continuation prompt (text already streamed)
-                history.push({ role: 'assistant', content: responseParts });
-                history.push({
+                const partialAssistant = { role: 'assistant', content: responseParts };
+                const continuationPrompt = {
                     role: 'user',
                     content: 'Continue where you left off. Do not repeat what you already said.',
-                });
+                };
+                history.push(partialAssistant);
+                persistSessionMessage(partialAssistant);
+                history.push(continuationPrompt);
+                persistSessionMessage(continuationPrompt);
+                lastSessionActivity = Date.now();
                 continue; // Retry with higher limit
             }
             // Reset recovery counter on successful completion
@@ -294,17 +323,13 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     invocations.push(part);
                 }
             }
-            history.push({ role: 'assistant', content: responseParts });
+            const assistantMessage = { role: 'assistant', content: responseParts };
+            history.push(assistantMessage);
+            persistSessionMessage(assistantMessage);
             // No more capabilities → done with this user message
             if (invocations.length === 0) {
-                // Save session on completed turn
-                appendToSession(sessionId, { role: 'assistant', content: responseParts });
-                updateSessionMeta(sessionId, {
-                    model: config.model,
-                    workDir: config.workingDir || process.cwd(),
-                    turnCount,
-                    messageCount: history.length,
-                });
+                lastSessionActivity = Date.now();
+                persistSessionMeta();
                 // Token budget warning — emit once per session when crossing 70%
                 if (!tokenBudgetWarned) {
                     const { estimated } = getAnchoredTokenCount(history);
@@ -327,7 +352,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 onEvent({ kind: 'capability_done', id: inv.id, result });
             }
             // Refresh activity timestamp after tool execution
-            lastActivity = Date.now();
+            lastSessionActivity = Date.now();
             // Append outcomes
             const outcomeContent = results.map(([inv, result]) => ({
                 type: 'tool_result',
@@ -335,9 +360,13 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 content: result.output,
                 is_error: result.isError,
             }));
-            history.push({ role: 'user', content: outcomeContent });
+            const toolResultMessage = { role: 'user', content: outcomeContent };
+            history.push(toolResultMessage);
+            persistSessionMessage(toolResultMessage);
         }
         if (loopCount >= maxTurns) {
+            lastSessionActivity = Date.now();
+            persistSessionMeta();
             onEvent({ kind: 'turn_done', reason: 'max_turns' });
         }
     }

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/commands/migrate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * franklin migrate — one-click import from other AI coding agents.
+ *
+ * Detects installed tools (Claude Code, Cline, Cursor, etc.),
+ * shows what can be migrated, and imports with user confirmation.
+ */
+export declare function migrateCommand(): Promise<void>;
+/**
+ * Check if other AI tools are installed and suggest migration.
+ * Only runs once — writes a marker file after first check.
+ * Returns true if the user chose to migrate (caller should re-run start after).
+ */
+export declare function checkAndSuggestMigration(): Promise<boolean>;