clawvault 1.11.2 → 2.0.0

package/dist/chunk-TXO34J3O.js

@@ -0,0 +1,56 @@
+import {
+  buildOrUpdateMemoryGraphIndex,
+  loadMemoryGraphIndex
+} from "./chunk-O5V7SD5C.js";
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
+
+// src/commands/graph.ts
+function formatGraphSummary(summary) {
+  const lines = [];
+  lines.push("Memory Graph Summary");
+  lines.push("-".repeat(34));
+  lines.push(`Schema version: ${summary.schemaVersion}`);
+  lines.push(`Generated at: ${summary.generatedAt}`);
+  lines.push(`Files indexed: ${summary.fileCount}`);
+  lines.push(`Nodes: ${summary.nodeCount}`);
+  lines.push(`Edges: ${summary.edgeCount}`);
+  lines.push("");
+  lines.push("Node types:");
+  for (const [type, count] of Object.entries(summary.nodeTypeCounts).sort((a, b) => a[0].localeCompare(b[0]))) {
+    lines.push(`  - ${type}: ${count}`);
+  }
+  lines.push("");
+  lines.push("Edge types:");
+  for (const [type, count] of Object.entries(summary.edgeTypeCounts).sort((a, b) => a[0].localeCompare(b[0]))) {
+    lines.push(`  - ${type}: ${count}`);
+  }
+  return lines.join("\n");
+}
+async function graphSummary(options = {}) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const index = options.refresh ? await buildOrUpdateMemoryGraphIndex(vaultPath) : loadMemoryGraphIndex(vaultPath) ?? await buildOrUpdateMemoryGraphIndex(vaultPath);
+  return {
+    schemaVersion: index.schemaVersion,
+    generatedAt: index.generatedAt,
+    nodeCount: index.graph.stats.nodeCount,
+    edgeCount: index.graph.stats.edgeCount,
+    nodeTypeCounts: index.graph.stats.nodeTypeCounts,
+    edgeTypeCounts: index.graph.stats.edgeTypeCounts,
+    fileCount: Object.keys(index.files).length
+  };
+}
+async function graphCommand(options = {}) {
+  const summary = await graphSummary(options);
+  if (options.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  console.log(formatGraphSummary(summary));
+}
+
+export {
+  graphSummary,
+  graphCommand
+};

package/dist/commands/compat.d.ts

@@ -0,0 +1,28 @@
+type CompatStatus = 'ok' | 'warn' | 'error';
+interface CompatCheck {
+    label: string;
+    status: CompatStatus;
+    detail?: string;
+    hint?: string;
+}
+interface CompatReport {
+    generatedAt: string;
+    checks: CompatCheck[];
+    warnings: number;
+    errors: number;
+}
+interface CompatOptions {
+    baseDir?: string;
+}
+interface CompatCommandOptions {
+    json?: boolean;
+    strict?: boolean;
+    baseDir?: string;
+}
+declare function checkOpenClawCompatibility(options?: CompatOptions): CompatReport;
+declare function compatibilityExitCode(report: CompatReport, options?: {
+    strict?: boolean;
+}): number;
+declare function compatCommand(options?: CompatCommandOptions): Promise<CompatReport>;
+
+export { type CompatCheck, type CompatCommandOptions, type CompatReport, type CompatStatus, checkOpenClawCompatibility, compatCommand, compatibilityExitCode };

package/dist/commands/compat.js

@@ -0,0 +1,10 @@
+import {
+  checkOpenClawCompatibility,
+  compatCommand,
+  compatibilityExitCode
+} from "../chunk-PAYUH64O.js";
+export {
+  checkOpenClawCompatibility,
+  compatCommand,
+  compatibilityExitCode
+};

package/dist/commands/context.d.ts

@@ -1,33 +1,2 @@
-import { Command } from 'commander';
-
-type ContextFormat = 'markdown' | 'json';
-interface ContextOptions {
-    vaultPath: string;
-    limit?: number;
-    format?: ContextFormat;
-    recent?: boolean;
-    includeObservations?: boolean;
-    budget?: number;
-}
-interface ContextEntry {
-    title: string;
-    path: string;
-    category: string;
-    score: number;
-    snippet: string;
-    modified: string;
-    age: string;
-    source: 'observation' | 'daily-note' | 'search';
-}
-interface ContextResult {
-    task: string;
-    generated: string;
-    context: ContextEntry[];
-    markdown: string;
-}
-declare function formatContextMarkdown(task: string, entries: ContextEntry[]): string;
-declare function buildContext(task: string, options: ContextOptions): Promise<ContextResult>;
-declare function contextCommand(task: string, options: ContextOptions): Promise<void>;
-declare function registerContextCommand(program: Command): void;
-
-export { type ContextEntry, type ContextFormat, type ContextOptions, type ContextResult, buildContext, contextCommand, formatContextMarkdown, registerContextCommand };
+import 'commander';
+export { C as ContextEntry, a as ContextFormat, b as ContextOptions, c as ContextProfile, e as ContextProfileOption, f as ContextResult, g as buildContext, h as contextCommand, i as formatContextMarkdown, r as registerContextCommand } from '../context-COo8oq1k.js';

package/dist/commands/context.js

@@ -3,9 +3,10 @@ import {
   contextCommand,
   formatContextMarkdown,
   registerContextCommand
-} from "../chunk-UBRYOIII.js";
-import "../chunk-3HFB7EMU.js";
+} from "../chunk-TBVI4N53.js";
+import "../chunk-QFBKWDYR.js";
 import "../chunk-MIIXBNO3.js";
