agentic-qe 3.15.5 → 3.15.7

package/dist/cli/commands/coverage.js

@@ -6,54 +6,12 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { runCoverageAnalysisWizard } from '../wizards/coverage-wizard.js';
-import { walkSourceFiles } from '../utils/file-discovery.js';
 import { writeOutput, toJSON, coverageToMarkdown } from '../utils/ci-output.js';
 import * as path from 'path';
-import { buildCoverageData, summarizeCoverage } from '../utils/coverage-data.js';
-import { describeNoData, isUnmeasured, resolveExistingCoverage, reconcileRecommendations, thresholdVerdict, } from '../../coordination/handlers/coverage-target.js';
-/** Which optional metrics an instrumented report actually carries. */
-function metricsCollected(data) {
-    if (!data.instrumented)
-        return { branch: true, function: true }; // labelled heuristic estimate
-    return {
-        branch: data.files.some(f => f.branches.total > 0),
-        function: data.files.some(f => f.functions.total > 0),
-    };
-}
-/** `aqe coverage` exit code when the target has no coverage measurement (#995). */
-export const EXIT_UNMEASURED = 3;
-/**
- * Resolve the coverage data for a CLI target (#995).
- *
- * Uses the SAME resolution and verdict as the MCP `coverage_analyze_sublinear`
- * handler (`resolveExistingCoverage`), so CLI and MCP cannot disagree about
- * what a report says for a target:
- *   - a coverage report file (lcov.info, coverage-final.json, ...) is parsed
- *     directly;
- *   - a directory or source file is scoped against the instrumented report of
- *     its PROJECT ROOT (nearest package.json/.git above it), not the cwd;
- *   - with no report at the project root, the CLI falls back to its labelled
- *     heuristic estimate (the CLI never runs the test suite).
- */
-export async function resolveCliCoverageData(targetPath) {
-    const existing = await resolveExistingCoverage(targetPath);
-    if (existing.status === 'target-missing') {
-        return { kind: 'no-data', reason: 'target-missing', message: describeNoData('target-missing', targetPath, null) };
-    }
-    if (existing.status === 'evaluated') {
-        const { evaluation, projectRoot } = existing;
-        if (evaluation.status === 'measured') {
-            const files = evaluation.files;
-            return { kind: 'data', data: { files, summary: summarizeCoverage(files), instrumented: true } };
-        }
-        return { kind: 'no-data', reason: evaluation.reason, message: describeNoData(evaluation.reason, targetPath, projectRoot) };
-    }
-    const sourceFiles = walkSourceFiles(existing.target, { includeTests: false });
-    if (sourceFiles.length === 0)
-        return { kind: 'no-sources' };
-    console.log(chalk.gray(`  Analyzing ${sourceFiles.length} files...\n`));
-    return { kind: 'data', data: buildCoverageData(sourceFiles, existing.projectRoot) };
-}
+import { EXIT_UNMEASURED, coverageExitCode, coverageJson, evaluateCliCoverage, } from '../utils/coverage-verdict.js';
+// #1012 / #1010: resolution and verdict are shared with `aqe ci` (and built on
+// the same functions as MCP); re-exported here for existing importers.
+export { EXIT_UNMEASURED, resolveCliCoverageData } from '../utils/coverage-verdict.js';
 function getColorForPercent(percent) {
     if (percent >= 80)
         return chalk.green;
@@ -87,7 +45,13 @@ Exit codes:
   1  coverage below the threshold, or an error (missing target, unreadable report)
   2  coverage within 5% above the threshold
   ${EXIT_UNMEASURED}  UNMEASURED: no coverage measurement exists for the target
-     (not in the report, the runner ran 0 tests, or only test files were reported)`)
+     (not in the report, the runner ran 0 tests, or only test files were reported),
+     or NO coverage report exists, so only a labelled static estimate was shown
+     (-F json: measured:false, estimated:true; no threshold verdict)
+
+In \`aqe ci\`, an UNMEASURED coverage phase is a warning (phase exit code 3); it
+does not fail the pipeline by itself. An enforced quality gate fails on
+missing coverage evidence.`)
         .action(async (target, options) => {
         let analyzeTarget = target;
         let includeRisk = options.risk;
@@ -141,90 +105,62 @@ Exit codes:
                 const targetPath = path.resolve(analyzeTarget);
                 // Fix #280: shared file discovery supporting all languages.
                 // #995: coverage files as targets; reports resolved from the project root.
-                const resolved = await resolveCliCoverageData(targetPath);
-                if (resolved.kind === 'no-sources') {
+                // #1012: one shared verdict (measured / unmeasured / labelled estimate).
+                const outcome = await evaluateCliCoverage(coverageAPI, targetPath, threshold);
+                const format = options.format;
+                if (outcome.kind === 'no-sources') {
                     console.log(chalk.yellow('No source files found'));
                     return;
                 }
-                if (resolved.kind === 'no-data') {
-                    // Errors (missing target, unreadable report) exit 1. Everything else
-                    // means "no measurement exists" — distinct exit code, never "0%".
-                    const isError = resolved.reason === 'target-missing' || resolved.reason === 'unreadable-report';
-                    if (options.format === 'json') {
+                if (outcome.kind === 'error' || outcome.kind === 'unmeasured' || outcome.kind === 'analysis-failed') {
+                    // Errors (missing target, unreadable report) exit 1. "No measurement
+                    // exists" has its own exit code — never "0%".
+                    if (format === 'json') {
                         // Same shape as a normal result, with nulls (#995 review N4).
-                        emit(toJSON({
-                            summary: { line: null, branch: null, function: null, statement: null },
-                            meetsThreshold: null,
-                            threshold,
-                            measured: false,
-                            unmeasured: isUnmeasured(resolved.reason),
-                            reason: resolved.reason,
-                            target: targetPath,
-                            warning: resolved.message,
-                        }));
+                        emit(toJSON(coverageJson(outcome, threshold, targetPath)));
                     }
                     else {
-                        console.log((isError ? chalk.red : chalk.yellow)(`  ${resolved.message}\n`));
+                        console.log((outcome.kind === 'unmeasured' ? chalk.yellow : chalk.red)(`  ${outcome.message}\n`));
                     }
-                    await cleanupAndExit(isError ? 1 : EXIT_UNMEASURED);
+                    await cleanupAndExit(coverageExitCode(outcome, threshold));
                     return;
                 }
-                const coverageData = resolved.data;
-                if (coverageData.instrumented) {
+                const coverageData = outcome.data;
+                const isEstimate = outcome.kind === 'estimate';
+                if (!isEstimate) {
                     console.log(chalk.green('  Using instrumented coverage data (V8/istanbul)\n'));
                     if (coverageData.unmeasuredFiles?.length) {
                         console.log(chalk.yellow(`  ${coverageData.unmeasuredFiles.length} file(s) not in the coverage report — UNMEASURED, excluded from the figures\n`));
                     }
                 }
                 else {
-                    console.log(chalk.yellow('  No instrumented coverage found — using heuristic estimation'));
+                    console.log(chalk.yellow('  No coverage report found — showing a heuristic STATIC ESTIMATE (UNMEASURED)'));
                     console.log(chalk.gray('  Run tests with coverage first: npm test -- --coverage\n'));
                 }
-                // #1008: a heuristic estimate is shown, never persisted as coverage evidence.
-                const result = await coverageAPI.analyze({
-                    coverageData,
-                    threshold,
-                    includeFileDetails: true,
-                    measured: coverageData.instrumented,
-                });
-                const format = options.format;
-                let coverageResult;
-                let overallCoverage = 0;
-                if (result.success && result.value) {
-                    const report = result.value;
-                    // #995 review NB5: a metric the report never collected is null — not
-                    // 0 — and is left out of the threshold verdict (same rule as MCP).
-                    const collected = metricsCollected(coverageData);
-                    const verdict = thresholdVerdict(report.summary, threshold, collected);
-                    const summary = {
-                        ...report.summary,
-                        branch: collected.branch ? report.summary.branch : null,
-                        function: collected.function ? report.summary.function : null,
-                    };
-                    // NB-A: the shortfall advice comes from the same verdict (shared with MCP).
-                    const recommendations = reconcileRecommendations(report.recommendations, verdict, threshold, collected);
-                    overallCoverage = verdict.overall;
-                    // For non-text formats, collect all data and output at end
-                    coverageResult = {
-                        summary: summary,
-                        meetsThreshold: verdict.meetsThreshold,
-                        threshold,
-                        recommendations,
-                    };
-                    if (format === 'text') {
-                        const fmt = (v) => v === null ? 'n/a (not collected)' : v.toFixed(1) + '%';
-                        const color = (v) => v === null ? chalk.gray : getColorForPercent(v);
-                        console.log(chalk.cyan('  Coverage Summary:'));
-                        console.log(`    Lines:      ${color(summary.line)(fmt(summary.line))}`);
-                        console.log(`    Branches:   ${color(summary.branch)(fmt(summary.branch))}`);
-                        console.log(`    Functions:  ${color(summary.function)(fmt(summary.function))}`);
-                        console.log(`    Statements: ${color(summary.statement)(fmt(summary.statement))}`);
-                        console.log(`\n    Threshold: ${verdict.meetsThreshold ? chalk.green(`Met (${threshold}%)`) : chalk.red(`Not met (${threshold}%)`)}`);
-                        if (recommendations.length > 0) {
-                            console.log(chalk.cyan('\n  Recommendations:'));
-                            for (const rec of recommendations) {
-                                console.log(chalk.gray(`    - ${rec}`));
-                            }
+                // #1012: the JSON carries its provenance (measured / estimated /
+                // coverageMethod) exactly as MCP does; an estimate has no verdict.
+                const coverageResult = coverageJson(outcome, threshold, targetPath);
+                const summary = outcome.summary;
+                if (format === 'text') {
+                    const fmt = (v) => v === null ? 'n/a (not collected)' : (isEstimate ? '~' : '') + v.toFixed(1) + '%';
+                    const color = (v) => v === null || isEstimate ? chalk.gray : getColorForPercent(v);
+                    console.log(chalk.cyan(isEstimate ? '  Coverage Summary (STATIC ESTIMATE — not measured):' : '  Coverage Summary:'));
+                    console.log(`    Lines:      ${color(summary.line)(fmt(summary.line))}`);
+                    console.log(`    Branches:   ${color(summary.branch)(fmt(summary.branch))}`);
+                    console.log(`    Functions:  ${color(summary.function)(fmt(summary.function))}`);
+                    console.log(`    Statements: ${color(summary.statement)(fmt(summary.statement))}`);
+                    if (outcome.kind === 'measured') {
+                        console.log(`\n    Threshold: ${outcome.verdict.meetsThreshold ? chalk.green(`Met (${threshold}%)`) : chalk.red(`Not met (${threshold}%)`)}`);
+                    }
+                    else {
+                        console.log(`\n    Threshold: ${chalk.yellow(`not evaluated (${threshold}%) — UNMEASURED, estimate only`)}`);
+                        console.log(chalk.gray(`    ${outcome.message}`));
+                    }
+                    const recommendations = outcome.kind === 'measured' ? outcome.recommendations : [];
+                    if (recommendations.length > 0) {
+                        console.log(chalk.cyan('\n  Recommendations:'));
+                        for (const rec of recommendations) {
+                            console.log(chalk.gray(`    - ${rec}`));
                         }
                     }
                 }
@@ -235,16 +171,17 @@ Exit codes:
                         coverageData,
                         minCoverage: threshold,
                         prioritize: includeRisk ? 'risk' : 'size',
+                        // #1014: gaps in an estimate are shown, never learned or published.
+                        measured: !isEstimate,
                     });
                     if (gapResult.success && gapResult.value) {
                         const gaps = gapResult.value;
-                        if (coverageResult)
-                            coverageResult.gaps = gaps.gaps.map(g => ({
-                                file: g.file.replace(process.cwd() + '/', ''),
-                                lines: g.lines,
-                                riskScore: g.riskScore,
-                                severity: g.severity,
-                            }));
+                        coverageResult.gaps = gaps.gaps.map(g => ({
+                            file: g.file.replace(process.cwd() + '/', ''),
+                            lines: g.lines,
+                            riskScore: g.riskScore,
+                            severity: g.severity,
+                        }));
                         console.log(chalk.gray(`    Total uncovered lines: ${gaps.totalUncoveredLines}`));
                         console.log(chalk.gray(`    Estimated effort: ${gaps.estimatedEffort} hours\n`));
                         for (const gap of gaps.gaps.slice(0, 8)) {
@@ -307,26 +244,18 @@ Exit codes:
                     }
                 }
                 // Non-text format output (collected all data)
-                if (coverageResult && format === 'json') {
+                if (format === 'json') {
                     emit(toJSON(coverageResult));
                 }
-                else if (coverageResult && format === 'markdown') {
+                else if (format === 'markdown') {
                     emit(coverageToMarkdown(coverageResult));
                 }
                 else if (format === 'text') {
                     console.log(chalk.green('\n Coverage analysis complete\n'));
                 }
-                // Exit codes: 1 = below threshold, 2 = within 5% of threshold, 0 = above threshold
-                if (coverageResult && !coverageResult.meetsThreshold) {
-                    await cleanupAndExit(1);
-                }
-                if (coverageResult) {
-                    const avg = overallCoverage;
-                    if (avg < threshold + 5 && avg >= threshold) {
-                        await cleanupAndExit(2);
-                    }
-                }
-                await cleanupAndExit(0);
+                // Exit codes: 1 = below threshold, 2 = within 5% of threshold,
+                // 0 = above threshold, 3 = UNMEASURED (estimate only) — shared with `aqe ci`.
+                await cleanupAndExit(coverageExitCode(outcome, threshold));
             }
             catch (error) {
                 console.error(chalk.red('\nFailed:'), error);

package/dist/cli/commands/daemon.js

@@ -70,7 +70,13 @@ Examples:
             // Fallback for environments where kernel isn't available
             const store = new Map();
             memory = {
-                async get(key) { return store.get(key); },
+                // Like InMemoryWorkerMemory (#1028 N4): this process-local store holds
+                // only daemon keys, so a read of another namespace finds nothing.
+                async get(key, options) {
+                    if (options?.namespace)
+                        return undefined;
+                    return store.get(key);
+                },
                 async set(key, value) { store.set(key, value); },
                 async search(pattern) {
                     const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');

package/dist/cli/commands/hooks-handlers/stats-hooks.d.ts

@@ -5,6 +5,21 @@
  * Handles pattern management and statistics subcommands.
  */
 import { Command } from 'commander';
+/**
+ * How a learned pattern reached vector search, by cause (#981, review N1).
+ * - `indexed`: stored with its vector in the active index.
+ * - `sqlite`: an embedder produced the vector and SQLite holds it (vector
+ *   search uses it now); only the ANN index (patterns.rvf) was not open in
+ *   this process. It is ingested automatically the next time the index opens.
+ * - `pending`: no vector (no embedding runtime); text search only until an
+ *   embedder is configured and `aqe learning backfill-embeddings` runs.
+ */
+export declare function describeVectorIndexState(pattern: {
+    embedding?: ArrayLike<number>;
+}, indexUnavailableCause?: string): {
+    vectorIndex: 'indexed' | 'sqlite' | 'pending';
+    notice?: string;
+};
 /**
  * Register stats, list, emit, learn, and search subcommands on the hooks command.
  */

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

@@ -7,7 +7,37 @@
 import chalk from 'chalk';
 import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
+import { committedPendingIndexPatternId } from '../../../learning/pattern-mutation-error.js';
 import { getHooksSystem, printJson, printSuccess, printError, } from './hooks-shared.js';
+/**
+ * How a learned pattern reached vector search, by cause (#981, review N1).
+ * - `indexed`: stored with its vector in the active index.
+ * - `sqlite`: an embedder produced the vector and SQLite holds it (vector
+ *   search uses it now); only the ANN index (patterns.rvf) was not open in
+ *   this process. It is ingested automatically the next time the index opens.
+ * - `pending`: no vector (no embedding runtime); text search only until an
+ *   embedder is configured and `aqe learning backfill-embeddings` runs.
+ */
+export function describeVectorIndexState(pattern, indexUnavailableCause) {
+    const hasVector = Boolean(pattern.embedding && pattern.embedding.length > 0);
+    if (!hasVector) {
+        return {
+            vectorIndex: 'pending',
+            notice: 'Pattern stored in SQLite without a vector (no embedding runtime is available). ' +
+                'Text search finds it now. Set AQE_EMBEDDER_ENDPOINT or install @huggingface/transformers, then run ' +
+                '`aqe learning backfill-embeddings` to enable semantic search for it.',
+        };
+    }
+    if (indexUnavailableCause) {
+        return {
+            vectorIndex: 'sqlite',
+            notice: 'Pattern stored; its vector is stored in SQLite and vector search can use it now. ' +
+                `The ANN index (patterns.rvf) was not open in this process (${indexUnavailableCause}); ` +
+                'the vector is added to it automatically the next time the index opens.',
+        };
+    }
+    return { vectorIndex: 'indexed' };
+}
 /**
  * Register stats, list, emit, learn, and search subcommands on the hooks command.
  */
@@ -161,10 +191,27 @@ export function registerStatsHooks(hooks) {
                     tags: options.tags || [],
                 },
             });
+            // #981: COMMITTED_PENDING_INDEX means the authoritative SQLite row was
+            // written and only the derived vector index is unavailable (e.g. no
+            // embedding runtime). That is a stored pattern, not a failure.
+            let pattern = result.success ? result.value : null;
+            let indexCause;
             if (!result.success) {
-                throw new Error(result.error.message);
+                const committedId = committedPendingIndexPatternId(result.error);
+                if (!committedId) {
+                    throw new Error(result.error.message);
+                }
+                pattern = await reasoningBank.getPattern(committedId);
+                if (!pattern) {
+                    throw new Error(result.error.message);
+                }
+                const cause = result.error.cause;
+                indexCause = cause instanceof Error ? cause.message : 'the vector index is unavailable';
             }
-            const pattern = result.value;
+            if (!pattern) {
+                throw new Error('learn failed: no pattern returned');
+            }
+            const { vectorIndex, notice: pendingWarning } = describeVectorIndexState(pattern, indexCause);
             if (options.json) {
                 printJson({
                     success: true,
@@ -174,6 +221,8 @@ export function registerStatsHooks(hooks) {
                         type: pattern.patternType,
                         domain: pattern.qeDomain,
                     },
+                    vectorIndex,
+                    ...(pendingWarning ? { warning: pendingWarning } : {}),
                 });
             }
             else {
@@ -181,6 +230,9 @@ export function registerStatsHooks(hooks) {
                 console.log(chalk.dim(`  ID: ${pattern.id}`));
                 console.log(chalk.dim(`  Domain: ${pattern.qeDomain}`));
                 console.log(chalk.dim(`  Tier: ${pattern.tier}`));
+                if (pendingWarning) {
+                    console.log(chalk.yellow(`  ${vectorIndex === 'pending' ? 'Vector index pending' : 'Vector index'}: ${pendingWarning}`));
+                }
             }
         }
         catch (error) {

package/dist/cli/commands/learning.js

@@ -12,6 +12,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { findProjectRoot } from '../../kernel/unified-memory.js';
 import { existsSync, writeFileSync, readFileSync, copyFileSync, renameSync } from 'node:fs';
 import { safeJsonParse } from '../../shared/safe-json.js';
@@ -24,6 +25,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 +153,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 +187,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 +439,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 +448,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 +471,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 +483,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 +628,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}`);
@@ -702,8 +738,8 @@ function registerBackupCommand(learning) {
             const dbPath = getDbPath();
             if (!existsSync(dbPath))
                 throw new Error(`No learning database found at: ${dbPath}`);
-            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-            const defaultOutput = path.join(process.cwd(), 'backups', `learning-${timestamp}.db`);
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 23);
+            const defaultOutput = path.join(process.cwd(), 'backups', `learning-${timestamp}-${randomUUID()}.db`);
             const outputPath = options.output ? path.resolve(options.output) : defaultOutput;
             const snapshot = await backupLearningDatabase(dbPath, outputPath, options);
             const { backupPath: finalPath, sourceSizeKB, backupSizeKB: finalSizeKB, schemaVersion } = snapshot;
@@ -962,7 +998,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 +1185,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/security.d.ts

@@ -5,5 +5,21 @@
  */
 import { Command } from 'commander';
 import type { CLIContext } from '../handlers/interfaces.js';
+import { type SecurityScanResult } from '../utils/ci-output.js';
+/** Name of the CLI check for the OSV dependency advisory scan (#1049). */
+export declare const DEPENDENCY_CHECK = "Dependency advisories";
+/** #1049: dependency advisories could not be checked; the dependency result is UNMEASURED (same code as coverage/quality). */
+export declare const EXIT_DEPENDENCIES_UNMEASURED = 3;
+/**
+ * `aqe security` exit contract:
+ * 0 = every requested check completed, no medium+ findings
+ * 1 = high/critical findings, non-compliance, or a non-dependency check incomplete/failed
+ * 2 = medium findings only, every requested check complete
+ * 3 = dependency advisories could not be checked (failed or partial OSV lookup) and
+ *     there are no high/critical findings, non-compliance or other incomplete checks:
+ *     UNMEASURED, never a clean exit (#1049). Medium findings plus an incomplete
+ *     dependency scan also exit 3: the result is unmeasured, not a medium-only verdict.
+ */
+export declare function securityExitCode(result: SecurityScanResult): number;
 export declare function createSecurityCommand(context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>): Command;
 //# sourceMappingURL=security.d.ts.map