agentic-qe 3.15.17 → 3.15.18

package/dist/learning/experience-capture.js

@@ -253,12 +253,17 @@ export class ExperienceCaptureService {
         // Extract patterns: require positive reward (or no reward signal) AND quality threshold
         // Zero or negative reward blocks extraction — only learn from genuinely positive outcomes
         const rewardAllowsExtraction = experience.reward === undefined || experience.reward > 0;
+        const passesExtractionGates = experience.success &&
+            experience.quality >= this.config.minQualityForPatternExtraction &&
+            rewardAllowsExtraction;
         // #1129: a measured outcome is recorded whether it succeeded or failed.
         // Recording only successes made the usage success rate 100% by selection.
-        if (experience.outcomeBasis !== undefined || (experience.success &&
-            experience.quality >= this.config.minQualityForPatternExtraction &&
-            rewardAllowsExtraction)) {
-            const extractionResult = await this.extractPattern(experience);
+        // #1147: only a run that passes the gates creates a pattern; any other
+        // measured run updates the usage of an existing matching pattern.
+        if (passesExtractionGates || experience.outcomeBasis !== undefined) {
+            const extractionResult = await this.extractPattern(experience, {
+                createIfMissing: passesExtractionGates,
+            });
             if (extractionResult.newPattern || extractionResult.reinforced) {
                 experience.patterns = [extractionResult.patternId];
             }
@@ -375,7 +380,7 @@ export class ExperienceCaptureService {
     /**
      * Extract pattern from experience
      */
-    async extractPattern(experience) {
+    async extractPattern(experience, options = {}) {
         if (!this.patternStore) {
             return { newPattern: false, reinforced: false, promoted: false };
         }
@@ -421,6 +426,11 @@ export class ExperienceCaptureService {
                 };
             }
         }
+        // #1147: a run that did not pass the extraction gates (e.g. a measured
+        // failure) never mints a pattern; with no existing match nothing is stored.
+        if (options.createIfMissing === false) {
+            return { newPattern: false, reinforced: false, promoted: false };
+        }
         // Create new pattern from experience
         const patternOptions = this.experienceToPatternOptions(experience);
         const createResult = await this.patternStore.create(patternOptions);

package/dist/learning/experience-space-verification.d.ts

@@ -61,6 +61,8 @@ export interface ExperienceSpaceVerificationResult {
  *   in steps_json.
  */
 export declare function legacyExperienceEmbeddingTexts(row: LegacyExperienceRow): string[];
+/** The row's stored float32 vector, or null when the blob is short. */
+export declare function storedExperienceVector(row: LegacyExperienceRow): number[] | null;
 /**
  * Check up to `limit` legacy rows (vector, no embedding_space_id) and set
  * embedding_space_id on those whose stored vector the active embedder

package/dist/learning/experience-space-verification.js

@@ -44,7 +44,8 @@ export function legacyExperienceEmbeddingTexts(row) {
     }
     return [...texts];
 }
-function storedVector(row) {
+/** The row's stored float32 vector, or null when the blob is short. */
+export function storedExperienceVector(row) {
     if (row.embedding.length < row.embedding_dimension * 4)
         return null;
     const v = [];
@@ -107,7 +108,7 @@ export async function verifyLegacyExperienceSpaces(db, options) {
     let lastRowid = 0;
     try {
         for (const row of rows) {
-            const stored = storedVector(row);
+            const stored = storedExperienceVector(row);
             let matched = false;
             if (stored) {
                 for (const text of legacyExperienceEmbeddingTexts(row)) {

package/dist/learning/learning-retention.js

@@ -26,6 +26,7 @@
  * Every step reports the row counts it measured before and after, or, in a
  * dry run, the counts it would change.
  */
+import { acknowledgeCheckpointShrink, removedRows } from './checkpoint-shrink-ack.js';
 export const DEFAULT_FAILED_DREAM_CYCLE_RETENTION_DAYS = 7;
 export const DEFAULT_OUTCOME_CONCEPT_CAP = 2000;
 /** Below this the cap would delete outcome nodes that the next dream reloads. */
@@ -187,6 +188,9 @@ export function runDreamRetention(db, settings = resolveDefaultRetention()) {
     if (settings.outcomeConceptCap !== null) {
         steps.push(capOutcomeConcepts(db, { maxNodes: settings.outcomeConceptCap, dryRun }));
     }
+    // #1251: a deliberate shrink, so the next brain checkpoint accepts it.
+    if (removedRows(steps))
+        acknowledgeCheckpointShrink(db, 'dream');
     return { enabled: settings.enabled, steps };
 }
 /** Lines for a dream's output: what retention removed, or would remove while off. */

package/dist/learning/pattern-promotion.d.ts

@@ -60,9 +60,16 @@ export interface SeedingDeps {
      */
     signal?: AbortSignal;
 }
+/** Tag stored on every pattern written by cross-domain seeding. */
+export declare const CROSS_DOMAIN_TRANSFER_TAG = "cross-domain-transfer";
 /**
  * Seed cross-domain patterns by transferring generalizable patterns
  * from populated domains to their related domains.
+ *
+ * Idempotent (#1325): only original patterns are counted and transferred
+ * (never a pattern tagged `cross-domain-transfer`), and a transfer whose exact
+ * target name already exists in the target domain is skipped. Re-running it
+ * against a seeded store transfers nothing.
  */
 export declare function seedCrossDomainPatterns(deps: SeedingDeps): Promise<{
     transferred: number;

package/dist/learning/pattern-promotion.js

@@ -152,9 +152,39 @@ export async function promotePattern(patternId, deps) {
         return result;
     }
 }
+/** Tag stored on every pattern written by cross-domain seeding. */
+export const CROSS_DOMAIN_TRANSFER_TAG = 'cross-domain-transfer';
+/** Maximum original patterns transferred out of one source domain per run. */
+const SEED_SOURCE_LIMIT = 50;
+function isCrossDomainTransfer(pattern) {
+    return pattern.context?.tags?.includes(CROSS_DOMAIN_TRANSFER_TAG) ?? false;
+}
+/**
+ * Snapshot one domain before seeding writes anything, or null when the store
+ * cannot list it. Counting and transferring only originals keeps every run's
+ * decisions the same as the first run's, so a re-run finds every transfer it
+ * would make already present by name (#1325).
+ */
+async function snapshotDomain(deps, domain, domainCount) {
+    if (domainCount === 0)
+        return { originals: [], names: new Set() };
+    const result = await deps.searchPatterns('', { domain, limit: domainCount });
+    if (!result.success)
+        return null;
+    const patterns = result.value.map(({ pattern }) => pattern);
+    return {
+        originals: patterns.filter((pattern) => !isCrossDomainTransfer(pattern)),
+        names: new Set(patterns.map((pattern) => pattern.name)),
+    };
+}
 /**
  * Seed cross-domain patterns by transferring generalizable patterns
  * from populated domains to their related domains.
+ *
+ * Idempotent (#1325): only original patterns are counted and transferred
+ * (never a pattern tagged `cross-domain-transfer`), and a transfer whose exact
+ * target name already exists in the target domain is skipped. Re-running it
+ * against a seeded store transfers nothing.
  */
 export async function seedCrossDomainPatterns(deps) {
     const { signal } = deps;
@@ -162,27 +192,48 @@ export async function seedCrossDomainPatterns(deps) {
     const stats = await deps.patternStore.getStats();
     let transferred = 0;
     let skipped = 0;
+    // Snapshot all involved domains up front, before any transfer is written.
+    const domains = new Set();
+    for (const [source, targets] of Object.entries(RELATED_DOMAINS)) {
+        domains.add(source);
+        for (const target of targets)
+            domains.add(target);
+    }
+    const snapshots = new Map();
+    for (const domain of domains) {
+        signal?.throwIfAborted();
+        snapshots.set(domain, await snapshotDomain(deps, domain, stats.byDomain[domain] || 0));
+    }
     for (const [sourceDomainStr, targetDomains] of Object.entries(RELATED_DOMAINS)) {
         signal?.throwIfAborted();
         const sourceDomain = sourceDomainStr;
-        const sourceCount = stats.byDomain[sourceDomain] || 0;
-        if (sourceCount === 0)
+        const source = snapshots.get(sourceDomain);
+        if (!source)
             continue;
-        const sourceResult = await deps.searchPatterns('', {
-            domain: sourceDomain,
-            limit: 50,
-        });
-        if (!sourceResult.success)
+        const sourceCount = source.originals.length;
+        if (sourceCount === 0)
             continue;
+        const sourcePatterns = source.originals.slice(0, SEED_SOURCE_LIMIT);
         for (const targetDomain of targetDomains) {
             signal?.throwIfAborted();
-            const targetCount = stats.byDomain[targetDomain] || 0;
-            if (targetCount >= sourceCount) {
+            const target = snapshots.get(targetDomain);
+            if (!target) {
+                // Cannot prove which transfers already exist: transfer nothing rather
+                // than risk duplicating the target domain.
+                skipped++;
+                continue;
+            }
+            if (target.originals.length >= sourceCount) {
                 skipped++;
                 continue;
             }
-            for (const { pattern: sourcePattern } of sourceResult.value) {
+            for (const sourcePattern of sourcePatterns) {
                 signal?.throwIfAborted();
+                const transferredName = `${sourcePattern.name} (from ${sourceDomain})`;
+                if (target.names.has(transferredName)) {
+                    skipped++;
+                    continue;
+                }
                 const existingCheck = await deps.searchPatterns(sourcePattern.name, {
                     domain: targetDomain,
                     limit: 1,
@@ -198,7 +249,7 @@ export async function seedCrossDomainPatterns(deps) {
                 const transferResult = await deps.storePattern({
                     patternType: sourcePattern.patternType,
                     qeDomain: targetDomain,
-                    name: `${sourcePattern.name} (from ${sourceDomain})`,
+                    name: transferredName,
                     description: `${sourcePattern.description} [Transferred from ${sourceDomain} domain]`,
                     template: sourcePattern.template,
                     context: {
@@ -206,13 +257,14 @@ export async function seedCrossDomainPatterns(deps) {
                         relatedDomains: [sourceDomain, targetDomain],
                         tags: [
                             ...sourcePattern.context.tags,
-                            'cross-domain-transfer',
+                            CROSS_DOMAIN_TRANSFER_TAG,
                             `source:${sourceDomain}`,
                         ],
                     },
                     confidence: transferredConfidence,
                 });
                 if (transferResult.success) {
+                    target.names.add(transferredName);
                     transferred++;
                 }
                 else {

package/dist/learning/real-embeddings.js

@@ -11,7 +11,8 @@ import { toErrorMessage } from '../shared/error-utils.js';
 import { EmbedderEndpointClient, ENDPOINT_IDENTITY_CANARY, redactEndpoint, } from './embedder-endpoint-client.js';
 import { loadEmbedderIdentity, resetEmbedderIdentityStore, saveEmbedderIdentity, } from './embedder-identity-store.js';
 import { EMBEDDING_SPACE_CANARY, deriveEmbeddingSpaceIdentity, fingerprintEmbeddingRuntime, } from './embedding-space.js';
-import { resolveEmbeddingSpace, } from './embedding-space-registry.js';
+import { resolveEmbeddingSpaceAdoptingLegacy, } from './embedding-space-registry.js';
+import { findAdoptableLegacySpace } from './embedding-space-legacy-adoption.js';
 // Lazy-loaded transformer pipeline
 let pipeline = null;
 let embeddingModel = null;
@@ -119,7 +120,7 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                 });
                 const boundCanary = endpointClient.getBoundCanary();
                 const space = boundCanary
-                    ? await resolveActiveSpace(derivedSpace, ENDPOINT_IDENTITY_CANARY, [...boundCanary])
+                    ? await resolveActiveSpace(derivedSpace, ENDPOINT_IDENTITY_CANARY, [...boundCanary], createEndpointPipeline(endpointClient))
                     : null;
                 activeEmbeddingSpaceIdentity = space?.identity ?? derivedSpace;
                 console.log(`[RealEmbeddings] Endpoint identity: dim=${endpointIdentity.dim} fingerprint=${endpointIdentity.fingerprint}`);
@@ -131,8 +132,11 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                 try {
                     const previous = loadEmbedderIdentity(endpointIdentity.endpoint);
                     // #1298: a restart that kept its registered space is not a change,
-                    // even when float noise moved the fingerprint.
-                    const spaceKept = space?.resolution === 'matched-exact' || space?.resolution === 'matched-cosine';
+                    // even when float noise moved the fingerprint (#1302: nor one that
+                    // adopted its pre-registry space).
+                    const spaceKept = space?.resolution === 'matched-exact' ||
+                        space?.resolution === 'matched-cosine' ||
+                        space?.resolution === 'adopted-legacy';
                     const changed = (previous !== null && previous.fingerprint !== endpointIdentity.fingerprint) ||
                         (space?.otherSpaces ?? 0) > 0;
                     if (!spaceKept && changed) {
@@ -196,7 +200,7 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                 implementation: `transformers:${fullConfig.quantized ? 'quantized' : 'full'}`,
                 runtimeFingerprint: fingerprintEmbeddingRuntime(canaryVector),
             });
-            activeEmbeddingSpaceIdentity = (await resolveActiveSpace(derivedSpace, EMBEDDING_SPACE_CANARY, canaryVector)).identity;
+            activeEmbeddingSpaceIdentity = (await resolveActiveSpace(derivedSpace, EMBEDDING_SPACE_CANARY, canaryVector, initializedModel)).identity;
             initializationFailed = false;
             failureReason = '';
             const loadTime = performance.now() - startTime;
@@ -221,8 +225,13 @@ export function __spaceRegistrationSettledForTests() {
  * of minting a new id from the exact fingerprint. Uses the shared memory.db
  * connection only when UnifiedMemory is already open; otherwise (and on any
  * registry error) the derived space is used, as before.
+ *
+ * #1302: when no registered space matches, a pre-registry space id whose
+ * stored experience vectors `model` reproduces is adopted instead of minting
+ * a new one. That check re-embeds a bounded number of rows and runs once:
+ * afterwards the chosen space is registered and matched from the registry.
  */
-async function resolveActiveSpace(derived, canaryText, canary) {
+async function resolveActiveSpace(derived, canaryText, canary, model) {
     let db = null;
     try {
         const { getOpenUnifiedMemoryDatabase } = await import('../kernel/unified-memory.js');
@@ -231,7 +240,22 @@ async function resolveActiveSpace(derived, canaryText, canary) {
     catch (error) {
         console.warn(`[RealEmbeddings] embedding-space registry unavailable: ${toErrorMessage(error)}`);
     }
-    const resolved = resolveEmbeddingSpace(db, derived, canaryText, canary);
+    const resolved = await resolveEmbeddingSpaceAdoptingLegacy(db, derived, canaryText, canary, async (space, registered) => {
+        const adoption = await findAdoptableLegacySpace(db, space, registered, async (text) => {
+            if (isNonSemanticText(text))
+                return new Array(space.dimensions).fill(0);
+            const output = await model(text, { pooling: 'mean', normalize: true });
+            return Array.from(output.data);
+        });
+        if (adoption.spaceId) {
+            console.log(`[RealEmbeddings] Embedding space ${adoption.spaceId.slice(0, 12)} adopted: it has no reference canary, ` +
+                `and the active runtime reproduces its stored experience vectors: ${adoption.reason}`);
+        }
+        else {
+            console.log(`[RealEmbeddings] No earlier embedding space adopted: ${adoption.reason}`);
+        }
+        return adoption.spaceId;
+    });
     lastSpaceRegistration = resolved.registration;
     if (resolved.resolution === 'matched-cosine') {
         console.log(`[RealEmbeddings] Embedding space ${resolved.identity.spaceId.slice(0, 12)} kept: ` +

package/dist/learning/rvf-pattern-store.js

@@ -378,7 +378,12 @@ export class RvfPatternStore {
         // Empty string query = return all patterns sorted by quality score
         if (typeof query === 'string' && !query.trim() && this.sqliteStore) {
             try {
-                const allPatterns = this.sqliteStore.getPatterns({ limit: limit * 2 });
+                // Filter by domain in SQL (#1325): a global LIMIT followed by the
+                // domain filter below silently dropped patterns of that domain.
+                const allPatterns = this.sqliteStore.getPatterns({
+                    domain: options.domain,
+                    limit: limit * 2,
+                });
                 const existingIds = new Set(results.map(r => r.pattern.id));
                 for (const pattern of allPatterns) {
                     if (existingIds.has(pattern.id))