clawvault 3.0.0 → 3.1.0

package/dist/index.cjs

@@ -30,12 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  CLAWVAULT_SERVE_PATH: () => CLAWVAULT_SERVE_PATH,
   ClawVault: () => ClawVault,
   Compressor: () => Compressor,
   DEFAULT_CATEGORIES: () => DEFAULT_CATEGORIES,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
-  DEFAULT_SERVE_PORT: () => DEFAULT_SERVE_PORT,
   MEMORY_GRAPH_SCHEMA_VERSION: () => MEMORY_GRAPH_SCHEMA_VERSION,
   MEMORY_TYPES: () => MEMORY_TYPES,
   Observer: () => Observer,
@@ -62,19 +60,15 @@ __export(index_exports, {
   buildTemplateVariables: () => buildTemplateVariables,
   buildTransitionEvent: () => buildTransitionEvent,
   checkOpenClawCompatibility: () => checkOpenClawCompatibility,
-  checkPeerClawVault: () => checkPeerClawVault,
   classifyQuestion: () => classifyQuestion,
-  compareManifests: () => compareManifests,
   compatCommand: () => compatCommand,
   compatibilityExitCode: () => compatibilityExitCode,
   completeTask: () => completeTask,
-  configureTailscaleServe: () => configureTailscaleServe,
   contextCommand: () => contextCommand,
   countBlockedTransitions: () => countBlockedTransitions,
   createProject: () => createProject,
   createVault: () => createVault,
   deterministicInjectMatches: () => deterministicInjectMatches,
-  discoverClawVaultPeers: () => discoverClawVaultPeers,
   doctor: () => doctor,
   embedCommand: () => embedCommand,
   entitySimilarity: () => entitySimilarity,
@@ -84,34 +78,26 @@ __export(index_exports, {
   extractPreferences: () => extractPreferences,
   extractTags: () => extractTags,
   extractWikiLinks: () => extractWikiLinks,
-  fetchRemoteFile: () => fetchRemoteFile,
-  fetchRemoteManifest: () => fetchRemoteManifest,
   filterSuperseded: () => filterSuperseded,
   findNearestVaultPath: () => findNearestVaultPath,
-  findPeer: () => findPeer,
   findVault: () => findVault,
   formatContextMarkdown: () => formatContextMarkdown,
   formatKanbanCard: () => formatKanbanCard,
   formatSessionRecapMarkdown: () => formatSessionRecapMarkdown,
   formatTransitionsTable: () => formatTransitionsTable,
   generateKanbanMarkdown: () => generateKanbanMarkdown,
-  generateVaultManifest: () => generateVaultManifest,
   getConfig: () => getConfig,
   getConfigValue: () => getConfigValue,
   getMemoryGraph: () => getMemoryGraph,
   getObserverStaleness: () => getObserverStaleness,
-  getOnlinePeers: () => getOnlinePeers,
   getProjectActivity: () => getProjectActivity,
   getProjectTasks: () => getProjectTasks,
   getScaledObservationThresholdBytes: () => getScaledObservationThresholdBytes,
   getSupersessionInfo: () => getSupersessionInfo,
-  getTailscaleStatus: () => getTailscaleStatus,
-  getTailscaleVersion: () => getTailscaleVersion,
   getVaultPath: () => getVaultPath,
   graphCommand: () => graphCommand,
   graphSummary: () => graphSummary,
   hasQmd: () => hasQmd,
-  hasTailscale: () => hasTailscale,
   importKanbanBoard: () => importKanbanBoard,
   indexInjectableItems: () => indexInjectableItems,
   inferContextProfile: () => inferContextProfile,
@@ -135,7 +121,6 @@ __export(index_exports, {
   parseKanbanMarkdown: () => parseKanbanMarkdown,
   parseSessionFile: () => parseSessionFile,
   parseSessionSourceLabel: () => parseSessionSourceLabel,
-  pushFileToRemote: () => pushFileToRemote,
   qmdEmbed: () => qmdEmbed,
   qmdUpdate: () => qmdUpdate,
   queryTransitions: () => queryTransitions,
@@ -155,11 +140,6 @@ __export(index_exports, {
   registerReflectCommand: () => registerReflectCommand,
   registerReplayCommand: () => registerReplayCommand,
   registerReweaveCommand: () => registerReweaveCommand,
-  registerTailscaleCommands: () => registerTailscaleCommands,
-  registerTailscaleDiscoverCommand: () => registerTailscaleDiscoverCommand,
-  registerTailscaleServeCommand: () => registerTailscaleServeCommand,
-  registerTailscaleStatusCommand: () => registerTailscaleStatusCommand,
-  registerTailscaleSyncCommand: () => registerTailscaleSyncCommand,
   removeRouteRule: () => removeRouteRule,
   renderTemplate: () => renderTemplate,
   replayCommand: () => replayCommand,
@@ -167,31 +147,23 @@ __export(index_exports, {
   resetConfig: () => resetConfig,
   resolveContextProfile: () => resolveContextProfile,
   resolveLlmProvider: () => resolveLlmProvider,
-  resolvePeerIP: () => resolvePeerIP,
   resolveVaultPath: () => resolveVaultPath,
   reweave: () => reweave,
   reweaveCommand: () => reweaveCommand,
   runPromptInjection: () => runPromptInjection,
   runReflection: () => runReflection,
   sentenceChunk: () => sentenceChunk,
-  serveVault: () => serveVault,
   sessionRecapCommand: () => sessionRecapCommand,
   setConfigValue: () => setConfigValue,
   setupCommand: () => setupCommand,
-  stopTailscaleServe: () => stopTailscaleServe,
   stripSupersededObservations: () => stripSupersededObservations,
   syncKanbanBoard: () => syncKanbanBoard,
-  syncWithPeer: () => syncWithPeer,
-  tailscaleDiscoverCommand: () => tailscaleDiscoverCommand,
-  tailscaleServeCommand: () => tailscaleServeCommand,
-  tailscaleStatusCommand: () => tailscaleStatusCommand,
-  tailscaleSyncCommand: () => tailscaleSyncCommand,
   testRouteRule: () => testRouteRule,
   updateProject: () => updateProject,
   updateTask: () => updateTask
 });
 module.exports = __toCommonJS(index_exports);
-var fs36 = __toESM(require("fs"), 1);
+var fs34 = __toESM(require("fs"), 1);
 
 // src/commands/context.ts
 var path5 = __toESM(require("path"), 1);
@@ -931,6 +903,7 @@ function stripQmdNoise(raw) {
 function parseQmdOutput(raw) {
   const trimmed = stripQmdNoise(raw).trim();
   if (!trimmed) return [];
+  if (trimmed.startsWith("No results") || trimmed.startsWith("No matches")) return [];
   const direct = tryParseJson(trimmed);
   const extracted = direct ? null : extractJsonPayload(trimmed);
   const parsed = direct ?? (extracted ? tryParseJson(extracted) : null);
@@ -1684,8 +1657,8 @@ function toUnresolvedNodeId(raw) {
   return `unresolved:${normalizeUnresolvedKey(raw)}`;
 }
 function titleFromNoteKey(noteKey) {
-  const basename16 = noteKey.split("/").pop() ?? noteKey;
-  return basename16.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+  const basename14 = noteKey.split("/").pop() ?? noteKey;
+  return basename14.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
 }
 function inferNodeType(relativePath, frontmatter) {
   const normalized = normalizeRelativePath(relativePath).toLowerCase();
@@ -4583,9 +4556,9 @@ function collectNodeAliases(node) {
     aliases.add(node.title);
   }
   if (node.path) {
-    const basename16 = path7.basename(node.path, ".md");
-    aliases.add(basename16.replace(/[-_]+/g, " "));
-    aliases.add(basename16);
+    const basename14 = path7.basename(node.path, ".md");
+    aliases.add(basename14.replace(/[-_]+/g, " "));
+    aliases.add(basename14);
   }
   return [...aliases].map((alias) => normalizeText(alias)).filter((alias) => alias.length >= 3);
 }
@@ -8258,8 +8231,8 @@ var SessionWatcher = class {
       this.fileOffsets.delete(resolved);
       this.pendingPaths.delete(resolved);
     });
-    await new Promise((resolve30, reject) => {
-      this.watcher?.once("ready", () => resolve30());
+    await new Promise((resolve28, reject) => {
+      this.watcher?.once("ready", () => resolve28());
       this.watcher?.once("error", (error) => reject(error));
     });
     if (this.ignoreInitial) {
@@ -9134,12 +9107,12 @@ async function watchSessions(observer, watchPath) {
   const watcher = new SessionWatcher(watchPath, observer);
   await watcher.start();
   console.log(`Watching session updates: ${watchPath}`);
-  await new Promise((resolve30) => {
+  await new Promise((resolve28) => {
     const shutdown = async () => {
       process.off("SIGINT", onSigInt);
       process.off("SIGTERM", onSigTerm);
       await watcher.stop();
-      resolve30();
+      resolve28();
     };
     const onSigInt = () => {
       void shutdown();
@@ -9806,2344 +9779,322 @@ function registerReweaveCommand(program) {
   });
 }
 
-// src/commands/tailscale.ts
-var path25 = __toESM(require("path"), 1);
-
-// src/lib/tailscale.ts
-var import_child_process4 = require("child_process");
-var fs25 = __toESM(require("fs"), 1);
-var path24 = __toESM(require("path"), 1);
-var http = __toESM(require("http"), 1);
-var https = __toESM(require("https"), 1);
+// src/cli/index.ts
+function registerCliCommands(program) {
+  registerContextCommand(program);
+  registerInjectCommand(program);
+  registerObserveCommand(program);
+  registerReflectCommand(program);
+  registerEmbedCommand(program);
+  registerReweaveCommand(program);
+  return program;
+}
 
-// src/lib/webdav.ts
+// src/commands/setup.ts
 var fs24 = __toESM(require("fs"), 1);
+var os2 = __toESM(require("os"), 1);
 var path23 = __toESM(require("path"), 1);
-var WEBDAV_PREFIX = "/webdav";
-var BLOCKED_PATHS = [
-  ".clawvault",
-  ".git",
-  ".obsidian",
-  "node_modules"
-];
-var SUPPORTED_METHODS = ["GET", "PUT", "DELETE", "MKCOL", "PROPFIND", "OPTIONS", "HEAD", "MOVE", "COPY"];
-function toRequestSegments(requestPath) {
-  return requestPath.replace(/\\/g, "/").split("/").filter(Boolean);
-}
-function isWithinRoot(fullPath, rootPath) {
-  const resolvedRoot = path23.resolve(rootPath);
-  const relative6 = path23.relative(resolvedRoot, fullPath);
-  return !(relative6.startsWith("..") || path23.isAbsolute(relative6));
-}
-function isPathSafe(requestPath, rootPath) {
-  const pathParts = toRequestSegments(requestPath);
-  if (pathParts.includes("..")) {
-    return false;
+var import_child_process4 = require("child_process");
+var import_gray_matter7 = __toESM(require("gray-matter"), 1);
+var CONFIG_FILE4 = ".clawvault.json";
+function resolveVaultTarget(vaultOverride) {
+  if (vaultOverride) {
+    const vaultPath = path23.resolve(vaultOverride);
+    return { vaultPath, source: "--vault flag", existed: fs24.existsSync(vaultPath) };
   }
-  const normalizedRelativePath = path23.normalize(pathParts.join(path23.sep));
-  const fullPath = path23.resolve(rootPath, normalizedRelativePath);
-  if (!isWithinRoot(fullPath, rootPath)) {
-    return false;
+  const envPath = process.env.CLAWVAULT_PATH?.trim();
+  const home = os2.homedir();
+  if (envPath) {
+    const vaultPath = path23.resolve(envPath);
+    return { vaultPath, source: "CLAWVAULT_PATH", existed: fs24.existsSync(vaultPath) };
   }
-  for (const part of pathParts) {
-    if (BLOCKED_PATHS.includes(part)) {
-      return false;
+  const candidates = [
+    { vaultPath: path23.join(home, ".openclaw", "workspace", "memory"), source: "OpenClaw default" },
+    { vaultPath: path23.resolve(process.cwd(), "memory"), source: "./memory" },
+    { vaultPath: path23.join(home, "memory"), source: "~/memory" }
+  ];
+  for (const candidate of candidates) {
+    if (fs24.existsSync(candidate.vaultPath)) {
+      return { ...candidate, existed: true };
     }
   }
-  return true;
+  const fallback = candidates[0];
+  return { ...fallback, existed: false };
 }
-function resolveWebDAVPath(requestPath, rootPath) {
-  const pathParts = toRequestSegments(requestPath);
-  if (pathParts.includes("..")) {
-    return null;
-  }
-  const normalizedRelativePath = path23.normalize(pathParts.join(path23.sep));
-  const fullPath = path23.resolve(rootPath, normalizedRelativePath);
-  if (!isWithinRoot(fullPath, rootPath)) {
-    return null;
+function ensureVaultStructure(vaultPath) {
+  fs24.mkdirSync(vaultPath, { recursive: true });
+  for (const category of DEFAULT_CATEGORIES) {
+    fs24.mkdirSync(path23.join(vaultPath, category), { recursive: true });
   }
-  return fullPath;
+  const configPath = path23.join(vaultPath, CONFIG_FILE4);
+  if (fs24.existsSync(configPath)) return false;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const name = path23.basename(vaultPath);
+  const meta = {
+    name,
+    version: "1.0.0",
+    created: now,
+    lastUpdated: now,
+    categories: DEFAULT_CATEGORIES,
+    documentCount: 0,
+    qmdCollection: name,
+    qmdRoot: vaultPath
+  };
+  fs24.writeFileSync(configPath, JSON.stringify(meta, null, 2));
+  return true;
 }
-function checkAuth(req, auth) {
-  if (!auth) {
-    return true;
+function writeBases(vaultPath, force) {
+  const basesFiles = {
+    "all-tasks.base": `filters:
+  and:
+    - file.inFolder("tasks")
+    - status != "done"
+formulas:
+  age: (now() - file.ctime).days
+  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", if(status == "open", "\u26AA", "\u2705")))
+views:
+  - type: table
+    name: All Active Tasks
+    groupBy:
+      property: status
+      direction: ASC
+    order:
+      - formula.status_icon
+      - file.name
+      - status
+      - owner
+      - project
+      - priority
+      - blocked_by
+      - formula.age
+  - type: cards
+    name: Task Board
+    groupBy:
+      property: status
+      direction: ASC
+    order:
+      - file.name
+      - owner
+      - project
+      - priority`,
+    "blocked.base": `filters:
+  and:
+    - file.inFolder("tasks")
+    - status == "blocked"
+formulas:
+  days_blocked: (now() - file.ctime).days
+views:
+  - type: table
+    name: Blocked Tasks
+    order:
+      - file.name
+      - owner
+      - project
+      - blocked_by
+      - formula.days_blocked
+      - priority`,
+    "by-project.base": `filters:
+  and:
+    - file.inFolder("tasks")
+    - status != "done"
+formulas:
+  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", "\u26AA"))
+views:
+  - type: table
+    name: By Project
+    groupBy:
+      property: project
+      direction: ASC
+    order:
+      - formula.status_icon
+      - file.name
+      - status
+      - owner
+      - priority
+  - type: cards
+    name: Project Cards
+    groupBy:
+      property: project
+      direction: ASC
+    order:
+      - file.name
+      - owner
+      - status`,
+    "by-owner.base": `filters:
+  and:
+    - file.inFolder("tasks")
+    - status != "done"
+views:
+  - type: table
+    name: By Owner
+    groupBy:
+      property: owner
+      direction: ASC
+    order:
+      - file.name
+      - status
+      - project
+      - priority`,
+    "backlog.base": `filters:
+  and:
+    - file.inFolder("backlog")
+views:
+  - type: table
+    name: Backlog
+    order:
+      - file.name
+      - source
+      - project
+      - file.ctime`
+  };
+  let written = 0;
+  for (const [filename, content] of Object.entries(basesFiles)) {
+    const filePath = path23.join(vaultPath, filename);
+    if (force || !fs24.existsSync(filePath)) {
+      fs24.writeFileSync(filePath, content);
+      written++;
+    }
   }
-  const authHeader = req.headers.authorization;
-  if (!authHeader || !authHeader.startsWith("Basic ")) {
+  return written;
+}
+var NEURAL_GRAPH_CSS = `/* ClawVault Graph Colors \u2014 Neural Neural Style */
+/* Auto-generated by \`clawvault setup --theme neural\` */
+
+body.theme-dark .graph-view .graph-view-container { background-color: #0a0a0a; }
+
+body.theme-dark .graph-view .node.tag-person circle { fill: #00b4d8 !important; }
+body.theme-dark .graph-view .node.tag-project circle { fill: #2d6a4f !important; }
+body.theme-dark .graph-view .node.tag-decision circle { fill: #e8590c !important; }
+body.theme-dark .graph-view .node.tag-lesson circle { fill: #fcc419 !important; }
+body.theme-dark .graph-view .node.tag-commitment circle { fill: #e03131 !important; }
+body.theme-dark .graph-view .node.tag-task circle { fill: #22b8cf !important; }
+body.theme-dark .graph-view .node.tag-observation circle { fill: #7950f2 !important; }
+body.theme-dark .graph-view .node.tag-handoff circle { fill: #845ef7 !important; }
+body.theme-dark .graph-view .node.tag-daily circle { fill: #495057 !important; }
+
+body.theme-dark .graph-view .node.is-focused circle {
+  fill: #e8a430 !important; stroke: #e8a430 !important;
+  stroke-width: 3px; filter: drop-shadow(0 0 6px #e8a430);
+}
+
+body.theme-dark .graph-view .link { stroke: rgba(45, 200, 120, 0.15) !important; }
+body.theme-dark .graph-view .link.is-focused { stroke: rgba(45, 200, 120, 0.6) !important; }
+body.theme-dark .graph-view .node text { fill: #c1c2c5 !important; font-size: 0.8em; }
+`;
+var MINIMAL_GRAPH_CSS = `/* ClawVault Graph Colors \u2014 Minimal */
+/* Auto-generated by \`clawvault setup --theme minimal\` */
+
+body.theme-dark .graph-view .node.tag-person circle { fill: #4a90e8 !important; }
+body.theme-dark .graph-view .node.tag-project circle { fill: #4ae85d !important; }
+body.theme-dark .graph-view .node.tag-decision circle { fill: #e85d4a !important; }
+body.theme-dark .graph-view .node.tag-lesson circle { fill: #9b59b6 !important; }
+body.theme-dark .graph-view .node.tag-task circle { fill: #e8a430 !important; }
+`;
+var NEURAL_COLOR_GROUPS = [
+  { query: "path:people", color: { a: 1, rgb: 47316 } },
+  { query: "path:projects", color: { a: 1, rgb: 2976335 } },
+  { query: "path:decisions", color: { a: 1, rgb: 15227916 } },
+  { query: "path:lessons", color: { a: 1, rgb: 16565273 } },
+  { query: "path:tasks", color: { a: 1, rgb: 2275535 } },
+  { query: "path:commitments", color: { a: 1, rgb: 14680369 } },
+  { query: "path:backlog", color: { a: 1, rgb: 9806262 } },
+  { query: "path:inbox", color: { a: 1, rgb: 15964178 } },
+  { query: "path:handoffs", color: { a: 1, rgb: 8675063 } },
+  { query: "path:ledger", color: { a: 1, rgb: 7950066 } }
+];
+var MINIMAL_COLOR_GROUPS = [
+  { query: "path:people", color: { a: 1, rgb: 4886760 } },
+  { query: "path:projects", color: { a: 1, rgb: 4909149 } },
+  { query: "path:decisions", color: { a: 1, rgb: 15228234 } },
+  { query: "path:lessons", color: { a: 1, rgb: 10181046 } },
+  { query: "path:tasks", color: { a: 1, rgb: 15246384 } }
+];
+function writeGraphColors(vaultPath, theme, force) {
+  const obsidianDir = path23.join(vaultPath, ".obsidian");
+  if (!fs24.existsSync(obsidianDir)) {
     return false;
   }
-  const base64Credentials = authHeader.slice(6);
-  const credentials = Buffer.from(base64Credentials, "base64").toString("utf-8");
-  const [username, password] = credentials.split(":");
-  return username === auth.username && password === auth.password;
-}
-function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-function formatWebDAVDate(date) {
-  return date.toUTCString();
-}
-function generatePropfindEntry(href, stats, isCollection) {
-  const resourceType = isCollection ? "<D:resourcetype><D:collection/></D:resourcetype>" : "<D:resourcetype/>";
-  const contentLength = stats && !isCollection ? `<D:getcontentlength>${stats.size}</D:getcontentlength>` : "";
-  const lastModified = stats ? `<D:getlastmodified>${formatWebDAVDate(stats.mtime)}</D:getlastmodified>` : "";
-  const etag = stats ? `<D:getetag>"${stats.mtime.getTime().toString(16)}-${stats.size.toString(16)}"</D:getetag>` : "";
-  const contentType = !isCollection ? "<D:getcontenttype>application/octet-stream</D:getcontenttype>" : "";
-  return `  <D:response>
-    <D:href>${escapeXml(href)}</D:href>
-    <D:propstat>
-      <D:prop>
-        ${resourceType}
-        ${contentLength}
-        ${lastModified}
-        ${etag}
-        ${contentType}
-      </D:prop>
-      <D:status>HTTP/1.1 200 OK</D:status>
-    </D:propstat>
-  </D:response>`;
-}
-function generatePropfindResponse(entries) {
-  const responseEntries = entries.map(
-    (e) => generatePropfindEntry(e.href, e.stats, e.isCollection)
-  ).join("\n");
-  return `<?xml version="1.0" encoding="utf-8"?>
-<D:multistatus xmlns:D="DAV:">
-${responseEntries}
-</D:multistatus>`;
-}
-function handleOptions(res, prefix) {
-  res.writeHead(200, {
-    "Allow": SUPPORTED_METHODS.join(", "),
-    "DAV": "1, 2",
-    "Content-Length": "0",
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": SUPPORTED_METHODS.join(", "),
-    "Access-Control-Allow-Headers": "Content-Type, Depth, Destination, Overwrite, Authorization",
-    "MS-Author-Via": "DAV"
-  });
-  res.end();
-}
-function handleHead(res, filePath) {
-  try {
-    const stats = fs24.statSync(filePath);
-    if (stats.isDirectory()) {
-      res.writeHead(200, {
-        "Content-Type": "httpd/unix-directory",
-        "Last-Modified": formatWebDAVDate(stats.mtime),
-        "ETag": `"${stats.mtime.getTime().toString(16)}"`,
-        "Access-Control-Allow-Origin": "*"
-      });
-    } else {
-      res.writeHead(200, {
-        "Content-Type": "application/octet-stream",
-        "Content-Length": stats.size.toString(),
-        "Last-Modified": formatWebDAVDate(stats.mtime),
-        "ETag": `"${stats.mtime.getTime().toString(16)}-${stats.size.toString(16)}"`,
-        "Access-Control-Allow-Origin": "*"
-      });
-    }
-    res.end();
-  } catch (err) {
-    res.writeHead(404, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-    res.end("Not Found");
+  const snippetsDir = path23.join(obsidianDir, "snippets");
+  fs24.mkdirSync(snippetsDir, { recursive: true });
+  const snippetName = "clawvault-graph";
+  const snippetPath = path23.join(snippetsDir, `${snippetName}.css`);
+  if (!force && fs24.existsSync(snippetPath)) {
+    return false;
   }
-}
-function handleGet(res, filePath) {
-  try {
-    const stats = fs24.statSync(filePath);
-    if (stats.isDirectory()) {
-      const entries = fs24.readdirSync(filePath);
-      const listing = entries.join("\n");
-      res.writeHead(200, {
-        "Content-Type": "text/plain",
-        "Content-Length": Buffer.byteLength(listing).toString(),
-        "Access-Control-Allow-Origin": "*"
-      });
-      res.end(listing);
-    } else {
-      const content = fs24.readFileSync(filePath);
-      res.writeHead(200, {
-        "Content-Type": "application/octet-stream",
-        "Content-Length": content.length.toString(),
-        "Last-Modified": formatWebDAVDate(stats.mtime),
-        "ETag": `"${stats.mtime.getTime().toString(16)}-${stats.size.toString(16)}"`,
-        "Access-Control-Allow-Origin": "*"
-      });
-      res.end(content);
+  const css = theme === "neural" ? NEURAL_GRAPH_CSS : MINIMAL_GRAPH_CSS;
+  fs24.writeFileSync(snippetPath, css);
+  const appearancePath = path23.join(obsidianDir, "appearance.json");
+  let appearance = {};
+  if (fs24.existsSync(appearancePath)) {
+    try {
+      appearance = JSON.parse(fs24.readFileSync(appearancePath, "utf-8"));
+    } catch {
     }
-  } catch (err) {
-    res.writeHead(404, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-    res.end("Not Found");
   }
-}
-function handlePut(res, filePath, body) {
-  try {
-    const exists = fs24.existsSync(filePath);
-    const dir = path23.dirname(filePath);
-    if (!fs24.existsSync(dir)) {
-      fs24.mkdirSync(dir, { recursive: true });
-    }
-    fs24.writeFileSync(filePath, body);
-    const status = exists ? 204 : 201;
-    res.writeHead(status, {
-      "Content-Length": "0",
-      "Access-Control-Allow-Origin": "*"
-    });
-    res.end();
-  } catch (err) {
-    res.writeHead(500, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-    res.end(`Error: ${err}`);
+  const snippets = appearance.enabledCssSnippets || [];
+  if (!snippets.includes(snippetName)) {
+    snippets.push(snippetName);
+    appearance.enabledCssSnippets = snippets;
+    fs24.writeFileSync(appearancePath, JSON.stringify(appearance, null, 2));
   }
-}
-function handleDelete(res, filePath) {
-  try {
-    if (!fs24.existsSync(filePath)) {
-      res.writeHead(404, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Not Found");
-      return;
-    }
-    const stats = fs24.statSync(filePath);
-    if (stats.isDirectory()) {
-      fs24.rmSync(filePath, { recursive: true });
-    } else {
-      fs24.unlinkSync(filePath);
-    }
-    res.writeHead(204, {
-      "Content-Length": "0",
-      "Access-Control-Allow-Origin": "*"
-    });
-    res.end();
-  } catch (err) {
-    res.writeHead(500, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-    res.end(`Error: ${err}`);
-  }
-}
-function handleMkcol(res, filePath) {
-  try {
-    if (fs24.existsSync(filePath)) {
-      res.writeHead(405, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Resource already exists");
-      return;
-    }
-    const parent = path23.dirname(filePath);
-    if (!fs24.existsSync(parent)) {
-      res.writeHead(409, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Parent directory does not exist");
-      return;
-    }
-    fs24.mkdirSync(filePath);
-    res.writeHead(201, {
-      "Content-Length": "0",
-      "Access-Control-Allow-Origin": "*"
-    });
-    res.end();
-  } catch (err) {
-    res.writeHead(500, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-    res.end(`Error: ${err}`);
-  }
-}
-function handlePropfind(res, filePath, webdavPath, prefix, depth) {
-  try {
-    if (!fs24.existsSync(filePath)) {
-      res.writeHead(404, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Not Found");
-      return;
-    }
-    const stats = fs24.statSync(filePath);
-    const entries = [];
-    const normalizedWebdavPath = webdavPath.startsWith("/") ? webdavPath : "/" + webdavPath;
-    const href = prefix + normalizedWebdavPath;
-    entries.push({
-      href: href.endsWith("/") || stats.isDirectory() ? href : href,
-      stats,
-      isCollection: stats.isDirectory()
-    });
-    if (stats.isDirectory() && depth !== "0") {
-      try {
-        const children = fs24.readdirSync(filePath);
-        for (const child of children) {
-          if (BLOCKED_PATHS.includes(child)) {
-            continue;
-          }
-          const childPath = path23.join(filePath, child);
-          const childWebdavPath = normalizedWebdavPath.endsWith("/") ? normalizedWebdavPath + child : normalizedWebdavPath + "/" + child;
-          try {
-            const childStats = fs24.statSync(childPath);
-            entries.push({
-              href: prefix + childWebdavPath,
-              stats: childStats,
-              isCollection: childStats.isDirectory()
-            });
-          } catch {
-          }
-        }
-      } catch {
-      }
-    }
-    const xml = generatePropfindResponse(entries);
-    res.writeHead(207, {
-      "Content-Type": "application/xml; charset=utf-8",
-      "Content-Length": Buffer.byteLength(xml).toString(),
-      "Access-Control-Allow-Origin": "*"
-    });
-    res.end(xml);
-  } catch (err) {
-    res.writeHead(500, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-    res.end(`Error: ${err}`);
-  }
-}
-function handleMove(res, sourcePath, destinationPath, overwrite) {
-  try {
-    if (!fs24.existsSync(sourcePath)) {
-      res.writeHead(404, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Source not found");
-      return;
-    }
-    if (!destinationPath) {
-      res.writeHead(400, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Destination header required");
-      return;
-    }
-    const destExists = fs24.existsSync(destinationPath);
-    if (destExists && !overwrite) {
-      res.writeHead(412, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Destination exists and Overwrite is F");
-      return;
-    }
-    const destDir = path23.dirname(destinationPath);
-    if (!fs24.existsSync(destDir)) {
-      fs24.mkdirSync(destDir, { recursive: true });
-    }
-    if (destExists) {
-      const destStats = fs24.statSync(destinationPath);
-      if (destStats.isDirectory()) {
-        fs24.rmSync(destinationPath, { recursive: true });
-      } else {
-        fs24.unlinkSync(destinationPath);
-      }
-    }
-    fs24.renameSync(sourcePath, destinationPath);
-    const status = destExists ? 204 : 201;
-    res.writeHead(status, {
-      "Content-Length": "0",
-      "Access-Control-Allow-Origin": "*"
-    });
-    res.end();
-  } catch (err) {
-    res.writeHead(500, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-    res.end(`Error: ${err}`);
-  }
-}
-function handleCopy(res, sourcePath, destinationPath, overwrite) {
-  try {
-    if (!fs24.existsSync(sourcePath)) {
-      res.writeHead(404, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Source not found");
-      return;
-    }
-    if (!destinationPath) {
-      res.writeHead(400, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Destination header required");
-      return;
-    }
-    const destExists = fs24.existsSync(destinationPath);
-    if (destExists && !overwrite) {
-      res.writeHead(412, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Destination exists and Overwrite is F");
-      return;
-    }
-    const destDir = path23.dirname(destinationPath);
-    if (!fs24.existsSync(destDir)) {
-      fs24.mkdirSync(destDir, { recursive: true });
-    }
-    const sourceStats = fs24.statSync(sourcePath);
-    if (sourceStats.isDirectory()) {
-      copyDirRecursive(sourcePath, destinationPath);
-    } else {
-      fs24.copyFileSync(sourcePath, destinationPath);
-    }
-    const status = destExists ? 204 : 201;
-    res.writeHead(status, {
-      "Content-Length": "0",
-      "Access-Control-Allow-Origin": "*"
-    });
-    res.end();
-  } catch (err) {
-    res.writeHead(500, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-    res.end(`Error: ${err}`);
-  }
-}
-function copyDirRecursive(src, dest) {
-  if (!fs24.existsSync(dest)) {
-    fs24.mkdirSync(dest, { recursive: true });
-  }
-  const entries = fs24.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path23.join(src, entry.name);
-    const destPath = path23.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs24.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-function parseDestinationHeader(destinationHeader, prefix, rootPath) {
-  if (!destinationHeader) {
-    return null;
-  }
-  try {
-    let destPath;
-    if (destinationHeader.startsWith("http://") || destinationHeader.startsWith("https://")) {
-      const url = new URL(destinationHeader);
-      destPath = decodeURIComponent(url.pathname);
-    } else {
-      destPath = decodeURIComponent(destinationHeader);
-    }
-    if (destPath.startsWith(prefix)) {
-      destPath = destPath.slice(prefix.length);
-    }
-    return resolveWebDAVPath(destPath, rootPath);
-  } catch {
-    return null;
-  }
-}
-function createWebDAVHandler(config) {
-  const { rootPath, prefix = WEBDAV_PREFIX, auth } = config;
-  return async (req, res) => {
-    const rawUrl = req.url || "/";
-    if (rawUrl.includes("..")) {
-      if (rawUrl.startsWith(prefix)) {
-        res.writeHead(403, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-        res.end("Forbidden");
-        return true;
-      }
-    }
-    const url = new URL(rawUrl, `http://${req.headers.host || "localhost"}`);
-    const pathname = decodeURIComponent(url.pathname);
-    if (!pathname.startsWith(prefix)) {
-      return false;
-    }
-    let webdavPath = pathname.slice(prefix.length);
-    if (!webdavPath.startsWith("/")) {
-      webdavPath = "/" + webdavPath;
-    }
-    if (req.method === "OPTIONS") {
-      handleOptions(res, prefix);
-      return true;
-    }
-    if (!checkAuth(req, auth)) {
-      res.writeHead(401, {
-        "WWW-Authenticate": 'Basic realm="ClawVault WebDAV"',
-        "Content-Type": "text/plain",
-        "Access-Control-Allow-Origin": "*"
-      });
-      res.end("Unauthorized");
-      return true;
-    }
-    if (!isPathSafe(webdavPath, rootPath)) {
-      res.writeHead(403, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Forbidden");
-      return true;
-    }
-    const filePath = resolveWebDAVPath(webdavPath, rootPath);
-    if (!filePath) {
-      res.writeHead(403, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-      res.end("Forbidden");
-      return true;
-    }
-    const depth = req.headers.depth || "infinity";
-    const overwrite = req.headers.overwrite?.toUpperCase() !== "F";
-    const destinationHeader = req.headers.destination;
-    switch (req.method) {
-      case "HEAD":
-        handleHead(res, filePath);
-        return true;
-      case "GET":
-        handleGet(res, filePath);
-        return true;
-      case "PUT": {
-        const chunks = [];
-        for await (const chunk of req) {
-          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        }
-        const body = Buffer.concat(chunks);
-        handlePut(res, filePath, body);
-        return true;
-      }
-      case "DELETE":
-        handleDelete(res, filePath);
-        return true;
-      case "MKCOL":
-        handleMkcol(res, filePath);
-        return true;
-      case "PROPFIND":
-        handlePropfind(res, filePath, webdavPath, prefix, depth);
-        return true;
-      case "MOVE": {
-        const destPath = parseDestinationHeader(destinationHeader, prefix, rootPath);
-        if (destPath && destinationHeader) {
-          const destWebdavPath = destinationHeader.includes(prefix) ? destinationHeader.slice(destinationHeader.indexOf(prefix) + prefix.length) : destinationHeader;
-          if (!isPathSafe(destWebdavPath, rootPath)) {
-            res.writeHead(403, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-            res.end("Forbidden");
-            return true;
-          }
-        }
-        handleMove(res, filePath, destPath, overwrite);
-        return true;
-      }
-      case "COPY": {
-        const destPath = parseDestinationHeader(destinationHeader, prefix, rootPath);
-        if (destPath && destinationHeader) {
-          const destWebdavPath = destinationHeader.includes(prefix) ? destinationHeader.slice(destinationHeader.indexOf(prefix) + prefix.length) : destinationHeader;
-          if (!isPathSafe(destWebdavPath, rootPath)) {
-            res.writeHead(403, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-            res.end("Forbidden");
-            return true;
-          }
-        }
-        handleCopy(res, filePath, destPath, overwrite);
-        return true;
-      }
-      default:
-        res.writeHead(405, {
-          "Allow": SUPPORTED_METHODS.join(", "),
-          "Content-Type": "text/plain",
-          "Access-Control-Allow-Origin": "*"
-        });
-        res.end("Method Not Allowed");
-        return true;
-    }
-  };
-}
-
-// src/lib/tailscale.ts
-var crypto = __toESM(require("crypto"), 1);
-var DEFAULT_SERVE_PORT = 8384;
-var CLAWVAULT_SERVE_PATH = "/.clawvault";
-function hasTailscale() {
-  const probe = (0, import_child_process4.spawnSync)("tailscale", ["version"], {
-    stdio: "pipe",
-    encoding: "utf-8",
-    timeout: 5e3
-  });
-  return !probe.error && probe.status === 0;
-}
-function getTailscaleVersion() {
-  const result = (0, import_child_process4.spawnSync)("tailscale", ["version"], {
-    stdio: "pipe",
-    encoding: "utf-8",
-    timeout: 5e3
-  });
-  if (result.error || result.status !== 0) {
-    return null;
-  }
-  const lines = result.stdout.trim().split("\n");
-  return lines[0] || null;
-}
-function getTailscaleStatus() {
-  const status = {
-    installed: false,
-    running: false,
-    connected: false,
-    peers: []
-  };
-  if (!hasTailscale()) {
-    status.error = "Tailscale CLI not found. Install from https://tailscale.com/download";
-    return status;
-  }
-  status.installed = true;
-  const result = (0, import_child_process4.spawnSync)("tailscale", ["status", "--json"], {
-    stdio: "pipe",
-    encoding: "utf-8",
-    timeout: 1e4
-  });
-  if (result.error) {
-    status.error = `Failed to get Tailscale status: ${result.error.message}`;
-    return status;
-  }
-  if (result.status !== 0) {
-    status.error = result.stderr?.trim() || "Tailscale daemon not running";
-    return status;
-  }
-  try {
-    const data = JSON.parse(result.stdout);
-    status.running = true;
-    status.backendState = data.BackendState;
-    status.connected = data.BackendState === "Running";
-    status.tailnetName = data.CurrentTailnet?.Name;
-    if (data.Self) {
-      status.selfIP = data.Self.TailscaleIPs?.[0];
-      status.selfHostname = data.Self.HostName;
-      status.selfDNSName = data.Self.DNSName;
-    }
-    if (data.Peer) {
-      for (const [_, peerData] of Object.entries(data.Peer)) {
-        const peer = {
-          hostname: peerData.HostName || "",
-          dnsName: peerData.DNSName || "",
-          tailscaleIPs: peerData.TailscaleIPs || [],
-          online: peerData.Online || false,
-          os: peerData.OS,
-          exitNode: peerData.ExitNode,
-          tags: peerData.Tags,
-          lastSeen: peerData.LastSeen
-        };
-        status.peers.push(peer);
-      }
-    }
-  } catch (err) {
-    status.error = `Failed to parse Tailscale status: ${err}`;
-  }
-  return status;
-}
-function findPeer(hostname) {
-  const status = getTailscaleStatus();
-  if (!status.connected) {
-    return null;
-  }
-  const normalizedSearch = hostname.toLowerCase();
-  let peer = status.peers.find(
-    (p) => p.hostname.toLowerCase() === normalizedSearch
-  );
-  if (peer) return peer;
-  peer = status.peers.find(
-    (p) => p.dnsName.toLowerCase().startsWith(normalizedSearch)
-  );
-  if (peer) return peer;
-  peer = status.peers.find(
-    (p) => p.hostname.toLowerCase().includes(normalizedSearch)
-  );
-  return peer || null;
-}
-function getOnlinePeers() {
-  const status = getTailscaleStatus();
-  return status.peers.filter((p) => p.online);
-}
-function resolvePeerIP(hostname) {
-  const peer = findPeer(hostname);
-  return peer?.tailscaleIPs[0] || null;
-}
-function calculateChecksum(filePath) {
-  const content = fs25.readFileSync(filePath);
-  return crypto.createHash("sha256").update(content).digest("hex");
-}
-function generateVaultManifest(vaultPath) {
-  const configPath = path24.join(vaultPath, ".clawvault.json");
-  if (!fs25.existsSync(configPath)) {
-    throw new Error(`Not a ClawVault: ${vaultPath}`);
-  }
-  const config = JSON.parse(fs25.readFileSync(configPath, "utf-8"));
-  const files = [];
-  function walkDir(dir, relativePath = "") {
-    const entries = fs25.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path24.join(dir, entry.name);
-      const relPath = path24.join(relativePath, entry.name);
-      if (entry.name.startsWith(".") && entry.name !== ".clawvault.json") {
-        continue;
-      }
-      if (entry.name === "node_modules") {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        walkDir(fullPath, relPath);
-      } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name === ".clawvault.json")) {
-        const stats = fs25.statSync(fullPath);
-        const category = relativePath.split(path24.sep)[0] || "root";
-        files.push({
-          path: relPath,
-          size: stats.size,
-          modified: stats.mtime.toISOString(),
-          checksum: calculateChecksum(fullPath),
-          category
-        });
-      }
-    }
-  }
-  walkDir(vaultPath);
-  return {
-    name: config.name,
-    version: config.version || "1.0.0",
-    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-    files
-  };
-}
-function compareManifests(local, remote) {
-  const localFiles = new Map(local.files.map((f) => [f.path, f]));
-  const remoteFiles = new Map(remote.files.map((f) => [f.path, f]));
-  const toPush = [];
-  const toPull = [];
-  const conflicts = [];
-  const unchanged = [];
-  for (const [filePath, localFile] of localFiles) {
-    const remoteFile = remoteFiles.get(filePath);
-    if (!remoteFile) {
-      toPush.push(localFile);
-    } else if (localFile.checksum === remoteFile.checksum) {
-      unchanged.push(filePath);
-    } else {
-      const localTime = new Date(localFile.modified).getTime();
-      const remoteTime = new Date(remoteFile.modified).getTime();
-      if (localTime > remoteTime) {
-        toPush.push(localFile);
-      } else if (remoteTime > localTime) {
-        toPull.push(remoteFile);
-      } else {
-        conflicts.push({ path: filePath, local: localFile, remote: remoteFile });
-      }
-    }
-  }
-  for (const [filePath, remoteFile] of remoteFiles) {
-    if (!localFiles.has(filePath)) {
-      toPull.push(remoteFile);
-    }
-  }
-  return { toPush, toPull, conflicts, unchanged };
-}
-function serveVault(vaultPath, options = {}) {
-  const port = options.port || DEFAULT_SERVE_PORT;
-  const pathPrefix = options.pathPrefix || CLAWVAULT_SERVE_PATH;
-  if (!fs25.existsSync(path24.join(vaultPath, ".clawvault.json"))) {
-    throw new Error(`Not a ClawVault: ${vaultPath}`);
-  }
-  const webdavHandler = createWebDAVHandler({
-    rootPath: vaultPath,
-    prefix: WEBDAV_PREFIX,
-    auth: options.webdavAuth
-  });
-  const server = http.createServer(async (req, res) => {
-    const url = new URL(req.url || "/", `http://localhost:${port}`);
-    const pathname = url.pathname;
-    if (pathname.startsWith(WEBDAV_PREFIX)) {
-      try {
-        const handled = await webdavHandler(req, res);
-        if (handled) return;
-      } catch (err) {
-        res.writeHead(500, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
-        res.end(`WebDAV Error: ${err}`);
-        return;
-      }
-    }
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-      res.writeHead(200);
-      res.end();
-      return;
-    }
-    if (pathname === `${pathPrefix}/health`) {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ status: "ok", vault: path24.basename(vaultPath) }));
-      return;
-    }
-    if (pathname === `${pathPrefix}/manifest`) {
-      try {
-        const manifest = generateVaultManifest(vaultPath);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(manifest));
-      } catch (err) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: String(err) }));
-      }
-      return;
-    }
-    if (pathname.startsWith(`${pathPrefix}/files/`)) {
-      const relativePath = decodeURIComponent(pathname.slice(`${pathPrefix}/files/`.length));
-      const filePath = path24.join(vaultPath, relativePath);
-      const resolvedPath = path24.resolve(filePath);
-      const resolvedVault = path24.resolve(vaultPath);
-      if (!resolvedPath.startsWith(resolvedVault)) {
-        res.writeHead(403, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Access denied" }));
-        return;
-      }
-      if (!fs25.existsSync(filePath)) {
-        res.writeHead(404, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "File not found" }));
-        return;
-      }
-      try {
-        const content = fs25.readFileSync(filePath, "utf-8");
-        const stats = fs25.statSync(filePath);
-        res.writeHead(200, {
-          "Content-Type": "text/markdown",
-          "Content-Length": Buffer.byteLength(content),
-          "Last-Modified": stats.mtime.toUTCString()
-        });
-        res.end(content);
-      } catch (err) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: String(err) }));
-      }
-      return;
-    }
-    if (pathname.startsWith(`${pathPrefix}/upload/`) && req.method === "POST") {
-      const relativePath = decodeURIComponent(pathname.slice(`${pathPrefix}/upload/`.length));
-      const filePath = path24.join(vaultPath, relativePath);
-      const resolvedPath = path24.resolve(filePath);
-      const resolvedVault = path24.resolve(vaultPath);
-      if (!resolvedPath.startsWith(resolvedVault)) {
-        res.writeHead(403, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Access denied" }));
-        return;
-      }
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk;
-      });
-      req.on("end", () => {
-        try {
-          const dir = path24.dirname(filePath);
-          if (!fs25.existsSync(dir)) {
-            fs25.mkdirSync(dir, { recursive: true });
-          }
-          fs25.writeFileSync(filePath, body, "utf-8");
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ success: true, path: relativePath }));
-        } catch (err) {
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: String(err) }));
-        }
-      });
-      return;
-    }
-    if (pathname === pathPrefix || pathname === `${pathPrefix}/`) {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({
-        service: "clawvault-sync",
-        version: "1.0.0",
-        vault: path24.basename(vaultPath),
-        endpoints: {
-          health: `${pathPrefix}/health`,
-          manifest: `${pathPrefix}/manifest`,
-          files: `${pathPrefix}/files/<path>`,
-          upload: `${pathPrefix}/upload/<path>`,
-          webdav: `${WEBDAV_PREFIX}/`
-        }
-      }));
-      return;
-    }
-    res.writeHead(404, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: "Not found" }));
-  });
-  server.listen(port, "0.0.0.0");
-  return {
-    server,
-    port,
-    stop: () => new Promise((resolve30, reject) => {
-      server.close((err) => {
-        if (err) reject(err);
-        else resolve30();
-      });
-    })
-  };
-}
-async function fetchRemoteManifest(host, port = DEFAULT_SERVE_PORT, useHttps = false) {
-  return new Promise((resolve30, reject) => {
-    const protocol = useHttps ? https : http;
-    const url = `${useHttps ? "https" : "http"}://${host}:${port}${CLAWVAULT_SERVE_PATH}/manifest`;
-    const req = protocol.get(url, { timeout: 1e4 }, (res) => {
-      let data = "";
-      res.on("data", (chunk) => {
-        data += chunk;
-      });
-      res.on("end", () => {
-        if (res.statusCode !== 200) {
-          reject(new Error(`Failed to fetch manifest: HTTP ${res.statusCode}`));
-          return;
-        }
-        try {
-          resolve30(JSON.parse(data));
-        } catch (err) {
-          reject(new Error(`Invalid manifest response: ${err}`));
-        }
-      });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Request timed out"));
-    });
-  });
-}
-async function fetchRemoteFile(host, filePath, port = DEFAULT_SERVE_PORT, useHttps = false) {
-  return new Promise((resolve30, reject) => {
-    const protocol = useHttps ? https : http;
-    const encodedPath = encodeURIComponent(filePath).replace(/%2F/g, "/");
-    const url = `${useHttps ? "https" : "http"}://${host}:${port}${CLAWVAULT_SERVE_PATH}/files/${encodedPath}`;
-    const req = protocol.get(url, { timeout: 3e4 }, (res) => {
-      let data = "";
-      res.on("data", (chunk) => {
-        data += chunk;
-      });
-      res.on("end", () => {
-        if (res.statusCode !== 200) {
-          reject(new Error(`Failed to fetch file: HTTP ${res.statusCode}`));
-          return;
-        }
-        resolve30(data);
-      });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Request timed out"));
-    });
-  });
-}
-async function pushFileToRemote(host, filePath, content, port = DEFAULT_SERVE_PORT, useHttps = false) {
-  return new Promise((resolve30, reject) => {
-    const protocol = useHttps ? https : http;
-    const encodedPath = encodeURIComponent(filePath).replace(/%2F/g, "/");
-    const url = new URL(`${useHttps ? "https" : "http"}://${host}:${port}${CLAWVAULT_SERVE_PATH}/upload/${encodedPath}`);
-    const options = {
-      hostname: url.hostname,
-      port: url.port,
-      path: url.pathname,
-      method: "POST",
-      headers: {
-        "Content-Type": "text/markdown",
-        "Content-Length": Buffer.byteLength(content)
-      },
-      timeout: 3e4
-    };
-    const req = protocol.request(options, (res) => {
-      let data = "";
-      res.on("data", (chunk) => {
-        data += chunk;
-      });
-      res.on("end", () => {
-        if (res.statusCode !== 200) {
-          reject(new Error(`Failed to push file: HTTP ${res.statusCode}`));
-          return;
-        }
-        resolve30();
-      });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Request timed out"));
-    });
-    req.write(content);
-    req.end();
-  });
-}
-async function syncWithPeer(vaultPath, options) {
-  const startTime = Date.now();
-  const result = {
-    pushed: [],
-    pulled: [],
-    deleted: [],
-    unchanged: [],
-    errors: [],
-    stats: {
-      bytesTransferred: 0,
-      filesProcessed: 0,
-      duration: 0
-    }
-  };
-  const {
-    peer,
-    port = DEFAULT_SERVE_PORT,
-    direction = "bidirectional",
-    dryRun = false,
-    deleteOrphans = false,
-    categories,
-    https: useHttps = false
-  } = options;
-  let host = peer;
-  if (!peer.match(/^\d+\.\d+\.\d+\.\d+$/)) {
-    const resolvedIP = resolvePeerIP(peer);
-    if (!resolvedIP) {
-      result.errors.push(`Could not resolve peer: ${peer}`);
-      result.stats.duration = Date.now() - startTime;
-      return result;
-    }
-    host = resolvedIP;
-  }
-  try {
-    const localManifest = generateVaultManifest(vaultPath);
-    const remoteManifest = await fetchRemoteManifest(host, port, useHttps);
-    let { toPush, toPull, conflicts, unchanged } = compareManifests(localManifest, remoteManifest);
-    if (categories && categories.length > 0) {
-      const categorySet = new Set(categories);
-      toPush = toPush.filter((f) => categorySet.has(f.category));
-      toPull = toPull.filter((f) => categorySet.has(f.category));
-    }
-    result.unchanged = unchanged;
-    for (const conflict of conflicts) {
-      result.errors.push(`Conflict: ${conflict.path} (local and remote have same timestamp but different content)`);
-    }
-    if (direction === "push" || direction === "bidirectional") {
-      for (const file of toPush) {
-        try {
-          if (!dryRun) {
-            const content = fs25.readFileSync(path24.join(vaultPath, file.path), "utf-8");
-            await pushFileToRemote(host, file.path, content, port, useHttps);
-            result.stats.bytesTransferred += file.size;
-          }
-          result.pushed.push(file.path);
-          result.stats.filesProcessed++;
-        } catch (err) {
-          result.errors.push(`Failed to push ${file.path}: ${err}`);
-        }
-      }
-    }
-    if (direction === "pull" || direction === "bidirectional") {
-      for (const file of toPull) {
-        try {
-          if (!dryRun) {
-            const content = await fetchRemoteFile(host, file.path, port, useHttps);
-            const filePath = path24.join(vaultPath, file.path);
-            const dir = path24.dirname(filePath);
-            if (!fs25.existsSync(dir)) {
-              fs25.mkdirSync(dir, { recursive: true });
-            }
-            fs25.writeFileSync(filePath, content, "utf-8");
-            result.stats.bytesTransferred += file.size;
-          }
-          result.pulled.push(file.path);
-          result.stats.filesProcessed++;
-        } catch (err) {
-          result.errors.push(`Failed to pull ${file.path}: ${err}`);
-        }
-      }
-    }
-    if (deleteOrphans && direction === "pull") {
-      const remoteFiles = new Set(remoteManifest.files.map((f) => f.path));
-      for (const file of localManifest.files) {
-        if (!remoteFiles.has(file.path)) {
-          if (!categories || categories.includes(file.category)) {
-            try {
-              if (!dryRun) {
-                fs25.unlinkSync(path24.join(vaultPath, file.path));
-              }
-              result.deleted.push(file.path);
-            } catch (err) {
-              result.errors.push(`Failed to delete ${file.path}: ${err}`);
-            }
-          }
-        }
-      }
-    }
-  } catch (err) {
-    result.errors.push(`Sync failed: ${err}`);
-  }
-  result.stats.duration = Date.now() - startTime;
-  return result;
-}
-function configureTailscaleServe(localPort, options = {}) {
-  if (!hasTailscale()) {
-    return null;
-  }
-  const args = ["serve"];
-  if (options.funnel) {
-    args.push("--bg");
-    args.push("funnel");
-  } else if (options.background) {
-    args.push("--bg");
-  }
-  args.push(`localhost:${localPort}`);
-  const proc = (0, import_child_process4.spawn)("tailscale", args, {
-    stdio: "inherit",
-    detached: options.background
-  });
-  if (options.background) {
-    proc.unref();
-  }
-  return proc;
-}
-function stopTailscaleServe() {
-  if (!hasTailscale()) {
-    return false;
-  }
-  const result = (0, import_child_process4.spawnSync)("tailscale", ["serve", "off"], {
-    stdio: "pipe",
-    encoding: "utf-8",
-    timeout: 5e3
-  });
-  return result.status === 0;
-}
-async function checkPeerClawVault(host, port = DEFAULT_SERVE_PORT) {
-  try {
-    const response = await new Promise((resolve30) => {
-      const req = http.get(
-        `http://${host}:${port}${CLAWVAULT_SERVE_PATH}/health`,
-        { timeout: 5e3 },
-        (res) => {
-          resolve30(res.statusCode === 200);
-        }
-      );
-      req.on("error", () => resolve30(false));
-      req.on("timeout", () => {
-        req.destroy();
-        resolve30(false);
-      });
-    });
-    return response;
-  } catch {
-    return false;
-  }
-}
-async function discoverClawVaultPeers(port = DEFAULT_SERVE_PORT) {
-  const status = getTailscaleStatus();
-  if (!status.connected) {
-    return [];
-  }
-  const clawvaultPeers = [];
-  const checkPromises = status.peers.filter((p) => p.online).map(async (peer) => {
-    const ip = peer.tailscaleIPs[0];
-    if (!ip) return;
-    const isServing = await checkPeerClawVault(ip, port);
-    if (isServing) {
-      peer.clawvaultServing = true;
-      peer.clawvaultPort = port;
-      clawvaultPeers.push(peer);
-    }
-  });
-  await Promise.all(checkPromises);
-  return clawvaultPeers;
-}
-
-// src/commands/tailscale.ts
-async function tailscaleStatusCommand(options = {}) {
-  const status = getTailscaleStatus();
-  if (options.json) {
-    console.log(JSON.stringify(status, null, 2));
-    return status;
-  }
-  if (!status.installed) {
-    console.log("Tailscale: Not installed");
-    console.log("  Install from: https://tailscale.com/download");
-    return status;
-  }
-  const version = getTailscaleVersion();
-  console.log(`Tailscale: ${version || "installed"}`);
-  if (!status.running) {
-    console.log("  Status: Daemon not running");
-    if (status.error) {
-      console.log(`  Error: ${status.error}`);
-    }
-    return status;
-  }
-  console.log(`  Status: ${status.backendState}`);
-  if (status.connected) {
-    console.log(`  Tailnet: ${status.tailnetName || "unknown"}`);
-    console.log(`  Self IP: ${status.selfIP || "unknown"}`);
-    console.log(`  Hostname: ${status.selfHostname || "unknown"}`);
-    if (status.selfDNSName) {
-      console.log(`  DNS Name: ${status.selfDNSName}`);
-    }
-    if (options.peers || status.peers.length > 0) {
-      const onlinePeers = status.peers.filter((p) => p.online);
-      const offlinePeers = status.peers.filter((p) => !p.online);
-      console.log(`
-Peers (${onlinePeers.length} online, ${offlinePeers.length} offline):`);
-      for (const peer of onlinePeers) {
-        const ip = peer.tailscaleIPs[0] || "no-ip";
-        const os4 = peer.os ? ` (${peer.os})` : "";
-        const clawvault = peer.clawvaultServing ? " [ClawVault]" : "";
-        console.log(`  \u25CF ${peer.hostname}${os4} - ${ip}${clawvault}`);
-      }
-      if (options.peers) {
-        for (const peer of offlinePeers) {
-          const ip = peer.tailscaleIPs[0] || "no-ip";
-          const os4 = peer.os ? ` (${peer.os})` : "";
-          console.log(`  \u25CB ${peer.hostname}${os4} - ${ip} [offline]`);
-        }
-      }
-    }
-  } else {
-    console.log("  Status: Not connected to tailnet");
-    if (status.error) {
-      console.log(`  Error: ${status.error}`);
-    }
-  }
-  return status;
-}
-function registerTailscaleStatusCommand(program) {
-  program.command("tailscale-status").alias("ts-status").description("Show Tailscale connection status and peers").option("--json", "Output as JSON").option("--peers", "Show all peers including offline").action(async (rawOptions) => {
-    await tailscaleStatusCommand({
-      json: rawOptions.json,
-      peers: rawOptions.peers
-    });
-  });
-}
-async function tailscaleSyncCommand(options) {
-  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
-  const status = getTailscaleStatus();
-  if (!status.installed) {
-    const error = {
-      pushed: [],
-      pulled: [],
-      deleted: [],
-      unchanged: [],
-      errors: ["Tailscale not installed. Install from https://tailscale.com/download"],
-      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
-    };
-    if (options.json) {
-      console.log(JSON.stringify(error, null, 2));
-    } else {
-      console.error("Error: Tailscale not installed");
-    }
-    return error;
-  }
-  if (!status.connected) {
-    const error = {
-      pushed: [],
-      pulled: [],
-      deleted: [],
-      unchanged: [],
-      errors: ["Not connected to Tailscale. Run `tailscale up` to connect."],
-      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
-    };
-    if (options.json) {
-      console.log(JSON.stringify(error, null, 2));
-    } else {
-      console.error("Error: Not connected to Tailscale");
-    }
-    return error;
-  }
-  const peer = findPeer(options.peer);
-  if (!peer) {
-    const error = {
-      pushed: [],
-      pulled: [],
-      deleted: [],
-      unchanged: [],
-      errors: [`Peer not found: ${options.peer}`],
-      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
-    };
-    if (options.json) {
-      console.log(JSON.stringify(error, null, 2));
-    } else {
-      console.error(`Error: Peer not found: ${options.peer}`);
-      console.log("\nAvailable online peers:");
-      for (const p of getOnlinePeers()) {
-        console.log(`  - ${p.hostname} (${p.tailscaleIPs[0]})`);
-      }
-    }
-    return error;
-  }
-  if (!peer.online) {
-    const error = {
-      pushed: [],
-      pulled: [],
-      deleted: [],
-      unchanged: [],
-      errors: [`Peer is offline: ${peer.hostname}`],
-      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
-    };
-    if (options.json) {
-      console.log(JSON.stringify(error, null, 2));
-    } else {
-      console.error(`Error: Peer is offline: ${peer.hostname}`);
-    }
-    return error;
-  }
-  const syncOptions = {
-    peer: peer.tailscaleIPs[0],
-    port: options.port || DEFAULT_SERVE_PORT,
-    direction: options.direction || "bidirectional",
-    dryRun: options.dryRun,
-    deleteOrphans: options.deleteOrphans,
-    categories: options.categories,
-    https: options.https
-  };
-  if (!options.json && !options.dryRun) {
-    console.log(`Syncing with ${peer.hostname} (${peer.tailscaleIPs[0]})...`);
-  }
-  const result = await syncWithPeer(vaultPath, syncOptions);
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    const prefix = options.dryRun ? "[dry-run] " : "";
-    if (result.pushed.length > 0) {
-      console.log(`
-${prefix}Pushed ${result.pushed.length} file(s):`);
-      for (const file of result.pushed.slice(0, 10)) {
-        console.log(`  \u2192 ${file}`);
-      }
-      if (result.pushed.length > 10) {
-        console.log(`  ... and ${result.pushed.length - 10} more`);
-      }
-    }
-    if (result.pulled.length > 0) {
-      console.log(`
-${prefix}Pulled ${result.pulled.length} file(s):`);
-      for (const file of result.pulled.slice(0, 10)) {
-        console.log(`  \u2190 ${file}`);
-      }
-      if (result.pulled.length > 10) {
-        console.log(`  ... and ${result.pulled.length - 10} more`);
-      }
-    }
-    if (result.deleted.length > 0) {
-      console.log(`
-${prefix}Deleted ${result.deleted.length} file(s):`);
-      for (const file of result.deleted.slice(0, 10)) {
-        console.log(`  \u2717 ${file}`);
-      }
-      if (result.deleted.length > 10) {
-        console.log(`  ... and ${result.deleted.length - 10} more`);
-      }
-    }
-    if (result.errors.length > 0) {
-      console.log(`
-Errors (${result.errors.length}):`);
-      for (const error of result.errors) {
-        console.log(`  ! ${error}`);
-      }
-    }
-    console.log(`
-Summary:`);
-    console.log(`  Pushed: ${result.pushed.length}`);
-    console.log(`  Pulled: ${result.pulled.length}`);
-    console.log(`  Deleted: ${result.deleted.length}`);
-    console.log(`  Unchanged: ${result.unchanged.length}`);
-    console.log(`  Errors: ${result.errors.length}`);
-    console.log(`  Duration: ${result.stats.duration}ms`);
-    console.log(`  Transferred: ${formatBytes2(result.stats.bytesTransferred)}`);
-  }
-  return result;
-}
-function formatBytes2(bytes) {
-  if (bytes === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
-}
-function registerTailscaleSyncCommand(program) {
-  program.command("tailscale-sync").alias("ts-sync").description("Sync vault with a peer on the Tailscale network").requiredOption("--peer <hostname>", "Peer hostname or IP to sync with").option("-v, --vault <path>", "Vault path").option("--port <number>", "Port on the peer", parseInt).option("--direction <dir>", "Sync direction: push, pull, or bidirectional", "bidirectional").option("--dry-run", "Show what would be synced without making changes").option("--delete-orphans", "Delete files that exist locally but not on peer (pull only)").option("--categories <list>", "Comma-separated list of categories to sync").option("--https", "Use HTTPS for connection").option("--json", "Output as JSON").action(async (rawOptions) => {
-    await tailscaleSyncCommand({
-      peer: rawOptions.peer,
-      vaultPath: rawOptions.vault,
-      port: rawOptions.port,
-      direction: rawOptions.direction,
-      dryRun: rawOptions.dryRun,
-      deleteOrphans: rawOptions.deleteOrphans,
-      categories: rawOptions.categories?.split(",").map((c) => c.trim()),
-      https: rawOptions.https,
-      json: rawOptions.json
-    });
-  });
-}
-var activeServeInstance = null;
-async function tailscaleServeCommand(options) {
-  if (options.stop) {
-    if (activeServeInstance) {
-      await activeServeInstance.stop();
-      activeServeInstance = null;
-      console.log("ClawVault serve stopped.");
-    }
-    stopTailscaleServe();
-    return;
-  }
-  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
-  const port = options.port || DEFAULT_SERVE_PORT;
-  const status = getTailscaleStatus();
-  console.log(`Starting ClawVault serve...`);
-  console.log(`  Vault: ${path25.basename(vaultPath)}`);
-  console.log(`  Port: ${port}`);
-  activeServeInstance = serveVault(vaultPath, { port });
-  console.log(`  Local URL: http://localhost:${port}/.clawvault`);
-  if (status.connected) {
-    console.log(`  Tailscale URL: http://${status.selfIP}:${port}/.clawvault`);
-    if (status.selfDNSName) {
-      const dnsHost = status.selfDNSName.replace(/\.$/, "");
-      console.log(`  MagicDNS URL: http://${dnsHost}:${port}/.clawvault`);
-    }
-    if (options.funnel || options.background) {
-      console.log("\nConfiguring Tailscale serve...");
-      configureTailscaleServe(port, {
-        funnel: options.funnel,
-        background: options.background
-      });
-      if (options.funnel) {
-        console.log("  Funnel enabled - vault is accessible from the public internet");
-      }
-    }
-  } else {
-    console.log("\n  Note: Not connected to Tailscale. Only local access available.");
-  }
-  console.log("\nEndpoints:");
-  console.log(`  Health: /.clawvault/health`);
-  console.log(`  Manifest: /.clawvault/manifest`);
-  console.log(`  Files: /.clawvault/files/<path>`);
-  if (!options.background) {
-    console.log("\nPress Ctrl+C to stop serving.");
-    process.on("SIGINT", async () => {
-      console.log("\nStopping ClawVault serve...");
-      if (activeServeInstance) {
-        await activeServeInstance.stop();
-        activeServeInstance = null;
-      }
-      stopTailscaleServe();
-      process.exit(0);
-    });
-    await new Promise(() => {
-    });
-  }
-}
-function registerTailscaleServeCommand(program) {
-  program.command("tailscale-serve").alias("ts-serve").description("Serve vault for sync over Tailscale").option("-v, --vault <path>", "Vault path").option("--port <number>", `Port to serve on (default: ${DEFAULT_SERVE_PORT})`, parseInt).option("--funnel", "Expose via Tailscale Funnel (public internet)").option("--background", "Run in background").option("--stop", "Stop serving").action(async (rawOptions) => {
-    await tailscaleServeCommand({
-      vaultPath: rawOptions.vault,
-      port: rawOptions.port,
-      funnel: rawOptions.funnel,
-      background: rawOptions.background,
-      stop: rawOptions.stop
-    });
-  });
-}
-async function tailscaleDiscoverCommand(options = {}) {
-  const port = options.port || DEFAULT_SERVE_PORT;
-  const status = getTailscaleStatus();
-  if (!status.connected) {
-    if (options.json) {
-      console.log(JSON.stringify({ error: "Not connected to Tailscale", peers: [] }));
-    } else {
-      console.error("Error: Not connected to Tailscale");
-    }
-    return [];
-  }
-  if (!options.json) {
-    console.log("Discovering ClawVault peers on tailnet...");
-  }
-  const peers = await discoverClawVaultPeers(port);
-  if (options.json) {
-    console.log(JSON.stringify({ peers }, null, 2));
-  } else {
-    if (peers.length === 0) {
-      console.log("\nNo ClawVault peers found.");
-      console.log("  Run `clawvault tailscale-serve` on other devices to enable sync.");
-    } else {
-      console.log(`
-Found ${peers.length} ClawVault peer(s):`);
-      for (const peer of peers) {
-        const ip = peer.tailscaleIPs[0] || "no-ip";
-        const os4 = peer.os ? ` (${peer.os})` : "";
-        console.log(`  \u25CF ${peer.hostname}${os4}`);
-        console.log(`    IP: ${ip}`);
-        console.log(`    Port: ${peer.clawvaultPort}`);
-        if (peer.dnsName) {
-          console.log(`    DNS: ${peer.dnsName.replace(/\.$/, "")}`);
-        }
-      }
-    }
-  }
-  return peers;
-}
-function registerTailscaleDiscoverCommand(program) {
-  program.command("tailscale-discover").alias("ts-discover").description("Discover ClawVault peers on the Tailscale network").option("--port <number>", `Port to check (default: ${DEFAULT_SERVE_PORT})`, parseInt).option("--json", "Output as JSON").action(async (rawOptions) => {
-    await tailscaleDiscoverCommand({
-      port: rawOptions.port,
-      json: rawOptions.json
-    });
-  });
-}
-function registerTailscaleCommands(program) {
-  registerTailscaleStatusCommand(program);
-  registerTailscaleSyncCommand(program);
-  registerTailscaleServeCommand(program);
-  registerTailscaleDiscoverCommand(program);
-}
-
-// src/cli/index.ts
-function registerCliCommands(program) {
-  registerContextCommand(program);
-  registerInjectCommand(program);
-  registerObserveCommand(program);
-  registerReflectCommand(program);
-  registerEmbedCommand(program);
-  registerReweaveCommand(program);
-  registerTailscaleCommands(program);
-  return program;
-}
-
-// src/commands/setup.ts
-var fs26 = __toESM(require("fs"), 1);
-var os2 = __toESM(require("os"), 1);
-var path26 = __toESM(require("path"), 1);
-var import_child_process5 = require("child_process");
-var import_gray_matter7 = __toESM(require("gray-matter"), 1);
-var CONFIG_FILE4 = ".clawvault.json";
-function resolveVaultTarget(vaultOverride) {
-  if (vaultOverride) {
-    const vaultPath = path26.resolve(vaultOverride);
-    return { vaultPath, source: "--vault flag", existed: fs26.existsSync(vaultPath) };
-  }
-  const envPath = process.env.CLAWVAULT_PATH?.trim();
-  const home = os2.homedir();
-  if (envPath) {
-    const vaultPath = path26.resolve(envPath);
-    return { vaultPath, source: "CLAWVAULT_PATH", existed: fs26.existsSync(vaultPath) };
-  }
-  const candidates = [
-    { vaultPath: path26.join(home, ".openclaw", "workspace", "memory"), source: "OpenClaw default" },
-    { vaultPath: path26.resolve(process.cwd(), "memory"), source: "./memory" },
-    { vaultPath: path26.join(home, "memory"), source: "~/memory" }
-  ];
-  for (const candidate of candidates) {
-    if (fs26.existsSync(candidate.vaultPath)) {
-      return { ...candidate, existed: true };
-    }
-  }
-  const fallback = candidates[0];
-  return { ...fallback, existed: false };
-}
-function ensureVaultStructure(vaultPath) {
-  fs26.mkdirSync(vaultPath, { recursive: true });
-  for (const category of DEFAULT_CATEGORIES) {
-    fs26.mkdirSync(path26.join(vaultPath, category), { recursive: true });
-  }
-  const configPath = path26.join(vaultPath, CONFIG_FILE4);
-  if (fs26.existsSync(configPath)) return false;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const name = path26.basename(vaultPath);
-  const meta = {
-    name,
-    version: "1.0.0",
-    created: now,
-    lastUpdated: now,
-    categories: DEFAULT_CATEGORIES,
-    documentCount: 0,
-    qmdCollection: name,
-    qmdRoot: vaultPath
-  };
-  fs26.writeFileSync(configPath, JSON.stringify(meta, null, 2));
-  return true;
-}
-function writeBases(vaultPath, force) {
-  const basesFiles = {
-    "all-tasks.base": `filters:
-  and:
-    - file.inFolder("tasks")
-    - status != "done"
-formulas:
-  age: (now() - file.ctime).days
-  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", if(status == "open", "\u26AA", "\u2705")))
-views:
-  - type: table
-    name: All Active Tasks
-    groupBy:
-      property: status
-      direction: ASC
-    order:
-      - formula.status_icon
-      - file.name
-      - status
-      - owner
-      - project
-      - priority
-      - blocked_by
-      - formula.age
-  - type: cards
-    name: Task Board
-    groupBy:
-      property: status
-      direction: ASC
-    order:
-      - file.name
-      - owner
-      - project
-      - priority`,
-    "blocked.base": `filters:
-  and:
-    - file.inFolder("tasks")
-    - status == "blocked"
-formulas:
-  days_blocked: (now() - file.ctime).days
-views:
-  - type: table
-    name: Blocked Tasks
-    order:
-      - file.name
-      - owner
-      - project
-      - blocked_by
-      - formula.days_blocked
-      - priority`,
-    "by-project.base": `filters:
-  and:
-    - file.inFolder("tasks")
-    - status != "done"
-formulas:
-  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", "\u26AA"))
-views:
-  - type: table
-    name: By Project
-    groupBy:
-      property: project
-      direction: ASC
-    order:
-      - formula.status_icon
-      - file.name
-      - status
-      - owner
-      - priority
-  - type: cards
-    name: Project Cards
-    groupBy:
-      property: project
-      direction: ASC
-    order:
-      - file.name
-      - owner
-      - status`,
-    "by-owner.base": `filters:
-  and:
-    - file.inFolder("tasks")
-    - status != "done"
-views:
-  - type: table
-    name: By Owner
-    groupBy:
-      property: owner
-      direction: ASC
-    order:
-      - file.name
-      - status
-      - project
-      - priority`,
-    "backlog.base": `filters:
-  and:
-    - file.inFolder("backlog")
-views:
-  - type: table
-    name: Backlog
-    order:
-      - file.name
-      - source
-      - project
-      - file.ctime`
-  };
-  let written = 0;
-  for (const [filename, content] of Object.entries(basesFiles)) {
-    const filePath = path26.join(vaultPath, filename);
-    if (force || !fs26.existsSync(filePath)) {
-      fs26.writeFileSync(filePath, content);
-      written++;
-    }
-  }
-  return written;
-}
-var NEURAL_GRAPH_CSS = `/* ClawVault Graph Colors \u2014 Neural Neural Style */
-/* Auto-generated by \`clawvault setup --theme neural\` */
-
-body.theme-dark .graph-view .graph-view-container { background-color: #0a0a0a; }
-
-body.theme-dark .graph-view .node.tag-person circle { fill: #00b4d8 !important; }
-body.theme-dark .graph-view .node.tag-project circle { fill: #2d6a4f !important; }
-body.theme-dark .graph-view .node.tag-decision circle { fill: #e8590c !important; }
-body.theme-dark .graph-view .node.tag-lesson circle { fill: #fcc419 !important; }
-body.theme-dark .graph-view .node.tag-commitment circle { fill: #e03131 !important; }
-body.theme-dark .graph-view .node.tag-task circle { fill: #22b8cf !important; }
-body.theme-dark .graph-view .node.tag-observation circle { fill: #7950f2 !important; }
-body.theme-dark .graph-view .node.tag-handoff circle { fill: #845ef7 !important; }
-body.theme-dark .graph-view .node.tag-daily circle { fill: #495057 !important; }
-
-body.theme-dark .graph-view .node.is-focused circle {
-  fill: #e8a430 !important; stroke: #e8a430 !important;
-  stroke-width: 3px; filter: drop-shadow(0 0 6px #e8a430);
-}
-
-body.theme-dark .graph-view .link { stroke: rgba(45, 200, 120, 0.15) !important; }
-body.theme-dark .graph-view .link.is-focused { stroke: rgba(45, 200, 120, 0.6) !important; }
-body.theme-dark .graph-view .node text { fill: #c1c2c5 !important; font-size: 0.8em; }
-`;
-var MINIMAL_GRAPH_CSS = `/* ClawVault Graph Colors \u2014 Minimal */
-/* Auto-generated by \`clawvault setup --theme minimal\` */
-
-body.theme-dark .graph-view .node.tag-person circle { fill: #4a90e8 !important; }
-body.theme-dark .graph-view .node.tag-project circle { fill: #4ae85d !important; }
-body.theme-dark .graph-view .node.tag-decision circle { fill: #e85d4a !important; }
-body.theme-dark .graph-view .node.tag-lesson circle { fill: #9b59b6 !important; }
-body.theme-dark .graph-view .node.tag-task circle { fill: #e8a430 !important; }
-`;
-var NEURAL_COLOR_GROUPS = [
-  { query: "path:people", color: { a: 1, rgb: 47316 } },
-  { query: "path:projects", color: { a: 1, rgb: 2976335 } },
-  { query: "path:decisions", color: { a: 1, rgb: 15227916 } },
-  { query: "path:lessons", color: { a: 1, rgb: 16565273 } },
-  { query: "path:tasks", color: { a: 1, rgb: 2275535 } },
-  { query: "path:commitments", color: { a: 1, rgb: 14680369 } },
-  { query: "path:backlog", color: { a: 1, rgb: 9806262 } },
-  { query: "path:inbox", color: { a: 1, rgb: 15964178 } },
-  { query: "path:handoffs", color: { a: 1, rgb: 8675063 } },
-  { query: "path:ledger", color: { a: 1, rgb: 7950066 } }
-];
-var MINIMAL_COLOR_GROUPS = [
-  { query: "path:people", color: { a: 1, rgb: 4886760 } },
-  { query: "path:projects", color: { a: 1, rgb: 4909149 } },
-  { query: "path:decisions", color: { a: 1, rgb: 15228234 } },
-  { query: "path:lessons", color: { a: 1, rgb: 10181046 } },
-  { query: "path:tasks", color: { a: 1, rgb: 15246384 } }
-];
-function writeGraphColors(vaultPath, theme, force) {
-  const obsidianDir = path26.join(vaultPath, ".obsidian");
-  if (!fs26.existsSync(obsidianDir)) {
-    return false;
-  }
-  const snippetsDir = path26.join(obsidianDir, "snippets");
-  fs26.mkdirSync(snippetsDir, { recursive: true });
-  const snippetName = "clawvault-graph";
-  const snippetPath = path26.join(snippetsDir, `${snippetName}.css`);
-  if (!force && fs26.existsSync(snippetPath)) {
-    return false;
-  }
-  const css = theme === "neural" ? NEURAL_GRAPH_CSS : MINIMAL_GRAPH_CSS;
-  fs26.writeFileSync(snippetPath, css);
-  const appearancePath = path26.join(obsidianDir, "appearance.json");
-  let appearance = {};
-  if (fs26.existsSync(appearancePath)) {
-    try {
-      appearance = JSON.parse(fs26.readFileSync(appearancePath, "utf-8"));
-    } catch {
-    }
-  }
-  const snippets = appearance.enabledCssSnippets || [];
-  if (!snippets.includes(snippetName)) {
-    snippets.push(snippetName);
-    appearance.enabledCssSnippets = snippets;
-    fs26.writeFileSync(appearancePath, JSON.stringify(appearance, null, 2));
-  }
-  const graphPath = path26.join(obsidianDir, "graph.json");
-  let graphConfig = {};
-  if (fs26.existsSync(graphPath)) {
-    try {
-      graphConfig = JSON.parse(fs26.readFileSync(graphPath, "utf-8"));
-    } catch {
-    }
-  }
-  graphConfig.colorGroups = theme === "neural" ? NEURAL_COLOR_GROUPS : MINIMAL_COLOR_GROUPS;
-  if (theme === "neural") {
-    graphConfig.showTags = false;
-    graphConfig.showAttachments = false;
-    graphConfig.nodeSizeMultiplier = 1.2;
-    graphConfig.lineSizeMultiplier = 0.8;
-    graphConfig.textFadeMultiplier = 0;
-    graphConfig.repelStrength = 10;
-    graphConfig.linkDistance = 250;
-    graphConfig.centerStrength = 0.5;
-  }
-  fs26.writeFileSync(graphPath, JSON.stringify(graphConfig, null, 2));
-  return true;
-}
-function getQmdConfig(vaultPath) {
-  const configPath = path26.join(vaultPath, CONFIG_FILE4);
-  if (fs26.existsSync(configPath)) {
-    try {
-      const meta = JSON.parse(fs26.readFileSync(configPath, "utf-8"));
-      return {
-        collection: meta.qmdCollection || meta.name || path26.basename(vaultPath),
-        root: meta.qmdRoot || vaultPath
-      };
-    } catch {
-      return { collection: path26.basename(vaultPath), root: vaultPath };
-    }
-  }
-  return { collection: path26.basename(vaultPath), root: vaultPath };
-}
-function slugify2(text) {
-  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
-}
-function scanMarkdownFiles(dirPath) {
-  const files = [];
-  const resolvedPath = path26.resolve(dirPath);
-  if (!fs26.existsSync(resolvedPath)) {
-    return files;
-  }
-  const stat = fs26.statSync(resolvedPath);
-  if (stat.isFile() && resolvedPath.endsWith(".md")) {
-    return [resolvedPath];
-  }
-  if (!stat.isDirectory()) {
-    return files;
-  }
-  const entries = fs26.readdirSync(resolvedPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path26.join(resolvedPath, entry.name);
-    if (entry.isFile() && entry.name.endsWith(".md")) {
-      files.push(fullPath);
-    } else if (entry.isDirectory()) {
-      files.push(...scanMarkdownFiles(fullPath));
-    }
-  }
-  return files;
-}
-function extractPeople(content) {
-  const people = [];
-  const seenNames = /* @__PURE__ */ new Set();
-  const emailPattern = /([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\s*<([^>]+@[^>]+)>/g;
-  let match;
-  while ((match = emailPattern.exec(content)) !== null) {
-    const name = match[1].trim();
-    const email = match[2].trim();
-    if (!seenNames.has(name.toLowerCase())) {
-      seenNames.add(name.toLowerCase());
-      people.push({ name, email });
-    }
-  }
-  const rolePatterns = [
-    /([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\s*\(([^)]+)\)/g,
-    /([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+),\s*(CEO|CTO|CFO|COO|VP|Director|Manager|Engineer|Designer|Lead|Head of [A-Za-z]+)/gi
-  ];
-  for (const pattern of rolePatterns) {
-    while ((match = pattern.exec(content)) !== null) {
-      const name = match[1].trim();
-      const role = match[2].trim();
-      if (!seenNames.has(name.toLowerCase())) {
-        seenNames.add(name.toLowerCase());
-        people.push({ name, role });
-      }
-    }
-  }
-  const contextPatterns = [
-    /(?:contact|met with|spoke with|emailed|called|messaged|talked to|meeting with)\s+([A-Z][a-zA-Z]*(?:\s+[A-Z][a-zA-Z]*)+)/g,
-    /([A-Z][a-zA-Z]*(?:\s+[A-Z][a-zA-Z]*)+)\s+(?:said|mentioned|suggested|recommended|asked|told me)/g
-  ];
-  for (const pattern of contextPatterns) {
-    while ((match = pattern.exec(content)) !== null) {
-      const name = match[1].trim();
-      if (!seenNames.has(name.toLowerCase()) && name.split(" ").length >= 2) {
-        seenNames.add(name.toLowerCase());
-        const lineStart = content.lastIndexOf("\n", match.index) + 1;
-        const lineEnd = content.indexOf("\n", match.index + match[0].length);
-        const context = content.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd).trim();
-        people.push({ name, context: context.slice(0, 200) });
-      }
-    }
-  }
-  return people;
-}
-function extractPreferences2(content) {
-  const preferences = [];
-  const seenPrefs = /* @__PURE__ */ new Set();
-  const patterns = [
-    // "prefers X" / "prefer X" / "I prefer X"
-    /(?:I\s+)?prefer(?:s)?\s+(?:to\s+)?([^.,\n]+)/gi,
-    // "likes X" / "like X"
-    /(?:I\s+)?like(?:s)?\s+(?:to\s+)?([^.,\n]+)/gi,
-    // "always use X"
-    /always\s+(?:use|uses?)\s+([^.,\n]+)/gi,
-    // "never use X"
-    /never\s+(?:use|uses?)\s+([^.,\n]+)/gi,
-    // "favorite X is Y"
-    /(?:my\s+)?favorite\s+(\w+)\s+is\s+([^.,\n]+)/gi,
-    // "prefer X over Y"
-    /prefer(?:s)?\s+([^.,\n]+)\s+over\s+([^.,\n]+)/gi,
-    // "use X instead of Y"
-    /use(?:s)?\s+([^.,\n]+)\s+instead\s+of\s+([^.,\n]+)/gi
-  ];
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      const fullMatch = match[0].trim();
-      const key = fullMatch.toLowerCase();
-      if (!seenPrefs.has(key) && fullMatch.length > 5 && fullMatch.length < 200) {
-        seenPrefs.add(key);
-        const lineStart = content.lastIndexOf("\n", match.index) + 1;
-        const lineEnd = content.indexOf("\n", match.index + match[0].length);
-        const context = content.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd).trim();
-        let subject = "general";
-        let preference = fullMatch;
-        if (match[2]) {
-          subject = match[1].trim();
-          preference = match[2].trim();
-        } else if (match[1]) {
-          preference = match[1].trim();
-        }
-        preferences.push({ subject, preference, context: context.slice(0, 200) });
-      }
-    }
-  }
-  return preferences;
-}
-function extractDecisions(content) {
-  const decisions = [];
-  const seenDecisions = /* @__PURE__ */ new Set();
-  const patterns = [
-    // "decided to X"
-    /(?:I\s+|we\s+)?decided\s+(?:to\s+)?([^.,\n]+)/gi,
-    // "decision: X" or "Decision - X"
-    /decision[:\s-]+([^.,\n]+)/gi,
-    // "we chose X" / "chose to X"
-    /(?:we\s+)?chose\s+(?:to\s+)?([^.,\n]+)/gi,
-    // "going with X"
-    /going\s+with\s+([^.,\n]+)/gi,
-    // "settled on X"
-    /settled\s+on\s+([^.,\n]+)/gi,
-    // "will use X" / "using X going forward"
-    /(?:will\s+use|using)\s+([^.,\n]+)\s+(?:going\s+forward|from\s+now\s+on)/gi
-  ];
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      const decision = match[1].trim();
-      const key = decision.toLowerCase();
-      if (!seenDecisions.has(key) && decision.length > 5 && decision.length < 200) {
-        seenDecisions.add(key);
-        const lineStart = content.lastIndexOf("\n", match.index) + 1;
-        const lineEnd = content.indexOf("\n", match.index + match[0].length);
-        const context = content.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd).trim();
-        const title = decision.length > 50 ? decision.slice(0, 50).trim() + "..." : decision;
-        decisions.push({ title, decision, context: context.slice(0, 200) });
-      }
+  const graphPath = path23.join(obsidianDir, "graph.json");
+  let graphConfig = {};
+  if (fs24.existsSync(graphPath)) {
+    try {
+      graphConfig = JSON.parse(fs24.readFileSync(graphPath, "utf-8"));
+    } catch {
     }
   }
-  return decisions;
-}
-function extractTasks(content) {
-  const tasks = [];
-  const seenTasks = /* @__PURE__ */ new Set();
-  const patterns = [
-    // Markdown checkbox "- [ ] task"
-    /^[\s]*[-*]\s*\[\s*\]\s*(.+)$/gm,
-    // "TODO: task" or "TODO - task"
-    /TODO[:\s-]+(.+)/gi,
-    // "FIXME: task"
-    /FIXME[:\s-]+(.+)/gi,
-    // "need to X"
-    /(?:I\s+|we\s+)?need\s+to\s+([^.,\n]+)/gi,
-    // "should X" (but not "should have" which is past)
-    /(?:I\s+|we\s+)?should\s+(?!have)([^.,\n]+)/gi,
-    // "must X"
-    /(?:I\s+|we\s+)?must\s+([^.,\n]+)/gi,
-    // "remember to X"
-    /remember\s+to\s+([^.,\n]+)/gi,
-    // "don't forget to X"
-    /don'?t\s+forget\s+to\s+([^.,\n]+)/gi
-  ];
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      const taskText = match[1].trim();
-      const key = taskText.toLowerCase();
-      if (!seenTasks.has(key) && taskText.length > 3 && taskText.length < 200) {
-        seenTasks.add(key);
-        let priority = "medium";
-        const lowerTask = taskText.toLowerCase();
-        if (lowerTask.includes("urgent") || lowerTask.includes("asap") || lowerTask.includes("critical")) {
-          priority = "critical";
-        } else if (lowerTask.includes("important") || lowerTask.includes("high priority")) {
-          priority = "high";
-        } else if (lowerTask.includes("low priority") || lowerTask.includes("eventually") || lowerTask.includes("someday")) {
-          priority = "low";
-        }
-        tasks.push({ title: taskText, priority });
-      }
-    }
+  graphConfig.colorGroups = theme === "neural" ? NEURAL_COLOR_GROUPS : MINIMAL_COLOR_GROUPS;
+  if (theme === "neural") {
+    graphConfig.showTags = false;
+    graphConfig.showAttachments = false;
+    graphConfig.nodeSizeMultiplier = 1.2;
+    graphConfig.lineSizeMultiplier = 0.8;
+    graphConfig.textFadeMultiplier = 0;
+    graphConfig.repelStrength = 10;
+    graphConfig.linkDistance = 250;
+    graphConfig.centerStrength = 0.5;
   }
-  return tasks;
-}
-function extractFromContent(content) {
-  return {
-    people: extractPeople(content),
-    preferences: extractPreferences2(content),
-    decisions: extractDecisions(content),
-    tasks: extractTasks(content)
-  };
+  fs24.writeFileSync(graphPath, JSON.stringify(graphConfig, null, 2));
+  return true;
 }
-function scanAndExtract(sourcePath) {
-  const files = scanMarkdownFiles(sourcePath);
-  const combined = {
-    people: [],
-    preferences: [],
-    decisions: [],
-    tasks: []
-  };
-  for (const file of files) {
+function getQmdConfig(vaultPath) {
+  const configPath = path23.join(vaultPath, CONFIG_FILE4);
+  if (fs24.existsSync(configPath)) {
     try {
-      const content = fs26.readFileSync(file, "utf-8");
-      const extracted = extractFromContent(content);
-      combined.people.push(...extracted.people);
-      combined.preferences.push(...extracted.preferences);
-      combined.decisions.push(...extracted.decisions);
-      combined.tasks.push(...extracted.tasks);
+      const meta = JSON.parse(fs24.readFileSync(configPath, "utf-8"));
+      return {
+        collection: meta.qmdCollection || meta.name || path23.basename(vaultPath),
+        root: meta.qmdRoot || vaultPath
+      };
     } catch {
+      return { collection: path23.basename(vaultPath), root: vaultPath };
     }
   }
-  const seenPeople = /* @__PURE__ */ new Set();
-  combined.people = combined.people.filter((p) => {
-    const key = p.name.toLowerCase();
-    if (seenPeople.has(key)) return false;
-    seenPeople.add(key);
-    return true;
-  });
-  const seenPrefs = /* @__PURE__ */ new Set();
-  combined.preferences = combined.preferences.filter((p) => {
-    const key = `${p.subject}:${p.preference}`.toLowerCase();
-    if (seenPrefs.has(key)) return false;
-    seenPrefs.add(key);
-    return true;
-  });
-  const seenDecisions = /* @__PURE__ */ new Set();
-  combined.decisions = combined.decisions.filter((d) => {
-    const key = d.decision.toLowerCase();
-    if (seenDecisions.has(key)) return false;
-    seenDecisions.add(key);
-    return true;
-  });
-  const seenTasks = /* @__PURE__ */ new Set();
-  combined.tasks = combined.tasks.filter((t) => {
-    const key = t.title.toLowerCase();
-    if (seenTasks.has(key)) return false;
-    seenTasks.add(key);
-    return true;
-  });
-  return combined;
-}
-function fileExistsWithSimilarName(dir, slug) {
-  if (!fs26.existsSync(dir)) return false;
-  const files = fs26.readdirSync(dir);
-  const targetSlug = slug.toLowerCase();
-  return files.some((f) => {
-    const fileSlug = path26.basename(f, ".md").toLowerCase();
-    return fileSlug === targetSlug || fileSlug.includes(targetSlug) || targetSlug.includes(fileSlug);
-  });
-}
-function writePerson(vaultPath, person, force) {
-  const peopleDir = path26.join(vaultPath, "people");
-  fs26.mkdirSync(peopleDir, { recursive: true });
-  const slug = slugify2(person.name);
-  if (!slug) return null;
-  const filePath = path26.join(peopleDir, `${slug}.md`);
-  if (!force && (fs26.existsSync(filePath) || fileExistsWithSimilarName(peopleDir, slug))) {
-    return null;
-  }
-  const template = loadTemplateDefinition("person");
-  const now = /* @__PURE__ */ new Date();
-  const date = now.toISOString().split("T")[0];
-  let content;
-  if (template) {
-    const rendered = renderDocumentFromTemplate(template, {
-      title: person.name,
-      now,
-      overrides: {
-        relationship: person.role ? "colleague" : "contact"
-      }
-    });
-    let body = rendered.content;
-    if (person.context) {
-      body = body.replace(/## Context\n-\s*/, `## Context
-- ${person.context}
-`);
-    }
-    if (person.email || person.role) {
-      const details = [];
-      if (person.email) details.push(`- Contact: ${person.email}`);
-      if (person.role) details.push(`- Role: ${person.role}`);
-      body = body.replace(/## Details\n- Contact:\n- Role:\n- Timezone:/, `## Details
-${details.join("\n")}
-- Timezone:`);
-    }
-    content = import_gray_matter7.default.stringify(body, rendered.frontmatter);
-  } else {
-    const frontmatter = {
-      title: person.name,
-      date,
-      type: "person",
-      relationship: person.role ? "colleague" : "contact"
-    };
-    let body = `# ${person.name}
-
-## Context
-`;
-    if (person.context) body += `- ${person.context}
-`;
-    else body += "- \n";
-    body += "\n## Details\n";
-    if (person.email) body += `- Contact: ${person.email}
-`;
-    else body += "- Contact:\n";
-    if (person.role) body += `- Role: ${person.role}
-`;
-    else body += "- Role:\n";
-    body += "- Timezone:\n";
-    body += `
-## History
-- ${date}: Added from memory import
-`;
-    content = import_gray_matter7.default.stringify(body, frontmatter);
-  }
-  fs26.writeFileSync(filePath, content);
-  return slug;
-}
-function writePreference(vaultPath, pref, force) {
-  const prefsDir = path26.join(vaultPath, "preferences");
-  fs26.mkdirSync(prefsDir, { recursive: true });
-  const slug = slugify2(`${pref.subject}-${pref.preference}`.slice(0, 60));
-  if (!slug) return null;
-  const filePath = path26.join(prefsDir, `${slug}.md`);
-  if (!force && (fs26.existsSync(filePath) || fileExistsWithSimilarName(prefsDir, slug))) {
-    return null;
-  }
-  const now = /* @__PURE__ */ new Date();
-  const date = now.toISOString().split("T")[0];
-  const frontmatter = {
-    title: `${pref.subject}: ${pref.preference}`.slice(0, 100),
-    date,
-    type: "preference",
-    category: pref.subject
-  };
-  let body = `# ${frontmatter.title}
-
-`;
-  body += `## Preference
-- ${pref.preference}
-`;
-  if (pref.context) {
-    body += `
-## Context
-- ${pref.context}
-`;
-  }
-  body += `
-## Source
-- Imported from memory on ${date}
-`;
-  const content = import_gray_matter7.default.stringify(body, frontmatter);
-  fs26.writeFileSync(filePath, content);
-  return slug;
-}
-function writeDecision(vaultPath, decision, force) {
-  const decisionsDir = path26.join(vaultPath, "decisions");
-  fs26.mkdirSync(decisionsDir, { recursive: true });
-  const slug = slugify2(decision.title);
-  if (!slug) return null;
-  const filePath = path26.join(decisionsDir, `${slug}.md`);
-  if (!force && (fs26.existsSync(filePath) || fileExistsWithSimilarName(decisionsDir, slug))) {
-    return null;
-  }
-  const template = loadTemplateDefinition("decision");
-  const now = /* @__PURE__ */ new Date();
-  const date = now.toISOString().split("T")[0];
-  let content;
-  if (template) {
-    const rendered = renderDocumentFromTemplate(template, {
-      title: decision.title,
-      now,
-      overrides: {
-        status: "decided"
-      }
-    });
-    let body = rendered.content;
-    if (decision.context) {
-      body = body.replace(/## Context\n-\s*/, `## Context
-- ${decision.context}
-`);
-    }
-    body = body.replace(/## Decision\n-\s*/, `## Decision
-- ${decision.decision}
-`);
-    body = body.replace(/## Consequences\n-\s*/, `## Consequences
-- Imported from memory on ${date}
-`);
-    content = import_gray_matter7.default.stringify(body, rendered.frontmatter);
-  } else {
-    const frontmatter = {
-      title: decision.title,
-      date,
-      type: "decision",
-      status: "decided"
-    };
-    let body = `# Decision: ${decision.title}
-
-`;
-    body += `## Context
-`;
-    if (decision.context) body += `- ${decision.context}
-`;
-    else body += "- \n";
-    body += `
-## Decision
-- ${decision.decision}
-`;
-    body += `
-## Consequences
-- Imported from memory on ${date}
-`;
-    content = import_gray_matter7.default.stringify(body, frontmatter);
-  }
-  fs26.writeFileSync(filePath, content);
-  return slug;
-}
-function writeTask(vaultPath, task, force) {
-  const tasksDir = path26.join(vaultPath, "tasks");
-  fs26.mkdirSync(tasksDir, { recursive: true });
-  const slug = slugify2(task.title);
-  if (!slug) return null;
-  const filePath = path26.join(tasksDir, `${slug}.md`);
-  if (!force && (fs26.existsSync(filePath) || fileExistsWithSimilarName(tasksDir, slug))) {
-    return null;
-  }
-  const template = loadTemplateDefinition("task");
-  const now = /* @__PURE__ */ new Date();
-  const datetime = now.toISOString();
-  let content;
-  if (template) {
-    const rendered = renderDocumentFromTemplate(template, {
-      title: task.title,
-      now,
-      overrides: {
-        status: "open",
-        priority: task.priority || "medium",
-        source: "memory-import",
-        description: task.description
-      },
-      frontmatter: { pruneEmpty: true }
-    });
-    content = rendered.markdown;
-  } else {
-    const frontmatter = {
-      status: "open",
-      source: "memory-import",
-      created: datetime,
-      updated: datetime,
-      priority: task.priority || "medium"
-    };
-    if (task.description) frontmatter.description = task.description;
-    const body = `# ${task.title}
-
-`;
-    content = import_gray_matter7.default.stringify(body, frontmatter);
-  }
-  fs26.writeFileSync(filePath, content);
-  return slug;
-}
-function importToVault(vaultPath, extracted, force) {
-  const summary = {
-    created: { people: [], preferences: [], decisions: [], tasks: [] },
-    skipped: { people: [], preferences: [], decisions: [], tasks: [] }
-  };
-  for (const person of extracted.people) {
-    const slug = writePerson(vaultPath, person, force);
-    if (slug) {
-      summary.created.people.push(person.name);
-    } else {
-      summary.skipped.people.push(person.name);
-    }
-  }
-  for (const pref of extracted.preferences) {
-    const slug = writePreference(vaultPath, pref, force);
-    if (slug) {
-      summary.created.preferences.push(`${pref.subject}: ${pref.preference}`.slice(0, 50));
-    } else {
-      summary.skipped.preferences.push(`${pref.subject}: ${pref.preference}`.slice(0, 50));
-    }
-  }
-  for (const decision of extracted.decisions) {
-    const slug = writeDecision(vaultPath, decision, force);
-    if (slug) {
-      summary.created.decisions.push(decision.title);
-    } else {
-      summary.skipped.decisions.push(decision.title);
-    }
-  }
-  for (const task of extracted.tasks) {
-    const slug = writeTask(vaultPath, task, force);
-    if (slug) {
-      summary.created.tasks.push(task.title);
-    } else {
-      summary.skipped.tasks.push(task.title);
-    }
-  }
-  return summary;
-}
-function printImportSummary(summary) {
-  const totalCreated = summary.created.people.length + summary.created.preferences.length + summary.created.decisions.length + summary.created.tasks.length;
-  const totalSkipped = summary.skipped.people.length + summary.skipped.preferences.length + summary.skipped.decisions.length + summary.skipped.tasks.length;
-  console.log("\n\u{1F4E5} Memory Import Summary");
-  console.log("\u2500".repeat(40));
-  if (summary.created.people.length > 0) {
-    console.log(`\u2713 People (${summary.created.people.length}):`);
-    for (const name of summary.created.people.slice(0, 5)) {
-      console.log(`    - ${name}`);
-    }
-    if (summary.created.people.length > 5) {
-      console.log(`    ... and ${summary.created.people.length - 5} more`);
-    }
-  }
-  if (summary.created.preferences.length > 0) {
-    console.log(`\u2713 Preferences (${summary.created.preferences.length}):`);
-    for (const pref of summary.created.preferences.slice(0, 5)) {
-      console.log(`    - ${pref}`);
-    }
-    if (summary.created.preferences.length > 5) {
-      console.log(`    ... and ${summary.created.preferences.length - 5} more`);
-    }
-  }
-  if (summary.created.decisions.length > 0) {
-    console.log(`\u2713 Decisions (${summary.created.decisions.length}):`);
-    for (const dec of summary.created.decisions.slice(0, 5)) {
-      console.log(`    - ${dec}`);
-    }
-    if (summary.created.decisions.length > 5) {
-      console.log(`    ... and ${summary.created.decisions.length - 5} more`);
-    }
-  }
-  if (summary.created.tasks.length > 0) {
-    console.log(`\u2713 Tasks (${summary.created.tasks.length}):`);
-    for (const task of summary.created.tasks.slice(0, 5)) {
-      console.log(`    - ${task}`);
-    }
-    if (summary.created.tasks.length > 5) {
-      console.log(`    ... and ${summary.created.tasks.length - 5} more`);
-    }
-  }
-  if (totalSkipped > 0) {
-    console.log(`
-\u2298 Skipped ${totalSkipped} items (already exist or similar)`);
-  }
-  console.log("\u2500".repeat(40));
-  console.log(`Total: ${totalCreated} created, ${totalSkipped} skipped`);
+  return { collection: path23.basename(vaultPath), root: vaultPath };
 }
 async function setupCommand(options = {}) {
   const target = resolveVaultTarget(options.vault);
-  if (target.existed && !fs26.statSync(target.vaultPath).isDirectory()) {
+  if (target.existed && !fs24.statSync(target.vaultPath).isDirectory()) {
     throw new Error(`Vault path is not a directory: ${target.vaultPath}`);
   }
-  if (!target.existed) fs26.mkdirSync(target.vaultPath, { recursive: true });
+  if (!target.existed) fs24.mkdirSync(target.vaultPath, { recursive: true });
   console.log(`${target.existed ? "Found" : "Created"} vault path (${target.source}): ${target.vaultPath}`);
   const initialized = ensureVaultStructure(target.vaultPath);
   console.log(initialized ? "\u2713 Initialized vault structure." : "\u2713 Vault structure already present.");
   const force = options.force ?? false;
   const theme = options.theme ?? "neural";
-  if (options.from) {
-    const sourcePath = path26.resolve(options.from);
-    if (!fs26.existsSync(sourcePath)) {
-      throw new Error(`Source path does not exist: ${sourcePath}`);
-    }
-    console.log(`
-\u{1F4C2} Scanning source: ${sourcePath}`);
-    const extracted = scanAndExtract(sourcePath);
-    const totalFound = extracted.people.length + extracted.preferences.length + extracted.decisions.length + extracted.tasks.length;
-    if (totalFound === 0) {
-      console.log("\u2298 No structured data found in source files.");
-    } else {
-      console.log(`Found: ${extracted.people.length} people, ${extracted.preferences.length} preferences, ${extracted.decisions.length} decisions, ${extracted.tasks.length} tasks`);
-      const summary = importToVault(target.vaultPath, extracted, force);
-      printImportSummary(summary);
-    }
-  }
   const explicitFlags = options.graphColors !== void 0 || options.bases !== void 0;
-  const fromOnly = options.from && !explicitFlags;
-  const doGraphColors = fromOnly ? false : explicitFlags ? options.graphColors !== false : true;
-  const doBases = fromOnly ? false : explicitFlags ? options.bases !== false : true;
+  const doGraphColors = explicitFlags ? options.graphColors !== false : true;
+  const doBases = explicitFlags ? options.bases !== false : true;
   if (doGraphColors && theme !== "none") {
     const wrote = writeGraphColors(target.vaultPath, theme, force);
     if (wrote) {
       console.log(`\u2713 Graph colors configured (${theme} theme)`);
     } else {
-      const obsidianDir = path26.join(target.vaultPath, ".obsidian");
-      if (!fs26.existsSync(obsidianDir)) {
+      const obsidianDir = path23.join(target.vaultPath, ".obsidian");
+      if (!fs24.existsSync(obsidianDir)) {
         console.log("\u2298 No .obsidian directory \u2014 skipping graph colors (not an Obsidian vault)");
       } else {
         console.log("\u2298 Graph colors already exist (use --force to overwrite)");
@@ -12163,7 +10114,7 @@ async function setupCommand(options = {}) {
   if (hasQmd()) {
     const { collection, root } = getQmdConfig(target.vaultPath);
     try {
-      (0, import_child_process5.execFileSync)("qmd", withQmdIndexArgs(["collection", "add", root, "--name", collection, "--mask", "**/*.md"], options.qmdIndexName), {
+      (0, import_child_process4.execFileSync)("qmd", withQmdIndexArgs(["collection", "add", root, "--name", collection, "--mask", "**/*.md"], options.qmdIndexName), {
         stdio: "ignore"
       });
       console.log(`\u2713 qmd collection ready: ${collection}`);
@@ -12179,82 +10130,52 @@ async function setupCommand(options = {}) {
   console.log("  clawvault setup --theme neural     # Neural neural graph colors");
   console.log("  clawvault setup --theme minimal        # Subtle category colors");
   console.log("  clawvault setup --no-bases --no-graph-colors  # Structure only");
-  console.log("  clawvault setup --from <path>           # Import from existing memory");
   console.log("  clawvault setup --force                 # Overwrite existing configs");
 }
 
 // src/commands/compat.ts
-var fs27 = __toESM(require("fs"), 1);
-var path27 = __toESM(require("path"), 1);
+var fs25 = __toESM(require("fs"), 1);
+var path24 = __toESM(require("path"), 1);
 var import_gray_matter8 = __toESM(require("gray-matter"), 1);
-var import_child_process6 = require("child_process");
+var import_child_process5 = require("child_process");
 var import_url3 = require("url");
 var import_meta3 = {};
-var REQUIRED_HOOK_EVENTS = ["gateway:startup", "command:new", "session:start"];
-var REQUIRED_HOOK_BIN = "clawvault";
 function readOptionalFile(filePath) {
   try {
-    if (!fs27.existsSync(filePath)) return null;
-    return fs27.readFileSync(filePath, "utf-8");
+    if (!fs25.existsSync(filePath)) return null;
+    return fs25.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function findPackageRoot() {
-  let dir = path27.dirname((0, import_url3.fileURLToPath)(import_meta3.url));
-  while (dir !== path27.dirname(dir)) {
-    if (fs27.existsSync(path27.join(dir, "package.json"))) {
+  let dir = path24.dirname((0, import_url3.fileURLToPath)(import_meta3.url));
+  while (dir !== path24.dirname(dir)) {
+    if (fs25.existsSync(path24.join(dir, "package.json"))) {
       return dir;
     }
-    dir = path27.dirname(dir);
-  }
-  return path27.dirname((0, import_url3.fileURLToPath)(import_meta3.url));
-}
-function resolveOpenClawHooksDir() {
-  const candidates = [
-    path27.join(process.env.HOME || "", ".openclaw", "hooks", "clawvault"),
-    path27.join(process.env.OPENCLAW_HOME || "", "hooks", "clawvault"),
-    path27.join(process.env.OPENCLAW_STATE_DIR || "", "hooks", "clawvault")
-  ].filter((p) => p && !p.startsWith(path27.sep + "hooks"));
-  for (const candidate of candidates) {
-    if (fs27.existsSync(candidate)) {
-      return candidate;
-    }
+    dir = path24.dirname(dir);
   }
-  return null;
+  return path24.dirname((0, import_url3.fileURLToPath)(import_meta3.url));
 }
 function resolveProjectFile(relativePath, baseDir) {
   if (baseDir) {
-    return path27.resolve(baseDir, relativePath);
+    return path24.resolve(baseDir, relativePath);
   }
-  const fromCwd = path27.resolve(process.cwd(), relativePath);
-  if (fs27.existsSync(fromCwd)) {
+  const fromCwd = path24.resolve(process.cwd(), relativePath);
+  if (fs25.existsSync(fromCwd)) {
     return fromCwd;
   }
-  if (relativePath.startsWith("hooks/clawvault/")) {
-    const hooksDir = resolveOpenClawHooksDir();
-    if (hooksDir) {
-      const hookRelative = relativePath.replace("hooks/clawvault/", "");
-      const fromHooks = path27.resolve(hooksDir, hookRelative);
-      if (fs27.existsSync(fromHooks)) {
-        return fromHooks;
-      }
-      const fromNestedHooks = path27.resolve(hooksDir, "hooks", "clawvault", hookRelative);
-      if (fs27.existsSync(fromNestedHooks)) {
-        return fromNestedHooks;
-      }
-    }
-  }
-  return path27.resolve(findPackageRoot(), relativePath);
+  return path24.resolve(findPackageRoot(), relativePath);
 }
 function checkOpenClawCli() {
-  const result = (0, import_child_process6.spawnSync)("openclaw", ["--version"], { stdio: "ignore" });
+  const result = (0, import_child_process5.spawnSync)("openclaw", ["--version"], { stdio: "ignore" });
   if (result.error) {
     return {
       label: "openclaw CLI available",
       status: "warn",
       detail: "openclaw binary not found",
-      hint: "Install OpenClaw CLI to enable hook runtime validation."
+      hint: "Install OpenClaw CLI to enable plugin runtime validation."
     };
   }
   if (typeof result.status === "number" && result.status !== 0) {
@@ -12275,152 +10196,106 @@ function checkOpenClawCli() {
   }
   return { label: "openclaw CLI available", status: "ok" };
 }
-function checkPackageHookRegistration(options) {
-  let packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
-  if (packageRaw && !options.baseDir) {
-    try {
-      const parsed = JSON.parse(packageRaw);
-      if (!parsed.openclaw?.hooks) {
-        const fallbackPath = path27.resolve(findPackageRoot(), "package.json");
-        const fallbackRaw = readOptionalFile(fallbackPath);
-        if (fallbackRaw) packageRaw = fallbackRaw;
-      }
-    } catch {
-    }
-  }
-  if (!packageRaw) {
+function checkPluginManifest(options) {
+  const manifestRaw = readOptionalFile(
+    resolveProjectFile("openclaw.plugin.json", options.baseDir)
+  );
+  if (!manifestRaw) {
     return {
-      label: "package hook registration",
+      label: "plugin manifest",
       status: "error",
-      detail: "package.json not found"
+      detail: "openclaw.plugin.json not found",
+      hint: "Create openclaw.plugin.json with id, kind, and configSchema fields."
     };
   }
   try {
-    const parsed = JSON.parse(packageRaw);
-    const registeredHooks = parsed.openclaw?.hooks ?? [];
-    if (registeredHooks.includes("./hooks/clawvault")) {
+    const manifest = JSON.parse(manifestRaw);
+    const issues = [];
+    if (!manifest.id) issues.push("missing id");
+    if (!manifest.kind) issues.push("missing kind");
+    if (!manifest.configSchema) issues.push("missing configSchema");
+    if (issues.length > 0) {
       return {
-        label: "package hook registration",
-        status: "ok",
-        detail: "./hooks/clawvault"
+        label: "plugin manifest",
+        status: "error",
+        detail: issues.join(", ")
       };
     }
     return {
-      label: "package hook registration",
-      status: "error",
-      detail: "Missing ./hooks/clawvault in package openclaw.hooks"
+      label: "plugin manifest",
+      status: "ok",
+      detail: `id=${manifest.id} kind=${manifest.kind}`
     };
   } catch (err) {
     return {
-      label: "package hook registration",
+      label: "plugin manifest",
       status: "error",
-      detail: err?.message || "Unable to parse package.json"
+      detail: err?.message || "Unable to parse openclaw.plugin.json"
     };
   }
 }
-function checkHookManifest(options) {
-  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
-  if (!hookRaw) {
+function checkPluginExtensions(options) {
+  let packageRaw = readOptionalFile(
+    resolveProjectFile("package.json", options.baseDir)
+  );
+  if (packageRaw && !options.baseDir) {
+    try {
+      const parsed = JSON.parse(packageRaw);
+      if (!parsed.openclaw?.extensions) {
+        const fallbackPath = path24.resolve(findPackageRoot(), "package.json");
+        const fallbackRaw = readOptionalFile(fallbackPath);
+        if (fallbackRaw) packageRaw = fallbackRaw;
+      }
+    } catch {
+    }
+  }
+  if (!packageRaw) {
     return {
-      label: "hook manifest",
+      label: "plugin extensions registration",
       status: "error",
-      detail: "HOOK.md not found"
+      detail: "package.json not found"
     };
   }
   try {
-    const parsed = (0, import_gray_matter8.default)(hookRaw);
-    const openclaw = parsed.data?.metadata?.openclaw;
-    const events = Array.isArray(openclaw?.events) ? openclaw?.events ?? [] : [];
-    const missingEvents = REQUIRED_HOOK_EVENTS.filter((event) => !events.includes(event));
-    if (missingEvents.length === 0) {
+    const parsed = JSON.parse(packageRaw);
+    const extensions = parsed.openclaw?.extensions ?? [];
+    if (extensions.length === 0) {
       return {
-        label: "hook manifest events",
-        status: "ok",
-        detail: events.join(", ")
+        label: "plugin extensions registration",
+        status: "error",
+        detail: "Missing openclaw.extensions in package.json",
+        hint: 'Add openclaw.extensions: ["./dist/plugin/index.js"] to package.json.'
       };
     }
-    return {
-      label: "hook manifest events",
-      status: "error",
-      detail: `Missing events: ${missingEvents.join(", ")}`
-    };
-  } catch (err) {
-    return {
-      label: "hook manifest events",
-      status: "error",
-      detail: err?.message || "Unable to parse HOOK.md frontmatter"
-    };
-  }
-}
-function checkHookManifestRequirements(options) {
-  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
-  if (!hookRaw) {
-    return {
-      label: "hook manifest requirements",
-      status: "error",
-      detail: "HOOK.md not found"
-    };
-  }
-  try {
-    const parsed = (0, import_gray_matter8.default)(hookRaw);
-    const requiresBins = parsed.data?.metadata?.openclaw?.requires?.bins;
-    const bins = Array.isArray(requiresBins) ? requiresBins : [];
-    if (bins.includes(REQUIRED_HOOK_BIN)) {
+    const baseDir = options.baseDir || findPackageRoot();
+    const missing = extensions.filter(
+      (ext) => !fs25.existsSync(path24.resolve(baseDir, ext))
+    );
+    if (missing.length > 0) {
       return {
-        label: "hook manifest requirements",
-        status: "ok",
-        detail: `bins: ${bins.join(", ")}`
+        label: "plugin extensions registration",
+        status: "error",
+        detail: `Entry file(s) not found: ${missing.join(", ")}`,
+        hint: "Run npm run build to generate dist files."
       };
     }
     return {
-      label: "hook manifest requirements",
-      status: "warn",
-      detail: `Missing required hook bin "${REQUIRED_HOOK_BIN}"`,
-      hint: 'Add metadata.openclaw.requires.bins: ["clawvault"] to hooks/clawvault/HOOK.md.'
+      label: "plugin extensions registration",
+      status: "ok",
+      detail: extensions.join(", ")
     };
   } catch (err) {
     return {
-      label: "hook manifest requirements",
-      status: "error",
-      detail: err?.message || "Unable to parse HOOK.md frontmatter"
-    };
-  }
-}
-function checkHookHandlerSafety(options) {
-  const handlerRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/handler.js", options.baseDir));
-  if (!handlerRaw) {
-    return {
-      label: "hook handler script",
+      label: "plugin extensions registration",
       status: "error",
-      detail: "handler.js not found"
-    };
-  }
-  const usesExecFileSync = handlerRaw.includes("execFileSync");
-  const usesExecSync = /\bexecSync\b/.test(handlerRaw);
-  const enablesShell = /\bshell\s*:\s*true\b/.test(handlerRaw);
-  const delegatesAutoProfile = /['"]--profile['"]\s*,\s*['"]auto['"]/.test(handlerRaw);
-  const violations = [];
-  if (!usesExecFileSync || usesExecSync) {
-    violations.push("execFileSync-only execution path");
-  }
-  if (enablesShell) {
-    violations.push("shell:false execution option");
-  }
-  if (!delegatesAutoProfile) {
-    violations.push("shared context profile delegation (--profile auto)");
-  }
-  if (violations.length > 0) {
-    return {
-      label: "hook handler safety",
-      status: "warn",
-      detail: `Missing conventions: ${violations.join(", ")}`,
-      hint: "Use execFileSync (no shell), avoid execSync, and delegate profile inference via --profile auto."
+      detail: err?.message || "Unable to parse package.json"
     };
   }
-  return { label: "hook handler safety", status: "ok" };
 }
 function checkSkillMetadata(options) {
-  const skillRaw = readOptionalFile(resolveProjectFile("SKILL.md", options.baseDir));
+  const skillRaw = readOptionalFile(
+    resolveProjectFile("SKILL.md", options.baseDir)
+  );
   if (!skillRaw) {
     return {
       label: "skill metadata",
@@ -12459,10 +10334,8 @@ function checkSkillMetadata(options) {
 function checkOpenClawCompatibility(options = {}) {
   const checks = [
     checkOpenClawCli(),
-    checkPackageHookRegistration(options),
-    checkHookManifest(options),
-    checkHookManifestRequirements(options),
-    checkHookHandlerSafety(options),
+    checkPluginManifest(options),
+    checkPluginExtensions(options),
     checkSkillMetadata(options)
   ];
   const warnings = checks.filter((check) => check.status === "warn").length;
@@ -12482,7 +10355,9 @@ function formatCompatibilityReport(report) {
   lines.push("");
   for (const check of report.checks) {
     const prefix = check.status === "ok" ? "\u2713" : check.status === "warn" ? "\u26A0" : "\u2717";
-    lines.push(`${prefix} ${check.label}${check.detail ? ` \u2014 ${check.detail}` : ""}`);
+    lines.push(
+      `${prefix} ${check.label}${check.detail ? ` \u2014 ${check.detail}` : ""}`
+    );
     if (check.hint) {
       lines.push(`  ${check.hint}`);
     }
@@ -12556,8 +10431,8 @@ async function graphCommand(options = {}) {
 }
 
 // src/commands/kanban.ts
-var fs28 = __toESM(require("fs"), 1);
-var path28 = __toESM(require("path"), 1);
+var fs26 = __toESM(require("fs"), 1);
+var path25 = __toESM(require("path"), 1);
 var import_gray_matter9 = __toESM(require("gray-matter"), 1);
 var STATUS_LANES = [
   { status: "open", name: "Open" },
@@ -12586,14 +10461,14 @@ function normalizeGroupBy(value) {
   throw new Error(`Unsupported kanban group field: ${normalized}`);
 }
 function resolveBoardPath(vaultPath, output) {
-  const resolvedVaultPath = path28.resolve(vaultPath);
+  const resolvedVaultPath = path25.resolve(vaultPath);
   if (!output) {
-    return path28.join(resolvedVaultPath, "Board.md");
+    return path25.join(resolvedVaultPath, "Board.md");
   }
-  if (path28.isAbsolute(output)) {
+  if (path25.isAbsolute(output)) {
     return output;
   }
-  return path28.join(resolvedVaultPath, output);
+  return path25.join(resolvedVaultPath, output);
 }
 function toHashTag(value) {
   return value.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9/_-]/g, "");
@@ -12745,7 +10620,7 @@ function syncKanbanBoard(vaultPath, options = {}) {
     groupBy,
     now: options.now
   });
-  fs28.writeFileSync(outputPath, markdown);
+  fs26.writeFileSync(outputPath, markdown);
   return {
     outputPath,
     groupBy,
@@ -12828,10 +10703,10 @@ function hasUpdates(updates) {
 }
 function importKanbanBoard(vaultPath, options = {}) {
   const outputPath = resolveBoardPath(vaultPath, options.output);
-  if (!fs28.existsSync(outputPath)) {
+  if (!fs26.existsSync(outputPath)) {
     throw new Error(`Kanban board not found: ${outputPath}`);
   }
-  const markdown = fs28.readFileSync(outputPath, "utf-8");
+  const markdown = fs26.readFileSync(outputPath, "utf-8");
   const parsed = parseKanbanMarkdown(markdown);
   const changes = [];
   const missingSlugs = [];
@@ -12973,7 +10848,7 @@ function registerArchiveCommand(program) {
 }
 
 // src/commands/rebuild.ts
-var fs29 = __toESM(require("fs"), 1);
+var fs27 = __toESM(require("fs"), 1);
 var DATE_RE2 = /^\d{4}-\d{2}-\d{2}$/;
 function parseDateFlag(raw, label) {
   if (!raw) return void 0;
@@ -12984,7 +10859,7 @@ function parseDateFlag(raw, label) {
   return trimmed;
 }
 function loadRawMessages(rawFilePath) {
-  const lines = fs29.readFileSync(rawFilePath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const lines = fs27.readFileSync(rawFilePath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   const messages = [];
   for (const line of lines) {
     try {
@@ -13025,8 +10900,8 @@ async function rebuildCommand(options) {
   for (const date of dates) {
     const ledgerObservationPath = getObservationPath(vaultPath, date);
     const legacyObservationPath = getLegacyObservationPath(vaultPath, date);
-    fs29.rmSync(ledgerObservationPath, { force: true });
-    fs29.rmSync(legacyObservationPath, { force: true });
+    fs27.rmSync(ledgerObservationPath, { force: true });
+    fs27.rmSync(legacyObservationPath, { force: true });
     const fixedNow = () => /* @__PURE__ */ new Date(`${date}T12:00:00.000Z`);
     const observer = new Observer(vaultPath, {
       tokenThreshold: 1,
@@ -13061,29 +10936,29 @@ function registerRebuildCommand(program) {
 }
 
 // src/commands/doctor.ts
-var fs32 = __toESM(require("fs"), 1);
+var fs30 = __toESM(require("fs"), 1);
 var os3 = __toESM(require("os"), 1);
-var path31 = __toESM(require("path"), 1);
+var path28 = __toESM(require("path"), 1);
 
 // src/lib/backlinks.ts
-var fs31 = __toESM(require("fs"), 1);
-var path30 = __toESM(require("path"), 1);
+var fs29 = __toESM(require("fs"), 1);
+var path27 = __toESM(require("path"), 1);
 
 // src/lib/entity-index.ts
-var fs30 = __toESM(require("fs"), 1);
-var path29 = __toESM(require("path"), 1);
+var fs28 = __toESM(require("fs"), 1);
+var path26 = __toESM(require("path"), 1);
 var import_gray_matter10 = __toESM(require("gray-matter"), 1);
 function buildEntityIndex(vaultPath) {
   const entries = /* @__PURE__ */ new Map();
   const byPath = /* @__PURE__ */ new Map();
   const entityFolders = ["people", "projects", "agents", "lessons", "decisions", "commitments"];
   for (const folder of entityFolders) {
-    const folderPath = path29.join(vaultPath, folder);
-    if (!fs30.existsSync(folderPath)) continue;
-    const files = fs30.readdirSync(folderPath).filter((f) => f.endsWith(".md"));
+    const folderPath = path26.join(vaultPath, folder);
+    if (!fs28.existsSync(folderPath)) continue;
+    const files = fs28.readdirSync(folderPath).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const filePath = path29.join(folderPath, file);
-      const content = fs30.readFileSync(filePath, "utf-8");
+      const filePath = path26.join(folderPath, file);
+      const content = fs28.readFileSync(filePath, "utf-8");
       const { data: frontmatter } = (0, import_gray_matter10.default)(content);
       const relativePath = `${folder}/${file.replace(".md", "")}`;
       const baseName = file.replace(".md", "");
@@ -13109,8 +10984,8 @@ function buildEntityIndex(vaultPath) {
 // src/lib/backlinks.ts
 var WIKI_LINK_REGEX = /\[\[([^\]]+)\]\]/g;
 function toVaultId(vaultPath, filePath) {
-  const relative6 = path30.relative(vaultPath, filePath).replace(/\.md$/, "");
-  return relative6.split(path30.sep).join("/");
+  const relative5 = path27.relative(vaultPath, filePath).replace(/\.md$/, "");
+  return relative5.split(path27.sep).join("/");
 }
 function normalizeLinkTarget(raw) {
   let target = raw.trim();
@@ -13141,9 +11016,9 @@ function listMarkdownFiles(vaultPath) {
   const files = [];
   const skipDirs = /* @__PURE__ */ new Set(["archive", "templates", "node_modules"]);
   function walk(dir) {
-    const entries = fs31.readdirSync(dir, { withFileTypes: true });
+    const entries = fs29.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path30.join(dir, entry.name);
+      const fullPath = path27.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || skipDirs.has(entry.name)) continue;
         walk(fullPath);
@@ -13185,7 +11060,7 @@ function scanVaultLinks(vaultPath, options = {}) {
   let linkCount = 0;
   for (const file of files) {
     const sourceId = toVaultId(vaultPath, file);
-    const content = fs31.readFileSync(file, "utf-8");
+    const content = fs29.readFileSync(file, "utf-8");
     const matches = content.match(WIKI_LINK_REGEX) || [];
     linkCount += matches.length;
     for (const match of matches) {
@@ -13234,12 +11109,12 @@ function describeAge(date, now = Date.now()) {
   return formatAge(now - date.getTime());
 }
 function loadCheckpointTimestamp(vaultPath) {
-  const checkpointPath = path31.join(vaultPath, CLAWVAULT_DIR, CHECKPOINT_FILE);
-  if (!fs32.existsSync(checkpointPath)) {
+  const checkpointPath = path28.join(vaultPath, CLAWVAULT_DIR, CHECKPOINT_FILE);
+  if (!fs30.existsSync(checkpointPath)) {
     return {};
   }
   try {
-    const data = JSON.parse(fs32.readFileSync(checkpointPath, "utf-8"));
+    const data = JSON.parse(fs30.readFileSync(checkpointPath, "utf-8"));
     return { timestamp: data.timestamp };
   } catch (err) {
     return { error: err?.message || "Failed to parse checkpoint" };
@@ -13247,20 +11122,20 @@ function loadCheckpointTimestamp(vaultPath) {
 }
 function getShellConfigPaths(shellPath) {
   const home = os3.homedir();
-  const shellName = shellPath ? path31.basename(shellPath) : "bash";
+  const shellName = shellPath ? path28.basename(shellPath) : "bash";
   if (shellName === "zsh") {
-    return [path31.join(home, ".zshenv"), path31.join(home, ".zshrc"), path31.join(home, ".zprofile")];
+    return [path28.join(home, ".zshenv"), path28.join(home, ".zshrc"), path28.join(home, ".zprofile")];
   }
   if (shellName === "fish") {
-    return [path31.join(home, ".config", "fish", "config.fish")];
+    return [path28.join(home, ".config", "fish", "config.fish")];
   }
-  return [path31.join(home, ".bashrc"), path31.join(home, ".bash_profile"), path31.join(home, ".profile")];
+  return [path28.join(home, ".bashrc"), path28.join(home, ".bash_profile"), path28.join(home, ".profile")];
 }
 function hasClawvaultPathConfig(paths) {
   for (const filePath of paths) {
-    if (!fs32.existsSync(filePath)) continue;
+    if (!fs30.existsSync(filePath)) continue;
     try {
-      const content = fs32.readFileSync(filePath, "utf-8");
+      const content = fs30.readFileSync(filePath, "utf-8");
       if (/CLAWVAULT_PATH\s*=/.test(content)) {
         return true;
       }
@@ -13271,13 +11146,13 @@ function hasClawvaultPathConfig(paths) {
 }
 async function resolveVault(vaultPath) {
   if (vaultPath) {
-    const vault = new ClawVault(path31.resolve(vaultPath));
+    const vault = new ClawVault(path28.resolve(vaultPath));
     await vault.load();
     return vault;
   }
   const envPath = process.env.CLAWVAULT_PATH;
   if (envPath) {
-    const vault = new ClawVault(path31.resolve(envPath));
+    const vault = new ClawVault(path28.resolve(envPath));
     await vault.load();
     return vault;
   }
@@ -13326,12 +11201,12 @@ async function doctor(options) {
     });
     errors++;
   }
-  const shellConfigs = getShellConfigPaths(process.env.SHELL).filter(fs32.existsSync);
+  const shellConfigs = getShellConfigPaths(process.env.SHELL).filter(fs30.existsSync);
   if (hasClawvaultPathConfig(shellConfigs)) {
     checks.push({
       label: "CLAWVAULT_PATH in shell config",
       status: "ok",
-      detail: shellConfigs.map((p) => path31.basename(p)).join(", ")
+      detail: shellConfigs.map((p) => path28.basename(p)).join(", ")
     });
   } else {
     checks.push({
@@ -13529,8 +11404,8 @@ async function doctor(options) {
 }
 
 // src/commands/replay.ts
-var fs33 = __toESM(require("fs"), 1);
-var path32 = __toESM(require("path"), 1);
+var fs31 = __toESM(require("fs"), 1);
+var path29 = __toESM(require("path"), 1);
 
 // src/replay/normalizers/chatgpt.ts
 function normalizeText3(value) {
@@ -13833,10 +11708,10 @@ function parseDateFlag2(raw, label) {
   return trimmed;
 }
 function collectFiles(rootPath, predicate) {
-  if (!fs33.existsSync(rootPath)) {
+  if (!fs31.existsSync(rootPath)) {
     return [];
   }
-  const stat = fs33.statSync(rootPath);
+  const stat = fs31.statSync(rootPath);
   if (stat.isFile()) {
     return predicate(rootPath) ? [rootPath] : [];
   }
@@ -13844,8 +11719,8 @@ function collectFiles(rootPath, predicate) {
     return [];
   }
   const files = [];
-  for (const entry of fs33.readdirSync(rootPath, { withFileTypes: true })) {
-    const absolute = path32.join(rootPath, entry.name);
+  for (const entry of fs31.readdirSync(rootPath, { withFileTypes: true })) {
+    const absolute = path29.join(rootPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...collectFiles(absolute, predicate));
       continue;
@@ -13857,11 +11732,11 @@ function collectFiles(rootPath, predicate) {
   return files.sort((left, right) => left.localeCompare(right));
 }
 function loadJson(filePath) {
-  return JSON.parse(fs33.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs31.readFileSync(filePath, "utf-8"));
 }
 function normalizeReplayMessages(source, inputPath) {
   if (source === "chatgpt") {
-    const files2 = collectFiles(inputPath, (filePath) => path32.basename(filePath).toLowerCase() === "conversations.json");
+    const files2 = collectFiles(inputPath, (filePath) => path29.basename(filePath).toLowerCase() === "conversations.json");
     if (files2.length === 0) {
       throw new Error("ChatGPT replay expects conversations.json in --input path.");
     }
@@ -13884,7 +11759,7 @@ function normalizeReplayMessages(source, inputPath) {
     }
     return files2.flatMap((filePath) => {
       if (filePath.toLowerCase().endsWith(".jsonl")) {
-        return normalizeOpenCodeExport(fs33.readFileSync(filePath, "utf-8"));
+        return normalizeOpenCodeExport(fs31.readFileSync(filePath, "utf-8"));
       }
       return normalizeOpenCodeExport(loadJson(filePath));
     });
@@ -13893,7 +11768,7 @@ function normalizeReplayMessages(source, inputPath) {
   if (files.length === 0) {
     throw new Error("OpenClaw replay expects .jsonl session transcript files.");
   }
-  return files.flatMap((filePath) => normalizeOpenClawTranscript(fs33.readFileSync(filePath, "utf-8")));
+  return files.flatMap((filePath) => normalizeOpenClawTranscript(fs31.readFileSync(filePath, "utf-8")));
 }
 function normalizeDateFromTimestamp(timestamp, fallbackDate) {
   if (!timestamp) return fallbackDate;
@@ -13914,8 +11789,8 @@ async function replayCommand(options) {
     throw new Error(`Invalid range: --from ${fromDate} is after --to ${toDate}.`);
   }
   const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
-  const resolvedInput = path32.resolve(options.inputPath);
-  if (!fs33.existsSync(resolvedInput)) {
+  const resolvedInput = path29.resolve(options.inputPath);
+  if (!fs31.existsSync(resolvedInput)) {
     throw new Error(`Replay input path not found: ${resolvedInput}`);
   }
   const allMessages = normalizeReplayMessages(source, resolvedInput);
@@ -13959,7 +11834,7 @@ async function replayCommand(options) {
     }
     await observer.processMessages(messages, {
       source,
-      transcriptId: path32.basename(resolvedInput),
+      transcriptId: path29.basename(resolvedInput),
       timestamp: nowForDate()
     });
     await observer.flush();
@@ -13992,7 +11867,7 @@ function registerReplayCommand(program) {
 }
 
 // src/commands/migrate-observations.ts
-var fs34 = __toESM(require("fs"), 1);
+var fs32 = __toESM(require("fs"), 1);
 function toBackupPath(filePath) {
   if (filePath.toLowerCase().endsWith(".md")) {
     return `${filePath.slice(0, -3)}.emoji-backup.md`;
@@ -14039,7 +11914,7 @@ function migrateObservations(vaultPath, options = {}) {
   let migrated = 0;
   let backups = 0;
   for (const entry of files) {
-    const raw = fs34.readFileSync(entry.path, "utf-8");
+    const raw = fs32.readFileSync(entry.path, "utf-8");
     const { converted, changed } = convertObservationMarkdown(raw);
     if (!changed) {
       continue;
@@ -14049,11 +11924,11 @@ function migrateObservations(vaultPath, options = {}) {
       continue;
     }
     const backupPath = toBackupPath(entry.path);
-    if (!fs34.existsSync(backupPath)) {
-      fs34.copyFileSync(entry.path, backupPath);
+    if (!fs32.existsSync(backupPath)) {
+      fs32.copyFileSync(entry.path, backupPath);
       backups += 1;
     }
-    fs34.writeFileSync(entry.path, `${converted.trim()}
+    fs32.writeFileSync(entry.path, `${converted.trim()}
 `, "utf-8");
   }
   return {
@@ -14086,8 +11961,8 @@ function registerMigrateObservationsCommand(program) {
 }
 
 // src/commands/session-recap.ts
-var fs35 = __toESM(require("fs"), 1);
-var path33 = __toESM(require("path"), 1);
+var fs33 = __toESM(require("fs"), 1);
+var path30 = __toESM(require("path"), 1);
 var DEFAULT_LIMIT2 = 15;
 var MAX_LIMIT = 50;
 var READ_CHUNK_SIZE = 64 * 1024;
@@ -14130,33 +12005,33 @@ function normalizeLimit(limit) {
   return Math.min(MAX_LIMIT, Math.max(1, parsed));
 }
 function isPathInside(parentPath, candidatePath) {
-  const normalizedParent = parentPath.endsWith(path33.sep) ? parentPath : `${parentPath}${path33.sep}`;
+  const normalizedParent = parentPath.endsWith(path30.sep) ? parentPath : `${parentPath}${path30.sep}`;
   return candidatePath.startsWith(normalizedParent);
 }
 function resolveSafeTranscriptPath(agentId, sessionId, sessionFile) {
   const sessionsDir = getSessionsDir(agentId);
-  if (!fs35.existsSync(sessionsDir)) {
+  if (!fs33.existsSync(sessionsDir)) {
     throw new Error(`Sessions directory not found for agent "${agentId}".`);
   }
-  const sessionsDirRealPath = fs35.realpathSync(sessionsDir);
+  const sessionsDirRealPath = fs33.realpathSync(sessionsDir);
   const candidatePaths = [];
   if (typeof sessionFile === "string" && sessionFile.trim()) {
-    candidatePaths.push(path33.resolve(sessionFile));
+    candidatePaths.push(path30.resolve(sessionFile));
   }
   candidatePaths.push(getSessionFilePath(agentId, sessionId));
   for (const candidatePath of candidatePaths) {
-    if (path33.extname(candidatePath).toLowerCase() !== ".jsonl") continue;
-    if (!fs35.existsSync(candidatePath)) continue;
+    if (path30.extname(candidatePath).toLowerCase() !== ".jsonl") continue;
+    if (!fs33.existsSync(candidatePath)) continue;
     let candidateRealPath = "";
     try {
-      candidateRealPath = fs35.realpathSync(candidatePath);
+      candidateRealPath = fs33.realpathSync(candidatePath);
     } catch {
       continue;
     }
     if (!isPathInside(sessionsDirRealPath, candidateRealPath)) {
       continue;
     }
-    const stat = fs35.statSync(candidateRealPath);
+    const stat = fs33.statSync(candidateRealPath);
     if (!stat.isFile()) continue;
     return candidateRealPath;
   }
@@ -14249,16 +12124,16 @@ function applyOutputBudget(turns) {
 }
 function readRecentTurnsFromTranscript(filePath, limit) {
   if (limit <= 0) return [];
-  const fileHandle = fs35.openSync(filePath, "r");
+  const fileHandle = fs33.openSync(filePath, "r");
   const collected = [];
   let remainder = "";
   try {
-    let position = fs35.fstatSync(fileHandle).size;
+    let position = fs33.fstatSync(fileHandle).size;
     while (position > 0 && collected.length < limit) {
       const readSize = Math.min(READ_CHUNK_SIZE, position);
       position -= readSize;
       const buffer = Buffer.allocUnsafe(readSize);
-      fs35.readSync(fileHandle, buffer, 0, readSize, position);
+      fs33.readSync(fileHandle, buffer, 0, readSize, position);
       const chunk = buffer.toString("utf-8");
       const text = chunk + remainder;
       const lines = text.split("\n");
@@ -14274,7 +12149,7 @@ function readRecentTurnsFromTranscript(filePath, limit) {
       if (turn) collected.push(turn);
     }
   } finally {
-    fs35.closeSync(fileHandle);
+    fs33.closeSync(fileHandle);
   }
   return applyOutputBudget(collected.reverse());
 }
@@ -14352,7 +12227,7 @@ var import_meta4 = {};
 function readPackageVersion() {
   try {
     const pkgUrl = new URL("../package.json", import_meta4.url);
-    const pkg = JSON.parse(fs36.readFileSync(pkgUrl, "utf-8"));
+    const pkg = JSON.parse(fs34.readFileSync(pkgUrl, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -14364,12 +12239,10 @@ function registerCommanderCommands(program) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CLAWVAULT_SERVE_PATH,
   ClawVault,
   Compressor,
   DEFAULT_CATEGORIES,
   DEFAULT_CONFIG,
-  DEFAULT_SERVE_PORT,
   MEMORY_GRAPH_SCHEMA_VERSION,
   MEMORY_TYPES,
   Observer,
@@ -14396,19 +12269,15 @@ function registerCommanderCommands(program) {
   buildTemplateVariables,
   buildTransitionEvent,
   checkOpenClawCompatibility,
-  checkPeerClawVault,
   classifyQuestion,
-  compareManifests,
   compatCommand,
   compatibilityExitCode,
   completeTask,
-  configureTailscaleServe,
   contextCommand,
   countBlockedTransitions,
   createProject,
   createVault,
   deterministicInjectMatches,
-  discoverClawVaultPeers,
   doctor,
   embedCommand,
   entitySimilarity,
@@ -14418,34 +12287,26 @@ function registerCommanderCommands(program) {
   extractPreferences,
   extractTags,
   extractWikiLinks,
-  fetchRemoteFile,
-  fetchRemoteManifest,
   filterSuperseded,
   findNearestVaultPath,
-  findPeer,
   findVault,
   formatContextMarkdown,
   formatKanbanCard,
   formatSessionRecapMarkdown,
   formatTransitionsTable,
   generateKanbanMarkdown,
-  generateVaultManifest,
   getConfig,
   getConfigValue,
   getMemoryGraph,
   getObserverStaleness,
-  getOnlinePeers,
   getProjectActivity,
   getProjectTasks,
   getScaledObservationThresholdBytes,
   getSupersessionInfo,
-  getTailscaleStatus,
-  getTailscaleVersion,
   getVaultPath,
   graphCommand,
   graphSummary,
   hasQmd,
-  hasTailscale,
   importKanbanBoard,
   indexInjectableItems,
   inferContextProfile,
@@ -14469,7 +12330,6 @@ function registerCommanderCommands(program) {
   parseKanbanMarkdown,
   parseSessionFile,
   parseSessionSourceLabel,
-  pushFileToRemote,
   qmdEmbed,
   qmdUpdate,
   queryTransitions,
@@ -14489,11 +12349,6 @@ function registerCommanderCommands(program) {
   registerReflectCommand,
   registerReplayCommand,
   registerReweaveCommand,
-  registerTailscaleCommands,
-  registerTailscaleDiscoverCommand,
-  registerTailscaleServeCommand,
-  registerTailscaleStatusCommand,
-  registerTailscaleSyncCommand,
   removeRouteRule,
   renderTemplate,
   replayCommand,
@@ -14501,25 +12356,17 @@ function registerCommanderCommands(program) {
   resetConfig,
   resolveContextProfile,
   resolveLlmProvider,
-  resolvePeerIP,
   resolveVaultPath,
   reweave,
   reweaveCommand,
   runPromptInjection,
   runReflection,
   sentenceChunk,
-  serveVault,
   sessionRecapCommand,
   setConfigValue,
   setupCommand,
-  stopTailscaleServe,
   stripSupersededObservations,
   syncKanbanBoard,
-  syncWithPeer,
-  tailscaleDiscoverCommand,
-  tailscaleServeCommand,
-  tailscaleStatusCommand,
-  tailscaleSyncCommand,
   testRouteRule,
   updateProject,
   updateTask