clawvault 2.6.1 → 2.6.4

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

@@ -6,20 +6,26 @@ import {
 } from "./chunk-4VQTUVH7.js";
 import {
   getObserverStaleness
-} from "./chunk-IEVLHNLU.js";
+} from "./chunk-627Q3QWK.js";
 import {
   ClawVault,
   findVault
-} from "./chunk-KL4NAOMO.js";
+} from "./chunk-YDWHS4LJ.js";
 import {
+  listQmdCollections,
+  loadVaultQmdConfig
+} from "./chunk-WIOLLGAD.js";
+import {
+  QMD_INSTALL_COMMAND,
+  QMD_INSTALL_URL,
   hasQmd
-} from "./chunk-MAKNAHAW.js";
+} from "./chunk-5PJ4STIC.js";
 import {
   loadMemoryGraphIndex
 } from "./chunk-ZZA73MFY.js";
 import {
   checkOpenClawCompatibility
-} from "./chunk-QVMXF7FY.js";
+} from "./chunk-X3SPPUFG.js";
 
 // src/commands/doctor.ts
 import * as fs from "fs";
@@ -29,6 +35,12 @@ var CLAWVAULT_DIR = ".clawvault";
 var CHECKPOINT_FILE = "last-checkpoint.json";
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var ACTIVE_USE_DAYS = 7;
+var V2_COLLECTION_PATTERNS = [
+  /^clawvault$/i,
+  /^vault$/i,
+  /^memory$/i,
+  /^notes$/i
+];
 function daysSince(date, now = Date.now()) {
   return Math.max(0, Math.floor((now - date.getTime()) / DAY_MS));
 }
@@ -71,6 +83,124 @@ function hasClawvaultPathConfig(paths) {
   }
   return false;
 }
