clawvault 3.3.0 → 3.4.1

package/dist/chunk-PLNK37JD.js

@@ -0,0 +1,2223 @@
+import {
+  buildRecallResult
+} from "./chunk-RL2L6I6K.js";
+import {
+  synthesizeEntityProfiles
+} from "./chunk-NSXYM6EZ.js";
+import {
+  normalizeForDedup,
+  similarityScore
+} from "./chunk-35JCYSRR.js";
+import {
+  FactStore,
+  extractFactsRuleBased
+} from "./chunk-BSJ6RIT7.js";
+import {
+  ClawVault
+} from "./chunk-ECGJYWNA.js";
+import {
+  hasQmd
+} from "./chunk-PTWPPVC7.js";
+import {
+  resolveVaultPath
+} from "./chunk-GJO3CFUN.js";
+
+// src/capture/extractor.ts
+var MEMORY_NOTE_PATTERN = /<memory_note([^>]*)>([\s\S]*?)<\/memory_note>/gi;
+var WIKI_LINK_PATTERN = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+var SENTENCE_SPLIT_PATTERN = /\r?\n|(?<=[.?!])\s+/;
+var CLASSIFIER_RULES = [
+  { type: "decision", confidence: 0.74, pattern: /\b(decid(?:e|ed|ing|ion)|chose|selected|opted|agreed|we will|i will)\b/i },
+  { type: "preference", confidence: 0.72, pattern: /\b(prefer(?:ence|red|s)?|like(?:s|d)?|dislike|always use|never use|default to)\b/i },
+  { type: "lesson", confidence: 0.76, pattern: /\b(learn(?:ed|ing|t)|lesson|insight|takeaway|next time|mistake|realized)\b/i },
+  { type: "relationship", confidence: 0.69, pattern: /\b(works with|reports to|collaborates with|partnered with|depends on|related to)\b/i },
+  { type: "episode", confidence: 0.64, pattern: /\b(today|yesterday|this morning|this afternoon|during|after|before|in the meeting)\b/i },
+  { type: "entity", confidence: 0.62, pattern: /\[\[[^\]]+\]\]/i }
+];
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function parseNoteAttributes(raw) {
+  const attributes = {};
+  const attributePattern = /([a-zA-Z_][\w-]*)\s*=\s*"([^"]*)"/g;
+  let match = attributePattern.exec(raw);
+  while (match) {
+    attributes[match[1]] = match[2];
+    match = attributePattern.exec(raw);
+  }
+  return attributes;
+}
+function sanitizeType(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  const allowed = [
+    "fact",
+    "preference",
+    "decision",
+    "lesson",
+    "entity",
+    "episode",
+    "relationship"
+  ];
+  return allowed.includes(normalized) ? normalized : null;
+}
+function parseConfidence(value, fallback = 0.85) {
+  if (!value) return fallback;
+  const parsed = Number.parseFloat(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(1, Math.max(0, parsed));
+}
+function extractEntities(text) {
+  const entities = /* @__PURE__ */ new Set();
+  WIKI_LINK_PATTERN.lastIndex = 0;
+  let linkMatch = WIKI_LINK_PATTERN.exec(text);
+  while (linkMatch) {
+    entities.add(linkMatch[1].trim());
+    linkMatch = WIKI_LINK_PATTERN.exec(text);
+  }
+  const properNounPattern = /\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,2})\b/g;
+  let nounMatch = properNounPattern.exec(text);
+  while (nounMatch) {
+    const value = nounMatch[1].trim();
+    if (value.length >= 3) {
+      entities.add(value);
+    }
+    nounMatch = properNounPattern.exec(text);
+  }
+  return [...entities];
+}
+function inferTypeFromSentence(sentence) {
+  for (const rule of CLASSIFIER_RULES) {
+    if (rule.pattern.test(sentence)) {
+      return { type: rule.type, confidence: rule.confidence };
+    }
+  }
+  return { type: "fact", confidence: 0.55 };
+}
+function titleFromContent(type, content) {
+  const words = normalizeWhitespace(content).split(" ").filter(Boolean).slice(0, 8);
+  const stem = words.join(" ");
+  return `${type}: ${stem}`.slice(0, 90);
+}
+function dedupeCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const candidate of candidates) {
+    const key = normalizeWhitespace(candidate.content).toLowerCase();
+    if (!key || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(candidate);
+  }
+  return deduped;
+}
+function extractTaggedMemoryNotes(text) {
+  const candidates = [];
+  MEMORY_NOTE_PATTERN.lastIndex = 0;
+  let match = MEMORY_NOTE_PATTERN.exec(text);
+  while (match) {
+    const attributes = parseNoteAttributes(match[1] ?? "");
+    const body = normalizeWhitespace(match[2] ?? "");
+    if (!body) {
+      match = MEMORY_NOTE_PATTERN.exec(text);
+      continue;
+    }
+    const type = sanitizeType(attributes.type) ?? inferTypeFromSentence(body).type;
+    const confidence = parseConfidence(attributes.confidence, 0.9);
+    const entities = extractEntities(body);
+    candidates.push({
+      content: body,
+      type,
+      confidence,
+      title: attributes.title || titleFromContent(type, body),
+      tags: attributes.tags ? attributes.tags.split(",").map((item) => item.trim()).filter(Boolean) : void 0,
+      entities,
+      source: "memory_note",
+      metadata: {
+        taggedType: attributes.type,
+        rawAttributes: attributes
+      }
+    });
+    match = MEMORY_NOTE_PATTERN.exec(text);
+  }
+  return dedupeCandidates(candidates);
+}
+function stripMemoryNotes(text) {
+  return text.replace(MEMORY_NOTE_PATTERN, " ");
+}
+function extractHeuristicMemories(text) {
+  const sanitized = stripMemoryNotes(text);
+  const sentences = sanitized.split(SENTENCE_SPLIT_PATTERN).map((line) => normalizeWhitespace(line)).filter((line) => line.length >= 20 && line.length <= 400);
+  const candidates = [];
+  for (const sentence of sentences) {
+    const classification = inferTypeFromSentence(sentence);
+    const entities = extractEntities(sentence);
+    const confidenceBoost = entities.length > 0 ? 0.08 : 0;
+    candidates.push({
+      content: sentence,
+      type: classification.type,
+      confidence: Math.min(1, classification.confidence + confidenceBoost),
+      title: titleFromContent(classification.type, sentence),
+      entities,
+      source: "heuristic"
+    });
+  }
+  return dedupeCandidates(candidates);
+}
+function extractMemoriesFromAssistantResponse(text) {
+  const fromTags = extractTaggedMemoryNotes(text);
+  const fromHeuristics = extractHeuristicMemories(text);
+  return dedupeCandidates([...fromTags, ...fromHeuristics]);
+}
+
+// src/capture/quality.ts
+var SECRET_PATTERNS = [
+  /sk-[A-Za-z0-9]{20,}/,
+  /AKIA[0-9A-Z]{16}/,
+  /-----BEGIN (?:RSA|EC|OPENSSH|PGP|DSA) PRIVATE KEY-----/,
+  /(?:api[-_ ]?key|access[-_ ]?token|secret)(?:\s*[:=]\s*|\s+)[A-Za-z0-9_\-]{12,}/i
+];
+var NOISE_PATTERNS = [
+  /^\s*[{[][\s\S]{30,}[}\]]\s*$/m,
+  /^\s*\$?\s*(?:npm|pnpm|yarn|bun|git|docker|kubectl|curl|node)\b/m,
+  /(?:stdout|stderr|exit code|stack trace|traceback|at\s+[A-Za-z0-9_.$]+\s+\()/i,
+  /^\s*[|+]{2,}[-+| ]+\s*$/m
+];
+function countAlphaWords(value) {
+  const words = value.match(/[A-Za-z][A-Za-z0-9'-]*/g) ?? [];
+  return words.length;
+}
+function symbolRatio(value) {
+  if (!value) return 1;
+  const symbols = value.replace(/[A-Za-z0-9\s]/g, "").length;
+  return symbols / value.length;
+}
+function lineDensity(value) {
+  const lines = value.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) return 0;
+  const averageLength = lines.reduce((sum, line) => sum + line.length, 0) / lines.length;
+  return averageLength;
+}
+function isLikelyJunkMemory(content) {
+  if (!content || content.trim().length < 12) {
+    return true;
+  }
+  if (SECRET_PATTERNS.some((pattern) => pattern.test(content))) {
+    return true;
+  }
+  if (NOISE_PATTERNS.some((pattern) => pattern.test(content))) {
+    return true;
+  }
+  if (symbolRatio(content) > 0.3) {
+    return true;
+  }
+  if (lineDensity(content) > 180) {
+    return true;
+  }
+  return false;
+}
+function plausibilityScore(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return 0;
+  const alphaWords = countAlphaWords(trimmed);
+  const hasSentencePunctuation = /[.!?]$/.test(trimmed) || trimmed.length > 40;
+  const hasVerbLikeWord = /\b(is|are|was|were|has|have|will|should|decided|prefer|learned|met|works|uses)\b/i.test(trimmed);
+  const hasBalancedLength = trimmed.length >= 20 && trimmed.length <= 400;
+  let score = 0;
+  if (alphaWords >= 4) score += 0.3;
+  if (alphaWords >= 8) score += 0.2;
+  if (hasSentencePunctuation) score += 0.2;
+  if (hasVerbLikeWord) score += 0.2;
+  if (hasBalancedLength) score += 0.1;
+  return Math.min(1, score);
+}
+function maxJaccardSimilarity(candidate, existingContents) {
+  if (existingContents.length === 0) return 0;
+  let best = 0;
+  const normalizedCandidate = normalizeForDedup(candidate);
+  for (const entry of existingContents) {
+    const score = similarityScore(normalizedCandidate, normalizeForDedup(entry));
+    if (score > best) {
+      best = score;
+    }
+  }
+  return best;
+}
+function evaluateCandidateQuality(candidate, existingContents, stagedContents = [], options = {}) {
+  const minConfidence = options.minConfidence ?? 0.4;
+  const minQualityScore = options.minQualityScore ?? 0.4;
+  const dedupThreshold = options.dedupThreshold ?? 0.82;
+  if (candidate.confidence < minConfidence) {
+    return {
+      accepted: false,
+      reason: `confidence below threshold (${candidate.confidence.toFixed(2)} < ${minConfidence.toFixed(2)})`,
+      qualityScore: candidate.confidence,
+      plausibilityScore: 0,
+      confidenceScore: candidate.confidence,
+      maxSimilarity: 0
+    };
+  }
+  if (isLikelyJunkMemory(candidate.content)) {
+    return {
+      accepted: false,
+      reason: "candidate flagged as junk/tool noise",
+      qualityScore: 0,
+      plausibilityScore: 0,
+      confidenceScore: candidate.confidence,
+      maxSimilarity: 0
+    };
+  }
+  const plausibility = plausibilityScore(candidate.content);
+  const maxSimilarity = maxJaccardSimilarity(candidate.content, [...existingContents, ...stagedContents]);
+  if (maxSimilarity >= dedupThreshold) {
+    return {
+      accepted: false,
+      reason: `candidate too similar to existing memory (similarity=${maxSimilarity.toFixed(2)})`,
+      qualityScore: 0,
+      plausibilityScore: plausibility,
+      confidenceScore: candidate.confidence,
+      maxSimilarity
+    };
+  }
+  const qualityScore = candidate.confidence * 0.6 + plausibility * 0.4;
+  if (qualityScore < minQualityScore) {
+    return {
+      accepted: false,
+      reason: `quality score below threshold (${qualityScore.toFixed(2)} < ${minQualityScore.toFixed(2)})`,
+      qualityScore,
+      plausibilityScore: plausibility,
+      confidenceScore: candidate.confidence,
+      maxSimilarity
+    };
+  }
+  return {
+    accepted: true,
+    qualityScore,
+    plausibilityScore: plausibility,
+    confidenceScore: candidate.confidence,
+    maxSimilarity
+  };
+}
+
+// src/capture/service.ts
+var CATEGORY_BY_MEMORY_TYPE = {
+  fact: "facts",
+  preference: "preferences",
+  decision: "decisions",
+  lesson: "lessons",
+  entity: "people",
+  episode: "transcripts",
+  relationship: "people"
+};
+function normalizeMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts = content.map((item) => {
+      if (typeof item === "string") return item;
+      if (!item || typeof item !== "object") return "";
+      const record = item;
+      if (typeof record.text === "string") return record.text;
+      if (typeof record.content === "string") return record.content;
+      return "";
+    }).filter(Boolean);
+    return parts.join("\n").trim();
+  }
+  if (content && typeof content === "object") {
+    const record = content;
+    if (typeof record.text === "string") return record.text;
+    if (typeof record.content === "string") return record.content;
+  }
+  return "";
+}
+function normalizeIncomingMessage(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const roleCandidate = record.role ?? record.authorRole ?? record.speaker ?? record.type;
+  const role = typeof roleCandidate === "string" ? roleCandidate.toLowerCase() : "assistant";
+  const content = normalizeMessageContent(record.content ?? record.text ?? record.message);
+  if (!content.trim()) {
+    return null;
+  }
+  const timestamp = typeof record.timestamp === "string" ? record.timestamp : typeof record.createdAt === "string" ? record.createdAt : void 0;
+  return { role, content, timestamp };
+}
+function titleForCandidate(candidate) {
+  if (candidate.title && candidate.title.trim()) {
+    return candidate.title.trim();
+  }
+  const stem = candidate.content.replace(/\s+/g, " ").trim().split(" ").slice(0, 8).join(" ");
+  return `${candidate.type}: ${stem}`.slice(0, 90);
+}
+function withCollisionSuffix(title) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `${title} ${stamp}`;
+}
+var LiveCaptureService = class {
+  async captureTurn(messages, options = {}) {
+    const normalizedMessages = messages.map((message) => normalizeIncomingMessage(message)).filter((message) => Boolean(message)).filter((message) => message.role === "assistant");
+    if (normalizedMessages.length === 0) {
+      return {
+        stored: 0,
+        rejected: 0,
+        storedDocuments: [],
+        acceptedCandidates: [],
+        rejectedCandidates: []
+      };
+    }
+    const vaultPath = resolveVaultPath({
+      explicitPath: options.vaultPath,
+      agentId: options.agentId,
+      pluginConfig: options.pluginConfig
+    });
+    const vault = new ClawVault(vaultPath);
+    await vault.load();
+    const extractedCandidates = normalizedMessages.flatMap(
+      (message) => extractMemoriesFromAssistantResponse(message.content)
+    );
+    if (extractedCandidates.length === 0) {
+      return {
+        stored: 0,
+        rejected: 0,
+        storedDocuments: [],
+        acceptedCandidates: [],
+        rejectedCandidates: []
+      };
+    }
+    const maxPerTurn = options.maxPerTurn ?? 8;
+    const existingDocs = await vault.list();
+    const existingContents = existingDocs.map((doc) => doc.content);
+    const stagedAcceptedContents = [];
+    const acceptedCandidates = [];
+    const rejectedCandidates = [];
+    for (const candidate of extractedCandidates) {
+      if (acceptedCandidates.length >= maxPerTurn) {
+        break;
+      }
+      const quality = evaluateCandidateQuality(
+        candidate,
+        existingContents,
+        stagedAcceptedContents,
+        {
+          minConfidence: options.minConfidence,
+          dedupThreshold: options.dedupThreshold
+        }
+      );
+      if (!quality.accepted) {
+        rejectedCandidates.push({
+          candidate,
+          reason: quality.reason ?? "quality gate rejected candidate"
+        });
+        continue;
+      }
+      stagedAcceptedContents.push(candidate.content);
+      acceptedCandidates.push(candidate);
+    }
+    const storedDocuments = [];
+    for (const candidate of acceptedCandidates) {
+      const doc = await this.persistCandidate(vault, candidate, options);
+      storedDocuments.push(doc.id);
+    }
+    const hasEntityMentions = acceptedCandidates.some((candidate) => (candidate.entities?.length ?? 0) > 0);
+    if (hasEntityMentions) {
+      await synthesizeEntityProfiles(vaultPath, { writeFiles: true });
+    }
+    return {
+      stored: storedDocuments.length,
+      rejected: rejectedCandidates.length,
+      storedDocuments,
+      acceptedCandidates,
+      rejectedCandidates
+    };
+  }
+  async persistCandidate(vault, candidate, options) {
+    const category = CATEGORY_BY_MEMORY_TYPE[candidate.type] ?? "inbox";
+    const title = titleForCandidate(candidate);
+    const frontmatter = {
+      memoryType: candidate.type,
+      captureSource: candidate.source,
+      confidence: Number(candidate.confidence.toFixed(3)),
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (candidate.tags && candidate.tags.length > 0) {
+      frontmatter.tags = candidate.tags;
+    }
+    if (candidate.entities && candidate.entities.length > 0) {
+      frontmatter.entities = candidate.entities;
+    }
+    if (options.sourceSessionId) {
+      frontmatter.sessionId = options.sourceSessionId;
+    }
+    if (candidate.metadata) {
+      frontmatter.captureMetadata = candidate.metadata;
+    }
+    try {
+      return await vault.store({
+        category,
+        title,
+        content: candidate.content,
+        frontmatter
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!message.includes("Document already exists")) {
+        throw err;
+      }
+      return vault.store({
+        category,
+        title: withCollisionSuffix(title),
+        content: candidate.content,
+        frontmatter
+      });
+    }
+  }
+};
+
+// src/plugin/slot.ts
+var CATEGORY_BY_TYPE = {
+  fact: "facts",
+  preference: "preferences",
+  decision: "decisions",
+  lesson: "lessons",
+  entity: "people",
+  episode: "transcripts",
+  relationship: "people"
+};
+function resolveSlotVaultPath(defaults, options) {
+  return resolveVaultPath({
+    explicitPath: options?.vaultPath ?? defaults.vaultPath,
+    pluginConfig: options?.pluginConfig ?? defaults.pluginConfig,
+    agentId: options?.agentId ?? defaults.agentId
+  });
+}
+function normalizeTitle(content, fallbackPrefix = "memory") {
+  const stem = content.replace(/\s+/g, " ").trim().split(" ").slice(0, 8).join(" ");
+  const value = stem.length > 0 ? stem : `${fallbackPrefix}-${Date.now()}`;
+  return value.slice(0, 90);
+}
+function createMemorySlot(defaults = {}) {
+  const captureService = new LiveCaptureService();
+  async function getVault(options) {
+    const vaultPath = resolveSlotVaultPath(defaults, options);
+    const vault = new ClawVault(vaultPath);
+    await vault.load();
+    return vault;
+  }
+  return {
+    async search(query, options = {}) {
+      const vault = await getVault(options);
+      const { vaultPath: _vaultPath, pluginConfig: _pluginConfig, agentId: _agentId, ...searchOptions } = options;
+      return vault.find(query, searchOptions);
+    },
+    async recall(query, options = {}) {
+      const vault = await getVault(options);
+      const result = await buildRecallResult(vault, query, {
+        ...options,
+        includeSources: options.includeSources ?? true
+      });
+      return result.context;
+    },
+    async capture(messages, options = {}) {
+      return captureService.captureTurn(messages, {
+        ...options,
+        vaultPath: options.vaultPath ?? defaults.vaultPath,
+        pluginConfig: options.pluginConfig ?? defaults.pluginConfig,
+        agentId: options.agentId ?? defaults.agentId
+      });
+    },
+    async store(content, metadata = {}) {
+      const vault = await getVault(metadata);
+      const category = metadata.category ?? (metadata.type ? CATEGORY_BY_TYPE[metadata.type] : "inbox");
+      const title = metadata.title ?? normalizeTitle(content, metadata.type ?? "memory");
+      const frontmatter = {
+        ...metadata.frontmatter ?? {}
+      };
+      if (metadata.tags && metadata.tags.length > 0) {
+        frontmatter.tags = metadata.tags;
+      }
+      if (metadata.type) {
+        frontmatter.memoryType = metadata.type;
+      }
+      return vault.store({
+        category,
+        title,
+        content,
+        frontmatter
+      });
+    }
+  };
+}
+function createMemorySlotPlugin(defaults = {}) {
+  return {
+    plugins: {
+      slots: {
+        memory: createMemorySlot(defaults)
+      }
+    }
+  };
+}
+function registerMemorySlot(registry, defaults = {}) {
+  if (!registry.plugins || typeof registry.plugins !== "object") {
+    registry.plugins = {};
+  }
+  if (!registry.plugins.slots || typeof registry.plugins.slots !== "object") {
+    registry.plugins.slots = {};
+  }
+  registry.plugins.slots.memory = createMemorySlot(defaults);
+}
+
+// src/plugin/config.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var SESSION_KEY_RE = /^agent:[a-zA-Z0-9_-]+:[a-zA-Z0-9:_-]+$/;
+var AGENT_ID_RE = /^[a-zA-Z0-9_-]{1,100}$/;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readPluginConfig(api) {
+  if (!isRecord(api.pluginConfig)) {
+    return {};
+  }
+  return api.pluginConfig;
+}
+function isOptInEnabled(pluginConfig, ...keys) {
+  return keys.some((key) => pluginConfig[key] === true);
+}
+function isFeatureEnabled(pluginConfig, key, defaultValue) {
+  const value = pluginConfig[key];
+  if (typeof value === "boolean") return value;
+  return defaultValue;
+}
+function allowsEnvAccess(pluginConfig) {
+  return isOptInEnabled(pluginConfig, "allowEnvAccess");
+}
+function sanitizeSessionKey(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!SESSION_KEY_RE.test(trimmed)) return "";
+  return trimmed.slice(0, 200);
+}
+function sanitizeAgentId(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!AGENT_ID_RE.test(trimmed)) return "";
+  return trimmed;
+}
+function extractAgentIdFromSessionKey(sessionKey) {
+  const match = /^agent:([^:]+):/.exec(sessionKey);
+  if (!match?.[1]) return "";
+  return sanitizeAgentId(match[1]);
+}
+function resolveAgentId(ctx, pluginConfig) {
+  const fromContext = sanitizeAgentId(ctx.agentId);
+  if (fromContext) return fromContext;
+  const fromSessionKey = extractAgentIdFromSessionKey(sanitizeSessionKey(ctx.sessionKey));
+  if (fromSessionKey) return fromSessionKey;
+  if (allowsEnvAccess(pluginConfig)) {
+    const fromEnv = sanitizeAgentId(process.env.OPENCLAW_AGENT_ID);
+    if (fromEnv) return fromEnv;
+  }
+  return "main";
+}
+function getConfiguredExecutablePath(pluginConfig) {
+  if (typeof pluginConfig.clawvaultBinaryPath !== "string") return null;
+  const trimmed = pluginConfig.clawvaultBinaryPath.trim();
+  return trimmed || null;
+}
+function getConfiguredExecutableSha256(pluginConfig) {
+  if (typeof pluginConfig.clawvaultBinarySha256 !== "string") return null;
+  const trimmed = pluginConfig.clawvaultBinarySha256.trim().toLowerCase();
+  return trimmed || null;
+}
+function normalizeAbsoluteEnvPath(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const resolved = path.resolve(trimmed);
+  if (!path.isAbsolute(resolved)) return null;
+  return resolved;
+}
+function getOpenClawAgentsDir(pluginConfig) {
+  if (allowsEnvAccess(pluginConfig)) {
+    const stateDir = normalizeAbsoluteEnvPath(process.env.OPENCLAW_STATE_DIR);
+    if (stateDir) {
+      return path.join(stateDir, "agents");
+    }
+    const openClawHome = normalizeAbsoluteEnvPath(process.env.OPENCLAW_HOME);
+    if (openClawHome) {
+      return path.join(openClawHome, "agents");
+    }
+  }
+  return path.join(os.homedir(), ".openclaw", "agents");
+}
+function validateVaultPath(vaultPath) {
+  if (!vaultPath || typeof vaultPath !== "string") return null;
+  const resolved = path.resolve(vaultPath);
+  if (!path.isAbsolute(resolved)) return null;
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) return null;
+  } catch {
+    return null;
+  }
+  const configPath = path.join(resolved, ".clawvault.json");
+  if (!fs.existsSync(configPath)) return null;
+  return resolved;
+}
+function resolveAgentVaultPath(pluginConfig, agentId) {
+  if (!agentId) return null;
+  if (!isRecord(pluginConfig.agentVaults)) return null;
+  const configured = pluginConfig.agentVaults[agentId];
+  if (typeof configured !== "string") return null;
+  return validateVaultPath(configured);
+}
+function findVaultPath(pluginConfig, options = {}) {
+  const agentId = sanitizeAgentId(options.agentId);
+  if (agentId) {
+    const perAgent = resolveAgentVaultPath(pluginConfig, agentId);
+    if (perAgent) return perAgent;
+  }
+  const configured = validateVaultPath(pluginConfig.vaultPath ?? null);
+  if (configured) return configured;
+  if (allowsEnvAccess(pluginConfig)) {
+    const fromPluginEnv = validateVaultPath(process.env.OPENCLAW_PLUGIN_CLAWVAULT_VAULTPATH ?? null);
+    if (fromPluginEnv) return fromPluginEnv;
+    const fromClawVaultEnv = validateVaultPath(process.env.CLAWVAULT_PATH ?? null);
+    if (fromClawVaultEnv) return fromClawVaultEnv;
+  }
+  let dir = path.resolve(options.cwd ?? process.cwd());
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const direct = validateVaultPath(dir);
+    if (direct) return direct;
+    const memorySubdir = validateVaultPath(path.join(dir, "memory"));
+    if (memorySubdir) return memorySubdir;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+// src/plugin/memory-manager.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+
+// src/plugin/clawvault-cli.ts
+import { execFileSync } from "child_process";
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/plugin/integrity.ts
+import { createHash } from "crypto";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var WINDOWS_PATHEXT_DEFAULT = ".EXE;.CMD;.BAT;.COM";
+function splitPathEnv(pathEnv) {
+  if (typeof pathEnv !== "string" || !pathEnv.trim()) {
+    return [];
+  }
+  return pathEnv.split(path2.delimiter).map((entry) => entry.trim()).filter(Boolean);
+}
+function listExecutableCandidates(commandName) {
+  if (process.platform !== "win32") {
+    return [commandName];
+  }
+  const ext = path2.extname(commandName);
+  if (ext) {
+    return [commandName];
+  }
+  const pathext = splitPathEnv(process.env.PATHEXT || WINDOWS_PATHEXT_DEFAULT).map((candidate) => candidate.toLowerCase());
+  if (pathext.length === 0) {
+    return [commandName];
+  }
+  return pathext.map((candidate) => `${commandName}${candidate}`);
+}
+function isExecutablePath(candidatePath) {
+  try {
+    const stats = fs2.statSync(candidatePath);
+    if (!stats.isFile()) return false;
+    if (process.platform === "win32") return true;
+    return (stats.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+function resolveFromPath(commandName, pathEnv) {
+  const candidates = listExecutableCandidates(commandName);
+  const directories = splitPathEnv(pathEnv);
+  for (const directory of directories) {
+    for (const candidate of candidates) {
+      const absoluteCandidate = path2.resolve(directory, candidate);
+      if (isExecutablePath(absoluteCandidate)) {
+        return absoluteCandidate;
+      }
+    }
+  }
+  return null;
+}
+function resolveExecutablePath(commandName, options = {}) {
+  if (typeof commandName !== "string" || !commandName.trim()) {
+    return null;
+  }
+  const explicitPath = typeof options.explicitPath === "string" ? options.explicitPath.trim() : "";
+  if (explicitPath) {
+    const absolute = path2.resolve(explicitPath);
+    return isExecutablePath(absolute) ? absolute : null;
+  }
+  if (commandName.includes(path2.sep)) {
+    const absolute = path2.resolve(commandName);
+    return isExecutablePath(absolute) ? absolute : null;
+  }
+  return resolveFromPath(commandName, process.env.PATH);
+}
+function sanitizeExecArgs(args) {
+  if (!Array.isArray(args)) {
+    throw new Error("Arguments must be an array");
+  }
+  return args.map((value, index) => {
+    if (typeof value !== "string") {
+      throw new Error(`Argument ${index} is not a string`);
+    }
+    if (value.includes("\0")) {
+      throw new Error(`Argument ${index} contains a null byte`);
+    }
+    return value;
+  });
+}
+function verifyExecutableIntegrity(executablePath, expectedSha256) {
+  if (typeof expectedSha256 !== "string" || !expectedSha256.trim()) {
+    return { ok: true, actualSha256: null };
+  }
+  const normalizedExpected = expectedSha256.trim().toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(normalizedExpected)) {
+    return { ok: false, actualSha256: null };
+  }
+  const payload = fs2.readFileSync(executablePath);
+  const actualSha256 = createHash("sha256").update(payload).digest("hex").toLowerCase();
+  return {
+    ok: actualSha256 === normalizedExpected,
+    actualSha256
+  };
+}
+
+// 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;
+var SMALL_SESSION_THRESHOLD_BYTES = 50 * ONE_KIB;
+var MEDIUM_SESSION_THRESHOLD_BYTES = 150 * ONE_KIB;
+var LARGE_SESSION_THRESHOLD_BYTES = 300 * ONE_KIB;
+var OBSERVE_CURSOR_FILE = "observe-cursors.json";
+function sanitizeForDisplay(value) {
+  if (typeof value !== "string") return "";
+  return value.replace(/[\x00-\x1f\x7f]/g, "").replace(/[`*_~\[\]]/g, "\\$&").slice(0, 240);
+}
+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:",
+    "",
+    "Recent conversation:"
+  ];
+  if (recapEntries.length === 0) {
+    lines.push("- No recent user/assistant turns found for this session.");
+  } else {
+    for (const entry of recapEntries) {
+      lines.push(`- ${entry.role}: ${entry.text}`);
+    }
+  }
+  lines.push("", "Relevant memories:");
+  if (memoryEntries.length === 0) {
+    lines.push("- No relevant vault memories found for the current prompt.");
+  } else {
+    for (const entry of memoryEntries) {
+      const pathSuffix = entry.path ? ` [${entry.path}]` : "";
+      lines.push(`- ${entry.title} (${entry.age}${pathSuffix}): ${entry.snippet}`);
+    }
+  }
+  return lines.join("\n");
+}
+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);
+}
+function loadObserveCursors(vaultPath) {
+  const cursorPath = getObserveCursorPath(vaultPath);
+  if (!fs3.existsSync(cursorPath)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(cursorPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function getScaledObservationThresholdBytes(fileSizeBytes) {
+  if (!Number.isFinite(fileSizeBytes) || fileSizeBytes <= 0) {
+    return SMALL_SESSION_THRESHOLD_BYTES;
+  }
+  if (fileSizeBytes < ONE_MIB) {
+    return SMALL_SESSION_THRESHOLD_BYTES;
+  }
+  if (fileSizeBytes <= 5 * ONE_MIB) {
+    return MEDIUM_SESSION_THRESHOLD_BYTES;
+  }
+  return LARGE_SESSION_THRESHOLD_BYTES;
+}
+function parseSessionIndex(agentId, pluginConfig) {
+  const sessionsDir = path3.join(getOpenClawAgentsDir(pluginConfig), agentId, "sessions");
+  const sessionsJsonPath = path3.join(sessionsDir, "sessions.json");
+  if (!fs3.existsSync(sessionsJsonPath)) {
+    return { sessionsDir, index: {} };
+  }
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(sessionsJsonPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { sessionsDir, index: {} };
+    }
+    return {
+      sessionsDir,
+      index: parsed
+    };
+  } catch {
+    return { sessionsDir, index: {} };
+  }
+}
+function shouldObserveActiveSessions(vaultPath, agentId, pluginConfig) {
+  const cursors = loadObserveCursors(vaultPath);
+  const { sessionsDir, index } = parseSessionIndex(agentId, pluginConfig);
+  const entries = Object.entries(index);
+  if (entries.length === 0) {
+    return false;
+  }
+  for (const [sessionKey, value] of entries) {
+    const sessionId = typeof value?.sessionId === "string" ? value.sessionId.trim() : "";
+    if (!/^[a-zA-Z0-9._-]{1,200}$/.test(sessionId)) continue;
+    const filePath = path3.join(sessionsDir, `${sessionId}.jsonl`);
+    let stat;
+    try {
+      stat = fs3.statSync(filePath);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    const fileSize = stat.size;
+    const cursorEntry = cursors[sessionId];
+    const previousOffset = Number.isFinite(cursorEntry?.lastObservedOffset) ? Math.max(0, Number(cursorEntry.lastObservedOffset)) : 0;
+    const startOffset = previousOffset <= fileSize ? previousOffset : 0;
+    const newBytes = Math.max(0, fileSize - startOffset);
+    const thresholdBytes = getScaledObservationThresholdBytes(fileSize);
+    if (newBytes >= thresholdBytes) {
+      return true;
+    }
+    if (sessionKey === "main" && newBytes > 0) {
+    }
+  }
+  return false;
+}
+function runObserverCron(vaultPath, agentId, pluginConfig, options = {}) {
+  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;
+}
+function resolveSessionKey(input) {
+  return sanitizeSessionKey(input);
+}
+
+// src/plugin/memory-manager.ts
+var DEFAULT_MAX_RESULTS = 6;
+var DEFAULT_MIN_SCORE = 0.2;
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function normalizeRelPath(relPath) {
+  return relPath.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/^\/+/, "");
+}
+function estimateLineRange(content, snippet) {
+  const cleanedSnippet = snippet.replace(/\s+/g, " ").trim();
+  if (!cleanedSnippet) {
+    return { startLine: 1, endLine: 1 };
+  }
+  const normalizedContent = content.replace(/\s+/g, " ");
+  const index = normalizedContent.toLowerCase().indexOf(cleanedSnippet.toLowerCase());
+  if (index < 0) {
+    return { startLine: 1, endLine: Math.max(1, cleanedSnippet.split(/\r?\n/).length) };
+  }
+  const upToIndex = normalizedContent.slice(0, index);
+  const startLine = upToIndex.split(/\r?\n/).length;
+  const endLine = startLine + Math.max(1, cleanedSnippet.split(/\r?\n/).length) - 1;
+  return { startLine, endLine };
+}
+function mapSearchResult(vaultPath, result) {
+  const relPath = normalizeRelPath(path4.relative(vaultPath, result.document.path));
+  const { startLine, endLine } = estimateLineRange(result.document.content, result.snippet);
+  const source = relPath === "MEMORY.md" || relPath.startsWith("memory/") ? "memory" : "sessions";
+  return {
+    path: relPath || path4.basename(result.document.path),
+    startLine,
+    endLine,
+    score: result.score,
+    snippet: result.snippet,
+    source,
+    citation: `${relPath || path4.basename(result.document.path)}#L${startLine}-L${endLine}`
+  };
+}
+function countMarkdownFiles(root) {
+  if (!fs4.existsSync(root)) return 0;
+  let count = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries;
+    try {
+      entries = fs4.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path4.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+        count += 1;
+      }
+    }
+  }
+  return count;
+}
+function toSafeFilePath(vaultPath, relPath) {
+  const normalized = normalizeRelPath(relPath);
+  const mapped = normalized.startsWith("qmd/") ? normalized.split("/").slice(2).join("/") : normalized;
+  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");
+  }
+  const absolute = path4.resolve(vaultPath, mapped);
+  const vaultRootWithSep = vaultPath.endsWith(path4.sep) ? vaultPath : `${vaultPath}${path4.sep}`;
+  if (absolute !== vaultPath && !absolute.startsWith(vaultRootWithSep)) {
+    throw new Error("Path escapes vault root");
+  }
+  return absolute;
+}
+function resolveManagerVaultPath(options, sessionKey) {
+  const derivedAgentId = sessionKey ? extractAgentIdFromSessionKey(sessionKey) : "";
+  const agentId = derivedAgentId || options.defaultAgentId;
+  return resolveVaultPathForAgent(options.pluginConfig, {
+    agentId,
+    cwd: options.workspaceDir
+  });
+}
+var ClawVaultMemoryManager = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async search(query, opts = {}) {
+    const normalizedQuery = sanitizePromptForContext(query);
+    if (!normalizedQuery) return [];
+    const vaultPath = resolveManagerVaultPath(this.options, opts.sessionKey);
+    if (!vaultPath) return [];
+    const maxResults = Number.isFinite(opts.maxResults) ? clamp(Math.floor(Number(opts.maxResults)), 1, 20) : DEFAULT_MAX_RESULTS;
+    const minScore = Number.isFinite(opts.minScore) ? clamp(Number(opts.minScore), 0, 1) : DEFAULT_MIN_SCORE;
+    try {
+      const vault = new ClawVault(vaultPath);
+      await vault.load();
+      const results = await vault.find(normalizedQuery, {
+        limit: maxResults,
+        minScore,
+        temporalBoost: true
+      });
+      return results.map((result) => mapSearchResult(vaultPath, result));
+    } catch (error) {
+      this.options.logger?.warn(
+        `[clawvault] memory_search fallback error: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return [];
+    }
+  }
+  async readFile(params) {
+    const vaultPath = resolveManagerVaultPath(this.options);
+    const normalizedPath = normalizeRelPath(params.relPath);
+    if (!vaultPath) {
+      return { text: "", path: normalizedPath };
+    }
+    let absolutePath;
+    try {
+      absolutePath = toSafeFilePath(vaultPath, normalizedPath);
+    } catch (error) {
+      throw new Error(error instanceof Error ? error.message : "Invalid memory path");
+    }
+    if (!fs4.existsSync(absolutePath)) {
+      return { text: "", path: normalizedPath };
+    }
+    const raw = fs4.readFileSync(absolutePath, "utf-8");
+    if (!Number.isFinite(params.from) && !Number.isFinite(params.lines)) {
+      return { text: raw, path: normalizedPath };
+    }
+    const from = Number.isFinite(params.from) ? Math.max(1, Math.floor(Number(params.from))) : 1;
+    const lines = Number.isFinite(params.lines) ? Math.max(1, Math.floor(Number(params.lines))) : 120;
+    const chunks = raw.split(/\r?\n/);
+    const startIndex = from - 1;
+    const sliced = chunks.slice(startIndex, startIndex + lines);
+    return {
+      text: sliced.join("\n"),
+      path: normalizedPath
+    };
+  }
+  status() {
+    const vaultPath = resolveManagerVaultPath(this.options);
+    const markdownFiles = vaultPath ? countMarkdownFiles(path4.join(vaultPath, "memory")) : 0;
+    return {
+      backend: "builtin",
+      provider: "clawvault",
+      workspaceDir: vaultPath ?? this.options.workspaceDir,
+      files: markdownFiles,
+      sources: ["memory", "sessions"],
+      vector: {
+        enabled: true,
+        available: hasQmd()
+      }
+    };
+  }
+  async sync(params) {
+    params?.progress?.({ completed: 0, total: 1, label: "syncing" });
+    const vaultPath = resolveManagerVaultPath(this.options);
+    if (vaultPath) {
+      const vault = new ClawVault(vaultPath);
+      await vault.load();
+    }
+    params?.progress?.({ completed: 1, total: 1, label: "done" });
+  }
+  async probeEmbeddingAvailability() {
+    try {
+      const sample = await this.search("health probe", { maxResults: 1, minScore: 0 });
+      if (sample.length >= 0) {
+        return { ok: true };
+      }
+      return { ok: true };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async probeVectorAvailability() {
+    return hasQmd();
+  }
+  async close() {
+    return Promise.resolve();
+  }
+};
+function buildToolSchema(properties, required = []) {
+  return {
+    type: "object",
+    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) => {
+    const inputSchema = buildToolSchema({
+      query: {
+        type: "string",
+        description: "Natural-language query for memory recall."
+      },
+      maxResults: {
+        type: "number",
+        minimum: 1,
+        maximum: 20,
+        description: "Maximum number of snippets to return."
+      },
+      minScore: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        description: "Minimum score threshold."
+      },
+      sessionKey: {
+        type: "string",
+        description: "Optional OpenClaw session key for scoped recall."
+      }
+    }, ["query"]);
+    const execute = async (toolCallIdOrInput, maybeInput) => {
+      const input = resolveToolInput(toolCallIdOrInput, maybeInput);
+      const query = typeof input.query === "string" ? input.query : "";
+      if (!query.trim()) {
+        return { query, count: 0, results: [] };
+      }
+      const results = await memoryManager.search(query, {
+        maxResults: Number.isFinite(Number(input.maxResults)) ? Number(input.maxResults) : void 0,
+        minScore: Number.isFinite(Number(input.minScore)) ? Number(input.minScore) : void 0,
+        sessionKey: typeof input.sessionKey === "string" ? input.sessionKey : void 0
+      });
+      return {
+        query,
+        count: results.length,
+        results
+      };
+    };
+    return {
+      label: "Memory Search",
+      name: "memory_search",
+      description: "Search ClawVault memory for relevant snippets before answering.",
+      inputSchema,
+      input_schema: inputSchema,
+      parameters: inputSchema,
+      execute,
+      run: execute,
+      handler: execute
+    };
+  };
+}
+function createMemoryGetToolFactory(memoryManager) {
+  return (_toolContext) => {
+    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)."
+      },
+      from: {
+        type: "number",
+        minimum: 1,
+        description: "Optional start line (1-indexed)."
+      },
+      lines: {
+        type: "number",
+        minimum: 1,
+        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 : "";
+      if (!relPath.trim()) {
+        return { path: relPath, text: "" };
+      }
+      return memoryManager.readFile({
+        relPath,
+        from: Number.isFinite(Number(input.from)) ? Number(input.from) : void 0,
+        lines: Number.isFinite(Number(input.lines)) ? Number(input.lines) : void 0
+      });
+    };
+    return {
+      label: "Memory Get",
+      name: "memory_get",
+      description: "Read a specific memory file or line range from ClawVault.",
+      inputSchema,
+      input_schema: inputSchema,
+      parameters: inputSchema,
+      execute,
+      run: execute,
+      handler: execute
+    };
+  };
+}
+
+// src/plugin/runtime-state.ts
+var ClawVaultPluginRuntimeState = class {
+  startupRecoveryNotice = null;
+  sessionContextByKey = /* @__PURE__ */ new Map();
+  lastWeeklyReflectionWeekKey = null;
+  setStartupRecoveryNotice(message) {
+    const trimmed = message.trim();
+    this.startupRecoveryNotice = trimmed || null;
+  }
+  consumeStartupRecoveryNotice() {
+    const notice = this.startupRecoveryNotice;
+    this.startupRecoveryNotice = null;
+    return notice;
+  }
+  setSessionRecap(sessionKey, recapText) {
+    const normalizedSessionKey = sessionKey.trim();
+    if (!normalizedSessionKey) return;
+    this.sessionContextByKey.set(normalizedSessionKey, {
+      recapText: recapText.trim(),
+      initializedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      recapInjected: false
+    });
+  }
+  getSessionRecap(sessionKey) {
+    if (!sessionKey) return null;
+    return this.sessionContextByKey.get(sessionKey) ?? null;
+  }
+  markSessionRecapInjected(sessionKey) {
+    const current = this.sessionContextByKey.get(sessionKey);
+    if (!current) return;
+    this.sessionContextByKey.set(sessionKey, { ...current, recapInjected: true });
+  }
+  clearSession(sessionKey) {
+    if (!sessionKey) return;
+    this.sessionContextByKey.delete(sessionKey);
+  }
+  shouldRunWeeklyReflection(weekKey) {
+    return this.lastWeeklyReflectionWeekKey !== weekKey;
+  }
+  markWeeklyReflectionRun(weekKey) {
+    this.lastWeeklyReflectionWeekKey = weekKey;
+  }
+};
+
+// src/plugin/communication-protocol.ts
+var BANNED_PHRASE_PATTERNS = [
+  { id: "good-catch", regex: /\bgood catch\b[:,]?\s*/gi, replacement: "" },
+  { id: "great-question", regex: /\bgreat question\b[:,]?\s*/gi, replacement: "" },
+  { id: "right-to-call-out", regex: /\byou(?:'|’)re right to call that out\b[:,]?\s*/gi, replacement: "" }
+];
+var RABBIT_HOLE_PATTERNS = [
+  /\bif (?:you(?:'|’)d like|you want(?: me)?(?: to)?|that would help),?\s*i can\b[^.!?]*(?:[.!?]|$)/gi,
+  /\blet me know if you(?:'|’)d like\b[^.!?]*(?:[.!?]|$)/gi
+];
+var QUESTION_OPENERS = /\b(what|why|who|where|when|which|can you|could you|do you|did you|would you|should we)\b/i;
+function buildCommunicationProtocolAppendix() {
+  return [
+    "ClawVault Communication Protocol:",
+    `- Never say: "good catch", "great question", or "you're right to call that out".`,
+    `- Never offer rabbit-hole phrasing such as "if you'd like I can ...".`,
+    "- Do not ask questions when memory already contains the answer.",
+    "- Use memory tools proactively before answering memory-sensitive prompts."
+  ].join("\n");
+}
+function normalizeWhitespace2(value) {
+  return value.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/[ \t]{2,}/g, " ").trim();
+}
+function rewriteOutboundMessage(content) {
+  let rewritten = content;
+  const violations = [];
+  for (const pattern of BANNED_PHRASE_PATTERNS) {
+    if (pattern.regex.test(rewritten)) {
+      violations.push(pattern.id);
+      rewritten = rewritten.replace(pattern.regex, pattern.replacement);
+    }
+  }
+  for (const regex of RABBIT_HOLE_PATTERNS) {
+    if (regex.test(rewritten)) {
+      violations.push("rabbit-hole-offer");
+      rewritten = rewritten.replace(regex, "");
+    }
+  }
+  rewritten = rewritten.replace(/^[,\-:; ]+/, "").replace(/[ ]+([,.!?;:])/g, "$1");
+  rewritten = normalizeWhitespace2(rewritten);
+  if (!rewritten) {
+    rewritten = "Understood.";
+  }
+  return { content: rewritten, violations };
+}
+function containsQuestion(content) {
+  if (!content.includes("?")) return false;
+  return QUESTION_OPENERS.test(content.toLowerCase()) || content.trim().endsWith("?");
+}
+function rewriteQuestionWithMemoryEvidence(originalContent, memoryHits) {
+  const cleaned = originalContent.replace(/\?/g, ".").replace(/\s+\./g, ".").trim();
+  if (memoryHits.length === 0) {
+    return cleaned || "Proceeding with the available context.";
+  }
+  const topHits = memoryHits.slice(0, 2).map((hit) => {
+    const citation = hit.citation ? ` (${hit.citation})` : "";
+    return `- ${hit.snippet}${citation}`;
+  });
+  const summary = [
+    cleaned || "I checked ClawVault memory before responding.",
+    "",
+    "Memory already contains relevant details:",
+    ...topHits
+  ].join("\n");
+  return normalizeWhitespace2(summary);
+}
+
+// src/plugin/vault-context-injector.ts
+var DEFAULT_MAX_CONTEXT_RESULTS = 4;
+var DEFAULT_MAX_RECAP_RESULTS = 6;
+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) {
+    return [];
+  }
+  return parseSessionRecapJson(recapResult.output, DEFAULT_MAX_RECAP_RESULTS);
+}
+async function fetchMemoryContextEntries(options) {
+  const prompt = sanitizePromptForContext(options.prompt);
+  if (!prompt) {
+    return { entries: [], vaultPath: null };
+  }
+  const vaultPath = resolveVaultPathForAgent(options.pluginConfig, {
+    agentId: options.agentId,
+    cwd: options.workspaceDir
+  });
+  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) {
+    return { entries: [], vaultPath };
+  }
+  return {
+    entries: parseContextJson(fallbackSearchResult.output, maxResults),
+    vaultPath
+  };
+}
+async function buildVaultContextInjection(options) {
+  const [recapEntries, memoryResult] = await Promise.all([
+    fetchSessionRecapEntries(options),
+    fetchMemoryContextEntries(options)
+  ]);
+  if (recapEntries.length === 0 && memoryResult.entries.length === 0) {
+    return {
+      prependSystemContext: "",
+      memoryEntries: [],
+      recapEntries: [],
+      vaultPath: memoryResult.vaultPath
+    };
+  }
+  return {
+    prependSystemContext: formatSessionContextInjection(recapEntries, memoryResult.entries),
+    memoryEntries: memoryResult.entries,
+    recapEntries,
+    vaultPath: memoryResult.vaultPath
+  };
+}
+
+// src/plugin/hooks/before-prompt-build.ts
+var MEMORY_RECALL_MANDATE = [
+  "ClawVault Memory Recall Policy:",
+  "- Before answering anything about prior work, people, decisions, preferences, todos, or historical context, call memory_search first.",
+  "- If memory_search returns relevant snippets, ground your answer in those snippets and use memory_get when details are needed.",
+  "- Do not guess from stale context when memory lookup is available."
+].join("\n");
+function appendSection(target, section) {
+  if (!section) return;
+  const trimmed = section.trim();
+  if (!trimmed) return;
+  target.push(trimmed);
+}
+function createBeforePromptBuildHandler(dependencies) {
+  const contextInjector = dependencies.contextInjector ?? buildVaultContextInjection;
+  return async (event, ctx) => {
+    const prependSections = [];
+    const appendSections = [];
+    const recallEnabled = isFeatureEnabled(dependencies.pluginConfig, "enableBeforePromptRecall", true);
+    const protocolEnabled = isFeatureEnabled(dependencies.pluginConfig, "enforceCommunicationProtocol", true);
+    const contextInjectionEnabled = isFeatureEnabled(dependencies.pluginConfig, "enableSessionContextInjection", true);
+    if (recallEnabled) {
+      prependSections.push(MEMORY_RECALL_MANDATE);
+    }
+    const startupNotice = dependencies.runtimeState.consumeStartupRecoveryNotice();
+    appendSection(prependSections, startupNotice ? `[ClawVault Recovery]
+${startupNotice}` : "");
+    if (ctx.sessionKey) {
+      const sessionCacheEntry = dependencies.runtimeState.getSessionRecap(ctx.sessionKey);
+      if (sessionCacheEntry?.recapText && !sessionCacheEntry.recapInjected) {
+        appendSection(prependSections, sessionCacheEntry.recapText);
+        dependencies.runtimeState.markSessionRecapInjected(ctx.sessionKey);
+      }
+    }
+    if (contextInjectionEnabled) {
+      const injection = await contextInjector({
+        prompt: event.prompt,
+        sessionKey: ctx.sessionKey,
+        agentId: ctx.agentId,
+        workspaceDir: ctx.workspaceDir,
+        pluginConfig: dependencies.pluginConfig,
+        contextProfile: dependencies.pluginConfig.contextProfile,
+        maxResults: dependencies.pluginConfig.maxContextResults
+      });
+      appendSection(prependSections, injection.prependSystemContext);
+    }
+    if (protocolEnabled) {
+      appendSections.push(buildCommunicationProtocolAppendix());
+    }
+    if (prependSections.length === 0 && appendSections.length === 0) {
+      return;
+    }
+    return {
+      prependSystemContext: prependSections.join("\n\n"),
+      appendSystemContext: appendSections.join("\n\n")
+    };
+  };
+}
+
+// src/plugin/hooks/message-sending.ts
+var DEFAULT_QUESTION_RECALL_MIN_SCORE = 0.35;
+function normalizeScoreThreshold(config) {
+  const raw = config.minQuestionRecallScore;
+  if (!Number.isFinite(raw)) return DEFAULT_QUESTION_RECALL_MIN_SCORE;
+  return Math.max(0, Math.min(1, Number(raw)));
+}
+function createMessageSendingHandler(dependencies) {
+  return async (event, _ctx) => {
+    const filterEnabled = isFeatureEnabled(dependencies.pluginConfig, "enableMessageSendingFilter", true);
+    if (!filterEnabled) {
+      return;
+    }
+    const rewritten = rewriteOutboundMessage(event.content);
+    let content = rewritten.content;
+    let shouldCancel = false;
+    if (containsQuestion(content)) {
+      const hits = await dependencies.memoryManager.search(content, {
+        maxResults: 2,
+        minScore: normalizeScoreThreshold(dependencies.pluginConfig)
+      });
+      if (hits.length > 0) {
+        content = rewriteQuestionWithMemoryEvidence(content, hits);
+        if (containsQuestion(content)) {
+          shouldCancel = true;
+        }
+      }
+    }
+    if (!shouldCancel && content === event.content) {
+      return;
+    }
+    if (shouldCancel) {
+      return { cancel: true };
+    }
+    return { content };
+  };
+}
+
+// src/plugin/fact-extractor.ts
+import * as fs5 from "fs";
+import * as path5 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");
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function sanitizeText(value, maxLength = MAX_TEXT_LENGTH) {
+  if (typeof value !== "string") return "";
+  return value.replace(/[\x00-\x1f\x7f]/g, " ").replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+function collectTextFragments(target, input, depth = 0) {
+  if (depth > 3 || input === null || input === void 0) return;
+  if (typeof input === "string") {
+    const cleaned = sanitizeText(input);
+    if (cleaned) target.push(cleaned);
+    return;
+  }
+  if (Array.isArray(input)) {
+    for (const item of input) {
+      collectTextFragments(target, item, depth + 1);
+    }
+    return;
+  }
+  if (typeof input !== "object") return;
+  const record = input;
+  const directKeys = ["text", "message", "content", "rawText", "prompt", "observation"];
+  for (const key of directKeys) {
+    const cleaned = sanitizeText(record[key]);
+    if (cleaned) target.push(cleaned);
+  }
+  const nestedKeys = ["messages", "history", "entries", "items", "events", "payload", "context"];
+  for (const key of nestedKeys) {
+    collectTextFragments(target, record[key], depth + 1);
+  }
+}
+function dedupeTexts(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const item of items) {
+    const cleaned = sanitizeText(item);
+    if (!cleaned || seen.has(cleaned)) continue;
+    seen.add(cleaned);
+    deduped.push(cleaned);
+  }
+  return deduped;
+}
+function collectObservedTextsForFactExtraction(event) {
+  const collected = [];
+  collectTextFragments(collected, event);
+  return dedupeTexts(collected);
+}
+function extractTimestamp(event) {
+  if (!event || typeof event !== "object") {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const record = event;
+  const candidates = [
+    record.timestamp,
+    record.scheduledAt,
+    record.time,
+    record.context?.timestamp
+  ];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const date = new Date(String(candidate));
+    if (!Number.isNaN(date.getTime())) {
+      return date.toISOString();
+    }
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function buildEntityGraph(facts) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  for (const fact of facts) {
+    const sourceId = `entity:${fact.entityNorm || fact.entity.toLowerCase()}`;
+    const sourceNode = nodes.get(sourceId) ?? {
+      id: sourceId,
+      name: fact.entityNorm || fact.entity.toLowerCase(),
+      displayName: fact.entity,
+      type: "person",
+      attributes: { entityNorm: fact.entityNorm || fact.entity.toLowerCase() },
+      lastSeen: fact.validFrom
+    };
+    if (new Date(fact.validFrom).getTime() > new Date(sourceNode.lastSeen).getTime()) {
+      sourceNode.lastSeen = fact.validFrom;
+    }
+    nodes.set(sourceId, sourceNode);
+    const normalizedValue = fact.value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    const targetId = `value:${fact.relation}:${normalizedValue || "unknown"}`;
+    const targetNode = nodes.get(targetId) ?? {
+      id: targetId,
+      name: normalizedValue || "unknown",
+      displayName: fact.value,
+      type: "attribute",
+      attributes: { relation: fact.relation },
+      lastSeen: fact.validFrom
+    };
+    if (new Date(fact.validFrom).getTime() > new Date(targetNode.lastSeen).getTime()) {
+      targetNode.lastSeen = fact.validFrom;
+    }
+    nodes.set(targetId, targetNode);
+    const edgeHash = createHash2("sha1").update(`${fact.id}|${sourceId}|${targetId}|${fact.validFrom}`).digest("hex").slice(0, 18);
+    edges.push({
+      id: `edge:${edgeHash}`,
+      source: sourceId,
+      target: targetId,
+      relation: fact.relation,
+      validFrom: fact.validFrom,
+      validUntil: fact.validUntil,
+      confidence: Math.max(0, Math.min(1, fact.confidence ?? 0.7))
+    });
+  }
+  return {
+    version: 1,
+    nodes: [...nodes.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    edges: edges.sort((a, b) => a.id.localeCompare(b.id))
+  };
+}
+function ensureFactsLogFile(vaultPath) {
+  const filePath = path5.join(ensureClawVaultDir(vaultPath), FACTS_FILE);
+  if (!fs5.existsSync(filePath)) {
+    fs5.writeFileSync(filePath, "", "utf-8");
+  }
+}
+function persistFactsAndGraph(vaultPath, extractedFacts) {
+  ensureFactsLogFile(vaultPath);
+  const store = new FactStore(vaultPath);
+  store.load();
+  const conflictsResolved = store.addFacts(extractedFacts);
+  store.save();
+  const allFacts = store.getAllFacts();
+  const graph = buildEntityGraph(allFacts);
+  const graphPath = path5.join(ensureClawVaultDir(vaultPath), ENTITY_GRAPH_FILE);
+  fs5.writeFileSync(graphPath, `${JSON.stringify(graph, null, 2)}
+`, "utf-8");
+  return {
+    extracted: extractedFacts.length,
+    added: Math.max(0, extractedFacts.length - conflictsResolved),
+    conflictsResolved,
+    totalFacts: allFacts.length
+  };
+}
+function runFactExtractionForEvent(vaultPath, event, sourceLabel) {
+  const observedTexts = collectObservedTextsForFactExtraction(event);
+  if (observedTexts.length === 0) {
+    return { extracted: 0, added: 0, conflictsResolved: 0, totalFacts: 0 };
+  }
+  const validFrom = extractTimestamp(event);
+  const source = `hook:${sourceLabel}`;
+  const facts = [];
+  for (const text of observedTexts) {
+    facts.push(...extractFactsRuleBased(text, source, validFrom));
+  }
+  if (facts.length === 0) {
+    return { extracted: 0, added: 0, conflictsResolved: 0, totalFacts: 0 };
+  }
+  return persistFactsAndGraph(vaultPath, facts);
+}
+
+// src/plugin/hooks/session-lifecycle.ts
+function getWeekKey(date) {
+  const year = date.getUTCFullYear();
+  const start = Date.UTC(year, 0, 1);
+  const days = Math.floor((date.getTime() - start) / (24 * 60 * 60 * 1e3));
+  const week = Math.floor(days / 7) + 1;
+  return `${year}-W${String(week).padStart(2, "0")}`;
+}
+function isSundayMidnightUtc(date) {
+  return date.getUTCDay() === 0 && date.getUTCHours() === 0 && date.getUTCMinutes() === 0;
+}
+async function runWeeklyReflectionIfNeeded(deps, agentId, workspaceDir) {
+  if (!isOptInEnabled(deps.pluginConfig, "enableWeeklyReflection", "weeklyReflection")) {
+    return;
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (!isSundayMidnightUtc(now)) {
+    return;
+  }
+  const weekKey = getWeekKey(now);
+  if (!deps.runtimeState.shouldRunWeeklyReflection(weekKey)) {
+    return;
+  }
+  const vaultPath = resolveVaultPathForAgent(deps.pluginConfig, {
+    agentId,
+    cwd: workspaceDir
+  });
+  if (!vaultPath) {
+    return;
+  }
+  const result = runClawvault(["reflect", "-v", vaultPath], deps.pluginConfig, {
+    timeoutMs: 12e4
+  });
+  if (result.success) {
+    deps.runtimeState.markWeeklyReflectionRun(weekKey);
+    deps.logger?.info("[clawvault] Weekly reflection complete");
+  } else if (!result.skipped) {
+    deps.logger?.warn("[clawvault] Weekly reflection failed");
+  }
+}
+async function handleGatewayStart(event, ctx, deps) {
+  const shouldRecover = isOptInEnabled(deps.pluginConfig, "enableStartupRecovery");
+  if (!shouldRecover) {
+    return;
+  }
+  const vaultPath = resolveVaultPathForAgent(deps.pluginConfig, { cwd: process.cwd(), agentId: "main" });
+  if (!vaultPath) {
+    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) {
+    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.";
+    deps.runtimeState.setStartupRecoveryNotice(message);
+    deps.logger?.warn("[clawvault] Context death detected at startup");
+  }
+  if (ctx.port || event.port) {
+  }
+}
+async function handleSessionStart(event, ctx, deps) {
+  const sessionKey = sanitizeSessionKey(ctx.sessionKey ?? event.sessionKey);
+  const agentId = resolveAgentId({ agentId: ctx.agentId, sessionKey }, deps.pluginConfig);
+  if (isOptInEnabled(deps.pluginConfig, "enableSessionContextInjection")) {
+    const recapEntries = await fetchSessionRecapEntries({
+      sessionKey,
+      agentId: extractAgentIdFromSessionKey(sessionKey) || agentId,
+      pluginConfig: deps.pluginConfig
+    });
+    if (recapEntries.length > 0) {
+      const recapInjection = formatSessionContextInjection(recapEntries, []);
+      deps.runtimeState.setSessionRecap(sessionKey, recapInjection);
+    }
+  }
+  await runWeeklyReflectionIfNeeded(deps, agentId, void 0);
+}
+function sanitizeForCheckpoint(value, maxLength) {
+  if (typeof value !== "string") return "unknown";
+  const cleaned = value.replace(/[^a-zA-Z0-9:_ -]/g, "").trim();
+  return cleaned.slice(0, maxLength) || "unknown";
+}
+async function handleBeforeReset(event, ctx, deps) {
+  const autoCheckpointEnabled = isOptInEnabled(deps.pluginConfig, "enableAutoCheckpoint", "autoCheckpoint");
+  const observerOnResetEnabled = isOptInEnabled(deps.pluginConfig, "enableObserveOnNew");
+  const factExtractionEnabled = isOptInEnabled(deps.pluginConfig, "enableFactExtraction");
+  if (!autoCheckpointEnabled && !observerOnResetEnabled && !factExtractionEnabled) {
+    return;
+  }
+  const sessionKey = sanitizeSessionKey(ctx.sessionKey);
+  const agentId = resolveAgentId(ctx, deps.pluginConfig);
+  const vaultPath = resolveVaultPathForAgent(deps.pluginConfig, {
+    agentId,
+    cwd: ctx.workspaceDir
+  });
+  if (!vaultPath) {
+    return;
+  }
+  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) {
+      deps.logger?.warn("[clawvault] Auto-checkpoint before reset failed");
+    }
+  }
+  if (observerOnResetEnabled) {
+    runObserverCron(vaultPath, agentId, deps.pluginConfig, {
+      minNewBytes: 1,
+      reason: "before_reset"
+    });
+  }
+  if (factExtractionEnabled) {
+    runFactExtractionForEvent(vaultPath, event, "before_reset");
+  }
+}
+async function handleSessionEnd(event, ctx, deps) {
+  deps.runtimeState.clearSession(ctx.sessionKey ?? event.sessionKey);
+}
+
+// src/plugin/hooks/observation.ts
+async function handleAgentEndHeartbeat(event, ctx, deps) {
+  if (!isOptInEnabled(deps.pluginConfig, "enableHeartbeatObservation", "observeOnHeartbeat")) {
+    return;
+  }
+  const agentId = resolveAgentId(ctx, deps.pluginConfig);
+  const vaultPath = resolveVaultPathForAgent(deps.pluginConfig, {
+    agentId,
+    cwd: ctx.workspaceDir
+  });
+  if (!vaultPath) {
+    return;
+  }
+  if (!shouldObserveActiveSessions(vaultPath, agentId, deps.pluginConfig)) {
+    return;
+  }
+  const observed = runObserverCron(vaultPath, agentId, deps.pluginConfig, {
+    reason: "agent_end heartbeat"
+  });
+  if (!observed) {
+    deps.logger?.warn("[clawvault] Heartbeat observation trigger failed");
+  }
+  if (!event.success && event.error) {
+    deps.logger?.info(`[clawvault] Agent ended with error: ${event.error}`);
+  }
+}
+async function handleBeforeCompactionObservation(event, ctx, deps) {
+  const compactionObserveEnabled = isOptInEnabled(deps.pluginConfig, "enableCompactionObservation");
+  const factExtractionEnabled = isOptInEnabled(deps.pluginConfig, "enableFactExtraction");
+  if (!compactionObserveEnabled && !factExtractionEnabled) {
+    return;
+  }
+  const agentId = resolveAgentId(ctx, deps.pluginConfig);
+  const vaultPath = resolveVaultPathForAgent(deps.pluginConfig, {
+    agentId,
+    cwd: ctx.workspaceDir
+  });
+  if (!vaultPath) {
+    return;
+  }
+  if (compactionObserveEnabled) {
+    runObserverCron(vaultPath, agentId, deps.pluginConfig, {
+      minNewBytes: 1,
+      reason: "before_compaction"
+    });
+  }
+  if (factExtractionEnabled) {
+    runFactExtractionForEvent(vaultPath, event, "before_compaction");
+  }
+}
+
+// src/openclaw-plugin.ts
+function isOpenClawPluginApi(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return typeof record.on === "function" && typeof record.registerTool === "function" && typeof record.logger === "object";
+}
+async function registerOpenClawPlugin(api) {
+  const pluginConfig = readPluginConfig(api);
+  const runtimeState = new ClawVaultPluginRuntimeState();
+  const memoryManager = new ClawVaultMemoryManager({
+    pluginConfig,
+    defaultAgentId: "main",
+    logger: {
+      debug: api.logger.debug,
+      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.on("before_prompt_build", createBeforePromptBuildHandler({
+    pluginConfig,
+    runtimeState
+  }), { priority: 30 });
+  api.on("message_sending", createMessageSendingHandler({
+    pluginConfig,
+    memoryManager
+  }), { priority: 20 });
+  api.on("gateway_start", async (event, ctx) => {
+    await handleGatewayStart(event, ctx, {
+      pluginConfig,
+      runtimeState,
+      logger: api.logger
+    });
+  });
+  api.on("session_start", async (event, ctx) => {
+    await handleSessionStart(event, ctx, {
+      pluginConfig,
+      runtimeState,
+      logger: api.logger
+    });
+  });
+  api.on("session_end", async (event, ctx) => {
+    await handleSessionEnd(event, ctx, {
+      pluginConfig,
+      runtimeState,
+      logger: api.logger
+    });
+  });
+  api.on("before_reset", async (event, ctx) => {
+    await handleBeforeReset(event, ctx, {
+      pluginConfig,
+      runtimeState,
+      logger: api.logger
+    });
+  });
+  api.on("before_compaction", async (event, ctx) => {
+    await handleBeforeCompactionObservation(event, ctx, {
+      pluginConfig,
+      logger: api.logger
+    });
+  });
+  api.on("agent_end", async (event, ctx) => {
+    await handleAgentEndHeartbeat(event, ctx, {
+      pluginConfig,
+      logger: api.logger
+    });
+  });
+  return {
+    plugins: {
+      slots: {
+        memory: memoryManager
+      }
+    }
+  };
+}
+var clawvaultPlugin = {
+  id: "clawvault",
+  name: "ClawVault",
+  kind: "memory",
+  description: "Structured memory system for AI agents with proactive recall and protocol-safe messaging",
+  async register(apiOrRuntime) {
+    if (isOpenClawPluginApi(apiOrRuntime)) {
+      return registerOpenClawPlugin(apiOrRuntime);
+    }
+    if (apiOrRuntime && typeof apiOrRuntime === "object") {
+      registerMemorySlot(apiOrRuntime);
+    }
+    return createMemorySlotPlugin();
+  }
+};
+var openclaw_plugin_default = clawvaultPlugin;
+
+export {
+  extractTaggedMemoryNotes,
+  extractHeuristicMemories,
+  extractMemoriesFromAssistantResponse,
+  isLikelyJunkMemory,
+  plausibilityScore,
+  evaluateCandidateQuality,
+  LiveCaptureService,
+  createMemorySlot,
+  createMemorySlotPlugin,
+  registerMemorySlot,
+  openclaw_plugin_default
+};