agenr 0.9.79 → 0.9.81

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.9.81] - 2026-03-08
+
+### Added
+
+- Added in-place entry metadata updates for memory hygiene, starting with `importance`, via the new `agenr update --id <id> --importance <n>` CLI command.
+- Added the `agenr_update` MCP tool and native OpenClaw plugin tool so agents can demote stale-but-still-true entries without retiring them.
+- Added focused coverage for CLI and MCP update flows plus OpenClaw plugin tool wiring.
+
+### 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

package/README.md

@@ -56,7 +56,7 @@ export OPENAI_API_KEY=sk-...  # for embeddings + extraction
 
 ### OpenClaw (recommended)
 
-`agenr init` auto-detects OpenClaw, installs the native plugin, and restarts the gateway. The plugin handles everything automatically: session-start context injection (recent turns, core recall, browse recall, and a memory index), mid-session signals when important entries arrive, cross-session handoff summaries, and native `agenr_recall`, `agenr_store`, `agenr_extract`, `agenr_retire`, and session-project tools.
+`agenr init` auto-detects OpenClaw, installs the native plugin, and restarts the gateway. The plugin handles everything automatically: session-start context injection (recent turns, core recall, browse recall, and a memory index), mid-session signals when important entries arrive, cross-session handoff summaries, and native `agenr_recall`, `agenr_store`, `agenr_extract`, `agenr_retire`, `agenr_update`, and session-project tools.
 
 No AGENTS.md edits needed. No MCP config needed. The bundled SKILL.md loads automatically and instructs the agent when to call `agenr_store` proactively.
 
@@ -127,7 +127,7 @@ Adds instructions to `~/.codeium/windsurf/memories/global_rules.md` and wires `.
 agenr init   # auto-detects platform, falls back to generic AGENTS.md
 ```
 
-Or start `agenr mcp` as a stdio MCP server and configure it in your tool's MCP settings manually. Your agent gets `agenr_recall`, `agenr_store`, `agenr_extract`, and `agenr_retire` as tools.
+Or start `agenr mcp` as a stdio MCP server and configure it in your tool's MCP settings manually. Your agent gets `agenr_recall`, `agenr_store`, `agenr_extract`, `agenr_retire`, and `agenr_update` as tools.
 
 ## How Memory Works
 
@@ -236,7 +236,7 @@ If you prefer manual MCP setup over `agenr init`, start the stdio server:
 agenr mcp
 ```
 
-This exposes four tools: `agenr_recall`, `agenr_store`, `agenr_extract`, `agenr_retire`. Configure it in your tool's MCP settings as a stdio server.
+This exposes five tools: `agenr_recall`, `agenr_store`, `agenr_extract`, `agenr_retire`, `agenr_update`. Configure it in your tool's MCP settings as a stdio server.
 
 ## Commands
 
@@ -252,6 +252,7 @@ This exposes four tools: `agenr_recall`, `agenr_store`, `agenr_extract`, `agenr_
 | `agenr store [files...]` | Store entries with semantic dedup |
 | `agenr recall [query]` | Semantic + memory-aware recall. Use `--since`/`--until` for date ranges, `--around` for target-date ranking, `--browse` for temporal mode. |
 | `agenr retire [subject]` | Retire a stale entry (hidden, not deleted). Match by subject or `--id`. |
+| `agenr update --id <id> --importance <n>` | Update an entry in place. Currently supports importance only. |
 | `agenr watch [file]` | Live-watch files/directories, auto-extract knowledge |
 | `agenr watcher install` | Install background watch daemon (macOS launchd) |
 | `agenr watcher status` | Show daemon status (running/stopped, pid, watched file, recent logs) |

package/dist/{chunk-JJZHOS4U.js → chunk-CEPFOYOL.js}

@@ -6289,6 +6289,112 @@ async function executeRetire(request, deps) {
   }
 }
 
