prjct-cli 1.7.3 → 1.7.4

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [1.7.4] - 2026-02-07
+
+### Bug Fixes
+
+- add eviction policies to all in-memory caches (PRJ-288) (#143)
+
+
+## [1.7.4] - 2026-02-07
+
+### Bug Fixes
+- **Add eviction policies to all in-memory caches (PRJ-288)**: Replaced unbounded Maps with TTLCache in SessionLogManager and ContextBuilder, capped PatternStore decision contexts at 20 with FIFO eviction, and added 90-day archival for stale decisions to prevent unbounded memory growth.
+
+### Implementation Details
+- SessionLogManager: replaced 2 `Map` caches with `TTLCache` (maxSize: 50, TTL: 1hr)
+- ContextBuilder: replaced `Map` + `_mtimes` + manual TTL with single `TTLCache<CachedFile>` (maxSize: 200, TTL: 5s), added project-switch detection
+- PatternStore: added `afterLoad()` hook to truncate oversized contexts arrays, FIFO cap at 20 in `recordDecision()`, new `archiveStaleDecisions()` method for 90-day archival
+- Exposed `archiveStaleDecisions()` via MemorySystem facade
+
+### Test Plan
+
+#### For QA
+1. Run `bun test core/__tests__/agentic/cache-eviction.test.ts` — 12 new tests pass
+2. Run `bun test` — full suite (538 tests) passes with no regressions
+3. Run `bun run build` — compiles without errors
+4. Verify `prjct sync` and `prjct status` work normally
+
+#### For Users
+**What changed:** Internal optimization — in-memory caches now bounded to prevent memory growth during long sessions.
+**How to use:** No user-facing changes.
+**Breaking changes:** None
+
 ## [1.7.3] - 2026-02-07
 
 ### Bug Fixes

package/core/__tests__/agentic/cache-eviction.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Cache Eviction Policy Tests (PRJ-288)
+ * Verifies TTLCache integration, context caps, and archival.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { ContextBuilder } from '../../agentic/context-builder'
+import { MemorySystem, PatternStore } from '../../agentic/memory-system'
+import pathManager from '../../infrastructure/path-manager'
+import { SessionLogManager } from '../../session/session-log-manager'
+import { TTLCache } from '../../utils/cache'
+
+const TEST_GLOBAL_BASE_DIR = path.join(process.cwd(), '.tmp', 'prjct-cli-cache-tests')
+let testCounter = 0
+const getTestProjectId = () => `test-cache-${Date.now()}-${++testCounter}`
+
+describe('Cache Eviction Policies (PRJ-288)', () => {
+  beforeAll(async () => {
+    pathManager.setGlobalBaseDir(TEST_GLOBAL_BASE_DIR)
+    await fs.mkdir(TEST_GLOBAL_BASE_DIR, { recursive: true })
+  })
+
+  afterAll(async () => {
+    await fs.rm(TEST_GLOBAL_BASE_DIR, { recursive: true, force: true })
+  })
+
+  // ===========================================================================
+  // TTLCache unit tests
+  // ===========================================================================
+
+  describe('TTLCache', () => {
+    it('should evict oldest entries when maxSize exceeded', () => {
+      const cache = new TTLCache<string>({ maxSize: 3, ttl: 60_000 })
+
+      cache.set('a', 'val-a')
+      cache.set('b', 'val-b')
+      cache.set('c', 'val-c')
+      expect(cache.size).toBe(3)
+
+      cache.set('d', 'val-d')
+      expect(cache.size).toBe(3)
+      // 'a' was oldest, should be evicted
+      expect(cache.get('a')).toBeNull()
+      expect(cache.get('d')).toBe('val-d')
+    })
+
+    it('should expire entries after TTL', async () => {
+      const cache = new TTLCache<string>({ maxSize: 10, ttl: 50 })
+
+      cache.set('key', 'value')
+      expect(cache.get('key')).toBe('value')
+
+      await new Promise((r) => setTimeout(r, 80))
+      expect(cache.get('key')).toBeNull()
+    })
+
+    it('should prune expired entries', async () => {
+      const cache = new TTLCache<string>({ maxSize: 10, ttl: 50 })
+
+      cache.set('a', '1')
+      cache.set('b', '2')
+      await new Promise((r) => setTimeout(r, 80))
+
+      cache.set('c', '3') // fresh
+      const pruned = cache.prune()
+      expect(pruned).toBe(2)
+      expect(cache.size).toBe(1)
+      expect(cache.get('c')).toBe('3')
+    })
+  })
+
+  // ===========================================================================
+  // SessionLogManager
+  // ===========================================================================
+
+  describe('SessionLogManager', () => {
+    it('should use TTLCache with LRU eviction at 50 entries', () => {
+      const manager = new SessionLogManager()
+      // Verify clearCache works (exercises TTLCache.clear())
+      manager.clearCache()
+    })
+  })
+
+  // ===========================================================================
+  // ContextBuilder
+  // ===========================================================================
+
+  describe('ContextBuilder', () => {
+    it('should report stats from TTLCache', () => {
+      const builder = new ContextBuilder()
+      const stats = builder.getCacheStats()
+      expect(stats).toHaveProperty('size')
+      expect(stats).toHaveProperty('maxSize')
+      expect(stats).toHaveProperty('ttl')
+      expect(stats.maxSize).toBe(200)
+      expect(stats.ttl).toBe(5000)
+    })
+
+    it('should clear cache and reset projectId', () => {
+      const builder = new ContextBuilder()
+      builder.clearCache()
+      const stats = builder.getCacheStats()
+      expect(stats.size).toBe(0)
+    })
+
+    it('should invalidate specific cache entries', async () => {
+      const builder = new ContextBuilder()
+
+      // Write a temp file, batchRead to populate cache, then invalidate
+      const tmpDir = path.join(TEST_GLOBAL_BASE_DIR, 'ctx-test')
+      await fs.mkdir(tmpDir, { recursive: true })
+      const tmpFile = path.join(tmpDir, 'test.txt')
+      await fs.writeFile(tmpFile, 'hello')
+
+      const result = await builder.batchRead([tmpFile])
+      expect(result.get(tmpFile)).toBe('hello')
+
+      // Invalidate and verify
+      builder.invalidateCache(tmpFile)
+      // After invalidation, a fresh batchRead should re-read from disk
+      await fs.writeFile(tmpFile, 'updated')
+      const result2 = await builder.batchRead([tmpFile])
+      expect(result2.get(tmpFile)).toBe('updated')
+    })
+  })
+
+  // ===========================================================================
+  // PatternStore - contexts cap
+  // ===========================================================================
+
+  describe('PatternStore contexts cap', () => {
+    let TEST_PROJECT_ID: string
+
+    beforeEach(() => {
+      TEST_PROJECT_ID = getTestProjectId()
+    })
+
+    it('should cap decision contexts at 20 (FIFO)', async () => {
+      const store = new PatternStore()
+
+      // Record a decision with many unique contexts
+      for (let i = 0; i < 25; i++) {
+        await store.recordDecision(TEST_PROJECT_ID, 'test-key', 'test-value', `context-${i}`)
+      }
+
+      const patterns = await store.load(TEST_PROJECT_ID)
+      const decision = patterns.decisions['test-key']
+      expect(decision.contexts.length).toBeLessThanOrEqual(20)
+      // Should keep the latest contexts
+      expect(decision.contexts).toContain('context-24')
+      expect(decision.contexts).toContain('context-5')
+      // Oldest should be evicted
+      expect(decision.contexts).not.toContain('context-0')
+    })
+
+    it('should truncate oversized contexts on afterLoad', async () => {
+      const store = new PatternStore()
+      const projectId = getTestProjectId()
+
+      // Manually write a patterns file with oversized contexts
+      const filePath = path.join(
+        pathManager.getGlobalProjectPath(projectId),
+        'memory',
+        'patterns.json'
+      )
+      await fs.mkdir(path.dirname(filePath), { recursive: true })
+
+      const oversizedPatterns = {
+        version: 1,
+        decisions: {
+          'big-key': {
+            value: 'v',
+            count: 30,
+            firstSeen: '2025-01-01T00:00:00.000Z',
+            lastSeen: '2025-06-01T00:00:00.000Z',
+            confidence: 'high',
+            contexts: Array.from({ length: 50 }, (_, i) => `ctx-${i}`),
+            userConfirmed: true,
+          },
+        },
+        preferences: {},
+        workflows: {},
+        counters: {},
+      }
+      await fs.writeFile(filePath, JSON.stringify(oversizedPatterns, null, 2), 'utf-8')
+
+      // Load triggers afterLoad which should truncate
+      const patterns = await store.load(projectId)
+      expect(patterns.decisions['big-key'].contexts.length).toBe(20)
+      // Should keep the latest 20 (indices 30-49)
+      expect(patterns.decisions['big-key'].contexts[19]).toBe('ctx-49')
+    })
+  })
+
+  // ===========================================================================
+  // PatternStore - archival
+  // ===========================================================================
+
+  describe('PatternStore archival', () => {
+    it('should archive decisions older than 90 days', async () => {
+      const store = new PatternStore()
+      const projectId = getTestProjectId()
+
+      // Write patterns with a stale and an active decision
+      const filePath = path.join(
+        pathManager.getGlobalProjectPath(projectId),
+        'memory',
+        'patterns.json'
+      )
+      await fs.mkdir(path.dirname(filePath), { recursive: true })
+
+      const now = new Date()
+      const staleDate = new Date(now.getTime() - 100 * 24 * 60 * 60 * 1000) // 100 days ago
+      const recentDate = new Date(now.getTime() - 5 * 24 * 60 * 60 * 1000) // 5 days ago
+
+      const patterns = {
+        version: 1,
+        decisions: {
+          'stale-key': {
+            value: 'old',
+            count: 3,
+            firstSeen: staleDate.toISOString(),
+            lastSeen: staleDate.toISOString(),
+            confidence: 'medium',
+            contexts: ['ctx1'],
+            userConfirmed: false,
+          },
+          'active-key': {
+            value: 'new',
+            count: 5,
+            firstSeen: recentDate.toISOString(),
+            lastSeen: recentDate.toISOString(),
+            confidence: 'high',
+            contexts: ['ctx2'],
+            userConfirmed: true,
+          },
+        },
+        preferences: {},
+        workflows: {},
+        counters: {},
+      }
+      await fs.writeFile(filePath, JSON.stringify(patterns, null, 2), 'utf-8')
+
+      // Reset store cache to force disk read
+      store.reset()
+      const archived = await store.archiveStaleDecisions(projectId)
+      expect(archived).toBe(1)
+
+      // Verify active decision remains
+      const updated = await store.load(projectId)
+      expect(updated.decisions['active-key']).toBeDefined()
+      expect(updated.decisions['stale-key']).toBeUndefined()
+
+      // Verify archive file was created
+      const archivePath = path.join(
+        pathManager.getGlobalProjectPath(projectId),
+        'memory',
+        'patterns-archive.json'
+      )
+      const archiveContent = JSON.parse(await fs.readFile(archivePath, 'utf-8'))
+      expect(archiveContent['stale-key']).toBeDefined()
+      expect(archiveContent['stale-key'].value).toBe('old')
+    })
+
+    it('should return 0 when no stale decisions exist', async () => {
+      const store = new PatternStore()
+      const projectId = getTestProjectId()
+
+      // Record a fresh decision
+      await store.recordDecision(projectId, 'fresh-key', 'fresh-val', 'ctx')
+      const archived = await store.archiveStaleDecisions(projectId)
+      expect(archived).toBe(0)
+    })
+  })
+
+  // ===========================================================================
+  // MemorySystem delegation
+  // ===========================================================================
+
+  describe('MemorySystem.archiveStaleDecisions', () => {
+    it('should delegate to PatternStore', async () => {
+      const ms = new MemorySystem()
+      const projectId = getTestProjectId()
+
+      // Just verify no crash - no stale data to archive
+      ms.resetState()
+      await ms.recordDecision(projectId, 'key', 'val', 'ctx')
+      const count = await ms.archiveStaleDecisions(projectId)
+      expect(count).toBe(0)
+    })
+  })
+})

package/core/agentic/context-builder.ts

@@ -11,6 +11,7 @@ import configManager from '../infrastructure/config-manager'
 import pathManager from '../infrastructure/path-manager'
 import type { ContextPaths, ContextState, ProjectContext } from '../types'
 import { isNotFoundError } from '../types/fs'
+import { TTLCache } from '../utils/cache'
 
 // Re-export types for convenience
 export type { ContextPaths, ContextState, ProjectContext } from '../types'
@@ -20,34 +21,22 @@ export type Paths = ContextPaths
 export type Context = ProjectContext
 export type State = ContextState
 
+interface CachedFile {
+  content: string | null
+  mtime: number | null
+}
+
 /**
  * Builds and caches project context for Claude decisions.
  * Features parallel reads, selective loading, and anti-hallucination mtime checks.
  */
 class ContextBuilder {
-  private _cache: Map<string, string | null>
-  private _cacheTimeout: number
-  private _lastCacheTime: number | null
-  private _mtimes: Map<string, number>
+  private _cache: TTLCache<CachedFile>
+  private _currentProjectId: string | null
 
   constructor() {
-    // Session cache - cleared between commands or after timeout
-    this._cache = new Map()
-    // ANTI-HALLUCINATION: Reduced from 30s to 5s to prevent stale data
-    this._cacheTimeout = 5000 // 5 seconds (was 30s - caused stale context issues)
-    this._lastCacheTime = null
-    // Track file modification times for additional staleness detection
-    this._mtimes = new Map()
-  }
-
-  /**
-   * Clear cache if stale or force clear
-   */
-  private _clearCacheIfStale(force: boolean = false): void {
-    if (force || !this._lastCacheTime || Date.now() - this._lastCacheTime > this._cacheTimeout) {
-      this._cache.clear()
-      this._lastCacheTime = Date.now()
-    }
+    this._cache = new TTLCache<CachedFile>({ ttl: 5000, maxSize: 200 })
+    this._currentProjectId = null
   }
 
   /**
@@ -57,6 +46,12 @@ class ContextBuilder {
     const projectId = await configManager.getProjectId(projectPath)
     const globalPath = pathManager.getGlobalProjectPath(projectId!)
 
+    // Clear cache on project switch
+    if (this._currentProjectId !== null && this._currentProjectId !== projectId) {
+      this._cache.clear()
+    }
+    this._currentProjectId = projectId
+
     return {
       // Project identification
       projectId,
@@ -94,8 +89,6 @@ class ContextBuilder {
    * Uses Promise.all() for 40-60% faster file I/O
    */
   async loadState(context: Context, onlyKeys: string[] | null = null): Promise<State> {
-    this._clearCacheIfStale()
-
     const state: State = {}
     const entries = Object.entries(context.paths)
 
@@ -105,20 +98,16 @@ class ContextBuilder {
     // ANTI-HALLUCINATION: Verify mtime before trusting cache
     // Files can change between commands - stale cache causes hallucinations
     for (const [, filePath] of filteredEntries) {
-      if (this._cache.has(filePath)) {
+      const cachedEntry = this._cache.get(filePath)
+      if (cachedEntry !== null) {
         try {
           const stat = await fs.stat(filePath)
-          const cachedMtime = this._mtimes.get(filePath)
-          if (!cachedMtime || stat.mtimeMs > cachedMtime) {
-            // File changed since cached - invalidate
+          if (!cachedEntry.mtime || stat.mtimeMs > cachedEntry.mtime) {
             this._cache.delete(filePath)
-            this._mtimes.delete(filePath)
           }
         } catch (error) {
-          // File doesn't exist or access error - invalidate cache
           if (isNotFoundError(error)) {
             this._cache.delete(filePath)
-            this._mtimes.delete(filePath)
           } else {
             throw error
           }
@@ -129,8 +118,9 @@ class ContextBuilder {
     // Separate cached vs uncached files
     const uncachedEntries: [string, string][] = []
     for (const [key, filePath] of filteredEntries) {
-      if (this._cache.has(filePath)) {
-        state[key] = this._cache.get(filePath)!
+      const cachedEntry = this._cache.get(filePath)
+      if (cachedEntry !== null) {
+        state[key] = cachedEntry.content
       } else {
         uncachedEntries.push([key, filePath])
       }
@@ -155,13 +145,9 @@ class ContextBuilder {
 
       const results = await Promise.all(readPromises)
 
-      // Populate state and cache (with mtime for anti-hallucination)
       for (const { key, filePath, content, mtime } of results) {
         state[key] = content
-        this._cache.set(filePath, content)
-        if (mtime) {
-          this._mtimes.set(filePath, mtime)
-        }
+        this._cache.set(filePath, { content, mtime })
       }
     }
 
@@ -218,15 +204,14 @@ class ContextBuilder {
    * Utility for custom file sets
    */
   async batchRead(filePaths: string[]): Promise<Map<string, string | null>> {
-    this._clearCacheIfStale()
-
     const results = new Map<string, string | null>()
     const uncachedPaths: string[] = []
 
     // Check cache first
     for (const filePath of filePaths) {
-      if (this._cache.has(filePath)) {
-        results.set(filePath, this._cache.get(filePath)!)
+      const cachedEntry = this._cache.get(filePath)
+      if (cachedEntry !== null) {
+        results.set(filePath, cachedEntry.content)
       } else {
         uncachedPaths.push(filePath)
       }
@@ -250,7 +235,7 @@ class ContextBuilder {
 
       for (const { filePath, content } of readResults) {
         results.set(filePath, content)
-        this._cache.set(filePath, content)
+        this._cache.set(filePath, { content, mtime: null })
       }
     }
 
@@ -268,7 +253,8 @@ class ContextBuilder {
    * Force clear entire cache
    */
   clearCache(): void {
-    this._clearCacheIfStale(true)
+    this._cache.clear()
+    this._currentProjectId = null
   }
 
   /**
@@ -289,12 +275,8 @@ class ContextBuilder {
   /**
    * Get cache stats (for debugging/metrics)
    */
-  getCacheStats(): { size: number; lastRefresh: number | null; timeout: number } {
-    return {
-      size: this._cache.size,
-      lastRefresh: this._lastCacheTime,
-      timeout: this._cacheTimeout,
-    }
+  getCacheStats(): { size: number; maxSize: number; ttl: number } {
+    return this._cache.stats()
   }
 }
 

package/core/agentic/memory-system.ts

@@ -351,6 +351,9 @@ export class HistoryStore {
  * Persistent learned preferences and decisions.
  */
 export class PatternStore extends CachedStore<Patterns> {
+  private static readonly MAX_CONTEXTS = 20
+  private static readonly ARCHIVE_AGE_DAYS = 90
+
   protected getFilename(): string {
     return 'patterns.json'
   }
@@ -365,6 +368,14 @@ export class PatternStore extends CachedStore<Patterns> {
     }
   }
 
+  protected afterLoad(patterns: Patterns): void {
+    for (const decision of Object.values(patterns.decisions)) {
+      if (decision.contexts.length > PatternStore.MAX_CONTEXTS) {
+        decision.contexts = decision.contexts.slice(-PatternStore.MAX_CONTEXTS)
+      }
+    }
+  }
+
   // Convenience alias for backward compatibility
   async loadPatterns(projectId: string): Promise<Patterns> {
     return this.load(projectId)
@@ -404,6 +415,9 @@ export class PatternStore extends CachedStore<Patterns> {
         decision.lastSeen = now
         if (context && !decision.contexts.includes(context)) {
           decision.contexts.push(context)
+          if (decision.contexts.length > PatternStore.MAX_CONTEXTS) {
+            decision.contexts = decision.contexts.slice(-PatternStore.MAX_CONTEXTS)
+          }
         }
         if (options.userConfirmed) {
           decision.userConfirmed = true
@@ -553,6 +567,50 @@ export class PatternStore extends CachedStore<Patterns> {
       preferences: Object.keys(patterns.preferences).length,
     }
   }
+
+  private _getArchivePath(projectId: string): string {
+    const basePath = path.join(pathManager.getGlobalProjectPath(projectId), 'memory')
+    return path.join(basePath, 'patterns-archive.json')
+  }
+
+  async archiveStaleDecisions(projectId: string): Promise<number> {
+    const patterns = await this.load(projectId)
+    const now = Date.now()
+    const cutoff = PatternStore.ARCHIVE_AGE_DAYS * 24 * 60 * 60 * 1000
+
+    const staleKeys: string[] = []
+    for (const [key, decision] of Object.entries(patterns.decisions)) {
+      const lastSeenMs = new Date(decision.lastSeen).getTime()
+      if (now - lastSeenMs > cutoff) {
+        staleKeys.push(key)
+      }
+    }
+
+    if (staleKeys.length === 0) return 0
+
+    // Load or create archive
+    const archivePath = this._getArchivePath(projectId)
+    let archive: Record<string, unknown> = {}
+    try {
+      const content = await fs.readFile(archivePath, 'utf-8')
+      archive = JSON.parse(content)
+    } catch (error) {
+      if (!isNotFoundError(error)) throw error
+    }
+
+    // Move stale decisions to archive
+    for (const key of staleKeys) {
+      archive[key] = patterns.decisions[key]
+      delete patterns.decisions[key]
+    }
+
+    // Save archive and pruned patterns
+    await fs.mkdir(path.dirname(archivePath), { recursive: true })
+    await fs.writeFile(archivePath, JSON.stringify(archive, null, 2), 'utf-8')
+    await this.save(projectId)
+
+    return staleKeys.length
+  }
 }
 
 // =============================================================================
@@ -1226,6 +1284,10 @@ export class MemorySystem {
     return this._patternStore.getPatternsSummary(projectId)
   }
 
+  archiveStaleDecisions(projectId: string): Promise<number> {
+    return this._patternStore.archiveStaleDecisions(projectId)
+  }
+
   // ===========================================================================
   // TIER 3: History
   // ===========================================================================

package/core/session/session-log-manager.ts

@@ -13,6 +13,7 @@ import type {
   SessionStats,
 } from '../types'
 import { getErrorMessage } from '../types/fs'
+import { TTLCache } from '../utils/cache'
 import * as dateHelper from '../utils/date-helper'
 import * as fileHelper from '../utils/file-helper'
 import * as jsonlHelper from '../utils/jsonl-helper'
@@ -20,12 +21,12 @@ import { VERSION } from '../utils/version'
 import { migrateLegacyJsonl, migrateLegacyMarkdown } from './log-migration'
 
 export class SessionLogManager {
-  private currentSessionCache: Map<string, string>
-  private sessionMetadataCache: Map<string, SessionLogMetadata>
+  private currentSessionCache: TTLCache<string>
+  private sessionMetadataCache: TTLCache<SessionLogMetadata>
 
   constructor() {
-    this.currentSessionCache = new Map()
-    this.sessionMetadataCache = new Map()
+    this.currentSessionCache = new TTLCache<string>({ maxSize: 50, ttl: 3_600_000 })
+    this.sessionMetadataCache = new TTLCache<SessionLogMetadata>({ maxSize: 50, ttl: 3_600_000 })
   }
 
   /**
@@ -34,8 +35,9 @@ export class SessionLogManager {
   async getCurrentSession(projectId: string): Promise<string> {
     const cacheKey = `${projectId}-${this._getTodayKey()}`
 
-    if (this.currentSessionCache.has(cacheKey)) {
-      return this.currentSessionCache.get(cacheKey)!
+    const cached = this.currentSessionCache.get(cacheKey)
+    if (cached !== null) {
+      return cached
     }
 
     const sessionPath = await pathManager.ensureSessionPath(projectId)
@@ -243,8 +245,9 @@ export class SessionLogManager {
   private async _getSessionLogMetadata(sessionPath: string): Promise<SessionLogMetadata | null> {
     const metadataPath = path.join(sessionPath, 'session-meta.json')
 
-    if (this.sessionMetadataCache.has(sessionPath)) {
-      return this.sessionMetadataCache.get(sessionPath)!
+    const cached = this.sessionMetadataCache.get(sessionPath)
+    if (cached !== null) {
+      return cached
     }
 
     const metadata = await fileHelper.readJson<SessionLogMetadata>(metadataPath, null)

package/dist/bin/prjct.mjs

@@ -7572,28 +7572,16 @@ var init_context_builder = __esm({
     init_config_manager();
     init_path_manager();
     init_fs();
+    init_cache();
     ContextBuilder = class {
       static {
         __name(this, "ContextBuilder");
       }
       _cache;
-      _cacheTimeout;
-      _lastCacheTime;
-      _mtimes;
+      _currentProjectId;
       constructor() {
-        this._cache = /* @__PURE__ */ new Map();
-        this._cacheTimeout = 5e3;
-        this._lastCacheTime = null;
-        this._mtimes = /* @__PURE__ */ new Map();
-      }
-      /**
-       * Clear cache if stale or force clear
-       */
-      _clearCacheIfStale(force = false) {
-        if (force || !this._lastCacheTime || Date.now() - this._lastCacheTime > this._cacheTimeout) {
-          this._cache.clear();
-          this._lastCacheTime = Date.now();
-        }
+        this._cache = new TTLCache({ ttl: 5e3, maxSize: 200 });
+        this._currentProjectId = null;
       }
       /**
        * Build full project context for Claude
@@ -7601,6 +7589,10 @@ var init_context_builder = __esm({
       async build(projectPath, commandParams = {}) {
         const projectId = await config_manager_default.getProjectId(projectPath);
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
+        if (this._currentProjectId !== null && this._currentProjectId !== projectId) {
+          this._cache.clear();
+        }
+        this._currentProjectId = projectId;
         return {
           // Project identification
           projectId,
@@ -7636,23 +7628,20 @@ var init_context_builder = __esm({
        * Uses Promise.all() for 40-60% faster file I/O
        */
       async loadState(context2, onlyKeys = null) {
-        this._clearCacheIfStale();
         const state = {};
         const entries = Object.entries(context2.paths);
         const filteredEntries = onlyKeys ? entries.filter(([key]) => onlyKeys.includes(key)) : entries;
         for (const [, filePath] of filteredEntries) {
-          if (this._cache.has(filePath)) {
+          const cachedEntry = this._cache.get(filePath);
+          if (cachedEntry !== null) {
             try {
               const stat = await fs21.stat(filePath);
-              const cachedMtime = this._mtimes.get(filePath);
-              if (!cachedMtime || stat.mtimeMs > cachedMtime) {
+              if (!cachedEntry.mtime || stat.mtimeMs > cachedEntry.mtime) {
                 this._cache.delete(filePath);
-                this._mtimes.delete(filePath);
               }
             } catch (error) {
               if (isNotFoundError(error)) {
                 this._cache.delete(filePath);
-                this._mtimes.delete(filePath);
               } else {
                 throw error;
               }
@@ -7661,8 +7650,9 @@ var init_context_builder = __esm({
         }
         const uncachedEntries = [];
         for (const [key, filePath] of filteredEntries) {
-          if (this._cache.has(filePath)) {
-            state[key] = this._cache.get(filePath);
+          const cachedEntry = this._cache.get(filePath);
+          if (cachedEntry !== null) {
+            state[key] = cachedEntry.content;
           } else {
             uncachedEntries.push([key, filePath]);
           }
@@ -7685,10 +7675,7 @@ var init_context_builder = __esm({
           const results = await Promise.all(readPromises);
           for (const { key, filePath, content, mtime } of results) {
             state[key] = content;
-            this._cache.set(filePath, content);
-            if (mtime) {
-              this._mtimes.set(filePath, mtime);
-            }
+            this._cache.set(filePath, { content, mtime });
           }
         }
         return state;
@@ -7733,12 +7720,12 @@ var init_context_builder = __esm({
        * Utility for custom file sets
        */
       async batchRead(filePaths) {
-        this._clearCacheIfStale();
         const results = /* @__PURE__ */ new Map();
         const uncachedPaths = [];
         for (const filePath of filePaths) {
-          if (this._cache.has(filePath)) {
-            results.set(filePath, this._cache.get(filePath));
+          const cachedEntry = this._cache.get(filePath);
+          if (cachedEntry !== null) {
+            results.set(filePath, cachedEntry.content);
           } else {
             uncachedPaths.push(filePath);
           }
@@ -7758,7 +7745,7 @@ var init_context_builder = __esm({
           const readResults = await Promise.all(readPromises);
           for (const { filePath, content } of readResults) {
             results.set(filePath, content);
-            this._cache.set(filePath, content);
+            this._cache.set(filePath, { content, mtime: null });
           }
         }
         return results;
@@ -7773,7 +7760,8 @@ var init_context_builder = __esm({
        * Force clear entire cache
        */
       clearCache() {
-        this._clearCacheIfStale(true);
+        this._cache.clear();
+        this._currentProjectId = null;
       }
       /**
        * Check file existence
@@ -7793,11 +7781,7 @@ var init_context_builder = __esm({
        * Get cache stats (for debugging/metrics)
        */
       getCacheStats() {
-        return {
-          size: this._cache.size,
-          lastRefresh: this._lastCacheTime,
-          timeout: this._cacheTimeout
-        };
+        return this._cache.stats();
       }
     };
     contextBuilder = new ContextBuilder();
@@ -10094,10 +10078,12 @@ var init_memory_system = __esm({
         return getLastJsonLines(sessionPath, limit);
       }
     };
-    PatternStore = class extends CachedStore {
+    PatternStore = class _PatternStore extends CachedStore {
       static {
         __name(this, "PatternStore");
       }
+      static MAX_CONTEXTS = 20;
+      static ARCHIVE_AGE_DAYS = 90;
       getFilename() {
         return "patterns.json";
       }
@@ -10110,6 +10096,13 @@ var init_memory_system = __esm({
           counters: {}
         };
       }
+      afterLoad(patterns) {
+        for (const decision of Object.values(patterns.decisions)) {
+          if (decision.contexts.length > _PatternStore.MAX_CONTEXTS) {
+            decision.contexts = decision.contexts.slice(-_PatternStore.MAX_CONTEXTS);
+          }
+        }
+      }
       // Convenience alias for backward compatibility
       async loadPatterns(projectId) {
         return this.load(projectId);
@@ -10137,6 +10130,9 @@ var init_memory_system = __esm({
             decision.lastSeen = now;
             if (context2 && !decision.contexts.includes(context2)) {
               decision.contexts.push(context2);
+              if (decision.contexts.length > _PatternStore.MAX_CONTEXTS) {
+                decision.contexts = decision.contexts.slice(-_PatternStore.MAX_CONTEXTS);
+              }
             }
             if (options.userConfirmed) {
               decision.userConfirmed = true;
@@ -10246,6 +10242,39 @@ var init_memory_system = __esm({
           preferences: Object.keys(patterns.preferences).length
         };
       }
+      _getArchivePath(projectId) {
+        const basePath = path22.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
+        return path22.join(basePath, "patterns-archive.json");
+      }
+      async archiveStaleDecisions(projectId) {
+        const patterns = await this.load(projectId);
+        const now = Date.now();
+        const cutoff = _PatternStore.ARCHIVE_AGE_DAYS * 24 * 60 * 60 * 1e3;
+        const staleKeys = [];
+        for (const [key, decision] of Object.entries(patterns.decisions)) {
+          const lastSeenMs = new Date(decision.lastSeen).getTime();
+          if (now - lastSeenMs > cutoff) {
+            staleKeys.push(key);
+          }
+        }
+        if (staleKeys.length === 0) return 0;
+        const archivePath = this._getArchivePath(projectId);
+        let archive = {};
+        try {
+          const content = await fs24.readFile(archivePath, "utf-8");
+          archive = JSON.parse(content);
+        } catch (error) {
+          if (!isNotFoundError(error)) throw error;
+        }
+        for (const key of staleKeys) {
+          archive[key] = patterns.decisions[key];
+          delete patterns.decisions[key];
+        }
+        await fs24.mkdir(path22.dirname(archivePath), { recursive: true });
+        await fs24.writeFile(archivePath, JSON.stringify(archive, null, 2), "utf-8");
+        await this.save(projectId);
+        return staleKeys.length;
+      }
     };
     SemanticMemories = class extends CachedStore {
       static {
@@ -10727,6 +10756,9 @@ Context: ${context2}` : ""}`,
       getPatternsSummary(projectId) {
         return this._patternStore.getPatternsSummary(projectId);
       }
+      archiveStaleDecisions(projectId) {
+        return this._patternStore.archiveStaleDecisions(projectId);
+      }
       // ===========================================================================
       // TIER 3: History
       // ===========================================================================
@@ -29110,7 +29142,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.7.3",
+      version: "1.7.4",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "1.7.3",
+  "version": "1.7.4",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {