agentic-qe 3.9.17 → 3.9.19

package/dist/cli/commands/hooks-handlers/routing-hooks.js

@@ -8,7 +8,7 @@ import { randomUUID } from 'crypto';
 import chalk from 'chalk';
 import path from 'node:path';
 import { findProjectRoot } from '../../../kernel/unified-memory.js';
-import { getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, printJson, printError, printGuidance, } from './hooks-shared.js';
+import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, printJson, printError, printGuidance, } from './hooks-shared.js';
 /**
  * Read piped stdin with a short timeout. Claude Code delivers
  * UserPromptSubmit / PostToolUse / etc. events as JSON on stdin —
@@ -147,7 +147,15 @@ export function registerRoutingHooks(hooks) {
                     await um.initialize();
                 }
                 const db = um.getDatabase();
+                applyHookBusyTimeout(db);
                 const outcomeId = `route-${Date.now()}-${randomUUID().slice(0, 8)}`;
+                // Split-write semantics: quality_score means "outcome quality after
+                // task ran" (6-dim formula), NOT routing confidence. Routing-
+                // confidence stays in decision_json. We write a sentinel
+                // (success=0, quality_score=-1) so post-task UPDATE fills the actual
+                // quality. lowConfidence is surfaced via decision_json + the error
+                // column so it's visible in queries that don't parse JSON.
+                const lowConfidence = routing.confidence < 0.5;
                 db.prepare(`
             INSERT OR REPLACE INTO routing_outcomes (
               id, task_json, decision_json, used_agent,
@@ -158,10 +166,12 @@ export function registerRoutingHooks(hooks) {
                     recommended: routing.recommendedAgent,
                     confidence: routing.confidence,
                     alternatives: routing.alternatives,
-                }), routing.recommendedAgent, 1, // followed_recommendation = true (recommendation stage)
-                1, // success = true (routing itself succeeded)
-                routing.confidence, 0, // duration not tracked at routing stage
-                null);
+                    lowConfidence,
+                }), routing.recommendedAgent, 1, // followed_recommendation = true
+                0, // success = 0 (sentinel — post-task UPDATEs)
+                -1, // quality_score = -1 sentinel
+                0, // duration not yet tracked
+                lowConfidence ? 'low-confidence' : null);
                 // Increment dream experience counter
                 const projectRoot = findProjectRoot();
                 const dataDir = path.join(projectRoot, '.agentic-qe');

package/dist/cli/commands/hooks-handlers/task-hooks.js

@@ -4,11 +4,52 @@
  *
  * Handles task lifecycle hooks for pattern learning.
  */
+import { createHash, randomUUID } from 'node:crypto';
 import chalk from 'chalk';
 import path from 'node:path';
 import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
-import { findProjectRoot } from '../../../kernel/unified-memory.js';
-import { getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, checkAndTriggerDream, printJson, printSuccess, } from './hooks-shared.js';
+import { findProjectRoot, getUnifiedMemory } from '../../../kernel/unified-memory.js';
+import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, checkAndTriggerDream, persistTaskOutcome, updateHookRouterQValue, updateRoutingOutcomeQuality, printJson, printSuccess, } from './hooks-shared.js';
+// ============================================================================
+// Constants — task-bridge / routing-quality / q-learning
+// ============================================================================
+/** kv_store namespace key for cross-subprocess pre-task → post-task bridge */
+const TASK_BRIDGE_NAMESPACE = 'task-bridge';
+/** Bridge TTL: a Task() invocation rarely exceeds this — older entries are stale */
+const TASK_BRIDGE_TTL_MS = 600_000; // 10 minutes
+/** Confidence floor below which we flag the route as low-confidence (patch 320) */
+const LOW_CONFIDENCE_THRESHOLD = 0.5;
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Derive a structural taskType from a free-form task description.
+ * Mirrors the categories the q-learning router cares about (ADR-061/087).
+ */
+function deriveTaskType(description) {
+    const d = description.toLowerCase();
+    if (/\bgenerate[- ]?test|\btest[- ]?gen|\bgenerate.+spec/.test(d))
+        return 'test-generation';
+    if (/\bcoverage|\banalyze.+cover/.test(d))
+        return 'coverage-analysis';
+    if (/\bquality|\bassess|\baudit/.test(d))
+        return 'quality-assessment';
+    if (/\bsecurity|\bvulnerab|\bcompliance/.test(d))
+        return 'security-compliance';
+    if (/\bdefect|\bbug|\bdiagnos/.test(d))
+        return 'defect-intelligence';
+    if (/\brequirement|\bspec\b/.test(d))
+        return 'requirements-validation';
+    if (/\brefactor|\brewrite|\boptim/.test(d))
+        return 'refactoring';
+    if (/\btest|\brun.+test/.test(d))
+        return 'test-execution';
+    return 'unknown';
+}
+/** Hash a description to a stable short bridge key. */
+function hashDescription(description) {
+    return createHash('sha256').update(description).digest('hex').slice(0, 16);
+}
 /**
  * Register pre-task and post-task subcommands on the hooks command.
  */
