agenr 0.9.78 → 0.9.80

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.9.80] - 2026-03-08
+
+### Fixed
+
+- Added startup-only `SQLITE_BUSY` retry/backoff for OpenClaw session-start browse and memory-index reads, reducing transient lock-induced degradation immediately after handoff recovery.
+- Session-start browse now logs explicit retry and unavailable states instead of collapsing lock failures into the ordinary `browse returned 0 entries` path.
+- Preserved existing startup fail-open rendering behavior by continuing to omit unavailable browse or memory-index sections while still completing session-start with the remaining recovered context.
+- Added focused regression coverage for strict startup browse execution, compatibility preservation in `runRecall()`, and session-start retry/degradation logging for browse and memory-index lock contention.
+
+## [0.9.79] - 2026-03-08
+
+### Fixed
+
+- Fixed OpenClaw session-start memory index observability so startup logs now distinguish successful empty loads from timeout, invalid-response, and error states instead of collapsing them all into `0 projects`.
+- Fixed the OpenClaw session-start core recall debug log to report configured `coreProjects` truthfully rather than mislabeling config length as "active projects".
+- Fixed OpenClaw session-start fallback recovery for newer TUI session keys such as `agent:main:tui-<uuid>` by allowing degraded same-family TUI predecessor acceptance when the current session identity resolves `family=tui` but cannot recover a stable lane.
+- Preserved strict lane matching for explicit predecessors and known-lane fallback cases, while keeping cross-family fallback candidates ineligible.
+- Added regression coverage for memory-index load result typing, session-start memory-index availability logging, markdown omission on unavailable index states, truthful core-project log wording, unknown-lane TUI fallback acceptance, alternate same-family TUI lane acceptance, cross-family rejection, and the new-key debug logging path.
+
 ## [0.9.78] - 2026-03-08
 
 ### Fixed

package/dist/openclaw-plugin/index.js

@@ -635,13 +635,15 @@ __export(recall_exports, {
   resolveAgenrPath: () => resolveAgenrPath,
   resolveBudget: () => resolveBudget,
   runMemoryIndex: () => runMemoryIndex,
-  runRecall: () => runRecall
+  runRecall: () => runRecall,
+  runRecallStrict: () => runRecallStrict
 });
 import path from "path";
 import { fileURLToPath } from "url";
 
 // src/openclaw-plugin/memory-index.ts
 var MEMORY_INDEX_TIMEOUT_MS = 1e4;
