@blockrun/franklin 3.8.6 → 3.8.8

package/dist/agent/bash-guard.js

@@ -16,8 +16,24 @@ const DANGEROUS_PATTERNS = [
     [/\brm\s+-[a-zA-Z]*[rR][a-zA-Z]*\s+[/~]/, 'recursive delete on root/home'],
     [/\brm\s+-[a-zA-Z]*[rR][a-zA-Z]*f/, 'forced recursive delete'],
     [/\brm\s+-[a-zA-Z]*f[a-zA-Z]*[rR]/, 'forced recursive delete'],
+    [/\brm\s+-[a-zA-Z]*f\s+\//, 'forced delete at filesystem root'],
     [/\bmkfs\b/, 'format filesystem'],
     [/\bdd\s+.*of=/, 'raw disk write'],
+    [/\btruncate\s+-s\s+0\b/, 'truncate file to zero'],
+    [/>\s*\/dev\/(sd|nvme|disk|hd)/, 'write to raw block device'],
+    // Silently overwriting with mv/cp
+    [/\bmv\s+-f\b/, 'mv -f overwrites target silently'],
+    [/\bcp\s+-[a-zA-Z]*f[a-zA-Z]*r/, 'cp -rf can overwrite directory trees silently'],
+    // Writes to system-level paths — most agents should NEVER touch these.
+    // Redirections (`>`, `>>`) or tee'ing to /etc/, /usr/, /boot/, /var/lib/ etc.
+    [/>\s*\/(etc|usr|bin|sbin|boot|lib|lib64|var\/lib|sys|proc)\//, 'write to system path'],
+    [/\btee\s+.*\s+\/(etc|usr|bin|sbin|boot|lib|lib64|var\/lib|sys|proc)\//, 'tee to system path'],
+    // Extract tar/zip at filesystem root — classic traversal foot-gun.
+    [/\btar\s+.*-C\s+\/(?!tmp|var\/tmp|home)/, 'extract archive to system path'],
+    [/\bunzip\s+.*-d\s+\/(?!tmp|var\/tmp|home)/, 'unzip to system path'],
+    // Shell-out of untrusted text
+    [/\beval\s/, 'eval executes arbitrary shell'],
+    [/\bexec\s+(bash|sh|zsh)/, 'exec replaces the shell process'],
     // Git irreversible operations
     [/\bgit\s+push\s+.*--force\b/, 'force push'],
     [/\bgit\s+push\s+-f\b/, 'force push'],
@@ -25,11 +41,14 @@ const DANGEROUS_PATTERNS = [
     [/\bgit\s+clean\s+-[a-zA-Z]*f/, 'git clean — deletes untracked files'],
     [/\bgit\s+checkout\s+--\s+\./, 'discard all working changes'],
     [/\bgit\s+branch\s+-D\b/, 'force delete branch'],
+    [/\bgit\s+filter-(repo|branch)\b/, 'history rewrite'],
     // Database destructive
     [/\bDROP\s+(TABLE|DATABASE|SCHEMA)\b/i, 'drop database objects'],
     [/\bTRUNCATE\s+TABLE\b/i, 'truncate table'],
+    [/\bDELETE\s+FROM\s+\S+\s*;?\s*$/i, 'DELETE without WHERE'],
     // System-level danger
     [/\bchmod\s+(-R\s+)?777\b/, 'world-writable permissions'],
+    [/\bchown\s+-R\s+\S+\s+\//, 'recursive chown at root'],
     // Pipe-to-shell: catch sudo/env prefixes and common shell variants (bash/sh/zsh/ksh/dash/fish).
     // The optional `-e`/`-x` flags after the shell binary are intentionally allowed by \b;
     // what we block is the routing of downloaded content into an interpreter.
@@ -38,11 +57,21 @@ const DANGEROUS_PATTERNS = [
     // Command substitution of a downloader into argv — `$(curl …)` or `` `curl …` ``.
     [/\$\(\s*(curl|wget|fetch)\b/, 'command substitution of network downloader'],
     [/`\s*(curl|wget|fetch)\b[^`]*`/, 'backtick substitution of network downloader'],
+    // Privilege escalation wrappers to destructive ops — order matters: the
+    // specific `sudo rm` pattern is listed first so its tailored message wins.
     [/\bsudo\s+rm\b/, 'sudo delete'],
+    [/\b(sudo|doas|su\s+-c)\s+.*\b(mv|dd|chmod|chown|mkfs|shutdown|reboot)\b/, 'privileged destructive op'],
+    // sed -i (in-place) on any system path
+    [/\bsed\s+-i(\s+'')?\s+.*\/(etc|usr|bin|sbin|boot|lib)\//, 'in-place edit of system path'],
     // Kill/shutdown
     [/\bkill\s+-9\s+-1\b/, 'kill all processes'],
+    [/\bkillall\s/, 'killall targets matching processes globally'],
     [/\bshutdown\b/, 'system shutdown'],
     [/\breboot\b/, 'system reboot'],
+    [/\bpoweroff\b/, 'system poweroff'],
+    // Cryptocurrency key exfiltration / secret exposure
+    [/\bcat\s+.*\.env(\.\w+)?\s*\|/, 'env file piped — potential secret exfiltration'],
+    [/\bcat\s+.*(\.ssh|\.gnupg)\/.*\s*\|/, 'ssh/gpg key piped — potential secret exfiltration'],
 ];
 // ─── Safe Commands ────────────────────────────────────────────────────────
 // If ALL segments use these commands, auto-approve.

package/dist/agent/planner.js

@@ -68,7 +68,7 @@ Rules:
 export function getExecutorModel(profile) {
     switch (profile) {
         case 'premium':
-            return 'moonshot/kimi-k2.5'; // Medium-tier, reliable execution
+            return 'moonshot/kimi-k2.6'; // Medium-tier, reliable execution (256K ctx, vision + reasoning)
         case 'auto':
         default:
             return 'google/gemini-2.5-flash'; // Cheap, fast, good at instructions

package/dist/agent/tokens.js

@@ -190,6 +190,7 @@ const MODEL_CONTEXT_WINDOWS = {
     'xai/grok-4-1-fast-reasoning': 131_072,
     // Others
     'zai/glm-5.1': 200_000,
+    'moonshot/kimi-k2.6': 256_000,
     'moonshot/kimi-k2.5': 128_000,
     'minimax/minimax-m2.7': 128_000,
 };

package/dist/commands/doctor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `franklin doctor` — one-command health check.
+ *
+ * The single highest-leverage onboarding improvement: most early failures
+ * are environmental (Node too old, no wallet, wrong chain, unreachable
+ * gateway, malformed MCP config). `franklin doctor` pokes each of those in
+ * sequence, prints a verdict per check, and exits non-zero if anything is
+ * broken so CI scripts can gate on it.
+ *
+ * Human-readable by default. Pass `--json` for machine-parseable output
+ * (useful for the ink REPL `/doctor` or external monitoring).
+ */
+export declare function doctorCommand(opts?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,251 @@
+/**
+ * `franklin doctor` — one-command health check.
+ *
+ * The single highest-leverage onboarding improvement: most early failures
+ * are environmental (Node too old, no wallet, wrong chain, unreachable
+ * gateway, malformed MCP config). `franklin doctor` pokes each of those in
+ * sequence, prints a verdict per check, and exits non-zero if anything is
+ * broken so CI scripts can gate on it.
+ *
+ * Human-readable by default. Pass `--json` for machine-parseable output
+ * (useful for the ink REPL `/doctor` or external monitoring).
+ */
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { setupAgentWallet, setupAgentSolanaWallet, } from '@blockrun/llm';
+import { loadChain, API_URLS, VERSION, BLOCKRUN_DIR } from '../config.js';
+import { isTelemetryEnabled, readAllRecords } from '../telemetry/store.js';
+async function runChecks() {
+    const out = [];
+    // ── 1. Runtime ────────────────────────────────────────────────────
+    const nodeVer = process.versions.node;
+    const nodeMajor = parseInt(nodeVer.split('.')[0], 10);
+    out.push({
+        name: 'Node.js',
+        status: nodeMajor >= 20 ? 'ok' : 'fail',
+        detail: `${nodeVer}${nodeMajor >= 20 ? '' : ' — require >= 20'}`,
+        remedy: nodeMajor >= 20 ? undefined : 'Upgrade Node.js: https://nodejs.org',
+    });
+    // ── 2. Franklin version ───────────────────────────────────────────
+    out.push({
+        name: 'Franklin',
+        status: 'ok',
+        detail: `v${VERSION}`,
+    });
+    // ── 3. BLOCKRUN_DIR writable ──────────────────────────────────────
+    try {
+        fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+        const probe = path.join(BLOCKRUN_DIR, '.doctor-probe');
+        fs.writeFileSync(probe, 'ok');
+        fs.unlinkSync(probe);
+        out.push({
+            name: 'Config directory',
+            status: 'ok',
+            detail: BLOCKRUN_DIR,
+        });
+    }
+    catch (err) {
+        out.push({
+            name: 'Config directory',
+            status: 'fail',
+            detail: `${BLOCKRUN_DIR} — ${err.message}`,
+            remedy: `Check permissions on ${BLOCKRUN_DIR} or unset HOME override`,
+        });
+    }
+    // ── 4. Chain configuration ────────────────────────────────────────
+    let chain = null;
+    try {
+        chain = loadChain();
+        out.push({
+            name: 'Chain',
+            status: 'ok',
+            detail: chain,
+        });
+    }
+    catch (err) {
+        out.push({
+            name: 'Chain',
+            status: 'fail',
+            detail: `failed to load — ${err.message}`,
+            remedy: 'Run: franklin setup base  (or: franklin setup solana)',
+        });
+    }
+    // ── 5. Wallet ─────────────────────────────────────────────────────
+    let walletBalance = null;
+    let walletAddress = '';
+    if (chain) {
+        try {
+            if (chain === 'solana') {
+                const client = await setupAgentSolanaWallet({ silent: true });
+                walletAddress = await client.getWalletAddress();
+                walletBalance = await client.getBalance();
+            }
+            else {
+                const client = setupAgentWallet({ silent: true });
+                walletAddress = client.getWalletAddress();
+                walletBalance = await client.getBalance();
+            }
+            out.push({
+                name: 'Wallet',
+                status: 'ok',
+                detail: `${walletAddress.slice(0, 10)}…${walletAddress.slice(-6)}`,
+            });
+            out.push({
+                name: 'USDC balance',
+                status: walletBalance > 0 ? 'ok' : 'warn',
+                detail: `$${walletBalance.toFixed(2)}${walletBalance === 0 ? ' — free-tier models only' : ''}`,
+                remedy: walletBalance === 0
+                    ? `Send USDC on ${chain} to ${walletAddress} to unlock paid models`
+                    : undefined,
+            });
+        }
+        catch (err) {
+            const msg = err.message || '';
+            out.push({
+                name: 'Wallet',
+                status: 'fail',
+                detail: `error — ${msg.slice(0, 120)}`,
+                remedy: msg.includes('ENOENT') || msg.includes('wallet') || msg.includes('key')
+                    ? 'Run: franklin setup'
+                    : 'Check network / wallet file permissions',
+            });
+        }
+    }
+    // ── 6. Gateway reachability ───────────────────────────────────────
+    if (chain) {
+        const apiUrl = API_URLS[chain];
+        try {
+            const ctl = new AbortController();
+            const t = setTimeout(() => ctl.abort(), 5000);
+            const res = await fetch(`${apiUrl}/health`, { signal: ctl.signal }).catch(() => null);
+            clearTimeout(t);
+            if (res && res.ok) {
+                out.push({
+                    name: 'Gateway',
+                    status: 'ok',
+                    detail: apiUrl,
+                });
+            }
+            else {
+                // Fall back to a HEAD on the messages endpoint — some deployments
+                // don't expose /health but the API is up.
+                const ctl2 = new AbortController();
+                const t2 = setTimeout(() => ctl2.abort(), 5000);
+                const res2 = await fetch(`${apiUrl}/v1/messages`, {
+                    method: 'HEAD',
+                    signal: ctl2.signal,
+                }).catch(() => null);
+                clearTimeout(t2);
+                out.push({
+                    name: 'Gateway',
+                    status: res2 ? 'ok' : 'fail',
+                    detail: res2 ? apiUrl : `unreachable: ${apiUrl}`,
+                    remedy: res2 ? undefined : 'Check network or try the other chain',
+                });
+            }
+        }
+        catch (err) {
+            out.push({
+                name: 'Gateway',
+                status: 'fail',
+                detail: `${apiUrl} — ${err.message}`,
+            });
+        }
+    }
+    // ── 7. MCP config ─────────────────────────────────────────────────
+    const mcpPath = path.join(BLOCKRUN_DIR, 'mcp.json');
+    if (fs.existsSync(mcpPath)) {
+        try {
+            const raw = fs.readFileSync(mcpPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const count = Object.keys(parsed.mcpServers || {}).length;
+            out.push({
+                name: 'MCP servers',
+                status: 'ok',
+                detail: `${count} configured in ${mcpPath}`,
+            });
+        }
+        catch (err) {
+            out.push({
+                name: 'MCP servers',
+                status: 'warn',
+                detail: `${mcpPath} has invalid JSON — ${err.message}`,
+                remedy: `Fix or delete ${mcpPath}`,
+            });
+        }
+    }
+    else {
+        out.push({
+            name: 'MCP servers',
+            status: 'ok',
+            detail: 'none configured',
+        });
+    }
+    // ── 8. Telemetry ──────────────────────────────────────────────────
+    const telEnabled = isTelemetryEnabled();
+    if (telEnabled) {
+        const records = readAllRecords();
+        out.push({
+            name: 'Telemetry',
+            status: 'ok',
+            detail: `enabled — ${records.length} session${records.length === 1 ? '' : 's'} recorded`,
+        });
+    }
+    else {
+        out.push({
+            name: 'Telemetry',
+            status: 'ok',
+            detail: 'disabled (default)',
+        });
+    }
+    // ── 9. Shell / PATH hint ──────────────────────────────────────────
+    const which = process.env.PATH || '';
+    const hasHomebrew = which.includes('/opt/homebrew/bin') || which.includes('/usr/local/bin');
+    if (os.platform() === 'darwin' && !hasHomebrew) {
+        out.push({
+            name: 'PATH',
+            status: 'warn',
+            detail: 'Homebrew paths not in PATH',
+            remedy: 'Add /opt/homebrew/bin to PATH in ~/.zshrc',
+        });
+    }
+    return out;
+}
+function printHuman(checks) {
+    console.log(chalk.bold('\n  franklin doctor\n'));
+    for (const c of checks) {
+        const icon = c.status === 'ok' ? chalk.green('✓') :
+            c.status === 'warn' ? chalk.yellow('⚠') :
+                chalk.red('✗');
+        console.log(`  ${icon}  ${c.name.padEnd(18)} ${chalk.dim(c.detail)}`);
+        if (c.remedy) {
+            console.log(`     ${chalk.dim('↳')} ${chalk.yellow(c.remedy)}`);
+        }
+    }
+    const fails = checks.filter(c => c.status === 'fail').length;
+    const warns = checks.filter(c => c.status === 'warn').length;
+    console.log();
+    if (fails > 0) {
+        console.log(chalk.red(`  ${fails} check${fails === 1 ? '' : 's'} failed. See remedies above.`));
+    }
+    else if (warns > 0) {
+        console.log(chalk.yellow(`  All criticals ok. ${warns} warning${warns === 1 ? '' : 's'} above — safe to ignore for now.`));
+    }
+    else {
+        console.log(chalk.green('  All clear. Ready to run: franklin'));
+    }
+    console.log();
+}
+export async function doctorCommand(opts = {}) {
+    const checks = await runChecks();
+    if (opts.json) {
+        const fails = checks.filter(c => c.status === 'fail').length;
+        process.stdout.write(JSON.stringify({ checks, healthy: fails === 0 }, null, 2) + '\n');
+        process.exit(fails > 0 ? 1 : 0);
+    }
+    printHuman(checks);
+    const fails = checks.filter(c => c.status === 'fail').length;
+    process.exit(fails > 0 ? 1 : 0);
+}

package/dist/index.js

@@ -166,6 +166,14 @@ program
         });
     }
 }
+program
+    .command('doctor')
+    .description('One-command health check (node, wallet, chain, gateway, MCP, telemetry)')
+    .option('--json', 'Machine-readable output')
+    .action(async (opts) => {
+    const { doctorCommand } = await import('./commands/doctor.js');
+    await doctorCommand(opts);
+});
 program
     .command('telemetry [action]')
     .description('Manage opt-in local telemetry (status|enable|disable|view|summary)')

package/dist/pricing.js

@@ -67,7 +67,8 @@ export const MODEL_PRICING = {
     // Minimax
     'minimax/minimax-m2.7': { input: 0.3, output: 1.2 },
     'minimax/minimax-m2.5': { input: 0.3, output: 1.2 },
-    // Others
+    // Moonshot
+    'moonshot/kimi-k2.6': { input: 0.95, output: 4.0 },
     'moonshot/kimi-k2.5': { input: 0.6, output: 3.0 },
     'nvidia/kimi-k2.5': { input: 0.55, output: 2.5 },
     // PROMOTION (active ~2026-04): flat $0.001/call for all GLM models

package/dist/proxy/server.js

@@ -105,7 +105,7 @@ const MODEL_SHORTCUTS = {
     minimax: 'minimax/minimax-m2.7',
     // Others
     glm: 'zai/glm-5.1',
-    kimi: 'moonshot/kimi-k2.5',
+    kimi: 'moonshot/kimi-k2.6',
 };
 // Model pricing now uses shared source from src/pricing.ts
 function detectModelSwitch(parsed) {

package/dist/router/index.js

@@ -40,15 +40,15 @@ function loadLearnedWeights() {
 const AUTO_TIERS = {
     SIMPLE: {
         primary: 'google/gemini-2.5-flash',
-        fallback: ['moonshot/kimi-k2.5', 'deepseek/deepseek-chat'],
+        fallback: ['moonshot/kimi-k2.6', 'deepseek/deepseek-chat'],
     },
     MEDIUM: {
         primary: 'anthropic/claude-sonnet-4.6',
-        fallback: ['openai/gpt-5.4', 'google/gemini-3.1-pro', 'moonshot/kimi-k2.5'],
+        fallback: ['openai/gpt-5.4', 'google/gemini-3.1-pro', 'moonshot/kimi-k2.6'],
     },
     COMPLEX: {
         primary: 'anthropic/claude-sonnet-4.6',
-        fallback: ['openai/gpt-5.4', 'anthropic/claude-opus-4.7', 'moonshot/kimi-k2.5'],
+        fallback: ['openai/gpt-5.4', 'anthropic/claude-opus-4.7', 'moonshot/kimi-k2.6'],
     },
     REASONING: {
         // Opus 4.7: step-change improvement in agentic coding over 4.6 per
@@ -84,7 +84,7 @@ const ECO_TIERS = {
 };
 const PREMIUM_TIERS = {
     SIMPLE: {
-        primary: 'moonshot/kimi-k2.5',
+        primary: 'moonshot/kimi-k2.6',
         fallback: ['anthropic/claude-haiku-4.5'],
     },
     MEDIUM: {

package/dist/tools/read.js

@@ -80,13 +80,32 @@ async function execute(input, ctx) {
         if (stat.size > maxBytes) {
             return { output: `Error: file is too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Use offset/limit to read a portion.`, isError: true };
         }
-        // Detect binary files
+        // Detect binary files — first by extension, then by content
+        // (some binaries have no extension: `.env.enc`, `.data`, compiled tools
+        // without suffixes, etc. Content sniff catches those.)
         const ext = path.extname(resolved).toLowerCase();
         const binaryExts = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.bmp', '.pdf', '.zip', '.tar', '.gz', '.woff', '.woff2', '.ttf', '.eot', '.mp3', '.mp4', '.wav', '.avi', '.mov', '.exe', '.dll', '.so', '.dylib']);
         if (binaryExts.has(ext)) {
             const sizeStr = stat.size >= 1024 ? `${(stat.size / 1024).toFixed(1)}KB` : `${stat.size}B`;
             return { output: `Binary file: ${resolved} (${ext}, ${sizeStr}). Cannot display contents.` };
         }
+        // NUL-byte content sniff — read up to 8KB as a Buffer, scan for 0x00.
+        // Text files effectively never contain NUL; binary files almost always
+        // do within the first few KB.
+        try {
+            const SNIFF_BYTES = Math.min(stat.size, 8192);
+            if (SNIFF_BYTES > 0) {
+                const fd = fs.openSync(resolved, 'r');
+                const buf = Buffer.alloc(SNIFF_BYTES);
+                fs.readSync(fd, buf, 0, SNIFF_BYTES, 0);
+                fs.closeSync(fd);
+                if (buf.includes(0)) {
+                    const sizeStr = stat.size >= 1024 ? `${(stat.size / 1024).toFixed(1)}KB` : `${stat.size}B`;
+                    return { output: `Binary file: ${resolved} (no text extension but NUL bytes detected, ${sizeStr}). Cannot display contents.` };
+                }
+            }
+        }
+        catch { /* best-effort sniff — fall through to text read */ }
         const raw = fs.readFileSync(resolved, 'utf-8');
         const allLines = raw.split('\n');
         const startLine = Math.max(0, (Math.max(1, offset ?? 1)) - 1);

package/dist/tools/write.js

@@ -87,6 +87,26 @@ async function execute(input, ctx) {
             isError: true,
         };
     }
+    // Write-size cap. A user-intended file write should never exceed a few
+    // MB; larger payloads are almost always accidental (log dumps, serialized
+    // objects) and refusing them explicitly beats a silent disk-full.
+    const MAX_WRITE_BYTES = 10 * 1024 * 1024;
+    const contentBytes = Buffer.byteLength(content, 'utf-8');
+    if (contentBytes > MAX_WRITE_BYTES) {
+        return {
+            output: `Error: refusing to write ${(contentBytes / 1024 / 1024).toFixed(1)}MB to ${resolved} — max allowed is ${MAX_WRITE_BYTES / 1024 / 1024}MB. Split into smaller writes, or use Bash if this is intentional bulk output.`,
+            isError: true,
+        };
+    }
+    // Content sniff — warn (not block) if NUL bytes detected. Text tools
+    // writing binary is almost always a mistake; explicit Buffer writes
+    // should go through Bash.
+    if (content.indexOf('\0') !== -1) {
+        return {
+            output: `Error: refusing to write NUL-byte content to ${resolved}. This tool writes text files only. For binary output use Bash with a base64 decode or an external script.`,
+            isError: true,
+        };
+    }
     try {
         // Ensure parent directory exists
         const parentDir = path.dirname(resolved);

package/dist/ui/model-picker.js

@@ -58,7 +58,8 @@ export const MODEL_SHORTCUTS = {
     glm: 'zai/glm-5.1',
     'glm-turbo': 'zai/glm-5-turbo',
     'glm5': 'zai/glm-5.1',
-    kimi: 'moonshot/kimi-k2.5',
+    kimi: 'moonshot/kimi-k2.6',
+    'kimi-k2.5': 'moonshot/kimi-k2.5',
 };
 /**
  * Resolve a model name — supports shortcuts.
@@ -125,7 +126,8 @@ export const PICKER_CATEGORIES = [
             { id: 'openai/gpt-5-nano', shortcut: 'nano', label: 'GPT-5 Nano', price: '$0.05/$0.4' },
             { id: 'google/gemini-2.5-flash', shortcut: 'flash', label: 'Gemini 2.5 Flash', price: '$0.3/$2.5' },
             { id: 'deepseek/deepseek-chat', shortcut: 'deepseek', label: 'DeepSeek V3', price: '$0.28/$0.42' },
-            { id: 'moonshot/kimi-k2.5', shortcut: 'kimi', label: 'Kimi K2.5', price: '$0.6/$3' },
+            { id: 'moonshot/kimi-k2.6', shortcut: 'kimi', label: 'Kimi K2.6', price: '$0.95/$4' },
+            { id: 'moonshot/kimi-k2.5', shortcut: 'kimi-k2.5', label: 'Kimi K2.5 (legacy)', price: '$0.6/$3' },
             { id: 'minimax/minimax-m2.7', shortcut: 'minimax', label: 'Minimax M2.7', price: '$0.3/$1.2' },
         ],
     },

package/package.json

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