total-recall-brain 3.2.3 → 3.4.0

package/src/core/surface.mjs

@@ -1,6 +1,8 @@
 import fs from 'fs';
 import path from 'path';
-import { loadNodes, loadSkills, atomicWrite } from './vault.mjs';
+import crypto from 'crypto';
+import { loadSkills, atomicWrite, walkMd } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import {
   buildMemoryLayerIndex,
   inferMemoryLayer,
@@ -114,7 +116,113 @@ function extractRuleContent(filePath) {
   return content.trim();
 }
 
-export function buildRulesBlock(skillsDir, nodes = [], { vaultDir, consumer = 'ide' } = {}) {
+/**
+ * Load cache of compacted rules.
+ */
+function loadCompactedRulesCache(derivedDir) {
+  if (!derivedDir) return {};
+  const cachePath = path.join(derivedDir, 'compacted-rules.json');
+  if (!fs.existsSync(cachePath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Save cache of compacted rules.
+ */
+function saveCompactedRulesCache(derivedDir, cache) {
+  if (!derivedDir) return;
+  const cachePath = path.join(derivedDir, 'compacted-rules.json');
+  try {
+    fs.mkdirSync(derivedDir, { recursive: true });
+    atomicWrite(cachePath, JSON.stringify(cache, null, 2));
+  } catch (err) {
+    // Non-fatal
+  }
+}
+
+/**
+ * Heuristically summarize a memory node.
+ */
+export function heuristicCompact(node) {
+  const title = (node.title || '').trim();
+  const text = (node.body || node.content || '').trim();
+  
+  let summary = title;
+  if (text) {
+    const firstLine = text.split('\n').map(l => l.trim()).filter(Boolean)[0] || '';
+    if (firstLine && 
+        !title.toLowerCase().includes(firstLine.toLowerCase()) && 
+        !firstLine.toLowerCase().includes(title.toLowerCase())) {
+      const separator = /[.!?]$/.test(title) ? ' ' : ' — ';
+      summary = `${title}${separator}${firstLine}`;
+    }
+  }
+  
+  summary = summary.replace(/\s+/g, ' ');
+  if (summary.length > 180) {
+    summary = summary.substring(0, 180).trim() + '... (use recall to read more)';
+  }
+  return summary;
+}
+
+/**
+ * Compact a single memory node using LLM or heuristic fallback.
+ */
+async function compactNode(node, derivedDir) {
+  const title = (node.title || '').trim();
+  const body = (node.body || node.content || '').trim();
+  const fullText = `${title}\n\n${body}`;
+  const contentHash = crypto.createHash('sha256').update(fullText).digest('hex');
+
+  // Load from cache if possible
+  let cache = {};
+  if (derivedDir) {
+    cache = loadCompactedRulesCache(derivedDir);
+    if (cache[node.slug] && cache[node.slug].content_sha256 === contentHash) {
+      return cache[node.slug].compacted;
+    }
+  }
+
+  // Fallback default
+  let compacted = heuristicCompact(node);
+
+  // If LLM compacting is requested
+  if (process.env.TR_LLM_COMPACT === 'true') {
+    try {
+      const { callLocalRuntime, loadRuntimeConfig } = await import('./runtime.mjs');
+      const runtimeConfig = loadRuntimeConfig();
+      
+      const systemPrompt = "You are a Rule Compactor. Your task is to compress a system instruction or preference rule into a single, dense, highly actionable sentence. Preserve all key constraints, file paths, model names, or terminal commands verbatim. Return only the compacted sentence and nothing else.";
+      const userPrompt = `Rule Title: ${title}\nRule Body: ${body}`;
+      
+      const response = await callLocalRuntime(userPrompt, systemPrompt, runtimeConfig);
+      const cleanResponse = response.trim().replace(/\s+/g, ' ');
+      if (cleanResponse && cleanResponse.length > 0 && cleanResponse.length < 250) {
+        compacted = cleanResponse;
+      }
+    } catch (err) {
+      // Graceful fallback to heuristic
+    }
+  }
+
+  // Save to cache
+  if (derivedDir) {
+    cache[node.slug] = {
+      compacted,
+      content_sha256: contentHash,
+      updated_at: new Date().toISOString()
+    };
+    saveCompactedRulesCache(derivedDir, cache);
+  }
+
+  return compacted;
+}
+
+export async function buildRulesBlock(skillsDir, nodes = [], { consumer = 'ide', derivedDir } = {}) {
   let combined;
 
   if (consumer === 'api') {
@@ -198,48 +306,42 @@ Show all available commands.
 `;
   }
 
-  // 1. Filter expired rules and auto-archive them
+  // 1. Filter expired rules. Compilation must remain a pure projection step;
+  // archival is handled by explicit memory operations.
   const now = new Date();
   const isExpired = (n) => n.expires_at && new Date(n.expires_at) <= now;
 
   const expiredNodes = nodes.filter(n => n.status === 'active' && isExpired(n));
   for (const expired of expiredNodes) {
-    expired.status = 'deprecated';
-    console.error(`⏰ Auto-archived expired rule: ${expired.slug}`);
-    if (vaultDir) {
-      try {
-        const nodePath = path.join(vaultDir, expired.category, `${expired.slug}.md`);
-        if (fs.existsSync(nodePath)) {
-          let content = fs.readFileSync(nodePath, 'utf8');
-          content = content.replace(/^status:\s*active$/m, 'status: deprecated');
-          atomicWrite(nodePath, content);
-        }
-      } catch { /* non-fatal: archive is best-effort */ }
-    }
+    console.error(`⏰ Expired rule omitted from surface: ${expired.slug}`);
   }
 
-  // 2. Group active (non-expired) rules from SSSS vault nodes
+  // 2. Group active (non-expired) rules from SSSS vault nodes.
+  // Note: Only invariants, preferences, and anti-patterns are included in instructions,
+  // enforcing Category Partitioning (concepts, decisions, facts are search-only).
   const invariants = nodes.filter(n => n.category === 'invariants' && n.status === 'active' && !isExpired(n));
   const preferences = nodes.filter(n => n.category === 'preferences' && n.status === 'active' && !isExpired(n));
   const corrections = nodes.filter(n => n.category === 'anti-patterns' && n.status === 'active' && !isExpired(n));
 
-  const formatNodes = (list) => {
-    return list.map(n => {
-      const text = n.body || n.content || '';
-      return text.startsWith('-') ? text : `- ${text}`;
-    }).join('\n');
+  const formatNodes = async (list) => {
+    const formatted = [];
+    for (const n of list) {
+      const snippet = await compactNode(n, derivedDir);
+      formatted.push(snippet.startsWith('-') ? snippet : `- ${snippet}`);
+    }
+    return formatted.join('\n');
   };
 
   if (invariants.length > 0) {
-    combined += `\n\n## Invariant Rules\n\n${formatNodes(invariants)}`;
+    combined += `\n\n## Invariant Rules\n\n${await formatNodes(invariants)}`;
   }
 
   if (preferences.length > 0) {
-    combined += `\n\n## User Preferences\n\n${formatNodes(preferences)}`;
+    combined += `\n\n## User Preferences\n\n${await formatNodes(preferences)}`;
   }
 
   if (corrections.length > 0) {
-    combined += `\n\n## Corrections\n\n${formatNodes(corrections)}`;
+    combined += `\n\n## Corrections\n\n${await formatNodes(corrections)}`;
   }
 
   // 2. Append legacy rule sheet files if they exist
@@ -283,9 +385,9 @@ function injectDirectives(fileContent, rulesBlock) {
 /**
  * Write or update a platform instruction shim with the pointer and active rules.
  */
-function writeShim(shimPath, skillsDir, nodes = [], { vaultDir } = {}) {
+async function writeShim(shimPath, skillsDir, nodes = [], { vaultDir, derivedDir } = {}) {
   const shimDir = path.dirname(shimPath);
-  const rulesBlock = buildRulesBlock(skillsDir, nodes, { vaultDir });
+  const rulesBlock = await buildRulesBlock(skillsDir, nodes, { vaultDir, derivedDir });
   const baseline = 'Read and follow .agent/skills/total-recall/SKILL.md on every turn.\n';
   const fullContent = `${baseline}\n${DIRECTIVES_BEGIN}\n${rulesBlock}\n${DIRECTIVES_END}\n`;
 
@@ -333,9 +435,7 @@ const CLIENT_SHIMS = {
 };
 
 /**
- * Read the set of connected IDE clients from config/clients.json.
- * Returns a Set of client name strings, or null if the file is
- * missing / empty / malformed (null signals "write all shims").
+ * Read the connected client config.
  */
 function readConnectedClients(clientsPath) {
   try {
@@ -351,22 +451,14 @@ function readConnectedClients(clientsPath) {
 }
 
 /**
- * Compile pointers with active rules directly into root instruction shims.
- *
- * ALL files (including INSTRUCTIONS.md) are user-owned. TR only injects
- * content between the <!-- BEGIN/END INJECTED ACTIVE DIRECTIVES --> markers,
- * preserving any user-written content outside the markers.
- *
- * Only shims for connected clients (per config/clients.json) are written.
- * If clients.json is absent or unreadable, ALL shims are written (backward compat).
- * INSTRUCTIONS.md is always written as the canonical source.
+ * Compile shims asynchronously.
  */
-function compilePointers(instructionsFile, skillsDir, nodes = [], { vaultDir } = {}) {
+async function compilePointers(instructionsFile, skillsDir, nodes = [], { vaultDir, derivedDir } = {}) {
   const agentDir = path.dirname(instructionsFile);
   const baseDir = path.basename(agentDir) === '.agent' ? path.dirname(agentDir) : agentDir;
 
   // Always write the canonical INSTRUCTIONS.md
-  writeShim(path.join(baseDir, 'INSTRUCTIONS.md'), skillsDir, nodes, { vaultDir });
+  await writeShim(path.join(baseDir, 'INSTRUCTIONS.md'), skillsDir, nodes, { vaultDir, derivedDir });
 
   // Determine which client shims to write
   const clientsPath = path.join(baseDir, '.agent', 'config', 'clients.json');
@@ -376,7 +468,7 @@ function compilePointers(instructionsFile, skillsDir, nodes = [], { vaultDir } =
     // No clients.json → backward compat: write ALL client shims
     for (const files of Object.values(CLIENT_SHIMS)) {
       for (const file of files) {
-        writeShim(path.join(baseDir, file), skillsDir, nodes, { vaultDir });
+        await writeShim(path.join(baseDir, file), skillsDir, nodes, { vaultDir, derivedDir });
       }
     }
   } else {
@@ -385,7 +477,7 @@ function compilePointers(instructionsFile, skillsDir, nodes = [], { vaultDir } =
       const files = CLIENT_SHIMS[client];
       if (!files) continue;
       for (const file of files) {
-        writeShim(path.join(baseDir, file), skillsDir, nodes, { vaultDir });
+        await writeShim(path.join(baseDir, file), skillsDir, nodes, { vaultDir, derivedDir });
       }
     }
   }
@@ -394,11 +486,29 @@ function compilePointers(instructionsFile, skillsDir, nodes = [], { vaultDir } =
 /**
  * Main surface compilation entry point.
  */
-export async function compileSurface({ vaultDir, skillsDir, derivedDir, instructionsFile }) {
-  const nodes = loadNodes(vaultDir);
+export async function compileSurface({ vaultDir, skillsDir, derivedDir, instructionsFile, force = false }) {
+  const nodes = getNodes(vaultDir);
+
+  // ── Incremental compilation: vault content hash check ──
+  const hashFile = path.join(derivedDir, 'vault-hash.txt');
+  const currentHash = computeVaultHash(vaultDir);
+
+  if (!force && fs.existsSync(hashFile)) {
+    const storedHash = fs.readFileSync(hashFile, 'utf8').trim();
+    if (storedHash === currentHash) {
+      return {
+        nodesProcessed: nodes.length,
+        skillsInjected: 0,
+        semanticIndexed: 0,
+        semanticUnavailable: false,
+        skipped: true,
+        reason: 'vault-hash-unchanged'
+      };
+    }
+  }
 
   // 1. Write pointer and active rules to all instruction shims
-  compilePointers(instructionsFile, skillsDir, nodes, { vaultDir });
+  await compilePointers(instructionsFile, skillsDir, nodes, { vaultDir, derivedDir });
 
   // 2. Build derived indexes (powers semantic search API)
   if (!fs.existsSync(derivedDir)) {
@@ -415,30 +525,70 @@ export async function compileSurface({ vaultDir, skillsDir, derivedDir, instruct
   }));
   atomicWrite(path.join(derivedDir, 'graph-index.jsonl'), graphIndex.map(n => JSON.stringify(n)).join('\n'));
   atomicWrite(
-    path.join(derivedDir, 'memory-layers.jsonl'),
-    buildMemoryLayerIndex(nodes).map(n => JSON.stringify(n)).join('\n')
+      path.join(derivedDir, 'memory-layers.jsonl'),
+      buildMemoryLayerIndex(nodes).map(n => JSON.stringify(n)).join('\n')
   );
 
   // 3. Build semantic embeddings index if available (fire-and-forget)
   let semanticResult = { indexed: 0, skipped: nodes.length, unavailable: true };
   try {
-    const { buildSemanticIndex } = await import('./semantic-index.mjs');
-    semanticResult = await buildSemanticIndex(nodes, derivedDir);
-  } catch { /* semantic index is optional — never block compile */ }
+    const { buildEmbeddingsIndex } = await import('./embeddings.mjs');
+    const embResult = await buildEmbeddingsIndex(nodes, derivedDir);
+    semanticResult = { indexed: embResult.built, skipped: embResult.skipped, unavailable: false };
+  } catch { /* semantic index is optional */ }
 
-  // 4. Generate Obsidian Canvas (fire-and-forget)
+  // 4. Generate Obsidian Canvas
   try {
     generateCanvas(nodes, vaultDir);
   } catch { /* non-fatal */ }
 
+  // 5. Write vault hash + projection manifest
+  atomicWrite(hashFile, currentHash);
+  writeProjectionManifest(derivedDir, currentHash);
+
   return {
     nodesProcessed: nodes.length,
-    skillsInjected: 0,  // v2: no more skill injection
+    skillsInjected: 0,
     semanticIndexed: semanticResult.indexed,
     semanticUnavailable: semanticResult.unavailable
   };
 }
+
+/**
+ * Compute vault content hash.
+ */
+function computeVaultHash(vaultDir) {
+  const files = walkMd(vaultDir).sort();
+  const hash = crypto.createHash('sha256');
+  for (const file of files) {
+    try {
+      const stat = fs.statSync(file);
+      hash.update(`${file}:${stat.mtimeMs}:${stat.size}\n`);
+    } catch { /* skip unreadable files */ }
+  }
+  return hash.digest('hex');
+}
+
+/**
+ * Write projection manifest.
+ */
+function writeProjectionManifest(derivedDir, vaultHash) {
+  const manifest = {
+    type: 'projection-manifest',
+    generated_at: new Date().toISOString(),
+    vault_hash: `sha256:${vaultHash}`,
+    projections: [
+      { file: 'graph-index.jsonl', disposable: true },
+      { file: 'memory-layers.jsonl', disposable: true },
+      { file: 'embeddings.jsonl', disposable: true },
+      { file: 'vault-hash.txt', disposable: true }
+    ],
+    rebuild_command: 'npx total-recall compile'
+  };
+  atomicWrite(path.join(derivedDir, 'MANIFEST.json'), JSON.stringify(manifest, null, 2));
+}
+
 // ─── Legacy exports (kept for backward compatibility) ───
 export function routeNodesToSkills() { return []; }
 export function injectSkills() {}
-export function compileTier1(nodes, instructionsFile) { compilePointers(instructionsFile); }
+export async function compileTier1(nodes, instructionsFile) { await compilePointers(instructionsFile); }

package/src/core/validated-write.mjs

@@ -0,0 +1,100 @@
+/**
+ * src/core/validated-write.mjs
+ *
+ * Validated write adapter — routes memory mutations through the SSSS §6
+ * Operation Contract (processOperation) instead of bypassing it via raw
+ * writeNode(). This ensures every write gets:
+ *   - Envelope validation (Stage 1)
+ *   - Idempotency deduplication (Stage 2)
+ *   - Authorization checks (Stage 3)
+ *   - Lease protection (Stage 4)
+ *   - Schema validation (Stage 5)
+ *   - Atomic commit (Stage 6)
+ *   - Audit trail (Stage 7)
+ *
+ * Usage:
+ *   import { writeNodeValidated } from './validated-write.mjs';
+ *   const result = writeNodeValidated(node, vaultDir);
+ *   if (!result.success) throw new Error(result.validation.errors.join('; '));
+ */
+
+import crypto from 'node:crypto';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { processOperation } from './operation-validator.mjs';
+import { safeStringify } from './vault.mjs';
+import { invalidate } from './vault-cache.mjs';
+
+/**
+ * Write a memory node through the full §6 Operation Contract pipeline.
+ *
+ * @param {object} node - The memory node object (slug, category, title, body, etc.)
+ * @param {string} vaultDir - Absolute path to the vault directory
+ * @param {object} [options]
+ * @param {string} [options.agentRole='admin'] - Agent authorization role
+ * @param {string} [options.workspaceId='default'] - Workspace scope
+ * @param {string} [options.idempotencyKey] - Idempotency key (auto-generated if omitted)
+ * @param {string} [options.leaseStore] - Path to lease store directory
+ * @param {string} [options.eventLogDir] - Path to event log directory
+ * @param {boolean} [options.dryRun=false] - Validate without committing
+ * @returns {object} Operation response (§6.4)
+ */
+export function writeNodeValidated(node, vaultDir, options = {}) {
+  const {
+    agentRole = 'admin',
+    workspaceId = 'default',
+    idempotencyKey,
+    leaseStore,
+    eventLogDir,
+    dryRun = false,
+  } = options;
+
+  // Build the Markdown content from the node object
+  const { body, _filePath, ...frontmatter } = node;
+  if (!frontmatter.type) frontmatter.type = 'memory';
+  if (!frontmatter.schema_version) frontmatter.schema_version = 2;
+  if (!frontmatter.updated) frontmatter.updated = new Date().toISOString();
+  if (!frontmatter.last_accessed) frontmatter.last_accessed = new Date().toISOString();
+
+  const content = safeStringify(body || '', frontmatter);
+
+  // Build the §6.1 envelope
+  const category = frontmatter.category || 'uncategorized';
+  const slug = frontmatter.slug || 'unnamed';
+  const vfsPath = `${category}/${slug}.md`;
+
+  const envelope = {
+    type: 'operation',
+    idempotency_key: idempotencyKey || crypto.randomUUID(),
+    path: vfsPath,
+    workspace_id: workspaceId,
+    content,
+    dry_run: dryRun,
+  };
+
+  // Run the full §6.3 pipeline
+  const result = processOperation(envelope, vaultDir, {
+    agentRole,
+    leaseStore,
+    eventLogDir,
+  });
+
+  // Invalidate vault cache on successful commit
+  if (result.success && !dryRun) {
+    invalidate(vaultDir);
+  }
+
+  return result;
+}
+
+/**
+ * Validate a node against the §6 pipeline without committing.
+ * Useful for pre-flight checks on user input.
+ *
+ * @param {object} node - The memory node object
+ * @param {string} vaultDir - Absolute path to the vault directory
+ * @returns {object} Validation result with errors/warnings
+ */
+export function validateNode(node, vaultDir) {
+  return writeNodeValidated(node, vaultDir, { dryRun: true });
+}

package/src/core/vault-cache.mjs

@@ -2,35 +2,58 @@ import fs from 'fs';
 import { loadNodes } from './vault.mjs';
 import { logger } from './logger.mjs';
 
-let cachedNodes = null;
-let watcher = null;
-let currentVaultDir = null;
+/**
+ * Per-directory vault cache with fs.watch auto-invalidation.
+ * Supports multiple vault directories (global + project brains)
+ * without cross-contamination.
+ */
+const cacheMap = new Map();   // vaultDir → { nodes, watcher }
 
 /**
  * Retrieves memory nodes from the in-memory cache if fresh, otherwise loads them from disk.
  * Automatically wires a file watcher on first load to track external changes.
+ * Supports multiple vault directories simultaneously (global + project).
  *
  * @param {string} vaultDir - Path to the memory vault directory
  * @returns {Array} List of memory node objects
  */
 export function getNodes(vaultDir) {
-  currentVaultDir = vaultDir;
-  if (cachedNodes !== null) {
-    logger.debug('Vault cache hit');
-    return cachedNodes;
+  const entry = cacheMap.get(vaultDir);
+  if (entry?.nodes !== null && entry?.nodes !== undefined) {
+    logger.debug('Vault cache hit', { vaultDir });
+    return entry.nodes;
   }
   logger.info('Vault cache miss, loading nodes from disk', { vaultDir });
-  cachedNodes = loadNodes(vaultDir);
-  startWatcher(vaultDir);
-  return cachedNodes;
+  const nodes = loadNodes(vaultDir);
+  if (entry) {
+    entry.nodes = nodes;
+  } else {
+    cacheMap.set(vaultDir, { nodes, watcher: null });
+    startWatcher(vaultDir);
+  }
+  return nodes;
 }
 
 /**
- * Invalidates the in-memory vault cache, forcing the next read to load from disk.
+ * Invalidates the in-memory vault cache for a specific directory,
+ * or all directories if none specified.
+ * Forces the next read to reload from disk.
+ *
+ * @param {string} [vaultDir] - Optional specific vault dir to invalidate. If omitted, invalidates all.
  */
-export function invalidate() {
-  logger.info('Vault cache invalidated');
-  cachedNodes = null;
+export function invalidate(vaultDir) {
+  if (vaultDir) {
+    const entry = cacheMap.get(vaultDir);
+    if (entry) {
+      logger.info('Vault cache invalidated', { vaultDir });
+      entry.nodes = null;
+    }
+  } else {
+    logger.info('Vault cache invalidated (all)');
+    for (const entry of cacheMap.values()) {
+      entry.nodes = null;
+    }
+  }
 }
 
 /**
@@ -40,7 +63,9 @@ export function invalidate() {
  * @param {string} vaultDir - Path to the vault directory to watch
  */
 function startWatcher(vaultDir) {
-  if (watcher) return;
+  const entry = cacheMap.get(vaultDir);
+  if (!entry || entry.watcher) return;
+
   if (!fs.existsSync(vaultDir)) {
     try {
       fs.mkdirSync(vaultDir, { recursive: true });
@@ -52,14 +77,15 @@ function startWatcher(vaultDir) {
 
   logger.info('Starting filesystem watcher for vault cache', { vaultDir });
   try {
-    watcher = fs.watch(vaultDir, { recursive: true }, (eventType, filename) => {
+    const watcher = fs.watch(vaultDir, { recursive: true }, (eventType, filename) => {
       if (filename && filename.endsWith('.md')) {
         logger.info(`Vault filesystem change detected (${eventType}: ${filename}), invalidating cache`);
-        invalidate();
+        invalidate(vaultDir);
       }
     });
     // Unref the watcher so it does not prevent Node from exiting cleanly
     watcher.unref();
+    entry.watcher = watcher;
   } catch (err) {
     logger.warn('Failed to start vault fs watcher, cache will rely on explicit invalidations', { error: err.message });
   }
@@ -71,6 +97,8 @@ function startWatcher(vaultDir) {
  * @param {string} vaultDir - Path to the vault directory to watch
  */
 export function start(vaultDir) {
-  currentVaultDir = vaultDir;
+  if (!cacheMap.has(vaultDir)) {
+    cacheMap.set(vaultDir, { nodes: null, watcher: null });
+  }
   startWatcher(vaultDir);
 }

package/src/core/vault.mjs

@@ -37,22 +37,6 @@ function stripUndefined(obj) {
  * @returns {string}        The serialized markdown with frontmatter
  */
 export function safeStringify(content, data) {
-  if (data && data.type === 'memory') {
-    const now = new Date().toISOString();
-    if (!data.x_temporal_context) {
-      data.x_temporal_context = data.updated || data.created || now;
-    }
-    if (!data.x_citations) {
-      data.x_citations = [{
-        source: data.source?.type || 'unknown',
-        title: data.title || 'Untitled Memory',
-        url: data.source?.session_id ? `session://${data.source.session_id}` : 'unknown',
-        published: data.x_temporal_context,
-        relevance: 1.0,
-        accessed: now
-      }];
-    }
-  }
   return matter.stringify(content ?? '', stripUndefined(data ?? {}));
 }
 
@@ -63,13 +47,12 @@ export function walkMd(dir) {
   let results = [];
   if (!fs.existsSync(dir)) return results;
   
-  const list = fs.readdirSync(dir);
-  for (const file of list) {
-    const fullPath = path.join(dir, file);
-    const stat = fs.statSync(fullPath);
-    if (stat && stat.isDirectory()) {
+  const list = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of list) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
       results = results.concat(walkMd(fullPath));
-    } else if (fullPath.endsWith('.md')) {
+    } else if (entry.name.endsWith('.md')) {
       results.push(fullPath);
     }
   }
@@ -178,13 +161,18 @@ export function writeNode(node, vaultDir) {
  * @returns {boolean}
  */
 export function deleteNode(slug, vaultDir) {
-  const nodes = loadNodes(vaultDir);
-  const node = nodes.find(n => n.slug === slug);
-  if (!node) return false;
-  const filePath = path.join(vaultDir, node.category, `${node.slug}.md`);
-  if (fs.existsSync(filePath)) {
-    fs.rmSync(filePath);
-    return true;
+  if (!SAFE_NAME.test(slug)) return false;
+  if (!fs.existsSync(vaultDir)) return false;
+  
+  // Scan category directories directly instead of loading entire vault
+  const entries = fs.readdirSync(vaultDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const filePath = path.join(vaultDir, entry.name, `${slug}.md`);
+    if (fs.existsSync(filePath)) {
+      fs.rmSync(filePath);
+      return true;
+    }
   }
   return false;
 }