openclaw-hybrid-memory 2026.5.310 → 2026.6.10

package/cli/commands/manage/register-storage-maintenance.ts

@@ -4,25 +4,34 @@
  */
 
 import { existsSync, unlinkSync } from "node:fs";
+import { isPreStoreGuardBlocked } from "../../../backends/facts-db/crud.js";
+import { computeAdaptivePressureDelayMs } from "../../../services/adaptive-catch-up-pacing.js";
+import {
+  is403QuotaOrRateLimitLike,
+  is429OrWrapped,
+  is500OrWrapped,
+  isConnectionErrorLike,
+  parseRetryAfterMs,
+} from "../../../services/chat.js";
 import { migrateEmbeddings } from "../../../services/embedding-migration.js";
-import { capturePluginError } from "../../../services/error-reporter.js";
 import { AllEmbeddingProvidersFailed } from "../../../services/embeddings.js";
+import { buildVectorlessSloRepairRecommendation } from "../../../services/entity-enrichment-adaptive.js";
+import { capturePluginError } from "../../../services/error-reporter.js";
 import { recordMaintenanceTimestamp } from "../../../services/maintenance-timestamp.js";
 import { countPendingReviewBacklogs } from "../../../services/pending-review-digest.js";
-import { deleteVectorsForFactIds } from "../../../services/vector-maintenance.js";
 import {
-  type VectorBackendObservability,
   collectVectorBackendObservability,
+  type VectorBackendObservability,
 } from "../../../services/vector-backend-observability.js";
 import { appendVectorLifecycleAuditEvent } from "../../../services/vector-lifecycle-audit.js";
-import { is500OrWrapped } from "../../../services/chat.js";
-import { getEnv } from "../../../utils/env-manager.js";
+import { deleteVectorsForFactIds } from "../../../services/vector-maintenance.js";
+import type { MemoryEntry } from "../../../types/memory.js";
 import { embedCallWithTimeoutAndRetry } from "../../../utils/embed-call.js";
+import { getEnv } from "../../../utils/env-manager.js";
 import { type CommanderOptsParent, readHybridMemVerbose } from "../../global-verbose.js";
-import { type Chainable, approxIntervalMs, withExit } from "../../shared.js";
+import { approxIntervalMs, type Chainable, withExit } from "../../shared.js";
 import type { ManageBindings } from "./bindings.js";
