@blockrun/franklin 3.15.65 → 3.15.67

package/dist/agent/loop.js

@@ -562,9 +562,11 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     const totalCleaned = hygieneReport.legacyFilesRemoved +
         hygieneReport.dataFilesTrimmed +
         hygieneReport.costLogRowsTrimmed +
-        hygieneReport.orphanToolResultsRemoved;
+        hygieneReport.orphanToolResultsRemoved +
+        hygieneReport.brainJunkEntitiesRemoved +
+        hygieneReport.oldTasksRemoved;
     if (totalCleaned > 0) {
-        logger.info(`[franklin] Data hygiene: ${hygieneReport.legacyFilesRemoved} legacy, ${hygieneReport.dataFilesTrimmed} data files, ${hygieneReport.costLogRowsTrimmed} cost_log rows, ${hygieneReport.orphanToolResultsRemoved} orphan tool-results dirs cleaned`);
+        logger.info(`[franklin] Data hygiene: ${hygieneReport.legacyFilesRemoved} legacy, ${hygieneReport.dataFilesTrimmed} data files, ${hygieneReport.costLogRowsTrimmed} cost_log rows, ${hygieneReport.orphanToolResultsRemoved} orphan tool-results dirs, ${hygieneReport.brainJunkEntitiesRemoved} junk brain entities, ${hygieneReport.oldTasksRemoved} expired tasks cleaned`);
     }
     persistSessionMeta();
     // Flush session meta on SIGINT/SIGTERM so mid-stream Ctrl+C doesn't

package/dist/commands/task.js

@@ -22,18 +22,33 @@ function fmtAge(ms) {
         return `${m}m`;
     return `${Math.floor(m / 60)}h${m % 60}m`;
 }
