agentic-qe 3.14.5 → 3.14.7

package/dist/planning/plan-executor.js

@@ -24,6 +24,7 @@ const DEFAULT_CONFIG = {
     maxRetries: 2,
     stepTimeoutMs: 60000,
     replanOnFailure: true,
+    maxReplans: 3,
     parallelExecution: false,
     recordWorldState: true,
     useUnified: true, // ADR-046: Default to unified storage
@@ -44,6 +45,24 @@ function safeStringify(value, maxLength = 2000) {
         return String(value);
     }
 }
+/**
+ * Issue #535: render the `error` of a domain Result err as text — an Error's
+ * message, a string as-is, else a (truncated) JSON rendering.
+ */
+function describeDomainError(reason) {
+    if (reason === undefined || reason === null)
+        return 'unknown error';
+    if (reason instanceof Error || typeof reason === 'string')
+        return toErrorMessage(reason);
+    const message = reason.message;
+    return typeof message === 'string' ? message : safeStringify(reason, 500);
+}
+/**
+ * Issue #535: goap_execution_steps marker row recording that an execution
+ * was cancelled (see persistExecutionResult). Excluded from step lists.
+ */
+const CANCELLED_MARKER_ACTION_ID = '__execution_cancelled__';
+const CANCELLED_MARKER_STATUS = 'cancelled';
 // ============================================================================
 // Plan Executor Class
 // ============================================================================
