clawvault 3.2.1 → 3.4.0

package/bin/register-query-commands.test.js

@@ -20,6 +20,21 @@ function buildProgram() {
 }
 
 describe('register-query-commands', () => {
+  it('registers recall command with strategy options', () => {
+    const program = buildProgram();
+    const recallCommand = program.commands.find((command) => command.name() === 'recall');
+    expect(recallCommand).toBeDefined();
+
+    const flags = recallCommand?.options.map((option) => option.flags) ?? [];
+    expect(flags).toEqual(expect.arrayContaining([
+      '-n, --limit <n>',
+      '--strategy <strategy>',
+      '--json',
+      '--no-sources',
+      '-v, --vault <path>'
+    ]));
+  });
+
   it('documents inject command options and config-backed defaults', () => {
     const program = buildProgram();
     const injectCommand = program.commands.find((command) => command.name() === 'inject');

package/bin/test-helpers/cli-command-fixtures.js

@@ -30,6 +30,7 @@ export function stubResolveVaultPath(value) {
 export function createVaultStub(overrides = {}) {
   return {
     store: async () => ({}),
+    patch: async () => ({}),
     capture: async () => ({}),
     find: async () => [],
     vsearch: async () => [],

package/dist/chunk-2PKBIKDH.js

@@ -0,0 +1,130 @@
+// src/lib/inbox.ts
+import * as fs from "fs";
+import * as path from "path";
+import { createHash } from "crypto";
+import matter from "gray-matter";
+import { globSync } from "glob";
+function normalizeContentForHash(content) {
+  return content.replace(/\r\n/g, "\n").trim();
+}
+function hashContent(content) {
+  return createHash("sha256").update(normalizeContentForHash(content)).digest("hex");
+}
+function ensureInboxDir(vaultPath) {
+  const inboxPath = path.join(path.resolve(vaultPath), "inbox");
+  fs.mkdirSync(inboxPath, { recursive: true });
+  return inboxPath;
+}
+function toSlug(value) {
+  const normalized = value.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
+  return normalized || "capture";
+}
+function compactTimestamp(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\..+$/, "").replace("T", "t");
+}
+function deriveTitle(content) {
+  const firstLine = content.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  if (!firstLine) {
+    return "Inbox Capture";
+  }
+  return firstLine.slice(0, 80);
+}
+function addInboxItem(vaultPath, rawContent, options = {}) {
+  const content = rawContent.replace(/\r\n/g, "\n").trim();
+  if (!content) {
+    throw new Error("Inbox content is empty.");
+  }
+  const now = options.now ? options.now() : /* @__PURE__ */ new Date();
+  const source = options.source?.trim() || "manual";
+  const title = options.title?.trim() || deriveTitle(content);
+  const hash = hashContent(content);
+  const baseSlug = toSlug(title);
+  const timestamp = compactTimestamp(now);
+  const inboxDir = ensureInboxDir(vaultPath);
+  let fileName = `${baseSlug}-${timestamp}-${hash.slice(0, 8)}.md`;
+  let fullPath = path.join(inboxDir, fileName);
+  let counter = 1;
+  while (fs.existsSync(fullPath)) {
+    fileName = `${baseSlug}-${timestamp}-${hash.slice(0, 8)}-${counter}.md`;
+    fullPath = path.join(inboxDir, fileName);
+    counter += 1;
+  }
+  const doc = matter.stringify(`${content}
+`, {
+    title,
+    date: now.toISOString().split("T")[0],
+    capturedAt: now.toISOString(),
+    source,
+    type: "inbox",
+    status: "pending",
+    hash
+  });
+  fs.writeFileSync(fullPath, doc, "utf-8");
+  return {
+    id: `inbox/${fileName.replace(/\.md$/, "")}`,
+    hash,
+    title,
+    path: fullPath,
+    relativePath: path.join("inbox", fileName),
+    source
+  };
+}
+function parseInboxFile(vaultPath, fullPath) {
+  const stats = fs.statSync(fullPath);
+  const relativePath = path.relative(path.resolve(vaultPath), fullPath);
+  const ext = path.extname(fullPath).toLowerCase();
+  const raw = fs.readFileSync(fullPath, "utf-8");
+  if (ext === ".md") {
+    const parsed = matter(raw);
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : path.basename(fullPath, ext);
+    const capturedAt = typeof parsed.data.capturedAt === "string" ? new Date(parsed.data.capturedAt) : stats.mtime;
+    const content2 = parsed.content.trim();
+    return {
+      id: relativePath.replace(/\\/g, "/").replace(/\.md$/, ""),
+      hash: hashContent(content2),
+      title,
+      content: content2,
+      path: fullPath,
+      relativePath: relativePath.replace(/\\/g, "/"),
+      capturedAt,
+      frontmatter: parsed.data
+    };
+  }
+  const content = raw.trim();
+  return {
+    id: relativePath.replace(/\\/g, "/"),
+    hash: hashContent(content),
+    title: path.basename(fullPath),
+    content,
+    path: fullPath,
+    relativePath: relativePath.replace(/\\/g, "/"),
+    capturedAt: stats.mtime,
+    frontmatter: {}
+  };
+}
+function readInboxItems(vaultPath, options = {}) {
+  const inboxDir = path.join(path.resolve(vaultPath), "inbox");
+  if (!fs.existsSync(inboxDir)) {
+    return [];
+  }
+  const ignore = ["**/processed/**", "**/merged/**"];
+  if (!options.includeArchived) {
+    ignore.push("**/archive/**");
+  }
+  const files = globSync("**/*", {
+    cwd: inboxDir,
+    nodir: true,
+    absolute: true,
+    ignore
+  });
+  const items = files.map((filePath) => parseInboxFile(vaultPath, filePath)).sort((left, right) => left.capturedAt.getTime() - right.capturedAt.getTime());
+  if (options.limit && options.limit > 0) {
+    return items.slice(0, options.limit);
+  }
+  return items;
+}
+
+export {
+  addInboxItem,
+  readInboxItems
+};

package/dist/{chunk-U67V476Y.js → chunk-2ZDO52B4.js}

@@ -4,7 +4,21 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -29,6 +43,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 export {
+  __require,
+  __glob,
+  __esm,
   __commonJS,
   __export,
   __toESM

package/dist/{chunk-ZZA73MFY.js → chunk-33DOSHTA.js}

@@ -1,11 +1,123 @@
 // src/lib/memory-graph.ts
 import * as fs from "fs";
-import * as path from "path";
+import * as path2 from "path";
 import matter from "gray-matter";
 import { glob } from "glob";
+
+// src/lib/wiki-links.ts
+import * as path from "path";
+function stripInlineCode(line) {
+  let result = "";
+  let cursor = 0;
+  while (cursor < line.length) {
+    if (line[cursor] !== "`") {
+      result += line[cursor];
+      cursor += 1;
+      continue;
+    }
+    let fenceLength = 1;
+    while (cursor + fenceLength < line.length && line[cursor + fenceLength] === "`") {
+      fenceLength += 1;
+    }
+    const fence = "`".repeat(fenceLength);
+    const closeIndex = line.indexOf(fence, cursor + fenceLength);
+    if (closeIndex === -1) {
+      result += fence;
+      cursor += fenceLength;
+      continue;
+    }
+    cursor = closeIndex + fenceLength;
+  }
+  return result;
+}
+function parseFence(line) {
+  const match = line.match(/^[ \t]{0,3}(`{3,}|~{3,})/);
+  if (!match) return null;
+  const marker = match[1][0];
+  if (marker !== "`" && marker !== "~") return null;
+  return { marker, length: match[1].length };
+}
+function isFenceClose(line, fence) {
+  const re = new RegExp(`^[ \\t]{0,3}${fence.marker}{${fence.length},}[ \\t]*$`);
+  return re.test(line);
+}
+function stripMarkdownCode(markdownContent) {
+  const lines = markdownContent.split("\n");
+  const visibleLines = [];
+  let activeFence = null;
+  for (const line of lines) {
+    if (activeFence) {
+      if (isFenceClose(line, activeFence)) {
+        activeFence = null;
+      }
+      visibleLines.push("");
+      continue;
+    }
+    const openingFence = parseFence(line);
+    if (openingFence) {
+      activeFence = openingFence;
+      visibleLines.push("");
+      continue;
+    }
+    if (/^(?: {4}|\t)/.test(line)) {
+      visibleLines.push("");
+      continue;
+    }
+    visibleLines.push(stripInlineCode(line));
+  }
+  return visibleLines.join("\n");
+}
+function extractRawWikiLinks(markdownContent) {
+  const content = stripMarkdownCode(markdownContent);
+  const links = [];
+  let cursor = 0;
+  while (cursor < content.length) {
+    const start = content.indexOf("[[", cursor);
+    if (start === -1) break;
+    const end = content.indexOf("]]", start + 2);
+    if (end === -1) break;
+    const candidate = content.slice(start + 2, end).trim();
+    if (candidate) {
+      links.push(candidate);
+    }
+    cursor = end + 2;
+  }
+  return links;
+}
+function normalizeWikiLinkTarget(rawTarget) {
+  let value = rawTarget.trim();
+  if (!value) return "";
+  if (value.startsWith("[[") && value.endsWith("]]")) {
+    value = value.slice(2, -2).trim();
+  }
+  const pipeIndex = value.indexOf("|");
+  if (pipeIndex >= 0) {
+    value = value.slice(0, pipeIndex);
+  }
+  if (value.startsWith("#")) {
+    return "";
+  }
+  const hashIndex = value.indexOf("#");
+  if (hashIndex >= 0) {
+    value = value.slice(0, hashIndex);
+  }
+  value = value.trim().replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!value) return "";
+  value = value.split("/").map((segment) => segment.trim()).join("/");
+  const normalizedPath = path.posix.normalize(value);
+  if (!normalizedPath || normalizedPath === ".") {
+    return "";
+  }
+  value = normalizedPath;
+  if (value.toLowerCase().endsWith(".md")) {
+    value = value.slice(0, -3);
+  }
+  return value.trim();
+}
+
+// src/lib/memory-graph.ts
 var MEMORY_GRAPH_SCHEMA_VERSION = 1;
-var GRAPH_INDEX_RELATIVE_PATH = path.join(".clawvault", "graph-index.json");
-var WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
+var GRAPH_INDEX_RELATIVE_PATH = path2.join(".clawvault", "graph-index.json");
 var HASH_TAG_RE = /(^|\s)#([\w-]+)/g;
 var FRONTMATTER_RELATION_FIELDS = [
   "related",
@@ -19,7 +131,7 @@ var FRONTMATTER_RELATION_FIELDS = [
   "links"
 ];
 function normalizeRelativePath(value) {
-  return value.split(path.sep).join("/").replace(/^\.\//, "").replace(/^\/+/, "");
+  return value.split(path2.sep).join("/").replace(/^\.\//, "").replace(/^\/+/, "");
 }
 function toNoteKey(relativePath) {
   const normalized = normalizeRelativePath(relativePath);
@@ -57,31 +169,14 @@ function inferNodeType(relativePath, frontmatter) {
   return "note";
 }
 function ensureClawvaultDir(vaultPath) {
-  const dirPath = path.join(vaultPath, ".clawvault");
+  const dirPath = path2.join(vaultPath, ".clawvault");
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, { recursive: true });
   }
   return dirPath;
 }
 function getGraphIndexPath(vaultPath) {
-  return path.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();
+  return path2.join(vaultPath, GRAPH_INDEX_RELATIVE_PATH);
 }
 function collectTags(frontmatter, markdownContent) {
   const tags = /* @__PURE__ */ new Set();
@@ -105,14 +200,15 @@ function collectTags(frontmatter, markdownContent) {
 }
 function extractWikiTargets(markdownContent) {
   const targets = /* @__PURE__ */ new Set();
-  for (const match of markdownContent.matchAll(WIKI_LINK_RE)) {
-    const candidate = match[1];
-    if (!candidate) continue;
+  for (const candidate of extractRawWikiLinks(markdownContent)) {
     const normalized = normalizeWikiTarget(candidate);
     if (normalized) targets.add(normalized);
   }
   return [...targets];
 }
+function normalizeWikiTarget(target) {
+  return normalizeWikiLinkTarget(target);
+}
 function toStringArray(value) {
   if (typeof value === "string") {
     return value.split(",").map((entry) => entry.trim()).filter(Boolean);
@@ -150,15 +246,57 @@ function buildNoteRegistry(relativePaths) {
   }
   return { byLowerPath, byLowerBasename };
 }
-function resolveTargetNodeId(rawTarget, registry) {
+function normalizeLookupPath(candidate) {
+  const normalized = normalizeWikiTarget(candidate);
+  if (!normalized) return "";
+  const resolved = path2.posix.normalize(normalized).replace(/^\/+/, "");
+  if (!resolved || resolved === "." || resolved.startsWith("../")) {
+    return "";
+  }
+  return resolved;
+}
+function buildTargetLookupCandidates(target, sourceNoteKey) {
+  const candidates = [];
+  const sourceDir = path2.posix.dirname(sourceNoteKey);
+  const hasSourceDir = sourceDir !== ".";
+  const isRelativeTarget = target.startsWith("./") || target.startsWith("../");
+  const addCandidate = (candidate) => {
+    const normalized = normalizeLookupPath(candidate);
+    if (!normalized || candidates.includes(normalized)) return;
+    candidates.push(normalized);
+  };
+  if (isRelativeTarget) {
+    if (hasSourceDir) {
+      addCandidate(path2.posix.join(sourceDir, target));
+    } else {
+      addCandidate(target);
+    }
+    if (target.startsWith("./")) {
+      addCandidate(target.slice(2));
+    }
+    return candidates;
+  }
+  if (!target.includes("/")) {
+    if (hasSourceDir) {
+      addCandidate(`${sourceDir}/${target}`);
+    }
+    addCandidate(target);
+    return candidates;
+  }
+  addCandidate(target);
+  return candidates;
+}
+function resolveTargetNodeId(rawTarget, registry, sourceNoteKey) {
   const normalized = normalizeWikiTarget(rawTarget);
   if (!normalized) {
     return toUnresolvedNodeId(rawTarget);
   }
   const lowerTarget = normalized.toLowerCase();
-  const direct = registry.byLowerPath.get(lowerTarget);
-  if (direct) {
-    return toNoteNodeId(direct);
+  for (const candidate of buildTargetLookupCandidates(normalized, sourceNoteKey)) {
+    const direct = registry.byLowerPath.get(candidate.toLowerCase());
+    if (direct) {
+      return toNoteNodeId(direct);
+    }
   }
   if (!normalized.includes("/")) {
     const basenameMatches = registry.byLowerBasename.get(lowerTarget) ?? [];
@@ -186,7 +324,7 @@ function buildFragmentNode(id, title, type, category, pathValue, tags, missing,
   };
 }
 function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
-  const absolutePath = path.join(vaultPath, relativePath);
+  const absolutePath = path2.join(vaultPath, relativePath);
   const raw = fs.readFileSync(absolutePath, "utf-8");
   const parsed = matter(raw);
   const frontmatter = parsed.data ?? {};
@@ -225,7 +363,7 @@ function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
   }
   const wikiTargets = extractWikiTargets(parsed.content);
   for (const target of wikiTargets) {
-    const targetNodeId = resolveTargetNodeId(target, registry);
+    const targetNodeId = resolveTargetNodeId(target, registry, noteKey);
     if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
       nodes.set(
         targetNodeId,
@@ -241,7 +379,7 @@ function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
     });
   }
   for (const relation of extractFrontmatterRelations(frontmatter)) {
-    const targetNodeId = resolveTargetNodeId(relation.target, registry);
+    const targetNodeId = resolveTargetNodeId(relation.target, registry, noteKey);
     if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
       nodes.set(
         targetNodeId,
@@ -326,7 +464,7 @@ function isValidIndex(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(path.resolve(vaultPath));
+  const indexPath = getGraphIndexPath(path2.resolve(vaultPath));
   if (!fs.existsSync(indexPath)) {
     return null;
   }
@@ -341,7 +479,7 @@ function loadMemoryGraphIndex(vaultPath) {
   }
 }
 async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
-  const vaultPath = path.resolve(vaultPathInput);
+  const vaultPath = path2.resolve(vaultPathInput);
   ensureClawvaultDir(vaultPath);
   const existing = options.forceFull ? null : loadMemoryGraphIndex(vaultPath);
   const markdownFiles = await glob("**/*.md", {
@@ -354,7 +492,7 @@ async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
   const existingFragments = existing?.files ?? {};
   const currentFileSet = new Set(normalizedFiles);
   for (const relativePath of normalizedFiles) {
-    const absolutePath = path.join(vaultPath, relativePath);
+    const absolutePath = path2.join(vaultPath, relativePath);
     const stat = fs.statSync(absolutePath);
     const existingFragment = existingFragments[relativePath];
     if (!options.forceFull && existingFragment && existingFragment.mtimeMs === stat.mtimeMs) {
@@ -391,6 +529,8 @@ async function getMemoryGraph(vaultPath, options = {}) {
 }
 
 export {
+  extractRawWikiLinks,
+  normalizeWikiLinkTarget,
   MEMORY_GRAPH_SCHEMA_VERSION,
   loadMemoryGraphIndex,
   buildOrUpdateMemoryGraphIndex,

package/dist/chunk-35JCYSRR.js

@@ -0,0 +1,158 @@
+// src/lib/maintenance/heuristics.ts
+var CATEGORY_PATTERNS = [
+  {
+    category: "decisions",
+    patterns: [
+      /\b(decid(?:e|ed|ing|ion)|chose|selected|opted|trade[- ]?off)\b/i,
+      /\b(approved|agreed|consensus)\b/i
+    ]
+  },
+  {
+    category: "lessons",
+    patterns: [
+      /\b(learn(?:ed|ing|t)|lesson|insight|realized|retrospective)\b/i,
+      /\b(next time|note to self|mistake)\b/i
+    ]
+  },
+  {
+    category: "commitments",
+    patterns: [
+      /\b(todo|task|action item|follow[- ]?up|deadline|due)\b/i,
+      /\b(i will|we will|must|need to)\b/i
+    ]
+  },
+  {
+    category: "people",
+    patterns: [
+      /\b(met with|talked to|spoke with|emailed|called|messaged)\b/i,
+      /\b(client|customer|partner|colleague|contact)\b/i
+    ]
+  },
+  {
+    category: "projects",
+    patterns: [
+      /\b(project|feature|release|deployment|deploy|service|api|repo)\b/i,
+      /\b(shipped|launched|merged|rolled out)\b/i
+    ]
+  },
+  {
+    category: "preferences",
+    patterns: [
+      /\b(prefer(?:s|red|ence)?|like(?:s|d)?|dislike|style|convention)\b/i,
+      /\b(always use|never use|default to)\b/i
+    ]
+  },
+  {
+    category: "facts",
+    patterns: [
+      /\b(is|are|was|were|has|have|contains|includes)\b/i
+    ]
+  }
+];
+function splitSentences(content) {
+  return content.split(/\r?\n|(?<=[.?!])\s+/).map((sentence) => sentence.trim()).filter(Boolean);
+}
+function compactWhitespace(value) {
+  return value.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "to",
+  "of",
+  "for",
+  "in",
+  "on",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "this",
+  "that",
+  "it",
+  "with",
+  "as",
+  "at",
+  "by",
+  "from",
+  "we",
+  "i",
+  "you",
+  "they",
+  "he",
+  "she"
+]);
+function classifyInboxItemHeuristic(item) {
+  const sample = `${item.title}
+${item.content.slice(0, 2400)}`;
+  for (const rule of CATEGORY_PATTERNS) {
+    if (rule.patterns.some((pattern) => pattern.test(sample))) {
+      return rule.category;
+    }
+  }
+  return "inbox";
+}
+function normalizeForDedup(content) {
+  return compactWhitespace(content.replace(/\[\[[^\]]+\]\]/g, ""));
+}
+function wordSet(content) {
+  const words = compactWhitespace(content).split(" ").filter(Boolean);
+  const filtered = words.filter((word) => !STOP_WORDS.has(word) && word.length > 2);
+  return new Set(filtered);
+}
+function similarityScore(left, right) {
+  const leftWords = wordSet(left);
+  const rightWords = wordSet(right);
+  if (leftWords.size === 0 || rightWords.size === 0) {
+    return 0;
+  }
+  let intersection = 0;
+  for (const word of leftWords) {
+    if (rightWords.has(word)) {
+      intersection += 1;
+    }
+  }
+  const union = leftWords.size + rightWords.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function extractHeuristicInsights(content) {
+  const sentences = splitSentences(content);
+  const facts = sentences.filter((line) => /\b(is|are|was|were|has|have|contains|includes)\b/i.test(line)).slice(0, 8);
+  const decisions = sentences.filter((line) => /\b(decid(?:e|ed|ing|ion)|chose|selected|opted|agreed)\b/i.test(line)).slice(0, 8);
+  const lessons = sentences.filter((line) => /\b(learn(?:ed|ing|t)|lesson|insight|realized|next time|mistake)\b/i.test(line)).slice(0, 8);
+  if (facts.length === 0 && sentences.length > 0) {
+    facts.push(sentences[0]);
+  }
+  return { facts, decisions, lessons };
+}
+function buildHeuristicSurveyRecommendations(params) {
+  const recommendations = [];
+  if (params.inboxCount > 20) {
+    recommendations.push(`Inbox backlog is high (${params.inboxCount}); run \`clawvault maintain --worker curator\` more frequently.`);
+  }
+  if (params.linkedRatio < 0.25) {
+    recommendations.push("Graph connectivity is low; add wiki-links between related notes to improve context traversal.");
+  }
+  if ((params.categoryCounts.lessons ?? 0) < 5) {
+    recommendations.push("Lessons are sparse; run distillation on long-form captures to keep reusable learnings explicit.");
+  }
+  if ((params.categoryCounts.decisions ?? 0) < 5) {
+    recommendations.push("Decision coverage is light; capture major choices and rationale in decisions/.");
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("Vault health looks balanced. Keep regular maintenance cadence and continue linking related notes.");
+  }
+  return recommendations;
+}
+
+export {
+  classifyInboxItemHeuristic,
+  normalizeForDedup,
+  similarityScore,
+  extractHeuristicInsights,
+  buildHeuristicSurveyRecommendations
+};

package/dist/{chunk-AZYOKJYC.js → chunk-4PY655YM.js}

@@ -18,6 +18,18 @@ function extractTitle(content) {
 function isDateSlug(slug) {
   return /^\d{4}-\d{2}-\d{2}$/.test(slug);
 }
+function buildProjectSlug(title) {
+  const direct = slugify(title);
+  if (direct) {
+    return direct;
+  }
+  let hash = 0;
+  for (const char of title) {
+    hash = (hash << 5) - hash + char.charCodeAt(0);
+    hash |= 0;
+  }
+  return `project-${Math.abs(hash).toString(36)}`;
+}
 function normalizeStringArray(value) {
   return value.map((item) => item.trim()).filter(Boolean);
 }
@@ -242,7 +254,7 @@ function readProject(vaultPath, slug) {
 }
 function createProject(vaultPath, title, options = {}) {
   ensureProjectsDir(vaultPath);
-  const slug = slugify(title);
+  const slug = buildProjectSlug(title);
   const projectPath = getProjectPath(vaultPath, slug);
   if (fs.existsSync(projectPath)) {
     throw new Error(`Project already exists: ${slug}`);