+// src/app/update-service.ts
+function validateEntryId(id) {
+  const entryId = id?.trim() ?? "";
+  if (!entryId) {
+    throw new Error("id is required");
+  }
+  return entryId;
+}
+function normalizeImportance(value) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(parsed) || parsed < IMPORTANCE_MIN || parsed > IMPORTANCE_MAX) {
+    throw new Error(`importance must be an integer between ${IMPORTANCE_MIN} and ${IMPORTANCE_MAX}`);
+  }
+  return parsed;
+}
+async function queryById2(db, id) {
+  const result = await db.execute({
+    sql: `
+      SELECT id, type, subject, importance, content
+      FROM entries
+      WHERE retired = 0 AND id = ?
+      LIMIT 1
+    `,
+    args: [id]
+  });
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  return {
+    id: toStringValue(row.id),
+    type: toStringValue(row.type),
+    subject: toStringValue(row.subject),
+    importance: toNumber(row.importance),
+    content: toStringValue(row.content)
+  };
+}
+async function lookupUpdateCandidate(request, deps) {
+  const resolvedDeps = {
+    readConfigFn: deps?.readConfigFn ?? readConfig,
+    getDbFn: deps?.getDbFn ?? getDb,
+    initDbFn: deps?.initDbFn ?? initDb,
+    closeDbFn: deps?.closeDbFn ?? closeDb
+  };
+  const runtimeEnv = request.env ?? process.env;
+  const id = validateEntryId(request.id);
+  const config = resolvedDeps.readConfigFn(runtimeEnv);
+  const db = resolvedDeps.getDbFn(request.dbPath?.trim() || config?.db?.path);
+  try {
+    await resolvedDeps.initDbFn(db);
+    return { candidate: await queryById2(db, id) };
+  } finally {
+    resolvedDeps.closeDbFn(db);
+  }
+}
+async function executeUpdate(request, deps) {
+  const resolvedDeps = {
+    readConfigFn: deps?.readConfigFn ?? readConfig,
+    getDbFn: deps?.getDbFn ?? getDb,
+    initDbFn: deps?.initDbFn ?? initDb,
+    closeDbFn: deps?.closeDbFn ?? closeDb
+  };
+  const runtimeEnv = request.env ?? process.env;
+  const id = validateEntryId(request.id);
+  const importance = normalizeImportance(request.importance);
+  const config = resolvedDeps.readConfigFn(runtimeEnv);
+  const db = resolvedDeps.getDbFn(request.dbPath?.trim() || config?.db?.path);
+  try {
+    await resolvedDeps.initDbFn(db);
+    const existing = await queryById2(db, id);
+    if (!existing) {
+      return { id, previousImportance: importance, importance, updated: false };
+    }
+    if (existing.importance === importance) {
+      return { id, previousImportance: existing.importance, importance, updated: true };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = await db.execute({
+      sql: `
+        UPDATE entries
+        SET importance = ?,
+            updated_at = ?
+        WHERE id = ?
+          AND retired = 0
+      `,
+      args: [importance, now, id]
+    });
+    if (toRowsAffected(result.rowsAffected) === 0) {
+      return {
+        id,
+        previousImportance: existing.importance,
+        importance: existing.importance,
+        updated: false
+      };
+    }
+    return {
+      id,
+      previousImportance: existing.importance,
+      importance,
+      updated: true
+    };
+  } finally {
+    resolvedDeps.closeDbFn(db);
+  }
+}
+
 // src/app/store-service.ts
 var KNOWLEDGE_TYPE_SET = new Set(KNOWLEDGE_TYPES);
 var EXPIRY_LEVEL_SET = new Set(EXPIRY_LEVELS);
@@ -6325,7 +6431,7 @@ function normalizeCanonicalKey(value) {
   }
   return normalized;
 }
