agentic-qe 3.15.4 → 3.15.6

package/dist/cli/commands/learning.js

@@ -24,6 +24,7 @@ import { backupLearningDatabase, restoreLearningDatabase } from './learning-snap
 import { createSQLitePatternStore } from '../../learning/sqlite-persistence.js';
 import { getActiveEmbeddingSpaceIdentity } from '../../learning/real-embeddings.js';
 import { inspectEmbeddingSpaceRows } from '../../learning/embedding-space.js';
+import { committedPendingIndexPatternId } from '../../learning/pattern-mutation-error.js';
 // Extracted helpers
 import { initializeLearningSystem, printJson, printSuccess, printError, printInfo, displayDashboard, getDbPath, compressFile, decompressFile, verifyDatabaseIntegrity, getSchemaVersion, padRight, EXPORT_FORMAT_VERSION, DOMAIN_MAPPING, PATTERN_TYPE_MAPPING, } from './learning-helpers.js';
 // ============================================================================
@@ -151,11 +152,29 @@ function registerBackfillEmbeddingsCommand(learning) {
             }
             const result = await store.backfillEmbeddings(batchSize);
             const after = store.getGhostPatternCount();
+            // #981 review B2: backfill writes SQLite vectors only. Opening the
+            // reasoning bank reconciles the RVF index with them (ingesting just
+            // the ids it is missing), so backfilled patterns reach vector search
+            // even when patterns.rvf already held other vectors.
+            let rvfIndex = { skipped: 'vector index unavailable' };
+            if (result.processed > 0) {
+                try {
+                    const reasoningBank = await initializeLearningSystem();
+                    const reconciled = reasoningBank.getLastVectorReconcile() ?? reasoningBank.reconcileVectorIndex();
+                    if (reconciled) {
+                        rvfIndex = { ingested: reconciled.ingested, missing: reconciled.missing, capped: reconciled.capped };
+                    }
+                }
+                catch (error) {
+                    rvfIndex = { skipped: error instanceof Error ? error.message : String(error) };
+                }
+            }
             const output = {
                 ...result,
                 batchSize,
                 missingBefore: before.withoutEmbeddings,
                 missingAfter: after.withoutEmbeddings,
+                rvfIndex,
             };
             if (options.json) {
                 printJson(output);
@@ -167,6 +186,9 @@ function registerBackfillEmbeddingsCommand(learning) {
                 console.log(`  Errors: ${result.errors}`);
                 console.log(`  Remaining missing: ${after.withoutEmbeddings}`);
                 console.log(`  Method: ${result.method}`);
+                console.log('ingested' in rvfIndex
+                    ? `  Vector index (RVF): ingested ${rvfIndex.ingested} of ${rvfIndex.missing} missing${rvfIndex.capped ? ' (capped; rerun to continue)' : ''}`
+                    : `  Vector index (RVF): not updated (${rvfIndex.skipped})`);
                 console.log('');
             }
         }