+function isLikelyV2CollectionName(name) {
+  return V2_COLLECTION_PATTERNS.some((pattern) => pattern.test(name));
+}
+function checkQmdCollectionExists(collections, expectedName) {
+  const found = collections.find((c) => c.name === expectedName);
+  return { exists: !!found, collection: found };
+}
+function checkCollectionPathMatches(collection, expectedRoot) {
+  if (!collection.root) return false;
+  const normalizedCollectionRoot = path.resolve(collection.root);
+  const normalizedExpectedRoot = path.resolve(expectedRoot);
+  return normalizedCollectionRoot === normalizedExpectedRoot;
+}
+function detectMigrationIssues(vaultPath, configuredCollection, configuredRoot) {
+  const issues = [];
+  if (!hasQmd()) {
+    return issues;
+  }
+  let collections;
+  try {
+    collections = listQmdCollections();
+  } catch {
+    return issues;
+  }
+  const vaultConfig = loadVaultQmdConfig(vaultPath);
+  const expectedCollection = configuredCollection || vaultConfig.qmdCollection;
+  const expectedRoot = configuredRoot || vaultConfig.qmdRoot;
+  const { exists, collection } = checkQmdCollectionExists(collections, expectedCollection);
+  if (!exists) {
+    const potentialV2Collections = collections.filter(
+      (c) => isLikelyV2CollectionName(c.name) && c.root && path.resolve(c.root) === path.resolve(expectedRoot)
+    );
+    if (potentialV2Collections.length > 0) {
+      issues.push({
+        type: "stale_collection_name",
+        description: `Found v2-style collection "${potentialV2Collections[0].name}" that should be renamed to "${expectedCollection}"`,
+        autoFixable: true,
+        details: {
+          oldName: potentialV2Collections[0].name,
+          newName: expectedCollection,
+          root: potentialV2Collections[0].root
+        }
+      });
+    } else {
+      issues.push({
+        type: "missing_qmd_collection",
+        description: `qmd collection "${expectedCollection}" does not exist`,
+        autoFixable: true,
+        details: {
+          collectionName: expectedCollection,
+          expectedRoot
+        }
+      });
+    }
+  } else if (collection && !checkCollectionPathMatches(collection, expectedRoot)) {
+    issues.push({
+      type: "wrong_vault_path",
+      description: `Collection "${expectedCollection}" points to "${collection.root}" but vault is at "${expectedRoot}"`,
+      autoFixable: true,
+      details: {
+        collectionName: expectedCollection,
+        currentRoot: collection.root,
+        expectedRoot
+      }
+    });
+  }
+  const orphanedCollections = collections.filter((c) => {
+    if (c.name === expectedCollection) return false;
+    if (!c.root) return false;
+    const collectionRoot = path.resolve(c.root);
+    const vaultRoot = path.resolve(expectedRoot);
+    return collectionRoot === vaultRoot || collectionRoot.startsWith(vaultRoot + path.sep);
+  });
+  for (const orphan of orphanedCollections) {
+    issues.push({
+      type: "orphaned_collection",
+      description: `Orphaned collection "${orphan.name}" points to vault path but is not the configured collection`,
+      autoFixable: true,
+      details: {
+        collectionName: orphan.name,
+        root: orphan.root
+      }
+    });
+  }
+  const configPath = path.join(vaultPath, ".clawvault.json");
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (!config.qmdCollection || !config.qmdRoot) {
+        issues.push({
+          type: "missing_qmd_config",
+          description: "Vault config is missing qmdCollection or qmdRoot settings",
+          autoFixable: true,
+          details: {
+            hasQmdCollection: !!config.qmdCollection,
+            hasQmdRoot: !!config.qmdRoot
+          }
+        });
+      }
+    } catch {
+      issues.push({
+        type: "legacy_config_format",
+        description: "Unable to parse .clawvault.json - may need migration",
+        autoFixable: false
+      });
+    }
+  }
+  return issues;
+}
+function migrationIssuesToChecks(issues) {
+  return issues.map((issue) => ({
+    label: `migration: ${issue.type.replace(/_/g, " ")}`,
+    status: "warn",
+    detail: issue.description,
+    hint: issue.autoFixable ? "Run `clawvault migrate` to auto-fix this issue." : "Manual intervention required.",
+    category: "migration"
+  }));
+}
 async function resolveVault(vaultPath) {
   if (vaultPath) {
     const vault = new ClawVault(path.resolve(vaultPath));
@@ -93,13 +223,15 @@ async function doctor(vaultPath) {
   const checks = [];
   let warnings = 0;
   let errors = 0;
+  const migrationIssues = [];
   const compatReport = checkOpenClawCompatibility();
   if (compatReport.errors > 0) {
     checks.push({
       label: "OpenClaw compatibility",
       status: "error",
       detail: `${compatReport.errors} error(s), ${compatReport.warnings} warning(s)`,
-      hint: "Run `clawvault compat` for full compatibility diagnostics."
+      hint: "Run `clawvault compat` for full compatibility diagnostics.",
+      category: "system"
     });
     errors++;
   } else if (compatReport.warnings > 0) {
@@ -107,22 +239,29 @@ async function doctor(vaultPath) {
       label: "OpenClaw compatibility",
       status: "warn",
       detail: `${compatReport.warnings} warning(s)`,
-      hint: "Run `clawvault compat` for full compatibility diagnostics."
+      hint: "Run `clawvault compat` for full compatibility diagnostics.",
+      category: "system"
     });
     warnings++;
   } else {
     checks.push({
       label: "OpenClaw compatibility",
-      status: "ok"
+      status: "ok",
+      category: "system"
     });
   }
   if (hasQmd()) {
-    checks.push({ label: "qmd installed", status: "ok" });
+    checks.push({ label: "qmd installed", status: "ok", category: "system" });
   } else {
     checks.push({
       label: "qmd installed",
       status: "error",
-      hint: "Install qmd to enable ClawVault commands."
+      detail: "qmd binary not found in PATH",
+      hint: `Install qmd to enable ClawVault search and indexing:
+  ${QMD_INSTALL_COMMAND}
+
+For more information: ${QMD_INSTALL_URL}`,
+      category: "system"
     });
     errors++;
   }
@@ -131,44 +270,57 @@ async function doctor(vaultPath) {
     checks.push({
       label: "CLAWVAULT_PATH in shell config",
       status: "ok",
-      detail: shellConfigs.map((p) => path.basename(p)).join(", ")
+      detail: shellConfigs.map((p) => path.basename(p)).join(", "),
+      category: "system"
     });
   } else {
     checks.push({
       label: "CLAWVAULT_PATH in shell config",
       status: "warn",
-      hint: "Run `clawvault shell-init` and add it to your shell rc."
+      hint: "Run `clawvault shell-init` and add it to your shell rc.",
+      category: "system"
     });
     warnings++;
   }
   if (!hasQmd()) {
-    return { vaultPath, checks, warnings, errors };
+    return { vaultPath, checks, warnings, errors, migrationIssues };
   }
   let vault;
   try {
     vault = await resolveVault(vaultPath);
-    checks.push({ label: "vault found", status: "ok", detail: vault.getPath() });
+    checks.push({ label: "vault found", status: "ok", detail: vault.getPath(), category: "system" });
   } catch (err) {
     checks.push({
       label: "vault found",
       status: "error",
-      detail: err?.message || "Unable to locate vault"
+      detail: err?.message || "Unable to locate vault",
+      category: "system"
     });
     errors++;
-    return { vaultPath, checks, warnings, errors };
+    return { vaultPath, checks, warnings, errors, migrationIssues };
   }
+  const detectedMigrationIssues = detectMigrationIssues(
+    vault.getPath(),
+    vault.getQmdCollection(),
+    vault.getQmdRoot()
+  );
+  migrationIssues.push(...detectedMigrationIssues);
+  const migrationChecks = migrationIssuesToChecks(detectedMigrationIssues);
+  checks.push(...migrationChecks);
+  warnings += migrationChecks.length;
   const stats = await vault.stats();
   const documents = await vault.list();
   const handoffs = await vault.list("handoffs");
   const inbox = await vault.list("inbox");
   const qmdCollection = vault.getQmdCollection();
   if (qmdCollection) {
-    checks.push({ label: "qmd collection configured", status: "ok", detail: qmdCollection });
+    checks.push({ label: "qmd collection configured", status: "ok", detail: qmdCollection, category: "system" });
   } else {
     checks.push({
       label: "qmd collection configured",
       status: "warn",
-      hint: "Set qmd collection in .clawvault.json"
+      hint: "Set qmd collection in .clawvault.json or run `clawvault migrate`.",
+      category: "system"
     });
     warnings++;
   }
@@ -180,7 +332,8 @@ async function doctor(vaultPath) {
       label: "memory graph index",
       status: "warn",
       detail: "No graph index found",
-      hint: "Run `clawvault graph --refresh` to build .clawvault/graph-index.json."
+      hint: "Run `clawvault graph --refresh` to build .clawvault/graph-index.json.",
+      category: "health"
     });
     warnings++;
   } else {
@@ -192,14 +345,16 @@ async function doctor(vaultPath) {
         label: "memory graph index",
         status: "warn",
         detail: `Stale graph index (generated ${generatedAge} ago)`,
-        hint: "Run `clawvault graph --refresh` to resync index."
+        hint: "Run `clawvault graph --refresh` to resync index.",
+        category: "health"
       });
       warnings++;
     } else {
       checks.push({
         label: "memory graph index",
         status: "ok",
-        detail: `${graphIndex.graph.stats.nodeCount} nodes, ${graphIndex.graph.stats.edgeCount} edges`
+        detail: `${graphIndex.graph.stats.nodeCount} nodes, ${graphIndex.graph.stats.edgeCount} edges`,
+        category: "health"
       });
     }
   }
