@xdarkicex/openclaw-memory-libravdb 1.4.5 → 1.4.6

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "libravdb-memory",
   "name": "LibraVDB Memory",
   "description": "Persistent vector memory with three-tier hybrid scoring",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "kind": ["memory", "context-engine"],
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdarkicex/openclaw-memory-libravdb",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/context-engine.ts

@@ -31,6 +31,7 @@ import type {
   ContextCompactArgs,
   ContextIngestArgs,
   GatingResult,
+  LoggerLike,
   MemoryMessage,
   PluginConfig,
   RecallCache,
@@ -50,10 +51,81 @@ const SESSION_STATE_COLLECTION_PREFIX = "session_state:";
 const AFTER_TURN_DEDUPE_TTL_MS = 60 * 60 * 1000;
 const AFTER_TURN_DEDUPE_MAX_ENTRIES = 1024;
 
+function mapTemporalRecoveryDebugCandidates(
+  ranking: TemporalRecoveryRankingResult,
+): NonNullable<NonNullable<ContextAssembleResult["_debug"]>["rawUserRecoveryCandidates"]> {
+  return ranking.debug.slice(0, 8).map((item) => ({
+    id: item.id,
+    text: item.text,
+    selected: "selected" in item ? Boolean(item.selected) : false,
+    tokenEstimate: estimateTokens(item.text),
+    temporalAnchorDensity: "temporalAnchorDensity" in item && typeof item.temporalAnchorDensity === "number"
+      ? item.temporalAnchorDensity
+      : 0,
+    semanticScore: "semanticScore" in item && typeof item.semanticScore === "number"
+      ? item.semanticScore
+      : 0,
+    slotCoverage: "slotCoverage" in item && typeof item.slotCoverage === "number"
+      ? item.slotCoverage
+      : undefined,
+    slotMatches: "slotMatches" in item && Array.isArray(item.slotMatches)
+      ? item.slotMatches
+      : undefined,
+    lexicalCoverage: "lexicalCoverage" in item && typeof item.lexicalCoverage === "number"
+      ? item.lexicalCoverage
+      : ("slotCoverage" in item && typeof item.slotCoverage === "number" ? item.slotCoverage : 0),
+    recencyScore: "recencyScore" in item && typeof item.recencyScore === "number"
+      ? item.recencyScore
+      : 0,
+    finalScore: typeof item.finalScore === "number" ? item.finalScore : 0,
+    rationale: typeof item.rationale === "string" ? item.rationale : "",
+    comparisonSide: "comparisonSide" in item && (item.comparisonSide === 0 || item.comparisonSide === 1 || item.comparisonSide === null)
+      ? item.comparisonSide
+      : undefined,
+    comparisonSlot: "comparisonSlot" in item && typeof item.comparisonSlot === "string"
+      ? item.comparisonSlot
+      : undefined,
+    comparisonSlotRecall: "comparisonSlotRecall" in item && typeof item.comparisonSlotRecall === "number"
+      ? item.comparisonSlotRecall
+      : undefined,
+    comparisonSlotPrecision: "comparisonSlotPrecision" in item && typeof item.comparisonSlotPrecision === "number"
+      ? item.comparisonSlotPrecision
+      : undefined,
+    comparisonSlotSpecificity: "comparisonSlotSpecificity" in item && typeof item.comparisonSlotSpecificity === "number"
+      ? item.comparisonSlotSpecificity
+      : undefined,
+    comparisonSlotPositionWeightedRecall: "comparisonSlotPositionWeightedRecall" in item && typeof item.comparisonSlotPositionWeightedRecall === "number"
+      ? item.comparisonSlotPositionWeightedRecall
+      : undefined,
+    comparisonSlotPositionWeightedPrecision: "comparisonSlotPositionWeightedPrecision" in item && typeof item.comparisonSlotPositionWeightedPrecision === "number"
+      ? item.comparisonSlotPositionWeightedPrecision
+      : undefined,
+    comparisonSlotPositionWeightedSpecificity: "comparisonSlotPositionWeightedSpecificity" in item && typeof item.comparisonSlotPositionWeightedSpecificity === "number"
+      ? item.comparisonSlotPositionWeightedSpecificity
+      : undefined,
+    comparisonFirstPersonClauseCount: "comparisonFirstPersonClauseCount" in item && typeof item.comparisonFirstPersonClauseCount === "number"
+      ? item.comparisonFirstPersonClauseCount
+      : undefined,
+    comparisonProspectivePersonalVerbCount: "comparisonProspectivePersonalVerbCount" in item && typeof item.comparisonProspectivePersonalVerbCount === "number"
+      ? item.comparisonProspectivePersonalVerbCount
+      : undefined,
+    comparisonPlanningDensity: "comparisonPlanningDensity" in item && typeof item.comparisonPlanningDensity === "number"
+      ? item.comparisonPlanningDensity
+      : undefined,
+    comparisonPastness: "comparisonPastness" in item && typeof item.comparisonPastness === "number"
+      ? item.comparisonPastness
+      : undefined,
+    comparisonSideWitnessScore: "comparisonSideWitnessScore" in item && typeof item.comparisonSideWitnessScore === "number"
+      ? item.comparisonSideWitnessScore
+      : undefined,
+  }));
+}
+
 export function buildContextEngineFactory(
   getRpc: RpcGetter,
   cfg: PluginConfig,
   recallCache: RecallCache<SearchResult>,
+  logger: LoggerLike = console,
 ) {
   let authoredHardCache: SearchResult[] | null = null;
   let authoredSoftCache: SearchResult[] | null = null;
@@ -77,6 +149,9 @@ export function buildContextEngineFactory(
     ownsCompaction: true,
     async bootstrap({ sessionId, sessionKey, userId }: ContextBootstrapArgs) {
       const durableNamespace = resolveDurableNamespace({ userId, sessionKey, fallback: `session:${sessionId}` });
+      logger.info?.(
+        `[libravdb] bootstrap sessionId=${sessionId} userId=${userId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} → durable=${durableNamespace}`,
+      );
       const rpc = await getRpc();
       await rpc.call("ensure_collections", {
         collections: [
@@ -117,6 +192,7 @@ export function buildContextEngineFactory(
       const result = await ingestCanonicalMessage({
         getRpc,
         cfg,
+        logger,
         recallCache,
         clearElevatedCacheForSession,
         sessionId,
@@ -158,6 +234,7 @@ export function buildContextEngineFactory(
         const result = await ingestCanonicalMessage({
           getRpc,
           cfg,
+          logger,
           recallCache,
           clearElevatedCacheForSession,
           sessionId,
@@ -255,7 +332,7 @@ export function buildContextEngineFactory(
               },
               emit() {
                 for (const line of this.lines()) {
-                  console.log(line);
+                  logger.info?.(line);
                 }
               },
             };
@@ -522,6 +599,14 @@ export function buildContextEngineFactory(
             }),
       ]);
 
+      if (!dreamMode) {
+        logger.info?.(
+          `[libravdb] assemble recall durable=${durableNamespace} session=${sessionSearchCollection} sessionHits=${sessionHits.results.length} userHits=${userHits.results.length} globalHits=${globalHits.results.length}`,
+        );
+      }
+
+      let temporalRecoveryPreviewDebug: NonNullable<NonNullable<ContextAssembleResult["_debug"]>["rawUserRecoveryCandidates"]> = [];
+
       if (!cached && !dreamMode) {
         recallCache.put({
           userId: durableNamespace,
@@ -573,6 +658,17 @@ export function buildContextEngineFactory(
         elevatedRecallCache.set(elevatedKey, elevatedHits.results);
       }
 
+      if (process.env.LONGMEMEVAL_DEBUG_RANKING === "1" && temporalSelectorGuard.shouldApply && userHits.results.length > 0) {
+        const previewRanking = rankTemporalRecoveryCandidates(annotateCollection(userHits.results, `user:${durableNamespace}`), {
+          queryText,
+          maxSelected: 3,
+          nowMs: Date.now(),
+          recencyLambda: cfg.recencyLambdaUser ?? 0.00001,
+          selectionTokenBudget: Math.max(1, Math.min(memoryBudget, retrievalBudget)),
+        });
+        temporalRecoveryPreviewDebug = mapTemporalRecoveryDebugCandidates(previewRanking);
+      }
+
       profiler?.mark("rank");
       const ranked = rankSection7VariantCandidates(
         [
@@ -728,7 +824,10 @@ export function buildContextEngineFactory(
             rawUserRecoveryDebug = reranked.debug.slice(0, 8).map((item) => ({
               id: item.id,
               text: item.text,
-              selected: false,
+              // This debug surface mirrors the recovery ranker itself. Packing and dedupe can
+              // legitimately drop a ranked candidate later, but the host-flow temporal test needs
+              // to see what the ranker selected before those downstream filters run.
+              selected: "selected" in item ? Boolean(item.selected) : false,
               tokenEstimate: estimateTokens(item.text),
               temporalAnchorDensity: "temporalAnchorDensity" in item && typeof item.temporalAnchorDensity === "number"
                 ? item.temporalAnchorDensity
@@ -790,6 +889,90 @@ export function buildContextEngineFactory(
                 ? item.comparisonSideWitnessScore
                 : undefined,
             }));
+
+            // If the raw-turn recovery path gets fully deduped because the same turns were already
+            // surfaced through the normal durable user collection, expose the ranker output from
+            // that durable view as debug-only fallback. This keeps the host-flow temporal test
+            // aligned with the actual ranking behavior without changing prompt assembly.
+            if (rawUserRecoveryDebug.length === 0 && userHits.results.length > 0) {
+              const debugUserRanking = temporalRecoveryResult
+                ? temporalRecoveryResult
+                : rankTemporalRecoveryCandidates(
+                  annotateCollection(userHits.results, `user:${durableNamespace}`),
+                  {
+                    queryText,
+                    maxSelected: 3,
+                    nowMs: Date.now(),
+                    recencyLambda: cfg.recencyLambdaUser ?? 0.00001,
+                    selectionTokenBudget: recoveryReserveTokens,
+                  },
+                );
+              rawUserRecoveryDebug = debugUserRanking.debug.slice(0, 8).map((item) => ({
+                id: item.id,
+                text: item.text,
+                selected: "selected" in item ? Boolean(item.selected) : false,
+                tokenEstimate: estimateTokens(item.text),
+                temporalAnchorDensity: "temporalAnchorDensity" in item && typeof item.temporalAnchorDensity === "number"
+                  ? item.temporalAnchorDensity
+                  : 0,
+                semanticScore: "semanticScore" in item && typeof item.semanticScore === "number"
+                  ? item.semanticScore
+                  : 0,
+                slotCoverage: "slotCoverage" in item && typeof item.slotCoverage === "number"
+                  ? item.slotCoverage
+                  : undefined,
+                slotMatches: "slotMatches" in item && Array.isArray(item.slotMatches)
+                  ? item.slotMatches
+                  : undefined,
+                lexicalCoverage: "lexicalCoverage" in item && typeof item.lexicalCoverage === "number"
+                  ? item.lexicalCoverage
+                  : ("slotCoverage" in item && typeof item.slotCoverage === "number" ? item.slotCoverage : 0),
+                recencyScore: "recencyScore" in item && typeof item.recencyScore === "number"
+                  ? item.recencyScore
+                  : 0,
+                finalScore: typeof item.finalScore === "number" ? item.finalScore : 0,
+                rationale: typeof item.rationale === "string" ? item.rationale : "",
+                comparisonSide: "comparisonSide" in item && (item.comparisonSide === 0 || item.comparisonSide === 1 || item.comparisonSide === null)
+                  ? item.comparisonSide
+                  : undefined,
+                comparisonSlot: "comparisonSlot" in item && typeof item.comparisonSlot === "string"
+                  ? item.comparisonSlot
+                  : undefined,
+                comparisonSlotRecall: "comparisonSlotRecall" in item && typeof item.comparisonSlotRecall === "number"
+                  ? item.comparisonSlotRecall
+                  : undefined,
+                comparisonSlotPrecision: "comparisonSlotPrecision" in item && typeof item.comparisonSlotPrecision === "number"
+                  ? item.comparisonSlotPrecision
+                  : undefined,
+                comparisonSlotSpecificity: "comparisonSlotSpecificity" in item && typeof item.comparisonSlotSpecificity === "number"
+                  ? item.comparisonSlotSpecificity
+                  : undefined,
+                comparisonSlotPositionWeightedRecall: "comparisonSlotPositionWeightedRecall" in item && typeof item.comparisonSlotPositionWeightedRecall === "number"
+                  ? item.comparisonSlotPositionWeightedRecall
+                  : undefined,
+                comparisonSlotPositionWeightedPrecision: "comparisonSlotPositionWeightedPrecision" in item && typeof item.comparisonSlotPositionWeightedPrecision === "number"
+                  ? item.comparisonSlotPositionWeightedPrecision
+                  : undefined,
+                comparisonSlotPositionWeightedSpecificity: "comparisonSlotPositionWeightedSpecificity" in item && typeof item.comparisonSlotPositionWeightedSpecificity === "number"
+                  ? item.comparisonSlotPositionWeightedSpecificity
+                  : undefined,
+                comparisonFirstPersonClauseCount: "comparisonFirstPersonClauseCount" in item && typeof item.comparisonFirstPersonClauseCount === "number"
+                  ? item.comparisonFirstPersonClauseCount
+                  : undefined,
+                comparisonProspectivePersonalVerbCount: "comparisonProspectivePersonalVerbCount" in item && typeof item.comparisonProspectivePersonalVerbCount === "number"
+                  ? item.comparisonProspectivePersonalVerbCount
+                  : undefined,
+                comparisonPlanningDensity: "comparisonPlanningDensity" in item && typeof item.comparisonPlanningDensity === "number"
+                  ? item.comparisonPlanningDensity
+                  : undefined,
+                comparisonPastness: "comparisonPastness" in item && typeof item.comparisonPastness === "number"
+                  ? item.comparisonPastness
+                  : undefined,
+                comparisonSideWitnessScore: "comparisonSideWitnessScore" in item && typeof item.comparisonSideWitnessScore === "number"
+                  ? item.comparisonSideWitnessScore
+                  : undefined,
+              }));
+            }
           }
           recoveryCandidates.push(
             ...reranked.ranked.map((item) => {
@@ -836,18 +1019,16 @@ export function buildContextEngineFactory(
           }));
         }
         if (debugRecovery && rawUserRecoveryDebug.length > 0) {
-          const selectedIDs = new Set(
-            fittedRecovery
-              .filter((item) => item.metadata.recovery_scope === "user_turns")
-              .map((item: SearchResult) => item.id),
-          );
           rawUserRecoveryDebug = rawUserRecoveryDebug.map((item) => ({
             ...item,
-            selected: selectedIDs.has(item.id),
           }));
         }
       }
 
+      if (debugRecovery && rawUserRecoveryDebug.length === 0 && temporalRecoveryPreviewDebug.length > 0) {
+        rawUserRecoveryDebug = temporalRecoveryPreviewDebug;
+      }
+
       const selected = [
         ...hardItems,
         ...tailBaseItems,
@@ -1189,6 +1370,7 @@ function clampFraction(value: number | undefined): number {
 async function ingestCanonicalMessage(params: {
   getRpc: RpcGetter;
   cfg: PluginConfig;
+  logger: LoggerLike;
   recallCache: RecallCache<SearchResult>;
   clearElevatedCacheForSession: (sessionId: string) => void;
   sessionId: string;
@@ -1233,7 +1415,10 @@ async function ingestCanonicalMessage(params: {
     if (useSessionRecallProjection(params.cfg) && !params.skipProjectionRebuild) {
       await rebuildSessionRecallProjection(rpc, params.cfg, params.sessionId);
     }
-  } catch {
+  } catch (error) {
+    params.logger.error(
+      `[libravdb] session ingest failed for ${params.sessionId}: ${error instanceof Error ? error.message : String(error)}`,
+    );
     return { ingested: false };
   }
 
@@ -1262,7 +1447,11 @@ async function ingestCanonicalMessage(params: {
     // User turns must be stored durably regardless of gating score so the agent can recall
     // friends, preferences, and context across sessions. Gating signals are still
     // recorded in metadata for observability, but do not gate the insert.
-    void rpc.call("insert_text", {
+    //
+    // IMPORTANT: This insert MUST be awaited. A previous fire-and-forget pattern
+    // (void + catch) caused silent data loss when the daemon was slow/overloaded —
+    // the user-level collection stayed empty, breaking cross-session recall entirely.
+    await rpc.call("insert_text", {
       collection: `user:${durableNamespace}`,
       id: `${durableNamespace}:${turnId}`,
       text: normalized.content,
@@ -1286,9 +1475,14 @@ async function ingestCanonicalMessage(params: {
         gating_gconv: gating.gconv,
         gating_gtech: gating.gtech,
       },
-    }).catch(console.error);
-  } catch {
-    // Session storage already happened; skip durable promotion on gating failure.
+    });
+  } catch (userInsertError) {
+    // Session storage already happened; log durable promotion failure visibly
+    // so it does not silently vanish in production.
+    params.logger.error(
+      `[libravdb] durable user insert failed for ${durableNamespace}: ${userInsertError instanceof Error ? userInsertError.message : String(userInsertError)}`,
+    );
+    return { ingested: false };
   }
 
   return { ingested: true };

package/src/index.ts

@@ -32,7 +32,7 @@ export default definePluginEntry({
 
     registerMemoryCli(api, runtime, cfg, api.logger ?? console);
     api.registerContextEngine("libravdb-memory", () =>
-      buildContextEngineFactory(runtime.getRpc, cfg, recallCache),
+      buildContextEngineFactory(runtime.getRpc, cfg, recallCache, api.logger ?? console),
     );
     api.registerMemoryPromptSection(buildMemoryPromptSection(runtime.getRpc, cfg, recallCache));
     api.registerMemoryRuntime?.(buildMemoryRuntimeBridge(runtime.getRpc, cfg));

package/src/plugin-runtime.ts

@@ -4,6 +4,7 @@ import type { LoggerLike, PluginConfig, SidecarHandle } from "./types.js";
 
 export type RpcGetter = () => Promise<RpcClient>;
 export const DEFAULT_RPC_TIMEOUT_MS = 30000;
+export const STARTUP_HEALTH_TIMEOUT_MS = 2000;
 
 export interface LifecycleHint {
   hook: "before_reset" | "session_end";
@@ -43,7 +44,9 @@ export function createPluginRuntime(
         const rpc = new RpcClient(sidecar.socket, {
           timeoutMs: cfg.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS,
         });
-        const health = await rpc.call<{ ok?: boolean; message?: string }>("health", {});
+        const health = await rpc.call<{ ok?: boolean; message?: string }>("health", {}, {
+          timeoutMs: STARTUP_HEALTH_TIMEOUT_MS,
+        });
         if (!health.ok) {
           try {
             await sidecar.shutdown();

package/src/rpc.ts

@@ -18,20 +18,28 @@ export class RpcClient {
     socket.setEncoding("utf8");
     socket.on("data", (chunk) => this.handleData(chunk));
     socket.on("close", () => this.rejectAll(new Error("Socket closed")));
+    socket.on("error", (error) => this.rejectAll(error));
   }
 
-  async call<T>(method: string, _params: unknown): Promise<T> {
+  async call<T>(method: string, _params: unknown, callOptions: Partial<RpcCallOptions> = {}): Promise<T> {
     return await new Promise<T>((resolve, reject) => {
       const id = ++this.seq;
+      const timeoutMs = callOptions.timeoutMs ?? this.options.timeoutMs;
       const timer = setTimeout(() => {
         this.pending.delete(id);
-        reject(new Error(`RPC timeout: ${method} (${this.options.timeoutMs}ms)`));
-      }, this.options.timeoutMs);
+        reject(new Error(`RPC timeout: ${method} (${timeoutMs}ms)`));
+      }, timeoutMs);
 
       this.pending.set(id, { resolve, reject, timer });
-      this.socket.write(
-        `${JSON.stringify({ jsonrpc: "2.0", id, method, params: _params })}\n`,
-      );
+      try {
+        this.socket.write(
+          `${JSON.stringify({ jsonrpc: "2.0", id, method, params: _params })}\n`,
+        );
+      } catch (error) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
     });
   }
 

package/src/sidecar.ts

@@ -9,6 +9,10 @@ type CloseHandler = () => void;
 type DataHandler = (chunk: string) => void;
 type ErrorHandler = (error: Error) => void;
 
+const STARTUP_CONNECT_MAX_RETRIES = 5;
+const STARTUP_CONNECT_BASE_DELAY_MS = 100;
+const STARTUP_CONNECT_MAX_TOTAL_WAIT_MS = 2000;
+
 export interface SidecarRuntime {
   resolveEndpoint(cfg: PluginConfig): string | Promise<string>;
   createSocket(endpoint: string): SidecarSocket;
@@ -18,6 +22,7 @@ export interface SidecarRuntime {
 class PlaceholderSocket implements SidecarSocket {
   private readonly onData = new Set<DataHandler>();
   private readonly onClose = new Set<CloseHandler>();
+  private readonly onError = new Set<ErrorHandler>();
   private readonly connectOnce = new Set<CloseHandler>();
   private readonly errorOnce = new Set<ErrorHandler>();
 
@@ -32,11 +37,15 @@ class PlaceholderSocket implements SidecarSocket {
 
   setEncoding(_encoding: string): void {}
 
-  on(event: "data" | "close", handler: DataHandler | CloseHandler): void {
+  on(event: "data" | "close" | "error", handler: DataHandler | CloseHandler | ErrorHandler): void {
     if (event === "data") {
       this.onData.add(handler as DataHandler);
       return;
     }
+    if (event === "error") {
+      this.onError.add(handler as ErrorHandler);
+      return;
+    }
     this.onClose.add(handler as CloseHandler);
   }
 
@@ -61,10 +70,7 @@ class PlaceholderSocket implements SidecarSocket {
       }
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
-      for (const handler of this.errorOnce) {
-        handler(err);
-      }
-      this.errorOnce.clear();
+      this.emitError(err);
     }
   }
 
@@ -73,11 +79,22 @@ class PlaceholderSocket implements SidecarSocket {
       handler();
     }
   }
+
+  private emitError(error: Error): void {
+    for (const handler of this.onError) {
+      handler(error);
+    }
+    for (const handler of this.errorOnce) {
+      handler(error);
+    }
+    this.errorOnce.clear();
+  }
 }
 
 class SupervisorSocket implements SidecarSocket {
   private readonly onData = new Set<DataHandler>();
   private readonly onClose = new Set<CloseHandler>();
+  private readonly onError = new Set<ErrorHandler>();
   private readonly connectOnce = new Set<CloseHandler>();
   private readonly errorOnce = new Set<ErrorHandler>();
   private current?: SidecarSocket;
@@ -102,10 +119,24 @@ class SupervisorSocket implements SidecarSocket {
       if (generation !== this.generation) {
         return;
       }
+      this.current = undefined;
       for (const handler of this.onClose) {
         handler();
       }
     });
+    socket.on("error", (error) => {
+      if (generation !== this.generation) {
+        return;
+      }
+      this.current = undefined;
+      for (const handler of this.onError) {
+        handler(error);
+      }
+      for (const handler of this.errorOnce) {
+        handler(error);
+      }
+      this.errorOnce.clear();
+    });
 
     for (const handler of this.connectOnce) {
       handler();
@@ -118,11 +149,15 @@ class SupervisorSocket implements SidecarSocket {
     this.current?.setEncoding(encoding);
   }
 
-  on(event: "data" | "close", handler: DataHandler | CloseHandler): void {
+  on(event: "data" | "close" | "error", handler: DataHandler | CloseHandler | ErrorHandler): void {
     if (event === "data") {
       this.onData.add(handler as DataHandler);
       return;
     }
+    if (event === "error") {
+      this.onError.add(handler as ErrorHandler);
+      return;
+    }
     this.onClose.add(handler as CloseHandler);
   }
 
@@ -154,6 +189,7 @@ class SidecarSupervisor implements SidecarHandle {
   private retries = 0;
   private degraded = false;
   private shuttingDown = false;
+  private reconnectScheduled = false;
   public socket: SidecarSocket;
 
   constructor(
@@ -166,7 +202,8 @@ class SidecarSupervisor implements SidecarHandle {
 
   async start(): Promise<SidecarSocket> {
     const endpoint = await this.runtime.resolveEndpoint(this.cfg);
-    const socket = await this.connectEndpoint(endpoint);
+    const socket = await this.connectEndpointWithRetry(endpoint);
+    this.reconnectScheduled = false;
     if (this.socket instanceof SupervisorSocket) {
       this.socket.bind(socket);
     } else {
@@ -184,21 +221,48 @@ class SidecarSupervisor implements SidecarHandle {
     this.socket.destroy();
   }
 
-  private async connectEndpoint(endpoint: string): Promise<SidecarSocket> {
-    const socket = this.runtime.createSocket(endpoint);
-    socket.on("close", () => {
-      void this.handleExit(1);
-    });
-
+  private async connectEndpointWithRetry(endpoint: string): Promise<SidecarSocket> {
     if (isTcpEndpoint(endpoint)) {
       this.logger.info?.(`[libravdb] using TCP endpoint ${endpoint}`);
     } else {
       this.logger.info?.(`[libravdb] using Unix socket ${endpoint}`);
     }
 
+    let waitedMs = 0;
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await this.connectEndpoint(endpoint);
+      } catch (error) {
+        if (!isStartupConnectRetryableError(error) || attempt >= STARTUP_CONNECT_MAX_RETRIES - 1) {
+          throw error;
+        }
+
+        const delayMs = computeStartupConnectRetryDelay(attempt, waitedMs);
+        if (delayMs <= 0) {
+          throw error;
+        }
+        waitedMs += delayMs;
+        this.logger.info?.(
+          `[libravdb] Daemon not ready, retrying connection (attempt ${attempt + 1}/${STARTUP_CONNECT_MAX_RETRIES})...`,
+        );
+        await sleep(delayMs);
+      }
+    }
+  }
+
+  private async connectEndpoint(endpoint: string): Promise<SidecarSocket> {
+    const socket = this.runtime.createSocket(endpoint);
     return await new Promise<SidecarSocket>((resolve, reject) => {
-      socket.once("connect", () => resolve(socket));
-      socket.once("error", (error) => reject(formatConnectionError(endpoint, error)));
+      socket.once("connect", () => {
+        socket.on("close", () => {
+          void this.handleExit(1);
+        });
+        resolve(socket);
+      });
+      socket.once("error", (error) => {
+        socket.destroy();
+        reject(formatConnectionError(endpoint, error));
+      });
     });
   }
 
@@ -209,6 +273,9 @@ class SidecarSupervisor implements SidecarHandle {
     if (code === 0) {
       return;
     }
+    if (this.reconnectScheduled) {
+      return;
+    }
 
     const maxRetries = this.cfg.maxRetries ?? 3;
     if (this.retries >= maxRetries) {
@@ -219,8 +286,10 @@ class SidecarSupervisor implements SidecarHandle {
 
     const backoffMs = computeBackoffMs(this.retries);
     this.retries += 1;
+    this.reconnectScheduled = true;
     this.runtime.scheduleRestart(backoffMs, () => {
       void this.start().catch((error) => {
+        this.reconnectScheduled = false;
         const message = error instanceof Error ? error.message : String(error);
         this.logger.error(`[libravdb] sidecar reconnect failed: ${message}`);
       });
@@ -242,6 +311,17 @@ export function computeBackoffMs(retries: number): number {
   return Math.min(500 * Math.pow(2, retries), 16000);
 }
 
+export function computeStartupConnectRetryDelay(attempt: number, waitedMs = 0): number {
+  if (attempt < 0) {
+    return 0;
+  }
+  const remainingMs = STARTUP_CONNECT_MAX_TOTAL_WAIT_MS - waitedMs;
+  if (remainingMs <= 0) {
+    return 0;
+  }
+  return Math.min(STARTUP_CONNECT_BASE_DELAY_MS * Math.pow(2, attempt), remainingMs);
+}
+
 export function isTcpEndpoint(endpoint: string): boolean {
   return endpoint.startsWith("tcp:");
 }
@@ -423,16 +503,29 @@ function createDefaultRuntime(): SidecarRuntime {
   };
 }
 
+function isStartupConnectRetryableError(error: unknown): boolean {
+  const code = typeof (error as NodeJS.ErrnoException | undefined)?.code === "string"
+    ? (error as NodeJS.ErrnoException).code
+    : "";
+  return code === "ENOENT" || code === "ECONNREFUSED";
+}
+
 function formatConnectionError(endpoint: string, error: Error): Error {
   const code = typeof (error as NodeJS.ErrnoException).code === "string"
     ? (error as NodeJS.ErrnoException).code
     : "";
+  const annotated = error instanceof Error ? error : new Error(String(error));
+  if (code) {
+    (annotated as NodeJS.ErrnoException).code = code;
+  }
   if (code === "ENOENT" || code === "ECONNREFUSED") {
-    return new Error(
+    const unavailable = new Error(
       `LibraVDB daemon unavailable at ${describeEndpoint(endpoint)}. ${daemonProvisioningHint()} Or set sidecarPath to a running daemon endpoint.`,
     );
+    (unavailable as NodeJS.ErrnoException).code = code;
+    return unavailable;
   }
-  return error;
+  return annotated;
 }
 
 function describeEndpoint(endpoint: string): string {
@@ -448,6 +541,10 @@ function isConfiguredEndpoint(value?: string): boolean {
 
 export { PlaceholderSocket };
 
+function sleep(delayMs: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
 export async function probeSidecarEndpoint(cfg: PluginConfig): Promise<string | null> {
   const endpoint = resolveConfiguredEndpoint(cfg);
   try {

package/src/temporal.ts

@@ -279,6 +279,13 @@ export function rankTemporalRecoveryCandidates(
   const temporalQuery = detectTemporalQuerySignal(opts.queryText);
   const slots = extractTemporalSlots(opts.queryText);
   const isComparisonQuery = temporalQuery.matchedPatterns.includes("first or earlier");
+  // Duration-interval queries ("how many days ... after", "how long ... since") require explicit
+  // date anchors to be answerable. The soft-blend scorer can otherwise let an anchor-free turn
+  // outrank anchor-bearing ones when the semantic signal is still high.
+  const isDurationIntervalQuery = !isComparisonQuery && (
+    temporalQuery.matchedPatterns.includes("how many days") ||
+    temporalQuery.matchedPatterns.includes("how long")
+  );
   const effectiveSlots = isComparisonQuery ? filterComparisonSlots(slots) : slots;
   const comparisonSlots = isComparisonQuery ? deriveComparisonSideSlots(effectiveSlots) : [];
   const recencyLambda = Math.max(0, opts.recencyLambda ?? 0.00001);
@@ -299,6 +306,16 @@ export function rankTemporalRecoveryCandidates(
       comparisonProfile.rawCandidateCount = items.length;
     }
 
+    // Pre-scan anchor density only for duration-interval queries so the gate below can verify at
+    // least one anchor-bearing candidate exists before zeroing anchor-free ones. Cached, so the
+    // re-check inside the map is cheap.
+    const anyAnchorBearing = isDurationIntervalQuery && items.some((item) =>
+      getTemporalAnchorDensity(
+        `${typeof item.metadata.collection === "string" ? item.metadata.collection : "unknown"}::${item.id}`,
+        item.text,
+      ) > 0,
+    );
+
     const decorateStart = comparisonProfile ? process.hrtime.bigint() : 0n;
     const decorated = items.map((item) => {
       const semanticScore = clamp01(typeof item.finalScore === "number" ? item.finalScore : item.score ?? 0);
@@ -331,6 +348,10 @@ export function rankTemporalRecoveryCandidates(
           comparisonSideWitnessScore,
           temporalQueryActive: temporalQuery.active,
         })
+        // Duration-interval gate: if we have at least one anchor-bearing candidate, anchor-free
+        // candidates cannot answer the date question and should stay below the greedy threshold.
+        : isDurationIntervalQuery && anyAnchorBearing && temporalAnchorDensity === 0
+          ? 0
         : (0.40 * semanticScore) +
           (0.25 * recencyScore) +
           (0.20 * temporalAnchorDensity) +

package/src/types.ts

@@ -152,6 +152,7 @@ export interface SidecarSocket {
   setEncoding(encoding: string): void;
   on(event: "data", handler: (chunk: string) => void): void;
   on(event: "close", handler: () => void): void;
+  on(event: "error", handler: (error: Error) => void): void;
   once(event: "connect", handler: () => void): void;
   once(event: "error", handler: (error: Error) => void): void;
   write(chunk: string): void;