clawvault 2.6.1 → 2.6.4

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  registerReplayCommand,
+  replayCommand
+} from "./chunk-6NYYDNNG.js";
 import {
   buildSessionRecap,
   formatSessionRecapMarkdown,
@@ -5,32 +9,37 @@ import {
 } from "./chunk-ZKGY7WTT.js";
 import {
   setupCommand
-} from "./chunk-RVYA52PY.js";
+} from "./chunk-NJYJL5AA.js";
 import {
   registerSyncBdCommand,
   syncBdCommand
-} from "./chunk-MGDEINGP.js";
+} from "./chunk-SS4B7P7V.js";
 import {
   migrateObservations,
   migrateObservationsCommand,
   registerMigrateObservationsCommand
-} from "./chunk-VXEOHTSL.js";
+} from "./chunk-2JQ3O2YL.js";
+import {
+  EmbeddingCache,
+  cosineSimilarity,
+  embed,
+  embedBatch,
+  hybridSearch,
+  reciprocalRankFusion,
+  semanticSearch
+} from "./chunk-U4O6C46S.js";
 import {
   rebuildCommand,
   registerRebuildCommand
-} from "./chunk-PBEE567J.js";
-import {
-  registerReplayCommand,
-  replayCommand
-} from "./chunk-R6SXNSFD.js";
+} from "./chunk-LUBZXECN.js";
 import {
   doctor
-} from "./chunk-UEOUADMO.js";
+} from "./chunk-MFL6EEPF.js";
 import "./chunk-7ZRP733D.js";
 import {
   graphCommand,
   graphSummary
-} from "./chunk-OZ7RIXTO.js";
+} from "./chunk-IIOU45CK.js";
 import {
   buildKanbanLanes,
   extractCardSlug,
@@ -45,7 +54,7 @@ import "./chunk-4VQTUVH7.js";
 import "./chunk-J7ZWCI2C.js";
 import {
   registerCliCommands
-} from "./chunk-TLGBDTYT.js";
+} from "./chunk-MPOSMDMU.js";
 import {
   registerTailscaleCommands,
   registerTailscaleDiscoverCommand,
@@ -56,7 +65,7 @@ import {
   tailscaleServeCommand,
   tailscaleStatusCommand,
   tailscaleSyncCommand
-} from "./chunk-THRJVD4L.js";
+} from "./chunk-Y6VJKXGL.js";
 import {
   CLAWVAULT_SERVE_PATH,
   DEFAULT_SERVE_PORT,
@@ -83,17 +92,17 @@ import {
   SessionWatcher,
   observeCommand,
   registerObserveCommand
-} from "./chunk-ME37YNW3.js";
+} from "./chunk-P7SY3D4E.js";
 import {
   parseSessionFile
 } from "./chunk-P5EPF6MB.js";
 import {
   reflectCommand,
   registerReflectCommand
-} from "./chunk-3BTHWPMB.js";
+} from "./chunk-S5OJEGFG.js";
 import {
   runReflection
-} from "./chunk-T76H47ZS.js";
+} from "./chunk-MNPUYCHQ.js";
 import {
   buildContext,
   contextCommand,
@@ -102,19 +111,28 @@ import {
   normalizeContextProfileInput,
   registerContextCommand,
   resolveContextProfile
-} from "./chunk-XAVB4GB4.js";
+} from "./chunk-LIGHWOH6.js";
 import {
   getObserverStaleness,
   getScaledObservationThresholdBytes,
   observeActiveSessions,
   parseSessionSourceLabel
-} from "./chunk-IEVLHNLU.js";
-import "./chunk-HRLWZGMA.js";
+} from "./chunk-627Q3QWK.js";
 import {
   Compressor,
+  FactStore,
   Observer,
-  Reflector
-} from "./chunk-Q2J5YTUF.js";
+  Reflector,
+  createDefaultAdapter,
+  createFactExtractionAdapter,
+  createGeminiFlashAdapter,
+  createLlmFunction,
+  extractFactsLlm,
+  extractFactsRuleBased,
+  factId,
+  normalizeEntity,
+  resolveFactExtractionMode
+} from "./chunk-OQGYFZ4A.js";
 import {
   archiveProject,
   createProject,
@@ -124,27 +142,34 @@ import {
   readProject,
   updateProject
 } from "./chunk-AZYOKJYC.js";
+import "./chunk-HRLWZGMA.js";
 import {
   ClawVault,
   createVault,
   findVault
-} from "./chunk-KL4NAOMO.js";
+} from "./chunk-YDWHS4LJ.js";
 import "./chunk-FHFUXL6G.js";
 import {
   embedCommand,
   registerEmbedCommand
-} from "./chunk-4QYGFWRM.js";
+} from "./chunk-ECRZL5XR.js";
+import {
+  loadVaultQmdConfig,
+  removeQmdCollection
+} from "./chunk-WIOLLGAD.js";
 import {
   QMD_INSTALL_COMMAND,
   QMD_INSTALL_URL,
+  QmdConfigurationError,
   QmdUnavailableError,
   SearchEngine,
   extractTags,
   extractWikiLinks,
+  getQmdErrorDetails,
   hasQmd,
   qmdEmbed,
   qmdUpdate
-} from "./chunk-MAKNAHAW.js";
+} from "./chunk-5PJ4STIC.js";
 import {
   buildInjectionResult,
   deterministicInjectMatches,
@@ -152,11 +177,7 @@ import {
   injectCommand,
   registerInjectCommand,
   runPromptInjection
-} from "./chunk-4VRIMU4O.js";
-import {
-  requestLlmCompletion,
-  resolveLlmProvider
-} from "./chunk-HIHOUSXS.js";
+} from "./chunk-YNIPYN4F.js";
 import {
   SUPPORTED_CONFIG_KEYS,
   addRouteRule,
@@ -169,7 +190,11 @@ import {
   resetConfig,
   setConfigValue,
   testRouteRule
-} from "./chunk-ITPEXLHA.js";
+} from "./chunk-URXDAUVH.js";
+import {
+  requestLlmCompletion,
+  resolveLlmProvider
+} from "./chunk-YXQCA6B7.js";
 import {
   DEFAULT_CATEGORIES,
   DEFAULT_CONFIG,
@@ -179,7 +204,7 @@ import {
 import {
   archiveCommand,
   registerArchiveCommand
-} from "./chunk-VR5NE7PZ.js";
+} from "./chunk-2RAZ4ZFE.js";
 import {
   archiveObservations
 } from "./chunk-MQUJNOHK.js";
@@ -187,7 +212,7 @@ import {
   findNearestVaultPath,
   getVaultPath,
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   MEMORY_GRAPH_SCHEMA_VERSION,
   buildOrUpdateMemoryGraphIndex,
@@ -217,14 +242,254 @@ import {
   checkOpenClawCompatibility,
   compatCommand,
   compatibilityExitCode
-} from "./chunk-QVMXF7FY.js";
+} from "./chunk-X3SPPUFG.js";
+import "./chunk-2ZDO52B4.js";
 
 // src/index.ts
+import * as fs2 from "fs";
+
+// src/commands/migrate.ts
 import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+function addQmdCollection(name, rootPath) {
+  execFileSync("qmd", ["collection", "add", name, rootPath], { stdio: "ignore" });
+}
+function updateVaultConfig(vaultPath, updates) {
+  const configPath = path.join(vaultPath, ".clawvault.json");
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch {
+      config = {};
+    }
+  }
+  if (updates.qmdCollection !== void 0) {
+    config.qmdCollection = updates.qmdCollection;
+  }
+  if (updates.qmdRoot !== void 0) {
+    config.qmdRoot = updates.qmdRoot;
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+function fixStaleCollectionName(issue, dryRun) {
+  const details = issue.details;
+  const action = {
+    type: "stale_collection_name",
+    description: `Rename collection "${details.oldName}" to "${details.newName}"`,
+    success: false
+  };
+  if (dryRun) {
+    action.success = true;
+    action.description += " (dry run)";
+    return action;
+  }
+  try {
+    removeQmdCollection(details.oldName);
+    addQmdCollection(details.newName, details.root);
+    action.success = true;
+  } catch (err) {
+    action.error = err?.message || "Failed to rename collection";
+  }
+  return action;
+}
+function fixMissingQmdCollection(issue, dryRun) {
+  const details = issue.details;
+  const action = {
+    type: "missing_qmd_collection",
+    description: `Create qmd collection "${details.collectionName}" at "${details.expectedRoot}"`,
+    success: false
+  };
+  if (dryRun) {
+    action.success = true;
+    action.description += " (dry run)";
+    return action;
+  }
+  try {
+    addQmdCollection(details.collectionName, details.expectedRoot);
+    action.success = true;
+  } catch (err) {
+    action.error = err?.message || "Failed to create collection";
+  }
+  return action;
+}
+function fixWrongVaultPath(issue, dryRun) {
+  const details = issue.details;
+  const action = {
+    type: "wrong_vault_path",
+    description: `Update collection "${details.collectionName}" path from "${details.currentRoot}" to "${details.expectedRoot}"`,
+    success: false
+  };
+  if (dryRun) {
+    action.success = true;
+    action.description += " (dry run)";
+    return action;
+  }
+  try {
+    removeQmdCollection(details.collectionName);
+    addQmdCollection(details.collectionName, details.expectedRoot);
+    action.success = true;
+  } catch (err) {
+    action.error = err?.message || "Failed to update collection path";
+  }
+  return action;
+}
+function fixOrphanedCollection(issue, dryRun) {
+  const details = issue.details;
+  const action = {
+    type: "orphaned_collection",
+    description: `Remove orphaned collection "${details.collectionName}"`,
+    success: false
+  };
+  if (dryRun) {
+    action.success = true;
+    action.description += " (dry run)";
+    return action;
+  }
+  try {
+    removeQmdCollection(details.collectionName);
+    action.success = true;
+  } catch (err) {
+    action.error = err?.message || "Failed to remove orphaned collection";
+  }
+  return action;
+}
+function fixMissingQmdConfig(issue, vaultPath, dryRun) {
+  const vaultConfig = loadVaultQmdConfig(vaultPath);
+  const action = {
+    type: "missing_qmd_config",
+    description: `Add qmdCollection="${vaultConfig.qmdCollection}" and qmdRoot="${vaultConfig.qmdRoot}" to .clawvault.json`,
+    success: false
+  };
+  if (dryRun) {
+    action.success = true;
+    action.description += " (dry run)";
+    return action;
+  }
+  try {
+    updateVaultConfig(vaultPath, {
+      qmdCollection: vaultConfig.qmdCollection,
+      qmdRoot: vaultConfig.qmdRoot
+    });
+    action.success = true;
+  } catch (err) {
+    action.error = err?.message || "Failed to update vault config";
+  }
+  return action;
+}
+function fixIssue(issue, vaultPath, dryRun) {
+  if (!issue.autoFixable) {
+    return null;
+  }
+  switch (issue.type) {
+    case "stale_collection_name":
+      return fixStaleCollectionName(issue, dryRun);
+    case "missing_qmd_collection":
+      return fixMissingQmdCollection(issue, dryRun);
+    case "wrong_vault_path":
+      return fixWrongVaultPath(issue, dryRun);
+    case "orphaned_collection":
+      return fixOrphanedCollection(issue, dryRun);
+    case "missing_qmd_config":
+      return fixMissingQmdConfig(issue, vaultPath, dryRun);
+    default:
+      return null;
+  }
+}
+async function migrate(options = {}) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const dryRun = options.dryRun ?? false;
+  if (!hasQmd()) {
+    return {
+      vaultPath,
+      issuesFound: 1,
+      issuesFixed: 0,
+      actions: [{
+        type: "missing_qmd_collection",
+        description: "qmd is not installed",
+        success: false,
+        error: `Install qmd first: ${QMD_INSTALL_COMMAND}
+More info: ${QMD_INSTALL_URL}`
+      }],
+      dryRun
+    };
+  }
+  const report = await doctor(vaultPath);
+  const issues = report.migrationIssues;
+  const actions = [];
+  for (const issue of issues) {
+    const action = fixIssue(issue, vaultPath, dryRun);
+    if (action) {
+      actions.push(action);
+    }
+  }
+  const issuesFixed = actions.filter((a) => a.success).length;
+  return {
+    vaultPath,
+    issuesFound: issues.length,
+    issuesFixed,
+    actions,
+    dryRun
+  };
+}
+function formatMigrateResult(result) {
+  const lines = [];
+  lines.push("ClawVault Migration Report");
+  lines.push("-".repeat(30));
+  lines.push(`Vault: ${result.vaultPath}`);
+  lines.push(`Mode: ${result.dryRun ? "Dry Run" : "Live"}`);
+  lines.push("");
+  if (result.issuesFound === 0) {
+    lines.push("\u2713 No migration issues found. Your vault is up to date.");
+    return lines.join("\n");
+  }
+  lines.push(`Found ${result.issuesFound} issue(s)`);
+  lines.push("");
+  for (const action of result.actions) {
+    const prefix = action.success ? "\u2713" : "\u2717";
+    lines.push(`${prefix} ${action.description}`);
+    if (action.error) {
+      lines.push(`  Error: ${action.error}`);
+    }
+  }
+  lines.push("");
+  if (result.dryRun) {
+    lines.push(`Would fix ${result.issuesFixed}/${result.issuesFound} issue(s).`);
+    lines.push("Run without --dry-run to apply changes.");
+  } else {
+    lines.push(`Fixed ${result.issuesFixed}/${result.issuesFound} issue(s).`);
+    if (result.issuesFixed < result.issuesFound) {
+      lines.push("Some issues require manual intervention.");
+    }
+  }
+  return lines.join("\n");
+}
+async function migrateCommand(options = {}) {
+  const result = await migrate(options);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatMigrateResult(result));
+  }
+  return result;
+}
+function registerMigrateCommand(program) {
+  program.command("migrate").description("Auto-fix common v2\u2192v3 migration issues (stale collections, missing qmd config, wrong paths)").option("-v, --vault <path>", "Vault path").option("--dry-run", "Preview changes without applying them").option("--force", "Force migration even if no issues detected").option("--json", "Output results as JSON").action(async (rawOptions) => {
+    await migrateCommand({
+      vaultPath: rawOptions.vault,
+      dryRun: rawOptions.dryRun,
+      force: rawOptions.force,
+      json: rawOptions.json
+    });
+  });
+}
+
+// src/index.ts
 function readPackageVersion() {
   try {
     const pkgUrl = new URL("../package.json", import.meta.url);
-    const pkg = JSON.parse(fs.readFileSync(pkgUrl, "utf-8"));
+    const pkg = JSON.parse(fs2.readFileSync(pkgUrl, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -241,11 +506,14 @@ export {
   DEFAULT_CATEGORIES,
   DEFAULT_CONFIG,
   DEFAULT_SERVE_PORT,
+  EmbeddingCache,
+  FactStore,
   MEMORY_GRAPH_SCHEMA_VERSION,
   MEMORY_TYPES,
   Observer,
   QMD_INSTALL_COMMAND,
   QMD_INSTALL_URL,
+  QmdConfigurationError,
   QmdUnavailableError,
   Reflector,
   SUPPORTED_CONFIG_KEYS,
@@ -273,16 +541,26 @@ export {
   completeTask,
   configureTailscaleServe,
   contextCommand,
+  cosineSimilarity,
   countBlockedTransitions,
+  createDefaultAdapter,
+  createFactExtractionAdapter,
+  createGeminiFlashAdapter,
+  createLlmFunction,
   createProject,
   createVault,
   deterministicInjectMatches,
   discoverClawVaultPeers,
   doctor,
+  embed,
+  embedBatch,
   embedCommand,
   extractCardSlug,
+  extractFactsLlm,
+  extractFactsRuleBased,
   extractTags,
   extractWikiLinks,
+  factId,
   fetchRemoteFile,
   fetchRemoteManifest,
   findNearestVaultPath,
@@ -301,6 +579,7 @@ export {
   getOnlinePeers,
   getProjectActivity,
   getProjectTasks,
+  getQmdErrorDetails,
   getScaledObservationThresholdBytes,
   getTailscaleStatus,
   getTailscaleVersion,
@@ -309,6 +588,7 @@ export {
   graphSummary,
   hasQmd,
   hasTailscale,
+  hybridSearch,
   importKanbanBoard,
   indexInjectableItems,
   inferContextProfile,
@@ -322,9 +602,12 @@ export {
   listSubtasks,
   loadMemoryGraphIndex,
   matchRouteRule,
+  migrate,
+  migrateCommand,
   migrateObservations,
   migrateObservationsCommand,
   normalizeContextProfileInput,
+  normalizeEntity,
   observeActiveSessions,
   observeCommand,
   parseKanbanMarkdown,
@@ -337,6 +620,7 @@ export {
   readAllTransitions,
   readProject,
   rebuildCommand,
+  reciprocalRankFusion,
   reflectCommand,
   registerArchiveCommand,
   registerCliCommands,
@@ -344,6 +628,7 @@ export {
   registerContextCommand,
   registerEmbedCommand,
   registerInjectCommand,
+  registerMigrateCommand,
   registerMigrateObservationsCommand,
   registerObserveCommand,
   registerRebuildCommand,
@@ -361,11 +646,13 @@ export {
   requestLlmCompletion,
   resetConfig,
   resolveContextProfile,
+  resolveFactExtractionMode,
   resolveLlmProvider,
   resolvePeerIP,
   resolveVaultPath,
   runPromptInjection,
   runReflection,
+  semanticSearch,
   serveVault,
   sessionRecapCommand,
   setConfigValue,

package/dist/{inject-x65KXWPk.d.ts → inject-DYUrDqQO.d.ts}

@@ -57,7 +57,7 @@ declare function getMemoryGraph(vaultPath: string, options?: {
     refresh?: boolean;
 }): Promise<MemoryGraph>;
 
-type LlmProvider = 'anthropic' | 'openai' | 'gemini';
+type LlmProvider = 'anthropic' | 'openai' | 'gemini' | 'xai' | 'openclaw';
 interface LlmCompletionOptions {
     prompt: string;
     provider?: LlmProvider | null;
@@ -134,4 +134,4 @@ declare function buildInjectionResult(message: string, options: InjectCommandOpt
 declare function injectCommand(message: string, options: InjectCommandOptions): Promise<void>;
 declare function registerInjectCommand(program: Command): void;
 
-export { runPromptInjection as A, type InjectCommandOptions as I, type LlmCompletionOptions as L, MEMORY_GRAPH_SCHEMA_VERSION as M, type InjectFormat as a, type InjectMatch as b, type InjectMatchReason as c, type InjectMatchSource as d, type InjectResult as e, type InjectRuntimeOptions as f, type InjectSourceCategory as g, type InjectableItem as h, type LlmProvider as i, type MemoryGraph as j, type MemoryGraphEdge as k, type MemoryGraphEdgeType as l, type MemoryGraphIndex as m, type MemoryGraphNode as n, type MemoryGraphNodeType as o, type MemoryGraphStats as p, buildInjectionResult as q, buildOrUpdateMemoryGraphIndex as r, deterministicInjectMatches as s, getMemoryGraph as t, indexInjectableItems as u, injectCommand as v, loadMemoryGraphIndex as w, registerInjectCommand as x, requestLlmCompletion as y, resolveLlmProvider as z };
+export { runPromptInjection as A, type InjectCommandOptions as I, type LlmProvider as L, MEMORY_GRAPH_SCHEMA_VERSION as M, type InjectFormat as a, type InjectMatch as b, type InjectMatchReason as c, type InjectMatchSource as d, type InjectResult as e, type InjectRuntimeOptions as f, type InjectSourceCategory as g, type InjectableItem as h, type LlmCompletionOptions as i, type MemoryGraph as j, type MemoryGraphEdge as k, type MemoryGraphEdgeType as l, type MemoryGraphIndex as m, type MemoryGraphNode as n, type MemoryGraphNodeType as o, type MemoryGraphStats as p, buildInjectionResult as q, buildOrUpdateMemoryGraphIndex as r, deterministicInjectMatches as s, getMemoryGraph as t, indexInjectableItems as u, injectCommand as v, loadMemoryGraphIndex as w, registerInjectCommand as x, requestLlmCompletion as y, resolveLlmProvider as z };

package/dist/ledger-B7g7jhqG.d.ts

@@ -0,0 +1,44 @@
+import { LedgerEntry, LedgerOp } from './workgraph/types.js';
+
+/**
+ * Append-only event ledger.
+ *
+ * Every mutation to the workgraph is logged here. This is the source of truth
+ * for coordination: who claimed what, when, and what's available.
+ *
+ * Format: one JSON object per line (.jsonl) in `.clawvault/ledger.jsonl`.
+ * Agents read the ledger to know the state of the world.
+ */
+
+declare function ledgerPath(vaultPath: string): string;
+declare function append(vaultPath: string, actor: string, op: LedgerOp, target: string, type?: string, data?: Record<string, unknown>): LedgerEntry;
+declare function readAll(vaultPath: string): LedgerEntry[];
+declare function readSince(vaultPath: string, since: string): LedgerEntry[];
+/** Get the current owner of a target (last claim without a subsequent release/done). */
+declare function currentOwner(vaultPath: string, target: string): string | null;
+/** Check if a target is currently claimed by any agent. */
+declare function isClaimed(vaultPath: string, target: string): boolean;
+/** Get all entries for a specific target. */
+declare function historyOf(vaultPath: string, target: string): LedgerEntry[];
+/** Get all entries by a specific actor. */
+declare function activityOf(vaultPath: string, actor: string): LedgerEntry[];
+/** Get all currently claimed targets and their owners. */
+declare function allClaims(vaultPath: string): Map<string, string>;
+/** Get recent ledger entries (last N). */
+declare function recent(vaultPath: string, count?: number): LedgerEntry[];
+
+declare const ledger_activityOf: typeof activityOf;
+declare const ledger_allClaims: typeof allClaims;
+declare const ledger_append: typeof append;
+declare const ledger_currentOwner: typeof currentOwner;
+declare const ledger_historyOf: typeof historyOf;
+declare const ledger_isClaimed: typeof isClaimed;
+declare const ledger_ledgerPath: typeof ledgerPath;
+declare const ledger_readAll: typeof readAll;
+declare const ledger_readSince: typeof readSince;
+declare const ledger_recent: typeof recent;
+declare namespace ledger {
+  export { ledger_activityOf as activityOf, ledger_allClaims as allClaims, ledger_append as append, ledger_currentOwner as currentOwner, ledger_historyOf as historyOf, ledger_isClaimed as isClaimed, ledger_ledgerPath as ledgerPath, ledger_readAll as readAll, ledger_readSince as readSince, ledger_recent as recent };
+}
+
+export { activityOf as a, allClaims as b, append as c, currentOwner as d, ledgerPath as e, readSince as f, recent as g, historyOf as h, isClaimed as i, ledger as l, readAll as r };

package/dist/lib/auto-linker.js

@@ -4,6 +4,7 @@ import {
   findUnlinkedMentions
 } from "../chunk-42MXU7A6.js";
 import "../chunk-J7ZWCI2C.js";
+import "../chunk-2ZDO52B4.js";
 export {
   autoLink,
   dryRunLink,

package/dist/lib/canvas-layout.js

@@ -15,6 +15,7 @@ import {
   stackNodesVertically,
   truncateText
 } from "../chunk-MDIH26GC.js";
+import "../chunk-2ZDO52B4.js";
 export {
   CANVAS_COLORS,
   LAYOUT,

package/dist/lib/config.d.ts

@@ -1,11 +1,35 @@
+interface AgentVaultsConfig {
+    [agentName: string]: string;
+}
+interface PluginConfig {
+    vaultPath?: string;
+    agentVaults?: AgentVaultsConfig;
+}
 /**
  * Get the vault path from CLAWVAULT_PATH env var or throw
  */
 declare function getVaultPath(): string;
 declare function findNearestVaultPath(startPath?: string): string | null;
-declare function resolveVaultPath(options?: {
+/**
+ * Resolve vault path for a specific agent from agentVaults config
+ */
+declare function resolveAgentVaultPath(agentVaults: AgentVaultsConfig | undefined, agentId: string | undefined): string | null;
+interface ResolveVaultPathOptions {
     explicitPath?: string;
     cwd?: string;
-}): string;
+    agentId?: string;
+    pluginConfig?: PluginConfig;
+}
+/**
+ * Resolve vault path with support for per-agent vault paths.
+ *
+ * Resolution order:
+ * 1. Explicit path (--vault flag)
+ * 2. Per-agent vault from agentVaults config (if agentId provided)
+ * 3. Plugin config vaultPath (fallback for all agents)
+ * 4. CLAWVAULT_PATH environment variable
+ * 5. Walk up from cwd to find nearest vault
+ */
+declare function resolveVaultPath(options?: ResolveVaultPathOptions): string;
 
-export { findNearestVaultPath, getVaultPath, resolveVaultPath };
+export { type AgentVaultsConfig, type PluginConfig, type ResolveVaultPathOptions, findNearestVaultPath, getVaultPath, resolveAgentVaultPath, resolveVaultPath };

package/dist/lib/config.js

@@ -1,10 +1,13 @@
 import {
   findNearestVaultPath,
   getVaultPath,
+  resolveAgentVaultPath,
   resolveVaultPath
-} from "../chunk-MXSSG3QU.js";
+} from "../chunk-GNJL4YGR.js";
+import "../chunk-2ZDO52B4.js";
 export {
   findNearestVaultPath,
   getVaultPath,
+  resolveAgentVaultPath,
   resolveVaultPath
 };

package/dist/lib/entity-index.js

@@ -2,6 +2,7 @@ import {
   buildEntityIndex,
   getSortedAliases
 } from "../chunk-J7ZWCI2C.js";
+import "../chunk-2ZDO52B4.js";
 export {
   buildEntityIndex,
   getSortedAliases