@blockrun/franklin 3.8.5 → 3.8.7

package/README.md

@@ -16,7 +16,7 @@
 <p>
   <a href="https://npmjs.com/package/@blockrun/franklin"><img src="https://img.shields.io/npm/v/@blockrun/franklin.svg?style=flat-square&color=FFD700&label=npm" alt="npm"></a>
   <a href="https://npmjs.com/package/@blockrun/franklin"><img src="https://img.shields.io/npm/dm/@blockrun/franklin.svg?style=flat-square&color=10B981&label=downloads" alt="downloads"></a>
-  <a href="https://github.com/RunFranklin/franklin/stargazers"><img src="https://img.shields.io/github/stars/RunFranklin/franklin?style=flat-square&color=FFD700&label=stars" alt="stars"></a>
+  <a href="https://github.com/BlockRunAI/Franklin/stargazers"><img src="https://img.shields.io/github/stars/BlockRunAI/Franklin?style=flat-square&color=FFD700&label=stars" alt="stars"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache_2.0-blue?style=flat-square" alt="license"></a>
   <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-strict-3178C6?style=flat-square&logo=typescript&logoColor=white" alt="TypeScript"></a>
   <a href="https://nodejs.org/"><img src="https://img.shields.io/badge/Node-%E2%89%A520-339933?style=flat-square&logo=node.js&logoColor=white" alt="Node"></a>
