@blockrun/franklin 3.15.36 → 3.15.38

package/dist/agent/loop.js

@@ -403,6 +403,12 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     let turnCount = 0;
     // Resume: hydrate history from the saved JSONL transcript.
     // Sanitize to drop any orphaned tool_use / tool_result pairs from a crash.
+    // Carry over running totals from prior runs so resume preserves them — see
+    // the `let sessionInputTokens` comment below.
+    let resumedInputTokens = 0;
+    let resumedOutputTokens = 0;
+    let resumedCostUsd = 0;
+    let resumedSavedVsOpusUsd = 0;
     if (config.resumeSessionId) {
         const prior = loadSessionHistory(config.resumeSessionId);
         if (prior.length > 0) {
@@ -411,6 +417,17 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             const meta = loadSessionMeta(config.resumeSessionId);
             if (meta) {
                 turnCount = meta.turnCount ?? 0;
+                // Pre-3.15.38 these fell on the floor — every resume reset the
+                // running cost/token totals to zero, then `updateSessionMeta`
+                // wrote the new (smaller) numbers back over the historical
+                // values. Verified 2026-05-04 from a real session: efd5e412
+                // had $2.65 + 200K input tokens accumulated, then a resume
+                // rewrote the meta to {costUsd: 0, inputTokens: 0, ...}
+                // before the user ran their next turn.
+                resumedInputTokens = meta.inputTokens ?? 0;
+                resumedOutputTokens = meta.outputTokens ?? 0;
+                resumedCostUsd = meta.costUsd ?? 0;
+                resumedSavedVsOpusUsd = meta.savedVsOpusUsd ?? 0;
             }
         }
     }
@@ -418,10 +435,14 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     let lastSessionActivity = Date.now();
     let lastRoutedModel = ''; // last model chosen by router (for local elo)
     let lastRoutedCategory = ''; // last category detected (for local elo)
-    let sessionInputTokens = 0;
-    let sessionOutputTokens = 0;
-    let sessionCostUsd = 0;
-    let sessionSavedVsOpus = 0;
+    // Session-cumulative counters. Seeded from prior session meta on resume so
+    // `franklin insights` and the status bar show the *true* session total
+    // across every restart, not just what happened since the latest process
+    // boot.
+    let sessionInputTokens = resumedInputTokens;
+    let sessionOutputTokens = resumedOutputTokens;
+    let sessionCostUsd = resumedCostUsd;
+    let sessionSavedVsOpus = resumedSavedVsOpusUsd;
     // 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.

package/dist/tools/detach.js

@@ -21,9 +21,15 @@ async function execute(input, ctx) {
             `label: ${label}\n` +
             `command: ${command}\n\n` +
             `Inspect with:\n` +
-            `  franklin task tail ${runId} --follow\n` +
-            `  franklin task wait ${runId}\n` +
-            `  franklin task cancel ${runId}\n`,
+            `  franklin task tail ${runId}              # non-blocking status snapshot — safe inside Bash\n` +
+            `  franklin task wait ${runId} --timeout-s 600   # block up to 10min; pair with Bash timeout >= same\n` +
+            `  franklin task cancel ${runId}\n` +
+            `\n` +
+            `WARNING: do NOT call \`franklin task tail ${runId} --follow\` from a Bash tool — \`--follow\`\n` +
+            `blocks until the task reaches a terminal state, which routinely outlasts the Bash tool's\n` +
+            `default 2-minute timeout and gives you "command killed". Use \`franklin task tail <runId>\`\n` +
+            `(no flag) for non-blocking status, or \`franklin task wait\` with explicit \`--timeout-s\` plus\n` +
+            `a matching Bash \`timeout\`.\n`,
     };
 }
 export const detachCapability = {
@@ -37,9 +43,12 @@ export const detachCapability = {
             "complete), or anything you'd otherwise loop on turn-by-turn (which " +
             "would burn turns and trip timeouts). The agent's job is to design and " +
             "orchestrate, not to be the for-loop. Pair with a script that writes a " +
-            "checkpoint file so progress survives restarts. Tail logs with " +
-            "`franklin task tail <runId> --follow` and check completion with " +
-            "`franklin task wait <runId>`. ALWAYS prefer Detach over a single " +
+            "checkpoint file so progress survives restarts. Inspect with " +
+            "`franklin task tail <runId>` (NON-blocking snapshot — safe inside " +
+            "Bash) — DO NOT use `--follow` from a Bash tool, it blocks until the " +
+            "task is done and will trip the Bash timeout. Block-until-done belongs " +
+            "in `franklin task wait <runId> --timeout-s N` paired with a matching " +
+            "Bash `timeout` parameter. ALWAYS prefer Detach over a single " +
             "foreground Bash call with `sleep` inside a for/while/until loop — that " +
             "antipattern blocks the agent for the full duration and looks frozen.",
         input_schema: {

package/package.json

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