agentic-qe 3.14.8 → 3.15.0

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/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

package/dist/planning/goap-planner.js

@@ -157,6 +157,7 @@ export class GOAPPlanner {
         // for databases seeded before this feature existed, or before a given
         // action's binding was added to the library.
         this.backfillActionMethodBindings();
+        this.backfillActionDurationEstimates();
         await this.loadActions();
         this.initialized = true;
         console.log(`[GOAPPlanner] Initialized: ${this.persistence.getDbPath()}`);
@@ -170,12 +171,12 @@ export class GOAPPlanner {
         const allActions = getAllQEActions();
         const db = this.ensureDb();
         const insertAction = db.prepare(`
-      INSERT INTO goap_actions (id, name, description, category, preconditions, effects, cost, qe_domain, agent_type, method, params, implemented)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO goap_actions (id, name, description, category, preconditions, effects, cost, qe_domain, agent_type, method, params, implemented, estimated_duration_ms)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         for (const action of allActions) {
             const id = `action-${Date.now()}-${randomUUID().slice(0, 8)}`;
-            insertAction.run(id, action.name, action.description, action.category, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.cost, action.qeDomain ?? null, action.agentType ?? null, action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0);
+            insertAction.run(id, action.name, action.description, action.category, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.cost, action.qeDomain ?? null, action.agentType ?? null, action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0, action.estimatedDurationMs ?? null);
         }
         // Seed QE goals using direct insertion
         const insertGoal = db.prepare(`
@@ -212,6 +213,21 @@ export class GOAPPlanner {
             update.run(action.method, action.params ? JSON.stringify(action.params) : '{}', action.name);
         }
     }
+    /** Restore missing estimates only for unchanged legacy library definitions. */
+    backfillActionDurationEstimates() {
+        const update = this.ensureDb().prepare(`
+      UPDATE goap_actions SET estimated_duration_ms = ?
+      WHERE estimated_duration_ms IS NULL AND name = ?
+        AND agent_type IS ? AND category = ? AND qe_domain IS ?
+        AND preconditions = ? AND effects = ?
+        AND method IS ? AND params IS ? AND implemented = ?
+    `);
+        for (const action of getAllQEActions()) {
+            if (action.estimatedDurationMs === undefined)
+                continue;
+            update.run(action.estimatedDurationMs, action.name, action.agentType ?? null, action.category, action.qeDomain ?? null, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0);
+        }
+    }
     // ==========================================================================
     // Core Planning - A* Search
     // ==========================================================================
@@ -242,6 +258,7 @@ export class GOAPPlanner {
                 this.recordPlanReuse(reusedPlan.id, true);
                 const clonedPlan = {
                     ...reusedPlan,
+                    estimatedDurationMs: reusedPlan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? 0), 0),
                     id: `plan-${Date.now()}-${randomUUID().slice(0, 8)}`,
                     initialState: this.cloneState(currentState),
                     reusedFrom: reusedPlan.id,
@@ -306,6 +323,9 @@ export class GOAPPlanner {
         // Entries are added on insert, updated when a better path is found, and
         // removed when the node is popped (moved to the closed set).
         const openSetCosts = new Map();
+        // Under a duration budget, cheaper paths can be slower or deeper. Keep
+        // nondominated labels rather than closing the entire state at its first cost.
+        const durationLabels = new Map();
         // Issue #535: cost-unit heuristic built once per search from the
         // actions that can actually move each goal key (see buildHeuristic).
         const heuristic = this.buildHeuristic(goal, availableActions);
@@ -322,34 +342,39 @@ export class GOAPPlanner {
             h: startH,
             f: 0,
             depth: 0,
+            estimatedDurationMs: 0,
         };
         startNode.f = startNode.g + startNode.h;
         openHeap.push(startNode);
         openSetCosts.set(this.hashState(start), 0);
+        durationLabels.set(this.hashState(start), [startNode]);
         // Constraint defaults
         const maxIterations = 10000;
         // Issue #535: constraints.maxSteps caps the search depth (= plan length).
         const maxPlanLength = constraints?.maxSteps ?? DEFAULT_MAX_PLAN_STEPS;
         const maxCost = constraints?.maxCost ?? Infinity;
         const maxDuration = constraints?.maxDurationMs ?? Infinity;
+        const boundedDuration = Number.isFinite(maxDuration);
         let iterations = 0;
         while (openHeap.length > 0 && iterations < maxIterations) {
             iterations++;
             // Get node with lowest f score — O(log n)
             const current = openHeap.pop();
+            const stateKey = this.hashState(current.state);
+            if (boundedDuration && !durationLabels.get(stateKey)?.includes(current)) {
+                continue; // a later label dominates this queued path
+            }
             // Check if goal reached
             if (this.meetsConditions(current.state, goal)) {
                 return this.reconstructPlan(current);
             }
-            // Generate state hash for closed set
-            const stateKey = this.hashState(current.state);
-            if (closedSet.has(stateKey)) {
-                // Lazy deletion: skip stale duplicate nodes
-                continue;
+            if (!boundedDuration) {
+                if (closedSet.has(stateKey)) {
+                    continue; // lazy deletion for the existing cost-only search
+                }
+                closedSet.add(stateKey);
+                openSetCosts.delete(stateKey);
             }
-            closedSet.add(stateKey);
-            // Node is now closed — remove from open set cost tracker
-            openSetCosts.delete(stateKey);
             // Check depth limit
             if (current.depth >= maxPlanLength) {
                 continue;
@@ -364,7 +389,7 @@ export class GOAPPlanner {
                 const newState = this.applyAction(current.state, action);
                 const newStateKey = this.hashState(newState);
                 // Skip if already visited
-                if (closedSet.has(newStateKey)) {
+                if (!boundedDuration && closedSet.has(newStateKey)) {
                     continue;
                 }
                 // Calculate costs
@@ -379,26 +404,33 @@ export class GOAPPlanner {
                     continue;
                 }
                 // Check duration constraints
-                const estimatedDuration = current.depth * 1000 + (action.estimatedDurationMs ?? 0);
+                const estimatedDuration = current.estimatedDurationMs + (action.estimatedDurationMs ?? 0);
                 if (estimatedDuration > maxDuration) {
                     continue;
                 }
-                // Only push if this is a better path than any previously seen in the open set
-                const prevG = openSetCosts.get(newStateKey);
-                if (prevG !== undefined && g >= prevG) {
-                    continue;
+                const next = {
+                    state: newState, action, parent: current, g, h, f,
+                    depth: current.depth + 1, estimatedDurationMs: estimatedDuration,
+                };
+                if (boundedDuration) {
+                    const labels = durationLabels.get(newStateKey) ?? [];
+                    if (labels.some((label) => label.g <= g &&
+                        label.estimatedDurationMs <= estimatedDuration && label.depth <= next.depth)) {
+                        continue;
+                    }
+                    durationLabels.set(newStateKey, [
+                        ...labels.filter((label) => !(g <= label.g &&
+                            estimatedDuration <= label.estimatedDurationMs && next.depth <= label.depth)),
+                        next,
+                    ]);
+                }
+                else {
+                    const prevG = openSetCosts.get(newStateKey);
+                    if (prevG !== undefined && g >= prevG)
+                        continue;
+                    openSetCosts.set(newStateKey, g);
                 }
-                openSetCosts.set(newStateKey, g);
-                // Add new node — O(log n)
-                openHeap.push({
-                    state: newState,
-                    action,
-                    parent: current,
-                    g,
-                    h,
-                    f,
-                    depth: current.depth + 1,
-                });
+                openHeap.push(next);
             }
         }
         // No plan found
@@ -896,20 +928,30 @@ export class GOAPPlanner {
       ORDER BY created_at DESC, id DESC
       LIMIT ?
     `).all(...args, boundedLimit);
-        const plans = rows.map((row) => {
-            const actionIds = safeJsonParse(row.action_sequence);
-            if (!Array.isArray(actionIds)) {
-                throw new Error(`Invalid action sequence in GOAP plan ${row.id}`);
+        const plans = [];
+        const invalidPlanIds = [];
+        for (const row of rows) {
+            let actionIds;
+            try {
+                actionIds = safeJsonParse(row.action_sequence);
+            }
+            catch {
+                invalidPlanIds.push(row.id);
+                continue;
+            }
+            if (!Array.isArray(actionIds) || !actionIds.every((id) => typeof id === 'string')) {
+                invalidPlanIds.push(row.id);
+                continue;
             }
-            return {
+            plans.push({
                 id: row.id,
                 status: row.status,
                 stepCount: actionIds.length,
                 totalCost: row.total_cost,
                 createdAt: row.created_at,
-            };
-        });
-        return { plans, count };
+            });
+        }
+        return { plans, count, ...(invalidPlanIds.length ? { invalidPlanIds } : {}) };
     }
     /**
      * Find a similar plan by goal conditions
@@ -998,7 +1040,8 @@ export class GOAPPlanner {
         if (plan.actions.length > maxSteps)
             return false;
         if (constraints?.maxDurationMs !== undefined &&
-            plan.estimatedDurationMs > constraints.maxDurationMs) {
+            plan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? 0), 0)
+                > constraints.maxDurationMs) {
             return false;
         }
         const allowed = new Set(this.getAvailableActions(constraints).map((a) => a.id));

package/dist/shared/embeddings/embedding-cache.js

@@ -22,7 +22,7 @@ export class EmbeddingCache {
      */
     hashContent(content, model) {
         return createHash('sha256')
-            .update(`${model}:${content}`)
+            .update(JSON.stringify([model, content]))
             .digest('hex');
     }
     /**

package/dist/shared/embeddings/nomic-embedder.js

@@ -14,6 +14,7 @@ import { OllamaClient } from './ollama-client.js';
 import { EmbeddingCache } from './embedding-cache.js';
 import { toErrorMessage } from '../error-utils.js';
 import { EMBEDDING_CONFIG, } from './types.js';
+const PSEUDO_EMBEDDING_MODEL = 'pseudo-embedding';
 /**
  * Nomic Embedder for generating code embeddings via Ollama
  */
@@ -50,17 +51,23 @@ export class NomicEmbedder {
      * Generate embedding for a single text string
      */
     async embed(text) {
-        // Check cache first
-        const cached = this.cache.get(text, EMBEDDING_CONFIG.MODEL);
+        // Prefer genuine cached vectors, then select the active backend before a
+        // single counted lookup so alternate namespaces do not inflate misses.
+        let model = this.cache.has(text, EMBEDDING_CONFIG.MODEL) ||
+            await this.isOllamaAvailable() || !this.enableFallback
+            ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+        const cached = this.cache.get(text, model);
         if (cached) {
             return cached;
         }
         // Try Ollama first, fall back to pseudo-embedding if unavailable
         let embedding;
         if (await this.isOllamaAvailable()) {
+            model = EMBEDDING_CONFIG.MODEL;
             embedding = await this.client.generateEmbedding(text);
         }
         else if (this.enableFallback) {
+            model = PSEUDO_EMBEDDING_MODEL;
             embedding = this.generatePseudoEmbedding(text);
         }
         else {
@@ -68,7 +75,7 @@ export class NomicEmbedder {
                 `Please run: ollama pull ${EMBEDDING_CONFIG.MODEL}`);
         }
         // Cache result
-        this.cache.set(text, EMBEDDING_CONFIG.MODEL, embedding);
+        this.cache.set(text, model, embedding);
         return embedding;
     }
     /**
@@ -181,12 +188,14 @@ export class NomicEmbedder {
             const formattedText = this.formatForEmbedding(chunk);
             const chunkStartTime = Date.now();
             // Check cache
-            const cachedEmbedding = this.cache.get(formattedText, EMBEDDING_CONFIG.MODEL);
+            const cachedModel = useOllama || this.cache.has(formattedText, EMBEDDING_CONFIG.MODEL)
+                ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+            const cachedEmbedding = this.cache.get(formattedText, cachedModel);
             if (cachedEmbedding) {
                 return {
                     chunkId: chunk.id,
                     embedding: cachedEmbedding,
-                    model: EMBEDDING_CONFIG.MODEL,
+                    model: cachedModel,
                     cached: true,
                     computeTimeMs: Date.now() - chunkStartTime,
                 };
@@ -201,11 +210,12 @@ export class NomicEmbedder {
                     embedding = this.generatePseudoEmbedding(formattedText);
                 }
                 // Cache the result
-                this.cache.set(formattedText, EMBEDDING_CONFIG.MODEL, embedding);
+                const model = useOllama ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+                this.cache.set(formattedText, model, embedding);
                 return {
                     chunkId: chunk.id,
                     embedding,
-                    model: useOllama ? EMBEDDING_CONFIG.MODEL : 'pseudo-embedding',
+                    model,
                     cached: false,
                     computeTimeMs: Date.now() - chunkStartTime,
                 };

package/dist/shared/embeddings/ollama-client.js

@@ -34,10 +34,12 @@ export class OllamaClient {
             }
             const data = await response.json();
             // Check if configured embedding model is available
-            // Model names may include tags like ":latest", so use startsWith for matching
+            // Match the configured model exactly, allowing its existing tag suffix.
             if (data.models) {
-                return data.models.some((model) => model.name?.startsWith(EMBEDDING_CONFIG.MODEL) ||
-                    model.model?.startsWith(EMBEDDING_CONFIG.MODEL));
+                return data.models.some((model) => model.name === EMBEDDING_CONFIG.MODEL ||
+                    model.name?.startsWith(`${EMBEDDING_CONFIG.MODEL}:`) ||
+                    model.model === EMBEDDING_CONFIG.MODEL ||
+                    model.model?.startsWith(`${EMBEDDING_CONFIG.MODEL}:`));
             }
             return false;
         }