agentic-qe 3.9.16 → 3.9.18

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

@@ -9,6 +9,71 @@ 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';
+/**
+ * Read piped stdin with a short timeout. Claude Code delivers
+ * UserPromptSubmit / PostToolUse / etc. events as JSON on stdin —
+ * `$PROMPT` is NOT exposed as an env var, so reading stdin is the
+ * only reliable way to recover the prompt body for routing.
+ *
+ * Returns '' when stdin is a TTY (interactive run) or no data arrives
+ * before the timeout. Never throws — a hook must never crash the host.
+ */
+async function readStdinJsonEvent(timeoutMs = 500) {
+    if (process.stdin.isTTY)
+        return '';
+    return new Promise((resolve) => {
+        let data = '';
+        const timer = setTimeout(() => {
+            process.stdin.removeAllListeners();
+            process.stdin.pause();
+            resolve(data);
+        }, timeoutMs);
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => {
+            clearTimeout(timer);
+            resolve(data);
+        });
+        process.stdin.on('error', () => {
+            clearTimeout(timer);
+            resolve(data);
+        });
+        process.stdin.resume();
+    });
+}
+/**
+ * Extract a routable task description from a Claude Code hook event JSON
+ * payload. Different hook surfaces use different field names — try the
+ * documented ones in priority order. Exported for unit testing.
+ */
+export function extractPromptFromEvent(raw) {
+    if (!raw.trim())
+        return '';
+    let event;
+    try {
+        event = JSON.parse(raw);
+    }
+    catch {
+        // Not JSON — treat the whole stdin as the prompt body
+        return raw.trim();
+    }
+    const candidates = [
+        event.prompt,
+        event.user_prompt,
+        event.command,
+        event.tool_input?.prompt,
+        event.tool_input?.description,
+        event.toolInput?.prompt,
+        event.toolInput?.description,
+    ];
+    for (const c of candidates) {
+        if (typeof c === 'string' && c.trim())
+            return c;
+    }
+    return '';
+}
 /**
  * Register route subcommand on the hooks command.
  */
@@ -19,15 +84,26 @@ export function registerRoutingHooks(hooks) {
     hooks
         .command('route')
         .description('Route a task to the optimal QE agent')
-        .requiredOption('-t, --task <description>', 'Task description')
+        .option('-t, --task <description>', 'Task description (falls back to stdin event JSON)')
         .option('-d, --domain <domain>', 'Target QE domain hint')
         .option('-c, --capabilities <caps...>', 'Required capabilities')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
         try {
+            // Resolve task: explicit --task wins, otherwise read the Claude Code
+            // hook event from stdin (UserPromptSubmit ships {prompt: "..."} on stdin
+            // and exposes nothing useful in env vars).
+            let task = options.task ?? '';
+            if (!task.trim()) {
+                const stdin = await readStdinJsonEvent();
+                task = extractPromptFromEvent(stdin);
+            }
+            if (!task.trim()) {
+                throw new Error('No task provided. Pass --task <description> or pipe a Claude Code hook event JSON to stdin.');
+            }
             const { reasoningBank } = await getHooksSystem();
             const request = {
-                task: options.task,
+                task,
                 domain: options.domain,
                 capabilities: options.capabilities,
             };
@@ -49,7 +125,7 @@ export function registerRoutingHooks(hooks) {
             }
             else {
                 console.log(chalk.bold('\n🎯 Task Routing Result'));
-                console.log(chalk.dim(`  Task: "${options.task}"`));
+                console.log(chalk.dim(`  Task: "${task}"`));
                 console.log(chalk.bold('\n👤 Recommended Agent:'), chalk.cyan(routing.recommendedAgent));
                 console.log(chalk.dim(`  Confidence: ${(routing.confidence * 100).toFixed(1)}%`));
                 if (routing.alternatives.length > 0) {
@@ -78,7 +154,7 @@ export function registerRoutingHooks(hooks) {
               followed_recommendation, success, quality_score,
               duration_ms, error
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-          `).run(outcomeId, JSON.stringify({ description: options.task, domain: options.domain }), JSON.stringify({
+          `).run(outcomeId, JSON.stringify({ description: task, domain: options.domain }), JSON.stringify({
                     recommended: routing.recommendedAgent,
                     confidence: routing.confidence,
                     alternatives: routing.alternatives,

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/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,
         };
     }

package/dist/init/init-wizard-hooks.js

@@ -131,8 +131,11 @@ export async function configureHooks(projectRoot, config) {
             {
                 hooks: [
                     {
+                        // Claude Code delivers the prompt body on stdin as JSON
+                        // (e.g. {"prompt":"..."}). $PROMPT is NOT exposed as an env
+                        // var, so we let the CLI read stdin directly.
                         type: 'command',
-                        command: 'npx agentic-qe hooks route --task "$PROMPT" --json',
+                        command: 'npx agentic-qe hooks route --json',
                         timeout: 5000,
                         continueOnError: true,
                     },

package/dist/init/phases/07-hooks.js

@@ -489,8 +489,11 @@ if (process.argv.includes('--json')) process.stdout.write(JSON.stringify(result)
                 {
                     hooks: [
                         {
+                            // Claude Code delivers the prompt body on stdin as JSON
+                            // (e.g. {"prompt":"..."}). $PROMPT is NOT exposed as an env
+                            // var, so we let the CLI read stdin directly.
                             type: 'command',
-                            command: 'npx agentic-qe hooks route --task "$PROMPT" --json',
+                            command: 'npx agentic-qe hooks route --json',
                             timeout: 5000,
                             continueOnError: true,
                         },