@@ -468,14 +468,14 @@ Same wallet. Same tools. From your phone.
 
 - [Telegram](https://t.me/blockrunAI) — realtime help, bug reports, feature requests
 - [@BlockRunAI](https://x.com/BlockRunAI) — release notes, demos
-- [Issues](https://github.com/RunFranklin/franklin/issues) — bugs and feature requests
+- [Issues](https://github.com/BlockRunAI/Franklin/issues) — bugs and feature requests
 
 ---
 
 ## Development
 
 ```bash
-git clone https://github.com/RunFranklin/franklin.git
+git clone https://github.com/BlockRunAI/Franklin.git
 cd franklin
 npm install
 npm run build

package/dist/agent/loop.js

@@ -358,6 +358,10 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     let sessionOutputTokens = 0;
     let sessionCostUsd = 0;
     let sessionSavedVsOpus = 0;
+    // Per-tool call counts aggregated across every turn. Session-scope, not
+    // per-turn. Counts the *name* of each tool invocation only — no inputs,
+    // outputs, or paths. Fed into opt-in telemetry at session end.
+    const sessionToolCounts = new Map();
     const toolGuard = new SessionToolGuard();
     const persistSessionMeta = () => {
         updateSessionMeta(sessionId, {
@@ -370,6 +374,9 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             costUsd: sessionCostUsd,
             savedVsOpusUsd: sessionSavedVsOpus,
             ...(config.sessionChannel !== undefined ? { channel: config.sessionChannel } : {}),
+            ...(sessionToolCounts.size > 0
+                ? { toolCallCounts: Object.fromEntries(sessionToolCounts) }
+                : {}),
         });
     };
     const persistSessionMessage = (message) => {
@@ -1039,6 +1046,8 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             for (const [inv] of results) {
                 const name = inv.name;
                 turnToolCounts.set(name, (turnToolCounts.get(name) || 0) + 1);
+                // Session-scope aggregate (drives telemetry opt-in export).
+                sessionToolCounts.set(name, (sessionToolCounts.get(name) || 0) + 1);
                 // Read file dedup: track paths already read
                 if (name === 'Read' && inv.input.file_path) {
                     readFileCache.add(inv.input.file_path);

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/start.js

@@ -313,6 +313,13 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     }
     ui.cleanup();
     flushStats();
+    // Opt-in telemetry — no-op unless user has run `franklin telemetry enable`.
+    // Appends a sanitized session summary to ~/.blockrun/telemetry.jsonl.
+    try {
+        const { recordLatestSessionIfEnabled } = await import('../telemetry/store.js');
+        recordLatestSessionIfEnabled(process.cwd(), agentConfig.chain);
+    }
+    catch { /* telemetry is best-effort */ }
     // Extract learnings from the session (async, 10s timeout, never blocks exit)
     if (sessionHistory && sessionHistory.length >= 4) {
         try {

package/dist/commands/telemetry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `franklin telemetry` — manage the opt-in local telemetry subsystem.
+ *
+ * Subcommands:
+ *   status   — print whether telemetry is enabled, where the log lives,
+ *              and a one-line summary of what's been recorded
+ *   enable   — turn on local recording (default is OFF)
+ *   disable  — stop future recording; existing data stays on disk
+ *   view     — print every record in the log as pretty JSONL so the
+ *              user can see exactly what was captured
+ *   summary  — aggregate all records into tool-usage histograms so
+ *              positioning decisions can be made from real data
+ */
+export declare function telemetryCommand(action?: string): Promise<void>;

package/dist/commands/telemetry.js

@@ -0,0 +1,150 @@
+/**
+ * `franklin telemetry` — manage the opt-in local telemetry subsystem.
+ *
+ * Subcommands:
+ *   status   — print whether telemetry is enabled, where the log lives,
+ *              and a one-line summary of what's been recorded
+ *   enable   — turn on local recording (default is OFF)
+ *   disable  — stop future recording; existing data stays on disk
+ *   view     — print every record in the log as pretty JSONL so the
+ *              user can see exactly what was captured
+ *   summary  — aggregate all records into tool-usage histograms so
+ *              positioning decisions can be made from real data
+ */
+import chalk from 'chalk';
+import { isTelemetryEnabled, setTelemetryEnabled, readConsent, readAllRecords, telemetryPaths, } from '../telemetry/store.js';
+export async function telemetryCommand(action) {
+    const cmd = (action || 'status').toLowerCase();
+    switch (cmd) {
+        case 'status':
+            return statusCmd();
+        case 'enable':
+        case 'on':
+            return enableCmd();
+        case 'disable':
+        case 'off':
+            return disableCmd();
+        case 'view':
+        case 'log':
+            return viewCmd();
+        case 'summary':
+            return summaryCmd();
+        default:
+            console.log(chalk.yellow(`Unknown subcommand: ${action}`));
+            console.log(chalk.dim('Try: franklin telemetry [status|enable|disable|view|summary]'));
+            process.exit(1);
+    }
+}
+function statusCmd() {
+    const enabled = isTelemetryEnabled();
+    const consent = readConsent();
+    const records = readAllRecords();
+    console.log(chalk.bold('Franklin telemetry'));
+    console.log(`  state:      ${enabled ? chalk.green('enabled') : chalk.dim('disabled (default)')}`);
+    if (consent.enabledAt) {
+        console.log(`  enabled at: ${chalk.dim(new Date(consent.enabledAt).toISOString())}`);
+    }
+    if (consent.disabledAt && !enabled) {
+        console.log(`  disabled at: ${chalk.dim(new Date(consent.disabledAt).toISOString())}`);
+    }
+    console.log(`  records:    ${chalk.cyan(records.length.toString())} session${records.length === 1 ? '' : 's'} on disk`);
+    console.log(`  log file:   ${chalk.dim(telemetryPaths.log)}`);
+    console.log();
+    console.log(chalk.dim('Telemetry is local-only: no network transmission.'));
+    console.log(chalk.dim('Records contain tool-usage counts and cost totals — NOT prompts, tool inputs, tool outputs, paths, or wallet addresses.'));
+    console.log();
+    console.log(chalk.dim('Commands:'));
+    console.log(chalk.dim('  franklin telemetry enable     turn on local recording'));
+    console.log(chalk.dim('  franklin telemetry disable    stop future recording (keeps existing data)'));
+    console.log(chalk.dim('  franklin telemetry view       print every stored record verbatim'));
+    console.log(chalk.dim('  franklin telemetry summary    aggregate tool-usage histograms'));
+}
+function enableCmd() {
+    if (isTelemetryEnabled()) {
+        console.log(chalk.dim('Telemetry is already enabled.'));
+        return;
+    }
+    setTelemetryEnabled(true);
+    console.log(chalk.green('Telemetry enabled.'));
+    console.log(chalk.dim('Each session end appends one JSON line to ' + telemetryPaths.log));
+    console.log(chalk.dim('Inspect with: franklin telemetry view'));
+    console.log(chalk.dim('Disable with: franklin telemetry disable'));
+}
+function disableCmd() {
+    if (!isTelemetryEnabled()) {
+        console.log(chalk.dim('Telemetry is already disabled.'));
+        return;
+    }
+    setTelemetryEnabled(false);
+    console.log(chalk.green('Telemetry disabled. Future sessions will not be recorded.'));
+    console.log(chalk.dim('Existing data at ' + telemetryPaths.log + ' is untouched.'));
+    console.log(chalk.dim('Delete it manually if you want to clear history.'));
+}
+function viewCmd() {
+    const records = readAllRecords();
+    if (records.length === 0) {
+        console.log(chalk.dim('No telemetry records yet.'));
+        if (!isTelemetryEnabled()) {
+            console.log(chalk.dim('Telemetry is disabled — enable with: franklin telemetry enable'));
+        }
+        return;
+    }
+    for (const r of records) {
+        console.log(JSON.stringify(r, null, 2));
+        console.log(chalk.dim('─'.repeat(60)));
+    }
+}
+function summaryCmd() {
+    const records = readAllRecords();
+    if (records.length === 0) {
+        console.log(chalk.dim('No telemetry records yet.'));
+        return;
+    }
+    const toolCounts = new Map();
+    const modelCounts = new Map();
+    const driverCounts = new Map();
+    let totalCost = 0;
+    let totalSaved = 0;
+    let totalTurns = 0;
+    for (const r of records) {
+        if (r.toolCallCounts) {
+            for (const [tool, n] of Object.entries(r.toolCallCounts)) {
+                toolCounts.set(tool, (toolCounts.get(tool) || 0) + n);
+            }
+        }
+        modelCounts.set(r.model, (modelCounts.get(r.model) || 0) + 1);
+        driverCounts.set(r.driver, (driverCounts.get(r.driver) || 0) + 1);
+        totalCost += r.costUsd;
+        totalSaved += r.savedVsOpusUsd;
+        totalTurns += r.turns;
+    }
+    console.log(chalk.bold(`\nFranklin telemetry summary — ${records.length} sessions\n`));
+    console.log(`  total turns:        ${totalTurns}`);
+    console.log(`  total USDC cost:    $${totalCost.toFixed(4)}`);
+    console.log(`  saved vs Opus:      $${totalSaved.toFixed(4)}`);
+    console.log();
+    console.log(chalk.bold('  Tool usage (session aggregate):'));
+    const sortedTools = [...toolCounts.entries()].sort((a, b) => b[1] - a[1]);
+    if (sortedTools.length === 0) {
+        console.log(chalk.dim('    (no tool calls recorded)'));
+    }
+    else {
+        const maxCount = sortedTools[0][1];
+        for (const [tool, n] of sortedTools) {
+            const bar = '█'.repeat(Math.max(1, Math.round((n / maxCount) * 20)));
+            console.log(`    ${tool.padEnd(22)} ${chalk.cyan(bar)} ${n}`);
+        }
+    }
+    console.log();
+    console.log(chalk.bold('  Models:'));
+    const sortedModels = [...modelCounts.entries()].sort((a, b) => b[1] - a[1]);
+    for (const [model, n] of sortedModels) {
+        console.log(`    ${model.padEnd(36)} ${n}`);
+    }
+    console.log();
+    console.log(chalk.bold('  Drivers:'));
+    for (const [driver, n] of driverCounts.entries()) {
+        console.log(`    ${driver.padEnd(22)} ${n}`);
+    }
+    console.log();
+}

package/dist/index.js

@@ -166,6 +166,13 @@ program
         });
     }
 }
+program
+    .command('telemetry [action]')
+    .description('Manage opt-in local telemetry (status|enable|disable|view|summary)')
+    .action(async (action) => {
+    const { telemetryCommand } = await import('./commands/telemetry.js');
+    await telemetryCommand(action);
+});
 program
     .command('telegram')
     .description('Drive Franklin from Telegram (requires TELEGRAM_BOT_TOKEN + TELEGRAM_OWNER_ID env vars)')

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/session/storage.d.ts

@@ -21,6 +21,13 @@ export interface SessionMeta {
      * Lets findLatestSessionByChannel pick up the right session on bot restart.
      */
     channel?: string;
+    /**
+     * Per-tool invocation counts for this session, aggregated across every
+     * turn. Populated by the agent loop at each tool-call batch. Used by the
+     * opt-in telemetry subsystem to aggregate vertical-usage signals — do NOT
+     * add any tool inputs or outputs here, just the count per tool name.
+     */
+    toolCallCounts?: Record<string, number>;
 }
 /** Get the absolute path to a session's JSONL file (for external readers like search). */
 export declare function getSessionFilePath(id: string): string;

package/dist/session/storage.js

@@ -95,6 +95,9 @@ export function updateSessionMeta(sessionId, meta) {
             ...(meta.channel !== undefined || existing?.channel !== undefined
                 ? { channel: meta.channel ?? existing?.channel }
                 : {}),
+            ...(meta.toolCallCounts !== undefined || existing?.toolCallCounts !== undefined
+                ? { toolCallCounts: meta.toolCallCounts ?? existing?.toolCallCounts }
+                : {}),
         };
         // Atomic write: tmp file + rename. Prevents corruption when parent
         // and sub-agent update the same session meta concurrently.

package/dist/telemetry/store.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Opt-in local telemetry.
+ *
+ * Principles (non-negotiable):
+ *   1. Opt-in only — default is off. A fresh install collects nothing.
+ *   2. Local only — this module writes to ~/.blockrun/telemetry.jsonl.
+ *      No network transmission, ever. A future opt-in "upload" feature
+ *      would be a separate module with its own consent gate.
+ *   3. No content — never log prompts, tool inputs, tool outputs, file
+ *      paths, or wallet addresses. Count-level aggregates only.
+ *   4. Inspectable — the log is plain JSONL, one record per session.
+ *      `franklin telemetry view` prints it. Users see exactly what was
+ *      recorded before ever considering sharing it.
+ *   5. Revocable — `franklin telemetry disable` stops future writes
+ *      and leaves historical data intact. `franklin telemetry reset`
+ *      (future) would wipe the log.
+ *
+ * Data model is a sanitized projection of SessionMeta. Nothing original
+ * is stored here that isn't already derivable from the session meta
+ * files — telemetry is just a stable, aggregation-friendly view of
+ * information the user already has.
+ */
+import type { SessionMeta } from '../session/storage.js';
+interface ConsentRecord {
+    enabled: boolean;
+    enabledAt?: number;
+    disabledAt?: number;
+}
+/** Sanitized projection of a session used for telemetry. No content. */
+export interface TelemetryRecord {
+    /** Stable per-install random UUID. Not tied to wallet or email. */
+    installId: string;
+    /** Franklin version at the time this session ran. */
+    version: string;
+    /** Session timestamp (ISO string). */
+    ts: string;
+    /** Number of user turns. */
+    turns: number;
+    /** Number of message entries (user + assistant + tool_result). */
+    messages: number;
+    /** Input / output tokens for the whole session. */
+    inputTokens: number;
+    outputTokens: number;
+    /** Cost in USDC. */
+    costUsd: number;
+    /** Savings vs Opus-tier baseline in USDC. */
+    savedVsOpusUsd: number;
+    /** Last-active model id for the session. */
+    model: string;
+    /** Chain the session settled on (base / solana). */
+    chain?: string;
+    /** Session driver — "cli" for normal use, or the channel tag for Telegram/etc. */
+    driver: string;
+    /** Per-tool invocation counts (names only, no content). */
+    toolCallCounts?: Record<string, number>;
+}
+/** Enabled-state check. Default: false. */
+export declare function isTelemetryEnabled(): boolean;
+export declare function setTelemetryEnabled(enabled: boolean): void;
+export declare function readConsent(): ConsentRecord;
+/** Stable per-install random UUID. Generated lazily on first write. */
+export declare function getOrCreateInstallId(): string;
+/**
+ * Sanitize a SessionMeta into a telemetry record. No content is added here
+ * that isn't already present in the meta — the sanitization rule is that
+ * every field must be count-level or identifier-level, never user content.
+ */
+export declare function sessionMetaToRecord(meta: SessionMeta, installId: string, chain?: string): TelemetryRecord;
+/** Append one record to the telemetry log. Silent no-op if disabled. */
+export declare function recordSession(meta: SessionMeta, chain?: string): void;
+/**
+ * Locate the session that just finished by ID or by "newest in the sessions
+ * directory whose workDir matches", then record it. Used by start.ts at
+ * exit since interactiveSession() doesn't currently thread the session id
+ * back to the caller.
+ */
+export declare function recordLatestSessionIfEnabled(workingDir: string, chain?: string): void;
+/** Read every record in the log. Returns [] if the file is missing. */
+export declare function readAllRecords(): TelemetryRecord[];
+/** File paths — surfaced so the CLI can show users where data lives. */
+export declare const telemetryPaths: {
+    consent: string;
+    log: string;
+    installId: string;
+};
+export {};

package/dist/telemetry/store.js

@@ -0,0 +1,158 @@
+/**
+ * Opt-in local telemetry.
+ *
+ * Principles (non-negotiable):
+ *   1. Opt-in only — default is off. A fresh install collects nothing.
+ *   2. Local only — this module writes to ~/.blockrun/telemetry.jsonl.
+ *      No network transmission, ever. A future opt-in "upload" feature
+ *      would be a separate module with its own consent gate.
+ *   3. No content — never log prompts, tool inputs, tool outputs, file
+ *      paths, or wallet addresses. Count-level aggregates only.
+ *   4. Inspectable — the log is plain JSONL, one record per session.
+ *      `franklin telemetry view` prints it. Users see exactly what was
+ *      recorded before ever considering sharing it.
+ *   5. Revocable — `franklin telemetry disable` stops future writes
+ *      and leaves historical data intact. `franklin telemetry reset`
+ *      (future) would wipe the log.
+ *
+ * Data model is a sanitized projection of SessionMeta. Nothing original
+ * is stored here that isn't already derivable from the session meta
+ * files — telemetry is just a stable, aggregation-friendly view of
+ * information the user already has.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { BLOCKRUN_DIR, VERSION } from '../config.js';
+const CONSENT_FILE = path.join(BLOCKRUN_DIR, 'telemetry-consent.json');
+const LOG_FILE = path.join(BLOCKRUN_DIR, 'telemetry.jsonl');
+const INSTALL_ID_FILE = path.join(BLOCKRUN_DIR, 'telemetry-install-id.txt');
+function ensureDir() {
+    fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+}
+/** Enabled-state check. Default: false. */
+export function isTelemetryEnabled() {
+    try {
+        const raw = fs.readFileSync(CONSENT_FILE, 'utf-8');
+        const record = JSON.parse(raw);
+        return record.enabled === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function setTelemetryEnabled(enabled) {
+    ensureDir();
+    const existing = readConsent();
+    const next = enabled
+        ? { enabled: true, enabledAt: Date.now() }
+        : { enabled: false, enabledAt: existing.enabledAt, disabledAt: Date.now() };
+    fs.writeFileSync(CONSENT_FILE, JSON.stringify(next, null, 2));
+}
+export function readConsent() {
+    try {
+        return JSON.parse(fs.readFileSync(CONSENT_FILE, 'utf-8'));
+    }
+    catch {
+        return { enabled: false };
+    }
+}
+/** Stable per-install random UUID. Generated lazily on first write. */
+export function getOrCreateInstallId() {
+    try {
+        const raw = fs.readFileSync(INSTALL_ID_FILE, 'utf-8').trim();
+        if (raw.length > 0)
+            return raw;
+    }
+    catch { /* first run */ }
+    ensureDir();
+    const id = crypto.randomUUID();
+    fs.writeFileSync(INSTALL_ID_FILE, id);
+    return id;
+}
+/**
+ * Sanitize a SessionMeta into a telemetry record. No content is added here
+ * that isn't already present in the meta — the sanitization rule is that
+ * every field must be count-level or identifier-level, never user content.
+ */
+export function sessionMetaToRecord(meta, installId, chain) {
+    return {
+        installId,
+        version: VERSION,
+        ts: new Date(meta.updatedAt).toISOString(),
+        turns: meta.turnCount ?? 0,
+        messages: meta.messageCount ?? 0,
+        inputTokens: meta.inputTokens ?? 0,
+        outputTokens: meta.outputTokens ?? 0,
+        costUsd: meta.costUsd ?? 0,
+        savedVsOpusUsd: meta.savedVsOpusUsd ?? 0,
+        model: meta.model ?? 'unknown',
+        chain,
+        // "cli" if no channel tag, else the channel string (e.g. "telegram:12345").
+        // Channel may include an owner id; we deliberately keep it because the
+        // install id is already user-agnostic and linking a driver to a user
+        // is necessary to distinguish "single user with Telegram" from "many
+        // users with CLI" in aggregate data. Users who don't want this strip
+        // it by running telemetry disable.
+        driver: meta.channel ?? 'cli',
+        ...(meta.toolCallCounts ? { toolCallCounts: meta.toolCallCounts } : {}),
+    };
+}
+/** Append one record to the telemetry log. Silent no-op if disabled. */
+export function recordSession(meta, chain) {
+    if (!isTelemetryEnabled())
+        return;
+    ensureDir();
+    const record = sessionMetaToRecord(meta, getOrCreateInstallId(), chain);
+    try {
+        fs.appendFileSync(LOG_FILE, JSON.stringify(record) + '\n');
+    }
+    catch {
+        // Telemetry is best-effort — never block a user session on a disk write.
+    }
+}
+/**
+ * Locate the session that just finished by ID or by "newest in the sessions
+ * directory whose workDir matches", then record it. Used by start.ts at
+ * exit since interactiveSession() doesn't currently thread the session id
+ * back to the caller.
+ */
+export function recordLatestSessionIfEnabled(workingDir, chain) {
+    if (!isTelemetryEnabled())
+        return;
+    // Lazy import to avoid a circular session/storage <-> telemetry dependency.
+    // Using require() here keeps this module synchronous for tests.
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { listSessions } = require('../session/storage.js');
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    const sessions = listSessions();
+    const match = sessions.find(s => s.workDir === workingDir);
+    if (!match)
+        return;
+    recordSession(match, chain);
+}
+/** Read every record in the log. Returns [] if the file is missing. */
+export function readAllRecords() {
+    try {
+        const raw = fs.readFileSync(LOG_FILE, 'utf-8');
+        const out = [];
+        for (const line of raw.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                out.push(JSON.parse(line));
+            }
+            catch { /* skip corrupt */ }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/** File paths — surfaced so the CLI can show users where data lives. */
+export const telemetryPaths = {
+    consent: CONSENT_FILE,
+    log: LOG_FILE,
+    installId: INSTALL_ID_FILE,
+};

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.5",
+  "version": "3.8.7",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {
@@ -52,10 +52,10 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/RunFranklin/franklin.git"
+    "url": "git+https://github.com/BlockRunAI/Franklin.git"
   },
   "bugs": {
-    "url": "https://github.com/RunFranklin/franklin/issues"
+    "url": "https://github.com/BlockRunAI/Franklin/issues"
   },
   "homepage": "https://Franklin.run",
   "engines": {