clawvault 3.4.1 → 3.5.1

package/dist/{chunk-PLNK37JD.js → chunk-P35SHNAU.js}

@@ -1,9 +1,22 @@
 import {
   buildRecallResult
 } from "./chunk-RL2L6I6K.js";
+import {
+  recover
+} from "./chunk-OIWVQYQF.js";
+import {
+  buildSessionRecap
+} from "./chunk-ZKGY7WTT.js";
+import {
+  checkpoint,
+  flush
+} from "./chunk-F55HGNU4.js";
 import {
   synthesizeEntityProfiles
 } from "./chunk-NSXYM6EZ.js";
+import {
+  runReflection
+} from "./chunk-TWMI3SNN.js";
 import {
   normalizeForDedup,
   similarityScore
@@ -707,7 +720,7 @@ import * as fs4 from "fs";
 import * as path4 from "path";
 
 // src/plugin/clawvault-cli.ts
-import { execFileSync } from "child_process";
+import { execFileSync, spawn } from "child_process";
 import * as fs3 from "fs";
 import * as path3 from "path";
 
@@ -806,8 +819,6 @@ function verifyExecutableIntegrity(executablePath, expectedSha256) {
 
 // src/plugin/clawvault-cli.ts
 var MAX_CONTEXT_PROMPT_LENGTH = 500;
-var MAX_CONTEXT_SNIPPET_LENGTH = 220;
-var MAX_RECAP_SNIPPET_LENGTH = 220;
 var CLAWVAULT_EXECUTABLE = "clawvault";
 var ONE_KIB = 1024;
 var ONE_MIB = ONE_KIB * ONE_KIB;
@@ -823,139 +834,6 @@ function sanitizePromptForContext(value) {
   if (typeof value !== "string") return "";
   return value.replace(/[\x00-\x1f\x7f]/g, " ").replace(/\s+/g, " ").trim().slice(0, MAX_CONTEXT_PROMPT_LENGTH);
 }
-function truncateSnippet(snippet) {
-  const safe = sanitizeForDisplay(snippet).replace(/\s+/g, " ").trim();
-  if (safe.length <= MAX_CONTEXT_SNIPPET_LENGTH) return safe;
-  return `${safe.slice(0, MAX_CONTEXT_SNIPPET_LENGTH - 3).trimEnd()}...`;
-}
-function truncateRecapSnippet(snippet) {
-  const safe = sanitizeForDisplay(snippet).replace(/\s+/g, " ").trim();
-  if (safe.length <= MAX_RECAP_SNIPPET_LENGTH) return safe;
-  return `${safe.slice(0, MAX_RECAP_SNIPPET_LENGTH - 3).trimEnd()}...`;
-}
-function isRecord2(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function parseTopLevelJson(output) {
-  const text = output.trim();
-  if (!text) return null;
-  const tryParse = (candidate) => {
-    try {
-      const parsed = JSON.parse(candidate);
-      return isRecord2(parsed) ? parsed : null;
-    } catch {
-      return null;
-    }
-  };
-  const direct = tryParse(text);
-  if (direct) return direct;
-  const findJsonEnd = (start) => {
-    const open = text[start];
-    if (open !== "{" && open !== "[") return -1;
-    const stack = [open];
-    let inString = false;
-    let escaped = false;
-    for (let i = start + 1; i < text.length; i += 1) {
-      const ch = text[i];
-      if (inString) {
-        if (escaped) {
-          escaped = false;
-          continue;
-        }
-        if (ch === "\\") {
-          escaped = true;
-          continue;
-        }
-        if (ch === '"') {
-          inString = false;
-        }
-        continue;
-      }
-      if (ch === '"') {
-        inString = true;
-        continue;
-      }
-      if (ch === "{" || ch === "[") {
-        stack.push(ch);
-        continue;
-      }
-      if (ch === "}" || ch === "]") {
-        const expected = ch === "}" ? "{" : "[";
-        const top = stack[stack.length - 1];
-        if (top !== expected) return -1;
-        stack.pop();
-        if (stack.length === 0) {
-          return i;
-        }
-      }
-    }
-    return -1;
-  };
-  for (let start = 0; start < text.length; start += 1) {
-    const ch = text[start];
-    if (ch !== "{" && ch !== "[") continue;
-    const end = findJsonEnd(start);
-    if (end < 0) continue;
-    const parsed = tryParse(text.slice(start, end + 1));
-    if (parsed) return parsed;
-  }
-  return null;
-}
-function resolveEntryArray(parsed, keys) {
-  for (const key of keys) {
-    const value = parsed[key];
-    if (!Array.isArray(value)) continue;
-    return value.filter((item) => isRecord2(item));
-  }
-  return [];
-}
-function parseContextJson(output, maxResults) {
-  const parsed = parseTopLevelJson(output);
-  if (!parsed) {
-    return [];
-  }
-  const rows = resolveEntryArray(parsed, ["context", "results", "entries", "memories"]);
-  return rows.slice(0, maxResults).map((entry) => {
-    const nestedDocument = isRecord2(entry.document) ? entry.document : null;
-    const title = sanitizeForDisplay(
-      entry.title ?? nestedDocument?.title ?? nestedDocument?.id ?? entry.path ?? "Untitled"
-    );
-    const resolvedPath = sanitizeForDisplay(
-      entry.path ?? entry.relPath ?? nestedDocument?.path ?? ""
-    );
-    const resolvedAge = sanitizeForDisplay(entry.age ?? entry.modified ?? "unknown age");
-    const snippetSource = String(
-      entry.snippet ?? entry.text ?? entry.content ?? nestedDocument?.snippet ?? nestedDocument?.content ?? ""
-    );
-    return {
-      title,
-      path: resolvedPath,
-      age: resolvedAge,
-      snippet: truncateSnippet(snippetSource),
-      score: Number.isFinite(Number(entry.score)) ? Number(entry.score) : 0
-    };
-  }).filter((entry) => entry.snippet.length > 0);
-}
-function parseSessionRecapJson(output, maxResults) {
-  const parsed = parseTopLevelJson(output);
-  if (!parsed) {
-    return [];
-  }
-  const rows = resolveEntryArray(parsed, ["messages", "turns", "recap"]);
-  return rows.map((entry) => {
-    const role = typeof entry.role === "string" ? entry.role.toLowerCase() : "";
-    const normalizedRole = role === "user" || role === "human" ? "User" : role === "assistant" || role === "ai" ? "Assistant" : "";
-    if (!normalizedRole) return null;
-    const text = truncateRecapSnippet(
-      typeof entry.text === "string" ? entry.text : typeof entry.content === "string" ? entry.content : ""
-    );
-    if (!text) return null;
-    return {
-      role: normalizedRole,
-      text
-    };
-  }).filter((entry) => Boolean(entry)).slice(-maxResults);
-}
 function formatSessionContextInjection(recapEntries, memoryEntries) {
   const lines = [
     "[ClawVault] Session context restored:",
@@ -983,82 +861,6 @@ function formatSessionContextInjection(recapEntries, memoryEntries) {
 function resolveVaultPathForAgent(pluginConfig, options = {}) {
   return findVaultPath(pluginConfig, options);
 }
-function runClawvault(args, pluginConfig, options = {}) {
-  if (!isOptInEnabled(pluginConfig, "allowClawvaultExec")) {
-    return {
-      success: false,
-      skipped: true,
-      output: "ClawVault CLI execution is disabled. Set allowClawvaultExec=true to enable.",
-      code: 0
-    };
-  }
-  const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(1e3, Number(options.timeoutMs)) : 15e3;
-  const executablePath = resolveExecutablePath(CLAWVAULT_EXECUTABLE, {
-    explicitPath: getConfiguredExecutablePath(pluginConfig)
-  });
-  if (!executablePath) {
-    return {
-      success: false,
-      output: "Unable to resolve clawvault executable path.",
-      code: 1
-    };
-  }
-  const expectedSha256 = getConfiguredExecutableSha256(pluginConfig);
-  const integrityResult = verifyExecutableIntegrity(executablePath, expectedSha256);
-  if (!integrityResult.ok) {
-    return {
-      success: false,
-      output: `Executable integrity verification failed for ${executablePath}.`,
-      code: 1
-    };
-  }
-  let sanitizedArgs;
-  try {
-    sanitizedArgs = sanitizeExecArgs(args);
-  } catch (error) {
-    return {
-      success: false,
-      output: error instanceof Error ? error.message : "Invalid command arguments",
-      code: 1
-    };
-  }
-  try {
-    const output = execFileSync(executablePath, sanitizedArgs, {
-      encoding: "utf-8",
-      timeout: timeoutMs,
-      stdio: ["pipe", "pipe", "pipe"],
-      shell: false
-    });
-    return {
-      success: true,
-      output: output.trim(),
-      code: 0
-    };
-  } catch (error) {
-    const details = error;
-    return {
-      success: false,
-      output: details.stderr?.toString() || details.message || "unknown error",
-      code: details.status || 1
-    };
-  }
-}
-function parseRecoveryOutput(output) {
-  if (!output || typeof output !== "string") {
-    return { hadDeath: false, workingOn: null };
-  }
-  const hadDeath = output.includes("Context death detected") || output.includes("died") || output.includes("\u26A0\uFE0F");
-  if (!hadDeath) {
-    return { hadDeath: false, workingOn: null };
-  }
-  const workingOnLine = output.split("\n").find((line) => line.toLowerCase().includes("working on"));
-  if (!workingOnLine) {
-    return { hadDeath: true, workingOn: null };
-  }
-  const parts = workingOnLine.split(":");
-  const workingOn = parts.length > 1 ? sanitizeForDisplay(parts.slice(1).join(":").trim()) : null;
-  return { hadDeath: true, workingOn: workingOn || null };
-}
 function getObserveCursorPath(vaultPath) {
   return path3.join(vaultPath, ".clawvault", OBSERVE_CURSOR_FILE);
 }
@@ -1141,12 +943,40 @@ function shouldObserveActiveSessions(vaultPath, agentId, pluginConfig) {
   return false;
 }
 function runObserverCron(vaultPath, agentId, pluginConfig, options = {}) {
+  if (!isOptInEnabled(pluginConfig, "allowClawvaultExec")) {
+    return false;
+  }
+  const executablePath = resolveExecutablePath(CLAWVAULT_EXECUTABLE, {
+    explicitPath: getConfiguredExecutablePath(pluginConfig)
+  });
+  if (!executablePath) {
+    return false;
+  }
+  const expectedSha256 = getConfiguredExecutableSha256(pluginConfig);
+  const integrityResult = verifyExecutableIntegrity(executablePath, expectedSha256);
+  if (!integrityResult.ok) {
+    return false;
+  }
   const args = ["observe", "--cron", "--agent", agentId, "-v", vaultPath];
   if (Number.isFinite(options.minNewBytes) && Number(options.minNewBytes) > 0) {
     args.push("--min-new", String(Math.floor(Number(options.minNewBytes))));
   }
-  const result = runClawvault(args, pluginConfig, { timeoutMs: 12e4 });
-  return !result.skipped && result.success;
+  let sanitizedArgs;
+  try {
+    sanitizedArgs = sanitizeExecArgs(args);
+  } catch {
+    return false;
+  }
+  try {
+    const child = spawn(executablePath, sanitizedArgs, {
+      stdio: "ignore",
+      shell: false
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
 }
 function resolveSessionKey(input) {
   return sanitizeSessionKey(input);
@@ -1222,8 +1052,8 @@ function toSafeFilePath(vaultPath, relPath) {
   if (!mapped || mapped.includes("..")) {
     throw new Error("Invalid memory path");
   }
-  if (!mapped.toLowerCase().endsWith(".md")) {
-    throw new Error("memory_get only allows Markdown note paths inside the vault");
+  if (mapped !== "MEMORY.md" && !mapped.startsWith("memory/")) {
+    throw new Error("memory_get only allows MEMORY.md or memory/* paths");
   }
   const absolute = path4.resolve(vaultPath, mapped);
   const vaultRootWithSep = vaultPath.endsWith(path4.sep) ? vaultPath : `${vaultPath}${path4.sep}`;
@@ -1350,17 +1180,8 @@ function buildToolSchema(properties, required = []) {
     additionalProperties: false
   };
 }
-function resolveToolInput(toolCallIdOrInput, maybeInput) {
-  if (maybeInput && typeof maybeInput === "object" && !Array.isArray(maybeInput)) {
-    return maybeInput;
-  }
-  if (toolCallIdOrInput && typeof toolCallIdOrInput === "object" && !Array.isArray(toolCallIdOrInput)) {
-    return toolCallIdOrInput;
-  }
-  return {};
-}
 function createMemorySearchToolFactory(memoryManager) {
-  return (_toolContext) => {
+  return () => {
     const inputSchema = buildToolSchema({
       query: {
         type: "string",
@@ -1383,8 +1204,7 @@ function createMemorySearchToolFactory(memoryManager) {
         description: "Optional OpenClaw session key for scoped recall."
       }
     }, ["query"]);
-    const execute = async (toolCallIdOrInput, maybeInput) => {
-      const input = resolveToolInput(toolCallIdOrInput, maybeInput);
+    const execute = async (input) => {
       const query = typeof input.query === "string" ? input.query : "";
       if (!query.trim()) {
         return { query, count: 0, results: [] };
@@ -1401,7 +1221,6 @@ function createMemorySearchToolFactory(memoryManager) {
       };
     };
     return {
-      label: "Memory Search",
       name: "memory_search",
       description: "Search ClawVault memory for relevant snippets before answering.",
       inputSchema,
@@ -1414,15 +1233,11 @@ function createMemorySearchToolFactory(memoryManager) {
   };
 }
 function createMemoryGetToolFactory(memoryManager) {
-  return (_toolContext) => {
+  return () => {
     const inputSchema = buildToolSchema({
-      path: {
-        type: "string",
-        description: "Relative path from memory_search result (for OpenClaw compatibility)."
-      },
       relPath: {
         type: "string",
-        description: "Alias of path (e.g. memory/2026-01-01.md)."
+        description: "Relative path from memory_search result (e.g. memory/2026-01-01.md)."
       },
       from: {
         type: "number",
@@ -1435,11 +1250,9 @@ function createMemoryGetToolFactory(memoryManager) {
         maximum: 400,
         description: "Optional number of lines to read."
       }
-    });
-    inputSchema.anyOf = [{ required: ["path"] }, { required: ["relPath"] }];
-    const execute = async (toolCallIdOrInput, maybeInput) => {
-      const input = resolveToolInput(toolCallIdOrInput, maybeInput);
-      const relPath = typeof input.path === "string" ? input.path : typeof input.relPath === "string" ? input.relPath : "";
+    }, ["relPath"]);
+    const execute = async (input) => {
+      const relPath = typeof input.relPath === "string" ? input.relPath : "";
       if (!relPath.trim()) {
         return { path: relPath, text: "" };
       }
@@ -1450,7 +1263,6 @@ function createMemoryGetToolFactory(memoryManager) {
       });
     };
     return {
-      label: "Memory Get",
       name: "memory_get",
       description: "Read a specific memory file or line range from ClawVault.",
       inputSchema,
@@ -1575,20 +1387,82 @@ function rewriteQuestionWithMemoryEvidence(originalContent, memoryHits) {
 }
 
 // src/plugin/vault-context-injector.ts
+import * as path5 from "path";
 var DEFAULT_MAX_CONTEXT_RESULTS = 4;
 var DEFAULT_MAX_RECAP_RESULTS = 6;
+var DEFAULT_MIN_SCORE2 = 0.2;
+var MAX_CONTEXT_SNIPPET_LENGTH = 220;
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+function clamp2(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function truncateContextSnippet(snippet) {
+  const normalized = sanitizeForDisplay(snippet).replace(/\s+/g, " ").trim();
+  if (normalized.length <= MAX_CONTEXT_SNIPPET_LENGTH) {
+    return normalized;
+  }
+  return `${normalized.slice(0, MAX_CONTEXT_SNIPPET_LENGTH - 3).trimEnd()}...`;
+}
+function toRelativeVaultPath(vaultPath, absolutePath) {
+  const rel = path5.relative(vaultPath, absolutePath).replace(/\\/g, "/");
+  return rel.startsWith(".") ? path5.basename(absolutePath) : rel;
+}
+function formatAgeLabel(modifiedAt) {
+  const modified = modifiedAt.getTime();
+  if (!Number.isFinite(modified)) {
+    return "unknown age";
+  }
+  const elapsedMs = Date.now() - modified;
+  if (elapsedMs < ONE_DAY_MS) {
+    return "today";
+  }
+  const days = Math.max(1, Math.floor(elapsedMs / ONE_DAY_MS));
+  if (days < 7) {
+    return `${days}d ago`;
+  }
+  const weeks = Math.floor(days / 7);
+  if (weeks < 5) {
+    return `${weeks}w ago`;
+  }
+  const months = Math.floor(days / 30);
+  if (months < 12) {
+    return `${months}mo ago`;
+  }
+  const years = Math.floor(days / 365);
+  return `${years}y ago`;
+}
+function mapSearchResultToContextEntry(vaultPath, result) {
+  const snippet = truncateContextSnippet(result.snippet);
+  if (!snippet) {
+    return null;
+  }
+  return {
+    title: sanitizeForDisplay(result.document.title || "Untitled"),
+    path: sanitizeForDisplay(toRelativeVaultPath(vaultPath, result.document.path)),
+    age: formatAgeLabel(result.document.modified),
+    snippet,
+    score: Number.isFinite(result.score) ? result.score : 0
+  };
+}
 async function fetchSessionRecapEntries(options) {
   const sessionKey = resolveSessionKey(options.sessionKey);
   if (!sessionKey) return [];
-  const recapArgs = ["session-recap", sessionKey, "--format", "json"];
-  if (options.agentId) {
-    recapArgs.push("--agent", options.agentId);
-  }
-  const recapResult = runClawvault(recapArgs, options.pluginConfig, { timeoutMs: 2e4 });
-  if (!recapResult.success) {
+  try {
+    const recap = await buildSessionRecap(sessionKey, {
+      agentId: options.agentId,
+      limit: DEFAULT_MAX_RECAP_RESULTS
+    });
+    return recap.messages.slice(-DEFAULT_MAX_RECAP_RESULTS).map((entry) => {
+      const text = sanitizeForDisplay(entry.text);
+      if (!text) return null;
+      return {
+        role: entry.role === "user" ? "User" : "Assistant",
+        text
+      };
+    }).filter((entry) => Boolean(entry));
+  } catch {
     return [];
   }
-  return parseSessionRecapJson(recapResult.output, DEFAULT_MAX_RECAP_RESULTS);
 }
 async function fetchMemoryContextEntries(options) {
   const prompt = sanitizePromptForContext(options.prompt);
@@ -1602,44 +1476,20 @@ async function fetchMemoryContextEntries(options) {
   if (!vaultPath) {
     return { entries: [], vaultPath: null };
   }
-  const maxResults = Number.isFinite(options.maxResults) ? Math.max(1, Math.min(20, Number(options.maxResults))) : DEFAULT_MAX_CONTEXT_RESULTS;
-  const profile = options.contextProfile ?? options.pluginConfig.contextProfile ?? "auto";
-  const contextArgs = [
-    "context",
-    prompt,
-    "--format",
-    "json",
-    "--profile",
-    profile,
-    "--limit",
-    String(maxResults),
-    "-v",
-    vaultPath
-  ];
-  const contextResult = runClawvault(contextArgs, options.pluginConfig, { timeoutMs: 25e3 });
-  if (contextResult.success) {
-    return {
-      entries: parseContextJson(contextResult.output, maxResults),
-      vaultPath
-    };
-  }
-  const fallbackSearchArgs = [
-    "search",
-    prompt,
-    "--json",
-    "-n",
-    String(maxResults),
-    "-v",
-    vaultPath
-  ];
-  const fallbackSearchResult = runClawvault(fallbackSearchArgs, options.pluginConfig, { timeoutMs: 25e3 });
-  if (!fallbackSearchResult.success) {
+  const maxResults = Number.isFinite(options.maxResults) ? clamp2(Math.floor(Number(options.maxResults)), 1, 20) : DEFAULT_MAX_CONTEXT_RESULTS;
+  try {
+    const vault = new ClawVault(vaultPath);
+    await vault.load();
+    const matches = await vault.find(prompt, {
+      limit: maxResults,
+      minScore: DEFAULT_MIN_SCORE2,
+      temporalBoost: true
+    });
+    const entries = matches.map((match) => mapSearchResultToContextEntry(vaultPath, match)).filter((entry) => Boolean(entry));
+    return { entries, vaultPath };
+  } catch {
     return { entries: [], vaultPath };
   }
-  return {
-    entries: parseContextJson(fallbackSearchResult.output, maxResults),
-    vaultPath
-  };
 }
 async function buildVaultContextInjection(options) {
   const [recapEntries, memoryResult] = await Promise.all([
@@ -1761,13 +1611,13 @@ function createMessageSendingHandler(dependencies) {
 
 // src/plugin/fact-extractor.ts
 import * as fs5 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 import { createHash as createHash2 } from "crypto";
 var FACTS_FILE = "facts.jsonl";
 var ENTITY_GRAPH_FILE = "entity-graph.json";
 var MAX_TEXT_LENGTH = 6e3;
 function ensureClawVaultDir(vaultPath) {
-  const dir = path5.join(vaultPath, ".clawvault");
+  const dir = path6.join(vaultPath, ".clawvault");
   if (!fs5.existsSync(dir)) {
     fs5.mkdirSync(dir, { recursive: true });
   }
@@ -1887,7 +1737,7 @@ function buildEntityGraph(facts) {
   };
 }
 function ensureFactsLogFile(vaultPath) {
-  const filePath = path5.join(ensureClawVaultDir(vaultPath), FACTS_FILE);
+  const filePath = path6.join(ensureClawVaultDir(vaultPath), FACTS_FILE);
   if (!fs5.existsSync(filePath)) {
     fs5.writeFileSync(filePath, "", "utf-8");
   }
@@ -1900,7 +1750,7 @@ function persistFactsAndGraph(vaultPath, extractedFacts) {
   store.save();
   const allFacts = store.getAllFacts();
   const graph = buildEntityGraph(allFacts);
-  const graphPath = path5.join(ensureClawVaultDir(vaultPath), ENTITY_GRAPH_FILE);
+  const graphPath = path6.join(ensureClawVaultDir(vaultPath), ENTITY_GRAPH_FILE);
   fs5.writeFileSync(graphPath, `${JSON.stringify(graph, null, 2)}
 `, "utf-8");
   return {
@@ -1957,13 +1807,13 @@ async function runWeeklyReflectionIfNeeded(deps, agentId, workspaceDir) {
   if (!vaultPath) {
     return;
   }
-  const result = runClawvault(["reflect", "-v", vaultPath], deps.pluginConfig, {
-    timeoutMs: 12e4
-  });
-  if (result.success) {
+  try {
+    const result = await runReflection({ vaultPath });
+    if (result.writtenWeeks > 0) {
+      deps.logger?.info("[clawvault] Weekly reflection complete");
+    }
     deps.runtimeState.markWeeklyReflectionRun(weekKey);
-    deps.logger?.info("[clawvault] Weekly reflection complete");
-  } else if (!result.skipped) {
+  } catch {
     deps.logger?.warn("[clawvault] Weekly reflection failed");
   }
 }
@@ -1977,19 +1827,16 @@ async function handleGatewayStart(event, ctx, deps) {
     deps.logger?.warn("[clawvault] No vault found, skipping startup recovery");
     return;
   }
-  const result = runClawvault(["recover", "--clear", "-v", vaultPath], deps.pluginConfig, {
-    timeoutMs: 2e4
-  });
-  if (result.skipped) {
-    return;
-  }
-  if (!result.success) {
+  let recoveryInfo;
+  try {
+    recoveryInfo = await recover(vaultPath, { clearFlag: true });
+  } catch {
     deps.logger?.warn("[clawvault] Startup recovery command failed");
     return;
   }
-  const parsed = parseRecoveryOutput(result.output);
-  if (parsed.hadDeath) {
-    const message = parsed.workingOn ? `[ClawVault] Context death detected. Last working on: ${parsed.workingOn}. Run \`clawvault wake\` for full recovery context.` : "[ClawVault] Context death detected. Run `clawvault wake` for full recovery context.";
+  if (recoveryInfo.died) {
+    const workingOn = recoveryInfo.checkpoint?.workingOn?.trim();
+    const message = workingOn ? `[ClawVault] Context death detected. Last working on: ${workingOn}. Run \`clawvault wake\` for full recovery context.` : "[ClawVault] Context death detected. Run `clawvault wake` for full recovery context.";
     deps.runtimeState.setStartupRecoveryNotice(message);
     deps.logger?.warn("[clawvault] Context death detected at startup");
   }
@@ -2036,16 +1883,14 @@ async function handleBeforeReset(event, ctx, deps) {
   if (autoCheckpointEnabled) {
     const safeSessionKey = sanitizeForCheckpoint(sessionKey, 120);
     const safeReason = sanitizeForCheckpoint(event.reason ?? "before_reset", 80);
-    const checkpointResult = runClawvault([
-      "checkpoint",
-      "--working-on",
-      `Session reset via ${safeReason}`,
-      "--focus",
-      `Pre-reset checkpoint, session: ${safeSessionKey}`,
-      "-v",
-      vaultPath
-    ], deps.pluginConfig, { timeoutMs: 3e4 });
-    if (!checkpointResult.success && !checkpointResult.skipped) {
+    try {
+      await checkpoint({
+        workingOn: `Session reset via ${safeReason}`,
+        focus: `Pre-reset checkpoint, session: ${safeSessionKey}`,
+        vaultPath
+      });
+      await flush();
+    } catch {
       deps.logger?.warn("[clawvault] Auto-checkpoint before reset failed");
     }
   }
@@ -2120,7 +1965,7 @@ function isOpenClawPluginApi(value) {
   const record = value;
   return typeof record.on === "function" && typeof record.registerTool === "function" && typeof record.logger === "object";
 }
-async function registerOpenClawPlugin(api) {
+function registerOpenClawPlugin(api) {
   const pluginConfig = readPluginConfig(api);
   const runtimeState = new ClawVaultPluginRuntimeState();
   const memoryManager = new ClawVaultMemoryManager({
@@ -2131,10 +1976,8 @@ async function registerOpenClawPlugin(api) {
       warn: api.logger.warn
     }
   });
-  const memorySearchTool = createMemorySearchToolFactory(memoryManager)();
-  const memoryGetTool = createMemoryGetToolFactory(memoryManager)();
-  api.registerTool(memorySearchTool, { name: "memory_search" });
-  api.registerTool(memoryGetTool, { name: "memory_get" });
+  api.registerTool(createMemorySearchToolFactory(memoryManager), { name: "memory_search" });
+  api.registerTool(createMemoryGetToolFactory(memoryManager), { name: "memory_get" });
   api.on("before_prompt_build", createBeforePromptBuildHandler({
     pluginConfig,
     runtimeState
@@ -2196,7 +2039,7 @@ var clawvaultPlugin = {
   name: "ClawVault",
   kind: "memory",
   description: "Structured memory system for AI agents with proactive recall and protocol-safe messaging",
-  async register(apiOrRuntime) {
+  register(apiOrRuntime) {
     if (isOpenClawPluginApi(apiOrRuntime)) {
       return registerOpenClawPlugin(apiOrRuntime);
     }