@stackmemoryai/stackmemory 0.2.9 → 0.3.0

package/dist/core/database/query-cache.js

@@ -0,0 +1,284 @@
+import { logger } from "../monitoring/logger.js";
+class LRUQueryCache {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  ttlMs;
+  enableMetrics;
+  // Metrics
+  metrics = {
+    hits: 0,
+    misses: 0,
+    evictions: 0,
+    totalQueries: 0
+  };
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? 1e3;
+    this.ttlMs = options.ttlMs ?? 3e5;
+    this.enableMetrics = options.enableMetrics ?? true;
+    logger.info("Query cache initialized", {
+      maxSize: this.maxSize,
+      ttlMs: this.ttlMs,
+      enableMetrics: this.enableMetrics
+    });
+  }
+  /**
+   * Get a value from cache
+   */
+  get(key) {
+    if (this.enableMetrics) {
+      this.metrics.totalQueries++;
+    }
+    const entry = this.cache.get(key);
+    if (!entry) {
+      if (this.enableMetrics) {
+        this.metrics.misses++;
+      }
+      return void 0;
+    }
+    const now = Date.now();
+    if (now - entry.createdAt > this.ttlMs) {
+      this.cache.delete(key);
+      if (this.enableMetrics) {
+        this.metrics.misses++;
+        this.metrics.evictions++;
+      }
+      logger.debug("Cache entry expired", { key, age: now - entry.createdAt });
+      return void 0;
+    }
+    entry.accessCount++;
+    entry.lastAccessed = now;
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    if (this.enableMetrics) {
+      this.metrics.hits++;
+    }
+    logger.debug("Cache hit", { key, accessCount: entry.accessCount });
+    return entry.value;
+  }
+  /**
+   * Set a value in cache
+   */
+  set(key, value) {
+    const now = Date.now();
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    while (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+        if (this.enableMetrics) {
+          this.metrics.evictions++;
+        }
+        logger.debug("Evicted LRU entry", { key: firstKey });
+      } else {
+        break;
+      }
+    }
+    const entry = {
+      value,
+      createdAt: now,
+      accessCount: 0,
+      lastAccessed: now
+    };
+    this.cache.set(key, entry);
+    logger.debug("Cache set", { key, size: this.cache.size });
+  }
+  /**
+   * Delete a specific key
+   */
+  delete(key) {
+    const deleted = this.cache.delete(key);
+    if (deleted) {
+      logger.debug("Cache delete", { key });
+    }
+    return deleted;
+  }
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    const size = this.cache.size;
+    this.cache.clear();
+    logger.info("Cache cleared", { previousSize: size });
+  }
+  /**
+   * Invalidate entries matching a pattern
+   */
+  invalidatePattern(pattern) {
+    let count = 0;
+    for (const key of this.cache.keys()) {
+      if (pattern.test(key)) {
+        this.cache.delete(key);
+        count++;
+      }
+    }
+    logger.info("Pattern invalidation", { pattern: pattern.source, invalidated: count });
+    return count;
+  }
+  /**
+   * Get cache metrics
+   */
+  getMetrics() {
+    return {
+      ...this.metrics,
+      hitRate: this.metrics.totalQueries > 0 ? this.metrics.hits / this.metrics.totalQueries : 0,
+      size: this.cache.size,
+      maxSize: this.maxSize
+    };
+  }
+  /**
+   * Get cache contents for debugging
+   */
+  debug() {
+    return Array.from(this.cache.entries()).map(([key, entry]) => ({ key, entry }));
+  }
+  /**
+   * Cleanup expired entries
+   */
+  cleanup() {
+    const now = Date.now();
+    let removed = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.createdAt > this.ttlMs) {
+        this.cache.delete(key);
+        removed++;
+        if (this.enableMetrics) {
+          this.metrics.evictions++;
+        }
+      }
+    }
+    if (removed > 0) {
+      logger.info("Cache cleanup completed", { removed, remaining: this.cache.size });
+    }
+    return removed;
+  }
+}
+class StackMemoryQueryCache {
+  frameCache = new LRUQueryCache({ maxSize: 500, ttlMs: 3e5 });
+  // 5 min
+  eventCache = new LRUQueryCache({ maxSize: 1e3, ttlMs: 18e4 });
+  // 3 min  
+  anchorCache = new LRUQueryCache({ maxSize: 200, ttlMs: 6e5 });
+  // 10 min
+  digestCache = new LRUQueryCache({ maxSize: 100, ttlMs: 9e5 });
+  // 15 min
+  /**
+   * Cache frame data
+   */
+  cacheFrame(frameId, data) {
+    this.frameCache.set(`frame:${frameId}`, data);
+  }
+  getFrame(frameId) {
+    return this.frameCache.get(`frame:${frameId}`);
+  }
+  /**
+   * Cache frame context assemblies (expensive operations)
+   */
+  cacheFrameContext(frameId, context) {
+    this.frameCache.set(`context:${frameId}`, context);
+  }
+  getFrameContext(frameId) {
+    return this.frameCache.get(`context:${frameId}`);
+  }
+  /**
+   * Cache events for a frame
+   */
+  cacheFrameEvents(frameId, events) {
+    this.eventCache.set(`events:${frameId}`, events);
+  }
+  getFrameEvents(frameId) {
+    return this.eventCache.get(`events:${frameId}`);
+  }
+  /**
+   * Cache anchors
+   */
+  cacheAnchors(frameId, anchors) {
+    this.anchorCache.set(`anchors:${frameId}`, anchors);
+  }
+  getAnchors(frameId) {
+    return this.anchorCache.get(`anchors:${frameId}`);
+  }
+  /**
+   * Cache digest data
+   */
+  cacheDigest(frameId, digest) {
+    this.digestCache.set(`digest:${frameId}`, digest);
+  }
+  getDigest(frameId) {
+    return this.digestCache.get(`digest:${frameId}`);
+  }
+  /**
+   * Invalidate caches for a specific frame
+   */
+  invalidateFrame(frameId) {
+    this.frameCache.delete(`frame:${frameId}`);
+    this.frameCache.delete(`context:${frameId}`);
+    this.eventCache.delete(`events:${frameId}`);
+    this.anchorCache.delete(`anchors:${frameId}`);
+    this.digestCache.delete(`digest:${frameId}`);
+    logger.info("Invalidated frame caches", { frameId });
+  }
+  /**
+   * Invalidate all caches for a project  
+   */
+  invalidateProject(projectId) {
+    const pattern = new RegExp(`^(frame|context|events|anchors|digest):.+`);
+    let total = 0;
+    total += this.frameCache.invalidatePattern(pattern);
+    total += this.eventCache.invalidatePattern(pattern);
+    total += this.anchorCache.invalidatePattern(pattern);
+    total += this.digestCache.invalidatePattern(pattern);
+    logger.info("Invalidated project caches", { projectId, totalInvalidated: total });
+  }
+  /**
+   * Get comprehensive cache metrics
+   */
+  getMetrics() {
+    return {
+      frame: this.frameCache.getMetrics(),
+      event: this.eventCache.getMetrics(),
+      anchor: this.anchorCache.getMetrics(),
+      digest: this.digestCache.getMetrics()
+    };
+  }
+  /**
+   * Cleanup all caches
+   */
+  cleanup() {
+    this.frameCache.cleanup();
+    this.eventCache.cleanup();
+    this.anchorCache.cleanup();
+    this.digestCache.cleanup();
+  }
+  /**
+   * Clear all caches
+   */
+  clear() {
+    this.frameCache.clear();
+    this.eventCache.clear();
+    this.anchorCache.clear();
+    this.digestCache.clear();
+    logger.info("All StackMemory caches cleared");
+  }
+}
+let globalCache = null;
+function getQueryCache() {
+  if (!globalCache) {
+    globalCache = new StackMemoryQueryCache();
+  }
+  return globalCache;
+}
+function createCacheKey(queryName, params) {
+  const paramsStr = params.map(
+    (p) => typeof p === "object" ? JSON.stringify(p) : String(p)
+  ).join(":");
+  return `${queryName}:${paramsStr}`;
+}
+export {
+  LRUQueryCache,
+  StackMemoryQueryCache,
+  createCacheKey,
+  getQueryCache
+};
+//# sourceMappingURL=query-cache.js.map

