@yeaft/webchat-agent 0.1.949 → 0.1.950

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.949",
+  "version": "0.1.950",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/cli.js

@@ -7,7 +7,7 @@
  *
  * Features:
  *   --dry-run "prompt"   — Assemble system prompt + messages, don't call LLM
- *   --trace stats|recent|search <keyword>  — Query debug.db
+ *   --trace stats|recent|search <keyword>|tools|compact  — Query/maintain debug.db
  *   -i / --interactive   — REPL mode with / commands
  *   <prompt>             — One-shot query (Phase 1: engine.query)
  *   --skip-mcp           — Skip MCP server connections (faster startup)
@@ -173,8 +173,17 @@ function handleTraceQuery(args, config) {
         }
         break;
       }
+      case 'compact': {
+        const s = trace.stats();
+        console.log(`Compacting debug database (${(s.dbSizeBytes / 1048576).toFixed(1)} MB, ${s.turnCount} turns)...`);
+        console.log('This rebuilds the file and may take a while on a large DB. Do not interrupt.');
+        const { before, after } = trace.compact();
+        const saved = Math.max(0, before - after);
+        console.log(`Done. ${(before / 1048576).toFixed(1)} MB → ${(after / 1048576).toFixed(1)} MB (reclaimed ${(saved / 1048576).toFixed(1)} MB).`);
+        break;
+      }
       default:
