clawvault 3.4.1 → 3.5.0

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

@@ -1,81 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { Command } from 'commander';
-import { registerResilienceCommands } from './register-resilience-commands.js';
-import { chalkStub } from './test-helpers/cli-command-fixtures.js';
-
-const {
-  recoverMock,
-  formatRecoveryInfoMock,
-  checkRecoveryStatusMock,
-  formatRecoveryCheckStatusMock,
-  listCheckpointsMock,
-  formatCheckpointListMock
-} = vi.hoisted(() => ({
-  recoverMock: vi.fn(),
-  formatRecoveryInfoMock: vi.fn(),
-  checkRecoveryStatusMock: vi.fn(),
-  formatRecoveryCheckStatusMock: vi.fn(),
-  listCheckpointsMock: vi.fn(),
-  formatCheckpointListMock: vi.fn()
-}));
-
-vi.mock('../dist/commands/recover.js', () => ({
-  recover: recoverMock,
-  formatRecoveryInfo: formatRecoveryInfoMock,
-  checkRecoveryStatus: checkRecoveryStatusMock,
-  formatRecoveryCheckStatus: formatRecoveryCheckStatusMock,
-  listCheckpoints: listCheckpointsMock,
-  formatCheckpointList: formatCheckpointListMock
-}));
-
-function buildProgram() {
-  const program = new Command();
-  registerResilienceCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: (value) => value ?? '/vault'
-  });
-  return program;
-}
-
-async function runCommand(args) {
-  const program = buildProgram();
-  await program.parseAsync(args, { from: 'user' });
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  recoverMock.mockResolvedValue({ died: false });
-  formatRecoveryInfoMock.mockReturnValue('recover');
-  checkRecoveryStatusMock.mockResolvedValue({ died: false, deathTime: null, checkpoint: null });
-  formatRecoveryCheckStatusMock.mockReturnValue('check');
-  listCheckpointsMock.mockReturnValue([]);
-  formatCheckpointListMock.mockReturnValue('list');
-});
-
-describe('register-resilience-commands', () => {
-  it('routes recover --check through check helpers', async () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      await runCommand(['recover', '--check']);
-      expect(checkRecoveryStatusMock).toHaveBeenCalledWith('/vault');
-      expect(formatRecoveryCheckStatusMock).toHaveBeenCalled();
-      expect(recoverMock).not.toHaveBeenCalled();
-      expect(logSpy).toHaveBeenCalledWith('check');
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-
-  it('routes recover --list through checkpoint listing helpers', async () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      await runCommand(['recover', '--list']);
-      expect(listCheckpointsMock).toHaveBeenCalledWith('/vault');
-      expect(formatCheckpointListMock).toHaveBeenCalled();
-      expect(recoverMock).not.toHaveBeenCalled();
-      expect(logSpy).toHaveBeenCalledWith('list');
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-});

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

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Command } from 'commander';
-import { registerTaskCommands } from './register-task-commands.js';
-import { chalkStub, stubResolveVaultPath } from './test-helpers/cli-command-fixtures.js';
-
-describe('register-task-commands', () => {
-  it('adds enriched task add/list/update options', () => {
-    const program = new Command();
-    registerTaskCommands(program, {
-      chalk: chalkStub,
-      resolveVaultPath: stubResolveVaultPath
-    });
-
-    const taskCommand = program.commands.find((command) => command.name() === 'task');
-    expect(taskCommand).toBeDefined();
-
-    const addCommand = taskCommand?.commands.find((command) => command.name() === 'add');
-    const addFlags = addCommand?.options.map((option) => option.flags) ?? [];
-    expect(addFlags).toEqual(expect.arrayContaining([
-      '--due <date>',
-      '--tags <tags>',
-      '--description <description>',
-      '--estimate <estimate>',
-      '--parent <slug>',
-      '--depends-on <slugs>'
-    ]));
-
-    const listCommand = taskCommand?.commands.find((command) => command.name() === 'list');
-    const listFlags = listCommand?.options.map((option) => option.flags) ?? [];
-    expect(listFlags).toEqual(expect.arrayContaining([
-      '--due',
-      '--tag <tag>',
-      '--overdue'
-    ]));
-
-    const updateCommand = taskCommand?.commands.find((command) => command.name() === 'update');
-    const updateFlags = updateCommand?.options.map((option) => option.flags) ?? [];
-    expect(updateFlags).toEqual(expect.arrayContaining([
-      '--tags <tags>',
-      '--description <description>',
-      '--estimate <estimate>',
-      '--parent <slug>',
-      '--depends-on <slugs>',
-      '--clear-due',
-      '--clear-tags',
-      '--clear-description',
-      '--clear-estimate',
-      '--clear-parent',
-      '--clear-depends-on'
-    ]));
-  });
-
-  it('adds simplified canvas flags', () => {
-    const program = new Command();
-    registerTaskCommands(program, {
-      chalk: chalkStub,
-      resolveVaultPath: stubResolveVaultPath
-    });
-
-    const canvasCommand = program.commands.find((command) => command.name() === 'canvas');
-    expect(canvasCommand).toBeDefined();
-
-    const optionFlags = canvasCommand?.options.map((option) => option.flags) ?? [];
-    expect(optionFlags).toEqual(expect.arrayContaining([
-      '-v, --vault <path>',
-      '--output <path>'
-    ]));
-  });
-});

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

@@ -1,87 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { Command } from 'commander';
-import { registerTemplateCommands } from './register-template-commands.js';
-import { chalkStub } from './test-helpers/cli-command-fixtures.js';
-
-const {
-  listTemplateDefinitionsMock,
-  createFromTemplateMock,
-  addTemplateMock
-} = vi.hoisted(() => ({
-  listTemplateDefinitionsMock: vi.fn(),
-  createFromTemplateMock: vi.fn(),
-  addTemplateMock: vi.fn()
-}));
-
-vi.mock('../dist/commands/template.js', () => ({
-  listTemplateDefinitions: listTemplateDefinitionsMock,
-  createFromTemplate: createFromTemplateMock,
-  addTemplate: addTemplateMock
-}));
-
-function buildProgram() {
-  const program = new Command();
-  registerTemplateCommands(program, { chalk: chalkStub });
-  return program;
-}
-
-async function runCommand(args) {
-  const program = buildProgram();
-  await program.parseAsync(args, { from: 'user' });
-}
-
-describe('register-template-commands', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    listTemplateDefinitionsMock.mockReturnValue([]);
-  });
-
-  it('registers list/create/add template subcommands', () => {
-    const program = buildProgram();
-    const templateCommand = program.commands.find((command) => command.name() === 'template');
-    expect(templateCommand).toBeDefined();
-    expect(templateCommand?.commands.map((command) => command.name())).toEqual(
-      expect.arrayContaining(['list', 'create', 'add'])
-    );
-  });
-
-  it('prints template fields in list output', async () => {
-    listTemplateDefinitionsMock.mockReturnValue([
-      { name: 'task', fields: ['status', 'owner'] },
-      { name: 'project', fields: ['status', 'client'] }
-    ]);
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      await runCommand(['template', 'list']);
-      expect(logSpy).toHaveBeenCalledWith('- task (status, owner)');
-      expect(logSpy).toHaveBeenCalledWith('- project (status, client)');
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-
-  it('dispatches create and add operations to template command handlers', async () => {
-    createFromTemplateMock.mockReturnValue({
-      outputPath: '/tmp/task.md',
-      templatePath: '/templates/task.md',
-      variables: { title: 'Task', type: 'task', date: '2026-02-16', datetime: '2026-02-16T00:00:00.000Z' }
-    });
-    addTemplateMock.mockReturnValue({
-      templatePath: '/vault/templates/custom.md',
-      name: 'custom'
-    });
-
-    await runCommand(['template', 'create', 'task', '--title', 'Ship It']);
-    expect(createFromTemplateMock).toHaveBeenCalledWith('task', {
-      title: 'Ship It',
-      vaultPath: undefined
-    });
-
-    await runCommand(['template', 'add', 'source.md', '--name', 'custom']);
-    expect(addTemplateMock).toHaveBeenCalledWith('source.md', {
-      name: 'custom',
-      vaultPath: undefined
-    });
-  });
-});

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