package/dist/core/database/query-cache.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/database/query-cache.ts"],
+  "sourcesContent": ["/**\n * Query Result Cache\n * LRU cache for frequently accessed database query results\n */\n\nimport { logger } from '../monitoring/logger.js';\n\nexport interface CacheOptions {\n  maxSize?: number;\n  ttlMs?: number;\n  enableMetrics?: boolean;\n}\n\nexport interface CacheEntry<T> {\n  value: T;\n  createdAt: number;\n  accessCount: number;\n  lastAccessed: number;\n}\n\nexport interface CacheMetrics {\n  hits: number;\n  misses: number;\n  evictions: number;\n  totalQueries: number;\n  hitRate: number;\n  size: number;\n  maxSize: number;\n}\n\nexport class LRUQueryCache<T = any> {\n  private cache = new Map<string, CacheEntry<T>>();\n  private maxSize: number;\n  private ttlMs: number;\n  private enableMetrics: boolean;\n  \n  // Metrics\n  private metrics: Omit<CacheMetrics, 'hitRate' | 'size' | 'maxSize'> = {\n    hits: 0,\n    misses: 0,\n    evictions: 0,\n    totalQueries: 0,\n  };\n\n  constructor(options: CacheOptions = {}) {\n    this.maxSize = options.maxSize ?? 1000;\n    this.ttlMs = options.ttlMs ?? 300000; // 5 minutes default\n    this.enableMetrics = options.enableMetrics ?? true;\n\n    logger.info('Query cache initialized', {\n      maxSize: this.maxSize,\n      ttlMs: this.ttlMs,\n      enableMetrics: this.enableMetrics,\n    });\n  }\n\n  /**\n   * Get a value from cache\n   */\n  get(key: string): T | undefined {\n    if (this.enableMetrics) {\n      this.metrics.totalQueries++;\n    }\n\n    const entry = this.cache.get(key);\n    \n    if (!entry) {\n      if (this.enableMetrics) {\n        this.metrics.misses++;\n      }\n      return undefined;\n    }\n\n    // Check TTL\n    const now = Date.now();\n    if (now - entry.createdAt > this.ttlMs) {\n      this.cache.delete(key);\n      if (this.enableMetrics) {\n        this.metrics.misses++;\n        this.metrics.evictions++;\n      }\n      logger.debug('Cache entry expired', { key, age: now - entry.createdAt });\n      return undefined;\n    }\n\n    // Update access stats and move to end (most recently used)\n    entry.accessCount++;\n    entry.lastAccessed = now;\n    this.cache.delete(key);\n    this.cache.set(key, entry);\n\n    if (this.enableMetrics) {\n      this.metrics.hits++;\n    }\n\n    logger.debug('Cache hit', { key, accessCount: entry.accessCount });\n    return entry.value;\n  }\n\n  /**\n   * Set a value in cache\n   */\n  set(key: string, value: T): void {\n    const now = Date.now();\n    \n    // Remove existing entry if present\n    if (this.cache.has(key)) {\n      this.cache.delete(key);\n    }\n    \n    // Evict least recently used entries if at capacity\n    while (this.cache.size >= this.maxSize) {\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey !== undefined) {\n        this.cache.delete(firstKey);\n        if (this.enableMetrics) {\n          this.metrics.evictions++;\n        }\n        logger.debug('Evicted LRU entry', { key: firstKey });\n      } else {\n        break;\n      }\n    }\n\n    // Add new entry\n    const entry: CacheEntry<T> = {\n      value,\n      createdAt: now,\n      accessCount: 0,\n      lastAccessed: now,\n    };\n\n    this.cache.set(key, entry);\n    logger.debug('Cache set', { key, size: this.cache.size });\n  }\n\n  /**\n   * Delete a specific key\n   */\n  delete(key: string): boolean {\n    const deleted = this.cache.delete(key);\n    if (deleted) {\n      logger.debug('Cache delete', { key });\n    }\n    return deleted;\n  }\n\n  /**\n   * Clear all cached entries\n   */\n  clear(): void {\n    const size = this.cache.size;\n    this.cache.clear();\n    logger.info('Cache cleared', { previousSize: size });\n  }\n\n  /**\n   * Invalidate entries matching a pattern\n   */\n  invalidatePattern(pattern: RegExp): number {\n    let count = 0;\n    for (const key of this.cache.keys()) {\n      if (pattern.test(key)) {\n        this.cache.delete(key);\n        count++;\n      }\n    }\n    logger.info('Pattern invalidation', { pattern: pattern.source, invalidated: count });\n    return count;\n  }\n\n  /**\n   * Get cache metrics\n   */\n  getMetrics(): CacheMetrics {\n    return {\n      ...this.metrics,\n      hitRate: this.metrics.totalQueries > 0 \n        ? this.metrics.hits / this.metrics.totalQueries \n        : 0,\n      size: this.cache.size,\n      maxSize: this.maxSize,\n    };\n  }\n\n  /**\n   * Get cache contents for debugging\n   */\n  debug(): Array<{ key: string; entry: CacheEntry<T> }> {\n    return Array.from(this.cache.entries()).map(([key, entry]) => ({ key, entry }));\n  }\n\n  /**\n   * Cleanup expired entries\n   */\n  cleanup(): number {\n    const now = Date.now();\n    let removed = 0;\n\n    for (const [key, entry] of this.cache.entries()) {\n      if (now - entry.createdAt > this.ttlMs) {\n        this.cache.delete(key);\n        removed++;\n        if (this.enableMetrics) {\n          this.metrics.evictions++;\n        }\n      }\n    }\n\n    if (removed > 0) {\n      logger.info('Cache cleanup completed', { removed, remaining: this.cache.size });\n    }\n\n    return removed;\n  }\n}\n\n/**\n * Query cache specifically designed for StackMemory operations\n */\nexport class StackMemoryQueryCache {\n  private frameCache = new LRUQueryCache<any>({ maxSize: 500, ttlMs: 300000 }); // 5 min\n  private eventCache = new LRUQueryCache<any>({ maxSize: 1000, ttlMs: 180000 }); // 3 min  \n  private anchorCache = new LRUQueryCache<any>({ maxSize: 200, ttlMs: 600000 }); // 10 min\n  private digestCache = new LRUQueryCache<any>({ maxSize: 100, ttlMs: 900000 }); // 15 min\n\n  /**\n   * Cache frame data\n   */\n  cacheFrame(frameId: string, data: any): void {\n    this.frameCache.set(`frame:${frameId}`, data);\n  }\n\n  getFrame(frameId: string): any {\n    return this.frameCache.get(`frame:${frameId}`);\n  }\n\n  /**\n   * Cache frame context assemblies (expensive operations)\n   */\n  cacheFrameContext(frameId: string, context: any): void {\n    this.frameCache.set(`context:${frameId}`, context);\n  }\n\n  getFrameContext(frameId: string): any {\n    return this.frameCache.get(`context:${frameId}`);\n  }\n\n  /**\n   * Cache events for a frame\n   */\n  cacheFrameEvents(frameId: string, events: any[]): void {\n    this.eventCache.set(`events:${frameId}`, events);\n  }\n\n  getFrameEvents(frameId: string): any[] {\n    return this.eventCache.get(`events:${frameId}`);\n  }\n\n  /**\n   * Cache anchors\n   */\n  cacheAnchors(frameId: string, anchors: any[]): void {\n    this.anchorCache.set(`anchors:${frameId}`, anchors);\n  }\n\n  getAnchors(frameId: string): any[] {\n    return this.anchorCache.get(`anchors:${frameId}`);\n  }\n\n  /**\n   * Cache digest data\n   */\n  cacheDigest(frameId: string, digest: any): void {\n    this.digestCache.set(`digest:${frameId}`, digest);\n  }\n\n  getDigest(frameId: string): any {\n    return this.digestCache.get(`digest:${frameId}`);\n  }\n\n  /**\n   * Invalidate caches for a specific frame\n   */\n  invalidateFrame(frameId: string): void {\n    this.frameCache.delete(`frame:${frameId}`);\n    this.frameCache.delete(`context:${frameId}`);\n    this.eventCache.delete(`events:${frameId}`);\n    this.anchorCache.delete(`anchors:${frameId}`);\n    this.digestCache.delete(`digest:${frameId}`);\n    \n    logger.info('Invalidated frame caches', { frameId });\n  }\n\n  /**\n   * Invalidate all caches for a project  \n   */\n  invalidateProject(projectId: string): void {\n    const pattern = new RegExp(`^(frame|context|events|anchors|digest):.+`);\n    \n    let total = 0;\n    total += this.frameCache.invalidatePattern(pattern);\n    total += this.eventCache.invalidatePattern(pattern);\n    total += this.anchorCache.invalidatePattern(pattern);\n    total += this.digestCache.invalidatePattern(pattern);\n    \n    logger.info('Invalidated project caches', { projectId, totalInvalidated: total });\n  }\n\n  /**\n   * Get comprehensive cache metrics\n   */\n  getMetrics() {\n    return {\n      frame: this.frameCache.getMetrics(),\n      event: this.eventCache.getMetrics(),\n      anchor: this.anchorCache.getMetrics(),\n      digest: this.digestCache.getMetrics(),\n    };\n  }\n\n  /**\n   * Cleanup all caches\n   */\n  cleanup(): void {\n    this.frameCache.cleanup();\n    this.eventCache.cleanup();\n    this.anchorCache.cleanup();\n    this.digestCache.cleanup();\n  }\n\n  /**\n   * Clear all caches\n   */\n  clear(): void {\n    this.frameCache.clear();\n    this.eventCache.clear();\n    this.anchorCache.clear();\n    this.digestCache.clear();\n    \n    logger.info('All StackMemory caches cleared');\n  }\n}\n\n// Global cache instance\nlet globalCache: StackMemoryQueryCache | null = null;\n\n/**\n * Get or create global query cache\n */\nexport function getQueryCache(): StackMemoryQueryCache {\n  if (!globalCache) {\n    globalCache = new StackMemoryQueryCache();\n  }\n  return globalCache;\n}\n\n/**\n * Create a cache key from query parameters\n */\nexport function createCacheKey(queryName: string, params: any[]): string {\n  const paramsStr = params.map(p => \n    typeof p === 'object' ? JSON.stringify(p) : String(p)\n  ).join(':');\n  \n  return `${queryName}:${paramsStr}`;\n}"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/digest/__tests__/enhanced-hybrid-digest.test.js

@@ -0,0 +1,379 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import {
+  EnhancedHybridDigestGenerator
+} from "../enhanced-hybrid-digest";
+describe("EnhancedHybridDigestGenerator", () => {
+  let db;
+  let generator;
+  let mockLLMProvider;
+  beforeEach(() => {
+    db = new Database(":memory:");
+    mockLLMProvider = {
+      generateSummary: vi.fn().mockResolvedValue({
+        summary: "Test summary",
+        insight: "Test insight",
+        flaggedIssue: "Test issue",
+        generatedAt: Date.now(),
+        modelUsed: "test-model",
+        tokensUsed: 150
+      })
+    };
+    generator = new EnhancedHybridDigestGenerator(
+      db,
+      { enableAIGeneration: true, maxTokens: 200 },
+      mockLLMProvider,
+      { checkInterval: 100 }
+      // Fast interval for testing
+    );
+  });
+  afterEach(() => {
+    generator.shutdown();
+    db.close();
+  });
+  describe("Idle Detection", () => {
+    it("should detect idle state after no tool calls", async () => {
+      let status = generator.getIdleStatus();
+      expect(status.isIdle).toBe(false);
+      generator.recordToolCall();
+      status = generator.getIdleStatus();
+      expect(status.isIdle).toBe(false);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      status = generator.getIdleStatus();
+      expect(status.timeSinceLastToolCall).toBeGreaterThan(0);
+    });
+    it("should track user input activity", () => {
+      generator.recordUserInput();
+      const status = generator.getIdleStatus();
+      expect(status.timeSinceLastInput).toBeLessThan(100);
+    });
+    it("should track active frames", () => {
+      generator.onFrameOpened("frame-1");
+      generator.onFrameOpened("frame-2");
+      let status = generator.getIdleStatus();
+      expect(status.activeFrames).toBe(2);
+      generator.onFrameClosed("frame-1");
+      status = generator.getIdleStatus();
+      expect(status.activeFrames).toBe(1);
+    });
+    it("should handle interruption gracefully", () => {
+      generator.handleInterruption();
+      const status = generator.getIdleStatus();
+      expect(status.isIdle).toBe(false);
+    });
+  });
+  describe("Digest Generation", () => {
+    const mockFrame = {
+      frame_id: "test-frame-1",
+      name: "Test Frame",
+      type: "task",
+      state: "active",
+      created_at: Math.floor(Date.now() / 1e3),
+      closed_at: null,
+      inputs: {},
+      outputs: {},
+      digest_text: "",
+      digest_json: {},
+      metadata: {}
+    };
+    const mockEvents = [
+      {
+        event_id: "evt-1",
+        frame_id: "test-frame-1",
+        ts: Math.floor(Date.now() / 1e3),
+        event_type: "tool_call",
+        payload: {
+          tool_name: "write_file",
+          file_path: "/src/test.ts"
+        }
+      },
+      {
+        event_id: "evt-2",
+        frame_id: "test-frame-1",
+        ts: Math.floor(Date.now() / 1e3),
+        event_type: "tool_result",
+        payload: {
+          success: true,
+          output: "10 tests passed"
+        }
+      }
+    ];
+    const mockAnchors = [
+      {
+        anchor_id: "anc-1",
+        frame_id: "test-frame-1",
+        type: "DECISION",
+        text: "Use TypeScript for type safety",
+        metadata: {},
+        created_at: Math.floor(Date.now() / 1e3)
+      }
+    ];
+    const mockInput = {
+      frame: mockFrame,
+      events: mockEvents,
+      anchors: mockAnchors
+    };
+    it("should generate deterministic digest immediately", () => {
+      const digest = generator.generateDigest(mockInput);
+      expect(digest).toBeDefined();
+      expect(digest.frameId).toBe("test-frame-1");
+      expect(digest.frameName).toBe("Test Frame");
+      expect(digest.deterministic).toBeDefined();
+      expect(digest.status).toBe("ai_pending");
+    });
+    it("should extract files modified correctly", () => {
+      const digest = generator.generateDigest(mockInput);
+      expect(digest.deterministic.filesModified).toHaveLength(1);
+      expect(digest.deterministic.filesModified[0]).toEqual({
+        path: "/src/test.ts",
+        operation: "modify",
+        linesChanged: void 0
+      });
+    });
+    it("should extract test results", () => {
+      const digest = generator.generateDigest(mockInput);
+      expect(digest.deterministic.testsRun).toHaveLength(1);
+      expect(digest.deterministic.testsRun[0]).toEqual({
+        name: "10 tests",
+        status: "passed",
+        duration: void 0
+      });
+    });
+    it("should extract decisions from anchors", () => {
+      const digest = generator.generateDigest(mockInput);
+      expect(digest.deterministic.decisions).toContain(
+        "Use TypeScript for type safety"
+      );
+    });
+    it("should generate text summary", () => {
+      const digest = generator.generateDigest(mockInput);
+      expect(digest.text).toBeDefined();
+      expect(digest.text).toContain("Test Frame");
+      expect(digest.text).toContain("Status: success");
+    });
+  });
+  describe("AI Generation Queue", () => {
+    it("should queue frames for AI generation", async () => {
+      const mockInput = {
+        frame: {
+          frame_id: "test-ai-1",
+          name: "AI Test Frame",
+          type: "feature",
+          state: "closed",
+          // Frame should be closed for AI generation
+          created_at: Math.floor(Date.now() / 1e3),
+          closed_at: Math.floor(Date.now() / 1e3) + 100,
+          inputs: {},
+          outputs: {},
+          digest_text: "",
+          digest_json: {},
+          metadata: {}
+        },
+        events: [],
+        anchors: []
+      };
+      const digest = generator.generateDigest(mockInput);
+      expect(digest.status).toBe("ai_pending");
+      await generator.forceProcessQueue();
+      const wasCalled = mockLLMProvider.generateSummary.mock.calls.length > 0;
+      if (!wasCalled) {
+        expect(digest.status).toBe("ai_pending");
+      }
+    });
+    it("should prioritize frame on close", () => {
+      generator.onFrameOpened("frame-close-test");
+      generator.onFrameClosed("frame-close-test");
+      const status = generator.getIdleStatus();
+      expect(status.activeFrames).toBe(0);
+    });
+  });
+  describe("Pattern Detection", () => {
+    it("should detect test-driven development pattern", () => {
+      const input = {
+        frame: {
+          frame_id: "tdd-frame",
+          name: "TDD Frame",
+          type: "feature",
+          state: "closed",
+          created_at: Math.floor(Date.now() / 1e3),
+          closed_at: Math.floor(Date.now() / 1e3) + 300,
+          inputs: {},
+          outputs: {},
+          digest_text: "",
+          digest_json: {},
+          metadata: {}
+        },
+        events: [
+          {
+            event_id: "evt-test",
+            frame_id: "tdd-frame",
+            ts: Math.floor(Date.now() / 1e3),
+            event_type: "tool_call",
+            payload: {
+              tool_name: "run_test",
+              command: "npm test",
+              output: "5 tests passed"
+            }
+          },
+          {
+            event_id: "evt-code",
+            frame_id: "tdd-frame",
+            ts: Math.floor(Date.now() / 1e3),
+            event_type: "tool_call",
+            payload: {
+              tool_name: "edit_file",
+              file_path: "/src/feature.ts"
+            }
+          }
+        ],
+        anchors: []
+      };
+      const digest = generator.generateDigest(input);
+      expect(digest.deterministic.testsRun.length).toBeGreaterThan(0);
+      expect(digest.deterministic.filesModified).toHaveLength(1);
+    });
+    it("should identify technical debt", () => {
+      const input = {
+        frame: {
+          frame_id: "debt-frame",
+          name: "Tech Debt Frame",
+          type: "feature",
+          state: "closed",
+          created_at: Math.floor(Date.now() / 1e3),
+          closed_at: Math.floor(Date.now() / 1e3) + 300,
+          inputs: {},
+          outputs: {},
+          digest_text: "",
+          digest_json: {},
+          metadata: {}
+        },
+        events: [
+          {
+            event_id: "evt-1",
+            frame_id: "debt-frame",
+            ts: Math.floor(Date.now() / 1e3),
+            event_type: "tool_call",
+            payload: {
+              tool_name: "write_file",
+              file_path: "/src/file1.ts"
+            }
+          },
+          {
+            event_id: "evt-2",
+            frame_id: "debt-frame",
+            ts: Math.floor(Date.now() / 1e3),
+            event_type: "tool_call",
+            payload: {
+              tool_name: "write_file",
+              file_path: "/src/file2.ts"
+            }
+          },
+          {
+            event_id: "evt-3",
+            frame_id: "debt-frame",
+            ts: Math.floor(Date.now() / 1e3),
+            event_type: "tool_call",
+            payload: {
+              tool_name: "write_file",
+              file_path: "/src/file3.ts"
+            }
+          },
+          {
+            event_id: "evt-4",
+            frame_id: "debt-frame",
+            ts: Math.floor(Date.now() / 1e3),
+            event_type: "tool_call",
+            payload: {
+              tool_name: "write_file",
+              file_path: "/src/file4.ts"
+            }
+          }
+        ],
+        anchors: [
+          {
+            anchor_id: "anc-todo",
+            frame_id: "debt-frame",
+            type: "DECISION",
+            text: "TODO: Refactor this later",
+            metadata: {},
+            created_at: Math.floor(Date.now() / 1e3)
+          }
+        ]
+      };
+      const digest = generator.generateDigest(input);
+      expect(digest.deterministic.filesModified.length).toBeGreaterThan(3);
+      expect(digest.deterministic.testsRun).toHaveLength(0);
+      expect(
+        digest.deterministic.decisions.some(
+          (d) => d.toLowerCase().includes("todo")
+        )
+      ).toBe(true);
+    });
+  });
+  describe("60/40 Split Validation", () => {
+    it("should maintain 60% deterministic content", () => {
+      const input = {
+        frame: {
+          frame_id: "split-test",
+          name: "Split Test Frame",
+          type: "task",
+          state: "active",
+          created_at: Math.floor(Date.now() / 1e3),
+          closed_at: null,
+          inputs: {},
+          outputs: {},
+          digest_text: "",
+          digest_json: {},
+          metadata: {}
+        },
+        events: Array(10).fill(null).map((_, i) => ({
+          event_id: `evt-${i}`,
+          frame_id: "split-test",
+          ts: Math.floor(Date.now() / 1e3),
+          event_type: "tool_call",
+          payload: { tool_name: `tool_${i}` }
+        })),
+        anchors: Array(5).fill(null).map((_, i) => ({
+          anchor_id: `anc-${i}`,
+          frame_id: "split-test",
+          type: "DECISION",
+          text: `Decision ${i}`,
+          metadata: {},
+          created_at: Math.floor(Date.now() / 1e3)
+        }))
+      };
+      const digest = generator.generateDigest(input);
+      expect(digest.deterministic).toBeDefined();
+      expect(digest.deterministic.toolCallCount).toBe(10);
+      expect(digest.deterministic.decisions).toHaveLength(5);
+      expect(digest.aiGenerated).toBeUndefined();
+      expect(digest.status).toBe("ai_pending");
+    });
+    it("should keep AI summaries under 200 tokens", async () => {
+      const input = {
+        frame: {
+          frame_id: "token-test",
+          name: "Token Test",
+          type: "task",
+          state: "closed",
+          created_at: Math.floor(Date.now() / 1e3),
+          closed_at: Math.floor(Date.now() / 1e3) + 100,
+          inputs: {},
+          outputs: {},
+          digest_text: "",
+          digest_json: {},
+          metadata: {}
+        },
+        events: [],
+        anchors: []
+      };
+      generator.generateDigest(input);
+      await generator.forceProcessQueue();
+      const mockCalls = vi.mocked(mockLLMProvider.generateSummary).mock.calls;
+      if (mockCalls.length > 0) {
+        expect(mockCalls[0][2]).toBe(200);
+      }
+    });
+  });
+});
+//# sourceMappingURL=enhanced-hybrid-digest.test.js.map