-        throw new Error(`Unknown trace command: ${args.trace}. Available: stats, recent, search <keyword>, tools [name]`);
+        throw new Error(`Unknown trace command: ${args.trace}. Available: stats, recent, search <keyword>, tools [name], compact`);
     }
   } finally {
     trace.close();

package/yeaft/debug-trace.js

@@ -176,6 +176,14 @@ export class DebugTrace {
   constructor(dbPath) {
     this.#dbPath = dbPath;
     this.#db = new DatabaseSync(dbPath);
+    // INCREMENTAL auto-vacuum lets cleanup() return freed pages to the OS via
+    // `PRAGMA incremental_vacuum` instead of leaving the file at its historical
+    // peak. SQLite only honours an auto_vacuum *change* before the first table
+    // is created (a fresh DB) — on a pre-existing store it is a silent no-op, so
+    // existing databases keep their default `auto_vacuum=NONE` and are
+    // unaffected (they only shrink under a manual compact()/VACUUM). Databases
+    // created from this version on are self-trimming. Must precede SCHEMA.
+    this.#db.exec('PRAGMA auto_vacuum = INCREMENTAL');
     this.#db.exec('PRAGMA journal_mode = WAL');
     this.#db.exec('PRAGMA foreign_keys = ON');
     this.#db.exec(SCHEMA);
@@ -608,11 +616,24 @@ export class DebugTrace {
   // ─── Maintenance ─────────────────────────────────────────────
 
   /**
-   * Delete data older than retentionDays.
-   * @param {number} [retentionDays=30]
+   * Delete trajectory data older than retentionDays, then mark the freed pages
+   * reclaimable.
+   *
+   * The always-on trace stamps every turn with the cumulative request/response
+   * snapshot, so each long-session row is MB-scale and the file grows fast
+   * (a real deployment hit 5GB in 15 days). A plain DELETE marks pages free but
+   * leaves the file at its peak size; `PRAGMA incremental_vacuum` moves those
+   * pages onto the freelist for return to the OS — but only when the DB was
+   * created with `auto_vacuum=INCREMENTAL` (see constructor). On a legacy
+   * `auto_vacuum=NONE` store the vacuum is a harmless no-op, so this is safe to
+   * call unconditionally. Note: in WAL mode the on-disk file truncates at the
+   * next checkpoint (the running agent's automatic checkpoints handle this), so
+   * the page_count drops here but the file size catches up shortly after.
+   *
+   * @param {number} [retentionDays=10]
    * @returns {{ deletedTurns: number, deletedTools: number, deletedEvents: number }}
    */
-  cleanup(retentionDays = 30) {
+  cleanup(retentionDays = 10) {
     const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
     const deletedTools = Number(this.#db.prepare(`
       DELETE FROM trace_tools WHERE turn_id IN (
@@ -625,9 +646,42 @@ export class DebugTrace {
     const deletedEvents = Number(this.#db.prepare(`
       DELETE FROM trace_events WHERE created_at < ?
     `).run(cutoff).changes);
+    // Reclaim freed pages (no-op on legacy auto_vacuum=NONE DBs). Wrapped so a
+    // vacuum failure can never mask a successful delete, but surfaced as a warn
+    // because this is the one operation the whole disk-growth fix relies on — a
+    // silent persistent failure would look exactly like "the fix works".
+    if (deletedTurns || deletedTools || deletedEvents) {
+      try { this.#db.exec('PRAGMA incremental_vacuum'); }
+      catch (err) { console.warn('[Yeaft] trace incremental_vacuum failed:', err?.message || err); }
+    }
     return { deletedTurns, deletedTools, deletedEvents };
   }
 
+  /**
+   * One-shot full compaction (VACUUM). Rebuilds the entire database file,
+   * reclaiming all free space AND converting a legacy `auto_vacuum=NONE` store
+   * to INCREMENTAL going forward. This is a HEAVY operation: it locks the DB
+   * and needs temporary scratch space up to the current file size, so it is
+   * NOT called automatically on session load — invoke it deliberately (e.g.
+   * from the `yeaft --trace` CLI) when an oversized legacy debug.db needs to be
+   * shrunk in place.
+   * @returns {{ before: number, after: number }} file size in bytes
+   */
+  compact() {
+    let before = 0;
+    try { before = statSync(this.#dbPath).size; } catch { /* ignore */ }
+    this.#db.exec('PRAGMA auto_vacuum = INCREMENTAL');
+    this.#db.exec('VACUUM');
+    // In WAL mode VACUUM writes the rebuilt (smaller) DB into the -wal file;
+    // the main .db file does not shrink until a checkpoint folds the WAL back
+    // in. TRUNCATE checkpoints and resets the WAL so the on-disk size we report
+    // (and the user sees) reflects the reclaimed space immediately.
+    try { this.#db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch { /* best-effort */ }
+    let after = 0;
+    try { after = statSync(this.#dbPath).size; } catch { /* ignore */ }
+    return { before, after };
+  }
+
   /** Delete all trace data. */
   purge() {
     this.#db.exec('DELETE FROM trace_tools');
@@ -695,6 +749,7 @@ export class NullTrace {
   search() { return []; }
   stats() { return { turnCount: 0, toolCount: 0, eventCount: 0, dbSizeBytes: 0 }; }
   cleanup() { return { deletedTurns: 0, deletedTools: 0, deletedEvents: 0 }; }
+  compact() { return { before: 0, after: 0 }; }
   purge() {}
   close() {}
   fetchRecentDebugHistory() { return { loops: [], turns: [], dreamEvents: [] }; }

package/yeaft/session.js

@@ -231,11 +231,13 @@ export async function loadSession(options = {}) {
     enabled: true,
     dbPath: join(yeaftDir, 'debug.db'),
   });
-  // Bound disk growth: prune trajectories older than 30 days on session load.
-  // Cheap (indexed DELETE), runs once per process start, not per turn. Without
-  // this the always-on store grows unbounded — cleanup() existed but had zero
-  // call sites before this PR.
-  try { trace.cleanup?.(30); } catch (err) {
+  // Bound disk growth: prune trajectories older than 10 days on session load.
+  // Cheap (indexed DELETE + incremental_vacuum), runs once per process start,
+  // not per turn. The always-on store stamps every turn with the *cumulative*
+  // request/response (each long-session row is ~MB), so without a tight TTL the
+  // file balloons — a real deployment hit 5GB in 15 days. 10 days keeps enough
+  // history for debug-panel replay while capping the steady-state footprint.
+  try { trace.cleanup?.(10); } catch (err) {
     console.warn('[Yeaft] trace.cleanup failed:', err?.message || err);
   }