agentic-qe 3.15.16 → 3.15.18

package/dist/learning/embedding-space-registry.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Embedding-space registry (#1298).
+ *
+ * A space id is a hash of the runtime configuration plus an exact fingerprint
+ * of a canary vector, rounded to int16 (steps of about 3e-5). The same model
+ * restarted on other hardware or kernels can move the canary by more than
+ * that, which would mint a new space id for vectors that are still
+ * comparable. So each space minted here also stores its canary vector, as the
+ * space's reference. At the next start, a runtime with the same configuration
+ * whose canary is within EMBEDDING_ROUND_TRIP_MIN_COSINE of a reference is
+ * that space: it keeps the stored identity and id instead of minting one.
+ *
+ * Entries live in memory.db kv_store (namespace _system) and are only ever
+ * added: a reference is never updated, so slow drift cannot walk a space
+ * away, and no stored id, vector or manifest is ever rewritten. Without a
+ * database, or when it cannot be read, derivation is what it was before.
+ */
+import { type EmbeddingSpaceIdentity } from './embedding-space.js';
+/** The raw memory.db connection the registry reads and writes. */
+export interface EmbeddingSpaceRegistryDb {
+    prepare(sql: string): {
+        all(...params: unknown[]): unknown[];
+        run(...params: unknown[]): unknown;
+    };
+}
+/** A space and the canary vector it was minted with. */
+export interface RegisteredEmbeddingSpace {
+    identity: EmbeddingSpaceIdentity;
+    /** The text the canary vector embeds; only like canaries are compared. */
+    canaryText: string;
+    canary: number[];
+}
+export type EmbeddingSpaceResolution = 
+/** A registered space with the same fingerprint. */
+'matched-exact'
+/** A registered space whose canary is within the round-trip cosine. */
+ | 'matched-cosine'
+/** No registered space matched: the derived space was registered. */
+ | 'registered'
+/** No registered space matched; a pre-registry space id was verified and registered (#1302). */
+ | 'adopted-legacy'
+/** No usable registry: the derived space is used as before. */
+ | 'unavailable';
+export interface ResolvedEmbeddingSpace {
+    identity: EmbeddingSpaceIdentity;
+    resolution: EmbeddingSpaceResolution;
+    /** Same-configuration spaces that did not match (for the drift warning). */
+    otherSpaces: number;
+    /** Settles when the registration write has run (or failed, logged). */
+    registration: Promise<void>;
+}
+/** Same configuration: everything but the runtime fingerprint. */
+export declare function sameEmbeddingSpaceConfig(a: EmbeddingSpaceIdentity, b: EmbeddingSpaceIdentity): boolean;
+/**
+ * The registered space a runtime belongs to, or null. Candidates share the
+ * runtime's configuration and canary text; an equal fingerprint wins, then
+ * the highest canary cosine at or above the round-trip threshold.
+ */
+export declare function matchRegisteredSpace(derived: EmbeddingSpaceIdentity, canaryText: string, canary: readonly number[], entries: readonly RegisteredEmbeddingSpace[]): {
+    entry: RegisteredEmbeddingSpace;
+    exact: boolean;
+} | null;
+/** Read every registered space. Malformed entries are skipped. Throws on a DB error. */
+export declare function loadRegisteredSpaces(db: EmbeddingSpaceRegistryDb): RegisteredEmbeddingSpace[];
+/**
+ * Add a space to the registry. Never replaces an entry. The write goes
+ * through the connection's write queue (#1283) when it has one, so a locked
+ * memory.db does not block the event loop.
+ */
+export declare function registerEmbeddingSpace(db: EmbeddingSpaceRegistryDb, space: RegisteredEmbeddingSpace): Promise<void>;
+/**
+ * Choose the space for a freshly derived runtime identity: a registered space
+ * it matches, or the derived space, which is then registered. Never throws:
+ * when the registry cannot be read the derived space is used, as before.
+ */
+export declare function resolveEmbeddingSpace(db: EmbeddingSpaceRegistryDb | null, derived: EmbeddingSpaceIdentity, canaryText: string, canary: readonly number[]): ResolvedEmbeddingSpace;
+/**
+ * Picks a legacy space id (one with stored vectors but no registry entry) the
+ * runtime belongs to, or null. Throws only on an unexpected failure.
+ */
+export type LegacySpaceAdopter = (derived: EmbeddingSpaceIdentity, registered: readonly RegisteredEmbeddingSpace[]) => Promise<string | null>;
+/**
+ * #1302: like resolveEmbeddingSpace, but before registering a new space the
+ * adopter may name a legacy space id the runtime has been shown to reproduce.
+ * That id is kept and registered with the current canary as its reference.
+ * Its identity carries the current runtime fields: a pre-registry id is a
+ * hash that cannot be reversed into the fields it was minted from.
+ */
+export declare function resolveEmbeddingSpaceAdoptingLegacy(db: EmbeddingSpaceRegistryDb | null, derived: EmbeddingSpaceIdentity, canaryText: string, canary: readonly number[], adoptLegacy: LegacySpaceAdopter): Promise<ResolvedEmbeddingSpace>;
+//# sourceMappingURL=embedding-space-registry.d.ts.map

package/dist/learning/embedding-space-registry.js

@@ -0,0 +1,181 @@
+/**
+ * Embedding-space registry (#1298).
+ *
+ * A space id is a hash of the runtime configuration plus an exact fingerprint
+ * of a canary vector, rounded to int16 (steps of about 3e-5). The same model
+ * restarted on other hardware or kernels can move the canary by more than
+ * that, which would mint a new space id for vectors that are still
+ * comparable. So each space minted here also stores its canary vector, as the
+ * space's reference. At the next start, a runtime with the same configuration
+ * whose canary is within EMBEDDING_ROUND_TRIP_MIN_COSINE of a reference is
+ * that space: it keeps the stored identity and id instead of minting one.
+ *
+ * Entries live in memory.db kv_store (namespace _system) and are only ever
+ * added: a reference is never updated, so slow drift cannot walk a space
+ * away, and no stored id, vector or manifest is ever rewritten. Without a
+ * database, or when it cannot be read, derivation is what it was before.
+ */
+import { cosineSimilarity } from '../shared/utils/vector-math.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
+import { toErrorMessage } from '../shared/error-utils.js';
+import { EMBEDDING_ROUND_TRIP_MIN_COSINE, } from './embedding-space.js';
+const NAMESPACE = '_system';
+const KEY_PREFIX = 'embedding_space:';
+/** Same configuration: everything but the runtime fingerprint. */
+export function sameEmbeddingSpaceConfig(a, b) {
+    return (a.provider === b.provider &&
+        a.model === b.model &&
+        a.dimensions === b.dimensions &&
+        (a.pooling ?? null) === (b.pooling ?? null) &&
+        a.normalized === b.normalized &&
+        (a.preprocessingVersion ?? null) === (b.preprocessingVersion ?? null) &&
+        (a.implementation ?? null) === (b.implementation ?? null));
+}
+/**
+ * The registered space a runtime belongs to, or null. Candidates share the
+ * runtime's configuration and canary text; an equal fingerprint wins, then
+ * the highest canary cosine at or above the round-trip threshold.
+ */
+export function matchRegisteredSpace(derived, canaryText, canary, entries) {
+    const candidates = entries.filter((entry) => entry.canaryText === canaryText &&
+        entry.canary.length === canary.length &&
+        sameEmbeddingSpaceConfig(entry.identity, derived));
+    const exact = candidates.find((entry) => entry.identity.runtimeFingerprint === derived.runtimeFingerprint);
+    if (exact)
+        return { entry: exact, exact: true };
+    let best = null;
+    for (const entry of candidates) {
+        const cosine = cosineSimilarity(entry.canary, canary);
+        if (cosine >= EMBEDDING_ROUND_TRIP_MIN_COSINE && (!best || cosine > best.cosine)) {
+            best = { entry, cosine };
+        }
+    }
+    return best ? { entry: best.entry, exact: false } : null;
+}
+/** Read every registered space. Malformed entries are skipped. Throws on a DB error. */
+export function loadRegisteredSpaces(db) {
+    const rows = db
+        .prepare('SELECT value FROM kv_store WHERE namespace = ? AND key LIKE ?')
+        .all(NAMESPACE, `${KEY_PREFIX}%`);
+    const entries = [];
+    for (const row of rows) {
+        const entry = parseEntry(row.value);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+function parseEntry(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+    const { identity, canaryText, canary } = parsed;
+    if (parsed.version !== 1 ||
+        !identity ||
+        typeof identity.spaceId !== 'string' ||
+        typeof identity.runtimeFingerprint !== 'string' ||
+        typeof identity.dimensions !== 'number' ||
+        typeof canaryText !== 'string' ||
+        !Array.isArray(canary) ||
+        canary.length !== identity.dimensions ||
+        !canary.every((x) => typeof x === 'number' && Number.isFinite(x))) {
+        return null;
+    }
+    return { identity, canaryText, canary };
+}
+/**
+ * Add a space to the registry. Never replaces an entry. The write goes
+ * through the connection's write queue (#1283) when it has one, so a locked
+ * memory.db does not block the event loop.
+ */
+export function registerEmbeddingSpace(db, space) {
+    const entry = { version: 1, createdAt: Date.now(), ...space };
+    return writeWhenUnlockedOn(db, () => {
+        db.prepare('INSERT OR IGNORE INTO kv_store (key, namespace, value) VALUES (?, ?, ?)').run(KEY_PREFIX + space.identity.spaceId, NAMESPACE, JSON.stringify(entry));
+    });
+}
+/**
+ * Choose the space for a freshly derived runtime identity: a registered space
+ * it matches, or the derived space, which is then registered. Never throws:
+ * when the registry cannot be read the derived space is used, as before.
+ */
+export function resolveEmbeddingSpace(db, derived, canaryText, canary) {
+    const lookup = lookupEmbeddingSpace(db, derived, canaryText, canary);
+    if (lookup.resolved)
+        return lookup.resolved;
+    return registerResolvedSpace(lookup.db, derived, canaryText, canary, 'registered', lookup.otherSpaces);
+}
+/**
+ * #1302: like resolveEmbeddingSpace, but before registering a new space the
+ * adopter may name a legacy space id the runtime has been shown to reproduce.
+ * That id is kept and registered with the current canary as its reference.
+ * Its identity carries the current runtime fields: a pre-registry id is a
+ * hash that cannot be reversed into the fields it was minted from.
+ */
+export async function resolveEmbeddingSpaceAdoptingLegacy(db, derived, canaryText, canary, adoptLegacy) {
+    const lookup = lookupEmbeddingSpace(db, derived, canaryText, canary);
+    if (lookup.resolved)
+        return lookup.resolved;
+    let legacySpaceId = null;
+    try {
+        legacySpaceId = await adoptLegacy(derived, lookup.entries);
+    }
+    catch (error) {
+        console.warn(`[EmbeddingSpaceRegistry] legacy space check failed (${toErrorMessage(error)}); ` +
+            `registering the derived space id`);
+    }
+    if (legacySpaceId) {
+        const adopted = { ...derived, spaceId: legacySpaceId };
+        return registerResolvedSpace(lookup.db, adopted, canaryText, canary, 'adopted-legacy', 0);
+    }
+    return registerResolvedSpace(lookup.db, derived, canaryText, canary, 'registered', lookup.otherSpaces);
+}
+/** A registered match (or the unavailable fallback), or what is needed to register. */
+function lookupEmbeddingSpace(db, derived, canaryText, canary) {
+    const unavailable = () => ({
+        resolved: {
+            identity: derived,
+            resolution: 'unavailable',
+            otherSpaces: 0,
+            registration: Promise.resolve(),
+        },
+    });
+    if (!db)
+        return unavailable();
+    let entries;
+    try {
+        entries = loadRegisteredSpaces(db);
+    }
+    catch (error) {
+        console.warn(`[EmbeddingSpaceRegistry] could not read registered embedding spaces ` +
+            `(${toErrorMessage(error)}); using the derived space id`);
+        return unavailable();
+    }
+    const match = matchRegisteredSpace(derived, canaryText, canary, entries);
+    if (match) {
+        return {
+            resolved: {
+                identity: match.entry.identity,
+                resolution: match.exact ? 'matched-exact' : 'matched-cosine',
+                otherSpaces: 0,
+                registration: Promise.resolve(),
+            },
+        };
+    }
+    const otherSpaces = entries.filter((entry) => entry.canaryText === canaryText && sameEmbeddingSpaceConfig(entry.identity, derived)).length;
+    return { db, entries, otherSpaces };
+}
+function registerResolvedSpace(db, identity, canaryText, canary, resolution, otherSpaces) {
+    const registration = Promise.resolve()
+        .then(() => registerEmbeddingSpace(db, { identity, canaryText, canary: [...canary] }))
+        .catch((error) => {
+        console.warn(`[EmbeddingSpaceRegistry] could not register embedding space ${identity.spaceId.slice(0, 12)} ` +
+            `(${toErrorMessage(error)}); it is registered at a later start`);
+    });
+    return { identity, resolution, otherSpaces, registration };
+}
+//# sourceMappingURL=embedding-space-registry.js.map

package/dist/learning/experience-capture.d.ts

@@ -254,7 +254,9 @@ export declare class ExperienceCaptureService {
     /**
      * Extract pattern from experience
      */
-    extractPattern(experience: TaskExperience): Promise<PatternExtractionResult>;
+    extractPattern(experience: TaskExperience, options?: {
+        createIfMissing?: boolean;
+    }): Promise<PatternExtractionResult>;
     /**
      * Share experience across domains
      */

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.d.ts

@@ -40,6 +40,7 @@ export interface EmbeddingConfig {
     endpointToken?: string;
 }
 export declare const DEFAULT_EMBEDDING_CONFIG: EmbeddingConfig;
+export declare function __spaceRegistrationSettledForTests(): Promise<void>;
 /**
  * Compute real embedding using transformer model
  *
@@ -95,6 +96,8 @@ export declare function allowEmbedderInitRetry(): void;
  *   for the breaker window as well as the caller's retry interval. The probe
  *   must find the identity this process bound to (ADR-097): a changed
  *   fingerprint means vectors would not be comparable.
+ *   The client refuses it (EmbedderEndpointIdentityChangedError) and keeps
+ *   refusing every caller, also when its breaker recovers on its own (#1282).
  * Callers rate-limit rechecks, then embed a canary to confirm.
  */
 export declare function recheckEmbedder(config?: Partial<EmbeddingConfig>): Promise<void>;