@@ -1,120 +0,0 @@
-import { Command } from 'commander';
-import * as fs from 'fs';
-import * as path from 'path';
-import { registerCoreCommands } from '../register-core-commands.js';
-import { registerMaintenanceCommands } from '../register-maintenance-commands.js';
-import { registerQueryCommands } from '../register-query-commands.js';
-import { registerResilienceCommands } from '../register-resilience-commands.js';
-import { registerSessionLifecycleCommands } from '../register-session-lifecycle-commands.js';
-import { registerTemplateCommands } from '../register-template-commands.js';
-import { registerVaultOperationsCommands } from '../register-vault-operations-commands.js';
-import { registerConfigCommands } from '../register-config-commands.js';
-import { registerRouteCommands } from '../register-route-commands.js';
-import { registerTaskCommands } from '../register-task-commands.js';
-import { registerKanbanCommands } from '../register-kanban-commands.js';
-import { registerProjectCommands } from '../register-project-commands.js';
-
-export const chalkStub = {
-  cyan: (value) => value,
-  green: (value) => value,
-  red: (value) => value,
-  dim: (value) => value,
-  yellow: (value) => value,
-  white: (value) => value
-};
-
-export function stubResolveVaultPath(value) {
-  return value ?? '/vault';
-}
-
-export function createVaultStub(overrides = {}) {
-  return {
-    store: async () => ({}),
-    patch: async () => ({}),
-    capture: async () => ({}),
-    find: async () => [],
-    vsearch: async () => [],
-    list: async () => [],
-    get: async () => null,
-    stats: async () => ({ tags: [], categories: {} }),
-    sync: async () => ({ copied: [], deleted: [], unchanged: [], errors: [] }),
-    reindex: async () => 0,
-    remember: async () => ({ id: '' }),
-    getQmdCollection: () => '',
-    createHandoff: async () => ({ id: '', path: '' }),
-    generateRecap: async () => ({}),
-    formatRecap: () => '',
-    ...overrides
-  };
-}
-
-export function createGetVaultStub(overrides = {}) {
-  return async () => createVaultStub(overrides);
-}
-
-export function registerAllCommandModules(program = new Command()) {
-  const getVault = createGetVaultStub();
-
-  registerCoreCommands(program, {
-    chalk: chalkStub,
-    path,
-    fs,
-    createVault: async () => ({ getCategories: () => [], getQmdRoot: () => '', getQmdCollection: () => '' }),
-    getVault,
-    runQmd: async () => {}
-  });
-
-  registerQueryCommands(program, {
-    chalk: chalkStub,
-    getVault,
-    resolveVaultPath: stubResolveVaultPath,
-    QmdUnavailableError: class extends Error {},
-    printQmdMissing: () => {}
-  });
-
-  registerVaultOperationsCommands(program, {
-    chalk: chalkStub,
-    fs,
-    getVault,
-    runQmd: async () => {},
-    resolveVaultPath: stubResolveVaultPath,
-    path
-  });
-
-  registerMaintenanceCommands(program, { chalk: chalkStub });
-  registerResilienceCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerSessionLifecycleCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath,
-    QmdUnavailableError: class extends Error {},
-    printQmdMissing: () => {},
-    getVault,
-    runQmd: async () => {}
-  });
-  registerTemplateCommands(program, { chalk: chalkStub });
-  registerConfigCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerRouteCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerTaskCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerKanbanCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerProjectCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-
-  return program;
-}

