@stackmemoryai/stackmemory 1.6.2 → 1.8.0

package/dist/src/core/context/frame-database.js

@@ -150,6 +150,44 @@ class FrameDatabase {
         -- Set initial schema version if not exists
         INSERT OR IGNORE INTO schema_version (version) VALUES (1);
       `);
+      try {
+        this.db.exec(
+          "ALTER TABLE frames ADD COLUMN access_count INTEGER DEFAULT 0"
+        );
+      } catch {
+      }
+      try {
+        this.db.exec("ALTER TABLE frames ADD COLUMN last_accessed INTEGER");
+      } catch {
+      }
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS frame_access_log (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          frame_id TEXT NOT NULL,
+          accessed_at INTEGER NOT NULL DEFAULT (unixepoch()),
+          FOREIGN KEY (frame_id) REFERENCES frames(frame_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_frame_access_log_frame
+          ON frame_access_log(frame_id);
+      `);
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS entity_states (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          project_id TEXT NOT NULL,
+          entity_name TEXT NOT NULL,
+          relation TEXT NOT NULL,
+          value TEXT NOT NULL,
+          context TEXT,
+          source_frame_id TEXT,
+          valid_from INTEGER NOT NULL DEFAULT (unixepoch()),
+          superseded_at INTEGER,
+          FOREIGN KEY (source_frame_id) REFERENCES frames(frame_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_entity_name
+          ON entity_states(project_id, entity_name, relation);
+        CREATE INDEX IF NOT EXISTS idx_entity_temporal
+          ON entity_states(entity_name, valid_from DESC);
+      `);
       this.db.exec(`
         CREATE TABLE IF NOT EXISTS cord_tasks (
           task_id TEXT PRIMARY KEY,

package/dist/src/core/context/frame-enrichment.js

@@ -0,0 +1,93 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { logger } from "../monitoring/logger.js";
+import { frameLifecycleHooks } from "./frame-lifecycle-hooks.js";
+const ENRICHMENT_PROMPT = `You are a context enrichment engine. Given a frame digest and its parent context, do two things:
+1. Rewrite the digest to be fully self-contained \u2014 resolve all pronouns ("it", "that", "the project") using parent context.
+2. Extract entity-relation-value triples from the content.
+
+Respond in JSON only:
+{"enrichedDigest":"...","entities":[{"name":"...","relation":"...","value":"...","context":"..."}]}`;
+function buildEnrichmentInput(frame, parents) {
+  const parentCtx = parents.map((p) => `[${p.name}]: ${p.digest_text ?? ""}`).join("\n");
+  return `Parent context:
+${parentCtx}
+
+Current frame "${frame.name}":
+${frame.digest_text ?? ""}`;
+}
+async function enrichFrame(frame, parents, apiKey) {
+  try {
+    const Anthropic = (await import("@anthropic-ai/sdk")).default;
+    const client = new Anthropic({ apiKey });
+    const input = buildEnrichmentInput(frame, parents);
+    const response = await client.messages.create({
+      model: "claude-3-5-haiku-latest",
+      max_tokens: 1024,
+      system: ENRICHMENT_PROMPT,
+      messages: [{ role: "user", content: input }]
+    });
+    const text = response.content[0].type === "text" ? response.content[0].text : "";
+    return JSON.parse(text);
+  } catch (err) {
+    logger.warn("Frame enrichment LLM call failed", {
+      error: err instanceof Error ? err.message : String(err),
+      frameId: frame.frame_id
+    });
+    return void 0;
+  }
+}
+let unregister = null;
+function registerEnrichmentHook(config, deps) {
+  if (unregister) unregister();
+  if (!config.enabled) return () => {
+  };
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    logger.warn("Enrichment enabled but ANTHROPIC_API_KEY not set");
+    return () => {
+    };
+  }
+  unregister = frameLifecycleHooks.onFrameClosed(
+    "frame-enrichment",
+    async (data) => {
+      if (!data.frame.digest_text) return;
+      const parents = await deps.getParentFrames(
+        data.frame.frame_id,
+        config.lookbackDepth
+      );
+      const result = await enrichFrame(data.frame, parents, apiKey);
+      if (!result) return;
+      await deps.updateDigest(data.frame.frame_id, result.enrichedDigest);
+      if (config.extractEntities) {
+        for (const entity of result.entities) {
+          try {
+            deps.recordEntity(
+              data.frame.project_id,
+              entity.name,
+              entity.relation,
+              entity.value,
+              entity.context,
+              data.frame.frame_id
+            );
+          } catch {
+          }
+        }
+      }
+    },
+    -10
+    // low priority — runs after other hooks
+  );
+  return () => {
+    if (unregister) {
+      unregister();
+      unregister = null;
+    }
+  };
+}
+export {
+  enrichFrame,
+  registerEnrichmentHook
+};

package/dist/src/core/context/frame-handoff-manager.js

@@ -489,7 +489,7 @@ class FrameHandoffManager {
    */
   async getHandoffMetrics(timeRange) {
     const handoffs = Array.from(this.activeHandoffs.values());
-    const filteredHandoffs = timeRange ? handoffs.filter((h) => {
+    const filteredHandoffs = timeRange ? handoffs.filter((_h) => {
       return true;
     }) : handoffs;
     const completedHandoffs = filteredHandoffs.filter(

package/dist/src/core/context/frame-manager.js

@@ -12,7 +12,7 @@ import {
 } from "../errors/index.js";
 import { FrameQueryMode } from "../session/index.js";
 import { frameLifecycleHooks } from "./frame-lifecycle-hooks.js";
-const MAX_FRAME_DEPTH = 100;
+const _MAX_FRAME_DEPTH = 100;
 const DEFAULT_MAX_DEPTH = 100;
 import { FrameDatabase } from "./frame-database.js";
 import { FrameStack } from "./frame-stack.js";
@@ -167,7 +167,7 @@ class FrameManager {
       outputs: {},
       digest_json: {}
     };
-    const createdFrame = this.frameDb.insertFrame(frame);
+    const _createdFrame = this.frameDb.insertFrame(frame);
     this.frameStack.pushFrame(frameId);
     logger.info("Created frame", {
       frameId,
@@ -275,7 +275,7 @@ class FrameManager {
       event_type: eventType,
       payload
     };
-    const createdEvent = this.frameDb.insertEvent(event);
+    const _createdEvent = this.frameDb.insertEvent(event);
     logger.debug("Added event", {
       eventId,
       frameId: targetFrameId,
@@ -316,7 +316,7 @@ class FrameManager {
       priority,
       metadata
     };
-    const createdAnchor = this.frameDb.insertAnchor(anchor);
+    const _createdAnchor = this.frameDb.insertAnchor(anchor);
     logger.debug("Added anchor", {
       anchorId,
       frameId: targetFrameId,

package/dist/src/core/context/rehydration.js

@@ -622,7 +622,7 @@ class EnhancedRehydrationManager {
       ];
       const files = await this.getDirectoryFiles(workingDir);
       for (const file of files) {
-        const ext = path.extname(file);
+        const _ext = path.extname(file);
         const basename = path.basename(file);
         if (configPatterns.some(
           (pattern) => pattern.includes("*") ? basename.includes(pattern.replace("*", "")) : basename === pattern
@@ -825,10 +825,10 @@ Stack preview: ${trace.stack_frames.slice(0, 3).join("\n")}`,
     logger.info("Rich context injected successfully");
   }
   // Helper methods
-  async getDirectoryFiles(dir) {
+  async getDirectoryFiles(_dir) {
     return [];
   }
-  async getRecentlyModifiedFiles(dir) {
+  async getRecentlyModifiedFiles(_dir) {
     return [];
   }
   inferContextTags(filePath) {
@@ -917,7 +917,7 @@ Stack preview: ${trace.stack_frames.slice(0, 3).join("\n")}`,
         resolution_attempted: data.resolutionAttempts || [],
         resolution_status: data.resolved ? "resolved" : "pending"
       };
-    } catch (error) {
+    } catch {
       return null;
     }
   }
@@ -944,7 +944,7 @@ Stack preview: ${trace.stack_frames.slice(0, 3).join("\n")}`,
     }
     return [...new Set(workflows)];
   }
-  inferCurrentFocus(snapshots, context) {
+  inferCurrentFocus(snapshots, _context) {
     if (snapshots.some((s) => s.contextTags.includes("migration"))) {
       return "Data migration and transformation";
     }
@@ -953,7 +953,7 @@ Stack preview: ${trace.stack_frames.slice(0, 3).join("\n")}`,
     }
     return "Development";
   }
-  createRecoveryAnchors(snapshots, context) {
+  createRecoveryAnchors(snapshots, _context) {
     const anchors = [];
     for (const snapshot of snapshots.slice(0, 3)) {
       anchors.push(

package/dist/src/core/database/sqlite-adapter.js

@@ -468,19 +468,11 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     };
   }
   /**
-   * Compute importance score for a single frame.
-   * Score range: [0.0, 1.0] — higher means more important, less likely to be GC'd.
+   * Compute structural salience for a frame (range 0.3-1.0).
+   * Based on anchors, events, digest, and children.
    */
-  computeImportanceScore(frameId) {
-    if (!this.db)
-      throw new DatabaseError(
-        "Database not connected",
-        ErrorCode.DB_CONNECTION_FAILED
-      );
-    const frame = this.db.prepare(
-      "SELECT frame_id, digest_text, created_at FROM frames WHERE frame_id = ?"
-    ).get(frameId);
-    if (!frame) return 0.3;
+  computeSalience(frameId, digestText) {
+    if (!this.db) return 0.3;
     let score = 0.3;
     const decisionCount = this.db.prepare(
       "SELECT COUNT(*) as count FROM anchors WHERE frame_id = ? AND type = 'DECISION'"
@@ -488,14 +480,61 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     if (decisionCount > 0) score += 0.15;
     const eventCount = this.db.prepare("SELECT COUNT(*) as count FROM events WHERE frame_id = ?").get(frameId).count;
     if (eventCount > 3) score += 0.1;
-    if (frame.digest_text) score += 0.15;
+    if (digestText) score += 0.15;
     const childCount = this.db.prepare(
       "SELECT COUNT(*) as count FROM frames WHERE parent_frame_id = ?"
     ).get(frameId).count;
     if (childCount > 0) score += 0.1;
+    return Math.min(score, 1);
+  }
+  /**
+   * Compute importance score using Ebbinghaus retention decay + reinforcement.
+   *
+   * R(frame, t) = I_salience * e^(-lambda * dt) + sigma * sum(1 / (t - t_access_i))
+   *
+   * Score range: [0.05, 1.0] — never fully zero.
+   */
+  computeImportanceScore(frameId) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const frame = this.db.prepare(
+      "SELECT frame_id, digest_text, created_at FROM frames WHERE frame_id = ?"
+    ).get(frameId);
+    if (!frame) return 0.3;
+    const salience = this.computeSalience(frameId, frame.digest_text);
     const nowSec = Math.floor(Date.now() / 1e3);
-    if (nowSec - frame.created_at < 86400) score += 0.1;
-    return Math.round(Math.min(score, 1) * 100) / 100;
+    const dtDays = Math.max(0, (nowSec - frame.created_at) / 86400);
+    const lambda = 0.05;
+    const decayTerm = salience * Math.exp(-lambda * dtDays);
+    const sigma = 0.1;
+    const accesses = this.db.prepare("SELECT accessed_at FROM frame_access_log WHERE frame_id = ?").all(frameId);
+    let reinforcement = 0;
+    for (const a of accesses) {
+      const gap = nowSec - a.accessed_at;
+      if (gap > 0) reinforcement += 1 / gap;
+    }
+    const raw = decayTerm + sigma * reinforcement;
+    return Math.round(Math.min(Math.max(raw, 0.05), 1) * 100) / 100;
+  }
+  /**
+   * Record a frame access for retention decay scoring.
+   * Inserts into frame_access_log and bumps access_count/last_accessed.
+   */
+  recordFrameAccess(frameId) {
+    if (!this.db) return;
+    const nowSec = Math.floor(Date.now() / 1e3);
+    try {
+      this.db.prepare(
+        "INSERT INTO frame_access_log (frame_id, accessed_at) VALUES (?, ?)"
+      ).run(frameId, nowSec);
+      this.db.prepare(
+        "UPDATE frames SET access_count = COALESCE(access_count, 0) + 1, last_accessed = ? WHERE frame_id = ?"
+      ).run(nowSec, frameId);
+    } catch {
+    }
   }
   /**
    * Compress a frame by stripping data according to strategy.
@@ -1611,6 +1650,88 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
       }
     });
   }
+  // --- Entity State Methods ---
+  recordEntityState(projectId, entityName, relation, value, context, sourceFrameId) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const nowSec = Math.floor(Date.now() / 1e3);
+    this.db.prepare(
+      `UPDATE entity_states
+         SET superseded_at = ?
+         WHERE entity_name = ? AND relation = ? AND superseded_at IS NULL`
+    ).run(nowSec, entityName, relation);
+    const result = this.db.prepare(
+      `INSERT INTO entity_states
+         (project_id, entity_name, relation, value, context, source_frame_id, valid_from)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      projectId,
+      entityName,
+      relation,
+      value,
+      context ?? null,
+      sourceFrameId ?? null,
+      nowSec
+    );
+    return Number(result.lastInsertRowid);
+  }
+  getEntityState(entityName, relation, asOf) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    if (asOf != null) {
+      const relFilter2 = relation ? " AND relation = ?" : "";
+      const sql2 = `SELECT * FROM entity_states
+        WHERE entity_name = ?${relFilter2}
+          AND valid_from <= ?
+          AND (superseded_at IS NULL OR superseded_at > ?)
+        ORDER BY valid_from DESC`;
+      const params2 = [entityName];
+      if (relation) params2.push(relation);
+      params2.push(asOf, asOf);
+      return this.db.prepare(sql2).all(...params2);
+    }
+    const relFilter = relation ? " AND relation = ?" : "";
+    const sql = `SELECT * FROM entity_states
+      WHERE entity_name = ?${relFilter} AND superseded_at IS NULL
+      ORDER BY valid_from DESC, id DESC`;
+    const params = [entityName];
+    if (relation) params.push(relation);
+    return this.db.prepare(sql).all(...params);
+  }
+  getEntityHistory(entityName, relation) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const relFilter = relation ? " AND relation = ?" : "";
+    const sql = `SELECT * FROM entity_states
+      WHERE entity_name = ?${relFilter}
+      ORDER BY valid_from DESC, id DESC`;
+    const params = [entityName];
+    if (relation) params.push(relation);
+    return this.db.prepare(sql).all(...params);
+  }
+  getEntityDiff(entityName, since) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const sinceFilter = since != null ? " AND valid_from > ?" : "";
+    const sql = `SELECT * FROM entity_states
+      WHERE entity_name = ?${sinceFilter}
+      ORDER BY valid_from DESC, id DESC`;
+    const params = [entityName];
+    if (since != null) params.push(since);
+    return this.db.prepare(sql).all(...params);
+  }
 }
 export {
   SQLiteAdapter

package/dist/src/core/digest/frame-digest-integration.js

@@ -138,7 +138,7 @@ class FrameDigestIntegration {
   /**
    * Get frame anchors (wrapper for proper typing)
    */
-  getFrameAnchors(frameId) {
+  getFrameAnchors(_frameId) {
     return [];
   }
   /**

package/dist/src/core/digest/hybrid-digest-generator.js

@@ -313,7 +313,7 @@ class HybridDigestGenerator {
    * Determine priority based on frame characteristics
    */
   determinePriority(input) {
-    const { frame, anchors, events } = input;
+    const { _frame, anchors, events } = input;
     const decisionCount = anchors.filter((a) => a.type === "DECISION").length;
     const errorCount = events.filter(
       (e) => e.payload?.error || e.payload?.success === false

package/dist/src/core/digest/hybrid-digest.js

@@ -119,7 +119,7 @@ class EnhancedHybridDigestGenerator extends HybridDigestGenerator {
     if (!this.llmProvider) {
       throw new Error("No LLM provider configured");
     }
-    const prompt = this.buildEnhancedPrompt(input, deterministic);
+    const _prompt = this.buildEnhancedPrompt(input, deterministic);
     const response = await this.llmProvider.generateSummary(
       input,
       deterministic,
@@ -162,7 +162,7 @@ class EnhancedHybridDigestGenerator extends HybridDigestGenerator {
   /**
    * Extract key decisions from AI response
    */
-  extractKeyDecisions(response) {
+  extractKeyDecisions(_response) {
     return [];
   }
   /**
@@ -178,7 +178,7 @@ class EnhancedHybridDigestGenerator extends HybridDigestGenerator {
   /**
    * Extract next steps from AI response
    */
-  extractNextSteps(response) {
+  extractNextSteps(_response) {
     return [];
   }
   /**

package/dist/src/core/errors/recovery.js

@@ -114,7 +114,7 @@ class CircuitBreaker {
       throw error;
     }
   }
-  handleFailure(error) {
+  handleFailure(_error) {
     this.failures++;
     this.lastFailTime = /* @__PURE__ */ new Date();
     if (this.state === "half_open" /* HALF_OPEN */) {

package/dist/src/core/extensions/loader.js

@@ -155,7 +155,7 @@ class ExtensionLoader {
   /**
    * Load extension from source based on type
    */
-  async loadFromSource(type, uri, options) {
+  async loadFromSource(type, uri, _options) {
     switch (type) {
       case "url":
         return this.loadFromUrl(uri);
@@ -277,7 +277,7 @@ class ExtensionLoader {
    */
   async loadFromNpm(packageName) {
     try {
-      const { name, version } = this.parseNpmPackage(packageName);
+      const { name, _version } = this.parseNpmPackage(packageName);
       let module;
       try {
         module = await import(name);
@@ -295,7 +295,7 @@ class ExtensionLoader {
           const entryPoint = packageJson.main || "index.js";
           const entryPath = path.join(nodeModulesPath, entryPoint);
           module = await import(pathToFileURL(entryPath).href);
-        } catch (innerError) {
+        } catch {
           return {
             success: false,
             error: `Package not found: ${name}. Try running: npm install ${name}`
@@ -321,7 +321,7 @@ class ExtensionLoader {
   /**
    * Evaluate extension code (for URL sources)
    */
-  async evaluateExtensionCode(code, sourceUrl) {
+  async evaluateExtensionCode(code, _sourceUrl) {
     const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
     try {
       const module = await import(dataUrl);
@@ -473,12 +473,12 @@ class ExtensionLoader {
       permissions,
       // State management (always available, scoped to extension)
       state: {
-        get: async (key) => {
+        get: async (_key) => {
           return void 0;
         },
-        set: async (key, value) => {
+        set: async (_key, _value) => {
         },
-        delete: async (key) => {
+        delete: async (_key) => {
         }
       },
       // Sandboxed fetch (always available)
@@ -511,7 +511,7 @@ class ExtensionLoader {
     };
     if (permSet.has("frames:read") || permSet.has("frames:write")) {
       context.frames = {
-        get: async (frameId) => {
+        get: async (_frameId) => {
           return void 0;
         },
         list: async () => {
@@ -519,10 +519,10 @@ class ExtensionLoader {
         }
       };
       if (permSet.has("frames:write")) {
-        context.frames.create = async (options) => {
+        context.frames.create = async (_options) => {
           throw new Error("Frame creation not implemented");
         };
-        context.frames.update = async (frameId, data) => {
+        context.frames.update = async (_frameId, _data) => {
           throw new Error("Frame update not implemented");
         };
       }

package/dist/src/core/extensions/plugin-system.js

@@ -362,7 +362,7 @@ function createLinearPlugin() {
       context.logger.info(`Sync complete: ${frames.length} frames`);
       return frames;
     },
-    watch(callback) {
+    watch(_callback) {
       context?.logger.info("Watch mode enabled");
       return () => {
         context?.logger.info("Watch mode disabled");

package/dist/src/core/monitoring/logger.js

@@ -112,7 +112,7 @@ class Logger {
       if (!fs.existsSync(logDir)) {
         fs.mkdirSync(logDir, { recursive: true });
       }
-    } catch (err) {
+    } catch {
       this.logFile = void 0;
       if (!this.fileLoggingDisabledNotified) {
         this.fileLoggingDisabledNotified = true;
@@ -131,7 +131,7 @@ class Logger {
     if (this.logFile) {
       try {
         fs.appendFileSync(this.logFile, logLine);
-      } catch (err) {
+      } catch {
         this.logFile = void 0;
         if (!this.fileLoggingDisabledNotified) {
           this.fileLoggingDisabledNotified = true;

package/dist/src/core/monitoring/metrics.js

@@ -6,7 +6,7 @@ import { EventEmitter } from "events";
 import * as fs from "fs";
 import * as path from "path";
 import { logger } from "./logger.js";
-function getEnv(key, defaultValue) {
+function _getEnv(key, defaultValue) {
   const value = process.env[key];
   if (value === void 0) {
     if (defaultValue !== void 0) return defaultValue;
@@ -14,7 +14,7 @@ function getEnv(key, defaultValue) {
   }
   return value;
 }
-function getOptionalEnv(key) {
+function _getOptionalEnv(key) {
   return process.env[key];
 }
 class MetricsCollector extends EventEmitter {

package/dist/src/core/monitoring/progress-tracker.js

@@ -4,7 +4,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
-function getEnv(key, defaultValue) {
+function _getEnv(key, defaultValue) {
   const value = process.env[key];
   if (value === void 0) {
     if (defaultValue !== void 0) return defaultValue;
@@ -12,7 +12,7 @@ function getEnv(key, defaultValue) {
   }
   return value;
 }
-function getOptionalEnv(key) {
+function _getOptionalEnv(key) {
   return process.env[key];
 }
 class ProgressTracker {

package/dist/src/core/performance/lazy-context-loader.js

@@ -232,7 +232,7 @@ class LazyContextLoader {
         ...row,
         metadata: JSON.parse(row.metadata || "{}")
       };
-    } catch (error) {
+    } catch {
       if (frameId.startsWith("frame-")) {
         return {
           id: frameId,

package/dist/src/core/performance/performance-benchmark.js

@@ -89,14 +89,14 @@ class PerformanceBenchmark {
     }
     const populateDuration = performance.now() - populateStart;
     const accessStart = performance.now();
-    let hits = 0;
-    let misses = 0;
+    let _hits = 0;
+    let _misses = 0;
     for (let i = 0; i < accessPatterns; i++) {
       const index = Math.floor(Math.random() * itemCount * 1.2);
       const key = `item-${index}`;
       const result2 = cache.get(key);
-      if (result2) hits++;
-      else misses++;
+      if (result2) _hits++;
+      else _misses++;
     }
     const accessDuration = performance.now() - accessStart;
     const stats = cache.getStats();
@@ -134,7 +134,7 @@ class PerformanceBenchmark {
     let frames = [];
     try {
       frames = db.prepare("SELECT id FROM frames ORDER BY updated_at DESC LIMIT ?").all(frameCount);
-    } catch (error) {
+    } catch {
       logger.warn("Frames table not found, using mock data for benchmark");
       frames = Array.from({ length: Math.min(frameCount, 10) }, (_, i) => ({
         id: `frame-${i}`
@@ -205,9 +205,9 @@ class PerformanceBenchmark {
     const suiteStart = performance.now();
     logger.info("Starting Performance Benchmark Suite");
     const tasksFile = join(projectRoot, ".stackmemory", "tasks.jsonl");
-    const jsonlResult = await this.benchmarkJSONLParsing(tasksFile);
-    const cacheResult = await this.benchmarkContextCache();
-    const lazyResult = await this.benchmarkLazyLoading(db, projectId);
+    const _jsonlResult = await this.benchmarkJSONLParsing(tasksFile);
+    const _cacheResult = await this.benchmarkContextCache();
+    const _lazyResult = await this.benchmarkLazyLoading(db, projectId);
     const totalDuration = performance.now() - suiteStart;
     const averageImprovement = this.results.filter((r) => r.improvement !== void 0).reduce((sum, r) => sum + (r.improvement || 0), 0) / this.results.filter((r) => r.improvement !== void 0).length;
     const suite = {

package/dist/src/core/performance/performance-profiler.js

@@ -4,7 +4,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../monitoring/logger.js";
 import { getQueryStatistics } from "../trace/db-trace-wrapper.js";
-function getEnv(key, defaultValue) {
+function _getEnv(key, defaultValue) {
   const value = process.env[key];
   if (value === void 0) {
     if (defaultValue !== void 0) return defaultValue;
@@ -12,7 +12,7 @@ function getEnv(key, defaultValue) {
   }
   return value;
 }
-function getOptionalEnv(key) {
+function _getOptionalEnv(key) {
   return process.env[key];
 }
 class PerformanceProfiler {