clawvault 2.6.4 → 2.6.5

package/dist/chunk-FBITHIZF.js

@@ -0,0 +1,351 @@
+import {
+  withQmdIndexArgs
+} from "./chunk-5PJ4STIC.js";
+
+// src/lib/qmd-collections.ts
+import { execFileSync } from "child_process";
+var COLLECTION_HEADER_RE = /^(\S+)\s+\(qmd:\/\/([^)]+)\)\s*$/;
+var DETAIL_LINE_RE = /^\s+([A-Za-z][A-Za-z0-9 _-]*):\s*(.+)\s*$/;
+var QMD_INDEX_ENV_VAR = "CLAWVAULT_QMD_INDEX";
+function normalizeDetailKey(value) {
+  return value.trim().toLowerCase().replace(/[ -]+/g, "_");
+}
+function parseCount(raw) {
+  if (!raw) return void 0;
+  const match = raw.match(/-?\d[\d,]*/);
+  if (!match) return void 0;
+  const parsed = Number.parseInt(match[0].replace(/,/g, ""), 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function pickDetail(details, keys) {
+  for (const key of keys) {
+    const value = details[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function pickCount(details, keys) {
+  for (const key of keys) {
+    const parsed = parseCount(details[key]);
+    if (parsed !== void 0) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function resolveQmdIndexName(indexName) {
+  const explicit = indexName?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const fromEnv = process.env[QMD_INDEX_ENV_VAR]?.trim();
+  return fromEnv || void 0;
+}
+function withQmdIndexArgs2(args, indexName) {
+  if (args.includes("--index")) {
+    return [...args];
+  }
+  const resolvedIndexName = resolveQmdIndexName(indexName);
+  if (!resolvedIndexName) {
+    return [...args];
+  }
+  return ["--index", resolvedIndexName, ...args];
+}
+function parseQmdCollectionList(raw) {
+  const collections = [];
+  let current = null;
+  for (const line of raw.split(/\r?\n/)) {
+    const headerMatch = line.match(COLLECTION_HEADER_RE);
+    if (headerMatch) {
+      current = {
+        name: headerMatch[1],
+        uri: headerMatch[2],
+        details: {}
+      };
+      collections.push(current);
+      continue;
+    }
+    if (!current) continue;
+    const detailMatch = line.match(DETAIL_LINE_RE);
+    if (!detailMatch) continue;
+    const key = normalizeDetailKey(detailMatch[1]);
+    current.details[key] = detailMatch[2].trim();
+  }
+  for (const collection of collections) {
+    const root = pickDetail(collection.details, ["root", "path", "directory"]);
+    if (root) {
+      collection.root = root;
+    }
+    collection.files = pickCount(collection.details, ["files", "documents", "docs"]);
+    collection.vectors = pickCount(collection.details, ["vectors", "embeddings", "vector_embeddings"]);
+    collection.pendingEmbeddings = pickCount(collection.details, [
+      "pending",
+      "pending_vectors",
+      "pending_embeddings",
+      "unembedded",
+      "without_embeddings"
+    ]);
+    if (collection.pendingEmbeddings === void 0 && collection.files !== void 0 && collection.vectors !== void 0) {
+      collection.pendingEmbeddings = Math.max(collection.files - collection.vectors, 0);
+    }
+  }
+  return collections;
+}
+function listQmdCollections(indexName) {
+  const output = execFileSync("qmd", withQmdIndexArgs2(["collection", "list"], indexName), {
+    encoding: "utf-8"
+  });
+  return parseQmdCollectionList(output);
+}
+function removeQmdCollection(name, indexName) {
+  try {
+    execFileSync("qmd", withQmdIndexArgs2(["collection", "remove", name], indexName), { stdio: "ignore" });
+    return;
+  } catch {
+    execFileSync("qmd", withQmdIndexArgs2(["collection", "rm", name], indexName), { stdio: "ignore" });
+  }
+}
+function collectionExists(name, indexName) {
+  try {
+    const collections = listQmdCollections(indexName);
+    return collections.some((c) => c.name === name);
+  } catch {
+    return false;
+  }
+}
+function getCollectionByName(name, indexName) {
+  try {
+    const collections = listQmdCollections(indexName);
+    return collections.find((collection) => collection.name === name);
+  } catch {
+    return void 0;
+  }
+}
+function findCollectionByRoot(rootPath, indexName) {
+  try {
+    const collections = listQmdCollections(indexName);
+    const normalizedRoot = rootPath.replace(/\/$/, "");
+    return collections.find((c) => {
+      if (!c.root) return false;
+      const normalizedCollectionRoot = c.root.replace(/\/$/, "");
+      return normalizedCollectionRoot === normalizedRoot;
+    });
+  } catch {
+    return void 0;
+  }
+}
+function getFirstCollection(indexName) {
+  try {
+    const collections = listQmdCollections(indexName);
+    return collections[0];
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lib/vault-qmd-config.ts
+import * as fs from "fs";
+import * as path from "path";
+var CONFIG_FILE = ".clawvault.json";
+function readTrimmedString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function autoDetectCollection(vaultPath, fallbackName) {
+  const byRoot = findCollectionByRoot(vaultPath);
+  if (byRoot) {
+    return { collection: byRoot.name, autoDetected: true };
+  }
+  if (collectionExists(fallbackName)) {
+    return { collection: fallbackName, autoDetected: false };
+  }
+  const first = getFirstCollection();
+  if (first) {
+    return { collection: first.name, autoDetected: true };
+  }
+  return { collection: fallbackName, autoDetected: false };
+}
+function loadVaultQmdConfig(vaultPath) {
+  const resolvedVaultPath = path.resolve(vaultPath);
+  const fallbackName = path.basename(resolvedVaultPath);
+  const fallbackRoot = resolvedVaultPath;
+  const configPath = path.join(resolvedVaultPath, CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    const { collection, autoDetected } = autoDetectCollection(resolvedVaultPath, fallbackName);
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection: collection,
+      qmdRoot: fallbackRoot,
+      autoDetected
+    };
+  }
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const configuredName = readTrimmedString(raw.name) ?? fallbackName;
+    const configuredCollection = readTrimmedString(raw.qmdCollection);
+    const rawRoot = readTrimmedString(raw.qmdRoot) ?? fallbackRoot;
+    const qmdRoot = path.isAbsolute(rawRoot) ? path.resolve(rawRoot) : path.resolve(resolvedVaultPath, rawRoot);
+    if (configuredCollection && collectionExists(configuredCollection)) {
+      return {
+        vaultPath: resolvedVaultPath,
+        qmdCollection: configuredCollection,
+        qmdRoot
+      };
+    }
+    const { collection, autoDetected } = autoDetectCollection(qmdRoot, configuredCollection ?? configuredName);
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection: collection,
+      qmdRoot,
+      autoDetected
+    };
+  } catch {
+    const { collection, autoDetected } = autoDetectCollection(resolvedVaultPath, fallbackName);
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection: collection,
+      qmdRoot: fallbackRoot,
+      autoDetected
+    };
+  }
+}
+
+// src/lib/qmd-embedding-recovery.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var CLAWVAULT_DIR = ".clawvault";
+var QMD_EMBED_WAL_FILE = "qmd-embed.wal.json";
+var WALK_SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", ".trash", ".clawvault", "node_modules"]);
+function getQmdEmbedWalPath(vaultPath) {
+  return path2.join(vaultPath, CLAWVAULT_DIR, QMD_EMBED_WAL_FILE);
+}
+function writeJsonAtomic(filePath, value) {
+  const dir = path2.dirname(filePath);
+  fs2.mkdirSync(dir, { recursive: true });
+  const tmpPath = path2.join(
+    dir,
+    `${path2.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
+  );
+  try {
+    fs2.writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+    fs2.renameSync(tmpPath, filePath);
+  } finally {
+    if (fs2.existsSync(tmpPath)) {
+      fs2.rmSync(tmpPath, { force: true });
+    }
+  }
+}
+function runQmdCommand(args, indexName) {
+  execFileSync2("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
+}
+function runQmdEmbedForce(collection, indexName) {
+  try {
+    runQmdCommand(["embed", "-f", "-c", collection], indexName);
+  } catch {
+    runQmdCommand(["embed", "-c", collection], indexName);
+  }
+}
+function countMarkdownFiles(rootPath) {
+  let total = 0;
+  const stack = [rootPath];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries;
+    try {
+      entries = fs2.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const entryPath = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || WALK_SKIP_DIRS.has(entry.name)) {
+          continue;
+        }
+        stack.push(entryPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".md") && !entry.name.startsWith(".")) {
+        total += 1;
+      }
+    }
+  }
+  return total;
+}
+function shouldRecoverEmptyVectors(collectionInfo, markdownCount) {
+  if (!collectionInfo) return false;
+  if (markdownCount === 0) return false;
+  if (collectionInfo.vectors === void 0) return false;
+  if (collectionInfo.vectors > 0) return false;
+  if (collectionInfo.pendingEmbeddings !== void 0 && collectionInfo.pendingEmbeddings > 0) {
+    return false;
+  }
+  return true;
+}
+function hasWalMarker(vaultPath) {
+  return fs2.existsSync(getQmdEmbedWalPath(vaultPath));
+}
+function clearQmdEmbedWalRecord(vaultPath) {
+  const walPath = getQmdEmbedWalPath(vaultPath);
+  if (fs2.existsSync(walPath)) {
+    fs2.rmSync(walPath, { force: true });
+  }
+}
+function writeQmdEmbedWalRecord(options) {
+  const wal = {
+    version: 1,
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    collection: options.collection,
+    rootPath: options.rootPath,
+    indexName: options.indexName
+  };
+  writeJsonAtomic(getQmdEmbedWalPath(options.vaultPath), wal);
+}
+function runCrashSafeQmdEmbed(options) {
+  writeQmdEmbedWalRecord(options);
+  try {
+    runQmdCommand(["embed", "-c", options.collection], options.indexName);
+    clearQmdEmbedWalRecord(options.vaultPath);
+  } catch (err) {
+    throw err;
+  }
+}
+function recoverQmdEmbeddingIfNeeded(options) {
+  const mode = options.mode ?? "marker-or-empty";
+  let reason;
+  if (hasWalMarker(options.vaultPath)) {
+    reason = "interrupted_wal";
+  } else if (mode === "marker-or-empty") {
+    const collectionInfo = getCollectionByName(options.collection, options.indexName);
+    const markdownCount = countMarkdownFiles(options.rootPath);
+    if (shouldRecoverEmptyVectors(collectionInfo, markdownCount)) {
+      reason = "empty_vectors";
+    }
+  }
+  if (!reason) {
+    return { recovered: false };
+  }
+  options.onLog?.(
+    reason === "interrupted_wal" ? `Detected interrupted qmd embedding run for "${options.collection}". Rebuilding...` : `Detected empty qmd vector state for "${options.collection}". Rebuilding...`
+  );
+  runQmdCommand(["update", "-c", options.collection], options.indexName);
+  runQmdEmbedForce(options.collection, options.indexName);
+  clearQmdEmbedWalRecord(options.vaultPath);
+  return { recovered: true, reason };
+}
+
+export {
+  parseQmdCollectionList,
+  listQmdCollections,
+  removeQmdCollection,
+  loadVaultQmdConfig,
+  runCrashSafeQmdEmbed,
+  recoverQmdEmbeddingIfNeeded
+};

package/dist/{chunk-OQGYFZ4A.js → chunk-FUSLEY6L.js}

@@ -56,6 +56,11 @@ var TODO_SIGNAL_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bre
 var COMMITMENT_TASK_SIGNAL_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
 var UNRESOLVED_COMMITMENT_RE = /\b(?:need to figure out|tbd|to be determined)\b/i;
 var DEADLINE_SIGNAL_RE = /\b(?:by\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|tomorrow)|before\s+the\s+\w+|deadline is)\b/i;
+var ROLE_PREFIX_RE = /^([a-z][a-z0-9_-]{1,31})\s*:\s*(.+)$/i;
+var BASE64_DATA_URI_RE = /\bdata:[^;\s]+;base64,[A-Za-z0-9+/=]{24,}\b/gi;
+var LONG_BASE64_TOKEN_RE = /\b[A-Za-z0-9+/]{80,}={0,2}\b/g;
+var NOISE_PREFIX_RE = /^(?:metadata|system metadata|session metadata)\s*:/i;
+var STRUCTURED_NOISE_MARKER_RE = /\b(?:tool[_-]?result|tool[_-]?use|toolcallid|tooluseid|function[_-]?(?:call|result)|stdout|stderr|exitcode|recordedat|trace(?:_|-)?id|parent(?:_|-)?id|session(?:_|-)?id|metadata|base64|mime(?:type)?)\b/i;
 var Compressor = class {
   provider;
   model;
@@ -72,7 +77,7 @@ var Compressor = class {
     this.fetchImpl = options.fetchImpl ?? fetch;
   }
   async compress(messages, existingObservations) {
-    const cleanedMessages = messages.map((message) => message.trim()).filter(Boolean);
+    const cleanedMessages = this.sanitizeIncomingMessages(messages);
     if (cleanedMessages.length === 0) {
       return existingObservations.trim();
     }
@@ -91,6 +96,82 @@ var Compressor = class {
     const fallback = this.fallbackCompression(cleanedMessages);
     return this.mergeObservations(existingObservations, fallback);
   }
+  sanitizeIncomingMessages(messages) {
+    const sanitized = [];
+    for (const message of messages) {
+      const cleaned = this.sanitizeIncomingMessage(message);
+      if (cleaned) {
+        sanitized.push(cleaned);
+      }
+    }
+    return sanitized;
+  }
+  sanitizeIncomingMessage(message) {
+    const normalized = message.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+      return "";
+    }
+    const roleMatch = ROLE_PREFIX_RE.exec(normalized);
+    if (roleMatch && this.isConversationRolePrefix(roleMatch[1])) {
+      const role = this.normalizeMessageRole(roleMatch[1]);
+      if (this.shouldDropMessageRole(role)) {
+        return "";
+      }
+      const content = this.stripNoisyData(roleMatch[2]);
+      if (!content || this.isLikelyStructuredNoise(content)) {
+        return "";
+      }
+      return `${role}: ${content}`;
+    }
+    const cleaned = this.stripNoisyData(normalized);
+    if (!cleaned || this.isLikelyStructuredNoise(cleaned)) {
+      return "";
+    }
+    return cleaned;
+  }
+  normalizeMessageRole(role) {
+    return role.trim().toLowerCase();
+  }
+  isConversationRolePrefix(role) {
+    const normalized = role.trim().toLowerCase().replace(/[\s_-]+/g, "");
+    if (!normalized) {
+      return false;
+    }
+    if (normalized === "user" || normalized === "assistant" || normalized === "system") {
+      return true;
+    }
+    if (normalized === "developer" || normalized === "metadata") {
+      return true;
+    }
+    return normalized.startsWith("tool");
+  }
+  shouldDropMessageRole(role) {
+    const normalized = role.replace(/[\s_-]+/g, "");
+    if (!normalized) {
+      return false;
+    }
+    if (normalized === "system" || normalized === "developer" || normalized === "metadata") {
+      return true;
+    }
+    return normalized.startsWith("tool");
+  }
+  stripNoisyData(value) {
+    return value.replace(BASE64_DATA_URI_RE, " ").replace(LONG_BASE64_TOKEN_RE, " ").replace(/\s+/g, " ").trim();
+  }
+  isLikelyStructuredNoise(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return true;
+    }
+    if (NOISE_PREFIX_RE.test(trimmed)) {
+      return true;
+    }
+    const looksStructured = trimmed.startsWith("{") || trimmed.startsWith("[");
+    if (looksStructured && STRUCTURED_NOISE_MARKER_RE.test(trimmed) && trimmed.length >= 40) {
+      return true;
+    }
+    return false;
+  }
   resolveProvider() {
     if (process.env.CLAWVAULT_NO_LLM) return null;
     if (this.provider) {

package/dist/{chunk-42MXU7A6.js → chunk-K4GFGKFD.js}

@@ -14,7 +14,7 @@ function findProtectedRanges(content) {
   while ((match = codeBlockRegex.exec(content)) !== null) {
     ranges.push({ start: match.index, end: match.index + match[0].length });
   }
-  const inlineCodeRegex = /`[^`]+`/g;
+  const inlineCodeRegex = /(?<!`)`[^`\n]+`(?!`)/g;
   while ((match = inlineCodeRegex.exec(content)) !== null) {
     ranges.push({ start: match.index, end: match.index + match[0].length });
   }
@@ -28,8 +28,42 @@ function findProtectedRanges(content) {
   }
   return ranges;
 }
-function isProtected(pos, ranges) {
-  return ranges.some((r) => pos >= r.start && pos < r.end);
+function isProtectedRange(start, end, ranges) {
+  return ranges.some((range) => start < range.end && end > range.start);
+}
+function createAliasRegex(alias) {
+  const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${escapedAlias}\\b`, "gi");
+}
+function formatWikiLink(path, originalText) {
+  return originalText.toLowerCase() === path.split("/").pop()?.toLowerCase() ? `[[${path}]]` : `[[${path}|${originalText}]]`;
+}
+function planLinks(content, index, protectedRanges) {
+  const sortedAliases = getSortedAliases(index);
+  const linkedEntities = /* @__PURE__ */ new Set();
+  const claimedRanges = [];
+  const plannedLinks = [];
+  for (const { alias, path } of sortedAliases) {
+    if (linkedEntities.has(path)) continue;
+    const regex = createAliasRegex(alias);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (isProtectedRange(start, end, protectedRanges)) continue;
+      if (isProtectedRange(start, end, claimedRanges)) continue;
+      plannedLinks.push({
+        start,
+        end,
+        originalText: match[0],
+        path
+      });
+      claimedRanges.push({ start, end });
+      linkedEntities.add(path);
+      break;
+    }
+  }
+  return plannedLinks;
 }
 function createLineLookup(content) {
   const lines = content.split("\n");
@@ -48,56 +82,24 @@ function createLineLookup(content) {
 }
 function autoLink(content, index) {
   const protectedRanges = findProtectedRanges(content);
-  const sortedAliases = getSortedAliases(index);
-  const linkedEntities = /* @__PURE__ */ new Set();
+  const plannedLinks = planLinks(content, index, protectedRanges);
   let result = content;
-  let offset = 0;
-  for (const { alias, path } of sortedAliases) {
-    if (linkedEntities.has(path)) continue;
-    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      const originalPos = match.index;
-      const adjustedPos = originalPos + offset;
-      if (isProtected(originalPos, protectedRanges)) continue;
-      const beforeMatch = result.substring(0, adjustedPos);
-      const openBrackets = (beforeMatch.match(/\[\[/g) || []).length;
-      const closeBrackets = (beforeMatch.match(/\]\]/g) || []).length;
-      if (openBrackets > closeBrackets) continue;
-      const originalText = match[0];
-      const replacement = originalText.toLowerCase() === path.split("/").pop()?.toLowerCase() ? `[[${path}]]` : `[[${path}|${originalText}]]`;
-      result = result.substring(0, adjustedPos) + replacement + result.substring(adjustedPos + originalText.length);
-      offset += replacement.length - originalText.length;
-      linkedEntities.add(path);
-      break;
-    }
+  const sortedByPosition = plannedLinks.slice().sort((a, b) => b.start - a.start);
+  for (const planned of sortedByPosition) {
+    const replacement = formatWikiLink(planned.path, planned.originalText);
+    result = result.substring(0, planned.start) + replacement + result.substring(planned.end);
   }
   return result;
 }
 function dryRunLink(content, index) {
   const protectedRanges = findProtectedRanges(content);
-  const sortedAliases = getSortedAliases(index);
-  const linkedEntities = /* @__PURE__ */ new Set();
-  const matches = [];
+  const plannedLinks = planLinks(content, index, protectedRanges);
   const getLineNumber = createLineLookup(content);
-  for (const { alias, path } of sortedAliases) {
-    if (linkedEntities.has(path)) continue;
-    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      if (isProtected(match.index, protectedRanges)) continue;
-      matches.push({
-        alias: match[0],
-        path,
-        line: getLineNumber(match.index)
-      });
-      linkedEntities.add(path);
-      break;
-    }
-  }
-  return matches;
+  return plannedLinks.map((planned) => ({
+    alias: planned.originalText,
+    path: planned.path,
+    line: getLineNumber(planned.start)
+  }));
 }
 function findUnlinkedMentions(content, index) {
   const protectedRanges = findProtectedRanges(content);
@@ -111,7 +113,9 @@ function findUnlinkedMentions(content, index) {
     const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
     let match;
     while ((match = regex.exec(content)) !== null) {
-      if (isProtected(match.index, protectedRanges)) continue;
+      const start = match.index;
+      const end = start + match[0].length;
+      if (isProtectedRange(start, end, protectedRanges)) continue;
       matches.push({
         alias: match[0],
         path,

package/dist/{chunk-LUBZXECN.js → chunk-KSZROBFH.js}

@@ -1,6 +1,6 @@
 import {
   Observer
-} from "./chunk-OQGYFZ4A.js";
+} from "./chunk-FUSLEY6L.js";
 import {
   resolveVaultPath
 } from "./chunk-GNJL4YGR.js";

package/dist/{chunk-MFL6EEPF.js → chunk-LMKQ7NIF.js}

@@ -3,18 +3,18 @@ import {
 } from "./chunk-7ZRP733D.js";
 import {
   scanVaultLinks
-} from "./chunk-4VQTUVH7.js";
+} from "./chunk-7YZWHM36.js";
 import {
   getObserverStaleness
-} from "./chunk-627Q3QWK.js";
+} from "./chunk-T3FKSZSN.js";
 import {
   ClawVault,
   findVault
-} from "./chunk-YDWHS4LJ.js";
+} from "./chunk-YD7SVXTF.js";
 import {
   listQmdCollections,
   loadVaultQmdConfig
-} from "./chunk-WIOLLGAD.js";
+} from "./chunk-FBITHIZF.js";
 import {
   QMD_INSTALL_COMMAND,
   QMD_INSTALL_URL,
@@ -22,7 +22,7 @@ import {
 } from "./chunk-5PJ4STIC.js";
 import {
   loadMemoryGraphIndex
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 import {
   checkOpenClawCompatibility
 } from "./chunk-X3SPPUFG.js";

package/dist/{chunk-MPOSMDMU.js → chunk-M5O6FQ66.js}

@@ -3,19 +3,19 @@ import {
 } from "./chunk-Y6VJKXGL.js";
 import {
   registerObserveCommand
-} from "./chunk-P7SY3D4E.js";
+} from "./chunk-SV7T4HRE.js";
 import {
   registerReflectCommand
 } from "./chunk-S5OJEGFG.js";
 import {
   registerContextCommand
-} from "./chunk-LIGHWOH6.js";
+} from "./chunk-TS6NDVOU.js";
 import {
   registerEmbedCommand
-} from "./chunk-ECRZL5XR.js";
+} from "./chunk-2GKPENIR.js";
 import {
   registerInjectCommand
-} from "./chunk-YNIPYN4F.js";
+} from "./chunk-A4EAUO7T.js";
 
 // src/cli/index.ts
 function registerCliCommands(program) {