package/dashboard/lib/graph-diff.test.js

@@ -1,75 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { diffGraphs } from './graph-diff.js';
-
-describe('diffGraphs', () => {
-  it('detects node and edge additions, updates, and removals', () => {
-    const previous = {
-      nodes: [
-        { id: 'a', title: 'A', category: 'root', tags: [], path: 'a.md', missing: false, degree: 1 },
-        { id: 'b', title: 'B', category: 'root', tags: ['x'], path: 'b.md', missing: false, degree: 1 },
-        { id: 'c', title: 'C', category: 'root', tags: [], path: null, missing: true, degree: 0 }
-      ],
-      edges: [{ source: 'a', target: 'b' }],
-      stats: { nodeCount: 3, edgeCount: 1 }
-    };
-
-    const next = {
-      nodes: [
-        { id: 'a', title: 'A Updated', category: 'root', tags: [], path: 'a.md', missing: false, degree: 1 },
-        { id: 'b', title: 'B', category: 'root', tags: ['x'], path: 'b.md', missing: false, degree: 2 },
-        { id: 'd', title: 'D', category: 'projects', tags: [], path: 'd.md', missing: false, degree: 1 }
-      ],
-      edges: [
-        { source: 'a', target: 'b' },
-        { source: 'b', target: 'd' }
-      ],
-      stats: { nodeCount: 3, edgeCount: 2 }
-    };
-
-    const patch = diffGraphs(previous, next);
-
-    expect(patch.addedNodes).toEqual([next.nodes[2]]);
-    expect(patch.updatedNodes).toEqual(expect.arrayContaining([next.nodes[0], next.nodes[1]]));
-    expect(patch.removedNodeIds).toEqual(['c']);
-    expect(patch.addedEdges).toEqual([{ source: 'b', target: 'd' }]);
-    expect(patch.removedEdges).toEqual([]);
-    expect(patch.changedNodeIds).toEqual(['a', 'b', 'c', 'd']);
-    expect(patch.hasChanges).toBe(true);
-  });
-
-  it('returns hasChanges=false for equivalent graphs', () => {
-    const graph = {
-      nodes: [{ id: 'a', title: 'A', category: 'root', tags: ['t'], path: 'a.md', missing: false, degree: 0 }],
-      edges: [],
-      stats: { nodeCount: 1, edgeCount: 0 }
-    };
-
-    const patch = diffGraphs(graph, structuredClone(graph));
-
-    expect(patch.hasChanges).toBe(false);
-    expect(patch.addedNodes).toEqual([]);
-    expect(patch.updatedNodes).toEqual([]);
-    expect(patch.removedNodeIds).toEqual([]);
-    expect(patch.addedEdges).toEqual([]);
-    expect(patch.removedEdges).toEqual([]);
-  });
-
-  it('treats edge type changes as edge diff', () => {
-    const previous = {
-      nodes: [
-        { id: 'a', title: 'A', category: 'root', tags: [], path: 'a.md', missing: false, degree: 1 },
-        { id: 'b', title: 'B', category: 'root', tags: [], path: 'b.md', missing: false, degree: 1 }
-      ],
-      edges: [{ source: 'a', target: 'b', type: 'wiki_link' }]
-    };
-    const next = {
-      nodes: previous.nodes,
-      edges: [{ source: 'a', target: 'b', type: 'frontmatter_relation', label: 'related' }]
-    };
-
-    const patch = diffGraphs(previous, next);
-    expect(patch.addedEdges).toEqual([{ source: 'a', target: 'b', type: 'frontmatter_relation', label: 'related' }]);
-    expect(patch.removedEdges).toEqual([{ source: 'a', target: 'b', type: 'wiki_link' }]);
-    expect(patch.hasChanges).toBe(true);
-  });
-});

