@blockrun/franklin 3.15.41 → 3.15.43

package/dist/agent/loop.js

@@ -1236,9 +1236,16 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 savings: routingSavings,
                 contextPct: Math.round(contextUsagePct),
             });
-            // Record usage for stats tracking (franklin stats command)
+            // Record usage for stats tracking (franklin stats command).
+            // Pass the fallback flag so franklin-stats.json's totalFallbacks +
+            // per-model fallbackCount stay in sync with the audit log a few
+            // lines below — same `turnFailedModels.size > 0` predicate, same
+            // turn. Without this, stats showed 0 fallbacks across 5150 real
+            // requests on a machine that visibly hit fallback paths in
+            // franklin-debug.log; `franklin insights` was therefore useless
+            // for spotting a hot routing chain.
             const costEstimate = estimateCost(resolvedModel, inputTokens, usage.outputTokens, 1);
-            recordUsage(resolvedModel, inputTokens, usage.outputTokens, costEstimate, 0);
+            recordUsage(resolvedModel, inputTokens, usage.outputTokens, costEstimate, 0, turnFailedModels.size > 0);
             // ── Circuit breakers: prevent infinite-loop wallet drain ──
             // Per-turn $-cap was removed in v3.11.0 — runaway loops are caught by
             // MAX_TOOL_CALLS_PER_TURN (25) and MAX_TINY_RESPONSES (2) above; the

package/dist/tasks/paths.d.ts

@@ -3,8 +3,24 @@
  *   meta.json    — single TaskRecord, atomically rewritten
  *   events.jsonl — append-only event log
  *   log.txt      — child process stdout/stderr
+ *
+ * Storage location: defaults to BLOCKRUN_DIR (~/.blockrun), matching
+ * every other persistent state in the codebase (sessions, audit, stats,
+ * brain, etc.). Earlier releases used ~/.franklin instead, so we
+ * lazily fall back to that legacy directory on reads when a task isn't
+ * found in the primary location. New tasks always write to the primary.
+ *
+ * Why a lazy fallback instead of a startup migration: a long-running
+ * task runner (`franklin _task-runner <runId>`) captures its task dir
+ * path in memory at spawn and continues writing there for the duration
+ * of the run. Verified 2026-05-04: an in-flight ETL task at PID 59095
+ * had been writing to ~/.franklin/tasks/ for 4 minutes, with ~10 hours
+ * of progress still ahead. Moving the directory mid-flight would
+ * orphan its writes; the fallback path lets new CLI commands keep
+ * reading legacy task state without disturbing an active runner.
  */
 export declare function getTasksDir(): string;
+export declare function getLegacyTasksDir(): string;
 export declare function getTaskDir(runId: string): string;
 export declare function ensureTaskDir(runId: string): string;
 export declare function taskMetaPath(runId: string): string;

package/dist/tasks/paths.js

@@ -3,18 +3,51 @@
  *   meta.json    — single TaskRecord, atomically rewritten
  *   events.jsonl — append-only event log
  *   log.txt      — child process stdout/stderr
+ *
+ * Storage location: defaults to BLOCKRUN_DIR (~/.blockrun), matching
+ * every other persistent state in the codebase (sessions, audit, stats,
+ * brain, etc.). Earlier releases used ~/.franklin instead, so we
+ * lazily fall back to that legacy directory on reads when a task isn't
+ * found in the primary location. New tasks always write to the primary.
+ *
+ * Why a lazy fallback instead of a startup migration: a long-running
+ * task runner (`franklin _task-runner <runId>`) captures its task dir
+ * path in memory at spawn and continues writing there for the duration
+ * of the run. Verified 2026-05-04: an in-flight ETL task at PID 59095
+ * had been writing to ~/.franklin/tasks/ for 4 minutes, with ~10 hours
+ * of progress still ahead. Moving the directory mid-flight would
+ * orphan its writes; the fallback path lets new CLI commands keep
+ * reading legacy task state without disturbing an active runner.
  */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { BLOCKRUN_DIR } from '../config.js';
+const LEGACY_FRANKLIN_HOME = path.join(os.homedir(), '.franklin');
 function franklinHome() {
-    return process.env.FRANKLIN_HOME || path.join(os.homedir(), '.franklin');
+    return process.env.FRANKLIN_HOME || BLOCKRUN_DIR;
 }
 export function getTasksDir() {
     return path.join(franklinHome(), 'tasks');
 }
+export function getLegacyTasksDir() {
+    return path.join(LEGACY_FRANKLIN_HOME, 'tasks');
+}
 export function getTaskDir(runId) {
-    return path.join(getTasksDir(), runId);
+    // Prefer the primary location. If a task already exists in the
+    // legacy ~/.franklin/tasks/ — either created by an older release or
+    // by a runner subprocess started before this version was installed —
+    // continue to read/write there until it completes, so we don't strand
+    // its in-flight events.jsonl + meta.json writes.
+    const primary = path.join(getTasksDir(), runId);
+    if (fs.existsSync(primary))
+        return primary;
+    if (process.env.FRANKLIN_HOME === undefined) {
+        const legacy = path.join(getLegacyTasksDir(), runId);
+        if (fs.existsSync(legacy))
+            return legacy;
+    }
+    return primary;
 }
 export function ensureTaskDir(runId) {
     const dir = getTaskDir(runId);

package/dist/tasks/store.js

@@ -16,7 +16,7 @@
  * tolerant of a torn last line.
  */
 import fs from 'node:fs';
-import { ensureTaskDir, taskMetaPath, taskEventsPath, getTasksDir, } from './paths.js';
+import { ensureTaskDir, taskMetaPath, taskEventsPath, getTasksDir, getLegacyTasksDir, } from './paths.js';
 export function writeTaskMeta(record) {
     ensureTaskDir(record.runId);
     const target = taskMetaPath(record.runId);
@@ -103,21 +103,35 @@ export function applyEvent(runId, event) {
     return next;
 }
 export function listTasks() {
-    let entries;
-    try {
-        entries = fs.readdirSync(getTasksDir(), { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
+    // Walk both the primary tasks dir and the legacy ~/.franklin/tasks/
+    // location so `franklin task list` keeps showing legacy tasks until
+    // their dirs are cleaned up. Dedupe by runId (first-wins, primary
+    // ordered first) — protects against the unlikely case of the same
+    // runId existing in both locations.
+    const dirs = [getTasksDir()];
+    if (process.env.FRANKLIN_HOME === undefined)
+        dirs.push(getLegacyTasksDir());
+    const seen = new Set();
     const out = [];
-    for (const ent of entries) {
-        // Skip junk like .DS_Store — only real per-task subdirectories are valid.
-        if (!ent.isDirectory())
+    for (const dir of dirs) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
             continue;
-        const meta = readTaskMeta(ent.name);
-        if (meta)
-            out.push(meta);
+        }
+        for (const ent of entries) {
+            // Skip junk like .DS_Store — only real per-task subdirectories are valid.
+            if (!ent.isDirectory())
+                continue;
+            if (seen.has(ent.name))
+                continue;
+            seen.add(ent.name);
+            const meta = readTaskMeta(ent.name);
+            if (meta)
+                out.push(meta);
+        }
     }
     out.sort((a, b) => b.createdAt - a.createdAt);
     return out;

package/package.json

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