-function normalizeImportance(value) {
+function normalizeImportance2(value) {
   const importanceRaw = typeof value === "number" ? value : Number(value);
   return Number.isInteger(importanceRaw) && importanceRaw >= IMPORTANCE_MIN && importanceRaw <= IMPORTANCE_MAX ? importanceRaw : 5;
 }
@@ -6358,7 +6464,7 @@ function normalizeStoreJsonEntry(raw, fallbackFile) {
     subject,
     canonical_key: normalizeCanonicalKey(record.canonical_key),
     content,
-    importance: normalizeImportance(record.importance),
+    importance: normalizeImportance2(record.importance),
     expiry: normalizeExpiry(record.expiry),
     tags: normalizeTags(record.tags),
     created_at: normalizeCreatedAt(record.created_at),
@@ -6485,7 +6591,7 @@ function normalizeStoreToolPayload(params, fallbackSourceFile, warn = () => void
       type,
       subject,
       content,
-      importance: normalizeImportance(entry.importance),
+      importance: normalizeImportance2(entry.importance),
       expiry: normalizedExpiry,
       tags: normalizeTags(entry.tags),
       source: {
@@ -6702,6 +6808,8 @@ export {
   recallSectionOrder,
   lookupRetireCandidates,
   executeRetire,
+  lookupUpdateCandidate,
+  executeUpdate,
   parseStoreJsonInput,
   normalizeStoreToolPayload,
   buildVirtualStoreBatch,

package/dist/cli-main.js

@@ -8,6 +8,7 @@ import {
   deduplicateEntries,
   ensurePluginDbTables,
   executeRetire,
+  executeUpdate,
   expandInputFiles,
   extractKnowledgeFromChunks,
   extractTextEntries,
@@ -27,6 +28,7 @@ import {
   getPendingReviews,
   isProjectWorthyOpenClawStoreEntry,
   lookupRetireCandidates,
+  lookupUpdateCandidate,
   normalizeKnowledgePlatform,
   parseStoreJsonInput,
   parseTranscriptFile,
@@ -39,7 +41,7 @@ import {
   runStoreService,
   runTraceService,
   ui
-} from "./chunk-JJZHOS4U.js";
+} from "./chunk-CEPFOYOL.js";
 import {
   ConflictAlreadyResolvedError,
   REVIEW_QUEUE_PATH,
@@ -64,6 +66,8 @@ import {
   ENTRY_SELECT_COLUMNS_WITH_EMBEDDING,
   EXPIRY_LEVELS,
   EmbeddingCache,
+  IMPORTANCE_MAX,
+  IMPORTANCE_MIN,
   KNOWLEDGE_PLATFORMS,
   KNOWLEDGE_TYPES,
   SCOPE_LEVELS,
@@ -170,7 +174,7 @@ import {
 } from "./chunk-UGIJJOPV.js";
 
 // src/cli-main.ts
-import * as clack18 from "@clack/prompts";
+import * as clack19 from "@clack/prompts";
 import { Command } from "commander";
 
 // src/auth-status.ts
@@ -6066,10 +6070,10 @@ function renderTextReport(stats, dryRun) {
 function createLogger2(jsonMode) {
   const useClack = process.stderr.isTTY && !jsonMode;
   if (!useClack) {
-    const log22 = createLogger("consolidate-cmd");
+    const log23 = createLogger("consolidate-cmd");
     return {
-      info: (message) => log22.info(message),
-      warn: (message) => log22.warn(message)
+      info: (message) => log23.info(message),
+      warn: (message) => log23.warn(message)
     };
   }
   const clackOutput = { output: process.stderr };
@@ -14010,6 +14014,27 @@ var TOOL_DEFINITIONS = [
         }
       }
     }
+  },
+  {
+    name: "agenr_update",
+    description: "Update an existing memory entry in place. Currently supports importance only.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["entry_id", "importance"],
+      properties: {
+        entry_id: {
+          type: "string",
+          description: "Entry id to update."
+        },
+        importance: {
+          type: "integer",
+          description: "New importance score.",
+          minimum: 1,
+          maximum: 10
+        }
+      }
+    }
   }
 ];
 function hasOwn(record, key) {
@@ -14259,12 +14284,12 @@ function createMcpServer(options = {}, deps = {}) {
   let dbInitPromise = null;
   let isStopped = false;
   let lineReader = null;
-  function log22(line) {
+  function log23(line) {
     errorOutput.write(`${line}
 `);
   }
   if (!scopedProjectDir) {
-    log22("warn: AGENR_PROJECT_DIR not set -- recall will return global (unscoped) results. Run agenr init to configure project scoping.");
+    log23("warn: AGENR_PROJECT_DIR not set -- recall will return global (unscoped) results. Run agenr init to configure project scoping.");
   }
   async function ensureDb() {
     if (!dbClient) {
@@ -14513,6 +14538,41 @@ function createMcpServer(options = {}, deps = {}) {
     const text4 = persist ? `${messageBase} Retirement will survive database re-ingest.` : messageBase;
     return text4;
   }
+  async function callUpdateTool(args) {
+    const entryId = typeof args.entry_id === "string" ? args.entry_id.trim() : "";
+    if (!entryId) {
+      throw new RpcError(JSON_RPC_INVALID_PARAMS, "entry_id is required");
+    }
+    const rawImportance = typeof args.importance === "number" ? args.importance : Number(args.importance);
+    if (!Number.isInteger(rawImportance) || rawImportance < 1 || rawImportance > 10) {
+      throw new RpcError(JSON_RPC_INVALID_PARAMS, "importance must be an integer between 1 and 10");
+    }
+    const db = await ensureDb();
+    const updateDeps = {
+      readConfigFn: resolvedDeps.readConfigFn,
+      getDbFn: () => db,
+      initDbFn: async () => void 0,
+      closeDbFn: () => void 0
+    };
+    const lookup = await lookupUpdateCandidate({
+      id: entryId,
+      dbPath: options.dbPath,
+      env
+    }, updateDeps);
+    if (!lookup.candidate) {
+      throw new RpcError(JSON_RPC_INVALID_PARAMS, `No active entry found with id: ${entryId}`);
+    }
+    const updated = await executeUpdate({
+      id: entryId,
+      importance: rawImportance,
+      dbPath: options.dbPath,
+      env
+    }, updateDeps);
+    if (!updated.updated) {
+      return `Not updated: ${lookup.candidate.subject} (type: ${lookup.candidate.type}) is no longer active.`;
+    }
+    return updated.previousImportance === updated.importance ? `Entry ${entryId} already has importance ${updated.importance}.` : `Updated: ${lookup.candidate.subject} (type: ${lookup.candidate.type}) importance ${updated.previousImportance} -> ${updated.importance}.`;
+  }
   async function dispatchToolCall(params) {
     try {
       if (params.name === "agenr_recall") {
@@ -14537,6 +14597,11 @@ function createMcpServer(options = {}, deps = {}) {
           content: [{ type: "text", text: await callRetireTool(params.args) }]
         };
       }
+      if (params.name === "agenr_update") {
+        return {
+          content: [{ type: "text", text: await callUpdateTool(params.args) }]
+        };
+      }
       throw new RpcError(JSON_RPC_INVALID_PARAMS, `Unknown tool: ${params.name}`);
     } catch (error) {
       if (error instanceof RpcError) {
@@ -14588,9 +14653,9 @@ function createMcpServer(options = {}, deps = {}) {
       const startupConfig = await resolvedDeps.readConfigFn();
       resolvedDeps.resolveEmbeddingApiKeyFn(startupConfig, env);
     } catch {
-      log22("[mcp] ERROR: OPENAI_API_KEY is required for embeddings but was not found.");
-      log22("[mcp] Set it via environment variable or run: agenr setup");
-      log22("[mcp] If using MCP, add it to your MCP server config env block.");
+      log23("[mcp] ERROR: OPENAI_API_KEY is required for embeddings but was not found.");
+      log23("[mcp] Set it via environment variable or run: agenr setup");
+      log23("[mcp] If using MCP, add it to your MCP server config env block.");
       process.exitCode = 1;
       return;
     }
@@ -14611,7 +14676,7 @@ function createMcpServer(options = {}, deps = {}) {
           continue;
         }
         if (verbose) {
-          log22(`[mcp] <= ${trimmed}`);
+          log23(`[mcp] <= ${trimmed}`);
         }
         let parsedJson;
         try {
@@ -14620,7 +14685,7 @@ function createMcpServer(options = {}, deps = {}) {
           const parseError = makeErrorResponse(null, JSON_RPC_PARSE_ERROR, "Parse error");
           await writeLine(output, parseError);
           if (verbose) {
-            log22(`[mcp] => ${JSON.stringify(parseError)}`);
+            log23(`[mcp] => ${JSON.stringify(parseError)}`);
           }
           continue;
         }
@@ -14632,13 +14697,13 @@ function createMcpServer(options = {}, deps = {}) {
           }
           await writeLine(output, response);
           if (verbose) {
-            log22(`[mcp] => ${JSON.stringify(response)}`);
+            log23(`[mcp] => ${JSON.stringify(response)}`);
           }
         } catch (error) {
           const normalized = error instanceof RpcError ? makeErrorResponse(idForError, error.code, error.message) : makeErrorResponse(idForError, JSON_RPC_INTERNAL_ERROR, "Internal error");
           await writeLine(output, normalized);
           if (verbose) {
-            log22(`[mcp] => ${JSON.stringify(normalized)}`);
+            log23(`[mcp] => ${JSON.stringify(normalized)}`);
           }
         }
       }
@@ -15767,11 +15832,83 @@ function registerTraceCommand(program) {
   );
 }
 
+// src/commands/update.ts
+import * as clack17 from "@clack/prompts";
+async function runUpdateCommand(options) {
+  const entryId = options.id?.trim() ?? "";
+  if (!entryId) {
+    throw new Error("id is required");
+  }
+  const importance = options.importance;
+  if (!Number.isInteger(importance) || importance < IMPORTANCE_MIN || importance > IMPORTANCE_MAX) {
+    throw new Error(`importance must be an integer between ${IMPORTANCE_MIN} and ${IMPORTANCE_MAX}`);
+  }
+  const clackOutput = { output: process.stderr };
+  clack17.intro(banner(), clackOutput);
+  const lookup = await lookupUpdateCandidate({
+    id: entryId,
+    dbPath: options.db
+  });
+  if (!lookup.candidate) {
+    clack17.log.warn(`No active entry found with id: ${entryId}`, clackOutput);
+    clack17.outro(void 0, clackOutput);
+    return { exitCode: 1 };
+  }
+  const candidate = lookup.candidate;
+  clack17.log.info(
+    `Entry: ${candidate.type} (importance: ${candidate.importance}) "${candidate.subject}"`,
+    clackOutput
+  );
+  if (options.force !== true) {
+    const confirmed = await clack17.confirm({
+      message: `Update importance from ${candidate.importance} to ${importance}?`
+    });
+    if (confirmed !== true) {
+      clack17.log.warn("Update canceled.", clackOutput);
+      clack17.outro(void 0, clackOutput);
+      return { exitCode: 1 };
+    }
+  }
+  const updated = await executeUpdate({
+    id: entryId,
+    importance,
+    dbPath: options.db
+  });
+  if (!updated.updated) {
+    clack17.log.warn(`No active entry found with id: ${entryId}`, clackOutput);
+    clack17.outro(void 0, clackOutput);
+    return { exitCode: 1 };
+  }
+  if (updated.previousImportance === updated.importance) {
+    clack17.log.success(`Entry ${entryId} already has importance ${updated.importance}.`, clackOutput);
+  } else {
+    clack17.log.success(
+      `Updated entry ${entryId} importance: ${updated.previousImportance} -> ${updated.importance}.`,
+      clackOutput
+    );
+  }
+  clack17.outro(void 0, clackOutput);
+  return { exitCode: 0 };
+}
+
+// src/cli/update.ts
+function registerUpdateCommand(program) {
+  program.command("update").description("Update mutable entry metadata in place").requiredOption("--id <id>", "Update a specific entry by its ID").requiredOption("--importance <n>", "New importance: 1-10").option("--force", "Skip confirmation prompt").option("--db <path>", "Path to database file").action(async (opts) => {
+    const result = await runUpdateCommand({
+      id: opts.id,
+      importance: Number(opts.importance),
+      force: opts.force === true,
+      db: opts.db
+    });
+    process.exitCode = result.exitCode;
+  });
+}
+
 // src/commands/watch.ts
 import fs26 from "fs/promises";
 import os12 from "os";
 import path25 from "path";
-import * as clack17 from "@clack/prompts";
+import * as clack18 from "@clack/prompts";
 
 // src/watch/watcher.ts
 import { watch as watchFs } from "fs";
@@ -16425,7 +16562,7 @@ async function runWatcher(options, deps) {
 }
 
 // src/commands/watch.ts
-var log20 = createLogger("watch");
+var log21 = createLogger("watch");
 function formatBytes2(value) {
   return value.toLocaleString("en-US");
 }
@@ -16697,11 +16834,11 @@ async function runWatchCommand(file, options, deps) {
   const clackOutput = { output: process.stderr };
   warnIfLocked();
   installSignalHandlers();
-  clack17.intro(banner(), clackOutput);
+  clack18.intro(banner(), clackOutput);
   try {
     await resolvedDeps.writeWatcherPidFn();
   } catch (error) {
-    clack17.log.error(
+    clack18.log.error(
       formatError(`Failed to write watcher PID file: ${toErrorMessage(error)}`),
       clackOutput
     );
@@ -16736,7 +16873,7 @@ async function runWatchCommand(file, options, deps) {
       return { version: 1, files: {} };
     });
     if (stateWarning) {
-      clack17.log.warn(formatWarn(stateWarning), clackOutput);
+      clack18.log.warn(formatWarn(stateWarning), clackOutput);
       await resolvedDeps.saveWatchStateFn(state);
     }
     const fileState = modeConfig.filePath ? getFileState(state, modeConfig.filePath) : void 0;
@@ -16744,11 +16881,11 @@ async function runWatchCommand(file, options, deps) {
     const config = resolvedDeps.readConfigFn(process.env);
     const dbPath = options.db?.trim() || config?.db?.path || "~/.agenr/knowledge.db";
     if (modeConfig.mode === "file") {
-      clack17.log.info(formatLabel("Watching", modeConfig.filePath ?? "(unknown)"), clackOutput);
+      clack18.log.info(formatLabel("Watching", modeConfig.filePath ?? "(unknown)"), clackOutput);
     } else if (modeConfig.mode === "dir") {
-      clack17.log.info(formatLabel("Watching directory", modeConfig.sessionsDir ?? "(unknown)"), clackOutput);
-      clack17.log.info(formatLabel("Platform", modeConfig.platform ?? "mtime"), clackOutput);
-      clack17.log.info(
+      clack18.log.info(formatLabel("Watching directory", modeConfig.sessionsDir ?? "(unknown)"), clackOutput);
+      clack18.log.info(formatLabel("Platform", modeConfig.platform ?? "mtime"), clackOutput);
+      clack18.log.info(
         formatLabel(
           "Active file",
           modeConfig.filePath ? formatSwitchLabel(modeConfig.filePath) : "(waiting for session file)"
@@ -16756,22 +16893,22 @@ async function runWatchCommand(file, options, deps) {
         clackOutput
       );
     }
-    clack17.log.info(
+    clack18.log.info(
       `${formatLabel("Interval", formatInterval(intervalMs))} | ${formatLabel("Min chunk", `${minChunkChars} chars`)}`,
       clackOutput
     );
-    clack17.log.info(
+    clack18.log.info(
       `${formatLabel("Offset", `${formatBytes2(offset)} bytes (${fileState ? "resume" : "fresh"})`)} | ${formatLabel("DB", dbPath)}`,
       clackOutput
     );
-    clack17.log.info("", clackOutput);
-    clack17.log.info("Waiting for changes...", clackOutput);
+    clack18.log.info("", clackOutput);
+    clack18.log.info("Waiting for changes...", clackOutput);
     const emitWatchWarning = (message) => {
       if (message.startsWith("Filtered:")) {
-        clack17.log.info(message, clackOutput);
+        clack18.log.info(message, clackOutput);
         return;
       }
-      clack17.log.warn(formatWarn(message), clackOutput);
+      clack18.log.warn(formatWarn(message), clackOutput);
     };
     let cycleCount = 0;
     let contextChain = Promise.resolve();
@@ -16799,7 +16936,7 @@ async function runWatchCommand(file, options, deps) {
         onSwitch: (from, to, platform) => {
           const fromLabel = from ? formatSwitchLabel(from) : "(none)";
           const platformLabel = platform ? ` [${platform}]` : "";
-          clack17.log.info(`Switched watch file${platformLabel}: ${fromLabel} -> ${formatSwitchLabel(to)}`, clackOutput);
+          clack18.log.info(`Switched watch file${platformLabel}: ${fromLabel} -> ${formatSwitchLabel(to)}`, clackOutput);
         },
         onCycle: (result, ctx) => {
           cycleCount += 1;
@@ -16811,29 +16948,29 @@ async function runWatchCommand(file, options, deps) {
 `);
           }
           if (result.error) {
-            clack17.log.warn(formatWarn(`[${timestamp}] Cycle ${cycleCount}: ${result.error}${fileLabel}`), clackOutput);
+            clack18.log.warn(formatWarn(`[${timestamp}] Cycle ${cycleCount}: ${result.error}${fileLabel}`), clackOutput);
             return;
           }
           if (result.skipped) {
             if (result.bytesRead > 0) {
-              clack17.log.info(
+              clack18.log.info(
                 `[${timestamp}] Cycle ${cycleCount}: +${formatBytes2(result.bytesRead)} bytes (below threshold, skipping)${fileLabel}`,
                 clackOutput
               );
             } else if (once2 || verbose) {
-              clack17.log.info(`[${timestamp}] Cycle ${cycleCount}: no new content${fileLabel}`, clackOutput);
+              clack18.log.info(`[${timestamp}] Cycle ${cycleCount}: no new content${fileLabel}`, clackOutput);
             }
             return;
           }
           if (dryRun) {
-            clack17.log.info(
+            clack18.log.info(
               `[${timestamp}] Cycle ${cycleCount}: +${formatBytes2(result.bytesRead)} bytes | ${result.entriesExtracted} entries extracted (dry-run)${fileLabel}`,
               clackOutput
             );
             return;
           }
           const deduped = Math.max(0, result.entriesExtracted - result.entriesStored);
-          clack17.log.info(
+          clack18.log.info(
             `[${timestamp}] Cycle ${cycleCount}: +${formatBytes2(result.bytesRead)} bytes | ${result.entriesExtracted} entries extracted | ${result.entriesStored} stored, ${deduped} deduped${fileLabel}`,
             clackOutput
           );
@@ -16885,11 +17022,11 @@ async function runWatchCommand(file, options, deps) {
         emitWatchWarning(`Context DB close failed: ${toErrorMessage(error)}`);
       }
     }
-    clack17.log.info(
+    clack18.log.info(
       `Summary: ${summary.cycles} cycles | ${summary.entriesStored} entries stored | watched for ${formatDuration(summary.durationMs)}`,
       clackOutput
     );
-    clack17.outro(void 0, clackOutput);
+    clack18.outro(void 0, clackOutput);
     return {
       exitCode: 0,
       cycles: summary.cycles,
@@ -16912,7 +17049,7 @@ async function runWatchCommand(file, options, deps) {
       }
     } else {
       const forceExitTimer = setTimeout(() => {
-        log20.warn("Force exit after timeout");
+        log21.warn("Force exit after timeout");
         resolvedDeps.exitProcessFn(1);
       }, resolvedDeps.shutdownTimeoutMs);
       forceExitTimer.unref();
@@ -16983,12 +17120,12 @@ function createProgram() {
   program.enablePositionalOptions();
   program.name("agenr").description("Memory infrastructure for AI agents").version(APP_VERSION).action(async () => {
     const quick = getQuickStatus(process.env);
-    clack18.intro(banner());
+    clack19.intro(banner());
     if (!quick.configured) {
-      clack18.note("Not configured", "Status");
-      clack18.log.warn("Run " + ui.bold("agenr setup") + " to get started.");
+      clack19.note("Not configured", "Status");
+      clack19.log.warn("Run " + ui.bold("agenr setup") + " to get started.");
     } else if (quick.credentialAvailable) {
-      clack18.note(
+      clack19.note(
         [
           formatLabel("Provider", quick.provider ?? "(not set)"),
           formatLabel("Model", quick.model ?? "(not set)"),
@@ -16998,7 +17135,7 @@ function createProgram() {
         "Ready"
       );
     } else {
-      clack18.note(
+      clack19.note(
         [
           formatLabel("Provider", quick.provider ?? "(not set)"),
           formatLabel("Model", quick.model ?? "(not set)"),
@@ -17006,16 +17143,17 @@ function createProgram() {
         ].join("\n"),
         "Not authenticated"
       );
-      clack18.log.warn(quick.guidance);
+      clack19.log.warn(quick.guidance);
     }
     program.outputHelp();
-    clack18.outro(ui.dim("https://agenr.ai"));
+    clack19.outro(ui.dim("https://agenr.ai"));
   });
   registerExtractCommand(program);
   registerStoreCommand(program);
   registerRecallCommand(program);
   registerRetireCommand(program);
   registerTraceCommand(program);
+  registerUpdateCommand(program);
   registerReviewCommand(program);
   registerEdgesCommand(program);
   registerSyntheticCommand(program);

package/dist/openclaw-plugin/index.js

@@ -5,17 +5,19 @@ import {
   clearSessionProject,
   ensurePluginDb,
   executeRetire,
+  executeUpdate,
   extractTextEntries,
   getSessionProject,
   getSessionProjectState,
   lookupRetireCandidates,
+  lookupUpdateCandidate,
   normalizeStoreToolPayload,
   resolveProjectWorthySessionProject,
   runRecallService,
   runStoreService,
   runTraceService,
   setSessionProject
-} from "../chunk-JJZHOS4U.js";
+} from "../chunk-CEPFOYOL.js";
 import {
   KNOWLEDGE_TYPES,
   SCOPE_LEVELS,
@@ -635,7 +637,8 @@ __export(recall_exports, {
   resolveAgenrPath: () => resolveAgenrPath,
   resolveBudget: () => resolveBudget,
   runMemoryIndex: () => runMemoryIndex,
-  runRecall: () => runRecall
+  runRecall: () => runRecall,
+  runRecallStrict: () => runRecallStrict
 });
 import path from "path";
 import { fileURLToPath } from "url";
@@ -773,34 +776,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;
   }
@@ -1668,6 +1682,53 @@ async function runRetireTool(_agenrPath, params, dbPath) {
     };
   }
 }
+async function runUpdateTool(_agenrPath, params, dbPath) {
+  try {
+    const entryId = asString(params.entry_id);
+    const importance = asNumber(params.importance);
+    if (!entryId) {
+      return {
+        content: [{ type: "text", text: "agenr_update failed: entry_id is required" }]
+      };
+    }
+    if (!Number.isInteger(importance) || importance < 1 || importance > 10) {
+      return {
+        content: [{ type: "text", text: "agenr_update failed: importance must be an integer between 1 and 10" }]
+      };
+    }
+    const lookup = await lookupUpdateCandidate({
+      id: entryId,
+      dbPath
+    });
+    if (!lookup.candidate) {
+      return {
+        content: [{ type: "text", text: `agenr_update failed: No active entry found with id: ${entryId}` }]
+      };
+    }
+    const updated = await executeUpdate({
+      id: entryId,
+      importance,
+      dbPath
+    });
+    if (!updated.updated) {
+      return {
+        content: [{ type: "text", text: `Entry ${entryId} was not updated because it is no longer active.` }]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: updated.previousImportance === updated.importance ? `Entry ${entryId} already has importance ${updated.importance}.` : `Updated entry ${entryId} importance: ${updated.previousImportance} -> ${updated.importance}.`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `agenr_update failed: ${toErrorMessage(error)}` }]
+    };
+  }
+}
 async function runTraceTool(_agenrPath, params, dbPath) {
   try {
     const entryId = asString(params.entry_id);
@@ -4592,6 +4653,7 @@ 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(",")}]`;
@@ -4611,6 +4673,59 @@ function describeMemoryIndexResult(result) {
       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(
@@ -4629,18 +4744,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)}`);
@@ -4660,12 +4765,16 @@ async function fetchSessionStartRecallData(currentSessionProjectKey, params) {
     "session-start",
     `core recall returned ${coreResult?.results.length ?? 0} entries (configured coreProjects=${formatConfiguredCoreProjects(coreProjects)})`
   );
-  debugLog(params.debug, "session-start", `browse returned ${browseResult?.results.length ?? 0} entries`);
-  debugLog(
-    params.debug,
-    "session-start",
-    describeMemoryIndexResult(memoryIndexResult)
-  );
+  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,
@@ -6279,6 +6388,26 @@ function registerAgenrTools(api, params) {
       }
     }
   );
+  api.registerTool(
+    {
+      name: "agenr_update",
+      label: "Agenr Update",
+      description: "Update an existing memory entry in place. Currently supports importance only.",
+      parameters: Type.Object({
+        entry_id: Type.String({ description: "Entry ID to update." }),
+        importance: Type.Integer({ minimum: 1, maximum: 10, description: "New importance score." })
+      }),
+      async execute(_toolCallId, toolParams) {
+        const runtimeConfig = api.pluginConfig;
+        if (runtimeConfig?.enabled === false) {
+          return makeDisabledToolResult();
+        }
+        const agenrPath = resolveAgenrPath(runtimeConfig);
+        const dbPath = runtimeConfig?.dbPath;
+        return runUpdateTool(agenrPath, toolParams, dbPath);
+      }
+    }
+  );
   api.registerTool(
     {
       name: "agenr_trace",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "0.9.79",
+  "version": "0.9.81",
   "openclaw": {
     "extensions": [
       "dist/openclaw-plugin/index.js"
@@ -11,19 +11,6 @@
   "bin": {
     "agenr": "dist/cli.js"
   },
-  "scripts": {
-    "build": "tsup src/cli.ts src/cli-main.ts src/openclaw-plugin/index.ts --format esm --dts --clean",
-    "check": "pnpm format:check && pnpm lint && pnpm typecheck && pnpm test",
-    "dev": "tsup src/cli.ts src/cli-main.ts --format esm --watch",
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "verify:dist": "node scripts/verify-dist.js",
-    "prepack": "pnpm build && pnpm verify:dist"
-  },
   "dependencies": {
     "@clack/prompts": "^1.0.1",
     "@libsql/client": "^0.17.0",
@@ -72,9 +59,16 @@
     "README.md"
   ],
   "author": "agenr-ai",
-  "pnpm": {
-    "overrides": {
-      "fast-xml-parser": "^5.3.6"
-    }
+  "scripts": {
+    "build": "tsup src/cli.ts src/cli-main.ts src/openclaw-plugin/index.ts --format esm --dts --clean",
+    "check": "pnpm format:check && pnpm lint && pnpm typecheck && pnpm test",
+    "dev": "tsup src/cli.ts src/cli-main.ts --format esm --watch",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "verify:dist": "node scripts/verify-dist.js"
   }
-}
+}