package/dashboard/lib/vault-parser.test.js

@@ -1,254 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { buildVaultGraph } from './vault-parser.js';
-
-function makeTempVault() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'clawvault-dashboard-'));
-}
-
-function writeVaultFile(root, relativePath, content) {
-  const fullPath = path.join(root, relativePath);
-  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-  fs.writeFileSync(fullPath, content, 'utf8');
-}
-
-describe('buildVaultGraph', () => {
-  it('builds nodes and edges from markdown wiki-links', async () => {
-    const vaultPath = makeTempVault();
-    try {
-      writeVaultFile(
-        vaultPath,
-        'decisions/use-clawvault.md',
-        `---
-title: Use ClawVault
-tags: [architecture, memory]
----
-Linked to [[projects/clawvault|ClawVault Project]] and [[missing-note]].
-`
-      );
-      writeVaultFile(vaultPath, 'projects/clawvault.md', '# ClawVault');
-
-      const graph = await buildVaultGraph(vaultPath);
-      const decisionNode = graph.nodes.find((node) => node.id === 'decisions/use-clawvault');
-      const unresolvedNode = graph.nodes.find((node) => node.id === 'missing-note');
-
-      expect(decisionNode).toMatchObject({
-        title: 'Use ClawVault',
-        category: 'decisions',
-        tags: ['architecture', 'memory'],
-        type: 'decision'
-      });
-      expect(graph.edges).toEqual(expect.arrayContaining([
-        expect.objectContaining({
-          source: 'decisions/use-clawvault',
-          target: 'projects/clawvault',
-          type: 'wiki_link'
-        }),
-        expect.objectContaining({
-          source: 'decisions/use-clawvault',
-          target: 'missing-note',
-          type: 'wiki_link'
-        }),
-        expect.objectContaining({
-          source: 'decisions/use-clawvault',
-          target: 'tag:architecture',
-          type: 'tag'
-        })
-      ]));
-      expect(unresolvedNode).toMatchObject({
-        missing: true,
-        category: 'unresolved'
-      });
-      expect(graph.stats.edgeTypeCounts.wiki_link).toBeGreaterThanOrEqual(2);
-      expect(graph.stats.edgeTypeCounts.tag).toBeGreaterThanOrEqual(1);
-    } finally {
-      fs.rmSync(vaultPath, { recursive: true, force: true });
-    }
-  });
-
-  it('resolves basename links when there is a unique match', async () => {
-    const vaultPath = makeTempVault();
-    try {
-      writeVaultFile(vaultPath, 'research/notes.md', 'See [[clawvault]].');
-      writeVaultFile(vaultPath, 'projects/clawvault.md', '# ClawVault');
-
-      const graph = await buildVaultGraph(vaultPath);
-
-      expect(graph.edges).toEqual(expect.arrayContaining([
-        expect.objectContaining({
-          source: 'research/notes',
-          target: 'projects/clawvault',
-          type: 'wiki_link'
-        })
-      ]));
-    } finally {
-      fs.rmSync(vaultPath, { recursive: true, force: true });
-    }
-  });
-
-  it('emits frontmatter relation edges with labels', async () => {
-    const vaultPath = makeTempVault();
-    try {
-      writeVaultFile(
-        vaultPath,
-        'decisions/db.md',
-        `---
-related:
-  - projects/clawvault
-owner: people/alice
----
-Decision details`
-      );
-      writeVaultFile(vaultPath, 'projects/clawvault.md', '# ClawVault');
-      writeVaultFile(vaultPath, 'people/alice.md', '# Alice');
-
-      const graph = await buildVaultGraph(vaultPath);
-      expect(graph.edges).toEqual(expect.arrayContaining([
-        expect.objectContaining({
-          source: 'decisions/db',
-          target: 'projects/clawvault',
-          type: 'frontmatter_relation',
-          label: 'related'
-        }),
-        expect.objectContaining({
-          source: 'decisions/db',
-          target: 'people/alice',
-          type: 'frontmatter_relation',
-          label: 'owner'
-        })
-      ]));
-    } finally {
-      fs.rmSync(vaultPath, { recursive: true, force: true });
-    }
-  });
-
-  it('loads graph data from memory graph index when present', async () => {
-    const vaultPath = makeTempVault();
-    try {
-      writeVaultFile(vaultPath, 'decisions/use-clawvault.md', '# Placeholder');
-      writeVaultFile(vaultPath, 'projects/clawvault.md', '# Placeholder project');
-      const decisionMtime = fs.statSync(path.join(vaultPath, 'decisions/use-clawvault.md')).mtimeMs;
-      const projectMtime = fs.statSync(path.join(vaultPath, 'projects/clawvault.md')).mtimeMs;
-      const indexPath = path.join(vaultPath, '.clawvault', 'graph-index.json');
-      fs.mkdirSync(path.dirname(indexPath), { recursive: true });
-      fs.writeFileSync(
-        indexPath,
-        JSON.stringify({
-          schemaVersion: 1,
-          files: {
-            'decisions/use-clawvault.md': {
-              relativePath: 'decisions/use-clawvault.md',
-              mtimeMs: decisionMtime
-            },
-            'projects/clawvault.md': {
-              relativePath: 'projects/clawvault.md',
-              mtimeMs: projectMtime
-            }
-          },
-          graph: {
-            nodes: [
-              {
-                id: 'note:decisions/use-clawvault',
-                title: 'Use ClawVault',
-                type: 'decision',
-                category: 'decisions',
-                tags: ['architecture'],
-                path: 'decisions/use-clawvault.md',
-                missing: false,
-                degree: 1
-              },
-              {
-                id: 'note:projects/clawvault',
-                title: 'ClawVault Project',
-                type: 'project',
-                category: 'projects',
-                tags: [],
-                path: 'projects/clawvault.md',
-                missing: false,
-                degree: 1
-              }
-            ],
-            edges: [
-              {
-                source: 'note:decisions/use-clawvault',
-                target: 'note:projects/clawvault',
-                type: 'frontmatter_relation',
-                label: 'related'
-              }
-            ],
-            stats: { generatedAt: '2026-02-13T00:00:00.000Z' }
-          }
-        }),
-        'utf8'
-      );
-
-      const graph = await buildVaultGraph(vaultPath);
-      expect(graph.nodes.find((node) => node.id === 'decisions/use-clawvault')).toBeTruthy();
-      expect(graph.edges).toEqual([
-        {
-          source: 'decisions/use-clawvault',
-          target: 'projects/clawvault',
-          type: 'frontmatter_relation',
-          label: 'related'
-        }
-      ]);
-      expect(graph.stats.fileCount).toBe(2);
-    } finally {
-      fs.rmSync(vaultPath, { recursive: true, force: true });
-    }
-  });
-
-  it('falls back to markdown parsing when memory graph index is stale', async () => {
-    const vaultPath = makeTempVault();
-    try {
-      writeVaultFile(vaultPath, 'projects/clawvault.md', '# ClawVault');
-      writeVaultFile(vaultPath, 'decisions/use-clawvault.md', 'See [[projects/clawvault]].');
-
-      const indexPath = path.join(vaultPath, '.clawvault', 'graph-index.json');
-      fs.mkdirSync(path.dirname(indexPath), { recursive: true });
-      fs.writeFileSync(
-        indexPath,
-        JSON.stringify({
-          schemaVersion: 1,
-          generatedAt: '2026-02-13T00:00:00.000Z',
-          files: {
-            'decisions/use-clawvault.md': { relativePath: 'decisions/use-clawvault.md', mtimeMs: 1 },
-            'projects/clawvault.md': { relativePath: 'projects/clawvault.md', mtimeMs: 1 }
-          },
-          graph: {
-            nodes: [
-              {
-                id: 'note:decisions/use-clawvault',
-                title: 'Old node',
-                type: 'decision',
-                category: 'decisions',
-                tags: [],
-                path: 'decisions/use-clawvault.md',
-                missing: false,
-                degree: 0
-              }
-            ],
-            edges: [],
-            stats: { generatedAt: '2026-02-13T00:00:00.000Z' }
-          }
-        }),
-        'utf8'
-      );
-
-      const graph = await buildVaultGraph(vaultPath);
-      const node = graph.nodes.find((candidate) => candidate.id === 'decisions/use-clawvault');
-      expect(node?.title).not.toBe('Old node');
-      expect(graph.edges).toEqual(expect.arrayContaining([
-        expect.objectContaining({
-          source: 'decisions/use-clawvault',
-          target: 'projects/clawvault',
-          type: 'wiki_link'
-        })
-      ]));
-    } finally {
-      fs.rmSync(vaultPath, { recursive: true, force: true });
-    }
-  });
-});