@@ -416,6 +438,7 @@ function registerImportCommand(learning) {
             const reasoningBank = await initializeLearningSystem();
             let imported = 0;
             let skipped = 0;
+            let pendingIndex = 0;
             const errors = [];
             if (!options.dryRun) {
                 for (const pattern of importData.patterns) {
@@ -424,8 +447,17 @@ function registerImportCommand(learning) {
                             patternType: pattern.patternType, name: pattern.name,
                             description: pattern.description, template: pattern.template, context: pattern.context,
                         });
-                        if (result.success)
+                        if (result.success) {
+                            imported++;
+                            // #981 review N2: stored text-only (no embedding runtime) → vector pending.
+                            if (!(result.value.embedding && result.value.embedding.length > 0))
+                                pendingIndex++;
+                        }
+                        // #981: the row committed; only its vector index is pending.
+                        else if (committedPendingIndexPatternId(result.error)) {
                             imported++;
+                            pendingIndex++;
+                        }
                         else {
                             skipped++;
                             errors.push(`${pattern.name}: ${result.error.message}`);
@@ -438,7 +470,7 @@ function registerImportCommand(learning) {
                 }
             }
             if (options.json) {
-                printJson({ dryRun: options.dryRun || false, totalPatterns: importData.patterns.length, imported, skipped, errors });
+                printJson({ dryRun: options.dryRun || false, totalPatterns: importData.patterns.length, imported, skipped, pendingIndex, errors });
             }
             else {
                 console.log(chalk.bold('\n📥 Pattern Import\n'));
@@ -450,6 +482,8 @@ function registerImportCommand(learning) {
                 }
                 else {
                     console.log(chalk.green(`\n  Imported: ${imported}`));
+                    if (pendingIndex > 0)
+                        console.log(chalk.yellow(`  Vector index pending: ${pendingIndex} (run "aqe learning backfill-embeddings" once an embedder is available)`));
                     if (skipped > 0)
                         console.log(chalk.yellow(`  Skipped: ${skipped}`));
                 }
@@ -593,7 +627,8 @@ function registerExtractCommand(learning) {
                                 template: { type: 'code', content: templateContent, variables: [{ name: 'implementation', type: 'code', required: true, description: 'Implementation code for this pattern' }] },
                                 context: { tags: [p.domain, p.patternType, `sources:${p.sourceCount}`, `reward:${p.avgReward.toFixed(2)}`] },
                             });
-                            if (result.success)
+                            // #981: a committed row with a pending vector index is stored.
+                            if (result.success || committedPendingIndexPatternId(result.error))
                                 stored++;
                             else
                                 errors.push(`${p.name}: ${result.error.message}`);
@@ -962,7 +997,8 @@ function registerImportMergeCommand(learning) {
                     }
                     try {
                         const result = await reasoningBank.storePattern({ patternType: pattern.patternType, name: pattern.name, description: pattern.description, template: pattern.template, context: pattern.context });
-                        if (result.success) {
+                        // #981: a committed row with a pending vector index is imported.
+                        if (result.success || committedPendingIndexPatternId(result.error)) {
                             if (isDuplicate)
                                 updated++;
                             else
@@ -1148,14 +1184,18 @@ function registerDreamCommand(learning) {
                     template: { type: 'workflow', content: insight.suggestedAction || insight.description, variables: [] },
                     context: { tags: ['dream-generated', insight.type, ...insight.sourceConcepts.slice(0, 3)], complexity: 'medium' },
                 });
+                // #981: a committed row with a pending vector index is a created pattern.
+                const createdPatternId = patternResult.success
+                    ? patternResult.value.id
+                    : committedPendingIndexPatternId(patternResult.error);
                 if (options.json) {
-                    printJson({ insightId: insight.id, applied: result.success, patternId: patternResult.success ? patternResult.value.id : null, error: result.error || (patternResult.success ? null : patternResult.error?.message) });
+                    printJson({ insightId: insight.id, applied: result.success, patternId: createdPatternId, error: result.error || (createdPatternId ? null : patternResult.success ? null : patternResult.error?.message) });
                 }
                 else {
                     if (result.success) {
                         printSuccess(`Applied insight ${insight.id.slice(0, 8)}`);
-                        if (patternResult.success)
-                            printSuccess(`Created pattern ${patternResult.value.id} in ReasoningBank`);
+                        if (createdPatternId)
+                            printSuccess(`Created pattern ${createdPatternId} in ReasoningBank`);
                     }
                     else
                         printError(`Failed to apply insight: ${result.error}`);

package/dist/cli/commands/quality.d.ts

@@ -11,12 +11,23 @@ import { type QualityGateResult } from '../utils/ci-output.js';
 import { type QualityEvidenceValues } from '../../domains/quality-assessment/quality-evidence.js';
 export declare function loadQualityEvidence(memory: MemoryBackend): Promise<QualityEvidenceValues>;
 export declare function evaluateMeasuredQualityEvidence(measured: QualityEvidenceValues): QualityGateResult;
+/**
+ * #996: when measured evidence is missing, stale or malformed the gate cannot
+ * be evaluated. Report it as a structured, non-passing result with the same
+ * `status: 'insufficient-evidence'` and `unmeasured` list that MCP
+ * `quality_assess({ runGate: true })` returns alongside its error. Errors that
+ * are not about evidence (e.g. the store itself failing) are rethrown.
+ */
+export declare function describeUnavailableQualityEvidence(memory: MemoryBackend, error: unknown): Promise<QualityGateResult>;
 /**
  * Published quality command exit contract:
  * 0 = passed with more than five percentage points of headroom
  * 1 = one or more measured checks failed
  * 2 = passed, but at least one measured check has less than five points of headroom
+ * 3 = insufficient evidence (#996): a metric is absent, stale or malformed, so
+ *     the gate was not evaluated (UNMEASURED — neither a pass nor a measured failure)
  */
-export declare function getMeasuredQualityExitCode(result: QualityGateResult): 0 | 1 | 2;
+export declare const INSUFFICIENT_EVIDENCE_EXIT_CODE = 3;
+export declare function getMeasuredQualityExitCode(result: QualityGateResult): 0 | 1 | 2 | 3;
 export declare function createQualityCommand(context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>): Command;
 //# sourceMappingURL=quality.d.ts.map

package/dist/cli/commands/quality.js

@@ -7,7 +7,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { writeOutput, toJSON, qualityGateToMarkdown } from '../utils/ci-output.js';
-import { evaluateQualityEvidence, loadQualityEvidence as loadCanonicalQualityEvidence, } from '../../domains/quality-assessment/quality-evidence.js';
+import { InsufficientQualityEvidenceError, evaluateQualityEvidence, inspectQualityEvidence, loadQualityEvidence as loadCanonicalQualityEvidence, } from '../../domains/quality-assessment/quality-evidence.js';
 export async function loadQualityEvidence(memory) {
     return loadCanonicalQualityEvidence(memory);
 }
@@ -20,13 +20,48 @@ export function evaluateMeasuredQualityEvidence(measured) {
         recommendations: evaluation.recommendations,
     };
 }
+/**
+ * #996: when measured evidence is missing, stale or malformed the gate cannot
+ * be evaluated. Report it as a structured, non-passing result with the same
+ * `status: 'insufficient-evidence'` and `unmeasured` list that MCP
+ * `quality_assess({ runGate: true })` returns alongside its error. Errors that
+ * are not about evidence (e.g. the store itself failing) are rethrown.
+ */
+export async function describeUnavailableQualityEvidence(memory, error) {
+    const insufficient = error instanceof InsufficientQualityEvidenceError
+        ? error
+        : await inspectQualityEvidence(memory).then(({ problems }) => problems.length > 0 ? new InsufficientQualityEvidenceError(problems) : undefined);
+    if (!insufficient)
+        throw error;
+    const reason = error instanceof Error ? error.message : String(error);
+    const details = insufficient.toDetails();
+    return {
+        passed: false,
+        score: 'N/A',
+        checks: [],
+        status: details.status,
+        evidenceStatus: details.evidenceStatus,
+        unmeasured: details.unmeasured,
+        gateEvaluated: false,
+        error: reason,
+        recommendations: [
+            `Quality gate not evaluated: ${reason}`,
+            ...details.recommendations,
+        ],
+    };
+}
 /**
  * Published quality command exit contract:
  * 0 = passed with more than five percentage points of headroom
  * 1 = one or more measured checks failed
  * 2 = passed, but at least one measured check has less than five points of headroom
+ * 3 = insufficient evidence (#996): a metric is absent, stale or malformed, so
+ *     the gate was not evaluated (UNMEASURED — neither a pass nor a measured failure)
  */
+export const INSUFFICIENT_EVIDENCE_EXIT_CODE = 3;
 export function getMeasuredQualityExitCode(result) {
+    if (result.evidenceStatus === 'insufficient-evidence')
+        return INSUFFICIENT_EVIDENCE_EXIT_CODE;
     if (!result.passed)
         return 1;
     return result.checks.some(check => (check.direction !== 'max'
@@ -53,14 +88,27 @@ export function createQualityCommand(context, cleanupAndExit, ensureInitialized)
                 if (format === 'text') {
                     console.log(chalk.blue(`\n Running quality gate evaluation...\n`));
                 }
-                const measured = await loadQualityEvidence(context.kernel.memory);
-                const gateResult = evaluateMeasuredQualityEvidence(measured);
+                const memory = context.kernel.memory;
+                let gateResult;
+                try {
+                    gateResult = evaluateMeasuredQualityEvidence(await loadQualityEvidence(memory));
+                }
+                catch (error) {
+                    gateResult = await describeUnavailableQualityEvidence(memory, error);
+                }
                 if (format === 'json') {
                     writeOutput(toJSON(gateResult), options.output);
                 }
                 else if (format === 'markdown') {
                     writeOutput(qualityGateToMarkdown(gateResult), options.output);
                 }
+                else if (gateResult.evidenceStatus === 'insufficient-evidence') {
+                    console.log(`  Quality Gate: ${chalk.yellow('⚠ INSUFFICIENT EVIDENCE (not evaluated)')}`);
+                    if (gateResult.unmeasured?.length) {
+                        console.log(`  Unmeasured: ${gateResult.unmeasured.join(', ')}`);
+                    }
+                    console.log(chalk.gray(`  ${gateResult.error ?? ''}\n`));
+                }
                 else {
                     const statusIcon = gateResult.passed ? chalk.green('✓ PASSED') : chalk.red('✗ FAILED');
                     console.log(`  Quality Gate: ${statusIcon}`);

package/dist/cli/commands/test.js

@@ -7,7 +7,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { filterTestFilesForFramework, walkSourceFiles } from '../utils/file-discovery.js';
 import { writeOutput, toJSON, toJUnit, testRunToMarkdown } from '../utils/ci-output.js';
-import { writeQualityEvidence } from '../../domains/quality-assessment/quality-evidence.js';
+import { writeTestRunEvidence } from '../../domains/quality-assessment/quality-evidence.js';
 import { validateBehaviorExamples } from '../../domains/test-generation/services/behavior-example-validation.js';
 import { findProjectRoot } from '../../kernel/project-root.js';
 import { writeGeneratedTestFile } from '../utils/generated-test-writer.js';
@@ -192,12 +192,11 @@ export function createTestCommand(context, cleanupAndExit, ensureInitialized) {
                         duration: run.duration,
                         measuredAt: new Date().toISOString(),
                     }, { namespace: 'test-execution', persist: true });
-                    await writeQualityEvidence(context.kernel.memory, {
-                        testsPassing: total > 0 ? (run.passed / total) * 100 : 0,
-                    }, {
-                        measuredAt: new Date().toISOString(),
-                        source: 'aqe test execute',
-                    });
+                    // #1027 NB1: the shared run-scoped writer (same as test_execute_parallel),
+                    // stamped with this run's id so it pairs with the run's own coverage.
+                    await writeTestRunEvidence(context.kernel.memory, {
+                        runId: run.runId, passed: run.passed, failed: run.failed, skipped: run.skipped,
+                    }, { source: 'aqe test execute' });
                     if (format === 'json') {
                         writeOutput(toJSON(run), options.output);
                     }

package/dist/cli/commands/workflow.js

@@ -227,13 +227,17 @@ export function createWorkflowCommand(context, cleanupAndExit, ensureInitialized
                     console.log(chalk.gray('  No scheduled workflows\n'));
                 }
                 else {
+                    // #991: entries loaded from a hand-edited or legacy file may lack
+                    // fields; show "(missing)" rather than "undefined".
+                    const show = (value) => value === undefined || value === null || value === '' ? '(missing)' : String(value);
                     for (const sched of scheduled) {
                         const statusIcon = sched.enabled ? chalk.green('*') : chalk.gray('o');
-                        console.log(`  ${statusIcon} ${chalk.white(sched.workflowId)}`);
-                        console.log(chalk.gray(`     ID: ${sched.id}`));
-                        console.log(chalk.gray(`     Schedule: ${sched.schedule} (${sched.scheduleDescription})`));
-                        console.log(chalk.gray(`     File: ${sched.pipelinePath}`));
-                        console.log(chalk.gray(`     Next run: ${sched.nextRun}`));
+                        console.log(`  ${statusIcon} ${chalk.white(show(sched.workflowId))}`);
+                        console.log(chalk.gray(`     ID: ${show(sched.id)}`));
+                        const description = sched.scheduleDescription ? ` (${sched.scheduleDescription})` : '';
+                        console.log(chalk.gray(`     Schedule: ${show(sched.schedule)}${description}`));
+                        console.log(chalk.gray(`     File: ${show(sched.pipelinePath)}`));
+                        console.log(chalk.gray(`     Next run: ${show(sched.nextRun)}`));
                         if (sched.lastRun) {
                             console.log(chalk.gray(`     Last run: ${sched.lastRun}`));
                         }

package/dist/cli/handlers/init-guard.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `aqe init` guard for shared directories (#1006, review of #1026 N3).
+ *
+ * Initializing in the OS temp dir or a system dir wrote `<tmp>/.agentic-qe`
+ * and `.mcp.json` there, but every later command resolves such a dir to a
+ * private scratch root, so the initialized store was never used. Refusing
+ * with a clear next step is less surprising than initializing a hidden root.
+ *
+ * @module cli/handlers/init-guard
+ */
+/** Error message when `cwd` must not be initialized, otherwise null. */
+export declare function sharedDirInitError(cwd: string, env?: NodeJS.ProcessEnv): string | null;
+//# sourceMappingURL=init-guard.d.ts.map

package/dist/cli/handlers/init-guard.js

@@ -0,0 +1,23 @@
+/**
+ * `aqe init` guard for shared directories (#1006, review of #1026 N3).
+ *
+ * Initializing in the OS temp dir or a system dir wrote `<tmp>/.agentic-qe`
+ * and `.mcp.json` there, but every later command resolves such a dir to a
+ * private scratch root, so the initialized store was never used. Refusing
+ * with a clear next step is less surprising than initializing a hidden root.
+ *
+ * @module cli/handlers/init-guard
+ */
+import { isSharedSystemDir } from '../../kernel/shared-dirs.js';
+/** Error message when `cwd` must not be initialized, otherwise null. */
+export function sharedDirInitError(cwd, env = process.env) {
+    if (env.AQE_PROJECT_ROOT)
+        return null;
+    if (!isSharedSystemDir(cwd))
+        return null;
+    return (`Refusing to initialize in "${cwd}": it is a shared temp/system directory, ` +
+        'so a store here would be shared by every unrelated project below it and ' +
+        'later commands would not use it. Create a project directory first ' +
+        '(mkdir my-project && cd my-project) or set AQE_PROJECT_ROOT to choose a root.');
+}
+//# sourceMappingURL=init-guard.js.map

package/dist/cli/handlers/init-handler.d.ts

@@ -80,6 +80,9 @@ export interface InitJsonOutput {
                 error?: string;
             };
         };
+        /** #1017: pre-3.15.6 test-named skill files removed / kept by init. */
+        retiredAssetsRemoved?: string[];
+        retiredAssetsKept?: string[];
     };
     totalDurationMs: number;
     timestamp: string;

package/dist/cli/handlers/init-handler.js

@@ -9,6 +9,7 @@ import { createRequire } from 'node:module';
 import { ALL_DOMAINS } from '../../shared/types/index.js';
 import { toErrorMessage } from '../../shared/error-utils.js';
 import { resolveInitFlags } from './init-flags.js';
+import { sharedDirInitError } from './init-guard.js';
 // ============================================================================
 // Init Handler
 // ============================================================================
@@ -88,6 +89,14 @@ export class InitHandler {
             });
         }
         try {
+            // #1006 (review of #1026 N3): never initialize a store in a shared
+            // temp/system dir; later commands would resolve elsewhere and ignore it.
+            const sharedDirError = sharedDirInitError(process.cwd());
+            if (sharedDirError) {
+                console.error(chalk.red(`\n  ${sharedDirError}\n`));
+                await this.cleanupAndExit(1);
+                return;
+            }
             // Expand --with-all-platforms into individual flags
             if (options.withAllPlatforms) {
                 options.withCopilot = true;

package/dist/cli/handlers/interfaces.js

@@ -5,6 +5,7 @@
  * Part of the CLI modularization refactoring.
  */
 import chalk from 'chalk';
+import { isAqeManagedDir } from '../../shared/aqe-managed-dirs.js';
 // ============================================================================
 // Helper Functions for Handlers
 // ============================================================================
@@ -66,7 +67,7 @@ export function getColorForPercent(percent) {
 export async function walkDirectory(dir, options = {}) {
     const fs = await import('fs');
     const path = await import('path');
-    const { extensions = ['.ts'], exclude = ['node_modules', 'dist'], maxDepth = 4, includeTests = false, } = options;
+    const { extensions = ['.ts'], exclude = ['node_modules', 'dist', '.git'], maxDepth = 4, includeTests = false, } = options;
     const walkDir = (currentDir, depth) => {
         if (depth > maxDepth)
             return [];
@@ -81,6 +82,9 @@ export async function walkDirectory(dir, options = {}) {
         for (const item of items) {
             if (exclude.includes(item))
                 continue;
+            // #999: AQE state/assets (.agentic-qe anywhere; .claude at the root or next to .agentic-qe)
+            if (isAqeManagedDir(currentDir, item, depth === 0))
+                continue;
             if (!includeTests && (item === 'tests' || item.includes('.test.') || item.includes('.spec.')))
                 continue;
             const fullPath = path.join(currentDir, item);

package/dist/cli/scheduler/persistent-scheduler.d.ts

@@ -123,9 +123,11 @@ export declare class PersistentScheduler {
         due: number;
     }>;
     /**
-     * Load schedules without acquiring lock (for use within locked context)
+     * Load schedules for a locked read-modify-write. A genuinely unparseable
+     * file is backed up (not removed) first, so the write that follows cannot
+     * silently replace it with fewer schedules.
      */
-    private loadSchedulesUnsafe;
+    private loadForWrite;
     /**
      * Parse schedules file content with validation
      * Security: Checks file size before parsing to prevent DoS
@@ -139,6 +141,8 @@ export declare class PersistentScheduler {
      * Handle corrupt schedules file by backing up and creating new
      */
     private handleCorruptFile;
+    /** Copy an unparseable schedules file to `.corrupt.<ts>` (left in place). */
+    private backupCorruptFile;
     /**
      * Execute a function with file locking for safe concurrent access
      */