-import type { MemoryEntry } from "../../../types/memory.js";
-import { isPreStoreGuardBlocked } from "../../../backends/facts-db/crud.js";
+import { runMaintenanceHeartbeat } from "./maintenance-heartbeat.js";
 import {
   countImplicitFeedbackTrajectorySignals,
   defaultReindexCheckpointPath,
@@ -32,7 +41,6 @@ import {
   recordStorageGrowthSample,
   writeReindexCheckpoint,
 } from "./storage-stats-helpers.js";
-import { runMaintenanceHeartbeat } from "./maintenance-heartbeat.js";
 
 type FactsDbWithBatch = {
   getBatch: (
@@ -104,6 +112,53 @@ function isEmbeddingProviderServerError(err: unknown): boolean {
   return false;
 }
 
+function isEmbeddingProviderRateLimitError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  if (is429OrWrapped(err) || is403QuotaOrRateLimitLike(err)) return true;
+  if (err instanceof AllEmbeddingProvidersFailed) {
+    return err.causes.some(
+      (cause) => cause instanceof Error && (is429OrWrapped(cause) || is403QuotaOrRateLimitLike(cause)),
+    );
+  }
+  return false;
+}
+
+function isEmbeddingProviderTransientError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  if (isEmbeddingProviderRateLimitError(err) || is500OrWrapped(err) || isConnectionErrorLike(err)) return true;
+  if (err instanceof AllEmbeddingProvidersFailed) {
+    return err.causes.some(
+      (cause) =>
+        cause instanceof Error &&
+        (is429OrWrapped(cause) ||
+          is403QuotaOrRateLimitLike(cause) ||
+          is500OrWrapped(cause) ||
+          isConnectionErrorLike(cause)),
+    );
+  }
+  return false;
+}
+
+function parseEmbeddingRetryAfterMs(err: unknown): number | undefined {
+  if (err instanceof Error) {
+    const fromTop = parseRetryAfterMs(err);
+    if (fromTop !== undefined) return fromTop;
+  }
+  if (err instanceof AllEmbeddingProvidersFailed) {
+    for (const cause of err.causes) {
+      if (!(cause instanceof Error)) continue;
+      const retryAfterMs = parseRetryAfterMs(cause);
+      if (retryAfterMs !== undefined) return retryAfterMs;
+    }
+  }
+  return undefined;
+}
+
+function sleep(ms: number): Promise<void> {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindings): void {
   const {
     factsDb,
@@ -653,6 +708,11 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
     .option("--source <s>", "Only process facts from this source")
     .option("--apply", "Actually embed and write LanceDB/fact_embeddings rows; default is dry-run")
     .option("--batch-size <n>", "Embedding batch size", "40")
+    .option("--batch-delay-ms <n>", "Delay between adaptive batches in ms (default 150)", "150")
+    .option(
+      "--adaptive-catch-up",
+      "Enable adaptive pacing (ramps up on healthy batches; backs off on provider/rate-limit/store pressure)",
+    )
     .option(
       "--max-embed-failures <n>",
       "Circuit-break after this many consecutive embed failures and exit 1; prevents indefinite stall on provider outage (default: 5)",
@@ -668,6 +728,8 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
             source?: string;
             apply?: boolean;
             batchSize?: string;
+            batchDelayMs?: string;
+            adaptiveCatchUp?: boolean;
             maxEmbedFailures?: string;
             verbose?: boolean;
             json?: boolean;
@@ -676,8 +738,18 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
         ) => {
           const limit = Number.parseInt(opts?.limit ?? "100", 10);
           const batchSize = Number.parseInt(opts?.batchSize ?? "40", 10);
+          const batchDelayMs = Number.parseInt(opts?.batchDelayMs ?? "150", 10);
+          const adaptiveCatchUp = opts?.adaptiveCatchUp === true;
           const maxEmbedFailures = Number.parseInt(opts?.maxEmbedFailures ?? "5", 10);
           const verbose = !!opts?.verbose || readHybridMemVerbose(cmd);
+          const adaptiveMinBatchSize = 1;
+          const adaptiveMaxBatchSize = 200;
+          const adaptiveMinDelayMs = 0;
+          const adaptiveMaxDelayMs = 5_000;
+          const adaptiveBackoffMinDelayMs = 50;
+          const adaptiveBatchSizeStep = 5;
+          const adaptiveDelayStepMs = 25;
+          const adaptiveSuccessStreakForRampUp = 2;
           if (!Number.isFinite(limit) || limit < 1) {
             console.error("error: --limit must be a positive integer");
             process.exitCode = 1;
@@ -688,19 +760,48 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
             process.exitCode = 1;
             return;
           }
+          if (!Number.isFinite(batchDelayMs) || batchDelayMs < 0) {
+            console.error("error: --batch-delay-ms must be a non-negative integer");
+            process.exitCode = 1;
+            return;
+          }
           if (!Number.isFinite(maxEmbedFailures) || maxEmbedFailures < 1) {
             console.error("error: --max-embed-failures must be a positive integer");
             process.exitCode = 1;
             return;
           }
           const before = factsDb.countVectorlessActiveFacts(opts?.source);
+          const globalVectorlessBefore = factsDb.countVectorlessActiveFacts();
           const candidates = factsDb.listVectorlessActiveFacts({ limit, source: opts?.source });
           const errors: string[] = [];
           let embedded = 0;
           let skipped = 0;
           let storeFailures = 0;
           let embedFailures = 0;
-          const totalBatches = batchSize > 0 ? Math.ceil(candidates.length / batchSize) : 0;
+          const startedAtMs = Date.now();
+          const baselineBatchSize = batchSize;
+          const baselineDelayMs = batchDelayMs;
+          let effectiveBatchSize = batchSize;
+          let effectiveDelayMs = batchDelayMs;
+          if (adaptiveCatchUp) {
+            effectiveBatchSize = Math.max(adaptiveMinBatchSize, Math.min(adaptiveMaxBatchSize, batchSize));
+            effectiveDelayMs = Math.max(adaptiveMinDelayMs, Math.min(adaptiveMaxDelayMs, batchDelayMs));
+          }
+          const adaptiveAdjustments: Array<{
+            reason: "pressure" | "ramp-up";
+            previousBatchSize: number;
+            previousDelayMs: number;
+            batchSize: number;
+            delayMs: number;
+            batchPressureSignals: number;
+            batchRateLimited: number;
+            batchTransientFailures: number;
+            batchStoreFailures: number;
+            batchEmbedFailures: number;
+            retryAfterMs?: number;
+            batchNumber: number;
+          }> = [];
+          let successStreak = 0;
           let processed = 0;
           let batchNumber = 0;
           let providerCircuitBreak = false;
@@ -713,11 +814,18 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
               verbose,
               async () => {
                 await vectorDb.runWithAutoOptimizePaused(async () => {
-                  for (let offset = 0; offset < candidates.length; offset += batchSize) {
+                  let offset = 0;
+                  while (offset < candidates.length) {
                     if (providerCircuitBreak) break;
-                    batchNumber = Math.floor(offset / batchSize) + 1;
-                    const batch = candidates.slice(offset, offset + batchSize);
+                    batchNumber++;
+                    const batch = candidates.slice(offset, offset + effectiveBatchSize);
                     let vectors: (number[] | null)[];
+                    let batchPressureSignals = 0;
+                    let batchRateLimited = 0;
+                    let batchTransientFailures = 0;
+                    let batchStoreFailures = 0;
+                    let batchEmbedFailures = 0;
+                    let batchRetryAfterMs: number | undefined;
                     try {
                       vectors = await embedCallWithTimeoutAndRetry(
                         () => embeddings.embedBatch(batch.map((fact) => fact.text)),
@@ -725,6 +833,14 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
                       );
                       consecutiveEmbedFailures = 0;
                     } catch (batchErr) {
+                      const batchRateLimitedErr = isEmbeddingProviderRateLimitError(batchErr);
+                      const batchTransientErr = isEmbeddingProviderTransientError(batchErr);
+                      batchRetryAfterMs = parseEmbeddingRetryAfterMs(batchErr);
+                      if (batchRateLimitedErr) batchRateLimited++;
+                      if (batchTransientErr) batchTransientFailures++;
+                      if (batchRateLimitedErr || batchTransientErr || batchRetryAfterMs !== undefined) {
+                        batchPressureSignals++;
+                      }
                       if (isEmbeddingProviderServerError(batchErr)) {
                         providerCircuitBreak = true;
                         providerCircuitBreakCause = "provider_5xx";
@@ -747,7 +863,19 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
                         } catch (singleErr) {
                           errors.push(`fact ${fact.id}: embed failed — ${String(singleErr)}`);
                           embedFailures++;
+                          batchEmbedFailures++;
                           vectors.push(null);
+                          const rateLimited = isEmbeddingProviderRateLimitError(singleErr);
+                          const transient = isEmbeddingProviderTransientError(singleErr);
+                          const retryAfterMs = parseEmbeddingRetryAfterMs(singleErr);
+                          if (rateLimited) batchRateLimited++;
+                          if (transient) batchTransientFailures++;
+                          if (rateLimited || transient || retryAfterMs !== undefined) {
+                            batchPressureSignals++;
+                          }
+                          if (retryAfterMs !== undefined) {
+                            batchRetryAfterMs = Math.max(batchRetryAfterMs ?? 0, retryAfterMs);
+                          }
                           if (isEmbeddingProviderServerError(singleErr)) {
                             providerCircuitBreak = true;
                             providerCircuitBreakCause = "provider_5xx";
@@ -798,26 +926,74 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
                       } catch (err) {
                         errors.push(`fact ${fact.id}: store failed — ${String(err)}`);
                         storeFailures++;
+                        batchStoreFailures++;
                         skipped++;
                       } finally {
                         processed++;
                       }
                     }
+                    if (adaptiveCatchUp) {
+                      const hadPressure = batchPressureSignals > 0 || batchStoreFailures > 0 || batchEmbedFailures > 0;
+                      const previousBatchSize = effectiveBatchSize;
+                      const previousDelayMs = effectiveDelayMs;
+                      if (hadPressure) {
+                        successStreak = 0;
+                        effectiveBatchSize = Math.max(adaptiveMinBatchSize, Math.floor(effectiveBatchSize / 2));
+                        effectiveDelayMs = computeAdaptivePressureDelayMs({
+                          currentDelayMs: effectiveDelayMs,
+                          batchRetryAfterMs,
+                          maxAdaptiveDelayMs: adaptiveMaxDelayMs,
+                          backoffMinDelayMs: adaptiveBackoffMinDelayMs,
+                        });
+                      } else {
+                        successStreak++;
+                        if (successStreak >= adaptiveSuccessStreakForRampUp) {
+                          successStreak = 0;
+                          effectiveBatchSize = Math.min(
+                            adaptiveMaxBatchSize,
+                            effectiveBatchSize + adaptiveBatchSizeStep,
+                          );
+                          effectiveDelayMs = Math.max(adaptiveMinDelayMs, effectiveDelayMs - adaptiveDelayStepMs);
+                        }
+                      }
+                      if (previousBatchSize !== effectiveBatchSize || previousDelayMs !== effectiveDelayMs) {
+                        adaptiveAdjustments.push({
+                          reason: hadPressure ? "pressure" : "ramp-up",
+                          previousBatchSize,
+                          previousDelayMs,
+                          batchSize: effectiveBatchSize,
+                          delayMs: effectiveDelayMs,
+                          batchPressureSignals,
+                          batchRateLimited,
+                          batchTransientFailures,
+                          batchStoreFailures,
+                          batchEmbedFailures,
+                          retryAfterMs: batchRetryAfterMs,
+                          batchNumber,
+                        });
+                      }
+                    }
+                    offset += batch.length;
+                    if (adaptiveCatchUp && offset < candidates.length && !providerCircuitBreak) {
+                      await sleep(effectiveDelayMs);
+                    }
                   }
                 });
               },
               {
                 progressSupplier: () =>
-                  `stage=embed-and-store; processed=${processed}/${candidates.length}; embedded=${embedded}; skipped=${skipped}; embedFailures=${embedFailures}; storeFailures=${storeFailures}; batch=${batchNumber}/${totalBatches}`,
+                  `stage=embed-and-store; processed=${processed}/${candidates.length}; remaining=${Math.max(0, candidates.length - processed)}; embedded=${embedded}; skipped=${skipped}; embedFailures=${embedFailures}; storeFailures=${storeFailures}; batch=${batchNumber}; batchSize=${effectiveBatchSize}; delayMs=${effectiveDelayMs}`,
                 jsonMode: opts?.json === true,
               },
             );
           }
           const after = opts?.apply ? factsDb.countVectorlessActiveFacts(opts?.source) : before;
+          const durationMs = Date.now() - startedAtMs;
           const report: Record<string, unknown> = {
             apply: opts?.apply === true,
             source: opts?.source ?? null,
             before,
+            candidates: candidates.length,
             considered: candidates.length,
             embedded,
             skipped,
@@ -826,8 +1002,32 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
             errors,
             after,
             processed,
+            remaining: after,
+            durationMs,
             aborted,
           };
+          if (adaptiveCatchUp) {
+            report.adaptive = {
+              enabled: true,
+              baselineBatchSize,
+              baselineDelayMs,
+              effectiveBatchSize,
+              effectiveDelayMs,
+              adjustments: adaptiveAdjustments,
+            };
+          }
+          const globalVectorlessAfter = opts?.apply ? factsDb.countVectorlessActiveFacts() : globalVectorlessBefore;
+          report.vectorSloRepair = buildVectorlessSloRepairRecommendation({
+            activeFacts: factsDb.getCount(),
+            vectorlessBefore: globalVectorlessBefore,
+            vectorlessAfter: globalVectorlessAfter,
+            embeddedThisRun: embedded,
+            runLimit: limit,
+            effectiveBatchSize: adaptiveCatchUp ? effectiveBatchSize : batchSize,
+            scopedSource: opts?.source,
+            scopedVectorlessBefore: opts?.source ? before : undefined,
+            scopedVectorlessAfter: opts?.source ? after : undefined,
+          });
           if (providerCircuitBreak) {
             report.failedReason =
               providerCircuitBreakCause === "provider_5xx"
@@ -842,7 +1042,16 @@ export function registerManageStorageMaintenance(mem: Chainable, b: ManageBindin
             return;
           }
           console.log(
-            `Reembed vectorless ${report.apply ? "applied" : "dry-run"}: before ${before}, candidates ${candidates.length}, embedded ${embedded}, skipped ${skipped}, storeFailures ${storeFailures}, after ${after}`,
+            `Reembed vectorless ${report.apply ? "applied" : "dry-run"}: before ${before}, candidates ${candidates.length}, embedded ${embedded}, skipped ${skipped}, storeFailures ${storeFailures}, after ${after}, remaining ${after}, durationMs ${durationMs}`,
+          );
+          if (adaptiveCatchUp) {
+            console.log(
+              `Adaptive pacing: batchSize ${baselineBatchSize}->${effectiveBatchSize}, delayMs ${baselineDelayMs}->${effectiveDelayMs}, adjustments ${adaptiveAdjustments.length}`,
+            );
+          }
+          const slo = report.vectorSloRepair as ReturnType<typeof buildVectorlessSloRepairRecommendation>;
+          console.log(
+            `Vectorless SLO repair: ratio ${(slo.vectorlessRatioAfter * 100).toFixed(2)}% (target ${(slo.targetVectorlessRatio * 100).toFixed(0)}%), clear ${slo.vectorlessToClearForSlo} more, ~${slo.estimatedRunsToReachSlo} run(s) at limit ${slo.recommendedLimitNextRun} batch ${slo.recommendedBatchSizeNextRun}`,
           );
           if (candidates.length > 0 && !opts?.apply) {
             console.log("Examples:");

package/cli/commands/manage/storage-stats-helpers.ts

@@ -81,6 +81,17 @@ export function parseBoundedFloatOption(raw: unknown, fallback: number, min: num
   return Math.max(min, Math.min(max, value));
 }
 
+function formatRatioPercent(value: number): string {
+  return `${(value * 100).toFixed(2)}%`;
+}
+
+function formatVectorLifecycleSloBreach(breach: AuditHealthReport["vectorLifecycleSlo"]["breaches"][number]): string {
+  if (breach.key === "vectorless_ratio") {
+    return `${breach.key} actual=${breach.actual} (${formatRatioPercent(breach.actual)}) target=${breach.target} (${formatRatioPercent(breach.target)})`;
+  }
+  return `${breach.key} actual=${breach.actual} target=${breach.target}`;
+}
+
 type SyncBundleFile = {
   path: string;
   contentBase64: string;
@@ -786,7 +797,7 @@ export function buildAuditHealthReport(
     );
   if (vectorLifecycleSloBreaches.length > 0)
     warnings.push(
-      `Vector lifecycle SLO breach(es): ${vectorLifecycleSloBreaches.map((b) => `${b.key} actual=${b.actual} target=${b.target}`).join("; ")}`,
+      `Vector lifecycle SLO breach(es): ${vectorLifecycleSloBreaches.map(formatVectorLifecycleSloBreach).join("; ")}`,
     );
   if (procedureTriage.summary.total > 0) {
     const reasonBreakdown = Object.entries(procedureTriage.summary.byReason)
@@ -941,7 +952,7 @@ export function printAuditHealthMarkdown(report: AuditHealthReport): void {
   }
   if (report.vectorLifecycleSlo.breaches.length > 0) {
     console.log(
-      `Vector lifecycle SLO breaches: ${report.vectorLifecycleSlo.breaches.map((b) => `${b.key} actual=${b.actual} target=${b.target}`).join(", ")}`,
+      `Vector lifecycle SLO breaches: ${report.vectorLifecycleSlo.breaches.map(formatVectorLifecycleSloBreach).join(", ")}`,
     );
   }
   if (report.vectorlessBySource.length > 0) {

package/cli/context.ts

@@ -152,26 +152,16 @@ export type ManageContext = {
     model?: string;
     all?: boolean;
     verbose?: boolean;
+    adaptiveCatchUp?: boolean;
+    batchSize?: number;
+    batchDelayMs?: number;
+    timeBudgetSec?: number;
+    targetDurationSec?: number;
+    maxConcurrency?: number;
+    providerPressureBudget?: number;
     onProgress?: (progress: import("../services/entity-enrichment-cli.js").EntityEnrichmentProgress) => void;
-  }) => Promise<{
-    pending: number;
-    pendingTotal?: number;
-    pendingByTier?: { hot: number; warm: number; structural: number; cold: number; unknown: number };
-    processed: number;
-    factsEnriched: number;
-    mode?: "bounded" | "all";
-    effectiveLimit?: number | "all";
-    remainingTotal?: number;
-    estimatedRunsRemaining?: number;
-    mentions: number;
-    accepted: number;
-    rejected: number;
-    duplicates: number;
-    rejectReasons: Record<string, number>;
-    skipped?: boolean;
-    pendingFactIds?: string[];
-    enrichedFacts?: import("../services/entity-enrichment-cli.js").EntityEnrichmentVerboseFact[];
-  }>;
+    onAdaptivePacing?: (state: import("../services/entity-enrichment-cli.js").EntityEnrichmentAdaptivePacing) => void;
+  }) => Promise<import("../services/entity-enrichment-cli.js").EntityEnrichmentCliResult>;
   runResolveContradictions: () => Promise<{
     autoResolved: Array<{ contradictionId: string; factIdNew: string; factIdOld: string }>;
     ambiguous: Array<{ contradictionId: string; factIdNew: string; factIdOld: string }>;

package/cli/distill.ts

@@ -68,6 +68,15 @@ export type DistillContext = {
     rejected?: number;
     partial?: boolean;
     dedupeDegraded?: boolean;
+    directiveDedupeMode?: "vector" | "lexical-only" | "mixed";
+    directiveRejected?: {
+      permanent: number;
+      retryable: number;
+      parserOrModelFailure: number;
+      boundedPartialRetry: number;
+    };
+    cursorAdvanced?: boolean;
+    cursorBlockedReason?: "retryable_rejections" | "parser_or_model_failure" | "bounded_partial_retry";
     skipped?: boolean;
   }>;
   runExtractReinforcement: (opts: {
@@ -386,12 +395,26 @@ export function registerDistillCommands(mem: Chainable, ctx: DistillContext): vo
             if ((result.rejected ?? 0) > 0) {
               console.log(`Rejected ${result.rejected} non-durable/untrusted directive candidate(s).`);
             }
+            if (result.directiveRejected) {
+              console.log(
+                `Status: directiveRejected=permanent:${result.directiveRejected.permanent},retryable:${result.directiveRejected.retryable},parserOrModelFailure:${result.directiveRejected.parserOrModelFailure},boundedPartialRetry:${result.directiveRejected.boundedPartialRetry}`,
+              );
+            }
             if (result.partial) {
-              console.log("Status: partial (rejections detected; cursor not advanced).");
+              console.log("Status: partial (retryable rejections detected; cursor not advanced).");
             }
             if (result.dedupeDegraded) {
               console.log("Status: degraded dedupe (lexical-only fallback used).");
             }
+            if (result.directiveDedupeMode) {
+              console.log(`Status: directiveDedupeMode=${result.directiveDedupeMode}`);
+            }
+            if (typeof result.cursorAdvanced === "boolean") {
+              console.log(`Status: cursorAdvanced=${result.cursorAdvanced}`);
+            }
+            if (result.cursorBlockedReason) {
+              console.log(`Status: cursorBlockedReason=${result.cursorBlockedReason}`);
+            }
           }
         },
       ),
@@ -440,6 +463,13 @@ export function registerDistillCommands(mem: Chainable, ctx: DistillContext): vo
               const status = result.annotationStatus;
               if (status) {
                 console.log(`Annotation status: ${status}`);
+                if (result.annotationDiagnostic) {
+                  const diagnostic = result.annotationDiagnostic;
+                  console.log(`Annotation diagnostic: ${diagnostic.kind} — ${diagnostic.summary}`);
+                  for (const action of diagnostic.recommendedActions) {
+                    console.log(`  next: ${action}`);
+                  }
+                }
                 if (status === "failed_annotation" || status === "degraded_model_or_parser") {
                   process.exitCode = 1;
                 }

package/cli/register.ts

@@ -17,7 +17,7 @@ import { PLUGIN_ID } from "../utils/constants.js";
 import { type ActiveTaskContext, registerActiveTaskCommands } from "./active-tasks.js";
 import { registerBenchmarkCommands } from "./benchmark.js";
 import { registerStatusCommands } from "./cmd-status.js";
-import { type UserFriendlyContext, registerUserFriendlyCommands } from "./cmd-user-friendly.js";
+import { registerUserFriendlyCommands, type UserFriendlyContext } from "./cmd-user-friendly.js";
 import { type DistillContext, registerDistillCommands } from "./distill.js";
 import { registerGoalCommands } from "./goals.js";
 import { type ManageContext, registerManageCommands } from "./manage.js";
@@ -52,37 +52,37 @@ import type {
   VerifyCliSink,
 } from "./types.js";
 import { registerVerifiedCommands } from "./verified.js";
-import { type VerifyContext, registerVerifyCommands } from "./verify.js";
+import { registerVerifyCommands, type VerifyContext } from "./verify.js";
 
 export type {
-  FindDuplicatesResult,
-  StoreCliOpts,
-  StoreCliResult,
-  InstallCliResult,
-  VerifyCliSink,
+  ActiveTaskContext,
+  AnalyzeFeedbackPhrasesResult,
+  BackfillCliResult,
+  BackfillCliSink,
+  ConfigCliResult,
+  CredentialsAuditResult,
+  CredentialsPruneResult,
+  DistillCliResult,
+  DistillCliSink,
   DistillWindowResult,
-  RecordDistillResult,
   ExtractDailyResult,
   ExtractDailySink,
   ExtractProceduresResult,
+  FindDuplicatesResult,
   GenerateAutoSkillsResult,
-  BackfillCliResult,
-  BackfillCliSink,
   IngestFilesResult,
   IngestFilesSink,
-  DistillCliResult,
-  DistillCliSink,
+  InstallCliResult,
+  MigrateToVaultResult,
+  RecordDistillResult,
   SelfCorrectionExtractResult,
   SelfCorrectionRunResult,
-  AnalyzeFeedbackPhrasesResult,
-  MigrateToVaultResult,
-  CredentialsAuditResult,
-  CredentialsPruneResult,
-  UpgradeCliResult,
+  StoreCliOpts,
+  StoreCliResult,
   UninstallCliResult,
-  ConfigCliResult,
+  UpgradeCliResult,
+  VerifyCliSink,
 };
-export type { ActiveTaskContext };
 
 export type HybridMemCliContext = {
   factsDb: FactsDB;
@@ -293,26 +293,16 @@ export type HybridMemCliContext = {
     model?: string;
     verbose?: boolean;
     all?: boolean;
+    adaptiveCatchUp?: boolean;
+    batchSize?: number;
+    batchDelayMs?: number;
+    timeBudgetSec?: number;
+    targetDurationSec?: number;
+    maxConcurrency?: number;
+    providerPressureBudget?: number;
     onProgress?: (progress: import("../services/entity-enrichment-cli.js").EntityEnrichmentProgress) => void;
-  }) => Promise<{
-    pending: number;
-    pendingTotal?: number;
-    pendingByTier?: { hot: number; warm: number; structural: number; cold: number; unknown: number };
-    processed: number;
-    factsEnriched: number;
-    mode?: "bounded" | "all";
-    effectiveLimit?: number | "all";
-    remainingTotal?: number;
-    estimatedRunsRemaining?: number;
-    mentions: number;
-    accepted: number;
-    rejected: number;
-    duplicates: number;
-    rejectReasons: Record<string, number>;
-    skipped?: boolean;
-    pendingFactIds?: string[];
-    enrichedFacts?: import("../services/entity-enrichment-cli.js").EntityEnrichmentVerboseFact[];
-  }>;
+    onAdaptivePacing?: (state: import("../services/entity-enrichment-cli.js").EntityEnrichmentAdaptivePacing) => void;
+  }) => Promise<import("../services/entity-enrichment-cli.js").EntityEnrichmentCliResult>;
   runSelfCorrectionExtract: (opts: {
     days?: number;
     outputPath?: string;

package/dist/api/plugin-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-runtime.js","names":[],"sources":["../../api/plugin-runtime.ts"],"sourcesContent":["/**\n * PluginRuntime: instance-scoped container for all mutable plugin state.\n *\n * Replaces module-level `let` variables in index.ts to enable:\n *  - Independent plugin instances in the same process (testability)\n *  - Clearer ownership of runtime state\n *  - Explicit context passing to tools and lifecycle hooks\n *\n * A single module-level `const runtimeRef: { value: PluginRuntime | null }` holds the\n * active instance.  Closures (tools, timers, event handlers) capture `runtimeRef` by\n * reference; when register() creates a fresh PluginRuntime after a SIGUSR1 reload the\n * closures automatically see the new instance through `runtimeRef.value`.\n */\n\nimport type OpenAI from \"openai\";\nimport type { AgentHealthStore } from \"../backends/agent-health-store.js\";\nimport type { ApitapStore } from \"../backends/apitap-store.js\";\nimport type { AuditStore } from \"../backends/audit-store.js\";\nimport type { CostTracker } from \"../backends/cost-tracker.js\";\nimport type { CredentialsDB } from \"../backends/credentials-db.js\";\nimport type { CrystallizationStore } from \"../backends/crystallization-store.js\";\nimport type { EdictStore } from \"../backends/edict-store.js\";\nimport type { EventBus } from \"../backends/event-bus.js\";\nimport type { EventLog } from \"../backends/event-log.js\";\nimport type { FactsDB } from \"../backends/facts-db.js\";\nimport type { IdentityReflectionStore } from \"../backends/identity-reflection-store.js\";\nimport type { IssueStore } from \"../backends/issue-store.js\";\nimport type { LearningsDB } from \"../backends/learnings-db.js\";\nimport type { NarrativesDB } from \"../backends/narratives-db.js\";\nimport type { PersonaStateStore } from \"../backends/persona-state-store.js\";\nimport type { ProposalsDB } from \"../backends/proposals-db.js\";\nimport type { ToolProposalStore } from \"../backends/tool-proposal-store.js\";\nimport type { VectorDB } from \"../backends/vector-db.js\";\nimport type { WriteAheadLog } from \"../backends/wal.js\";\nimport type { WorkflowStore } from \"../backends/workflow-store.js\";\nimport type { HybridMemoryConfig } from \"../config.js\";\nimport type { PendingLLMWarnings } from \"../services/chat.js\";\nimport type { VariantGenerationQueue } from \"../services/contextual-variants.js\";\nimport type { EmbeddingRegistry } from \"../services/embedding-registry.js\";\nimport type { EmbeddingProvider } from \"../services/embeddings.js\";\nimport type { ProvenanceService } from \"../services/provenance.js\";\nimport type { PythonBridge } from \"../services/python-bridge.js\";\nimport type { AliasDB } from \"../services/retrieval-aliases.js\";\nimport type { VerificationStore } from \"../services/verification-store.js\";\nimport type { LifecycleHooksHandle } from \"../setup/register-hooks.js\";\nimport type { ToolRegistrationHandle } from \"../setup/register-tools.js\";\n\n/** All mutable per-instance state for the memory-hybrid plugin. */\nexport interface PluginRuntime {\n  // --- Config & resolved paths ---\n  cfg: HybridMemoryConfig;\n  resolvedLancePath: string;\n  resolvedSqlitePath: string;\n\n  // --- Core backends (always present after init) ---\n  factsDb: FactsDB;\n  edictStore: EdictStore;\n  vectorDb: VectorDB;\n  embeddings: EmbeddingProvider;\n  embeddingRegistry: EmbeddingRegistry;\n  openai: OpenAI;\n\n  // --- Optional backends (null when feature disabled) ---\n  credentialsDb: CredentialsDB | null;\n  wal: WriteAheadLog | null;\n  proposalsDb: ProposalsDB | null;\n  identityReflectionStore: IdentityReflectionStore | null;\n  personaStateStore: PersonaStateStore | null;\n  eventLog: EventLog | null;\n  narrativesDb: NarrativesDB | null;\n  aliasDb: AliasDB | null;\n  eventBus: EventBus | null;\n  costTracker: CostTracker | null;\n  issueStore: IssueStore | null;\n  workflowStore: WorkflowStore | null;\n  crystallizationStore: CrystallizationStore | null;\n  toolProposalStore: ToolProposalStore | null;\n  provenanceService: ProvenanceService | null;\n  verificationStore: VerificationStore | null;\n  apitapStore: ApitapStore | null;\n  pythonBridge: PythonBridge | null;\n  variantQueue: VariantGenerationQueue | null;\n  /** Staged intake buffer for errors, lessons, and feature requests (Issue #617). */\n  learningsDb: LearningsDB | null;\n  /** Cross-agent audit log (Issue #790). */\n  auditStore: AuditStore | null;\n  agentHealthStore: AgentHealthStore | null;\n\n  // --- Lifecycle state ---\n  /** Handle returned by registerLifecycleHooks; set after hooks are registered, null until then. */\n  lifecycleHooksHandle: LifecycleHooksHandle | null;\n  /** Handle returned by registerTools; set after tool registration, null until then. */\n  toolRegistrationHandle: ToolRegistrationHandle | null;\n  /**\n   * Resolves when async bootstrap work from `initializeDatabases` finishes (embedding/vault checks, etc.).\n   * Used to sequence CLI teardown so we do not close DBs while init I/O is still running (Issue #1039).\n   */\n  bootstrapAsyncInit: Promise<void>;\n  /** Tracks whether bootstrapAsyncInit has settled (used by re-register reuse policy). */\n  bootstrapSettledRef?: { value: boolean };\n  /** Last bootstrap health snapshot from initializeDatabases() for reuse-databases policy. */\n  bootstrapHealth?: {\n    embeddingsOk: boolean;\n    credentialsVaultOk: boolean;\n    lastCheckTime: number;\n  };\n  pendingLLMWarnings: PendingLLMWarnings;\n\n  // --- Mutable refs (objects so that closures can share mutations) ---\n  /** Detected agent for current session; updated on before_agent_start. */\n  currentAgentIdRef: { value: string | null };\n  /** Set to true once the restart-pending flag has been cleared this session. */\n  restartPendingClearedRef: { value: boolean };\n  /** Count of in-flight recall operations (degradation / back-pressure). */\n  recallInFlightRef: { value: number };\n  /** Last user prompt used for interactive auto-recall (issue #957 post-compaction reinjection). */\n  lastAutoRecallPromptRef: { value: string | null };\n  /** Last progressive index fact IDs (1-based position → fact id). */\n  lastProgressiveIndexIds: string[];\n\n  // --- Timer refs (objects so they can be passed by reference to plugin-service) ---\n  timers: {\n    pruneTimer: { value: ReturnType<typeof setInterval> | null };\n    classifyTimer: { value: ReturnType<typeof setInterval> | null };\n    classifyStartupTimeout: { value: ReturnType<typeof setTimeout> | null };\n    proposalsPruneTimer: { value: ReturnType<typeof setInterval> | null };\n    languageKeywordsTimer: { value: ReturnType<typeof setInterval> | null };\n    languageKeywordsStartupTimeout: { value: ReturnType<typeof setTimeout> | null };\n    postUpgradeTimeout: { value: ReturnType<typeof setTimeout> | null };\n    passiveObserverTimer: { value: ReturnType<typeof setInterval> | null };\n    /** Issue #631: Stale-run watchdog timer for autonomous task queue self-healing. */\n    watchdogTimer: { value: ReturnType<typeof setInterval> | null };\n  };\n}\n\n/** Create a fresh, empty timers bag for a new PluginRuntime instance. */\nexport function createTimers(): PluginRuntime[\"timers\"] {\n  return {\n    pruneTimer: { value: null },\n    classifyTimer: { value: null },\n    classifyStartupTimeout: { value: null },\n    proposalsPruneTimer: { value: null },\n    languageKeywordsTimer: { value: null },\n    languageKeywordsStartupTimeout: { value: null },\n    postUpgradeTimeout: { value: null },\n    passiveObserverTimer: { value: null },\n    watchdogTimer: { value: null },\n  };\n}\n\n/**\n * Clear all runtime timer handles and reset refs.\n * Shared by CLI teardown and hot-reload cleanup paths.\n */\nexport function clearRuntimeTimers(timers: PluginRuntime[\"timers\"]): void {\n  if (timers.pruneTimer.value) {\n    clearInterval(timers.pruneTimer.value);\n    timers.pruneTimer.value = null;\n  }\n  if (timers.classifyTimer.value) {\n    clearInterval(timers.classifyTimer.value);\n    timers.classifyTimer.value = null;\n  }\n  if (timers.classifyStartupTimeout.value) {\n    clearTimeout(timers.classifyStartupTimeout.value);\n    timers.classifyStartupTimeout.value = null;\n  }\n  if (timers.proposalsPruneTimer.value) {\n    clearInterval(timers.proposalsPruneTimer.value);\n    timers.proposalsPruneTimer.value = null;\n  }\n  if (timers.languageKeywordsTimer.value) {\n    clearInterval(timers.languageKeywordsTimer.value);\n    timers.languageKeywordsTimer.value = null;\n  }\n  if (timers.languageKeywordsStartupTimeout.value) {\n    clearTimeout(timers.languageKeywordsStartupTimeout.value);\n    timers.languageKeywordsStartupTimeout.value = null;\n  }\n  if (timers.postUpgradeTimeout.value) {\n    clearTimeout(timers.postUpgradeTimeout.value);\n    timers.postUpgradeTimeout.value = null;\n  }\n  if (timers.passiveObserverTimer.value) {\n    clearInterval(timers.passiveObserverTimer.value);\n    timers.passiveObserverTimer.value = null;\n  }\n  if (timers.watchdogTimer.value) {\n    clearInterval(timers.watchdogTimer.value);\n    timers.watchdogTimer.value = null;\n  }\n}\n"],"mappings":";;AAwIA,SAAgB,eAAwC;CACtD,OAAO;EACL,YAAY,EAAE,OAAO,MAAM;EAC3B,eAAe,EAAE,OAAO,MAAM;EAC9B,wBAAwB,EAAE,OAAO,MAAM;EACvC,qBAAqB,EAAE,OAAO,MAAM;EACpC,uBAAuB,EAAE,OAAO,MAAM;EACtC,gCAAgC,EAAE,OAAO,MAAM;EAC/C,oBAAoB,EAAE,OAAO,MAAM;EACnC,sBAAsB,EAAE,OAAO,MAAM;EACrC,eAAe,EAAE,OAAO,MAAM;EAC/B;;;;;;AAOH,SAAgB,mBAAmB,QAAuC;CACxE,IAAI,OAAO,WAAW,OAAO;EAC3B,cAAc,OAAO,WAAW,MAAM;EACtC,OAAO,WAAW,QAAQ;;CAE5B,IAAI,OAAO,cAAc,OAAO;EAC9B,cAAc,OAAO,cAAc,MAAM;EACzC,OAAO,cAAc,QAAQ;;CAE/B,IAAI,OAAO,uBAAuB,OAAO;EACvC,aAAa,OAAO,uBAAuB,MAAM;EACjD,OAAO,uBAAuB,QAAQ;;CAExC,IAAI,OAAO,oBAAoB,OAAO;EACpC,cAAc,OAAO,oBAAoB,MAAM;EAC/C,OAAO,oBAAoB,QAAQ;;CAErC,IAAI,OAAO,sBAAsB,OAAO;EACtC,cAAc,OAAO,sBAAsB,MAAM;EACjD,OAAO,sBAAsB,QAAQ;;CAEvC,IAAI,OAAO,+BAA+B,OAAO;EAC/C,aAAa,OAAO,+BAA+B,MAAM;EACzD,OAAO,+BAA+B,QAAQ;;CAEhD,IAAI,OAAO,mBAAmB,OAAO;EACnC,aAAa,OAAO,mBAAmB,MAAM;EAC7C,OAAO,mBAAmB,QAAQ;;CAEpC,IAAI,OAAO,qBAAqB,OAAO;EACrC,cAAc,OAAO,qBAAqB,MAAM;EAChD,OAAO,qBAAqB,QAAQ;;CAEtC,IAAI,OAAO,cAAc,OAAO;EAC9B,cAAc,OAAO,cAAc,MAAM;EACzC,OAAO,cAAc,QAAQ"}
+{"version":3,"file":"plugin-runtime.js","names":[],"sources":["../../api/plugin-runtime.ts"],"sourcesContent":["/**\n * PluginRuntime: instance-scoped container for all mutable plugin state.\n *\n * Replaces module-level `let` variables in index.ts to enable:\n *  - Independent plugin instances in the same process (testability)\n *  - Clearer ownership of runtime state\n *  - Explicit context passing to tools and lifecycle hooks\n *\n * A single module-level `const runtimeRef: { value: PluginRuntime | null }` holds the\n * active instance.  Closures (tools, timers, event handlers) capture `runtimeRef` by\n * reference; when register() creates a fresh PluginRuntime after a SIGUSR1 reload the\n * closures automatically see the new instance through `runtimeRef.value`.\n */\n\nimport type OpenAI from \"openai\";\nimport type { AgentHealthStore } from \"../backends/agent-health-store.js\";\nimport type { ApitapStore } from \"../backends/apitap-store.js\";\nimport type { AuditStore } from \"../backends/audit-store.js\";\nimport type { CostTracker } from \"../backends/cost-tracker.js\";\nimport type { CredentialsDB } from \"../backends/credentials-db.js\";\nimport type { CrystallizationStore } from \"../backends/crystallization-store.js\";\nimport type { EdictStore } from \"../backends/edict-store.js\";\nimport type { EventBus } from \"../backends/event-bus.js\";\nimport type { EventLog } from \"../backends/event-log.js\";\nimport type { FactsDB } from \"../backends/facts-db.js\";\nimport type { IdentityReflectionStore } from \"../backends/identity-reflection-store.js\";\nimport type { IssueStore } from \"../backends/issue-store.js\";\nimport type { LearningsDB } from \"../backends/learnings-db.js\";\nimport type { NarrativesDB } from \"../backends/narratives-db.js\";\nimport type { PersonaStateStore } from \"../backends/persona-state-store.js\";\nimport type { ProposalsDB } from \"../backends/proposals-db.js\";\nimport type { ToolProposalStore } from \"../backends/tool-proposal-store.js\";\nimport type { VectorDB } from \"../backends/vector-db.js\";\nimport type { WriteAheadLog } from \"../backends/wal.js\";\nimport type { WorkflowStore } from \"../backends/workflow-store.js\";\nimport type { HybridMemoryConfig } from \"../config.js\";\nimport type { PendingLLMWarnings } from \"../services/chat.js\";\nimport type { VariantGenerationQueue } from \"../services/contextual-variants.js\";\nimport type { EmbeddingRegistry } from \"../services/embedding-registry.js\";\nimport type { EmbeddingProvider } from \"../services/embeddings.js\";\nimport type { ProvenanceService } from \"../services/provenance.js\";\nimport type { PythonBridge } from \"../services/python-bridge.js\";\nimport type { AliasDB } from \"../services/retrieval-aliases.js\";\nimport type { VerificationStore } from \"../services/verification-store.js\";\nimport type { LifecycleHooksHandle } from \"../setup/register-hooks.js\";\nimport type { ToolRegistrationHandle } from \"../setup/register-tools.js\";\n\n/** All mutable per-instance state for the memory-hybrid plugin. */\nexport interface PluginRuntime {\n  // --- Config & resolved paths ---\n  cfg: HybridMemoryConfig;\n  /** Parse-time config snapshot for hot-reload reuse checks (bootstrap may mutate `cfg`). */\n  parsedCfgSnapshot: HybridMemoryConfig;\n  resolvedLancePath: string;\n  resolvedSqlitePath: string;\n\n  // --- Core backends (always present after init) ---\n  factsDb: FactsDB;\n  edictStore: EdictStore;\n  vectorDb: VectorDB;\n  embeddings: EmbeddingProvider;\n  embeddingRegistry: EmbeddingRegistry;\n  openai: OpenAI;\n\n  // --- Optional backends (null when feature disabled) ---\n  credentialsDb: CredentialsDB | null;\n  wal: WriteAheadLog | null;\n  proposalsDb: ProposalsDB | null;\n  identityReflectionStore: IdentityReflectionStore | null;\n  personaStateStore: PersonaStateStore | null;\n  eventLog: EventLog | null;\n  narrativesDb: NarrativesDB | null;\n  aliasDb: AliasDB | null;\n  eventBus: EventBus | null;\n  costTracker: CostTracker | null;\n  issueStore: IssueStore | null;\n  workflowStore: WorkflowStore | null;\n  crystallizationStore: CrystallizationStore | null;\n  toolProposalStore: ToolProposalStore | null;\n  provenanceService: ProvenanceService | null;\n  verificationStore: VerificationStore | null;\n  apitapStore: ApitapStore | null;\n  pythonBridge: PythonBridge | null;\n  variantQueue: VariantGenerationQueue | null;\n  /** Staged intake buffer for errors, lessons, and feature requests (Issue #617). */\n  learningsDb: LearningsDB | null;\n  /** Cross-agent audit log (Issue #790). */\n  auditStore: AuditStore | null;\n  agentHealthStore: AgentHealthStore | null;\n\n  // --- Lifecycle state ---\n  /** Handle returned by registerLifecycleHooks; set after hooks are registered, null until then. */\n  lifecycleHooksHandle: LifecycleHooksHandle | null;\n  /** Handle returned by registerTools; set after tool registration, null until then. */\n  toolRegistrationHandle: ToolRegistrationHandle | null;\n  /**\n   * Resolves when async bootstrap work from `initializeDatabases` finishes (embedding/vault checks, etc.).\n   * Used to sequence CLI teardown so we do not close DBs while init I/O is still running (Issue #1039).\n   */\n  bootstrapAsyncInit: Promise<void>;\n  /** Tracks whether bootstrapAsyncInit has settled (used by re-register reuse policy). */\n  bootstrapSettledRef?: { value: boolean };\n  /** Last bootstrap health snapshot from initializeDatabases() for reuse-databases policy. */\n  bootstrapHealth?: {\n    embeddingsOk: boolean;\n    credentialsVaultOk: boolean;\n    lastCheckTime: number;\n  };\n  pendingLLMWarnings: PendingLLMWarnings;\n\n  // --- Mutable refs (objects so that closures can share mutations) ---\n  /** Detected agent for current session; updated on before_agent_start. */\n  currentAgentIdRef: { value: string | null };\n  /** Set to true once the restart-pending flag has been cleared this session. */\n  restartPendingClearedRef: { value: boolean };\n  /** Count of in-flight recall operations (degradation / back-pressure). */\n  recallInFlightRef: { value: number };\n  /** Last user prompt used for interactive auto-recall (issue #957 post-compaction reinjection). */\n  lastAutoRecallPromptRef: { value: string | null };\n  /** Last progressive index fact IDs (1-based position → fact id). */\n  lastProgressiveIndexIds: string[];\n\n  // --- Timer refs (objects so they can be passed by reference to plugin-service) ---\n  timers: {\n    pruneTimer: { value: ReturnType<typeof setInterval> | null };\n    classifyTimer: { value: ReturnType<typeof setInterval> | null };\n    classifyStartupTimeout: { value: ReturnType<typeof setTimeout> | null };\n    proposalsPruneTimer: { value: ReturnType<typeof setInterval> | null };\n    languageKeywordsTimer: { value: ReturnType<typeof setInterval> | null };\n    languageKeywordsStartupTimeout: { value: ReturnType<typeof setTimeout> | null };\n    postUpgradeTimeout: { value: ReturnType<typeof setTimeout> | null };\n    passiveObserverTimer: { value: ReturnType<typeof setInterval> | null };\n    /** Issue #631: Stale-run watchdog timer for autonomous task queue self-healing. */\n    watchdogTimer: { value: ReturnType<typeof setInterval> | null };\n  };\n}\n\n/** Create a fresh, empty timers bag for a new PluginRuntime instance. */\nexport function createTimers(): PluginRuntime[\"timers\"] {\n  return {\n    pruneTimer: { value: null },\n    classifyTimer: { value: null },\n    classifyStartupTimeout: { value: null },\n    proposalsPruneTimer: { value: null },\n    languageKeywordsTimer: { value: null },\n    languageKeywordsStartupTimeout: { value: null },\n    postUpgradeTimeout: { value: null },\n    passiveObserverTimer: { value: null },\n    watchdogTimer: { value: null },\n  };\n}\n\n/**\n * Clear all runtime timer handles and reset refs.\n * Shared by CLI teardown and hot-reload cleanup paths.\n */\nexport function clearRuntimeTimers(timers: PluginRuntime[\"timers\"]): void {\n  if (timers.pruneTimer.value) {\n    clearInterval(timers.pruneTimer.value);\n    timers.pruneTimer.value = null;\n  }\n  if (timers.classifyTimer.value) {\n    clearInterval(timers.classifyTimer.value);\n    timers.classifyTimer.value = null;\n  }\n  if (timers.classifyStartupTimeout.value) {\n    clearTimeout(timers.classifyStartupTimeout.value);\n    timers.classifyStartupTimeout.value = null;\n  }\n  if (timers.proposalsPruneTimer.value) {\n    clearInterval(timers.proposalsPruneTimer.value);\n    timers.proposalsPruneTimer.value = null;\n  }\n  if (timers.languageKeywordsTimer.value) {\n    clearInterval(timers.languageKeywordsTimer.value);\n    timers.languageKeywordsTimer.value = null;\n  }\n  if (timers.languageKeywordsStartupTimeout.value) {\n    clearTimeout(timers.languageKeywordsStartupTimeout.value);\n    timers.languageKeywordsStartupTimeout.value = null;\n  }\n  if (timers.postUpgradeTimeout.value) {\n    clearTimeout(timers.postUpgradeTimeout.value);\n    timers.postUpgradeTimeout.value = null;\n  }\n  if (timers.passiveObserverTimer.value) {\n    clearInterval(timers.passiveObserverTimer.value);\n    timers.passiveObserverTimer.value = null;\n  }\n  if (timers.watchdogTimer.value) {\n    clearInterval(timers.watchdogTimer.value);\n    timers.watchdogTimer.value = null;\n  }\n}\n"],"mappings":";;AA0IA,SAAgB,eAAwC;CACtD,OAAO;EACL,YAAY,EAAE,OAAO,KAAK;EAC1B,eAAe,EAAE,OAAO,KAAK;EAC7B,wBAAwB,EAAE,OAAO,KAAK;EACtC,qBAAqB,EAAE,OAAO,KAAK;EACnC,uBAAuB,EAAE,OAAO,KAAK;EACrC,gCAAgC,EAAE,OAAO,KAAK;EAC9C,oBAAoB,EAAE,OAAO,KAAK;EAClC,sBAAsB,EAAE,OAAO,KAAK;EACpC,eAAe,EAAE,OAAO,KAAK;CAC/B;AACF;;;;;AAMA,SAAgB,mBAAmB,QAAuC;CACxE,IAAI,OAAO,WAAW,OAAO;EAC3B,cAAc,OAAO,WAAW,KAAK;EACrC,OAAO,WAAW,QAAQ;CAC5B;CACA,IAAI,OAAO,cAAc,OAAO;EAC9B,cAAc,OAAO,cAAc,KAAK;EACxC,OAAO,cAAc,QAAQ;CAC/B;CACA,IAAI,OAAO,uBAAuB,OAAO;EACvC,aAAa,OAAO,uBAAuB,KAAK;EAChD,OAAO,uBAAuB,QAAQ;CACxC;CACA,IAAI,OAAO,oBAAoB,OAAO;EACpC,cAAc,OAAO,oBAAoB,KAAK;EAC9C,OAAO,oBAAoB,QAAQ;CACrC;CACA,IAAI,OAAO,sBAAsB,OAAO;EACtC,cAAc,OAAO,sBAAsB,KAAK;EAChD,OAAO,sBAAsB,QAAQ;CACvC;CACA,IAAI,OAAO,+BAA+B,OAAO;EAC/C,aAAa,OAAO,+BAA+B,KAAK;EACxD,OAAO,+BAA+B,QAAQ;CAChD;CACA,IAAI,OAAO,mBAAmB,OAAO;EACnC,aAAa,OAAO,mBAAmB,KAAK;EAC5C,OAAO,mBAAmB,QAAQ;CACpC;CACA,IAAI,OAAO,qBAAqB,OAAO;EACrC,cAAc,OAAO,qBAAqB,KAAK;EAC/C,OAAO,qBAAqB,QAAQ;CACtC;CACA,IAAI,OAAO,cAAc,OAAO;EAC9B,cAAc,OAAO,cAAc,KAAK;EACxC,OAAO,cAAc,QAAQ;CAC/B;AACF"}