@@ -35,6 +76,132 @@ export function registerTaskHooks(hooks) {
                     routing = result.value;
                 }
             }
+            // Patch 050: top-5 selectedPatternIds for downstream per-pattern feedback
+            const selectedPatternIds = (routing?.patterns ?? [])
+                .slice(0, 5)
+                .map((p) => p?.id)
+                .filter((id) => typeof id === 'string');
+            // Patches 090/100/160/300/320: signals derived from memory.db.
+            // All best-effort: failures fall through to empty/default values.
+            let historicalBest = null;
+            let priorVerdicts = [];
+            let estimatedTokenSavings = 0;
+            let bridgeKey = null;
+            try {
+                const um = getUnifiedMemory();
+                if (!um.isInitialized()) {
+                    await um.initialize();
+                }
+                const db = um.getDatabase();
+                applyHookBusyTimeout(db);
+                // Patch 090: best-historical-agent across past successful routes
+                try {
+                    const row = db.prepare(`
+              SELECT used_agent AS agent,
+                     ROUND(AVG(quality_score), 3) AS avgQuality,
+                     COUNT(*) AS n
+              FROM routing_outcomes
+              WHERE success = 1 AND quality_score >= 0
+              GROUP BY used_agent
+              ORDER BY avgQuality DESC, n DESC
+              LIMIT 1
+            `).get();
+                    if (row)
+                        historicalBest = row;
+                }
+                catch { /* table may be empty */ }
+                // Patch 100: surface recent verdicts namespace for context reuse
+                try {
+                    const rows = db.prepare(`
+              SELECT key, value
+              FROM kv_store
+              WHERE namespace = 'verdicts'
+                AND created_at > datetime('now', '-7 days')
+              ORDER BY created_at DESC
+              LIMIT 3
+            `).all();
+                    priorVerdicts = rows.map((r) => ({
+                        key: r.key,
+                        summary: String(r.value).slice(0, 200),
+                    }));
+                }
+                catch { /* table may be empty */ }
+                // Patch 300: bootstrap estimatedTokenSavings from selected patterns
+                if (selectedPatternIds.length > 0) {
+                    try {
+                        const placeholders = selectedPatternIds.map(() => '?').join(',');
+                        const tokRow = db.prepare(`
+                SELECT COALESCE(SUM(average_token_savings), 0) AS sum
+                FROM qe_patterns
+                WHERE id IN (${placeholders})
+              `).get(...selectedPatternIds);
+                        estimatedTokenSavings = Math.max(0, Math.round(tokRow?.sum ?? 0));
+                    }
+                    catch { /* column may not exist on older schemas */ }
+                }
+                // Patch 160 + 280-bridge: write the task-bridge entry that post-task
+                // will consume to fan out experience_applications per pattern_id and
+                // derive a structural q-learning state_key.
+                if (options.description && selectedPatternIds.length > 0) {
+                    try {
+                        const description = String(options.description);
+                        const taskType = deriveTaskType(description);
+                        const priority = 'normal';
+                        const domain = routing?.domains?.[0] ?? 'any';
+                        const complexityBucket = Math.max(0, Math.min(10, Math.round(Math.min(description.length / 200, 1) * 10)));
+                        bridgeKey = `task:${hashDescription(description)}`;
+                        const payload = JSON.stringify({
+                            selectedPatternIds,
+                            agent: routing?.recommendedAgent ?? null,
+                            description: description.slice(0, 200),
+                            taskType,
+                            priority,
+                            domain,
+                            complexityBucket,
+                            estimatedTokenSavings,
+                            ts: Date.now(),
+                        });
+                        const expiresAt = Date.now() + TASK_BRIDGE_TTL_MS;
+                        db.prepare(`
+                INSERT OR REPLACE INTO kv_store (key, namespace, value, expires_at, created_at)
+                VALUES (?, ?, ?, ?, strftime('%s','now')*1000)
+              `).run(bridgeKey, TASK_BRIDGE_NAMESPACE, payload, expiresAt);
+                    }
+                    catch (bridgeErr) {
+                        console.error(chalk.dim(`[hooks] pre-task bridge: ${bridgeErr instanceof Error ? bridgeErr.message : 'unknown'}`));
+                    }
+                }
+                // Patch 150: write a routing_outcomes sentinel that post-task UPDATEs
+                // with the 6-dim outcome quality. Pre-task cannot know quality yet.
+                // success=0/quality=-1 sentinel pair makes the row easy to find later.
+                if (routing?.recommendedAgent && options.taskId) {
+                    try {
+                        const outcomeId = `route-${Date.now()}-${randomUUID().slice(0, 8)}`;
+                        const lowConfidence = routing.confidence < LOW_CONFIDENCE_THRESHOLD;
+                        db.prepare(`
+                INSERT INTO routing_outcomes (
+                  id, task_json, decision_json, used_agent,
+                  followed_recommendation, success, quality_score,
+                  duration_ms, error
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+              `).run(outcomeId, JSON.stringify({ description: options.description, taskId: options.taskId }), JSON.stringify({
+                            recommended: routing.recommendedAgent,
+                            confidence: routing.confidence,
+                            alternatives: routing.alternatives,
+                            lowConfidence,
+                        }), routing.recommendedAgent, 1, 0, // success = 0 (sentinel — post-task UPDATEs to actual)
+                        -1, // quality_score = -1 sentinel
+                        0, lowConfidence ? 'low-confidence' : null);
+                    }
+                    catch (sentinelErr) {
+                        console.error(chalk.dim(`[hooks] pre-task sentinel: ${sentinelErr instanceof Error ? sentinelErr.message : 'unknown'}`));
+                    }
+                }
+            }
+            catch (memErr) {
+                console.error(chalk.dim(`[hooks] pre-task memory: ${memErr instanceof Error ? memErr.message : 'unknown'}`));
+            }
+            const lowConfidence = routing ? routing.confidence < LOW_CONFIDENCE_THRESHOLD : false;
             if (options.json) {
                 printJson({
                     success: true,
@@ -43,6 +210,18 @@ export function registerTaskHooks(hooks) {
                     recommendedAgent: routing?.recommendedAgent,
                     confidence: routing?.confidence,
                     guidance: routing?.guidance || [],
+                    // Patch 050
+                    selectedPatternIds,
+                    // Patch 090
+                    historicalBest,
+                    // Patch 100
+                    priorVerdicts,
+                    // Patch 300
+                    estimatedTokenSavings,
+                    // Patch 320
+                    lowConfidence,
+                    // Bridge identifier so post-task can correlate (debug aid)
+                    bridgeKey,
                 });
             }
             else {
@@ -51,6 +230,9 @@ export function registerTaskHooks(hooks) {
                 if (routing) {
                     console.log(chalk.bold('\n🎯 Recommended:'), chalk.cyan(routing.recommendedAgent));
                     console.log(chalk.dim(`  Confidence: ${(routing.confidence * 100).toFixed(1)}%`));
+                    if (lowConfidence) {
+                        console.log(chalk.yellow('  ⚠  Low confidence — consider providing more context'));
+                    }
                 }
             }
             return;
@@ -95,14 +277,43 @@ export function registerTaskHooks(hooks) {
                 // Record as learning experience for every post-task invocation
                 if (options.taskId) {
                     const agent = options.agent || 'unknown';
+                    const durationMs = options.duration ? parseInt(options.duration, 10) : 0;
                     await reasoningBank.recordOutcome({
                         patternId: `task:${agent}:${options.taskId}`,
                         success,
-                        metrics: {
-                            executionTimeMs: options.duration ? parseInt(options.duration, 10) : 0,
-                        },
+                        metrics: { executionTimeMs: durationMs },
                         feedback: `Agent: ${agent}, Task: ${options.taskId}`,
                     });
+                    // Stream B: full experience pipeline (captured_experiences,
+                    // experience_applications + per-pattern fan-out, qe_trajectories
+                    // single-step + multi-step stitch, dream_insights.applied bump).
+                    // Patches 060/110/120/160/180/300.
+                    const outcome = await persistTaskOutcome({
+                        taskId: options.taskId,
+                        agent,
+                        durationMs,
+                        success,
+                    });
+                    // Stream D (patch 150): apply 6-dim outcome quality to the
+                    // routing_outcomes sentinel that pre-task wrote with quality=-1.
+                    await updateRoutingOutcomeQuality({
+                        agent,
+                        success,
+                        durationMs,
+                        qualityScore: outcome.qualityScore,
+                    });
+                    // Stream F (patch 280): Bellman Q-update for the hook-router state.
+                    // Bridge payload carries the structural state derivation.
+                    if (outcome.bridge) {
+                        await updateHookRouterQValue({
+                            taskType: outcome.bridge.taskType,
+                            priority: outcome.bridge.priority,
+                            domain: outcome.bridge.domain,
+                            complexityBucket: outcome.bridge.complexityBucket,
+                            agent,
+                            success,
+                        });
+                    }
                 }
                 // Record experience for dream scheduler and check if dream should trigger
                 const projectRoot = findProjectRoot();

package/dist/coordination/handlers/test-execution-handlers.d.ts

@@ -5,5 +5,23 @@
  * Covers: generate-tests, execute-tests
  */
 import type { TaskHandlerContext } from './handler-types';
+/**
+ * Rewrite any temp-source references in a generated test so the user gets a
+ * test that imports from the original source path (when known) or a clear
+ * placeholder. Without this, generated tests reference the throwaway
+ * `/tmp/aqe-temp-*` file we created for analysis — that file is unlinked
+ * after generation, so the test would never run as-emitted.
+ *
+ * The generator may emit the temp path with the original extension
+ * (`/tmp/aqe-temp-X.ts`), with a substituted extension
+ * (`/tmp/aqe-temp-X.test.ts`), or extension-stripped (TS import convention:
+ * `/tmp/aqe-temp-X`). All three forms must be rewritten.
+ *
+ * Exported for unit testing (bug #1 regression).
+ */
+export declare function rewriteTempPathsInGeneratedTest(testCode: string | undefined, sourceFile: string | undefined, tempPath: string | undefined, originalFilePath: string | undefined): {
+    testCode?: string;
+    sourceFile?: string;
+};
 export declare function registerTestExecutionHandlers(ctx: TaskHandlerContext): void;
 //# sourceMappingURL=test-execution-handlers.d.ts.map

package/dist/coordination/handlers/test-execution-handlers.js

@@ -8,6 +8,49 @@ import { v4 as uuidv4 } from 'uuid';
 import * as fs from 'fs/promises';
 import { ok, err } from '../../shared/types';
 import { toError } from '../../shared/error-utils.js';
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Rewrite any temp-source references in a generated test so the user gets a
+ * test that imports from the original source path (when known) or a clear
+ * placeholder. Without this, generated tests reference the throwaway
+ * `/tmp/aqe-temp-*` file we created for analysis — that file is unlinked
+ * after generation, so the test would never run as-emitted.
+ *
+ * The generator may emit the temp path with the original extension
+ * (`/tmp/aqe-temp-X.ts`), with a substituted extension
+ * (`/tmp/aqe-temp-X.test.ts`), or extension-stripped (TS import convention:
+ * `/tmp/aqe-temp-X`). All three forms must be rewritten.
+ *
+ * Exported for unit testing (bug #1 regression).
+ */
+export function rewriteTempPathsInGeneratedTest(testCode, sourceFile, tempPath, originalFilePath) {
+    if (!tempPath) {
+        return { testCode, sourceFile };
+    }
+    // For the user's import target we strip the source extension when the
+    // original is a path (TS imports omit `.ts`); preserve it otherwise.
+    const stripExt = (p) => p.replace(/\.[a-z]+$/i, '');
+    const replacement = originalFilePath
+        ? (originalFilePath.match(/\.(ts|tsx|js|jsx|mjs|cjs)$/i) ? stripExt(originalFilePath) : originalFilePath)
+        : './module-under-test';
+    const todoComment = originalFilePath
+        ? ''
+        : `// TODO: replace './module-under-test' with the actual import path of the module under test\n`;
+    // Build a regex that matches the temp path with any (or no) extension suffix.
+    // Order matters: replace extension-bearing forms before extension-less, since
+    // the extension-less form is a prefix of the others.
+    const tempBase = stripExt(tempPath);
+    const tempBaseEscaped = escapeRegExp(tempBase);
+    // Matches: <base>.<ext> | <base>.<ext>.<ext> | <base>
+    const anyForm = new RegExp(tempBaseEscaped + '(?:\\.[a-zA-Z]+){0,2}', 'g');
+    const newCode = testCode
+        ? todoComment + testCode.replace(anyForm, replacement)
+        : testCode;
+    const newRef = sourceFile === tempPath ? (originalFilePath || sourceFile) : sourceFile;
+    return { testCode: newCode, sourceFile: newRef };
+}
 export function registerTestExecutionHandlers(ctx) {
     // Register test generation handler - REAL IMPLEMENTATION
     ctx.registerHandler('generate-tests', async (task) => {
@@ -16,6 +59,7 @@ export function registerTestExecutionHandlers(ctx) {
             const generator = ctx.getTestGenerator();
             // Determine source files to analyze
             let sourceFiles = [];
+            let tempPath;
             if (payload.sourceFiles && payload.sourceFiles.length > 0) {
                 sourceFiles = payload.sourceFiles;
             }
@@ -32,7 +76,7 @@ export function registerTestExecutionHandlers(ctx) {
                     cpp: '.cpp', c: '.c', scala: '.scala',
                 };
                 const ext = langExtMap[payload.language?.toLowerCase() || 'typescript'] || '.ts';
-                const tempPath = `/tmp/aqe-temp-${uuidv4()}${ext}`;
+                tempPath = `/tmp/aqe-temp-${uuidv4()}${ext}`;
                 await fs.writeFile(tempPath, payload.sourceCode, 'utf-8');
                 sourceFiles = [tempPath];
             }
@@ -46,30 +90,54 @@ export function registerTestExecutionHandlers(ctx) {
                     warning: 'No source files or code provided for test generation. Provide sourceCode, filePath, or sourceFiles in the payload.',
                 });
             }
-            // Use the real TestGeneratorService
+            // Use the real TestGeneratorService.
+            // Bug #1 fix: when we wrote a temp file for analysis, tell the generator
+            // to bake a sensible logical import path into the emitted tests instead
+            // of the throwaway temp path. If the user supplied filePath, use that;
+            // otherwise use a placeholder the user can edit.
             const framework = (payload.framework || 'vitest');
+            const importPathOverrides = tempPath
+                ? { [tempPath]: payload.filePath
+                        ? payload.filePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, '')
+                        : './module-under-test' }
+                : undefined;
             const result = await generator.generateTests({
                 sourceFiles,
                 testType: payload.testType || 'unit',
                 framework,
                 coverageTarget: payload.coverageGoal || 80,
                 patterns: [],
+                importPathOverrides,
             });
+            // Always clean up the temp file we created — even on failure
+            if (tempPath) {
+                try {
+                    await fs.unlink(tempPath);
+                }
+                catch { /* best-effort */ }
+            }
             if (!result.success) {
                 return result;
             }
             const generatedTests = result.value;
-            return ok({
-                testsGenerated: generatedTests.tests.length,
-                coverageEstimate: generatedTests.coverageEstimate,
-                tests: generatedTests.tests.map(t => ({
+            // Rewrite any temp-path references in generated tests so users get tests
+            // that reference a real source path (or a clear placeholder) rather than
+            // a /tmp/aqe-temp-* path that never existed in their codebase.
+            const tests = generatedTests.tests.map(t => {
+                const rewritten = rewriteTempPathsInGeneratedTest(t.testCode, t.sourceFile, tempPath, payload.filePath);
+                return {
                     name: t.name,
                     file: t.testFile,
                     type: t.type,
-                    sourceFile: t.sourceFile,
+                    sourceFile: rewritten.sourceFile,
                     assertions: t.assertions,
-                    testCode: t.testCode,
-                })),
+                    testCode: rewritten.testCode,
+                };
+            });
+            return ok({
+                testsGenerated: tests.length,
+                coverageEstimate: generatedTests.coverageEstimate,
+                tests,
                 patternsUsed: generatedTests.patternsUsed,
             });
         }

package/dist/coordination/task-executor.js

@@ -297,9 +297,18 @@ export class DomainTaskExecutor {
             // Log outcome for debugging and metrics
             console.debug(`[TaskExecutor] Outcome recorded: task=${task.id}, tier=${tier}, ` +
                 `model=${getModelForTier(tier)}, success=${success}, duration=${durationMs}ms`);
-            // ADR-023: Record routing outcome for learning feedback loop
+            // ADR-023: Record routing outcome for learning feedback loop.
+            // qualityScore uses the 6-dim outcome formula (matches the post-task
+            // hook UPDATE path) instead of a binary success?0.8:0.2.
             if (this.qualityFeedbackLoop) {
                 const targetDomains = task.targetDomains || [];
+                const successScore = success ? 1 : 0;
+                const durationTier = durationMs < 100 ? 1.0 :
+                    durationMs < 500 ? 0.8 :
+                        durationMs < 2000 ? 0.6 :
+                            durationMs < 5000 ? 0.4 :
+                                durationMs < 10000 ? 0.2 : 0.1;
+                const qualityScore = 0.25 * successScore + 0.325 + 0.10 * durationTier;
                 await this.qualityFeedbackLoop.recordRoutingOutcome({
                     taskId: task.id,
                     taskDescription: task.type,
@@ -307,7 +316,7 @@ export class DomainTaskExecutor {
                     usedAgent: String(tier),
                     followedRecommendation: true,
                     success,
-                    qualityScore: success ? 0.8 : 0.2,
+                    qualityScore,
                     durationMs,
                     timestamp: new Date(),
                     error: success ? undefined : 'Task execution failed',

package/dist/domains/test-generation/generators/jest-vitest-generator.js

@@ -52,8 +52,15 @@ export class JestVitestGenerator extends BaseTestGenerator {
         const patternComment = this.generatePatternComment(patterns);
         const exports = this.extractExports(analysis.functions, analysis.classes);
         const importStatement = this.generateImportStatement(exports, importPath, moduleName);
-        const mockImport = this.framework === 'vitest' ? ', vi' : '';
-        let testCode = `${patternComment}import { describe, it, expect, beforeEach${mockImport} } from '${this.framework}';
+        // Per-framework imports:
+        // - vitest: `import { ..., vi } from 'vitest'` (vi is the mock util)
+        // - jest:   `import { ..., jest } from '@jest/globals'`
+        //   (jest 28+ provides @jest/globals; importing from 'jest' is invalid —
+        //    it's a CLI package, not a runtime export. Globals work too but
+        //    explicit imports match vitest style and are TS-friendly.)
+        const mockImport = this.framework === 'vitest' ? ', vi' : ', jest';
+        const importSource = this.framework === 'vitest' ? 'vitest' : '@jest/globals';
+        let testCode = `${patternComment}import { describe, it, expect, beforeEach${mockImport} } from '${importSource}';
 ${importStatement}
 `;
         // KG: Generate mock declarations for external (non-relative) dependencies only.
@@ -274,7 +281,10 @@ ${importStatement}
             callerTest += `      expect(publicKeys.length).toBeGreaterThan(0);\n`;
             callerTest += `    });\n`;
         }
-        return `${patternComment}import { ${moduleName} } from '${importPath}';
+        const stubImportSource = this.framework === 'vitest' ? 'vitest' : '@jest/globals';
+        const stubMockImport = this.framework === 'vitest' ? ', vi' : ', jest';
+        return `${patternComment}import { describe, it, expect, beforeEach${stubMockImport} } from '${stubImportSource}';
+import { ${moduleName} } from '${importPath}';
 ${mockDeclarations}
 describe('${moduleName}', () => {
 ${similarityComment}  describe('${testType} tests', () => {

package/dist/domains/test-generation/interfaces.d.ts

@@ -26,6 +26,18 @@ export interface IGenerateTestsRequest {
     projectRoot?: string;
     compileValidation?: boolean;
     maxCompileRetries?: number;
+    /**
+     * Map of sourceFile path → import path to bake into generated test imports.
+     * Use this when the file at `sourceFiles[i]` is a temporary copy of source
+     * (e.g. an inline-source MCP call) and the generated tests should reference
+     * a different logical path. If a file is not in the map, the import path
+     * is derived from the source file path as before.
+     *
+     * Example:
+     *   { '/tmp/aqe-temp-abc.ts': './src/services/auth' }
+     * → generated test emits `import { ... } from './src/services/auth'`
+     */
+    importPathOverrides?: Record<string, string>;
 }
 export interface IGeneratedTests {
     tests: IGeneratedTest[];

package/dist/domains/test-generation/services/test-generator.js

@@ -420,7 +420,11 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
         }
         const generator = this.generatorFactory.create(framework);
         const moduleName = this.extractModuleName(sourceFile);
-        const importPath = this.getImportPath(sourceFile);
+        // Bug #1 fix: prefer caller-supplied import path override when present
+        // (used by MCP handler when sourceCode is written to a temp file but the
+        // generated tests should reference the original logical path).
+        const importPath = originalRequest?.importPathOverrides?.[sourceFile]
+            ?? this.getImportPath(sourceFile);
         const context = {
             moduleName,
             importPath,

package/dist/governance/continue-gate-integration.d.ts

@@ -79,6 +79,19 @@ export declare class ContinueGateIntegration {
      *
      * ContinueDecision has: { decision, reasons, metrics, recommendedAction }
      * We map to: { shouldContinue, reason, throttleMs, escalate, reworkRatio }
+     *
+     * Decision semantics:
+     * - 'continue', 'checkpoint': proceed normally
+     * - 'throttle': proceed but caller should slow down (soft signal — not a block).
+     *   The recommended action is "slow down", not "abort". Treating throttle as
+     *   a hard rejection would cause legitimate work to be denied; the caller can
+     *   apply the throttleMs as a backoff hint between subsequent calls.
+     * - 'pause', 'stop': block this task
+     *
+     * NOTE: With totalTokensUsed pinned to 0 in the caller (no real token
+     * telemetry yet), the guidance gate's budget-slope detector cannot fire,
+     * so 'throttle' from this path is rare in practice — it would only fire
+     * if some other slowdown signal (not budget) were configured.
      */
     private mapGuidanceDecision;
     /**

package/dist/governance/continue-gate-integration.js

@@ -142,6 +142,17 @@ export class ContinueGateIntegration {
         if (this.guidanceContinueGate && localDecision.shouldContinue && !localDecision.reason) {
             try {
                 const reworkRatio = this.calculateReworkRatio(history.slice(-10));
+                // ADR-058 NOTE: We do NOT track real per-action token usage here.
+                // Passing a synthetic estimate (e.g. history.length * 500) to the
+                // guidance gate causes the linear-regression slope detector to fire
+                // on the first multi-step interaction (slope = 500 vs 0.02 threshold),
+                // which would block legitimate one-off MCP tool calls.
+                //
+                // Until real token telemetry is wired in, we set totalTokensUsed = 0
+                // and a generous budgetRemaining. This effectively disables the
+                // budget-slope and budget-exhaustion checks (they require non-zero
+                // token data to fire) while keeping the coherence, rework, and
+                // uncertainty checks active — those use real data we DO have.
                 const stepContext = {
                     stepNumber: history.length,
                     totalToolCalls: history.length,
@@ -150,9 +161,9 @@ export class ContinueGateIntegration {
                     uncertaintyScore: reworkRatio,
                     elapsedMs: history.length > 0 ? Date.now() - history[0].timestamp : 0,
                     lastCheckpointStep: 0,
-                    totalTokensUsed: history.length * 500, // Estimate ~500 tokens per action
+                    totalTokensUsed: 0, // No real token telemetry — see comment above
                     budgetRemaining: {
-                        tokens: Math.max(0, (flags.maxConsecutiveRetries * 10 * 500) - (history.length * 500)),
+                        tokens: Number.MAX_SAFE_INTEGER, // Defer budget gating to dedicated cost monitor
                         toolCalls: Math.max(0, (flags.maxConsecutiveRetries * 10) - history.length),
                         timeMs: Math.max(0, flags.idleTimeoutMs - (history.length > 0 ? Date.now() - history[history.length - 1].timestamp : 0)),
                     },
@@ -254,15 +265,27 @@ export class ContinueGateIntegration {
      *
      * ContinueDecision has: { decision, reasons, metrics, recommendedAction }
      * We map to: { shouldContinue, reason, throttleMs, escalate, reworkRatio }
+     *
+     * Decision semantics:
+     * - 'continue', 'checkpoint': proceed normally
+     * - 'throttle': proceed but caller should slow down (soft signal — not a block).
+     *   The recommended action is "slow down", not "abort". Treating throttle as
+     *   a hard rejection would cause legitimate work to be denied; the caller can
+     *   apply the throttleMs as a backoff hint between subsequent calls.
+     * - 'pause', 'stop': block this task
+     *
+     * NOTE: With totalTokensUsed pinned to 0 in the caller (no real token
+     * telemetry yet), the guidance gate's budget-slope detector cannot fire,
+     * so 'throttle' from this path is rare in practice — it would only fire
+     * if some other slowdown signal (not budget) were configured.
      */
     mapGuidanceDecision(decision, agentId) {
         const flags = governanceFlags.getFlags().continueGate;
-        const shouldContinue = decision.decision === 'continue' || decision.decision === 'checkpoint';
+        const isBlocking = decision.decision === 'pause' || decision.decision === 'stop';
+        const shouldContinue = !isBlocking;
         const reason = decision.reasons.length > 0 ? decision.reasons.join('; ') : undefined;
-        // Throttle on 'throttle', 'pause', or 'stop'
-        if (!shouldContinue && flags.throttleOnExceed) {
-            const throttleMs = decision.decision === 'stop' ? 30000 :
-                decision.decision === 'pause' ? 15000 : 5000;
+        if (isBlocking && flags.throttleOnExceed) {
+            const throttleMs = decision.decision === 'stop' ? 30000 : 15000;
             this.throttledAgents.set(agentId, Date.now() + throttleMs);
         }
         return {
@@ -271,7 +294,7 @@ export class ContinueGateIntegration {
             throttleMs: decision.decision === 'throttle' ? 5000 :
                 decision.decision === 'pause' ? 15000 :
                     decision.decision === 'stop' ? 30000 : undefined,
-            escalate: decision.decision === 'stop' || decision.decision === 'pause',
+            escalate: isBlocking,
             reworkRatio: decision.metrics.reworkRatio,
         };
     }