@@ -200,9 +219,30 @@ export class PlanExecutor {
      */
     async executeWithCallbacks(plan, onStepStart, onStepComplete, initialState) {
         await this.initialize();
-        const startTime = Date.now();
         const executionId = `exec-${Date.now()}-${randomUUID().slice(0, 8)}`;
         this.currentExecution = { planId: plan.id, cancelled: false };
+        try {
+            const result = await this.runPlan(plan, onStepStart, onStepComplete, initialState, {
+                excludedActions: new Set(),
+                replanDepth: 0,
+            });
+            // Persist once per top-level execution. Issue #535: replanned
+            // sub-plans used to persist their own steps AND hand them back to the
+            // parent, which persisted them again under the same step ids
+            // ("UNIQUE constraint failed: goap_execution_steps.id").
+            await this.persistExecutionResult(executionId, result);
+            return result;
+        }
+        finally {
+            this.currentExecution = null;
+        }
+    }
+    /**
+     * Run a plan's steps (and any replacement plans after a failure) without
+     * persisting or resetting execution tracking — see executeWithCallbacks.
+     */
+    async runPlan(plan, onStepStart, onStepComplete, initialState, replan) {
+        const startTime = Date.now();
         const result = {
             planId: plan.id,
             status: 'completed',
@@ -222,106 +262,115 @@ export class PlanExecutor {
             stepOrder: index,
             status: 'pending',
         }));
-        try {
-            for (const step of steps) {
-                // Check for cancellation
-                if (this.currentExecution?.cancelled) {
-                    result.status = 'cancelled';
-                    result.error = 'Execution was cancelled';
+        for (const step of steps) {
+            // Check for cancellation
+            if (this.currentExecution?.cancelled) {
+                result.status = 'cancelled';
+                result.error = 'Execution was cancelled';
+                break;
+            }
+            // Record world state before execution
+            if (this.config.recordWorldState) {
+                step.worldStateBefore = this.cloneState(currentState);
+            }
+            // Notify step start
+            onStepStart(step);
+            // Execute with retries
+            let success = false;
+            let lastError;
+            let retries = 0;
+            let output;
+            let agentId;
+            const stepStartTime = Date.now();
+            for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+                const execResult = await this.executeStep(step, currentState);
+                if (execResult.success) {
+                    success = true;
+                    currentState = execResult.newState;
+                    output = execResult.output;
+                    agentId = execResult.agentId;
                     break;
                 }
-                // Record world state before execution
-                if (this.config.recordWorldState) {
-                    step.worldStateBefore = this.cloneState(currentState);
-                }
-                // Notify step start
-                onStepStart(step);
-                // Execute with retries
-                let success = false;
-                let lastError;
-                let retries = 0;
-                let output;
-                let agentId;
-                const stepStartTime = Date.now();
-                for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
-                    const execResult = await this.executeStep(step, currentState);
-                    if (execResult.success) {
-                        success = true;
-                        currentState = execResult.newState;
-                        output = execResult.output;
-                        agentId = execResult.agentId;
-                        break;
-                    }
-                    lastError = execResult.error;
-                    retries = attempt;
-                    // Wait before retry (exponential backoff)
-                    if (attempt < this.config.maxRetries) {
-                        await this.delay(Math.min(1000 * Math.pow(2, attempt), 5000));
-                    }
+                lastError = execResult.error;
+                retries = attempt;
+                // Issue #535: deterministic failures (no implementation, domain
+                // not loaded, missing method, unmet preconditions) cannot succeed
+                // on retry — don't burn seconds of backoff on them.
+                if (execResult.retryable === false) {
+                    break;
                 }
-                // Record executed step
-                const executedStep = {
-                    ...step,
-                    status: success ? 'completed' : 'failed',
-                    retries,
-                    startedAt: new Date(stepStartTime),
-                    completedAt: new Date(),
-                    durationMs: Date.now() - stepStartTime,
-                    agentId,
-                    agentOutput: output,
-                    worldStateAfter: this.config.recordWorldState
-                        ? this.cloneState(currentState)
-                        : undefined,
-                    error: lastError,
-                };
-                result.steps.push(executedStep);
-                onStepComplete(executedStep);
-                if (success) {
-                    result.stepsCompleted++;
-                    await this.updateActionStats(step.action.id, true, executedStep.durationMs ?? 0);
+                // Wait before retry (exponential backoff)
+                if (attempt < this.config.maxRetries) {
+                    await this.delay(Math.min(1000 * Math.pow(2, attempt), 5000));
                 }
-                else {
-                    result.stepsFailed++;
-                    await this.updateActionStats(step.action.id, false, 0);
-                    // Try to replan if configured
-                    if (this.config.replanOnFailure) {
-                        const newPlan = await this.replanFromFailure(plan, step.stepOrder, currentState);
-                        if (newPlan) {
-                            // Execute new plan recursively
-                            const replanResult = await this.executeWithCallbacks(newPlan, onStepStart, onStepComplete, currentState);
-                            result.steps.push(...replanResult.steps);
-                            result.stepsCompleted += replanResult.stepsCompleted;
-                            result.stepsFailed += replanResult.stepsFailed;
-                            if (replanResult.status === 'completed' && replanResult.finalWorldState) {
-                                currentState = replanResult.finalWorldState;
-                            }
-                            else {
-                                result.status = 'partial';
-                                result.error = `Replanning partially succeeded: ${replanResult.error || 'unknown error'}`;
-                            }
+            }
+            // Record executed step
+            const executedStep = {
+                ...step,
+                status: success ? 'completed' : 'failed',
+                retries,
+                startedAt: new Date(stepStartTime),
+                completedAt: new Date(),
+                durationMs: Date.now() - stepStartTime,
+                agentId,
+                agentOutput: output,
+                worldStateAfter: this.config.recordWorldState
+                    ? this.cloneState(currentState)
+                    : undefined,
+                error: lastError,
+            };
+            result.steps.push(executedStep);
+            onStepComplete(executedStep);
+            if (success) {
+                result.stepsCompleted++;
+                await this.updateActionStats(step.action.id, true, executedStep.durationMs ?? 0);
+            }
+            else {
+                result.stepsFailed++;
+                await this.updateActionStats(step.action.id, false, 0);
+                // Try to replan if configured (bounded — issue #535)
+                const maxReplans = this.config.maxReplans ?? 3;
+                if (this.config.replanOnFailure && replan.replanDepth < maxReplans) {
+                    // Accumulate exclusions across successive replans so a chain of
+                    // failures can't bounce back to an action that already failed.
+                    replan.excludedActions.add(step.action.id);
+                    const newPlan = await this.replanFromFailure(plan, step.stepOrder, currentState, [...replan.excludedActions]);
+                    if (newPlan) {
+                        const replanResult = await this.runPlan(newPlan, onStepStart, onStepComplete, currentState, { excludedActions: replan.excludedActions, replanDepth: replan.replanDepth + 1 });
+                        result.steps.push(...replanResult.steps);
+                        result.stepsCompleted += replanResult.stepsCompleted;
+                        result.stepsFailed += replanResult.stepsFailed;
+                        if (replanResult.status === 'completed' && replanResult.finalWorldState) {
+                            currentState = replanResult.finalWorldState;
                         }
                         else {
-                            result.status = 'failed';
-                            result.error = `Step ${step.stepOrder} failed and replanning unsuccessful: ${lastError}`;
-                            break;
+                            // The goal was not reached — report it as such rather than
+                            // the old 'partial' ("Replanning partially succeeded").
+                            result.status = replanResult.status === 'cancelled' ? 'cancelled' : 'failed';
+                            result.error =
+                                `Step ${step.stepOrder} failed (${lastError}); replanning did not recover: ` +
+                                    `${replanResult.error || 'unknown error'}`;
                         }
+                        // The replacement plan supersedes the rest of this plan —
+                        // don't keep executing stale steps after it.
+                        break;
                     }
                     else {
                         result.status = 'failed';
-                        result.error = `Step ${step.stepOrder} failed: ${lastError}`;
+                        result.error = `Step ${step.stepOrder} failed and replanning unsuccessful: ${lastError}`;
                         break;
                     }
                 }
+                else {
+                    result.status = 'failed';
+                    result.error = `Step ${step.stepOrder} failed: ${lastError}`;
+                    break;
+                }
             }
-            result.finalWorldState = currentState;
-            result.totalDurationMs = Date.now() - startTime;
-            // Persist execution result
-            await this.persistExecutionResult(executionId, result);
-            return result;
-        }
-        finally {
-            this.currentExecution = null;
         }
+        result.finalWorldState = currentState;
+        result.totalDurationMs = Date.now() - startTime;
+        return result;
     }
     /**
      * Execute a single step
@@ -334,6 +383,7 @@ export class PlanExecutor {
                 success: false,
                 newState: currentState,
                 error: `Preconditions not met for action: ${action.name}`,
+                retryable: false,
             };
         }
         // A14: an action explicitly marked as having no real domain backing
@@ -347,6 +397,7 @@ export class PlanExecutor {
                 success: false,
                 newState: currentState,
                 error: `Action '${action.name}' has no real implementation yet (not simulated — see GOAPAction.implemented)`,
+                retryable: false,
             };
         }
         // A14: real dispatch — opt-in via constructor-injected getDomainAPI
@@ -359,9 +410,7 @@ export class PlanExecutor {
         const taskDescription = this.buildTaskDescription(action);
         try {
             // Execute with timeout
-            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Step timeout after ${this.config.stepTimeoutMs}ms`)), this.config.stepTimeoutMs));
-            const spawnPromise = this.spawner.spawn(action.agentType, taskDescription);
-            const agentResult = await Promise.race([spawnPromise, timeoutPromise]);
+            const agentResult = await this.withStepTimeout(this.spawner.spawn(action.agentType, taskDescription));
             if (agentResult.success) {
                 // Apply action effects to world state
                 const newState = this.applyEffects(currentState, action.effects);
@@ -404,6 +453,7 @@ export class PlanExecutor {
                 success: false,
                 newState: currentState,
                 error: `Action '${action.name}' has no qeDomain to resolve a real API from`,
+                retryable: false,
             };
         }
         if (!action.method) {
@@ -411,6 +461,7 @@ export class PlanExecutor {
                 success: false,
                 newState: currentState,
                 error: `Action '${action.name}' is marked implemented but has no method binding`,
+                retryable: false,
             };
         }
         let api;
@@ -429,6 +480,7 @@ export class PlanExecutor {
                 success: false,
                 newState: currentState,
                 error: `Domain '${action.qeDomain}' is not available (kernel not initialized, or the domain isn't loaded — try fleet_init)`,
+                retryable: false,
             };
         }
         const method = api[action.method];
@@ -437,12 +489,28 @@ export class PlanExecutor {
                 success: false,
                 newState: currentState,
                 error: `Domain '${action.qeDomain}' has no method '${action.method}'`,
+                retryable: false,
             };
         }
         try {
-            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Step timeout after ${this.config.stepTimeoutMs}ms`)), this.config.stepTimeoutMs));
             const invokePromise = method.call(api, action.params ?? {});
-            const result = await Promise.race([invokePromise, timeoutPromise]);
+            const result = await this.withStepTimeout(invokePromise);
+            // Issue #535: domain APIs return Result<T, Error> ({ success: false,
+            // error }) rather than throwing. Treating any resolved value as
+            // success reported e.g. detectGaps({}) -> err("missing coverageData")
+            // as a completed step and applied its effects — a fabricated success.
+            if (typeof result === 'object' &&
+                result !== null &&
+                result.success === false) {
+                const reason = result.error;
+                return {
+                    success: false,
+                    newState: currentState,
+                    agentId: `domain:${action.qeDomain}`,
+                    error: `Domain '${action.qeDomain}' method '${action.method}' returned an error: ` +
+                        describeDomainError(reason),
+                };
+            }
             const newState = this.applyEffects(currentState, action.effects);
             return {
                 success: true,
@@ -459,6 +527,25 @@ export class PlanExecutor {
             };
         }
     }
+    /**
+     * Race `work` against the per-step timeout, clearing the timer once the
+     * race settles so completed steps don't leave a pending timer behind
+     * (codex review, #535: it kept short-lived processes alive for up to
+     * stepTimeoutMs and accumulated timers across executions).
+     */
+    async withStepTimeout(work) {
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`Step timeout after ${this.config.stepTimeoutMs}ms`)), this.config.stepTimeoutMs);
+        });
+        try {
+            return await Promise.race([work, timeout]);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+    }
     /**
      * Build a task description for an agent
      */
@@ -494,11 +581,12 @@ export class PlanExecutor {
      * @param currentState - Current world state at failure point
      * @returns New plan or null if replanning fails
      */
-    async replanFromFailure(originalPlan, failedStepIndex, currentState) {
+    async replanFromFailure(originalPlan, failedStepIndex, currentState, additionalExcluded = []) {
         try {
-            // Exclude the failed action from replanning
+            // Exclude the failed action (and any that failed earlier in this
+            // execution) from replanning
             const failedAction = originalPlan.actions[failedStepIndex];
-            const excludedActions = [failedAction.id];
+            const excludedActions = [...new Set([failedAction.id, ...additionalExcluded])];
             // Try to find a new plan
             const newPlan = await this.planner.findPlan(currentState, originalPlan.goalState, { excludedActions });
             return newPlan;
@@ -555,7 +643,8 @@ export class PlanExecutor {
         SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as steps_completed,
         SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as steps_failed,
         SUM(COALESCE(duration_ms, 0)) as total_duration_ms,
-        COUNT(*) as steps_recorded,
+        SUM(CASE WHEN action_id = '${CANCELLED_MARKER_ACTION_ID}' THEN 0 ELSE 1 END) as steps_recorded,
+        SUM(CASE WHEN action_id = '${CANCELLED_MARKER_ACTION_ID}' THEN 1 ELSE 0 END) as cancelled_markers,
         MAX(CASE WHEN status = 'failed' THEN error_message END) as last_error
       FROM goap_execution_steps
     `;
@@ -571,9 +660,18 @@ export class PlanExecutor {
             const steps = await this.getExecutedSteps(row.execution_id);
             const finalWorldState = [...steps].reverse().find((s) => s.worldStateAfter)?.worldStateAfter;
             const plannedStepCount = this.getPlannedActionCount(row.plan_id);
+            // Issue #535: a failed step followed by a successful replacement plan
+            // is a recovered (completed) execution; only a run that ENDS on a
+            // failed step failed. Without failures, fewer recorded steps than
+            // planned means it was cancelled.
+            const lastStep = steps[steps.length - 1];
             let status;
-            if (row.steps_failed > 0)
+            if (row.cancelled_markers > 0)
+                status = 'cancelled';
+            else if (lastStep?.status === 'failed')
                 status = 'failed';
+            else if (row.steps_failed > 0)
+                status = 'completed';
             else if (plannedStepCount != null && row.steps_recorded < plannedStepCount)
                 status = 'cancelled';
             else
@@ -605,8 +703,8 @@ export class PlanExecutor {
      */
     async getExecutedSteps(executionId) {
         const rows = this.db
-            .prepare(`SELECT * FROM goap_execution_steps WHERE execution_id = ? ORDER BY step_order`)
-            .all(executionId);
+            .prepare(`SELECT * FROM goap_execution_steps WHERE execution_id = ? AND action_id != ? ORDER BY step_order`)
+            .all(executionId, CANCELLED_MARKER_ACTION_ID);
         return rows.map((row) => ({
             id: row.id,
             planId: row.plan_id,
@@ -662,8 +760,19 @@ export class PlanExecutor {
         agent_output, world_state_before, world_state_after, error_message
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        for (const step of result.steps) {
-            insertStep.run(step.id, step.planId, executionId, step.action.id, step.stepOrder, step.status, step.retries, step.startedAt.toISOString(), step.durationMs ?? null, step.agentId ?? null, step.agentOutput ?? null, step.worldStateBefore ? JSON.stringify(step.worldStateBefore) : null, step.worldStateAfter ? JSON.stringify(step.worldStateAfter) : null, step.error ?? null);
+        // Issue #535: steps from replacement plans (replanning) are recorded
+        // under the top-level plan id with a chronological step order, so one
+        // execution is one history record for the plan the caller executed —
+        // not split across sub-plan ids with colliding step orders.
+        result.steps.forEach((step, index) => {
+            insertStep.run(step.id, result.planId, executionId, step.action.id, index, step.status, step.retries, step.startedAt.toISOString(), step.durationMs ?? null, step.agentId ?? null, step.agentOutput ?? null, step.worldStateBefore ? JSON.stringify(step.worldStateBefore) : null, step.worldStateAfter ? JSON.stringify(step.worldStateAfter) : null, step.error ?? null);
+        });
+        // Issue #535 (codex review): an execution's cancellation cannot be
+        // inferred from its step rows once replanning is involved (the step
+        // count no longer matches the executed plan's action count), so record
+        // it explicitly with a marker row that history reads and then hides.
+        if (result.status === 'cancelled') {
+            insertStep.run(`${executionId}-${CANCELLED_MARKER_STATUS}`, result.planId, executionId, CANCELLED_MARKER_ACTION_ID, result.steps.length, CANCELLED_MARKER_STATUS, 0, new Date().toISOString(), null, null, null, null, null, result.error ?? 'Execution was cancelled');
         }
         // Reflects only the most recent execution attempt for this plan — a
         // deliberate, documented scope limit: goap_plans is one row per plan,

package/dist/planning/types.d.ts

@@ -220,6 +220,12 @@ export interface PlanConstraints {
     maxCost?: number;
     /** Maximum total duration in milliseconds */
     maxDurationMs?: number;
+    /**
+     * Maximum number of actions (steps) in the returned plan. Must be a
+     * positive integer; the planner rejects anything else. Defaults to
+     * DEFAULT_MAX_PLAN_STEPS when omitted. Issue #535.
+     */
+    maxSteps?: number;
     /** Only use actions that these agent types can execute */
     requiredAgentTypes?: string[];
     /** Exclude these specific action IDs */
@@ -227,6 +233,16 @@ export interface PlanConstraints {
     /** Prefer actions in these QE domains */
     preferredQeDomains?: QEDomain[];
 }
+/**
+ * Default A* depth limit (plan length cap) when constraints.maxSteps is unset.
+ */
+export declare const DEFAULT_MAX_PLAN_STEPS = 20;
+/**
+ * Validate a constraints.maxSteps value. Returns an error message, or null
+ * when the value is absent or a positive integer. Issue #535: shared by the
+ * planner and the goap_plan MCP tool so both boundaries reject the same input.
+ */
+export declare function validateMaxSteps(maxSteps: unknown): string | null;
 /**
  * Default world state for initialization
  */

package/dist/planning/types.js

@@ -12,6 +12,23 @@
  * @module planning/types
  * @version 3.0.0
  */
+/**
+ * Default A* depth limit (plan length cap) when constraints.maxSteps is unset.
+ */
+export const DEFAULT_MAX_PLAN_STEPS = 20;
+/**
+ * Validate a constraints.maxSteps value. Returns an error message, or null
+ * when the value is absent or a positive integer. Issue #535: shared by the
+ * planner and the goap_plan MCP tool so both boundaries reject the same input.
+ */
+export function validateMaxSteps(maxSteps) {
+    if (maxSteps === undefined)
+        return null;
+    if (typeof maxSteps !== 'number' || !Number.isInteger(maxSteps) || maxSteps < 1) {
+        return `constraints.maxSteps must be a positive integer, got ${String(maxSteps)}`;
+    }
+    return null;
+}
 // ============================================================================
 // Default World State
 // ============================================================================

package/dist/shared/error-utils.d.ts

@@ -13,4 +13,19 @@ export declare function toErrorMessage(error: unknown): string;
  * Coerce unknown error value to an Error instance.
  */
 export declare function toError(error: unknown): Error;
+/**
+ * A request was rejected because the caller's input is invalid (a malformed
+ * argument, an unknown function name, an unsupported option combination).
+ *
+ * The failure is deterministic and says nothing about the health of the
+ * component that rejected it, so it must not be retried and must not count
+ * toward a domain circuit breaker (ADR-064). The marker survives being
+ * flattened to a message string via `callerError` on TaskFailed events.
+ */
+export declare class CallerInputError extends Error {
+    readonly callerError: true;
+    constructor(message: string);
+}
+/** True when `error` is (or is marked as) a caller-input error. */
+export declare function isCallerInputError(error: unknown): boolean;
 //# sourceMappingURL=error-utils.d.ts.map

package/dist/shared/error-utils.js

@@ -17,4 +17,25 @@ export function toErrorMessage(error) {
 export function toError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
+/**
+ * A request was rejected because the caller's input is invalid (a malformed
+ * argument, an unknown function name, an unsupported option combination).
+ *
+ * The failure is deterministic and says nothing about the health of the
+ * component that rejected it, so it must not be retried and must not count
+ * toward a domain circuit breaker (ADR-064). The marker survives being
+ * flattened to a message string via `callerError` on TaskFailed events.
+ */
+export class CallerInputError extends Error {
+    callerError = true;
+    constructor(message) {
+        super(message);
+        this.name = 'CallerInputError';
+    }
+}
+/** True when `error` is (or is marked as) a caller-input error. */
+export function isCallerInputError(error) {
+    return error instanceof CallerInputError
+        || (typeof error === 'object' && error !== null && error.callerError === true);
+}
 //# sourceMappingURL=error-utils.js.map

package/dist/shared/events/domain-events.d.ts

@@ -17,7 +17,8 @@ export interface TestSuiteCreatedPayload {
     suiteId: string;
     testCount: number;
     sourceFiles: string[];
-    coverageEstimate: number;
+    /** null means unmeasured; never coerce unknown coverage to measured zero. */
+    coverageEstimate: number | null;
 }
 export declare const TestGenerationEvents: {
     readonly TestGenerated: "test-generation.TestGenerated";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.14.5",
+  "version": "3.14.7",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -78,7 +78,7 @@
     "mcp": "tsx src/mcp/entry.ts",
     "test": "NODE_OPTIONS='--max-old-space-size=1024 --expose-gc' vitest run",
     "test:unit": "npm run test:unit:fast && npm run test:unit:heavy && npm run test:unit:mcp",
-    "test:unit:fast": "vitest run --exclude='**/qe-reasoning-bank.test.ts' --exclude='**/qe-reasoning-bank-feedback-loop.test.ts' --exclude='**/aqe-learning-engine.test.ts' --exclude='**/aqe-learning-engine-patterns.test.ts' tests/unit/adapters tests/unit/shared tests/unit/cli tests/unit/learning tests/unit/kernel tests/unit/workers tests/unit/routing tests/unit/strange-loop tests/unit/sync tests/unit/feedback tests/unit/error-paths tests/unit/early-exit tests/unit/causal-discovery tests/unit/neural-optimizer tests/unit/test-scheduling tests/unit/logging tests/unit/validation tests/unit/memory tests/unit/performance tests/unit/scripts tests/unit/planning tests/context",
+    "test:unit:fast": "vitest run --exclude='**/qe-reasoning-bank.test.ts' --exclude='**/aqe-learning-engine.test.ts' --exclude='**/aqe-learning-engine-patterns.test.ts' tests/unit/adapters tests/unit/shared tests/unit/cli tests/unit/learning tests/unit/kernel tests/unit/workers tests/unit/routing tests/unit/strange-loop tests/unit/sync tests/unit/feedback tests/unit/error-paths tests/unit/early-exit tests/unit/causal-discovery tests/unit/neural-optimizer tests/unit/test-scheduling tests/unit/logging tests/unit/validation tests/unit/memory tests/unit/performance tests/unit/scripts tests/unit/planning tests/context",
     "test:unit:heavy": "vitest run tests/unit/coordination tests/unit/domains tests/unit/integrations tests/unit/optimization tests/unit/init --exclude='**/browser/**' --exclude='**/*.e2e.test.ts' --exclude='**/vibium/**' --exclude='**/browser-swarm-coordinator.test.ts'",
     "test:unit:mcp": "vitest run tests/unit/mcp --exclude='**/mcp/handlers/domain-handlers.test.ts' --fileParallelism=false",
     "test:ci": "vitest run --exclude='**/browser/**' --exclude='**/*.e2e.test.ts' --exclude='**/vibium/**' --exclude='**/integration/browser/**' --exclude='**/browser-swarm-coordinator.test.ts' --exclude='**/mcp/handlers/domain-handlers.test.ts' --exclude='**/fixtures/init-corpus/**'",
@@ -115,7 +115,7 @@
     "test:journeys:ci": "vitest run tests/integration/ --exclude='**/browser/**' --exclude='**/browser-integration/**' --exclude='**/integration/mcp/**' --exclude='**/integration/sync/**' --exclude='**/integration/learning/**' --exclude='**/integration/domains/**' --exclude='**/integration/llm/**' --exclude='**/integration/n8n/**' --exclude='**/*.e2e.test.ts'",
     "test:watch": "vitest",
     "performance:gate": "npx tsx src/performance/run-gates.ts",
-    "test:integration:browser": "VIBIUM_REAL_TESTS=true vitest run tests/integrations/vibium/vibium-real.test.ts",
+    "test:integration:browser": "VIBIUM_REAL_TESTS=true vitest run --config config/vitest.browser.config.ts",
     "benchmark:token-reduction": "vitest bench tests/benchmarks/code-intelligence-token-reduction.bench.ts",
     "benchmark:self-learning": "tsx scripts/benchmark-self-learning.ts",
     "benchmark:rabitq": "tsx scripts/benchmark-rabitq.ts",
@@ -196,13 +196,13 @@
     "semver": "^7.8.5",
     "typescript": "^5.9.3",
     "uuid": "^14.0.0",
-    "vibium": "^0.1.2",
     "web-tree-sitter": "~0.26.8",
     "yaml": "^2.8.2"
   },
   "peerDependencies": {
     "@claude-flow/browser": "3.0.0-alpha.1",
-    "@claude-flow/guidance": "3.0.0-alpha.1"
+    "@claude-flow/guidance": "3.0.0-alpha.1",
+    "vibium": "^26.8.21"
   },
   "peerDependenciesMeta": {
     "@claude-flow/browser": {
@@ -210,6 +210,9 @@
     },
     "@claude-flow/guidance": {
       "optional": true
+    },
+    "vibium": {
+      "optional": true
     }
   },
   "optionalDependencies": {
@@ -276,7 +279,8 @@
     "glob": "^13.0.0",
     "msw": "^2.12.7",
     "tsx": "^4.21.0",
-    "vitest": "^5.0.1"
+    "vitest": "^5.0.1",
+    "vibium": "^26.8.21"
   },
   "engines": {
     "node": ">=22.13.0",

package/dist/cli/chunks/adapter-IYC62SXA.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.14.5");process.exit(0)}
-import{a,b,c}from"./chunk-UKGXWW64.js";import"./chunk-I2NENQ44.js";import"./chunk-DLF5BOJD.js";import"./chunk-IJHCIXJC.js";import"./chunk-J5UNP6W3.js";import"./chunk-JSZ663MU.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/agent-booster-wasm-EDNKP3SP.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.14.5");process.exit(0)}
-import{a as x}from"./chunk-J27F4NSB.js";import{c as f}from"./chunk-7CD7PBHY.js";import"./chunk-JSZ663MU.js";x();import{createRequire as w}from"module";var S=f.create("agent-booster-wasm"),t={JavaScript:0,TypeScript:1,Python:2,Rust:3,Go:4,Java:5,C:6,Cpp:7},l={ExactReplace:0,FuzzyReplace:1,InsertAfter:2,InsertBefore:3,Append:4},v={0:"JavaScript",1:"TypeScript",2:"Python",3:"Rust",4:"Go",5:"Java",6:"C",7:"Cpp"},a=null,u=null,p=null;async function g(){if(a)return!0;if(p)return!1;try{if(a=w(import.meta.url)("./agent_booster_wasm.js"),!a)throw new Error("WASM module loaded but is null");return u=new a.AgentBoosterWasm,!0}catch(e){return p=e,console.warn("[AgentBoosterWASM] Failed to load WASM module:",e),!1}}function A(e){return{".js":t.JavaScript,".mjs":t.JavaScript,".cjs":t.JavaScript,".jsx":t.JavaScript,".ts":t.TypeScript,".tsx":t.TypeScript,".mts":t.TypeScript,".cts":t.TypeScript,".py":t.Python,".rs":t.Rust,".go":t.Go,".java":t.Java,".c":t.C,".h":t.C,".cpp":t.Cpp,".cc":t.Cpp,".cxx":t.Cpp,".hpp":t.Cpp}[e.toLowerCase()]??t.JavaScript}var M=[{name:"var-to-const",detect:(e,r)=>e.includes("var ")&&r.includes("const "),apply:(e,r)=>e.replace(/\bvar\s+/g,"const ")},{name:"var-to-let",detect:(e,r)=>e.includes("var ")&&r.includes("let "),apply:(e,r)=>e.replace(/\bvar\s+/g,"let ")},{name:"add-types-function",detect:(e,r)=>e.includes("function")&&!e.includes(":")&&r.includes(":"),apply:(e,r)=>r},{name:"async-wrapper",detect:(e,r)=>!e.includes("async")&&r.includes("async")&&r.includes("await"),apply:(e,r)=>r},{name:"try-catch-wrapper",detect:(e,r)=>!e.includes("try {")&&r.includes("try {"),apply:(e,r)=>r},{name:"null-check",detect:(e,r)=>!e.includes("if (!")&&!e.includes("if (!")&&(r.includes("if (!")||r.includes("?.")),apply:(e,r)=>r},{name:"test-assertion",detect:(e,r)=>e.includes("test(")&&!e.includes("expect(")&&r.includes("expect("),apply:(e,r)=>r}];function y(e,r){for(let n of M)if(n.detect(e,r))try{return{success:!0,code:n.apply(e,r),pattern:n.name}}catch(s){S.debug("Pattern transform failed, trying next",{pattern:n.name,error:s instanceof Error?s.message:String(s)});continue}return{success:!1,code:r}}async function b(e,r,n,s={}){let o=performance.now(),{confidenceThreshold:T=.5,allowFallback:d=!0}=s;if(!e.trim())return{success:!0,mergedCode:r,confidence:1,strategy:l.Append,syntaxValid:!0,source:"fallback",latencyMs:performance.now()-o};if(await g()&&u&&a)try{let c=a.WasmLanguage[v[n]],i=u.apply_edit(e,r,c);return{success:!0,mergedCode:i.merged_code,confidence:i.confidence,strategy:i.strategy,syntaxValid:i.syntax_valid,source:"wasm",latencyMs:performance.now()-o}}catch(c){let i=c;if(d){let m=y(e,r);if(m.success)return{success:!0,mergedCode:m.code,confidence:.7,strategy:l.FuzzyReplace,syntaxValid:!0,source:"pattern",latencyMs:performance.now()-o}}return{success:!1,mergedCode:r,confidence:0,strategy:l.Append,syntaxValid:!1,source:"fallback",latencyMs:performance.now()-o,error:i.message}}if(d){let c=y(e,r);return{success:c.success,mergedCode:c.code,confidence:c.success?.7:0,strategy:l.FuzzyReplace,syntaxValid:!0,source:"pattern",latencyMs:performance.now()-o}}return{success:!1,mergedCode:r,confidence:0,strategy:l.Append,syntaxValid:!1,source:"fallback",latencyMs:performance.now()-o,error:p?.message??"WASM not available"}}async function W(e,r={}){return Promise.all(e.map(({original:n,edit:s,language:o})=>b(n,s,o,r)))}async function C(){return g()}async function L(){return await g()&&a?a.AgentBoosterWasm.version():"unavailable"}async function R(){if(await g(),u&&a)try{u.apply_edit("function x() {}","function x() {}",a.WasmLanguage.JavaScript)}catch(e){console.debug("[AgentBoosterWASM] Warmup error:",e instanceof Error?e.message:e)}}var _={transform:b,batchTransform:W,isWasmAvailable:C,getVersion:L,warmup:R,Language:t,MergeStrategy:l,languageFromExtension:A};export{t as Language,l as MergeStrategy,W as batchTransform,_ as default,L as getVersion,C as isWasmAvailable,A as languageFromExtension,b as transform,R as warmup};