@@ -208,7 +363,8 @@ async function doctor(vaultPath) {
     checks.push({
       label: "recent handoff",
       status: "warn",
-      hint: "Run `clawvault sleep` at the end of sessions."
+      hint: "Run `clawvault sleep` at the end of sessions.",
+      category: "health"
     });
     warnings++;
   } else {
@@ -220,14 +376,16 @@ async function doctor(vaultPath) {
         label: "recent handoff",
         status: "warn",
         detail: `Last handoff ${ageLabel} ago`,
-        hint: "Run `clawvault sleep` before long pauses."
+        hint: "Run `clawvault sleep` before long pauses.",
+        category: "health"
       });
       warnings++;
     } else {
       checks.push({
         label: "recent handoff",
         status: "ok",
-        detail: `Last handoff ${ageLabel} ago`
+        detail: `Last handoff ${ageLabel} ago`,
+        category: "health"
       });
     }
   }
@@ -237,7 +395,8 @@ async function doctor(vaultPath) {
     checks.push({
       label: "checkpoint freshness",
       status: "warn",
-      detail: checkpointInfo.error
+      detail: checkpointInfo.error,
+      category: "health"
     });
     warnings++;
   } else if (!checkpointInfo.timestamp) {
@@ -247,7 +406,8 @@ async function doctor(vaultPath) {
       label: "checkpoint freshness",
       status,
       detail: activeUse ? "No checkpoint found" : "No checkpoint found (vault appears inactive)",
-      hint: activeUse ? "Run `clawvault checkpoint` during heavy work." : void 0
+      hint: activeUse ? "Run `clawvault checkpoint` during heavy work." : void 0,
+      category: "health"
     });
   } else {
     const checkpointDate = new Date(checkpointInfo.timestamp);
@@ -258,14 +418,16 @@ async function doctor(vaultPath) {
         label: "checkpoint freshness",
         status: "warn",
         detail: `Last checkpoint ${ageLabel} ago`,
-        hint: "Checkpoint at least once per active day."
+        hint: "Checkpoint at least once per active day.",
+        category: "health"
       });
       warnings++;
     } else {
       checks.push({
         label: "checkpoint freshness",
         status: "ok",
-        detail: `Last checkpoint ${ageLabel} ago`
+        detail: `Last checkpoint ${ageLabel} ago`,
+        category: "health"
       });
     }
   }
@@ -275,13 +437,15 @@ async function doctor(vaultPath) {
       label: "observer freshness",
       status: "warn",
       detail: `${observerStaleness.staleCount} stale session cursor(s); oldest ${formatAge(observerStaleness.oldestMs)} ago`,
-      hint: "Run `clawvault observe --cron` and verify cron/hook scheduling."
+      hint: "Run `clawvault observe --cron` and verify cron/hook scheduling.",
+      category: "health"
     });
     warnings++;
   } else {
     checks.push({
       label: "observer freshness",
-      status: "ok"
+      status: "ok",
+      category: "health"
     });
   }
   const linkScan = scanVaultLinks(vault.getPath());
@@ -290,14 +454,16 @@ async function doctor(vaultPath) {
       label: "orphan links",
       status: "warn",
       detail: `${linkScan.orphans.length} orphan link(s)`,
-      hint: "Run `clawvault link --orphans` to review."
+      hint: "Run `clawvault link --orphans` to review.",
+      category: "health"
     });
     warnings++;
   } else {
     checks.push({
       label: "orphan links",
       status: "ok",
-      detail: `${linkScan.orphans.length} orphan link(s)`
+      detail: `${linkScan.orphans.length} orphan link(s)`,
+      category: "health"
     });
   }
   if (inbox.length > 5) {
@@ -305,14 +471,16 @@ async function doctor(vaultPath) {
       label: "inbox backlog",
       status: "warn",
       detail: `${inbox.length} inbox item(s) pending`,
-      hint: "Process inbox items to keep memory tidy."
+      hint: "Process inbox items to keep memory tidy.",
+      category: "health"
     });
     warnings++;
   } else {
     checks.push({
       label: "inbox backlog",
       status: "ok",
-      detail: `${inbox.length} inbox item(s) pending`
+      detail: `${inbox.length} inbox item(s) pending`,
+      category: "health"
     });
   }
   if (stats.documents < 5) {
@@ -320,11 +488,12 @@ async function doctor(vaultPath) {
       label: "vault activity",
       status: "warn",
       detail: `${stats.documents} total documents`,
-      hint: "Start capturing decisions, lessons, and projects."
+      hint: "Start capturing decisions, lessons, and projects.",
+      category: "health"
     });
     warnings++;
   }
-  return { vaultPath: vault.getPath(), checks, warnings, errors };
+  return { vaultPath: vault.getPath(), checks, warnings, errors, migrationIssues };
 }
 
 export {

package/dist/chunk-MM6QGW3P.js

@@ -0,0 +1,207 @@
+import {
+  __export
+} from "./chunk-2ZDO52B4.js";
+
+// src/workgraph/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  defineType: () => defineType,
+  extendType: () => extendType,
+  getType: () => getType,
+  listTypes: () => listTypes,
+  loadRegistry: () => loadRegistry,
+  registryPath: () => registryPath,
+  saveRegistry: () => saveRegistry
+});
+import fs from "fs";
+import path from "path";
+var REGISTRY_FILE = ".clawvault/registry.json";
+var CURRENT_VERSION = 1;
+var BUILT_IN_TYPES = [
+  {
+    name: "thread",
+    description: "A unit of coordinated work. The core workgraph node.",
+    directory: "threads",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      title: { type: "string", required: true, description: "What this thread is about" },
+      goal: { type: "string", required: true, description: "What success looks like" },
+      status: { type: "string", required: true, default: "open", description: "open | active | blocked | done | cancelled" },
+      owner: { type: "string", description: "Agent that claimed this thread" },
+      priority: { type: "string", default: "medium", description: "urgent | high | medium | low" },
+      deps: { type: "list", default: [], description: "Wiki-link refs to threads this depends on" },
+      parent: { type: "ref", description: "Parent thread (if decomposed from a larger thread)" },
+      context_refs: { type: "list", default: [], description: "Wiki-link refs to vault docs that inform this work" },
+      tags: { type: "list", default: [], description: "Freeform tags" },
+      created: { type: "date", required: true },
+      updated: { type: "date", required: true }
+    }
+  },
+  {
+    name: "space",
+    description: "A workspace boundary that groups related threads and sets context.",
+    directory: "spaces",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      title: { type: "string", required: true, description: "Space name" },
+      description: { type: "string", description: "What this space is for" },
+      members: { type: "list", default: [], description: "Agent names that participate" },
+      thread_refs: { type: "list", default: [], description: "Wiki-link refs to threads in this space" },
+      tags: { type: "list", default: [], description: "Freeform tags" },
+      created: { type: "date", required: true },
+      updated: { type: "date", required: true }
+    }
+  },
+  {
+    name: "decision",
+    description: "A recorded decision with reasoning and context.",
+    directory: "decisions",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      title: { type: "string", required: true },
+      date: { type: "date", required: true },
+      status: { type: "string", default: "active", description: "active | superseded | reverted" },
+      context_refs: { type: "list", default: [], description: "What informed this decision" },
+      tags: { type: "list", default: [] }
+    }
+  },
+  {
+    name: "lesson",
+    description: "A captured insight or pattern learned from experience.",
+    directory: "lessons",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      title: { type: "string", required: true },
+      date: { type: "date", required: true },
+      confidence: { type: "string", default: "medium", description: "high | medium | low" },
+      context_refs: { type: "list", default: [] },
+      tags: { type: "list", default: [] }
+    }
+  },
+  {
+    name: "fact",
+    description: "A structured piece of knowledge with optional temporal validity.",
+    directory: "facts",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      subject: { type: "string", required: true },
+      predicate: { type: "string", required: true },
+      object: { type: "string", required: true },
+      confidence: { type: "number", default: 1 },
+      valid_from: { type: "date" },
+      valid_until: { type: "date" },
+      source: { type: "ref", description: "Where this fact came from" }
+    }
+  },
+  {
+    name: "agent",
+    description: "A registered participant in the workgraph.",
+    directory: "agents",
+    builtIn: true,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    createdBy: "system",
+    fields: {
+      name: { type: "string", required: true },
+      role: { type: "string", description: "What this agent specializes in" },
+      capabilities: { type: "list", default: [], description: "What this agent can do" },
+      active_threads: { type: "list", default: [], description: "Threads currently claimed" },
+      last_seen: { type: "date" }
+    }
+  }
+];
+function registryPath(vaultPath) {
+  return path.join(vaultPath, REGISTRY_FILE);
+}
+function loadRegistry(vaultPath) {
+  const rPath = registryPath(vaultPath);
+  if (fs.existsSync(rPath)) {
+    const raw = fs.readFileSync(rPath, "utf-8");
+    const registry = JSON.parse(raw);
+    return ensureBuiltIns(registry);
+  }
+  return seedRegistry();
+}
+function saveRegistry(vaultPath, registry) {
+  const rPath = registryPath(vaultPath);
+  const dir = path.dirname(rPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(rPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+}
+function defineType(vaultPath, name, description, fields, actor, directory) {
+  const registry = loadRegistry(vaultPath);
+  const safeName = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+  if (registry.types[safeName]?.builtIn) {
+    throw new Error(`Cannot redefine built-in type "${safeName}". You can extend it with new fields instead.`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const typeDef = {
+    name: safeName,
+    description,
+    fields: {
+      title: { type: "string", required: true },
+      created: { type: "date", required: true },
+      updated: { type: "date", required: true },
+      tags: { type: "list", default: [] },
+      ...fields
+    },
+    directory: directory ?? `${safeName}s`,
+    builtIn: false,
+    createdAt: now,
+    createdBy: actor
+  };
+  registry.types[safeName] = typeDef;
+  saveRegistry(vaultPath, registry);
+  return typeDef;
+}
+function getType(vaultPath, name) {
+  const registry = loadRegistry(vaultPath);
+  return registry.types[name];
+}
+function listTypes(vaultPath) {
+  const registry = loadRegistry(vaultPath);
+  return Object.values(registry.types);
+}
+function extendType(vaultPath, name, newFields, actor) {
+  const registry = loadRegistry(vaultPath);
+  const existing = registry.types[name];
+  if (!existing) throw new Error(`Type "${name}" not found in registry.`);
+  existing.fields = { ...existing.fields, ...newFields };
+  saveRegistry(vaultPath, registry);
+  return existing;
+}
+function seedRegistry() {
+  const types = {};
+  for (const t of BUILT_IN_TYPES) {
+    types[t.name] = t;
+  }
+  return { version: CURRENT_VERSION, types };
+}
+function ensureBuiltIns(registry) {
+  for (const t of BUILT_IN_TYPES) {
+    if (!registry.types[t.name]) {
+      registry.types[t.name] = t;
+    }
+  }
+  return registry;
+}
+
+export {
+  registryPath,
+  loadRegistry,
+  saveRegistry,
+  defineType,
+  getType,
+  listTypes,
+  extendType,
+  registry_exports
+};

package/dist/{chunk-T76H47ZS.js → chunk-MNPUYCHQ.js}

@@ -5,7 +5,7 @@ import {
 import {
   requestLlmCompletion,
   resolveLlmProvider
-} from "./chunk-HIHOUSXS.js";
+} from "./chunk-YXQCA6B7.js";
 import {
   archiveObservations
 } from "./chunk-MQUJNOHK.js";

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

@@ -1,21 +1,21 @@
 import {
   registerTailscaleCommands
-} from "./chunk-THRJVD4L.js";
+} from "./chunk-Y6VJKXGL.js";
 import {
   registerObserveCommand
-} from "./chunk-ME37YNW3.js";
+} from "./chunk-P7SY3D4E.js";
 import {
   registerReflectCommand
-} from "./chunk-3BTHWPMB.js";
+} from "./chunk-S5OJEGFG.js";
 import {
   registerContextCommand
-} from "./chunk-XAVB4GB4.js";
+} from "./chunk-LIGHWOH6.js";
 import {
   registerEmbedCommand
-} from "./chunk-4QYGFWRM.js";
+} from "./chunk-ECRZL5XR.js";
 import {
   registerInjectCommand
-} from "./chunk-4VRIMU4O.js";
+} from "./chunk-YNIPYN4F.js";
 
 // src/cli/index.ts
 function registerCliCommands(program) {