test: fix brain.add() return type usage in VFS tests

Fixed tests to correctly use brain.add() return value:
- brain.add() returns string (entity ID), not Entity object
- Updated tests to use knowledgeId instead of knowledgeEntity.id
- Simple VFS filter test now passing (demonstrates filtering works)
- 3/5 integration tests passing

Verified working:
✅ brain.find() excludes VFS by default
✅ brain.find({ includeVFS: true }) includes VFS
✅ Type queries (Document, Collection) filter correctly
✅ Where clause with isVFS works
✅ VFS-knowledge relationships work

Note: Semantic search tests still failing (Buffer embedding issue)

tests/integration/vfs-knowledge-separation.test.ts

@@ -48,7 +48,7 @@ describe('VFS-Knowledge Separation (Option 3C)', () => {
     await vfs.writeFile('/docs/readme.md', '# Hello World')
 
     // Create knowledge entity (no isVFS flag)
-    const knowledgeEntity = await brain.add({
+    const knowledgeId = await brain.add({
       data: 'This is a knowledge document about AI',
       type: NounType.Document,
       metadata: {
@@ -74,7 +74,7 @@ describe('VFS-Knowledge Separation (Option 3C)', () => {
     // Should only return knowledge entities (no VFS)
     expect(vfsResults.length).toBe(0)
     expect(knowledgeResults.length).toBeGreaterThan(0)
-    expect(results.some(r => r.id === knowledgeEntity.id)).toBe(true)
+    expect(results.some(r => r.id === knowledgeId)).toBe(true)
   })
 
   it('should include VFS entities when includeVFS: true', async () => {

tests/manual/simple-vfs-filter-test.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Simple VFS filtering test
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { Brainy } from '../../src/brainy.js'
+import { NounType } from '../../src/types/graphTypes.js'
+import * as fs from 'fs'
+import * as path from 'path'
+
+describe('Simple VFS Filter Test', () => {
+  const testDir = path.join(process.cwd(), 'test-simple-vfs-filter')
+  let brain: Brainy
+
+  beforeAll(async () => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true })
+    }
+    fs.mkdirSync(testDir, { recursive: true })
+
+    brain = new Brainy({
+      storage: {
+        type: 'filesystem',
+        options: { path: testDir }
+      }
+    })
+    await brain.init()
+  })
+
+  afterAll(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true })
+    }
+  })
+
+  it('should demonstrate VFS filtering', async () => {
+    console.log('\n=== TEST START ===\n')
+
+    // 1. Create knowledge entity
+    console.log('1. Creating knowledge entity...')
+    const knowledgeId = await brain.add({
+      data: 'Knowledge document',
+      type: NounType.Document,
+      metadata: { title: 'Knowledge' }
+    })
+    console.log(`   Created: ${knowledgeId}`)
+
+    // 2. Create VFS file
+    console.log('\n2. Creating VFS file...')
+    const vfs = brain.vfs()
+    await vfs.init()
+    await vfs.writeFile('/test.txt', 'VFS file')
+    console.log('   VFS file created')
+
+    // 3. Query all (should exclude VFS)
+    console.log('\n3. Query: brain.find({}) [excludes VFS by default]')
+    const all = await brain.find({ limit: 100 })
+    console.log(`   Results: ${all.length}`)
+    for (const r of all) {
+      console.log(`     - ${r.id}, type: ${r.type}, isVFS: ${r.metadata?.isVFS}, title: ${r.metadata?.title}`)
+    }
+
+    // 4. Query all with VFS
+    console.log('\n4. Query: brain.find({ includeVFS: true })')
+    const allWithVFS = await brain.find({ includeVFS: true, limit: 100 })
+    console.log(`   Results: ${allWithVFS.length}`)
+    for (const r of allWithVFS) {
+      console.log(`     - ${r.id}, type: ${r.type}, isVFS: ${r.metadata?.isVFS}, path: ${r.metadata?.path || 'n/a'}`)
+    }
+
+    // 5. Query by type (should exclude VFS)
+    console.log('\n5. Query: brain.find({ type: NounType.Document }) [excludes VFS]')
+    const docs = await brain.find({ type: NounType.Document, limit: 100 })
+    console.log(`   Results: ${docs.length}`)
+    for (const r of docs) {
+      console.log(`     - ${r.id}, type: ${r.type}, isVFS: ${r.metadata?.isVFS}`)
+    }
+
+    // 6. Query by type with VFS
+    console.log('\n6. Query: brain.find({ type: NounType.Document, includeVFS: true })' )
+    const docsWithVFS = await brain.find({ type: NounType.Document, includeVFS: true, limit: 100 })
+    console.log(`   Results: ${docsWithVFS.length}`)
+    for (const r of docsWithVFS) {
+      console.log(`     - ${r.id}, type: ${r.type}, isVFS: ${r.metadata?.isVFS}, path: ${r.metadata?.path || 'n/a'}`)
+    }
+
+    console.log('\n=== TEST END ===\n')
+
+    // Assertions
+    expect(all.length).toBe(1) // Only knowledge entity
+    expect(all.some(r => r.id === knowledgeId)).toBe(true)
+
+    expect(allWithVFS.length).toBeGreaterThanOrEqual(2) // Knowledge + VFS entities
+
+    expect(docs.length).toBe(1) // Only knowledge entity
+    expect(docs.some(r => r.id === knowledgeId)).toBe(true)
+
+    expect(docsWithVFS.length).toBeGreaterThanOrEqual(2) // Knowledge + VFS file (both documents)
+  })
+})