+import "../chunk-O5V7SD5C.js";
 export {
   buildContext,
   contextCommand,

package/dist/commands/doctor.js

@@ -1,7 +1,13 @@
+import {
+  formatAge
+} from "../chunk-7ZRP733D.js";
+import {
+  checkOpenClawCompatibility
+} from "../chunk-PAYUH64O.js";
 import {
   ClawVault,
   findVault
-} from "../chunk-3HFB7EMU.js";
+} from "../chunk-QFBKWDYR.js";
 import {
   hasQmd
 } from "../chunk-MIIXBNO3.js";
@@ -10,8 +16,8 @@ import {
 } from "../chunk-4VQTUVH7.js";
 import "../chunk-J7ZWCI2C.js";
 import {
-  formatAge
-} from "../chunk-7ZRP733D.js";
+  loadMemoryGraphIndex
+} from "../chunk-O5V7SD5C.js";
 
 // src/commands/doctor.ts
 import * as fs from "fs";
@@ -85,6 +91,29 @@ async function doctor(vaultPath) {
   const checks = [];
   let warnings = 0;
   let errors = 0;
+  const compatReport = checkOpenClawCompatibility();
+  if (compatReport.errors > 0) {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "error",
+      detail: `${compatReport.errors} error(s), ${compatReport.warnings} warning(s)`,
+      hint: "Run `clawvault compat` for full compatibility diagnostics."
+    });
+    errors++;
+  } else if (compatReport.warnings > 0) {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "warn",
+      detail: `${compatReport.warnings} warning(s)`,
+      hint: "Run `clawvault compat` for full compatibility diagnostics."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "ok"
+    });
+  }
   if (hasQmd()) {
     checks.push({ label: "qmd installed", status: "ok" });
   } else {
@@ -143,6 +172,35 @@ async function doctor(vaultPath) {
   }
   const latestDoc = documents.slice().sort((a, b) => b.modified.getTime() - a.modified.getTime())[0];
   const latestDocAge = latestDoc ? daysSince(latestDoc.modified) : null;
+  const graphIndex = loadMemoryGraphIndex(vault.getPath());
+  if (!graphIndex) {
+    checks.push({
+      label: "memory graph index",
+      status: "warn",
+      detail: "No graph index found",
+      hint: "Run `clawvault graph --refresh` to build .clawvault/graph-index.json."
+    });
+    warnings++;
+  } else {
+    const generatedAt = new Date(graphIndex.generatedAt);
+    const generatedAge = describeAge(generatedAt);
+    const latestDocIsNewer = latestDoc ? latestDoc.modified.getTime() > generatedAt.getTime() + 1e3 : false;
+    if (latestDocIsNewer) {
+      checks.push({
+        label: "memory graph index",
+        status: "warn",
+        detail: `Stale graph index (generated ${generatedAge} ago)`,
+        hint: "Run `clawvault graph --refresh` to resync index."
+      });
+      warnings++;
+    } else {
+      checks.push({
+        label: "memory graph index",
+        status: "ok",
+        detail: `${graphIndex.graph.stats.nodeCount} nodes, ${graphIndex.graph.stats.edgeCount} edges`
+      });
+    }
+  }
   let lastHandoffAge = null;
   if (handoffs.length === 0) {
     checks.push({

package/dist/commands/entities.d.ts

@@ -1,5 +1,6 @@
 interface EntitiesOptions {
     json?: boolean;
+    vaultPath?: string;
 }
 declare function entitiesCommand(options: EntitiesOptions): Promise<void>;
 

package/dist/commands/entities.js

@@ -1,13 +1,13 @@
-import {
-  getVaultPath
-} from "../chunk-4KDZZW4X.js";
 import {
   buildEntityIndex
 } from "../chunk-J7ZWCI2C.js";
+import {
+  resolveVaultPath
+} from "../chunk-MXSSG3QU.js";
 
 // src/commands/entities.ts
 async function entitiesCommand(options) {
-  const vaultPath = getVaultPath();
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
   const index = buildEntityIndex(vaultPath);
   if (options.json) {
     const output = {};

package/dist/commands/graph.d.ts

@@ -0,0 +1,21 @@
+interface GraphSummary {
+    schemaVersion: number;
+    generatedAt: string;
+    nodeCount: number;
+    edgeCount: number;
+    nodeTypeCounts: Record<string, number>;
+    edgeTypeCounts: Record<string, number>;
+    fileCount: number;
+}
+declare function graphSummary(options?: {
+    vaultPath?: string;
+    refresh?: boolean;
+    json?: boolean;
+}): Promise<GraphSummary>;
+declare function graphCommand(options?: {
+    vaultPath?: string;
+    refresh?: boolean;
+    json?: boolean;
+}): Promise<void>;
+
+export { type GraphSummary, graphCommand, graphSummary };

package/dist/commands/graph.js

@@ -0,0 +1,10 @@
+import {
+  graphCommand,
+  graphSummary
+} from "../chunk-TXO34J3O.js";
+import "../chunk-O5V7SD5C.js";
+import "../chunk-MXSSG3QU.js";
+export {
+  graphCommand,
+  graphSummary
+};

package/dist/commands/link.d.ts

@@ -4,6 +4,7 @@ interface LinkOptions {
     backlinks?: string;
     orphans?: boolean;
     rebuild?: boolean;
+    vaultPath?: string;
 }
 declare function linkCommand(file: string | undefined, options: LinkOptions): Promise<void>;
 

package/dist/commands/link.js

@@ -8,18 +8,21 @@ import {
   rebuildBacklinksIndex,
   scanVaultLinks
 } from "../chunk-4VQTUVH7.js";
-import {
-  getVaultPath
-} from "../chunk-4KDZZW4X.js";
 import {
   buildEntityIndex
 } from "../chunk-J7ZWCI2C.js";
+import {
+  buildOrUpdateMemoryGraphIndex
+} from "../chunk-O5V7SD5C.js";
+import {
+  resolveVaultPath
+} from "../chunk-MXSSG3QU.js";
 
 // src/commands/link.ts
 import * as fs from "fs";
 import * as path from "path";
 async function linkCommand(file, options) {
-  const vaultPath = getVaultPath();
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
   const index = buildEntityIndex(vaultPath);
   const suggestionIndex = filterIndex(index, /* @__PURE__ */ new Set(["people", "projects", "decisions"]));
   const modeCount = [options.backlinks ? 1 : 0, options.orphans ? 1 : 0, options.rebuild ? 1 : 0].reduce((sum, value) => sum + value, 0);
@@ -74,6 +77,9 @@ async function linkCommand(file, options) {
   }
   if (options.all) {
     await linkAllFiles(vaultPath, index, suggestionIndex, options.dryRun);
+    if (!options.dryRun) {
+      await buildOrUpdateMemoryGraphIndex(vaultPath);
+    }
     return;
   }
   if (!file) {
@@ -85,7 +91,10 @@ async function linkCommand(file, options) {
     console.error(`Error: File not found: ${filePath}`);
     process.exit(1);
   }
-  await linkFile(filePath, index, suggestionIndex, options.dryRun);
+  const linked = await linkFile(filePath, index, suggestionIndex, options.dryRun);
+  if (!options.dryRun && linked > 0) {
+    await buildOrUpdateMemoryGraphIndex(vaultPath);
+  }
 }
 function filterIndex(index, categories) {
   const entries = /* @__PURE__ */ new Map();

package/dist/commands/sleep.js

@@ -1,9 +1,3 @@
-import {
-  ClawVault
-} from "../chunk-3HFB7EMU.js";
-import {
-  qmdUpdate
-} from "../chunk-MIIXBNO3.js";
 import {
   Observer,
   parseSessionFile
@@ -11,6 +5,13 @@ import {
 import {
   clearDirtyFlag
 } from "../chunk-MZZJLQNQ.js";
+import {
+  ClawVault
+} from "../chunk-QFBKWDYR.js";
+import {
+  qmdUpdate
+} from "../chunk-MIIXBNO3.js";
+import "../chunk-O5V7SD5C.js";
 
 // src/commands/sleep.ts
 import * as fs from "fs";

package/dist/commands/status.d.ts

@@ -17,6 +17,12 @@ interface VaultStatus {
         indexStatus: 'present' | 'missing' | 'root-mismatch';
         error?: string;
     };
+    graph: {
+        indexStatus: 'present' | 'missing' | 'stale';
+        generatedAt?: string;
+        nodeCount?: number;
+        edgeCount?: number;
+    };
     git?: {
         repoRoot: string;
         clean: boolean;

package/dist/commands/status.js

@@ -1,6 +1,9 @@
+import {
+  formatAge
+} from "../chunk-7ZRP733D.js";
 import {
   ClawVault
-} from "../chunk-3HFB7EMU.js";
+} from "../chunk-QFBKWDYR.js";
 import {
   QmdUnavailableError,
   hasQmd
@@ -10,8 +13,8 @@ import {
 } from "../chunk-4VQTUVH7.js";
 import "../chunk-J7ZWCI2C.js";
 import {
-  formatAge
-} from "../chunk-7ZRP733D.js";
+  loadMemoryGraphIndex
+} from "../chunk-O5V7SD5C.js";
 
 // src/commands/status.ts
 import * as fs from "fs";
@@ -38,6 +41,31 @@ function getGitStatus(repoRoot) {
   const lines = output.split("\n").filter(Boolean);
   return { clean: lines.length === 0, dirtyCount: lines.length };
 }
+function getLatestVaultMarkdownMtime(vaultPath) {
+  const skipDirs = /* @__PURE__ */ new Set([".git", ".obsidian", ".trash", "node_modules", ".clawvault"]);
+  let latest = null;
+  function walk(currentPath) {
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolute = path.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        if (!skipDirs.has(entry.name)) {
+          walk(absolute);
+        }
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".md")) {
+        continue;
+      }
+      const mtime = fs.statSync(absolute).mtime;
+      if (!latest || mtime.getTime() > latest.getTime()) {
+        latest = mtime;
+      }
+    }
+  }
+  walk(vaultPath);
+  return latest;
+}
 function parseQmdCollectionsText(raw) {
   const names = [];
   const regex = /^(\S+)\s+\(qmd:\/\/\1\/\)/gm;
@@ -122,6 +150,26 @@ async function getStatus(vaultPath) {
       issues.push(`Git status error: ${err?.message || "unknown error"}`);
     }
   }
+  const graphIndex = loadMemoryGraphIndex(vault.getPath());
+  let graphStatus = {
+    indexStatus: "missing"
+  };
+  if (!graphIndex) {
+    issues.push("Memory graph index missing");
+  } else {
+    const generatedAt = graphIndex.generatedAt;
+    const latestDocMtime = getLatestVaultMarkdownMtime(vault.getPath());
+    const isStale = latestDocMtime ? latestDocMtime.getTime() > new Date(generatedAt).getTime() + 1e3 : false;
+    graphStatus = {
+      indexStatus: isStale ? "stale" : "present",
+      generatedAt,
+      nodeCount: graphIndex.graph.stats.nodeCount,
+      edgeCount: graphIndex.graph.stats.edgeCount
+    };
+    if (isStale) {
+      issues.push("Memory graph index stale");
+    }
+  }
   return {
     vaultName: vault.getName(),
     vaultPath: vault.getPath(),
@@ -134,6 +182,7 @@ async function getStatus(vaultPath) {
       indexStatus: qmdIndexStatus,
       error: qmdError
     },
+    graph: graphStatus,
     git: gitStatus,
     links: {
       total: linkScan.linkCount,
@@ -197,6 +246,17 @@ function formatStatus(status) {
     output += `  - Repo: ${status.git.repoRoot}
 `;
     output += `  - Status: ${status.git.clean ? "clean" : "dirty"} (${status.git.dirtyCount} change(s))
+`;
+  }
+  output += "\nGraph:\n";
+  output += `  - Index: ${status.graph.indexStatus}
+`;
+  if (status.graph.generatedAt) {
+    output += `  - Generated: ${status.graph.generatedAt}
+`;
+  }
+  if (status.graph.nodeCount !== void 0 && status.graph.edgeCount !== void 0) {
+    output += `  - Size: ${status.graph.nodeCount} nodes, ${status.graph.edgeCount} edges
 `;
   }
   output += "\nLinks:\n";

package/dist/commands/wake.js

@@ -1,7 +1,3 @@
-import {
-  ClawVault
-} from "../chunk-3HFB7EMU.js";
-import "../chunk-MIIXBNO3.js";
 import {
   recover
 } from "../chunk-MILVYUPK.js";
@@ -9,6 +5,11 @@ import {
   clearDirtyFlag
 } from "../chunk-MZZJLQNQ.js";
 import "../chunk-7ZRP733D.js";
+import {
+  ClawVault
+} from "../chunk-QFBKWDYR.js";
+import "../chunk-MIIXBNO3.js";
+import "../chunk-O5V7SD5C.js";
 
 // src/commands/wake.ts
 import * as fs from "fs";

package/dist/context-COo8oq1k.d.ts

@@ -0,0 +1,45 @@
+import { Command } from 'commander';
+
+type ResolvedContextProfile = 'default' | 'planning' | 'incident' | 'handoff';
+type ContextProfileInput = ResolvedContextProfile | 'auto';
+declare function inferContextProfile(task: string): ResolvedContextProfile;
+declare function normalizeContextProfileInput(profile: string | undefined): ContextProfileInput;
+declare function resolveContextProfile(profile: ContextProfileInput | undefined, task: string): ResolvedContextProfile;
+
+type ContextFormat = 'markdown' | 'json';
+type ContextProfile = ResolvedContextProfile;
+type ContextProfileOption = ContextProfile | 'auto';
+interface ContextOptions {
+    vaultPath: string;
+    limit?: number;
+    format?: ContextFormat;
+    recent?: boolean;
+    includeObservations?: boolean;
+    budget?: number;
+    profile?: ContextProfileOption;
+}
+interface ContextEntry {
+    title: string;
+    path: string;
+    category: string;
+    score: number;
+    snippet: string;
+    modified: string;
+    age: string;
+    source: 'observation' | 'daily-note' | 'search' | 'graph';
+    signals?: string[];
+    rationale?: string;
+}
+interface ContextResult {
+    task: string;
+    profile: ContextProfile;
+    generated: string;
+    context: ContextEntry[];
+    markdown: string;
+}
+declare function formatContextMarkdown(task: string, entries: ContextEntry[]): string;
+declare function buildContext(task: string, options: ContextOptions): Promise<ContextResult>;
+declare function contextCommand(task: string, options: ContextOptions): Promise<void>;
+declare function registerContextCommand(program: Command): void;
+
+export { type ContextEntry as C, type ResolvedContextProfile as R, type ContextFormat as a, type ContextOptions as b, type ContextProfile as c, type ContextProfileInput as d, type ContextProfileOption as e, type ContextResult as f, buildContext as g, contextCommand as h, formatContextMarkdown as i, inferContextProfile as j, resolveContextProfile as k, normalizeContextProfileInput as n, registerContextCommand as r };

package/dist/index.d.ts

@@ -2,9 +2,12 @@ import { Command } from 'commander';
 import { V as VaultConfig, S as StoreOptions, D as Document, a as SearchOptions, b as SearchResult, c as SyncOptions, d as SyncResult, C as Category, M as MemoryType, H as HandoffDocument, e as SessionRecap } from './types-DMU3SuAV.js';
 export { f as DEFAULT_CATEGORIES, g as DEFAULT_CONFIG, h as MEMORY_TYPES, T as TYPE_TO_CATEGORY, i as VaultMeta } from './types-DMU3SuAV.js';
 export { setupCommand } from './commands/setup.js';
-export { ContextEntry, ContextFormat, ContextOptions, ContextResult, buildContext, contextCommand, formatContextMarkdown, registerContextCommand } from './commands/context.js';
+export { CompatCheck, CompatCommandOptions, CompatReport, CompatStatus, checkOpenClawCompatibility, compatCommand, compatibilityExitCode } from './commands/compat.js';
+export { GraphSummary, graphCommand, graphSummary } from './commands/graph.js';
+export { C as ContextEntry, a as ContextFormat, b as ContextOptions, c as ContextProfile, d as ContextProfileInput, e as ContextProfileOption, f as ContextResult, R as ResolvedContextProfile, g as buildContext, h as contextCommand, i as formatContextMarkdown, j as inferContextProfile, n as normalizeContextProfileInput, r as registerContextCommand, k as resolveContextProfile } from './context-COo8oq1k.js';
 export { ObserveCommandOptions, observeCommand, registerObserveCommand } from './commands/observe.js';
 export { SessionRecapFormat, SessionRecapOptions, SessionRecapResult, SessionTurn, buildSessionRecap, formatSessionRecapMarkdown, sessionRecapCommand } from './commands/session-recap.js';
+export { findNearestVaultPath, getVaultPath, resolveVaultPath } from './lib/config.js';
 export { TemplateVariables, buildTemplateVariables, renderTemplate } from './lib/template-engine.js';
 
 /**
@@ -135,6 +138,7 @@ declare class ClawVault {
     private slugify;
     private saveIndex;
     private createTemplates;
+    private syncMemoryGraphIndex;
     private generateReadme;
     private getCategoryDescription;
 }
@@ -263,6 +267,63 @@ declare function extractWikiLinks(content: string): string[];
  */
 declare function extractTags(content: string): string[];
 
+declare const MEMORY_GRAPH_SCHEMA_VERSION = 1;
+type NodeCategory = 'note' | 'daily' | 'observation' | 'handoff' | 'decision' | 'lesson' | 'project' | 'person' | 'commitment' | 'tag' | 'unresolved';
+type MemoryGraphNodeType = NodeCategory;
+type MemoryGraphEdgeType = 'wiki_link' | 'tag' | 'frontmatter_relation';
+interface MemoryGraphNode {
+    id: string;
+    title: string;
+    type: MemoryGraphNodeType;
+    category: string;
+    path: string | null;
+    tags: string[];
+    missing: boolean;
+    degree: number;
+    modifiedAt: string | null;
+}
+interface MemoryGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: MemoryGraphEdgeType;
+    label?: string;
+}
+interface MemoryGraphStats {
+    generatedAt: string;
+    nodeCount: number;
+    edgeCount: number;
+    nodeTypeCounts: Record<string, number>;
+    edgeTypeCounts: Record<string, number>;
+}
+interface MemoryGraph {
+    schemaVersion: number;
+    nodes: MemoryGraphNode[];
+    edges: MemoryGraphEdge[];
+    stats: MemoryGraphStats;
+}
+interface MemoryGraphFileFragment {
+    relativePath: string;
+    mtimeMs: number;
+    nodes: MemoryGraphNode[];
+    edges: MemoryGraphEdge[];
+}
+interface MemoryGraphIndex {
+    schemaVersion: number;
+    vaultPath: string;
+    generatedAt: string;
+    files: Record<string, MemoryGraphFileFragment>;
+    graph: MemoryGraph;
+}
+interface BuildGraphIndexOptions {
+    forceFull?: boolean;
+}
+declare function loadMemoryGraphIndex(vaultPath: string): MemoryGraphIndex | null;
+declare function buildOrUpdateMemoryGraphIndex(vaultPathInput: string, options?: BuildGraphIndexOptions): Promise<MemoryGraphIndex>;
+declare function getMemoryGraph(vaultPath: string, options?: {
+    refresh?: boolean;
+}): Promise<MemoryGraph>;
+
 interface ObserverCompressor {
     compress(messages: string[], existingObservations: string): Promise<string>;
 }
@@ -425,4 +486,4 @@ declare function parseSessionFile(filePath: string): string[];
 declare const VERSION: string;
 declare function registerCommanderCommands(program: Command): Command;
 
-export { Category, ClawVault, Compressor, type CompressorOptions, Document, HandoffDocument, MemoryType, Observer, type ObserverCompressor, type ObserverOptions, type ObserverReflector, QMD_INSTALL_COMMAND, QMD_INSTALL_URL, QmdUnavailableError, Reflector, type ReflectorOptions, SearchEngine, SearchOptions, SearchResult, SessionRecap, SessionWatcher, type SessionWatcherOptions, StoreOptions, SyncOptions, SyncResult, VERSION, VaultConfig, createVault, extractTags, extractWikiLinks, findVault, hasQmd, parseSessionFile, qmdEmbed, qmdUpdate, registerCommanderCommands };
+export { Category, ClawVault, Compressor, type CompressorOptions, Document, HandoffDocument, MEMORY_GRAPH_SCHEMA_VERSION, type MemoryGraph, type MemoryGraphEdge, type MemoryGraphEdgeType, type MemoryGraphIndex, type MemoryGraphNode, type MemoryGraphNodeType, type MemoryGraphStats, MemoryType, Observer, type ObserverCompressor, type ObserverOptions, type ObserverReflector, QMD_INSTALL_COMMAND, QMD_INSTALL_URL, QmdUnavailableError, Reflector, type ReflectorOptions, SearchEngine, SearchOptions, SearchResult, SessionRecap, SessionWatcher, type SessionWatcherOptions, StoreOptions, SyncOptions, SyncResult, VERSION, VaultConfig, buildOrUpdateMemoryGraphIndex, createVault, extractTags, extractWikiLinks, findVault, getMemoryGraph, hasQmd, loadMemoryGraphIndex, parseSessionFile, qmdEmbed, qmdUpdate, registerCommanderCommands };