@blockrun/franklin 3.15.16 → 3.15.18

package/dist/agent/loop.js

@@ -22,6 +22,8 @@ import { recordSessionUsage } from '../stats/session-tracker.js';
 import { appendAudit, extractLastUserPrompt } from '../stats/audit.js';
 import { logger, setDebugMode } from '../logger.js';
 import { runDataHygiene } from '../storage/hygiene.js';
+import { isTestFixtureModel } from '../stats/test-fixture.js';
+import { setSessionPersistenceDisabled } from '../session/storage.js';
 import { estimateCost, OPUS_PRICING } from '../pricing.js';
 import { maybeMidSessionExtract } from '../learnings/extractor.js';
 import { extractMentions, buildEntityContext, loadEntities } from '../brain/store.js';
@@ -330,6 +332,14 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     // Wire stderr-mirroring of log lines to the same flag the agent already
     // uses to gate verbose console output. File writes happen regardless.
     setDebugMode(!!config.debug);
+    // In-process tests run interactiveSession() with model="local/test*"
+    // and were creating real session files on the user's machine —
+    // verified 19 of 33 metas (57.6%) were polluted on a real install.
+    // Gate session persistence at the entry point so the rest of the
+    // loop doesn't have to thread the flag through. Tests that genuinely
+    // exercise the persistence path use a non-fixture model name like
+    // `zai/glm-5.1` (mock-server-backed) so they keep writing.
+    setSessionPersistenceDisabled(isTestFixtureModel(config.model));
     const client = new ModelClient({
         apiUrl: config.apiUrl,
         chain: config.chain,

package/dist/router/local-elo.js

@@ -8,6 +8,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { BLOCKRUN_DIR } from '../config.js';
+import { isTestFixtureModel } from '../stats/test-fixture.js';
 const HISTORY_FILE = path.join(BLOCKRUN_DIR, 'router-history.jsonl');
 const MAX_RECORDS = 2000;
 const K_FACTOR = 32; // Elo K-factor — how much each outcome shifts the rating
@@ -15,6 +16,13 @@ const K_FACTOR = 32; // Elo K-factor — how much each outcome shifts the rating
  * Record a model outcome for local learning.
  */
 export function recordOutcome(category, model, outcome, toolCalls) {
+    // Defensive: same fixture-model gate as appendAudit / recordUsage.
+    // router-history.jsonl is currently clean (test runs typically have
+    // an empty `lastRoutedCategory` and the agent loop already guards
+    // against that), but a future change to category detection would
+    // immediately leak. Belt-and-braces.
+    if (isTestFixtureModel(model))
+        return;
     try {
         fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
         const record = { ts: Date.now(), category, model, outcome, toolCalls };

package/dist/session/storage.d.ts

@@ -3,6 +3,8 @@
  * Saves conversation history as JSONL for resume capability.
  */
 import type { Dialogue } from '../agent/types.js';
+export declare function setSessionPersistenceDisabled(disabled: boolean): void;
+export declare function isSessionPersistenceDisabled(): boolean;
 export interface SessionMeta {
     id: string;
     model: string;

package/dist/session/storage.js

@@ -9,6 +9,20 @@ import { randomUUID } from 'node:crypto';
 import { BLOCKRUN_DIR } from '../config.js';
 const MAX_SESSIONS = 20; // Keep last 20 sessions
 let resolvedSessionsDir = null;
+// When in-process tests run interactiveSession() with model="local/test*",
+// session writes were creating real .jsonl + .meta.json files in the
+// user's ~/.blockrun/sessions/ — verified 19 of 33 metas (57.6%) on a
+// real machine. Toggled at session start by the agent loop based on the
+// model name; defaults to enabled so production never accidentally goes
+// silent. No-op writes when disabled — reads still work so resume tests
+// can pre-seed state with their own writes if they want to.
+let persistenceDisabled = false;
+export function setSessionPersistenceDisabled(disabled) {
+    persistenceDisabled = disabled;
+}
+export function isSessionPersistenceDisabled() {
+    return persistenceDisabled;
+}
 function getSessionsDir() {
     if (resolvedSessionsDir)
         return resolvedSessionsDir;
@@ -69,6 +83,8 @@ export function createSessionId() {
  * Save a message to the session transcript (append-only JSONL).
  */
 export function appendToSession(sessionId, message) {
+    if (persistenceDisabled)
+        return;
     const line = JSON.stringify(message) + '\n';
     withWritableSessionDir(() => {
         fs.appendFileSync(sessionPath(sessionId), line);
@@ -78,6 +94,8 @@ export function appendToSession(sessionId, message) {
  * Update session metadata.
  */
 export function updateSessionMeta(sessionId, meta) {
+    if (persistenceDisabled)
+        return;
     withWritableSessionDir(() => {
         const existing = loadSessionMeta(sessionId);
         const updated = {

package/dist/storage/hygiene.js

@@ -61,6 +61,10 @@ export function runDataHygiene() {
         removeLegacyFiles();
     }
     catch { /* best effort */ }
+    try {
+        sweepOrphanToolResults();
+    }
+    catch { /* best effort */ }
 }
 function trimDataDir() {
     const dir = path.join(BLOCKRUN_DIR, 'data');
@@ -132,3 +136,57 @@ function removeLegacyFiles() {
         catch { /* ok */ }
     }
 }
+/**
+ * `streaming-executor` writes large tool outputs to
+ * `~/.blockrun/tool-results/<sessionId>/<toolUseId>.txt`. When a session is
+ * pruned by `pruneOldSessions`, the meta + jsonl are deleted but the
+ * tool-results dir is left dangling. Verified on a real machine: 5 dirs,
+ * oldest from 4/14 (3 weeks past MAX_SESSIONS=20 retention).
+ *
+ * A tool-results dir is considered orphan when its name (the session id)
+ * has no `<sessionId>.meta.json` partner in the sessions/ dir. The active
+ * session is implicitly protected because its meta exists.
+ */
+function sweepOrphanToolResults() {
+    const toolResultsDir = path.join(BLOCKRUN_DIR, 'tool-results');
+    const sessionsDir = path.join(BLOCKRUN_DIR, 'sessions');
+    if (!fs.existsSync(toolResultsDir))
+        return;
+    const knownSessionIds = new Set();
+    if (fs.existsSync(sessionsDir)) {
+        try {
+            for (const f of fs.readdirSync(sessionsDir)) {
+                if (f.endsWith('.meta.json')) {
+                    knownSessionIds.add(f.slice(0, -'.meta.json'.length));
+                }
+            }
+        }
+        catch {
+            // Best-effort — if we can't read sessions/, skip the sweep so
+            // we never delete tool-results that might still belong to a
+            // live session.
+            return;
+        }
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(toolResultsDir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (knownSessionIds.has(name))
+            continue;
+        const dir = path.join(toolResultsDir, name);
+        try {
+            const stat = fs.statSync(dir);
+            if (!stat.isDirectory())
+                continue;
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // Skip — best-effort cleanup.
+        }
+    }
+}

package/package.json

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