+var MEMORY_INDEX_TIMEOUT = /* @__PURE__ */ Symbol("memory-index-timeout");
 function normalizeDate(value) {
   const raw = typeof value === "string" ? value.trim() : "";
   if (!raw) {
@@ -693,9 +695,16 @@ function parseMemoryIndex(value) {
 }
 async function runMemoryIndex(_agenrPath, dbPath) {
   try {
-    return await withTimeout(loadMemoryIndex(dbPath), MEMORY_INDEX_TIMEOUT_MS);
-  } catch {
-    return null;
+    const result = await withTimeout(loadMemoryIndex(dbPath), MEMORY_INDEX_TIMEOUT_MS);
+    if (result === MEMORY_INDEX_TIMEOUT) {
+      return { status: "timeout" };
+    }
+    return result;
+  } catch (error) {
+    return {
+      status: "error",
+      error: toErrorMessage(error)
+    };
   }
 }
 async function loadMemoryIndex(dbPath) {
@@ -703,14 +712,24 @@ async function loadMemoryIndex(dbPath) {
     index: true,
     dbPath
   });
-  return result.mode === "index" ? parseMemoryIndex(result.indexPayload) : null;
+  if (result.mode !== "index") {
+    return { status: "invalid" };
+  }
+  const index = parseMemoryIndex(result.indexPayload);
+  if (!index) {
+    return { status: "invalid" };
+  }
+  return {
+    status: "ok",
+    index
+  };
 }
 async function withTimeout(promise, timeoutMs) {
   let timer;
   try {
     return await new Promise((resolve, reject) => {
       timer = setTimeout(() => {
-        resolve(null);
+        resolve(MEMORY_INDEX_TIMEOUT);
       }, timeoutMs);
       promise.then(resolve).catch(reject);
     });
@@ -755,34 +774,45 @@ function buildSpawnArgs(agenrPath) {
   }
   return { cmd: agenrPath, args: [] };
 }
-async function runRecall(_agenrPath, budget, project, query, options, dbPath) {
+function buildRecallServiceRequest(budget, project, query, options, dbPath) {
+  const isBrowse = options?.context === "browse";
+  const trimmedQuery = query?.trim() ?? "";
+  const truncatedQuery = trimmedQuery.length > RECALL_QUERY_MAX_CHARS ? trimmedQuery.slice(0, RECALL_QUERY_MAX_CHARS) : trimmedQuery;
+  return {
+    queryInput: isBrowse ? void 0 : truncatedQuery || void 0,
+    context: isBrowse ? "browse" : "session-start",
+    browse: isBrowse,
+    since: isBrowse ? options?.since ?? "1d" : void 0,
+    limit: options?.limit,
+    minImportance: options?.minImportance,
+    expiry: options?.expiry,
+    universalOnly: options?.nullProjectOnly === true || options?.universalOnly === true,
+    project: options?.nullProjectOnly || options?.universalOnly || !project ? void 0 : [project],
+    projectStrict: Boolean(project && !options?.nullProjectOnly && !options?.universalOnly),
+    budget: isBrowse ? void 0 : budget,
+    dbPath,
+    metadataMode: "non-browse"
+  };
+}
+function shapeRecallResult(result) {
+  return {
+    query: result.payload.query,
+    results: result.payload.results.map((item) => ({
+      entry: item.entry,
+      score: item.score,
+      category: item.category
+    }))
+  };
+}
+async function runRecallStrict(_agenrPath, budget, project, query, options, dbPath) {
+  const result = await runRecallService(
+    buildRecallServiceRequest(budget, project, query, options, dbPath)
+  );
+  return shapeRecallResult(result);
+}
+async function runRecall(agenrPath, budget, project, query, options, dbPath) {
   try {
-    const isBrowse = options?.context === "browse";
-    const trimmedQuery = query?.trim() ?? "";
-    const truncatedQuery = trimmedQuery.length > RECALL_QUERY_MAX_CHARS ? trimmedQuery.slice(0, RECALL_QUERY_MAX_CHARS) : trimmedQuery;
-    const result = await runRecallService({
-      queryInput: isBrowse ? void 0 : truncatedQuery || void 0,
-      context: isBrowse ? "browse" : "session-start",
-      browse: isBrowse,
-      since: isBrowse ? options?.since ?? "1d" : void 0,
-      limit: options?.limit,
-      minImportance: options?.minImportance,
-      expiry: options?.expiry,
-      universalOnly: options?.nullProjectOnly === true || options?.universalOnly === true,
-      project: options?.nullProjectOnly || options?.universalOnly || !project ? void 0 : [project],
-      projectStrict: Boolean(project && !options?.nullProjectOnly && !options?.universalOnly),
-      budget: isBrowse ? void 0 : budget,
-      dbPath,
-      metadataMode: "non-browse"
-    });
-    return {
-      query: result.payload.query,
-      results: result.payload.results.map((item) => ({
-        entry: item.entry,
-        score: item.score,
-        category: item.category
-      }))
-    };
+    return await runRecallStrict(agenrPath, budget, project, query, options, dbPath);
   } catch {
     return null;
   }
@@ -2806,15 +2836,17 @@ function resolveSessionFamilyPolicy(currentFamily, predecessorFamily, options) {
   const normalizedPredecessorFamily = normalizePolicyFamily(predecessorFamily);
   const sameKnownFamily = currentFamily !== "unknown" && normalizedPredecessorFamily !== "unknown" && normalizedPredecessorFamily === currentFamily;
   const webchatLaneIdentityAvailable = sameKnownFamily && currentFamily === "webchat" && normalizedPredecessorFamily === "webchat" && (hasStableLaneIdentity(currentFamily, options?.currentLaneId) || hasStableLaneIdentity(normalizedPredecessorFamily, options?.predecessorLaneId));
-  const laneContinuityRequired = sameKnownFamily && (requiresStrictLaneScopedContinuity(currentFamily) || requiresStrictLaneScopedContinuity(normalizedPredecessorFamily) || webchatLaneIdentityAvailable);
-  const laneContinuityConfirmed = laneContinuityRequired ? options?.laneContinuityConfirmed === true : sameKnownFamily;
-  const predecessorContinuityEligible = sameKnownFamily && laneContinuityConfirmed;
+  const degradedLaneFallbackUsed = sameKnownFamily && options?.degradedSameFamilyFallbackAllowed === true;
+  const laneContinuityRequired = !degradedLaneFallbackUsed && sameKnownFamily && (requiresStrictLaneScopedContinuity(currentFamily) || requiresStrictLaneScopedContinuity(normalizedPredecessorFamily) || webchatLaneIdentityAvailable);
+  const laneContinuityConfirmed = degradedLaneFallbackUsed ? true : laneContinuityRequired ? options?.laneContinuityConfirmed === true : sameKnownFamily;
+  const predecessorContinuityEligible = sameKnownFamily && (degradedLaneFallbackUsed || laneContinuityConfirmed);
   return {
     currentFamily,
     predecessorFamily: normalizedPredecessorFamily,
     laneContinuityRequired,
     laneContinuityConfirmed,
     predecessorContinuityEligible,
+    degradedLaneFallbackUsed,
     startupHandoffBrowseEntriesAllowed: predecessorContinuityEligible,
     sessionProjectInheritanceAllowed: predecessorContinuityEligible,
     clearedSessionProjectInheritanceAllowed: predecessorContinuityEligible
@@ -3968,8 +4000,14 @@ function isFallbackLaneContinuityConfirmed(currentIdentity, predecessorFamily, p
   }
   return currentIdentity.laneId === predecessorLaneId;
 }
+function shouldAllowDegradedTuiFallback(currentIdentity, predecessorFamily) {
+  return currentIdentity.family === "tui" && predecessorFamily === "tui" && !currentIdentity.laneId;
+}
 function describeContinuityDecisionReason(currentFamily, predecessorFamily, currentLaneId, predecessorLaneId, policy) {
   if (policy.predecessorContinuityEligible) {
+    if (policy.degradedLaneFallbackUsed) {
+      return "same-family continuity accepted (tui degraded fallback: current lane unknown)";
+    }
     if (currentFamily === "webchat" && predecessorFamily === "webchat" && !policy.laneContinuityRequired) {
       return "same-family continuity accepted (webchat single-lane runtime)";
     }
@@ -4224,6 +4262,10 @@ async function resolveSessionContinuity(event, ctx, sessionsDir, logger, debug,
         currentIdentity,
         predecessorFamilySignal.family,
         predecessorLaneSignal.laneId
+      ),
+      degradedSameFamilyFallbackAllowed: shouldAllowDegradedTuiFallback(
+        currentIdentity,
+        predecessorFamilySignal.family
       )
     });
     const predecessorIdentity = {
@@ -4562,7 +4604,79 @@ function diversifySessionStartBrowseCandidates(browseResult, limit = SESSION_STA
 
 // src/openclaw-plugin/hooks/before-prompt-build-session-start-recall.ts
 var SESSION_START_BROWSE_SINCE = "30d";
+var SQLITE_BUSY_RETRY_DELAYS_MS = [100, 200, 400];
 var sessionStartLog3 = createLogger("session-start");
+function formatConfiguredCoreProjects(coreProjects) {
+  return `[${coreProjects.join(",")}]`;
+}
+function describeMemoryIndexResult(result) {
+  if (!result) {
+    return "memory index unavailable: unknown failure";
+  }
+  switch (result.status) {
+    case "ok":
+      return `memory index loaded: ${result.index.projects.length} projects`;
+    case "timeout":
+      return "memory index unavailable: timeout";
+    case "error":
+      return `memory index unavailable: ${result.error}`;
+    case "invalid":
+      return "memory index unavailable: invalid response";
+  }
+}
+function isSqliteBusyMessage(message) {
+  return message.toUpperCase().includes("SQLITE_BUSY");
+}
+async function sleepMs(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function loadSessionStartBrowseWithRetry(params, project, options) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await runRecallStrict(
+        params.agenrPath,
+        params.budget,
+        project,
+        void 0,
+        options,
+        params.config?.dbPath
+      );
+    } catch (error) {
+      const message = toErrorMessage(error);
+      const isBusy = isSqliteBusyMessage(message);
+      if (!isBusy || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) {
+        sessionStartLog3.warn(`browse unavailable: ${message}`);
+        return null;
+      }
+      const delayMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt] ?? 400;
+      sessionStartLog3.warn(
+        `browse hit SQLITE_BUSY, retrying in ${delayMs}ms (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1})`
+      );
+      await sleepMs(delayMs);
+    }
+  }
+}
+async function loadMemoryIndexWithRetry(params) {
+  for (let attempt = 0; ; attempt += 1) {
+    const result = await runMemoryIndex(
+      params.agenrPath,
+      params.config?.dbPath
+    );
+    const message = result.status === "error" ? result.error : "";
+    const isBusy = result.status === "error" && isSqliteBusyMessage(message);
+    if (!isBusy || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) {
+      if (result.status !== "ok") {
+        sessionStartLog3.warn(describeMemoryIndexResult(result));
+      }
+      return result;
+    }
+    const delayMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt] ?? 400;
+    sessionStartLog3.warn(
+      `memory index hit SQLITE_BUSY, retrying in ${delayMs}ms (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1})`
+    );
+    await sleepMs(delayMs);
+  }
+}
 async function fetchSessionStartRecallData(currentSessionProjectKey, params) {
   const coreProjects = params.config?.coreProjects ?? [];
   const sessionStartBrowseProject = await resolveSessionStartBrowseProject(
@@ -4581,18 +4695,8 @@ async function fetchSessionStartRecallData(currentSessionProjectKey, params) {
   }
   const [coreSettled, browseSettled, memoryIndexSettled] = await Promise.allSettled([
     fetchCoreEntries(params.agenrPath, coreProjects, params.config?.dbPath),
-    runRecall(
-      params.agenrPath,
-      params.budget,
-      sessionStartBrowseProject,
-      void 0,
-      browseRecallOptions,
-      params.config?.dbPath
-    ),
-    runMemoryIndex(
-      params.agenrPath,
-      params.config?.dbPath
-    )
+    loadSessionStartBrowseWithRetry(params, sessionStartBrowseProject, browseRecallOptions),
+    loadMemoryIndexWithRetry(params)
   ]);
   if (coreSettled.status === "rejected") {
     sessionStartLog3.error(`core recall failed: ${toErrorMessage(coreSettled.reason)}`);
@@ -4606,18 +4710,22 @@ async function fetchSessionStartRecallData(currentSessionProjectKey, params) {
   const coreResult = coreSettled.status === "fulfilled" ? coreSettled.value : null;
   const browseResult = browseSettled.status === "fulfilled" ? browseSettled.value : null;
   const memoryIndexResult = memoryIndexSettled.status === "fulfilled" ? memoryIndexSettled.value : null;
-  const memoryIndexMarkdown = memoryIndexResult ? formatMemoryIndex(memoryIndexResult) : void 0;
+  const memoryIndexMarkdown = memoryIndexResult?.status === "ok" ? formatMemoryIndex(memoryIndexResult.index) : void 0;
   debugLog(
     params.debug,
     "session-start",
-    `core recall returned ${coreResult?.results.length ?? 0} entries (${coreProjects.length} active projects)`
-  );
-  debugLog(params.debug, "session-start", `browse returned ${browseResult?.results.length ?? 0} entries`);
-  debugLog(
-    params.debug,
-    "session-start",
-    `memory index returned ${memoryIndexResult?.projects.length ?? 0} projects`
+    `core recall returned ${coreResult?.results.length ?? 0} entries (configured coreProjects=${formatConfiguredCoreProjects(coreProjects)})`
   );
+  if (browseResult) {
+    debugLog(params.debug, "session-start", `browse returned ${browseResult.results.length} entries`);
+  }
+  if (memoryIndexResult?.status === "ok") {
+    debugLog(
+      params.debug,
+      "session-start",
+      describeMemoryIndexResult(memoryIndexResult)
+    );
+  }
   return {
     coreResult,
     browseResult,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "0.9.78",
+  "version": "0.9.80",
   "openclaw": {
     "extensions": [
       "dist/openclaw-plugin/index.js"