prjct-cli 0.51.0 → 0.53.0

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [0.53.0] - 2026-01-30
+
+### Features
+
+- Lazy template loading with TTL cache - PRJ-76 (#79)
+
+
+## [0.53.0] - 2026-01-30
+
+### Features
+
+- Lazy template loading with TTL cache - PRJ-76
+
+
+## [0.53.0] - 2026-01-30
+
+### Added
+
+- **Lazy template loading with TTL cache** (PRJ-76)
+  - Templates now loaded on-demand with 60-second TTL cache
+  - Added `getTemplate()` method with per-file caching
+  - `loadChecklists()` and `loadChecklistRouting()` now use TTL cache
+  - Added `clearTemplateCache()` method for testing/forced refresh
+  - Reduces disk I/O for frequently accessed templates
+
+
+## [0.52.0] - 2026-01-30
+
+### Features
+
+- Add confidence scores to all stored preferences - PRJ-104 (#78)
+
+
+## [0.52.0] - 2026-01-30
+
+### Added
+
+- **Confidence scores for stored preferences** (PRJ-104)
+  - All preferences, decisions, and workflows now track confidence level
+  - Confidence: `low` (1-2 obs), `medium` (3-5 obs), `high` (6+ or confirmed)
+  - Added `confirmPreference()`, `confirmDecision()`, `confirmWorkflow()` methods
+  - User confirmation immediately sets confidence to `high`
+  - Added `calculateConfidence()` utility function
+
+
 ## [0.51.0] - 2026-01-30
 
 ### Features

package/core/agentic/memory-system.ts

@@ -22,6 +22,7 @@ import { appendJsonLine, getLastJsonLines } from '../utils/jsonl-helper'
 
 // Re-export types from canonical location
 export type {
+  ConfidenceLevel,
   Decision,
   HistoryEntry,
   HistoryEventType,
@@ -35,7 +36,7 @@ export type {
   Workflow,
 } from '../types/memory'
 
-export { MEMORY_TAGS } from '../types/memory'
+export { calculateConfidence, MEMORY_TAGS } from '../types/memory'
 
 import type {
   HistoryEntry,
@@ -49,7 +50,7 @@ import type {
   Workflow,
 } from '../types/memory'
 
-import { MEMORY_TAGS } from '../types/memory'
+import { calculateConfidence, MEMORY_TAGS } from '../types/memory'
 
 // =============================================================================
 // Base Store
@@ -306,7 +307,8 @@ export class PatternStore extends CachedStore<Patterns> {
     projectId: string,
     key: string,
     value: string,
-    context: string = ''
+    context: string = '',
+    options: { userConfirmed?: boolean } = {}
   ): Promise<void> {
     const patterns = await this.load(projectId)
     const now = getTimestamp()
@@ -317,11 +319,14 @@ export class PatternStore extends CachedStore<Patterns> {
         count: 1,
         firstSeen: now,
         lastSeen: now,
-        confidence: 'low',
+        confidence: options.userConfirmed ? 'high' : 'low',
         contexts: [context].filter(Boolean),
-      }
+        userConfirmed: options.userConfirmed || false,
+      } as Patterns['decisions'][string]
     } else {
-      const decision = patterns.decisions[key]
+      const decision = patterns.decisions[key] as Patterns['decisions'][string] & {
+        userConfirmed?: boolean
+      }
 
       if (decision.value === value) {
         decision.count++
@@ -329,23 +334,36 @@ export class PatternStore extends CachedStore<Patterns> {
         if (context && !decision.contexts.includes(context)) {
           decision.contexts.push(context)
         }
-
-        if (decision.count >= 5) {
-          decision.confidence = 'high'
-        } else if (decision.count >= 3) {
-          decision.confidence = 'medium'
+        if (options.userConfirmed) {
+          decision.userConfirmed = true
         }
+        decision.confidence = calculateConfidence(decision.count, decision.userConfirmed)
       } else {
         decision.value = value
         decision.count = 1
         decision.lastSeen = now
-        decision.confidence = 'low'
+        decision.userConfirmed = options.userConfirmed || false
+        decision.confidence = options.userConfirmed ? 'high' : 'low'
       }
     }
 
     await this.save(projectId)
   }
 
+  async confirmDecision(projectId: string, key: string): Promise<boolean> {
+    const patterns = await this.load(projectId)
+    const decision = patterns.decisions[key] as
+      | (Patterns['decisions'][string] & { userConfirmed?: boolean })
+      | undefined
+    if (!decision) return false
+
+    decision.userConfirmed = true
+    decision.confidence = 'high'
+    decision.lastSeen = getTimestamp()
+    await this.save(projectId)
+    return true
+  }
+
   async getDecision(
     projectId: string,
     key: string
@@ -378,15 +396,31 @@ export class PatternStore extends CachedStore<Patterns> {
         count: 1,
         firstSeen: now,
         lastSeen: now,
+        confidence: 'low',
+        userConfirmed: false,
       }
     } else {
-      patterns.workflows[workflowName].count++
-      patterns.workflows[workflowName].lastSeen = now
+      const workflow = patterns.workflows[workflowName]
+      workflow.count++
+      workflow.lastSeen = now
+      workflow.confidence = calculateConfidence(workflow.count, workflow.userConfirmed)
     }
 
     await this.save(projectId)
   }
 
+  async confirmWorkflow(projectId: string, workflowName: string): Promise<boolean> {
+    const patterns = await this.load(projectId)
+    const workflow = patterns.workflows[workflowName]
+    if (!workflow) return false
+
+    workflow.userConfirmed = true
+    workflow.confidence = 'high'
+    workflow.lastSeen = getTimestamp()
+    await this.save(projectId)
+    return true
+  }
+
   async getWorkflow(projectId: string, workflowName: string): Promise<Workflow | null> {
     const patterns = await this.load(projectId)
     const workflow = patterns.workflows[workflowName]
@@ -395,12 +429,39 @@ export class PatternStore extends CachedStore<Patterns> {
     return workflow
   }
 
-  async setPreference(projectId: string, key: string, value: Preference['value']): Promise<void> {
+  async setPreference(
+    projectId: string,
+    key: string,
+    value: Preference['value'],
+    options: { userConfirmed?: boolean } = {}
+  ): Promise<void> {
     const patterns = await this.load(projectId)
-    patterns.preferences[key] = { value, updatedAt: getTimestamp() }
+    const existing = patterns.preferences[key]
+    const observationCount = existing ? existing.observationCount + 1 : 1
+    const userConfirmed = options.userConfirmed || existing?.userConfirmed || false
+
+    patterns.preferences[key] = {
+      value,
+      updatedAt: getTimestamp(),
+      confidence: calculateConfidence(observationCount, userConfirmed),
+      observationCount,
+      userConfirmed,
+    }
     await this.save(projectId)
   }
 
+  async confirmPreference(projectId: string, key: string): Promise<boolean> {
+    const patterns = await this.load(projectId)
+    const pref = patterns.preferences[key]
+    if (!pref) return false
+
+    pref.userConfirmed = true
+    pref.confidence = 'high'
+    pref.updatedAt = getTimestamp()
+    await this.save(projectId)
+    return true
+  }
+
   async getPreference(
     projectId: string,
     key: string,
@@ -857,14 +918,31 @@ export class MemorySystem {
     return this._patternStore.getWorkflow(projectId, workflowName)
   }
 
-  setPreference(projectId: string, key: string, value: Preference['value']): Promise<void> {
-    return this._patternStore.setPreference(projectId, key, value)
+  setPreference(
+    projectId: string,
+    key: string,
+    value: Preference['value'],
+    options?: { userConfirmed?: boolean }
+  ): Promise<void> {
+    return this._patternStore.setPreference(projectId, key, value, options)
   }
 
   getPreference(projectId: string, key: string, defaultValue?: unknown): Promise<unknown> {
     return this._patternStore.getPreference(projectId, key, defaultValue)
   }
 
+  confirmPreference(projectId: string, key: string): Promise<boolean> {
+    return this._patternStore.confirmPreference(projectId, key)
+  }
+
+  confirmDecision(projectId: string, key: string): Promise<boolean> {
+    return this._patternStore.confirmDecision(projectId, key)
+  }
+
+  confirmWorkflow(projectId: string, workflowName: string): Promise<boolean> {
+    return this._patternStore.confirmWorkflow(projectId, workflowName)
+  }
+
   getPatternsSummary(projectId: string) {
     return this._patternStore.getPatternsSummary(projectId)
   }

package/core/agentic/prompt-builder.ts

@@ -43,17 +43,73 @@ type Agent = PromptAgent
 type Context = PromptContext
 type State = PromptState
 
+/**
+ * Cached template entry with TTL support
+ * @see PRJ-76
+ */
+interface CachedTemplate {
+  content: string
+  loadedAt: number
+}
+
 /**
  * Builds prompts for Claude using templates, context, and learned patterns.
  * Supports plan mode, think blocks, and quality checklists.
  * Auto-injects unified state and performance insights.
+ *
+ * Uses lazy loading for templates with 60s TTL cache.
+ * @see PRJ-76
  */
 class PromptBuilder {
   private _checklistsCache: Record<string, string> | null = null
+  private _checklistsCacheTime: number = 0
   private _checklistRoutingCache: string | null = null
+  private _checklistRoutingCacheTime: number = 0
   private _currentContext: Context | null = null
   private _stateCache: Map<string, { state: ProjectState; timestamp: number }> = new Map()
   private _stateCacheTTL = 5000 // 5 seconds
+  private _templateCache: Map<string, CachedTemplate> = new Map()
+  private readonly TEMPLATE_CACHE_TTL_MS = 60_000 // 60 seconds
+
+  /**
+   * Get a template with TTL caching.
+   * Returns cached content if within TTL, otherwise loads from disk.
+   * @see PRJ-76
+   */
+  getTemplate(templatePath: string): string | null {
+    const cached = this._templateCache.get(templatePath)
+    const now = Date.now()
+
+    if (cached && now - cached.loadedAt < this.TEMPLATE_CACHE_TTL_MS) {
+      return cached.content
+    }
+
+    try {
+      if (fs.existsSync(templatePath)) {
+        const content = fs.readFileSync(templatePath, 'utf-8')
+        this._templateCache.set(templatePath, { content, loadedAt: now })
+        return content
+      }
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        console.error(`Template loading warning: ${(error as Error).message}`)
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Clear the template cache (for testing or forced refresh)
+   * @see PRJ-76
+   */
+  clearTemplateCache(): void {
+    this._templateCache.clear()
+    this._checklistsCache = null
+    this._checklistsCacheTime = 0
+    this._checklistRoutingCache = null
+    this._checklistRoutingCacheTime = 0
+  }
 
   /**
    * Reset context (for testing)
@@ -71,9 +127,16 @@ class PromptBuilder {
 
   /**
    * Load quality checklists from templates/checklists/
+   * Uses lazy loading with TTL cache.
+   * @see PRJ-76
    */
   loadChecklists(): Record<string, string> {
-    if (this._checklistsCache) return this._checklistsCache
+    const now = Date.now()
+
+    // Check if cache is still valid
+    if (this._checklistsCache && now - this._checklistsCacheTime < this.TEMPLATE_CACHE_TTL_MS) {
+      return this._checklistsCache
+    }
 
     const checklistsDir = path.join(__dirname, '..', '..', 'templates', 'checklists')
     const checklists: Record<string, string> = {}
@@ -83,8 +146,12 @@ class PromptBuilder {
         const files = fs.readdirSync(checklistsDir).filter((f) => f.endsWith('.md'))
         for (const file of files) {
           const name = file.replace('.md', '')
-          const content = fs.readFileSync(path.join(checklistsDir, file), 'utf-8')
-          checklists[name] = content
+          const templatePath = path.join(checklistsDir, file)
+          // Use getTemplate for individual files to leverage per-file caching
+          const content = this.getTemplate(templatePath)
+          if (content) {
+            checklists[name] = content
+          }
         }
       }
     } catch (error) {
@@ -95,6 +162,7 @@ class PromptBuilder {
     }
 
     this._checklistsCache = checklists
+    this._checklistsCacheTime = now
     return checklists
   }
 
@@ -215,9 +283,19 @@ class PromptBuilder {
 
   /**
    * Load checklist routing template for Claude to decide which checklists apply
+   * Uses lazy loading with TTL cache.
+   * @see PRJ-76
    */
   loadChecklistRouting(): string | null {
-    if (this._checklistRoutingCache) return this._checklistRoutingCache
+    const now = Date.now()
+
+    // Check if cache is still valid
+    if (
+      this._checklistRoutingCache &&
+      now - this._checklistRoutingCacheTime < this.TEMPLATE_CACHE_TTL_MS
+    ) {
+      return this._checklistRoutingCache
+    }
 
     const routingPath = path.join(
       __dirname,
@@ -228,15 +306,11 @@ class PromptBuilder {
       'checklist-routing.md'
     )
 
-    try {
-      if (fs.existsSync(routingPath)) {
-        this._checklistRoutingCache = fs.readFileSync(routingPath, 'utf-8')
-      }
-    } catch (error) {
-      // Silent fail - checklist routing is optional
-      if (!isNotFoundError(error)) {
-        console.error(`Checklist routing warning: ${(error as Error).message}`)
-      }
+    // Use getTemplate for consistent caching behavior
+    const content = this.getTemplate(routingPath)
+    if (content) {
+      this._checklistRoutingCache = content
+      this._checklistRoutingCacheTime = now
     }
 
     return this._checklistRoutingCache || null

package/core/types/memory.ts

@@ -43,6 +43,10 @@ export interface Memory {
   userTriggered: boolean
   createdAt: string
   updatedAt: string
+  /** Confidence level for this memory (optional for backward compatibility) */
+  confidence?: ConfidenceLevel
+  /** Number of times this memory was reinforced */
+  observationCount?: number
 }
 
 /**
@@ -123,8 +127,10 @@ export interface Decision {
   count: number
   firstSeen: string
   lastSeen: string
-  confidence: 'low' | 'medium' | 'high'
+  confidence: ConfidenceLevel
   contexts: string[]
+  /** Whether user explicitly confirmed this decision */
+  userConfirmed?: boolean
 }
 
 /**
@@ -141,14 +147,47 @@ export interface Workflow {
   successRate?: number
   /** Steps in the workflow */
   steps?: string[]
+  /** Confidence level based on execution count */
+  confidence?: ConfidenceLevel
+  /** Whether user explicitly confirmed this workflow */
+  userConfirmed?: boolean
 }
 
 /**
- * A user preference value.
+ * Confidence level for stored preferences and decisions.
+ * @see PRJ-104
+ */
+export type ConfidenceLevel = 'low' | 'medium' | 'high'
+
+/**
+ * Calculate confidence level from observation count.
+ * - low: 1-2 observations
+ * - medium: 3-5 observations
+ * - high: 6+ observations or explicit user confirmation
+ */
+export function calculateConfidence(
+  count: number,
+  userConfirmed: boolean = false
+): ConfidenceLevel {
+  if (userConfirmed) return 'high'
+  if (count >= 6) return 'high'
+  if (count >= 3) return 'medium'
+  return 'low'
+}
+
+/**
+ * A user preference value with confidence scoring.
+ * @see PRJ-104
  */
 export interface Preference {
   value: string | number | boolean
   updatedAt: string
+  /** Confidence level based on observations */
+  confidence: ConfidenceLevel
+  /** Number of times this preference was observed */
+  observationCount: number
+  /** Whether user explicitly confirmed this preference */
+  userConfirmed: boolean
 }
 
 /**

package/dist/bin/prjct.mjs

@@ -8568,6 +8568,12 @@ var init_jsonl_helper = __esm({
 });
 
 // core/types/memory.ts
+function calculateConfidence(count, userConfirmed = false) {
+  if (userConfirmed) return "high";
+  if (count >= 6) return "high";
+  if (count >= 3) return "medium";
+  return "low";
+}
 var MEMORY_TAGS;
 var init_memory = __esm({
   "core/types/memory.ts"() {
@@ -8591,6 +8597,7 @@ var init_memory = __esm({
       CONFIRMATION_LEVEL: "confirmation_level",
       AGENT_PREFERENCE: "agent_preference"
     };
+    __name(calculateConfidence, "calculateConfidence");
   }
 });
 
@@ -8782,7 +8789,7 @@ var init_memory_system = __esm({
       async savePatterns(projectId) {
         return this.save(projectId);
       }
-      async recordDecision(projectId, key, value, context2 = "") {
+      async recordDecision(projectId, key, value, context2 = "", options = {}) {
         const patterns = await this.load(projectId);
         const now = getTimestamp();
         if (!patterns.decisions[key]) {
@@ -8791,8 +8798,9 @@ var init_memory_system = __esm({
             count: 1,
             firstSeen: now,
             lastSeen: now,
-            confidence: "low",
-            contexts: [context2].filter(Boolean)
+            confidence: options.userConfirmed ? "high" : "low",
+            contexts: [context2].filter(Boolean),
+            userConfirmed: options.userConfirmed || false
           };
         } else {
           const decision = patterns.decisions[key];
@@ -8802,20 +8810,30 @@ var init_memory_system = __esm({
             if (context2 && !decision.contexts.includes(context2)) {
               decision.contexts.push(context2);
             }
-            if (decision.count >= 5) {
-              decision.confidence = "high";
-            } else if (decision.count >= 3) {
-              decision.confidence = "medium";
+            if (options.userConfirmed) {
+              decision.userConfirmed = true;
             }
+            decision.confidence = calculateConfidence(decision.count, decision.userConfirmed);
           } else {
             decision.value = value;
             decision.count = 1;
             decision.lastSeen = now;
-            decision.confidence = "low";
+            decision.userConfirmed = options.userConfirmed || false;
+            decision.confidence = options.userConfirmed ? "high" : "low";
           }
         }
         await this.save(projectId);
       }
+      async confirmDecision(projectId, key) {
+        const patterns = await this.load(projectId);
+        const decision = patterns.decisions[key];
+        if (!decision) return false;
+        decision.userConfirmed = true;
+        decision.confidence = "high";
+        decision.lastSeen = getTimestamp();
+        await this.save(projectId);
+        return true;
+      }
       async getDecision(projectId, key) {
         const patterns = await this.load(projectId);
         const decision = patterns.decisions[key];
@@ -8835,24 +8853,57 @@ var init_memory_system = __esm({
             ...pattern,
             count: 1,
             firstSeen: now,
-            lastSeen: now
+            lastSeen: now,
+            confidence: "low",
+            userConfirmed: false
           };
         } else {
-          patterns.workflows[workflowName].count++;
-          patterns.workflows[workflowName].lastSeen = now;
+          const workflow2 = patterns.workflows[workflowName];
+          workflow2.count++;
+          workflow2.lastSeen = now;
+          workflow2.confidence = calculateConfidence(workflow2.count, workflow2.userConfirmed);
         }
         await this.save(projectId);
       }
+      async confirmWorkflow(projectId, workflowName) {
+        const patterns = await this.load(projectId);
+        const workflow2 = patterns.workflows[workflowName];
+        if (!workflow2) return false;
+        workflow2.userConfirmed = true;
+        workflow2.confidence = "high";
+        workflow2.lastSeen = getTimestamp();
+        await this.save(projectId);
+        return true;
+      }
       async getWorkflow(projectId, workflowName) {
         const patterns = await this.load(projectId);
         const workflow2 = patterns.workflows[workflowName];
         if (!workflow2 || workflow2.count < 3) return null;
         return workflow2;
       }
-      async setPreference(projectId, key, value) {
+      async setPreference(projectId, key, value, options = {}) {
+        const patterns = await this.load(projectId);
+        const existing = patterns.preferences[key];
+        const observationCount = existing ? existing.observationCount + 1 : 1;
+        const userConfirmed = options.userConfirmed || existing?.userConfirmed || false;
+        patterns.preferences[key] = {
+          value,
+          updatedAt: getTimestamp(),
+          confidence: calculateConfidence(observationCount, userConfirmed),
+          observationCount,
+          userConfirmed
+        };
+        await this.save(projectId);
+      }
+      async confirmPreference(projectId, key) {
         const patterns = await this.load(projectId);
-        patterns.preferences[key] = { value, updatedAt: getTimestamp() };
+        const pref = patterns.preferences[key];
+        if (!pref) return false;
+        pref.userConfirmed = true;
+        pref.confidence = "high";
+        pref.updatedAt = getTimestamp();
         await this.save(projectId);
+        return true;
       }
       async getPreference(projectId, key, defaultValue = null) {
         const patterns = await this.load(projectId);
@@ -9169,12 +9220,21 @@ Context: ${context2}` : ""}`,
       getWorkflow(projectId, workflowName) {
         return this._patternStore.getWorkflow(projectId, workflowName);
       }
-      setPreference(projectId, key, value) {
-        return this._patternStore.setPreference(projectId, key, value);
+      setPreference(projectId, key, value, options) {
+        return this._patternStore.setPreference(projectId, key, value, options);
       }
       getPreference(projectId, key, defaultValue) {
         return this._patternStore.getPreference(projectId, key, defaultValue);
       }
+      confirmPreference(projectId, key) {
+        return this._patternStore.confirmPreference(projectId, key);
+      }
+      confirmDecision(projectId, key) {
+        return this._patternStore.confirmDecision(projectId, key);
+      }
+      confirmWorkflow(projectId, workflowName) {
+        return this._patternStore.confirmWorkflow(projectId, workflowName);
+      }
       getPatternsSummary(projectId) {
         return this._patternStore.getPatternsSummary(projectId);
       }
@@ -12272,11 +12332,51 @@ var init_prompt_builder = __esm({
         __name(this, "PromptBuilder");
       }
       _checklistsCache = null;
+      _checklistsCacheTime = 0;
       _checklistRoutingCache = null;
+      _checklistRoutingCacheTime = 0;
       _currentContext = null;
       _stateCache = /* @__PURE__ */ new Map();
       _stateCacheTTL = 5e3;
       // 5 seconds
+      _templateCache = /* @__PURE__ */ new Map();
+      TEMPLATE_CACHE_TTL_MS = 6e4;
+      // 60 seconds
+      /**
+       * Get a template with TTL caching.
+       * Returns cached content if within TTL, otherwise loads from disk.
+       * @see PRJ-76
+       */
+      getTemplate(templatePath) {
+        const cached = this._templateCache.get(templatePath);
+        const now = Date.now();
+        if (cached && now - cached.loadedAt < this.TEMPLATE_CACHE_TTL_MS) {
+          return cached.content;
+        }
+        try {
+          if (fs25.existsSync(templatePath)) {
+            const content = fs25.readFileSync(templatePath, "utf-8");
+            this._templateCache.set(templatePath, { content, loadedAt: now });
+            return content;
+          }
+        } catch (error) {
+          if (!isNotFoundError(error)) {
+            console.error(`Template loading warning: ${error.message}`);
+          }
+        }
+        return null;
+      }
+      /**
+       * Clear the template cache (for testing or forced refresh)
+       * @see PRJ-76
+       */
+      clearTemplateCache() {
+        this._templateCache.clear();
+        this._checklistsCache = null;
+        this._checklistsCacheTime = 0;
+        this._checklistRoutingCache = null;
+        this._checklistRoutingCacheTime = 0;
+      }
       /**
        * Reset context (for testing)
        */
@@ -12291,9 +12391,14 @@ var init_prompt_builder = __esm({
       }
       /**
        * Load quality checklists from templates/checklists/
+       * Uses lazy loading with TTL cache.
+       * @see PRJ-76
        */
       loadChecklists() {
-        if (this._checklistsCache) return this._checklistsCache;
+        const now = Date.now();
+        if (this._checklistsCache && now - this._checklistsCacheTime < this.TEMPLATE_CACHE_TTL_MS) {
+          return this._checklistsCache;
+        }
         const checklistsDir = path25.join(__dirname, "..", "..", "templates", "checklists");
         const checklists = {};
         try {
@@ -12301,8 +12406,11 @@ var init_prompt_builder = __esm({
             const files = fs25.readdirSync(checklistsDir).filter((f) => f.endsWith(".md"));
             for (const file of files) {
               const name = file.replace(".md", "");
-              const content = fs25.readFileSync(path25.join(checklistsDir, file), "utf-8");
-              checklists[name] = content;
+              const templatePath = path25.join(checklistsDir, file);
+              const content = this.getTemplate(templatePath);
+              if (content) {
+                checklists[name] = content;
+              }
             }
           }
         } catch (error) {
@@ -12311,6 +12419,7 @@ var init_prompt_builder = __esm({
           }
         }
         this._checklistsCache = checklists;
+        this._checklistsCacheTime = now;
         return checklists;
       }
       /**
@@ -12408,9 +12517,14 @@ var init_prompt_builder = __esm({
       }
       /**
        * Load checklist routing template for Claude to decide which checklists apply
+       * Uses lazy loading with TTL cache.
+       * @see PRJ-76
        */
       loadChecklistRouting() {
-        if (this._checklistRoutingCache) return this._checklistRoutingCache;
+        const now = Date.now();
+        if (this._checklistRoutingCache && now - this._checklistRoutingCacheTime < this.TEMPLATE_CACHE_TTL_MS) {
+          return this._checklistRoutingCache;
+        }
         const routingPath = path25.join(
           __dirname,
           "..",
@@ -12419,14 +12533,10 @@ var init_prompt_builder = __esm({
           "agentic",
           "checklist-routing.md"
         );
-        try {
-          if (fs25.existsSync(routingPath)) {
-            this._checklistRoutingCache = fs25.readFileSync(routingPath, "utf-8");
-          }
-        } catch (error) {
-          if (!isNotFoundError(error)) {
-            console.error(`Checklist routing warning: ${error.message}`);
-          }
+        const content = this.getTemplate(routingPath);
+        if (content) {
+          this._checklistRoutingCache = content;
+          this._checklistRoutingCacheTime = now;
         }
         return this._checklistRoutingCache || null;
       }
@@ -24604,7 +24714,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.51.0",
+      version: "0.53.0",
       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": "0.51.0",
+  "version": "0.53.0",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {