clawvault 3.1.0 → 3.2.1

package/dist/commands/inject.cjs

@@ -1,1636 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/commands/inject.ts
-var inject_exports = {};
-__export(inject_exports, {
-  buildInjectionResult: () => buildInjectionResult,
-  injectCommand: () => injectCommand,
-  registerInjectCommand: () => registerInjectCommand
-});
-module.exports = __toCommonJS(inject_exports);
-var path4 = __toESM(require("path"), 1);
-
-// src/lib/config-manager.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-
-// src/types.ts
-var DEFAULT_CATEGORIES = [
-  "rules",
-  "preferences",
-  "decisions",
-  "patterns",
-  "people",
-  "projects",
-  "goals",
-  "transcripts",
-  "inbox",
-  "templates",
-  "lessons",
-  "agents",
-  "commitments",
-  "handoffs",
-  "research",
-  "tasks",
-  "backlog"
-];
-
-// src/lib/config-manager.ts
-var CONFIG_FILE = ".clawvault.json";
-var OBSERVE_PROVIDERS = ["anthropic", "openai", "gemini"];
-var OBSERVER_COMPRESSION_PROVIDERS = [
-  "anthropic",
-  "openai",
-  "gemini",
-  "openai-compatible",
-  "ollama"
-];
-var THEMES = ["neural", "minimal", "none"];
-var CONTEXT_PROFILES = ["default", "planning", "incident", "handoff", "auto"];
-var DEFAULT_THEME = "none";
-var DEFAULT_OBSERVE_MODEL = "gemini-2.0-flash";
-var DEFAULT_OBSERVE_PROVIDER = "gemini";
-var DEFAULT_CONTEXT_MAX_RESULTS = 5;
-var DEFAULT_CONTEXT_PROFILE = "default";
-var DEFAULT_GRAPH_MAX_HOPS = 2;
-var DEFAULT_INJECT_MAX_RESULTS = 8;
-var DEFAULT_INJECT_USE_LLM = true;
-var DEFAULT_INJECT_SCOPE = ["global"];
-function configPathFor(vaultPath) {
-  return path.join(path.resolve(vaultPath), CONFIG_FILE);
-}
-function readConfigDocument(vaultPath) {
-  const configPath = configPathFor(vaultPath);
-  if (!fs.existsSync(configPath)) {
-    throw new Error(`No ClawVault config found at ${configPath}`);
-  }
-  try {
-    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("Config root must be a JSON object.");
-    }
-    return { ...parsed };
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`Failed to parse ${CONFIG_FILE}: ${error.message}`);
-    }
-    throw new Error(`Failed to parse ${CONFIG_FILE}.`);
-  }
-}
-function asStringArray(value) {
-  if (!Array.isArray(value)) {
-    return null;
-  }
-  const output = value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
-  return output.length > 0 ? output : null;
-}
-function asPositiveInteger(value) {
-  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
-    return value;
-  }
-  if (typeof value === "string") {
-    const parsed = Number.parseInt(value, 10);
-    if (Number.isInteger(parsed) && parsed > 0) {
-      return parsed;
-    }
-  }
-  return null;
-}
-function asBoolean(value) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    if (["true", "1", "yes", "on"].includes(normalized)) {
-      return true;
-    }
-    if (["false", "0", "no", "off"].includes(normalized)) {
-      return false;
-    }
-  }
-  return null;
-}
-function isObserveProvider(value) {
-  return typeof value === "string" && OBSERVE_PROVIDERS.includes(value);
-}
-function isObserverCompressionProvider(value) {
-  return typeof value === "string" && OBSERVER_COMPRESSION_PROVIDERS.includes(value);
-}
-function isTheme(value) {
-  return typeof value === "string" && THEMES.includes(value);
-}
-function isContextProfile(value) {
-  return typeof value === "string" && CONTEXT_PROFILES.includes(value);
-}
-function normalizeRouteTarget(target) {
-  const trimmed = target.trim().replace(/^\/+/, "").replace(/\/+$/, "");
-  if (!trimmed) {
-    throw new Error("Route target cannot be empty.");
-  }
-  const segments = trimmed.split("/").map((segment) => segment.trim()).filter(Boolean);
-  if (segments.length === 0) {
-    throw new Error("Route target cannot be empty.");
-  }
-  if (segments.some((segment) => segment === "." || segment === "..")) {
-    throw new Error(`Route target cannot contain relative path segments: ${target}`);
-  }
-  return segments.join("/");
-}
-function normalizeRouteRule(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return null;
-  }
-  const record = raw;
-  const pattern = typeof record.pattern === "string" ? record.pattern.trim() : "";
-  const target = typeof record.target === "string" ? record.target.trim() : "";
-  const priority = asPositiveInteger(record.priority);
-  if (!pattern || !target || priority === null) {
-    return null;
-  }
-  return {
-    pattern,
-    target: normalizeRouteTarget(target),
-    priority
-  };
-}
-function normalizeRoutes(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.map((entry) => normalizeRouteRule(entry)).filter((entry) => entry !== null).sort((left, right) => right.priority - left.priority || left.pattern.localeCompare(right.pattern));
-}
-function withDefaults(vaultPath, config) {
-  const resolvedPath = path.resolve(vaultPath);
-  const defaults = {
-    name: path.basename(resolvedPath),
-    categories: [...DEFAULT_CATEGORIES],
-    theme: DEFAULT_THEME,
-    observe: {
-      model: DEFAULT_OBSERVE_MODEL,
-      provider: DEFAULT_OBSERVE_PROVIDER
-    },
-    observer: {
-      compression: {}
-    },
-    context: {
-      maxResults: DEFAULT_CONTEXT_MAX_RESULTS,
-      defaultProfile: DEFAULT_CONTEXT_PROFILE
-    },
-    graph: {
-      maxHops: DEFAULT_GRAPH_MAX_HOPS
-    },
-    inject: {
-      maxResults: DEFAULT_INJECT_MAX_RESULTS,
-      useLlm: DEFAULT_INJECT_USE_LLM,
-      scope: [...DEFAULT_INJECT_SCOPE]
-    },
-    routes: []
-  };
-  const observeRecord = config.observe && typeof config.observe === "object" && !Array.isArray(config.observe) ? config.observe : {};
-  const contextRecord = config.context && typeof config.context === "object" && !Array.isArray(config.context) ? config.context : {};
-  const observerRecord = config.observer && typeof config.observer === "object" && !Array.isArray(config.observer) ? config.observer : {};
-  const compressionRecord = observerRecord.compression && typeof observerRecord.compression === "object" && !Array.isArray(observerRecord.compression) ? observerRecord.compression : {};
-  const graphRecord = config.graph && typeof config.graph === "object" && !Array.isArray(config.graph) ? config.graph : {};
-  const compressionProvider = isObserverCompressionProvider(compressionRecord.provider) ? compressionRecord.provider : void 0;
-  const compressionModel = typeof compressionRecord.model === "string" && compressionRecord.model.trim() ? compressionRecord.model.trim() : void 0;
-  const compressionBaseUrl = typeof compressionRecord.baseUrl === "string" && compressionRecord.baseUrl.trim() ? compressionRecord.baseUrl.trim() : void 0;
-  const compressionApiKey = typeof compressionRecord.apiKey === "string" && compressionRecord.apiKey.trim() ? compressionRecord.apiKey.trim() : void 0;
-  const normalizedCompression = {};
-  if (compressionProvider) {
-    normalizedCompression.provider = compressionProvider;
-  }
-  if (compressionModel) {
-    normalizedCompression.model = compressionModel;
-  }
-  if (compressionBaseUrl) {
-    normalizedCompression.baseUrl = compressionBaseUrl;
-  }
-  if (compressionApiKey) {
-    normalizedCompression.apiKey = compressionApiKey;
-  }
-  const injectRecord = config.inject && typeof config.inject === "object" && !Array.isArray(config.inject) ? config.inject : {};
-  return {
-    ...config,
-    name: typeof config.name === "string" && config.name.trim() ? config.name.trim() : defaults.name,
-    categories: asStringArray(config.categories) ?? defaults.categories,
-    theme: isTheme(config.theme) ? config.theme : defaults.theme,
-    observe: {
-      ...observeRecord,
-      model: typeof observeRecord.model === "string" && observeRecord.model.trim() ? observeRecord.model.trim() : defaults.observe.model,
-      provider: isObserveProvider(observeRecord.provider) ? observeRecord.provider : defaults.observe.provider
-    },
-    observer: {
-      ...observerRecord,
-      compression: normalizedCompression
-    },
-    context: {
-      ...contextRecord,
-      maxResults: asPositiveInteger(contextRecord.maxResults) ?? defaults.context.maxResults,
-      defaultProfile: isContextProfile(contextRecord.defaultProfile) ? contextRecord.defaultProfile : defaults.context.defaultProfile
-    },
-    graph: {
-      ...graphRecord,
-      maxHops: asPositiveInteger(graphRecord.maxHops) ?? defaults.graph.maxHops
-    },
-    inject: {
-      ...injectRecord,
-      maxResults: asPositiveInteger(injectRecord.maxResults) ?? defaults.inject.maxResults,
-      useLlm: asBoolean(injectRecord.useLlm) ?? defaults.inject.useLlm,
-      scope: asStringArray(injectRecord.scope) ?? (typeof injectRecord.scope === "string" ? injectRecord.scope.split(",").map((entry) => entry.trim()).filter(Boolean) : null) ?? [...defaults.inject.scope]
-    },
-    routes: normalizeRoutes(config.routes)
-  };
-}
-function listConfig(vaultPath) {
-  const config = readConfigDocument(vaultPath);
-  return withDefaults(vaultPath, config);
-}
-
-// src/lib/inject-utils.ts
-var fs3 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
-
-// src/lib/memory-graph.ts
-var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-var import_glob = require("glob");
-var MEMORY_GRAPH_SCHEMA_VERSION = 1;
-var GRAPH_INDEX_RELATIVE_PATH = path2.join(".clawvault", "graph-index.json");
-var WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
-var HASH_TAG_RE = /(^|\s)#([\w-]+)/g;
-var FRONTMATTER_RELATION_FIELDS = [
-  "related",
-  "depends_on",
-  "dependsOn",
-  "blocked_by",
-  "blocks",
-  "owner",
-  "project",
-  "people",
-  "links"
-];
-function normalizeRelativePath(value) {
-  return value.split(path2.sep).join("/").replace(/^\.\//, "").replace(/^\/+/, "");
-}
-function toNoteKey(relativePath) {
-  const normalized = normalizeRelativePath(relativePath);
-  return normalized.toLowerCase().endsWith(".md") ? normalized.slice(0, -3) : normalized;
-}
-function toNoteNodeId(noteKey) {
-  return `note:${noteKey}`;
-}
-function toTagNodeId(tag) {
-  return `tag:${tag.toLowerCase()}`;
-}
-function normalizeUnresolvedKey(raw) {
-  const normalized = raw.trim().toLowerCase().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\.md$/, "").replace(/[^a-z0-9/_-]+/g, "-").replace(/\/+/g, "/").replace(/-+/g, "-").replace(/^[-/]+|[-/]+$/g, "");
-  return normalized || "unknown";
-}
-function toUnresolvedNodeId(raw) {
-  return `unresolved:${normalizeUnresolvedKey(raw)}`;
-}
-function titleFromNoteKey(noteKey) {
-  const basename3 = noteKey.split("/").pop() ?? noteKey;
-  return basename3.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
-}
-function inferNodeType(relativePath, frontmatter) {
-  const normalized = normalizeRelativePath(relativePath).toLowerCase();
-  const category = normalized.split("/")[0] ?? "note";
-  const explicitType = typeof frontmatter.type === "string" ? frontmatter.type.toLowerCase() : "";
-  if (category.includes("daily") || explicitType === "daily") return "daily";
-  if (category === "observations" || explicitType === "observation") return "observation";
-  if (category === "handoffs" || explicitType === "handoff") return "handoff";
-  if (category === "decisions" || explicitType === "decision") return "decision";
-  if (category === "lessons" || explicitType === "lesson") return "lesson";
-  if (category === "projects" || explicitType === "project") return "project";
-  if (category === "people" || explicitType === "person") return "person";
-  if (category === "commitments" || explicitType === "commitment") return "commitment";
-  return "note";
-}
-function ensureClawvaultDir(vaultPath) {
-  const dirPath = path2.join(vaultPath, ".clawvault");
-  if (!fs2.existsSync(dirPath)) {
-    fs2.mkdirSync(dirPath, { recursive: true });
-  }
-  return dirPath;
-}
-function getGraphIndexPath(vaultPath) {
-  return path2.join(vaultPath, GRAPH_INDEX_RELATIVE_PATH);
-}
-function normalizeWikiTarget(target) {
-  let value = target.trim();
-  if (!value) return "";
-  const pipeIndex = value.indexOf("|");
-  if (pipeIndex >= 0) {
-    value = value.slice(0, pipeIndex);
-  }
-  const hashIndex = value.indexOf("#");
-  if (hashIndex >= 0) {
-    value = value.slice(0, hashIndex);
-  }
-  value = value.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
-  if (value.toLowerCase().endsWith(".md")) {
-    value = value.slice(0, -3);
-  }
-  return value.trim();
-}
-function collectTags(frontmatter, markdownContent) {
-  const tags = /* @__PURE__ */ new Set();
-  const fmTags = frontmatter.tags;
-  if (Array.isArray(fmTags)) {
-    for (const tag of fmTags) {
-      if (typeof tag === "string" && tag.trim()) tags.add(tag.trim().toLowerCase());
-    }
-  } else if (typeof fmTags === "string") {
-    for (const token of fmTags.split(",")) {
-      const normalized = token.trim().toLowerCase();
-      if (normalized) tags.add(normalized);
-    }
-  }
-  const markdownMatches = markdownContent.matchAll(HASH_TAG_RE);
-  for (const match of markdownMatches) {
-    const tag = match[2]?.trim().toLowerCase();
-    if (tag) tags.add(tag);
-  }
-  return [...tags].sort((a, b) => a.localeCompare(b));
-}
-function extractWikiTargets(markdownContent) {
-  const targets = /* @__PURE__ */ new Set();
-  for (const match of markdownContent.matchAll(WIKI_LINK_RE)) {
-    const candidate = match[1];
-    if (!candidate) continue;
-    const normalized = normalizeWikiTarget(candidate);
-    if (normalized) targets.add(normalized);
-  }
-  return [...targets];
-}
-function toStringArray(value) {
-  if (typeof value === "string") {
-    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((entry) => typeof entry === "string" ? entry.split(",") : []).map((entry) => entry.trim()).filter(Boolean);
-  }
-  return [];
-}
-function extractFrontmatterRelations(frontmatter) {
-  const relations = [];
-  for (const field of FRONTMATTER_RELATION_FIELDS) {
-    const raw = frontmatter[field];
-    for (const value of toStringArray(raw)) {
-      const normalized = normalizeWikiTarget(value);
-      if (normalized) relations.push({ field, target: normalized });
-    }
-  }
-  return relations;
-}
-function buildNoteRegistry(relativePaths) {
-  const byLowerPath = /* @__PURE__ */ new Map();
-  const byLowerBasename = /* @__PURE__ */ new Map();
-  for (const relativePath of relativePaths) {
-    const noteKey = toNoteKey(relativePath);
-    const lowerKey = noteKey.toLowerCase();
-    if (!byLowerPath.has(lowerKey)) {
-      byLowerPath.set(lowerKey, noteKey);
-    }
-    const base = noteKey.split("/").pop() ?? noteKey;
-    const lowerBase = base.toLowerCase();
-    const existing = byLowerBasename.get(lowerBase) ?? [];
-    existing.push(noteKey);
-    byLowerBasename.set(lowerBase, existing);
-  }
-  return { byLowerPath, byLowerBasename };
-}
-function resolveTargetNodeId(rawTarget, registry) {
-  const normalized = normalizeWikiTarget(rawTarget);
-  if (!normalized) {
-    return toUnresolvedNodeId(rawTarget);
-  }
-  const lowerTarget = normalized.toLowerCase();
-  const direct = registry.byLowerPath.get(lowerTarget);
-  if (direct) {
-    return toNoteNodeId(direct);
-  }
-  if (!normalized.includes("/")) {
-    const basenameMatches = registry.byLowerBasename.get(lowerTarget) ?? [];
-    if (basenameMatches.length === 1) {
-      return toNoteNodeId(basenameMatches[0]);
-    }
-  }
-  return toUnresolvedNodeId(normalized);
-}
-function createEdgeId(type, source, target, label) {
-  const suffix = label ? `:${label}` : "";
-  return `${type}:${source}->${target}${suffix}`;
-}
-function buildFragmentNode(id, title, type, category, pathValue, tags, missing, modifiedAt) {
-  return {
-    id,
-    title,
-    type,
-    category,
-    path: pathValue,
-    tags,
-    missing,
-    degree: 0,
-    modifiedAt
-  };
-}
-function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
-  const absolutePath = path2.join(vaultPath, relativePath);
-  const raw = fs2.readFileSync(absolutePath, "utf-8");
-  const parsed = (0, import_gray_matter.default)(raw);
-  const frontmatter = parsed.data ?? {};
-  const noteKey = toNoteKey(relativePath);
-  const noteNodeId = toNoteNodeId(noteKey);
-  const noteType = inferNodeType(relativePath, frontmatter);
-  const tags = collectTags(frontmatter, parsed.content);
-  const modifiedAt = new Date(mtimeMs).toISOString();
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  nodes.set(
-    noteNodeId,
-    buildFragmentNode(
-      noteNodeId,
-      typeof frontmatter.title === "string" && frontmatter.title.trim() ? frontmatter.title.trim() : titleFromNoteKey(noteKey),
-      noteType,
-      noteType,
-      normalizeRelativePath(relativePath),
-      tags,
-      false,
-      modifiedAt
-    )
-  );
-  for (const tag of tags) {
-    const tagNodeId = toTagNodeId(tag);
-    if (!nodes.has(tagNodeId)) {
-      nodes.set(tagNodeId, buildFragmentNode(tagNodeId, `#${tag}`, "tag", "tag", null, [], false, null));
-    }
-    const edgeId = createEdgeId("tag", noteNodeId, tagNodeId);
-    edges.set(edgeId, {
-      id: edgeId,
-      source: noteNodeId,
-      target: tagNodeId,
-      type: "tag"
-    });
-  }
-  const wikiTargets = extractWikiTargets(parsed.content);
-  for (const target of wikiTargets) {
-    const targetNodeId = resolveTargetNodeId(target, registry);
-    if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
-      nodes.set(
-        targetNodeId,
-        buildFragmentNode(targetNodeId, titleFromNoteKey(normalizeUnresolvedKey(target)), "unresolved", "unresolved", null, [], true, null)
-      );
-    }
-    const edgeId = createEdgeId("wiki_link", noteNodeId, targetNodeId);
-    edges.set(edgeId, {
-      id: edgeId,
-      source: noteNodeId,
-      target: targetNodeId,
-      type: "wiki_link"
-    });
-  }
-  for (const relation of extractFrontmatterRelations(frontmatter)) {
-    const targetNodeId = resolveTargetNodeId(relation.target, registry);
-    if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
-      nodes.set(
-        targetNodeId,
-        buildFragmentNode(
-          targetNodeId,
-          titleFromNoteKey(normalizeUnresolvedKey(relation.target)),
-          "unresolved",
-          "unresolved",
-          null,
-          [],
-          true,
-          null
-        )
-      );
-    }
-    const edgeId = createEdgeId("frontmatter_relation", noteNodeId, targetNodeId, relation.field);
-    edges.set(edgeId, {
-      id: edgeId,
-      source: noteNodeId,
-      target: targetNodeId,
-      type: "frontmatter_relation",
-      label: relation.field
-    });
-  }
-  return {
-    relativePath: normalizeRelativePath(relativePath),
-    mtimeMs,
-    nodes: [...nodes.values()],
-    edges: [...edges.values()]
-  };
-}
-function combineFragments(fragments, generatedAt) {
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  for (const fragment of Object.values(fragments)) {
-    for (const node of fragment.nodes) {
-      const existing = nodes.get(node.id);
-      if (!existing) {
-        nodes.set(node.id, { ...node, degree: 0 });
-      } else if (node.modifiedAt && (!existing.modifiedAt || node.modifiedAt > existing.modifiedAt)) {
-        nodes.set(node.id, { ...existing, ...node, degree: 0 });
-      }
-    }
-    for (const edge of fragment.edges) {
-      edges.set(edge.id, edge);
-    }
-  }
-  const degreeByNode = /* @__PURE__ */ new Map();
-  for (const edge of edges.values()) {
-    degreeByNode.set(edge.source, (degreeByNode.get(edge.source) ?? 0) + 1);
-    degreeByNode.set(edge.target, (degreeByNode.get(edge.target) ?? 0) + 1);
-  }
-  for (const node of nodes.values()) {
-    node.degree = degreeByNode.get(node.id) ?? 0;
-  }
-  const nodeTypeCounts = {};
-  for (const node of nodes.values()) {
-    nodeTypeCounts[node.type] = (nodeTypeCounts[node.type] ?? 0) + 1;
-  }
-  const edgeTypeCounts = {};
-  for (const edge of edges.values()) {
-    edgeTypeCounts[edge.type] = (edgeTypeCounts[edge.type] ?? 0) + 1;
-  }
-  const sortedNodes = [...nodes.values()].sort((a, b) => a.id.localeCompare(b.id));
-  const sortedEdges = [...edges.values()].sort((a, b) => a.id.localeCompare(b.id));
-  return {
-    schemaVersion: MEMORY_GRAPH_SCHEMA_VERSION,
-    nodes: sortedNodes,
-    edges: sortedEdges,
-    stats: {
-      generatedAt,
-      nodeCount: sortedNodes.length,
-      edgeCount: sortedEdges.length,
-      nodeTypeCounts,
-      edgeTypeCounts
-    }
-  };
-}
-function isValidIndex(index) {
-  if (!index || typeof index !== "object") return false;
-  const typed = index;
-  return typed.schemaVersion === MEMORY_GRAPH_SCHEMA_VERSION && typeof typed.vaultPath === "string" && typeof typed.generatedAt === "string" && Boolean(typed.files && typeof typed.files === "object") && Boolean(typed.graph && typeof typed.graph === "object");
-}
-function loadMemoryGraphIndex(vaultPath) {
-  const indexPath = getGraphIndexPath(path2.resolve(vaultPath));
-  if (!fs2.existsSync(indexPath)) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(fs2.readFileSync(indexPath, "utf-8"));
-    if (!isValidIndex(parsed)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
-  const vaultPath = path2.resolve(vaultPathInput);
-  ensureClawvaultDir(vaultPath);
-  const existing = options.forceFull ? null : loadMemoryGraphIndex(vaultPath);
-  const markdownFiles = await (0, import_glob.glob)("**/*.md", {
-    cwd: vaultPath,
-    ignore: ["**/node_modules/**", "**/.git/**", "**/.obsidian/**", "**/.trash/**", "**/ledger/archive/**"]
-  });
-  const normalizedFiles = markdownFiles.map(normalizeRelativePath).sort((a, b) => a.localeCompare(b));
-  const registry = buildNoteRegistry(normalizedFiles);
-  const nextFragments = {};
-  const existingFragments = existing?.files ?? {};
-  const currentFileSet = new Set(normalizedFiles);
-  for (const relativePath of normalizedFiles) {
-    const absolutePath = path2.join(vaultPath, relativePath);
-    const stat = fs2.statSync(absolutePath);
-    const existingFragment = existingFragments[relativePath];
-    if (!options.forceFull && existingFragment && existingFragment.mtimeMs === stat.mtimeMs) {
-      nextFragments[relativePath] = existingFragment;
-      continue;
-    }
-    nextFragments[relativePath] = parseFileFragment(vaultPath, relativePath, stat.mtimeMs, registry);
-  }
-  for (const [relativePath, fragment] of Object.entries(existingFragments)) {
-    if (!currentFileSet.has(relativePath)) {
-      continue;
-    }
-    if (!nextFragments[relativePath]) {
-      nextFragments[relativePath] = fragment;
-    }
-  }
-  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const graph = combineFragments(nextFragments, generatedAt);
-  const nextIndex = {
-    schemaVersion: MEMORY_GRAPH_SCHEMA_VERSION,
-    vaultPath,
-    generatedAt,
-    files: nextFragments,
-    graph
-  };
-  fs2.writeFileSync(getGraphIndexPath(vaultPath), JSON.stringify(nextIndex, null, 2));
-  return nextIndex;
-}
-async function getMemoryGraph(vaultPath, options = {}) {
-  if (options.refresh === true) {
-    return (await buildOrUpdateMemoryGraphIndex(vaultPath, { forceFull: true })).graph;
-  }
-  return (await buildOrUpdateMemoryGraphIndex(vaultPath)).graph;
-}
-
-// src/lib/claude-credentials.ts
-var import_child_process = require("child_process");
-var import_fs = require("fs");
-var import_os = require("os");
-var import_path = require("path");
-var CLAUDE_CODE_SERVICE = "Claude Code-credentials";
-var CLAUDE_CODE_ACCOUNT = "Claude Code";
-var OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-var TOKEN_REFRESH_URL = "https://console.anthropic.com/v1/oauth/token";
-var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
-function readClaudeCliCredentials(opts) {
-  if (process.platform === "darwin") {
-    try {
-      const raw = (0, import_child_process.execFileSync)(
-        "security",
-        ["find-generic-password", "-s", CLAUDE_CODE_SERVICE, "-w"],
-        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
-      ).trim();
-      const parsed = parseCredentialsJson(raw);
-      if (parsed) return parsed;
-    } catch {
-    }
-  }
-  const home = opts?.homeDir ?? (0, import_os.homedir)();
-  const credFile = (0, import_path.join)(home, ".claude", ".credentials.json");
-  if (!(0, import_fs.existsSync)(credFile)) {
-    return null;
-  }
-  try {
-    const raw = (0, import_fs.readFileSync)(credFile, "utf8");
-    return parseCredentialsJson(raw);
-  } catch {
-    return null;
-  }
-}
-function parseCredentialsJson(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    const oauth = parsed.claudeAiOauth;
-    if (oauth && typeof oauth.accessToken === "string" && typeof oauth.refreshToken === "string" && typeof oauth.expiresAt === "number") {
-      return {
-        accessToken: oauth.accessToken,
-        refreshToken: oauth.refreshToken,
-        expiresAt: oauth.expiresAt
-      };
-    }
-  } catch {
-  }
-  return null;
-}
-async function refreshClaudeOAuthToken(refreshToken, fetchImpl) {
-  const f = fetchImpl ?? fetch;
-  const response = await f(TOKEN_REFRESH_URL, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      grant_type: "refresh_token",
-      client_id: OAUTH_CLIENT_ID,
-      refresh_token: refreshToken
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`OAuth token refresh failed (${response.status})`);
-  }
-  const data = await response.json();
-  return {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token,
-    expiresAt: Date.now() + data.expires_in * 1e3
-  };
-}
-function writeClaudeCliCredentials(cred, opts) {
-  const payload = JSON.stringify({ claudeAiOauth: cred });
-  if (process.platform === "darwin") {
-    try {
-      (0, import_child_process.execFileSync)(
-        "security",
-        ["add-generic-password", "-U", "-s", CLAUDE_CODE_SERVICE, "-a", CLAUDE_CODE_ACCOUNT, "-w", payload],
-        { stdio: "ignore" }
-      );
-      return;
-    } catch {
-    }
-  }
-  const home = opts?.homeDir ?? (0, import_os.homedir)();
-  const credFile = (0, import_path.join)(home, ".claude", ".credentials.json");
-  (0, import_fs.writeFileSync)(credFile, payload, "utf8");
-}
-async function resolveClaudeOAuthToken(opts) {
-  const cred = readClaudeCliCredentials(opts);
-  if (!cred) {
-    return null;
-  }
-  if (cred.expiresAt < Date.now() + EXPIRY_BUFFER_MS) {
-    try {
-      const refreshed = await refreshClaudeOAuthToken(cred.refreshToken, opts?.fetchImpl);
-      writeClaudeCliCredentials(refreshed, opts);
-      return refreshed.accessToken;
-    } catch {
-      return cred.accessToken;
-    }
-  }
-  return cred.accessToken;
-}
-
-// src/lib/llm-provider.ts
-var DEFAULT_MODELS = {
-  anthropic: "claude-haiku-4-5",
-  openai: "gpt-4o-mini",
-  gemini: "gemini-2.0-flash"
-};
-async function resolveAnthropicAuth(fetchImpl) {
-  const oauthEnvToken = process.env.ANTHROPIC_OAUTH_TOKEN?.trim();
-  if (oauthEnvToken) {
-    return { token: oauthEnvToken, isOAuth: true };
-  }
-  const apiKey = process.env.ANTHROPIC_API_KEY?.trim();
-  if (apiKey) {
-    return { token: apiKey, isOAuth: false };
-  }
-  if (process.env.CLAWVAULT_CLAUDE_AUTH) {
-    const oauthToken = await resolveClaudeOAuthToken({ fetchImpl });
-    if (oauthToken) {
-      return { token: oauthToken, isOAuth: true };
-    }
-  }
-  return null;
-}
-async function resolveLlmProvider(fetchImpl) {
-  if (process.env.CLAWVAULT_NO_LLM) {
-    return null;
-  }
-  const anthropicAuth = await resolveAnthropicAuth(fetchImpl);
-  if (anthropicAuth) {
-    return "anthropic";
-  }
-  if (process.env.OPENAI_API_KEY) {
-    return "openai";
-  }
-  if (process.env.GEMINI_API_KEY) {
-    return "gemini";
-  }
-  return null;
-}
-async function requestLlmCompletion(options) {
-  const provider = options.provider ?? await resolveLlmProvider(options.fetchImpl);
-  if (!provider) {
-    return "";
-  }
-  if (provider === "anthropic") {
-    return callAnthropic(options, provider);
-  }
-  if (provider === "gemini") {
-    return callGemini(options, provider);
-  }
-  return callOpenAI(options, provider);
-}
-async function callAnthropic(options, provider) {
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const auth = await resolveAnthropicAuth(fetchImpl);
-  if (!auth) {
-    return "";
-  }
-  const headers = auth.isOAuth ? {
-    "content-type": "application/json",
-    "authorization": `Bearer ${auth.token}`,
-    "anthropic-version": "2023-06-01",
-    "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
-    "x-app": "cli",
-    "user-agent": "claude-cli/1.0.0 (external, cli)"
-  } : {
-    "content-type": "application/json",
-    "x-api-key": auth.token,
-    "anthropic-version": "2023-06-01"
-  };
-  const systemMessages = [];
-  if (auth.isOAuth) {
-    systemMessages.push({ type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." });
-  }
-  if (options.systemPrompt?.trim()) {
-    systemMessages.push({ type: "text", text: options.systemPrompt.trim() });
-  }
-  const body = {
-    model: options.model ?? DEFAULT_MODELS[provider],
-    temperature: options.temperature ?? 0.1,
-    max_tokens: options.maxTokens ?? 1200,
-    messages: [{ role: "user", content: options.prompt }]
-  };
-  if (systemMessages.length > 0) {
-    body.system = systemMessages;
-  }
-  const response = await fetchImpl("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    throw new Error(`Anthropic request failed (${response.status})`);
-  }
-  const payload = await response.json();
-  return payload.content?.filter((entry) => entry.type === "text" && entry.text).map((entry) => entry.text).join("\n").trim() ?? "";
-}
-async function callOpenAI(options, provider) {
-  const apiKey = process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    return "";
-  }
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const messages = [];
-  if (options.systemPrompt?.trim()) {
-    messages.push({ role: "system", content: options.systemPrompt.trim() });
-  }
-  messages.push({ role: "user", content: options.prompt });
-  const response = await fetchImpl("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({
-      model: options.model ?? DEFAULT_MODELS[provider],
-      temperature: options.temperature ?? 0.1,
-      max_tokens: options.maxTokens ?? 1200,
-      messages
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`OpenAI request failed (${response.status})`);
-  }
-  const payload = await response.json();
-  return payload.choices?.[0]?.message?.content?.trim() ?? "";
-}
-async function callGemini(options, provider) {
-  const apiKey = process.env.GEMINI_API_KEY;
-  if (!apiKey) {
-    return "";
-  }
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const model = options.model ?? DEFAULT_MODELS[provider];
-  const response = await fetchImpl(
-    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
-    {
-      method: "POST",
-      headers: { "content-type": "application/json", "x-goog-api-key": apiKey },
-      body: JSON.stringify({
-        contents: [{ parts: [{ text: options.prompt }] }],
-        generationConfig: {
-          temperature: options.temperature ?? 0.1,
-          maxOutputTokens: options.maxTokens ?? 1200
-        }
-      })
-    }
-  );
-  if (!response.ok) {
-    throw new Error(`Gemini request failed (${response.status})`);
-  }
-  const payload = await response.json();
-  return payload.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "";
-}
-
-// src/lib/inject-utils.ts
-var INJECTABLE_CATEGORIES = ["rules", "decisions", "preferences"];
-var DEFAULT_CATEGORY_PRIORITY = {
-  rules: 100,
-  decisions: 80,
-  preferences: 60
-};
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "and",
-  "are",
-  "as",
-  "at",
-  "be",
-  "by",
-  "for",
-  "from",
-  "in",
-  "is",
-  "it",
-  "of",
-  "on",
-  "or",
-  "that",
-  "the",
-  "this",
-  "to",
-  "with",
-  "you",
-  "your",
-  "we",
-  "our",
-  "their",
-  "they",
-  "them",
-  "i"
-]);
-function normalizeText(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
-}
-function normalizeScopeValue(value) {
-  return value.trim().toLowerCase().replace(/\s+/g, "-");
-}
-function toRelativePath(vaultPath, absolutePath) {
-  return path3.relative(vaultPath, absolutePath).split(path3.sep).join("/");
-}
-function toNoteNodeId2(relativePath) {
-  const normalized = relativePath.toLowerCase().endsWith(".md") ? relativePath.slice(0, -3) : relativePath;
-  return `note:${normalized}`;
-}
-function extractHeadingTitle(content) {
-  const match = content.match(/^#\s+(.+)$/m);
-  return match?.[1]?.trim() || null;
-}
-function toStringArray2(value) {
-  if (typeof value === "string") {
-    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((entry) => typeof entry === "string" ? entry.split(",") : []).map((entry) => entry.trim()).filter(Boolean);
-  }
-  return [];
-}
-function parsePriority(frontmatter, category) {
-  const explicit = frontmatter.priority;
-  if (typeof explicit === "number" && Number.isFinite(explicit)) {
-    return Math.max(1, Math.round(explicit));
-  }
-  if (typeof explicit === "string") {
-    const parsed = Number.parseFloat(explicit);
-    if (Number.isFinite(parsed)) {
-      return Math.max(1, Math.round(parsed));
-    }
-  }
-  const importance = frontmatter.importance;
-  if (typeof importance === "number" && Number.isFinite(importance) && importance >= 0 && importance <= 1) {
-    return Math.max(1, Math.round(importance * 100));
-  }
-  return DEFAULT_CATEGORY_PRIORITY[category];
-}
-function deriveTitle(frontmatter, markdownContent, fallbackPath) {
-  if (typeof frontmatter.title === "string" && frontmatter.title.trim()) {
-    return frontmatter.title.trim();
-  }
-  const heading = extractHeadingTitle(markdownContent);
-  if (heading) {
-    return heading;
-  }
-  return path3.basename(fallbackPath, ".md").replace(/[-_]+/g, " ").trim();
-}
-function deriveTriggers(params) {
-  const { category, frontmatter, title, relativePath } = params;
-  const explicitTriggers = toStringArray2(frontmatter.triggers);
-  const tags = toStringArray2(frontmatter.tags);
-  const aliases = toStringArray2(frontmatter.aliases);
-  const baseName = path3.basename(relativePath, ".md").replace(/[-_]+/g, " ").trim();
-  const normalizedTitle = title.trim();
-  const triggerSet = /* @__PURE__ */ new Set();
-  for (const value of [...explicitTriggers, ...tags, ...aliases]) {
-    if (value.trim()) {
-      triggerSet.add(value.trim());
-    }
-  }
-  if (triggerSet.size === 0 || category !== "rules") {
-    if (normalizedTitle) {
-      triggerSet.add(normalizedTitle);
-    }
-    if (baseName) {
-      triggerSet.add(baseName);
-    }
-  }
-  for (const keyword of tokenizeKeywords(normalizedTitle)) {
-    if (keyword.length >= 4) {
-      triggerSet.add(keyword);
-    }
-  }
-  return [...triggerSet];
-}
-function deriveScope(frontmatter) {
-  const raw = [
-    ...toStringArray2(frontmatter.scope),
-    ...toStringArray2(frontmatter.scopes)
-  ];
-  return [...new Set(raw.map(normalizeScopeValue).filter(Boolean))];
-}
-function tokenizeKeywords(value) {
-  const normalized = normalizeText(value);
-  if (!normalized) {
-    return [];
-  }
-  const tokens = normalized.split(" ").filter(Boolean);
-  const unique = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const token of tokens) {
-    if (token.length < 3 || STOP_WORDS.has(token) || seen.has(token)) {
-      continue;
-    }
-    seen.add(token);
-    unique.push(token);
-  }
-  return unique;
-}
-function collectMarkdownFiles(rootPath, currentPath, collected) {
-  if (!fs3.existsSync(currentPath)) {
-    return;
-  }
-  const entries = fs3.readdirSync(currentPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const absolutePath = path3.join(currentPath, entry.name);
-    if (entry.isDirectory()) {
-      collectMarkdownFiles(rootPath, absolutePath, collected);
-      continue;
-    }
-    if (entry.isFile() && entry.name.endsWith(".md")) {
-      collected.push(toRelativePath(rootPath, absolutePath));
-    }
-  }
-}
-function parseInjectableFile(vaultPath, category, relativePath) {
-  const absolutePath = path3.join(vaultPath, relativePath);
-  if (!fs3.existsSync(absolutePath)) {
-    return null;
-  }
-  try {
-    const raw = fs3.readFileSync(absolutePath, "utf-8");
-    const parsed = (0, import_gray_matter2.default)(raw);
-    const frontmatter = parsed.data ?? {};
-    const title = deriveTitle(frontmatter, parsed.content, relativePath);
-    const triggers = deriveTriggers({ category, frontmatter, title, relativePath });
-    const scope = deriveScope(frontmatter);
-    const priority = parsePriority(frontmatter, category);
-    const searchKeywordSet = /* @__PURE__ */ new Set();
-    for (const trigger of triggers) {
-      for (const keyword of tokenizeKeywords(trigger)) {
-        searchKeywordSet.add(keyword);
-      }
-    }
-    for (const keyword of tokenizeKeywords(title)) {
-      searchKeywordSet.add(keyword);
-    }
-    return {
-      id: relativePath,
-      category,
-      relativePath,
-      title,
-      content: parsed.content.trim(),
-      triggers,
-      scope,
-      priority,
-      searchKeywords: [...searchKeywordSet],
-      noteNodeId: toNoteNodeId2(relativePath)
-    };
-  } catch {
-    return null;
-  }
-}
-function indexInjectableItems(vaultPathInput) {
-  const vaultPath = path3.resolve(vaultPathInput);
-  const items = [];
-  for (const category of INJECTABLE_CATEGORIES) {
-    const categoryRoot = path3.join(vaultPath, category);
-    const markdownFiles = [];
-    collectMarkdownFiles(vaultPath, categoryRoot, markdownFiles);
-    for (const relativePath of markdownFiles.sort((left, right) => left.localeCompare(right))) {
-      const parsed = parseInjectableFile(vaultPath, category, relativePath);
-      if (parsed) {
-        items.push(parsed);
-      }
-    }
-  }
-  return items;
-}
-function containsPhrase(normalizedHaystack, phrase) {
-  const normalizedPhrase = normalizeText(phrase);
-  if (!normalizedPhrase) {
-    return false;
-  }
-  const haystack = ` ${normalizedHaystack} `;
-  const needle = ` ${normalizedPhrase} `;
-  return haystack.includes(needle);
-}
-function collectNodeAliases(node) {
-  const aliases = /* @__PURE__ */ new Set();
-  if (node.title) {
-    aliases.add(node.title);
-  }
-  if (node.path) {
-    const basename3 = path3.basename(node.path, ".md");
-    aliases.add(basename3.replace(/[-_]+/g, " "));
-    aliases.add(basename3);
-  }
-  return [...aliases].map((alias) => normalizeText(alias)).filter((alias) => alias.length >= 3);
-}
-function isEligibleGraphNode(node) {
-  if (!node) return false;
-  if (node.missing) return false;
-  if (node.type === "tag" || node.type === "unresolved") return false;
-  return Boolean(node.path);
-}
-function buildDeterministicEntityMatches(message, graph) {
-  const normalizedMessage = normalizeText(message);
-  const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
-  const directAliasesByNode = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    if (!isEligibleGraphNode(node)) {
-      continue;
-    }
-    const aliases = collectNodeAliases(node);
-    for (const alias of aliases) {
-      if (containsPhrase(normalizedMessage, alias)) {
-        const bucket = directAliasesByNode.get(node.id) ?? /* @__PURE__ */ new Set();
-        bucket.add(alias);
-        directAliasesByNode.set(node.id, bucket);
-      }
-    }
-  }
-  const oneHopSourcesByNode = /* @__PURE__ */ new Map();
-  if (directAliasesByNode.size === 0) {
-    return { directAliasesByNode, oneHopSourcesByNode };
-  }
-  for (const edge of graph.edges) {
-    const leftDirect = directAliasesByNode.has(edge.source);
-    const rightDirect = directAliasesByNode.has(edge.target);
-    if (!leftDirect && !rightDirect) {
-      continue;
-    }
-    if (leftDirect && !rightDirect) {
-      const target = nodeById.get(edge.target);
-      const source = nodeById.get(edge.source);
-      if (!isEligibleGraphNode(target) || !isEligibleGraphNode(source)) {
-        continue;
-      }
-      const bucket = oneHopSourcesByNode.get(target.id) ?? /* @__PURE__ */ new Set();
-      bucket.add(source.title || source.id);
-      oneHopSourcesByNode.set(target.id, bucket);
-      continue;
-    }
-    if (rightDirect && !leftDirect) {
-      const source = nodeById.get(edge.source);
-      const target = nodeById.get(edge.target);
-      if (!isEligibleGraphNode(source) || !isEligibleGraphNode(target)) {
-        continue;
-      }
-      const bucket = oneHopSourcesByNode.get(source.id) ?? /* @__PURE__ */ new Set();
-      bucket.add(target.title || target.id);
-      oneHopSourcesByNode.set(source.id, bucket);
-    }
-  }
-  return { directAliasesByNode, oneHopSourcesByNode };
-}
-function normalizeScopeInput(scope) {
-  if (!scope) {
-    return [];
-  }
-  if (Array.isArray(scope)) {
-    return [...new Set(scope.map(normalizeScopeValue).filter(Boolean))];
-  }
-  return [...new Set(scope.split(",").map(normalizeScopeValue).filter(Boolean))];
-}
-function scopeMatches(itemScope, requestedScope) {
-  if (requestedScope.length === 0 || requestedScope.includes("global") || requestedScope.includes("*")) {
-    return true;
-  }
-  if (itemScope.length === 0 || itemScope.includes("global") || itemScope.includes("*")) {
-    return true;
-  }
-  return itemScope.some((scope) => requestedScope.includes(scope));
-}
-function deterministicInjectMatches(params) {
-  const message = params.message.trim();
-  if (!message) {
-    return [];
-  }
-  const requestedScope = normalizeScopeInput(params.scope);
-  const messageKeywords = new Set(tokenizeKeywords(message));
-  const { directAliasesByNode, oneHopSourcesByNode } = buildDeterministicEntityMatches(message, params.graph);
-  const normalizedMessage = normalizeText(message);
-  const matches = [];
-  for (const item of params.items) {
-    if (!scopeMatches(item.scope, requestedScope)) {
-      continue;
-    }
-    const reasons = [];
-    let signalScore = 0;
-    const triggerHits = [];
-    for (const trigger of item.triggers) {
-      if (containsPhrase(normalizedMessage, trigger)) {
-        triggerHits.push(trigger);
-      }
-    }
-    if (triggerHits.length > 0) {
-      const weight = Math.min(30, 12 + triggerHits.length * 6);
-      signalScore += weight;
-      reasons.push({
-        source: "trigger",
-        value: triggerHits.slice(0, 3).join(", "),
-        weight
-      });
-    }
-    const keywordHits = item.searchKeywords.filter((keyword) => messageKeywords.has(keyword));
-    if (keywordHits.length > 0) {
-      const weight = Math.min(18, keywordHits.length * 4);
-      signalScore += weight;
-      reasons.push({
-        source: "keyword",
-        value: keywordHits.slice(0, 4).join(", "),
-        weight
-      });
-    }
-    const directAliases = directAliasesByNode.get(item.noteNodeId);
-    if (directAliases && directAliases.size > 0) {
-      const weight = 18;
-      signalScore += weight;
-      reasons.push({
-        source: "entity",
-        value: [...directAliases].slice(0, 3).join(", "),
-        weight
-      });
-    }
-    const oneHopSources = oneHopSourcesByNode.get(item.noteNodeId);
-    if (oneHopSources && oneHopSources.size > 0) {
-      const weight = 10;
-      signalScore += weight;
-      reasons.push({
-        source: "graph_1hop",
-        value: `via ${[...oneHopSources].slice(0, 2).join(", ")}`,
-        weight
-      });
-    }
-    if (reasons.length === 0) {
-      continue;
-    }
-    const deterministicScore = item.priority + signalScore;
-    matches.push({
-      item,
-      score: deterministicScore,
-      deterministicScore,
-      llmScore: null,
-      reasons
-    });
-  }
-  return matches.sort((left, right) => {
-    if (right.score !== left.score) {
-      return right.score - left.score;
-    }
-    if (right.item.priority !== left.item.priority) {
-      return right.item.priority - left.item.priority;
-    }
-    return left.item.relativePath.localeCompare(right.item.relativePath);
-  });
-}
-function parseLlmMatches(rawOutput) {
-  const cleaned = rawOutput.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
-  if (!cleaned) {
-    return [];
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(cleaned);
-  } catch {
-    return [];
-  }
-  const rows = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.matches) ? parsed.matches : [];
-  return rows.flatMap((row) => {
-    if (!row || typeof row !== "object" || Array.isArray(row)) {
-      return [];
-    }
-    const id = typeof row.id === "string" ? row.id.trim() : "";
-    const scoreRaw = row.score;
-    const score = typeof scoreRaw === "number" ? scoreRaw : Number.NaN;
-    const reason = typeof row.reason === "string" ? row.reason.trim() : "";
-    if (!id || !Number.isFinite(score)) {
-      return [];
-    }
-    return [{
-      id,
-      score: Math.max(0, Math.min(1, score)),
-      reason
-    }];
-  });
-}
-async function addLlmIntentMatches(params) {
-  if (params.items.length === 0) {
-    return params.matches;
-  }
-  const existingById = new Map(params.matches.map((match) => [match.item.id, match]));
-  const candidates = [...params.items].sort((left, right) => right.priority - left.priority || left.relativePath.localeCompare(right.relativePath)).slice(0, 40);
-  const prompt = [
-    "You rank ClawVault injectable memory items for an agent prompt.",
-    "Return strict JSON only in this shape:",
-    '{"matches":[{"id":"<candidate id>","score":0.0-1.0,"reason":"short why"}]}',
-    "Only include candidate IDs from the list below.",
-    "Use higher scores for items that are relevant to the user message intent even if wording differs.",
-    "",
-    `User message: ${params.message}`,
-    "",
-    "Candidates:",
-    ...candidates.map((item) => {
-      const preview = item.content.replace(/\s+/g, " ").trim().slice(0, 220);
-      return [
-        `- id: ${item.id}`,
-        `  category: ${item.category}`,
-        `  title: ${item.title}`,
-        `  triggers: ${item.triggers.join(", ") || "(none)"}`,
-        `  scope: ${item.scope.join(", ") || "(none)"}`,
-        `  content: ${preview || "(empty)"}`
-      ].join("\n");
-    })
-  ].join("\n");
-  const output = await requestLlmCompletion({
-    provider: params.provider,
-    prompt,
-    model: params.model,
-    temperature: 0.1,
-    maxTokens: 1200,
-    fetchImpl: params.fetchImpl,
-    systemPrompt: "You are an intent ranking engine. Respond with valid JSON only."
-  });
-  const parsed = parseLlmMatches(output);
-  if (parsed.length === 0) {
-    return params.matches;
-  }
-  const itemById = new Map(params.items.map((item) => [item.id, item]));
-  for (const row of parsed) {
-    const candidate = itemById.get(row.id);
-    if (!candidate) {
-      continue;
-    }
-    const llmWeight = row.score * 24;
-    const reason = row.reason || `intent score ${row.score.toFixed(2)}`;
-    const existing = existingById.get(row.id);
-    if (existing) {
-      existing.llmScore = row.score;
-      existing.score += llmWeight;
-      existing.reasons.push({
-        source: "llm_intent",
-        value: reason,
-        weight: llmWeight
-      });
-      continue;
-    }
-    if (row.score < 0.45) {
-      continue;
-    }
-    const seededDeterministic = candidate.priority * 0.2;
-    existingById.set(row.id, {
-      item: candidate,
-      deterministicScore: seededDeterministic,
-      llmScore: row.score,
-      score: seededDeterministic + llmWeight,
-      reasons: [{
-        source: "llm_intent",
-        value: reason,
-        weight: llmWeight
-      }]
-    });
-  }
-  return [...existingById.values()].sort((left, right) => {
-    if (right.score !== left.score) {
-      return right.score - left.score;
-    }
-    if (right.item.priority !== left.item.priority) {
-      return right.item.priority - left.item.priority;
-    }
-    return left.item.relativePath.localeCompare(right.item.relativePath);
-  });
-}
-async function readGraph(vaultPath) {
-  const resolvedPath = path3.resolve(vaultPath);
-  const loaded = loadMemoryGraphIndex(resolvedPath);
-  if (loaded?.graph) {
-    return loaded.graph;
-  }
-  try {
-    return await getMemoryGraph(resolvedPath);
-  } catch {
-    return {
-      schemaVersion: 1,
-      nodes: [],
-      edges: [],
-      stats: {
-        generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-        nodeCount: 0,
-        edgeCount: 0,
-        nodeTypeCounts: {},
-        edgeTypeCounts: {}
-      }
-    };
-  }
-}
-async function runPromptInjection(vaultPathInput, message, options = {}) {
-  const vaultPath = path3.resolve(vaultPathInput);
-  const maxResults = Math.max(1, Math.floor(options.maxResults ?? 8));
-  const useLlm = options.useLlm ?? false;
-  const startDeterministic = Date.now();
-  const items = indexInjectableItems(vaultPath);
-  const graph = await readGraph(vaultPath);
-  let matches = deterministicInjectMatches({
-    message,
-    items,
-    graph,
-    scope: options.scope
-  });
-  const deterministicMs = Date.now() - startDeterministic;
-  let llmProvider = null;
-  if (useLlm) {
-    llmProvider = await resolveLlmProvider();
-    if (llmProvider) {
-      try {
-        matches = await addLlmIntentMatches({
-          message,
-          items,
-          matches,
-          provider: llmProvider,
-          model: options.model,
-          fetchImpl: options.fetchImpl
-        });
-      } catch {
-      }
-    }
-  }
-  return {
-    message,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    deterministicMs,
-    llmProvider,
-    usedLlm: Boolean(useLlm && llmProvider),
-    matches: matches.slice(0, maxResults)
-  };
-}
-
-// src/commands/inject.ts
-function asPositiveInteger2(value, fallback) {
-  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
-    return value;
-  }
-  if (typeof value === "string") {
-    const parsed = Number.parseInt(value, 10);
-    if (Number.isInteger(parsed) && parsed > 0) {
-      return parsed;
-    }
-  }
-  return fallback;
-}
-function asBoolean2(value, fallback) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    if (["true", "1", "yes", "on"].includes(normalized)) {
-      return true;
-    }
-    if (["false", "0", "no", "off"].includes(normalized)) {
-      return false;
-    }
-  }
-  return fallback;
-}
-function asStringArray2(value, fallback) {
-  if (Array.isArray(value)) {
-    const normalized = value.flatMap((entry) => typeof entry === "string" ? entry.split(",") : []).map((entry) => entry.trim()).filter(Boolean);
-    if (normalized.length > 0) {
-      return normalized;
-    }
-  }
-  if (typeof value === "string") {
-    const normalized = value.split(",").map((entry) => entry.trim()).filter(Boolean);
-    if (normalized.length > 0) {
-      return normalized;
-    }
-  }
-  return fallback;
-}
-function readInjectConfig(vaultPath) {
-  const config = listConfig(vaultPath);
-  const inject = config.inject ?? {};
-  return {
-    maxResults: asPositiveInteger2(inject.maxResults, 8),
-    useLlm: asBoolean2(inject.useLlm, true),
-    scope: asStringArray2(inject.scope, ["global"])
-  };
-}
-function formatReasons(match) {
-  return match.reasons.map((reason) => `${reason.source}:${reason.value}`).join(" | ");
-}
-function formatInjectMarkdown(result) {
-  const lines = [];
-  lines.push(`## Prompt Injection for: ${result.message}`);
-  lines.push("");
-  lines.push(`- Deterministic matching: ${result.deterministicMs}ms`);
-  lines.push(`- LLM fuzzy matching: ${result.usedLlm ? `enabled (${result.llmProvider})` : "disabled"}`);
-  lines.push("");
-  if (result.matches.length === 0) {
-    lines.push("_No injectable rules matched this message._");
-    return lines.join("\n");
-  }
-  for (const [index, match] of result.matches.entries()) {
-    lines.push(`### ${index + 1}. ${match.item.title}`);
-    lines.push(`- Path: ${match.item.relativePath}`);
-    lines.push(`- Category: ${match.item.category}`);
-    lines.push(`- Priority: ${match.item.priority}`);
-    lines.push(`- Score: ${match.score.toFixed(2)}`);
-    lines.push(`- Match sources: ${formatReasons(match)}`);
-    lines.push("");
-    lines.push(match.item.content || "_No content._");
-    lines.push("");
-  }
-  return lines.join("\n").trimEnd();
-}
-async function buildInjectionResult(message, options) {
-  const normalizedMessage = message.trim();
-  if (!normalizedMessage) {
-    throw new Error("Message is required for inject.");
-  }
-  const vaultPath = path4.resolve(options.vaultPath);
-  const config = readInjectConfig(vaultPath);
-  const maxResults = options.maxResults ?? config.maxResults;
-  const useLlm = options.useLlm ?? config.useLlm;
-  const scope = options.scope ?? config.scope;
-  return runPromptInjection(vaultPath, normalizedMessage, {
-    maxResults,
-    useLlm,
-    scope,
-    model: options.model
-  });
-}
-async function injectCommand(message, options) {
-  const result = await buildInjectionResult(message, options);
-  if ((options.format ?? "markdown") === "json") {
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-  console.log(formatInjectMarkdown(result));
-}
-function parsePositiveInteger(raw, label) {
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`Invalid ${label}: ${raw}`);
-  }
-  return parsed;
-}
-function registerInjectCommand(program) {
-  program.command("inject <message>").description("Inject rules, decisions, and preferences into your prompt context").option("-v, --vault <path>", "Vault path").option("-n, --max-results <n>", "Maximum number of injected items").option("--scope <scope>", "Comma-separated scope filter override").option("--enable-llm", "Enable optional LLM fuzzy intent matching").option("--disable-llm", "Disable optional LLM fuzzy intent matching").option("--format <format>", "Output format (markdown|json)", "markdown").option("--model <model>", "Override LLM model when fuzzy matching is enabled").action(async (message, rawOptions) => {
-    const format = rawOptions.format === "json" ? "json" : "markdown";
-    const useLlm = rawOptions.enableLlm ? true : rawOptions.disableLlm ? false : void 0;
-    await injectCommand(message, {
-      vaultPath: rawOptions.vault ?? process.env.CLAWVAULT_PATH ?? process.cwd(),
-      maxResults: rawOptions.maxResults ? parsePositiveInteger(rawOptions.maxResults, "max-results") : void 0,
-      useLlm,
-      scope: rawOptions.scope,
-      format,
-      model: rawOptions.model
-    });
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildInjectionResult,
-  injectCommand,
-  registerInjectCommand
-});