agentic-qe 3.14.7 → 3.15.0

package/dist/mcp/connection-pool.d.ts

@@ -56,6 +56,7 @@ declare class ConnectionPoolImpl {
     private readonly config;
     private healthCheckInterval;
     private initialized;
+    private initializationPromise;
     private totalRequests;
     private cacheHits;
     private acquisitionTimes;
@@ -67,6 +68,7 @@ declare class ConnectionPoolImpl {
      * Initialize the connection pool with minConnections
      */
     initialize(): Promise<void>;
+    private initializeOnce;
     /**
      * Acquire a connection from the pool (O(1) operation)
      * Uses semaphore pattern to prevent race conditions

package/dist/mcp/connection-pool.js

@@ -27,6 +27,7 @@ class ConnectionPoolImpl {
     config;
     healthCheckInterval = null;
     initialized = false;
+    initializationPromise = null;
     // Performance tracking
     totalRequests = 0;
     cacheHits = 0;
@@ -45,6 +46,14 @@ class ConnectionPoolImpl {
         if (this.initialized) {
             return;
         }
+        if (!this.initializationPromise) {
+            this.initializationPromise = this.initializeOnce().finally(() => {
+                this.initializationPromise = null;
+            });
+        }
+        return this.initializationPromise;
+    }
+    async initializeOnce() {
         // Pre-warm minimum connections
         const warmupPromises = [];
         for (let i = 0; i < this.config.minConnections; i++) {
@@ -115,7 +124,7 @@ class ConnectionPoolImpl {
         // O(1) acquisition from idle set
         for (const connId of this.idleConnections) {
             const conn = this.connections.get(connId);
-            if (conn && conn.isHealthy) {
+            if (conn && conn.isHealthy && !conn.inUse) {
                 // Mark as in use and remove from idle set
                 conn.inUse = true;
                 conn.lastUsedAt = Date.now();
@@ -134,6 +143,7 @@ class ConnectionPoolImpl {
             const newConn = this.createConnectionSync();
             if (newConn) {
                 newConn.inUse = true;
+                this.idleConnections.delete(newConn.id);
                 this.cacheHits++;
                 const elapsed = performance.now() - startTime;
                 this.trackAcquisitionTime(elapsed);
@@ -224,7 +234,7 @@ class ConnectionPoolImpl {
         const pruned = [];
         for (const [id, conn] of this.connections.entries()) {
             // Prune if unhealthy or idle for too long
-            if (!conn.isHealthy || (now - conn.lastUsedAt > this.config.idleTimeoutMs)) {
+            if (!conn.inUse && (!conn.isHealthy || (now - conn.lastUsedAt > this.config.idleTimeoutMs))) {
                 pruned.push(id);
             }
         }
@@ -252,6 +262,7 @@ class ConnectionPoolImpl {
      * Shutdown the pool
      */
     async shutdown() {
+        await this.initializationPromise;
         if (this.healthCheckInterval) {
             clearInterval(this.healthCheckInterval);
             this.healthCheckInterval = null;

package/dist/mcp/handlers/memory-handlers.d.ts

@@ -21,6 +21,7 @@ interface MemoryQueryResult {
         score?: number;
         timestamp?: string;
     }>;
+    /** Matching candidates fetched, including the look-ahead; not a corpus-wide count. */
     total: number;
     hasMore: boolean;
     searchType: 'pattern' | 'semantic';

package/dist/mcp/handlers/memory-handlers.js

@@ -5,6 +5,7 @@
  * ADR-058: Integrated with MemoryWriteGate for contradiction detection
  * and ComplianceReporter for violation tracking.
  */
+import { randomUUID } from 'node:crypto';
 import { getFleetState, isFleetInitialized } from './core-handlers.js';
 // ADR-058: Governance integration for memory writes
 import { toErrorMessage } from '../../shared/error-utils.js';
@@ -199,8 +200,15 @@ export async function handleMemoryQuery(params) {
     }
     try {
         const namespace = params.namespace || 'default';
-        const limit = params.limit || 100;
-        const offset = params.offset || 0;
+        const limit = params.limit ?? 100;
+        const offset = params.offset ?? 0;
+        if (!Number.isSafeInteger(limit) || limit < 0 ||
+            !Number.isSafeInteger(offset) || offset < 0 ||
+            !Number.isSafeInteger(limit + offset + 1)) {
+            return { success: false, error: 'Memory query limit and offset must be non-negative safe integers with a safe combined page size.' };
+        }
+        // One extra candidate proves whether another page exists without scanning all memory.
+        const fetchLimit = limit + offset + 1;
         // Determine if we should use semantic (HNSW vector) search
         const useSemantic = params.semantic === true ||
             (params.semantic !== false && params.pattern && isNaturalLanguageQuery(params.pattern));
@@ -209,8 +217,9 @@ export async function handleMemoryQuery(params) {
             try {
                 // Generate real 384-dim transformer embedding for accurate cosine similarity search
                 const embedding = await computeRealEmbedding(params.pattern);
-                const keyPrefix = namespace !== 'default' ? `${namespace}:` : undefined;
-                const filtered = await memory.vectorSearch(embedding, limit + offset, keyPrefix);
+                // Semantic queries have the same namespace boundary as pattern queries.
+                const keyPrefix = `${namespace}:`;
+                const filtered = await memory.vectorSearch(embedding, fetchLimit, keyPrefix);
                 const paginatedResults = filtered.slice(offset, offset + limit);
                 const entries = paginatedResults.map(r => {
                     const parts = r.key.split(':');
@@ -240,7 +249,7 @@ export async function handleMemoryQuery(params) {
         const pattern = params.pattern
             ? `${namespace}:${params.pattern}`
             : `${namespace}:*`;
-        const keys = await memory.search(pattern, limit + offset);
+        const keys = await memory.search(pattern, fetchLimit);
         // Apply pagination
         const paginatedKeys = keys.slice(offset, offset + limit);
         const entries = paginatedKeys.map((key) => {
@@ -353,7 +362,8 @@ export async function handleMemoryShare(params) {
     }
     try {
         // Store shared knowledge for each target agent
-        const sharedKey = `shared:${params.knowledgeDomain}:${Date.now()}`;
+        // Concurrent agents can publish several findings within the same millisecond.
+        const sharedKey = `shared:${params.knowledgeDomain}:${Date.now()}:${randomUUID()}`;
         const sharedContent = {
             source: params.sourceAgentId,
             targets: params.targetAgentIds,

package/dist/mcp/protocol-server.js

@@ -417,6 +417,7 @@ export class MCPProtocolServer {
         const startTime = performance.now();
         let success = false;
         let cacheable;
+        let invalidatesCache = false;
         // Emit AG-UI progress event for tool start
         const stepId = `${name}-${Date.now()}`;
         this.eventAdapter.adapt({
@@ -461,14 +462,13 @@ export class MCPProtocolServer {
             // IMP-00: Execute pre-tool-call middleware
             const processedCtx = await this.middlewareChain.executePreHooks(ctx);
             // Issue #473: Session-cache lookup for read-only tools.
-            // Concurrency-safe tools are idempotent in practice — same input yields
-            // the same output, so we can short-circuit repeated calls with an O(1)
-            // fingerprint lookup. Tools without isConcurrencySafe (writes, scans,
-            // executions) always re-run.
-            // Explicit quality gates depend on current measured evidence and its age,
-            // not just arguments. A cached approval can outlive or contradict evidence.
+            // Concurrency safety does not imply stable output: status and metrics
+            // can change in the background without another MCP mutation. Live reads
+            // opt out of reuse while retaining their concurrency-safe scheduling hint.
+            // Explicit quality gates also depend on current measured evidence/age.
             const measuredQualityGate = name === 'quality_assess' && processedCtx.params?.runGate === true;
-            cacheable = tool.definition.isConcurrencySafe === true && !measuredQualityGate;
+            invalidatesCache = tool.definition.isConcurrencySafe !== true || measuredQualityGate;
+            cacheable = !invalidatesCache && tool.definition.isCacheable !== false;
             let cacheFingerprint = null;
             let cacheGeneration = null;
             if (cacheable && process.env.AQE_SESSION_CACHE !== 'off') {
@@ -592,7 +592,7 @@ export class MCPProtocolServer {
             // Tool names and success flags do not prove whether state changed.
             // Unknown cross-domain effects require a global flush, including after
             // a handler throws or reports failure following a partial effect.
-            if (cacheable === false && process.env.AQE_SESSION_CACHE !== 'off') {
+            if (invalidatesCache && process.env.AQE_SESSION_CACHE !== 'off') {
                 try {
                     const { getSessionCache } = await import('../optimization/session-cache.js');
                     getSessionCache().invalidateAll();
@@ -631,6 +631,7 @@ export class MCPProtocolServer {
                 description: 'Get fleet status: agents, tasks, health, and learning stats. Example: fleet_status({ verbose: true })',
                 category: 'core',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'verbose', type: 'boolean', description: 'Include detailed information', default: false },
                 ],
@@ -643,6 +644,7 @@ export class MCPProtocolServer {
                 description: 'Check fleet and per-domain health status with load metrics. Example: fleet_health({ domain: "test-generation" })',
                 category: 'core',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Specific domain to check' },
                 ],
@@ -670,6 +672,7 @@ export class MCPProtocolServer {
                 description: 'List tasks with optional status/limit filtering. Example: task_list({ status: "running", limit: 10 })',
                 category: 'task',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'status', type: 'string', description: 'Filter by status' },
                     { name: 'limit', type: 'number', description: 'Maximum results', default: 50 },
@@ -683,6 +686,7 @@ export class MCPProtocolServer {
                 description: 'Get detailed status, progress, and result of a specific task. Example: task_status({ taskId: "abc-123" })',
                 category: 'task',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'taskId', type: 'string', description: 'Task ID', required: true },
                 ],
@@ -719,6 +723,7 @@ export class MCPProtocolServer {
                 description: 'List all active agents, optionally filtered by domain. Example: agent_list({ domain: "test-generation" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Filter by domain' },
                 ],
@@ -743,6 +748,7 @@ export class MCPProtocolServer {
                 description: 'Get CPU, memory, and task performance metrics for agents. Example: agent_metrics({ agentId: "agent-1" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'agentId', type: 'string', description: 'Specific agent ID', required: true },
                 ],
@@ -755,6 +761,7 @@ export class MCPProtocolServer {
                 description: 'Get detailed status and current task of a specific agent. Example: agent_status({ agentId: "agent-1" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'agentId', type: 'string', description: 'Agent ID', required: true },
                 ],
@@ -768,6 +775,7 @@ export class MCPProtocolServer {
                 description: 'List all active domain teams and their agent counts. Example: team_list({ domain: "coverage-analysis" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Filter by domain' },
                 ],
@@ -780,6 +788,7 @@ export class MCPProtocolServer {
                 description: 'Get team health, agent utilization, and consensus status for a domain. Example: team_health({ domain: "security-compliance" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Domain to check', required: true },
                 ],
@@ -1024,6 +1033,8 @@ export class MCPProtocolServer {
                     { name: 'pattern', type: 'string', description: 'Key pattern (glob) or natural language query (for semantic search)' },
                     { name: 'namespace', type: 'string', description: 'Memory namespace' },
                     { name: 'semantic', type: 'boolean', description: 'Use HNSW vector search instead of pattern matching. Auto-detected when pattern contains spaces and no wildcards.' },
+                    { name: 'limit', type: 'number', description: 'Maximum entries in the page (non-negative safe integer)', default: 100 },
+                    { name: 'offset', type: 'number', description: 'Number of entries to skip (non-negative safe integer)', default: 0 },
                 ],
             },
             handler: (params) => handleMemoryQuery(params),
@@ -1046,6 +1057,7 @@ export class MCPProtocolServer {
                 description: 'Get memory usage statistics: entry counts, namespaces, and storage size. Example: memory_usage({})',
                 category: 'memory',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleMemoryUsage(),
@@ -1089,6 +1101,7 @@ export class MCPProtocolServer {
                 description: 'Get model routing statistics: tier distribution, cost savings, and routing log. Example: routing_metrics({ includeLog: true, logLimit: 20 })',
                 category: 'routing',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'includeLog', type: 'boolean', description: 'Include routing log entries', default: false },
                     { name: 'logLimit', type: 'number', description: 'Max log entries to return', default: 100 },
@@ -1102,6 +1115,7 @@ export class MCPProtocolServer {
                 description: 'Get economic routing report: tier efficiency, budget status, cost-per-quality analysis, and savings opportunities. Example: routing_economics({ taskComplexity: 0.5 })',
                 category: 'routing',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'taskComplexity', type: 'number', description: 'Task complexity score 0-1 for tier scoring (default: 0.5)', default: 0.5 },
                 ],
@@ -1115,6 +1129,7 @@ export class MCPProtocolServer {
                 description: 'Get infrastructure self-healing status: detected failures, recovery stats, and failing services. Example: infra_healing_status({ verbose: true })',
                 category: 'infra-healing',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'verbose', type: 'boolean', description: 'Include detailed observation data', default: false },
                 ],
@@ -1215,6 +1230,7 @@ export class MCPProtocolServer {
                 description: 'Get cross-phase memory statistics (total signals, by loop, by namespace)',
                 category: 'cross-phase',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleCrossPhaseStats(),
@@ -1307,6 +1323,7 @@ export class MCPProtocolServer {
                 description: 'List all loaded YAML pipelines. Example: pipeline_list({})',
                 category: 'coordination',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: (params) => handlePipelineList(params),
@@ -1346,6 +1363,7 @@ export class MCPProtocolServer {
                 description: 'Get session operation cache statistics: hit rate, cache size, tokens saved via O(1) fingerprint reuse. Example: session_cache_stats({})',
                 category: 'learning',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: async () => {
@@ -1380,6 +1398,7 @@ export class MCPProtocolServer {
                 description: 'Check AQE server health: returns status, loaded domains, memory stats, HNSW index status, and pattern count. Example: aqe_health({})',
                 category: 'core',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleAQEHealth(),
@@ -1391,6 +1410,7 @@ export class MCPProtocolServer {
                 description: 'Get RVF migration status: current stage, metrics, consistency, and gate evaluation. Example: migration_status({})',
                 category: 'persistence',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleMigrationStatus(),
@@ -1401,6 +1421,7 @@ export class MCPProtocolServer {
                 description: 'Run a consistency check comparing SQLite and RVF search results. Samples random patterns and reports divergences. Example: migration_check({})',
                 category: 'persistence',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleMigrationCheck(),

package/dist/mcp/security/rate-limiter.d.ts

@@ -135,6 +135,7 @@ export declare class RateLimiter {
     private createBucket;
     private getBucket;
     private getEndpointKey;
+    private matchesEndpoint;
     private getConfig;
     private refillBucket;
     private buildHeaders;

package/dist/mcp/security/rate-limiter.js

@@ -86,6 +86,9 @@ export class RateLimiter {
      * Consume tokens (blocks if not available in sync mode)
      */
     consume(clientId, endpoint, tokens = 1) {
+        if (!Number.isFinite(tokens) || tokens < 0) {
+            throw new RangeError('Token cost must be finite and nonnegative');
+        }
         this.stats.totalRequests++;
         const now = Date.now();
         // Get configuration (endpoint-specific or default)
@@ -144,7 +147,10 @@ export class RateLimiter {
      * Reset a client's bucket
      */
     resetClient(clientId) {
-        this.clientBuckets.delete(clientId);
+        for (const key of this.clientBuckets.keys()) {
+            if (JSON.parse(key)[0] === clientId)
+                this.clientBuckets.delete(key);
+        }
     }
     /**
      * Reset all buckets
@@ -177,7 +183,7 @@ export class RateLimiter {
      * Get client-specific statistics
      */
     getClientStats(clientId) {
-        const bucket = this.clientBuckets.get(clientId);
+        const bucket = this.clientBuckets.get(JSON.stringify([clientId, null]));
         return bucket ? { ...bucket } : null;
     }
     /**
@@ -209,7 +215,8 @@ export class RateLimiter {
         }
         // Create a composite key for client + endpoint-specific limits
         const endpointKey = this.getEndpointKey(endpoint);
-        const bucketKey = endpointKey ? `${clientId}:${endpointKey}` : clientId;
+        // Encode boundaries so an endpoint bucket cannot alias another client ID.
+        const bucketKey = JSON.stringify([clientId, endpointKey]);
         let bucket = this.clientBuckets.get(bucketKey);
         if (!bucket) {
             bucket = {
@@ -231,19 +238,29 @@ export class RateLimiter {
             const pattern = typeof limit.pattern === 'string'
                 ? createSafeRegex(limit.pattern)
                 : limit.pattern;
-            if (pattern && pattern.test(endpoint)) {
+            if (pattern && this.matchesEndpoint(pattern, endpoint)) {
                 return `ep${i}`;
             }
         }
         return null;
     }
+    matchesEndpoint(pattern, endpoint) {
+        const previousIndex = pattern.lastIndex;
+        try {
+            pattern.lastIndex = 0;
+            return pattern.test(endpoint);
+        }
+        finally {
+            pattern.lastIndex = previousIndex;
+        }
+    }
     getConfig(endpoint) {
         if (endpoint) {
             for (const limit of this.endpointLimits) {
                 const pattern = typeof limit.pattern === 'string'
                     ? createSafeRegex(limit.pattern)
                     : limit.pattern;
-                if (pattern && pattern.test(endpoint)) {
+                if (pattern && this.matchesEndpoint(pattern, endpoint)) {
                     return {
                         tokensPerSecond: limit.tokensPerSecond,
                         maxBurst: limit.maxBurst,

package/dist/mcp/services/session-store.js

@@ -80,26 +80,26 @@ export class SessionStore {
             uuid,
             parentUuid: this.lastUuid,
         };
+        // Database-free mode keeps bookkeeping without serialization or disk I/O.
+        if (!this.persistDisabled) {
+            const line = JSON.stringify(fullEntry) + '\n';
+            if (!this.fileCreated) {
+                // First write: synchronous for write-ahead guarantee
+                this.ensureDirectory();
+                fs.appendFileSync(this.filePath, line, 'utf-8');
+                this.fileCreated = true;
+            }
+            else {
+                // Subsequent writes: buffer and batch
+                this.writeBuffer.push(line);
+                this.scheduleBatchFlush();
+            }
+        }
+        // Only advance the chain and metadata after the entry has been accepted.
         this.lastUuid = uuid;
         this.entryCount++;
         this.lastActivityAt = fullEntry.timestamp;
         this.currentState = fullEntry.state;
-        // Database-free mode: bookkeeping done above; skip all disk I/O.
-        if (this.persistDisabled) {
-            return uuid;
-        }
-        const line = JSON.stringify(fullEntry) + '\n';
-        if (!this.fileCreated) {
-            // First write: synchronous for write-ahead guarantee
-            this.ensureDirectory();
-            fs.appendFileSync(this.filePath, line, 'utf-8');
-            this.fileCreated = true;
-        }
-        else {
-            // Subsequent writes: buffer and batch
-            this.writeBuffer.push(line);
-            this.scheduleBatchFlush();
-        }
         return uuid;
     }
     /**
@@ -112,8 +112,8 @@ export class SessionStore {
         }
         if (this.writeBuffer.length > 0 && this.filePath && this.fileCreated) {
             const batch = this.writeBuffer.join('');
-            this.writeBuffer = [];
             fs.appendFileSync(this.filePath, batch, 'utf-8');
+            this.writeBuffer = [];
         }
     }
     /**

package/dist/mcp/tools/planning/goap-status.d.ts

@@ -109,6 +109,8 @@ export interface PlansResult {
         createdAt?: string;
     }>;
     count: number;
+    /** Stored rows omitted from this page because their action sequence is invalid. */
+    invalidPlanIds?: string[];
     reuseStats?: {
         totalPlans: number;
         reusedPlans: number;

package/dist/mcp/tools/planning/goap-status.js

@@ -11,6 +11,7 @@ import { MCPToolBase, } from '../base.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
 import { getSharedGOAPPlanner, createMockExecutor, getAllQEActions, } from '../../../planning/index.js';
 import { detectWorldState, defaultedFields, } from './world-state.js';
+const PLAN_STATUSES = ['pending', 'executing', 'completed', 'failed', 'cancelled'];
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -54,7 +55,8 @@ export class GOAPStatusTool extends MCPToolBase {
                         },
                         status: {
                             type: 'string',
-                            description: 'Filter plans by status (pending, executing, completed, failed)',
+                            description: 'Filter plans by status (pending, executing, completed, failed, cancelled)',
+                            enum: [...PLAN_STATUSES],
                         },
                         limit: {
                             type: 'number',
@@ -252,8 +254,11 @@ export class GOAPStatusTool extends MCPToolBase {
      * Get plans
      */
     async getPlans(status, limit = 20) {
+        if (status !== undefined && !PLAN_STATUSES.includes(status)) {
+            return { success: false, error: `filter.status must be one of: ${PLAN_STATUSES.join(', ')}` };
+        }
         const planner = await this.getPlanner();
-        const [{ plans, count }, reuseStats] = await Promise.all([
+        const [{ plans, count, invalidPlanIds }, reuseStats] = await Promise.all([
             planner.listPlanSummaries(status, limit),
             planner.getPlanReuseStats(),
         ]);
@@ -265,6 +270,7 @@ export class GOAPStatusTool extends MCPToolBase {
                 data: {
                     plans,
                     count,
+                    ...(invalidPlanIds ? { invalidPlanIds } : {}),
                     reuseStats: {
                         totalPlans: reuseStats.totalPlans,
                         reusedPlans: reuseStats.reusedPlans,

package/dist/mcp/types.d.ts

@@ -42,6 +42,8 @@ export interface ToolDefinition {
     domain?: DomainName;
     lazyLoad?: boolean;
     isConcurrencySafe?: boolean;
+    /** False for live reads whose results must not be reused by the session cache. */
+    isCacheable?: boolean;
     annotations?: ToolAnnotations;
 }
 /**

package/dist/optimization/session-cache.js

@@ -40,17 +40,19 @@ export const DEFAULT_SESSION_CACHE_CONFIG = {
  * Ensures identical logical objects always produce the same fingerprint.
  */
 function canonicalStringify(value) {
-    if (value === null || value === undefined)
-        return JSON.stringify(value);
-    if (typeof value !== 'object')
-        return JSON.stringify(value);
-    if (Array.isArray(value)) {
-        return '[' + value.map(v => canonicalStringify(v)).join(',') + ']';
+    // Honor JSON's array holes, undefined fields and toJSON (for example Date)
+    // before ordering keys. Hand-built fragments can conflate distinct inputs.
+    const normalized = JSON.parse(JSON.stringify(value));
+    function encode(item) {
+        if (item === null || typeof item !== 'object')
+            return JSON.stringify(item);
+        if (Array.isArray(item))
+            return '[' + item.map(encode).join(',') + ']';
+        const obj = item;
+        return '{' + Object.keys(obj).sort()
+            .map(key => JSON.stringify(key) + ':' + encode(obj[key])).join(',') + '}';
     }
-    const obj = value;
-    const sortedKeys = Object.keys(obj).sort();
-    const pairs = sortedKeys.map(k => JSON.stringify(k) + ':' + canonicalStringify(obj[k]));
-    return '{' + pairs.join(',') + '}';
+    return encode(normalized);
 }
 // ============================================================================
 // Implementation
@@ -114,7 +116,7 @@ export class SessionOperationCache {
         if (!this.config.enabled)
             return;
         // Evict oldest if at capacity
-        if (this.cache.size >= this.config.maxEntries) {
+        if (!this.cache.has(fingerprint) && this.cache.size >= this.config.maxEntries) {
             this.evictOldest();
         }
         const entry = {

package/dist/planning/goap-planner.d.ts

@@ -75,6 +75,8 @@ export declare class GOAPPlanner {
      * bindings on already-seeded databases without requiring a full re-seed.
      */
     private backfillActionMethodBindings;
+    /** Restore missing estimates only for unchanged legacy library definitions. */
+    private backfillActionDurationEstimates;
     /**
      * Find an optimal plan using A* search
      *
@@ -222,6 +224,7 @@ export declare class GOAPPlanner {
             createdAt: string;
         }>;
         count: number;
+        invalidPlanIds?: string[];
     }>;
     /**
      * Find a similar plan by goal conditions