+function reconcileBestEffort() {
+    try {
+        reconcileLostTasks();
+    }
+    catch { /* best-effort */ }
+}
 export function buildTaskCommand() {
     const cmd = new Command('task').description('Manage long-running detached tasks');
     cmd
         .command('list')
         .description('List recent tasks (newest first)')
         .action(() => {
-        reconcileLostTasks();
+        reconcileBestEffort();
         const tasks = listTasks();
         if (tasks.length === 0) {
             console.log('No tasks. Start one via the Task agent tool.');
             return;
         }
+        // Header row matches `franklin content list` shape — verified
+        // 2026-05-05 that task list was emitting bare data rows with no
+        // column labels, leaving users to guess at the column meaning
+        // (`14h19m` could be elapsed-since-start or since-end). The
+        // running-vs-terminal age semantics are documented in 3.15.46;
+        // the header makes the column itself self-explanatory.
+        const idHeader = 'runId';
+        const idWidth = Math.max(idHeader.length, ...tasks.map(t => t.runId.length));
+        console.log([idHeader.padEnd(idWidth), 'status'.padEnd(10), '  age', 'label'].join('  '));
         const now = Date.now();
         for (const t of tasks) {
             // For a running task, "age" should mean "how long has this been
@@ -48,7 +63,7 @@ export function buildTaskCommand() {
                 ? (t.endedAt ?? t.lastEventAt ?? t.createdAt)
                 : (t.startedAt ?? t.createdAt);
             const age = fmtAge(now - ageRefMs);
-            console.log(`${t.runId}  ${t.status.padEnd(10)}  ${age.padStart(5)}  ${t.label}`);
+            console.log(`${t.runId.padEnd(idWidth)}  ${t.status.padEnd(10)}  ${age.padStart(5)}  ${t.label}`);
         }
     });
     cmd
@@ -56,6 +71,7 @@ export function buildTaskCommand() {
         .description('Print log + current status for a task')
         .option('-f, --follow', 'Poll until task reaches terminal state')
         .action(async (runId, opts) => {
+        reconcileBestEffort();
         const meta0 = readTaskMeta(runId);
         if (!meta0) {
             console.error(`No task: ${runId}`);
@@ -78,6 +94,7 @@ export function buildTaskCommand() {
         if (opts.follow) {
             while (true) {
                 await new Promise((r) => setTimeout(r, 1000));
+                reconcileBestEffort();
                 printNew();
                 const meta = readTaskMeta(runId);
                 if (meta && isTerminalTaskStatus(meta.status))
@@ -108,6 +125,7 @@ export function buildTaskCommand() {
         const cap = parseInt(opts.timeout, 10);
         const t0 = Date.now();
         while (true) {
+            reconcileBestEffort();
             const meta = readTaskMeta(runId);
             if (!meta) {
                 console.error(`No task: ${runId}`);
@@ -128,6 +146,7 @@ export function buildTaskCommand() {
         .command('cancel <runId>')
         .description('Cancel a running task (SIGTERM to runner)')
         .action((runId) => {
+        reconcileBestEffort();
         const meta = readTaskMeta(runId);
         if (!meta) {
             console.error(`No task: ${runId}`);

package/dist/storage/hygiene.d.ts

@@ -33,6 +33,7 @@ export interface HygieneReport {
     costLogRowsTrimmed: number;
     orphanToolResultsRemoved: number;
     brainJunkEntitiesRemoved: number;
+    oldTasksRemoved: number;
 }
 /**
  * Top-level entry. Call once at agent session start. Catches its own

package/dist/storage/hygiene.js

@@ -25,12 +25,22 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { BLOCKRUN_DIR } from '../config.js';
 import { pruneJunkBrainEntries } from '../brain/store.js';
+import { getTasksDir, getLegacyTasksDir } from '../tasks/paths.js';
+import { isTerminalTaskStatus } from '../tasks/types.js';
 // Retention knobs. Tuned conservatively — a power user with 50+ calls/day
 // for 30 days still fits in DATA_DIR_MAX_FILES, and 5000 cost-log entries
 // covers months of normal use without truncating the running totals.
 const DATA_DIR_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
 const DATA_DIR_MAX_FILES = 2000;
 const COST_LOG_MAX_ENTRIES = 5000;
+// Task records (meta + events + log per task dir). Verified 2026-05-05:
+// 10 tasks across ~/.franklin/tasks/, oldest "lost" status from 53 hours
+// ago, none ever cleaned up. Each task's log.txt can run 1+ MB for ETL
+// jobs. Without retention, disk fills slowly. 7 days lets a user inspect
+// the previous week's runs but archives anything older. Running tasks
+// are NEVER touched (status check + heartbeat freshness).
+const TASK_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+const TASK_MIN_RETAIN = 5; // always keep the 5 most-recent records regardless of age
 // Cost log entries are tiny (~60 bytes — ts, endpoint, cost only). 40 bytes
 // per entry keeps the probe under the real average so a slightly-overlong
 // file always triggers the rescan rather than silently growing past cap.
@@ -51,6 +61,7 @@ const ZERO_REPORT = {
     costLogRowsTrimmed: 0,
     orphanToolResultsRemoved: 0,
     brainJunkEntitiesRemoved: 0,
+    oldTasksRemoved: 0,
 };
 /**
  * Top-level entry. Call once at agent session start. Catches its own
@@ -81,8 +92,74 @@ export function runDataHygiene() {
         report.brainJunkEntitiesRemoved = pruneJunkBrainEntries().entitiesRemoved;
     }
     catch { /* best effort */ }
+    try {
+        report.oldTasksRemoved = pruneOldTaskRecords();
+    }
+    catch { /* best effort */ }
     return report;
 }
+/**
+ * Remove terminal-state task directories older than TASK_MAX_AGE_MS.
+ * Scans both the canonical (~/.blockrun/tasks/) and legacy
+ * (~/.franklin/tasks/) locations, since 3.15.42 leaves both readable.
+ *
+ * Safety:
+ *   - Running / queued tasks are NEVER removed (status check).
+ *   - Always keep the most-recent TASK_MIN_RETAIN records regardless of
+ *     age, so users can see recent history after a long pause.
+ *   - Best-effort: corrupt meta or unreadable dirs are skipped silently.
+ */
+function pruneOldTaskRecords() {
+    const cutoff = Date.now() - TASK_MAX_AGE_MS;
+    let removed = 0;
+    const dirs = [getTasksDir()];
+    if (process.env.FRANKLIN_HOME === undefined)
+        dirs.push(getLegacyTasksDir());
+    for (const dir of dirs) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        const cands = [];
+        for (const name of entries) {
+            const taskDir = path.join(dir, name);
+            const metaPath = path.join(taskDir, 'meta.json');
+            try {
+                const stat = fs.statSync(taskDir);
+                if (!stat.isDirectory())
+                    continue;
+                const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+                const terminal = typeof meta.status === 'string' && isTerminalTaskStatus(meta.status);
+                cands.push({ runId: name, mtime: stat.mtimeMs, terminal, metaPath });
+            }
+            catch {
+                // Unreadable meta or stat — skip silently. We never delete a dir
+                // we can't confirm is terminal, to avoid killing a running task
+                // whose meta we just couldn't read.
+            }
+        }
+        // Sort newest-first so the slice for retention is at index 0..N-1.
+        cands.sort((a, b) => b.mtime - a.mtime);
+        const protectedIds = new Set(cands.slice(0, TASK_MIN_RETAIN).map(c => c.runId));
+        for (const c of cands) {
+            if (protectedIds.has(c.runId))
+                continue;
+            if (!c.terminal)
+                continue; // never touch running/queued
+            if (c.mtime >= cutoff)
+                continue; // young enough to keep
+            try {
+                fs.rmSync(path.join(dir, c.runId), { recursive: true, force: true });
+                removed++;
+            }
+            catch { /* ok */ }
+        }
+    }
+    return removed;
+}
 function trimDataDir() {
     const dir = path.join(BLOCKRUN_DIR, 'data');
     if (!fs.existsSync(dir))

package/package.json

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