@cleocode/core 2026.4.5 → 2026.4.7

package/src/nexus/__tests__/nexus-e2e.test.js

@@ -1,1220 +0,0 @@
-/**
- * Comprehensive E2E tests for NEXUS cross-project registry system.
- *
- * Covers: audit log verification, health status, permission updates,
- * schema integrity, cross-project reference resolution, orphan detection
- * with real project deletion, multi-project scenarios, discovery module,
- * and edge cases.
- *
- * @task WAVE-1D
- */
-import { randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { eq } from 'drizzle-orm';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { seedTasks } from '../../store/__tests__/test-db-helper.js';
-import { nexusAuditLog, nexusSchemaMeta, projectRegistry } from '../../store/nexus-schema.js';
-import { getNexusDb, NEXUS_SCHEMA_VERSION, resetNexusDbState } from '../../store/nexus-sqlite.js';
-import { resetDbState } from '../../store/sqlite.js';
-import { createSqliteDataAccessor } from '../../store/sqlite-data-accessor.js';
-import { blockingAnalysis, buildGlobalGraph, criticalPath, invalidateGraphCache, nexusDeps, orphanDetection, resolveCrossDeps, } from '../deps.js';
-import { discoverRelated, extractKeywords, searchAcrossProjects } from '../discover.js';
-import { generateProjectHash } from '../hash.js';
-import { canExecute, canRead, canWrite, checkPermission, checkPermissionDetail, getPermission, permissionLevel, requirePermission, setPermission, } from '../permissions.js';
-import { getProjectFromQuery, parseQuery, resolveTask, validateSyntax } from '../query.js';
-import { nexusGetProject, nexusInit, nexusList, nexusProjectExists, nexusReconcile, nexusRegister, nexusSetPermission, nexusSync, nexusSyncAll, nexusUnregister, readRegistry, readRegistryRequired, } from '../registry.js';
-// ── Test helpers ─────────────────────────────────────────────────────
-/** Create a test project with tasks in SQLite (tasks.db). */
-async function createTestProjectDb(dir, tasks) {
-    await mkdir(join(dir, '.cleo'), { recursive: true });
-    resetDbState();
-    const accessor = await createSqliteDataAccessor(dir);
-    await seedTasks(accessor, tasks);
-    await accessor.close();
-    resetDbState();
-}
-/** Create a test project with tasks.db and project-info.json. */
-async function createTestProjectWithId(dir, tasks, projectId) {
-    const pid = projectId ?? randomUUID();
-    await createTestProjectDb(dir, tasks);
-    await writeFile(join(dir, '.cleo', 'project-info.json'), JSON.stringify({ projectId: pid, createdAt: new Date().toISOString() }));
-    return pid;
-}
-// ── Shared state ─────────────────────────────────────────────────────
-let testDir;
-let registryDir;
-beforeEach(async () => {
-    testDir = await mkdtemp(join(tmpdir(), 'nexus-e2e-test-'));
-    registryDir = join(testDir, 'cleo-home');
-    await mkdir(registryDir, { recursive: true });
-    process.env['CLEO_HOME'] = registryDir;
-    process.env['NEXUS_HOME'] = join(registryDir, 'nexus');
-    process.env['NEXUS_CACHE_DIR'] = join(registryDir, 'nexus', 'cache');
-    process.env['NEXUS_CURRENT_PROJECT'] = 'e2e-project';
-    delete process.env['NEXUS_SKIP_PERMISSION_CHECK'];
-    resetNexusDbState();
-    resetDbState();
-    invalidateGraphCache();
-});
-afterEach(async () => {
-    delete process.env['CLEO_HOME'];
-    delete process.env['NEXUS_HOME'];
-    delete process.env['NEXUS_CACHE_DIR'];
-    delete process.env['NEXUS_CURRENT_PROJECT'];
-    delete process.env['NEXUS_SKIP_PERMISSION_CHECK'];
-    resetNexusDbState();
-    resetDbState();
-    invalidateGraphCache();
-    await rm(testDir, { recursive: true, force: true });
-});
-// =====================================================================
-// 1. AUDIT LOG VERIFICATION
-// =====================================================================
-describe('audit log', () => {
-    it('register creates an audit entry with action=register', async () => {
-        const projDir = join(testDir, 'audit-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        const hash = await nexusRegister(projDir, 'audit-proj', 'read');
-        const db = await getNexusDb();
-        const entries = await db
-            .select()
-            .from(nexusAuditLog)
-            .where(eq(nexusAuditLog.action, 'register'));
-        expect(entries.length).toBeGreaterThanOrEqual(1);
-        const entry = entries.find((e) => e.projectHash === hash);
-        expect(entry).toBeDefined();
-        expect(entry.action).toBe('register');
-        expect(entry.success).toBe(1);
-        expect(entry.domain).toBe('nexus');
-        expect(entry.timestamp).toBeTruthy();
-        expect(entry.id).toBeTruthy();
-    });
-    it('unregister creates an audit entry with action=unregister', async () => {
-        const projDir = join(testDir, 'unreg-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        const hash = await nexusRegister(projDir, 'unreg-proj', 'read');
-        await nexusUnregister('unreg-proj');
-        const db = await getNexusDb();
-        const entries = await db
-            .select()
-            .from(nexusAuditLog)
-            .where(eq(nexusAuditLog.action, 'unregister'));
-        expect(entries.length).toBeGreaterThanOrEqual(1);
-        const entry = entries.find((e) => e.projectHash === hash);
-        expect(entry).toBeDefined();
-        expect(entry.success).toBe(1);
-    });
-    it('sync creates an audit entry with action=sync', async () => {
-        const projDir = join(testDir, 'sync-audit-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'sync-audit-proj', 'read');
-        await nexusSync('sync-audit-proj');
-        const db = await getNexusDb();
-        const entries = await db.select().from(nexusAuditLog).where(eq(nexusAuditLog.action, 'sync'));
-        expect(entries.length).toBeGreaterThanOrEqual(1);
-        expect(entries[0].success).toBe(1);
-    });
-    it('sync-all creates an audit entry with action=sync-all', async () => {
-        const projDir = join(testDir, 'syncall-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'syncall-proj', 'read');
-        await nexusSyncAll();
-        const db = await getNexusDb();
-        const entries = await db
-            .select()
-            .from(nexusAuditLog)
-            .where(eq(nexusAuditLog.action, 'sync-all'));
-        expect(entries.length).toBeGreaterThanOrEqual(1);
-        expect(entries[0].success).toBe(1);
-        const details = JSON.parse(entries[0].detailsJson ?? '{}');
-        expect(details.synced).toBe(1);
-        expect(details.failed).toBe(0);
-    });
-    it('set-permission creates an audit entry', async () => {
-        const projDir = join(testDir, 'perm-audit-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'perm-audit-proj', 'read');
-        await nexusSetPermission('perm-audit-proj', 'execute');
-        const db = await getNexusDb();
-        const entries = await db
-            .select()
-            .from(nexusAuditLog)
-            .where(eq(nexusAuditLog.action, 'set-permission'));
-        expect(entries.length).toBeGreaterThanOrEqual(1);
-        expect(entries[0].success).toBe(1);
-        const details = JSON.parse(entries[0].detailsJson ?? '{}');
-        expect(details.permission).toBe('execute');
-    });
-    it('reconcile creates audit entries', async () => {
-        const projDir = join(testDir, 'recon-audit-proj');
-        await createTestProjectWithId(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusReconcile(projDir);
-        const db = await getNexusDb();
-        const entries = await db
-            .select()
-            .from(nexusAuditLog)
-            .where(eq(nexusAuditLog.action, 'reconcile'));
-        expect(entries.length).toBeGreaterThanOrEqual(1);
-        expect(entries[0].success).toBe(1);
-    });
-    it('audit entries survive project deletion', async () => {
-        const projDir = join(testDir, 'surviving-audit-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        const hash = await nexusRegister(projDir, 'surviving-audit-proj', 'read');
-        await nexusUnregister('surviving-audit-proj');
-        // Verify audit entries remain even after project is removed
-        const db = await getNexusDb();
-        const entries = await db
-            .select()
-            .from(nexusAuditLog)
-            .where(eq(nexusAuditLog.projectHash, hash));
-        // At least register + unregister = 2 entries
-        expect(entries.length).toBeGreaterThanOrEqual(2);
-        const actions = entries.map((e) => e.action);
-        expect(actions).toContain('register');
-        expect(actions).toContain('unregister');
-    });
-    it('audit entries have valid timestamps', async () => {
-        const projDir = join(testDir, 'ts-audit-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'ts-audit-proj', 'read');
-        const db = await getNexusDb();
-        const entries = await db.select().from(nexusAuditLog);
-        for (const entry of entries) {
-            expect(entry.timestamp).toBeTruthy();
-            // Should be parseable as a date
-            const date = new Date(entry.timestamp);
-            expect(date.getTime()).not.toBeNaN();
-        }
-    });
-    it('audit entries have unique UUIDs', async () => {
-        const projDir = join(testDir, 'uuid-audit-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'uuid-audit-proj', 'read');
-        await nexusSync('uuid-audit-proj');
-        await nexusUnregister('uuid-audit-proj');
-        const db = await getNexusDb();
-        const entries = await db.select().from(nexusAuditLog);
-        const ids = entries.map((e) => e.id);
-        const uniqueIds = new Set(ids);
-        expect(uniqueIds.size).toBe(ids.length);
-    });
-});
-// =====================================================================
-// 2. HEALTH STATUS
-// =====================================================================
-describe('health status', () => {
-    it('newly registered project has unknown health status', async () => {
-        const projDir = join(testDir, 'health-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'health-proj', 'read');
-        const project = await nexusGetProject('health-proj');
-        expect(project).not.toBeNull();
-        expect(project.healthStatus).toBe('unknown');
-        expect(project.healthLastCheck).toBeNull();
-    });
-    it('health status can be updated directly via DB', async () => {
-        const projDir = join(testDir, 'health-update-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'health-update-proj', 'read');
-        // Simulate health check update directly
-        const db = await getNexusDb();
-        const hash = generateProjectHash(projDir);
-        const now = new Date().toISOString();
-        await db
-            .update(projectRegistry)
-            .set({ healthStatus: 'healthy', healthLastCheck: now })
-            .where(eq(projectRegistry.projectHash, hash));
-        const project = await nexusGetProject('health-update-proj');
-        expect(project).not.toBeNull();
-        expect(project.healthStatus).toBe('healthy');
-        expect(project.healthLastCheck).toBe(now);
-    });
-    it('health status values are preserved through readRegistry', async () => {
-        const projDir = join(testDir, 'health-registry-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'health-registry-proj', 'read');
-        const db = await getNexusDb();
-        const hash = generateProjectHash(projDir);
-        await db
-            .update(projectRegistry)
-            .set({ healthStatus: 'degraded' })
-            .where(eq(projectRegistry.projectHash, hash));
-        const registry = await readRegistry();
-        expect(registry).not.toBeNull();
-        const project = Object.values(registry.projects).find((p) => p.name === 'health-registry-proj');
-        expect(project).toBeDefined();
-        expect(project.healthStatus).toBe('degraded');
-    });
-    it('all valid health status values can be stored and retrieved', async () => {
-        const statuses = ['unknown', 'healthy', 'degraded', 'unreachable'];
-        for (const status of statuses) {
-            const projDir = join(testDir, `health-${status}-proj`);
-            await createTestProjectDb(projDir, [
-                { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-            ]);
-            await nexusRegister(projDir, `health-${status}`, 'read');
-            const db = await getNexusDb();
-            const hash = generateProjectHash(projDir);
-            await db
-                .update(projectRegistry)
-                .set({ healthStatus: status })
-                .where(eq(projectRegistry.projectHash, hash));
-            const project = await nexusGetProject(`health-${status}`);
-            expect(project.healthStatus).toBe(status);
-        }
-    });
-});
-// =====================================================================
-// 3. PERMISSION UPDATES
-// =====================================================================
-describe('permission updates', () => {
-    it('nexusSetPermission changes permission from read to write', async () => {
-        const projDir = join(testDir, 'perm-rw-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'perm-rw-proj', 'read');
-        expect((await nexusGetProject('perm-rw-proj')).permissions).toBe('read');
-        await nexusSetPermission('perm-rw-proj', 'write');
-        expect((await nexusGetProject('perm-rw-proj')).permissions).toBe('write');
-    });
-    it('nexusSetPermission changes permission from read to execute', async () => {
-        const projDir = join(testDir, 'perm-rx-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'perm-rx-proj', 'read');
-        await nexusSetPermission('perm-rx-proj', 'execute');
-        const project = await nexusGetProject('perm-rx-proj');
-        expect(project.permissions).toBe('execute');
-        expect(await checkPermission('perm-rx-proj', 'read')).toBe(true);
-        expect(await checkPermission('perm-rx-proj', 'write')).toBe(true);
-        expect(await checkPermission('perm-rx-proj', 'execute')).toBe(true);
-    });
-    it('nexusSetPermission can downgrade from execute to read', async () => {
-        const projDir = join(testDir, 'perm-down-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'perm-down-proj', 'execute');
-        await nexusSetPermission('perm-down-proj', 'read');
-        expect(await checkPermission('perm-down-proj', 'write')).toBe(false);
-        expect(await checkPermission('perm-down-proj', 'execute')).toBe(false);
-        expect(await checkPermission('perm-down-proj', 'read')).toBe(true);
-    });
-    it('nexusSetPermission throws for non-existent project', async () => {
-        await nexusInit();
-        await expect(nexusSetPermission('no-such-project', 'write')).rejects.toThrow(/not found/i);
-    });
-    it('setPermission (from permissions module) updates correctly', async () => {
-        const projDir = join(testDir, 'setperm-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'setperm-proj', 'read');
-        await setPermission('setperm-proj', 'execute');
-        const perm = await getPermission('setperm-proj');
-        expect(perm).toBe('execute');
-    });
-    it('setPermission throws on empty name', async () => {
-        await expect(setPermission('', 'read')).rejects.toThrow(/required/i);
-    });
-});
-// =====================================================================
-// 4. SCHEMA INTEGRITY
-// =====================================================================
-describe('schema integrity', () => {
-    it('nexus.db is created with correct schema version in nexus_schema_meta', async () => {
-        await nexusInit();
-        const db = await getNexusDb();
-        const meta = await db
-            .select()
-            .from(nexusSchemaMeta)
-            .where(eq(nexusSchemaMeta.key, 'schemaVersion'));
-        expect(meta.length).toBe(1);
-        expect(meta[0].value).toBe(NEXUS_SCHEMA_VERSION);
-    });
-    it('all required tables exist after init', async () => {
-        await nexusInit();
-        const db = await getNexusDb();
-        // Verify each table can be queried
-        const projects = await db.select().from(projectRegistry);
-        expect(Array.isArray(projects)).toBe(true);
-        const auditLogs = await db.select().from(nexusAuditLog);
-        expect(Array.isArray(auditLogs)).toBe(true);
-        const schemaMeta = await db.select().from(nexusSchemaMeta);
-        expect(Array.isArray(schemaMeta)).toBe(true);
-    });
-    it('project_registry indexes exist and are usable', async () => {
-        await nexusInit();
-        // Register a project to populate the table
-        const projDir = join(testDir, 'idx-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'idx-proj', 'read');
-        // Query by hash (uses idx_project_registry_hash)
-        const byHash = await nexusGetProject(generateProjectHash(projDir));
-        expect(byHash).not.toBeNull();
-        // Query by name (uses idx_project_registry_name)
-        const byName = await nexusGetProject('idx-proj');
-        expect(byName).not.toBeNull();
-    });
-    it('nexus.db file is created on disk', async () => {
-        await nexusInit();
-        const dbPath = join(registryDir, 'nexus.db');
-        expect(existsSync(dbPath)).toBe(true);
-    });
-    it('readRegistry returns null before initialization when DB does not exist', async () => {
-        // Point to a non-existent CLEO_HOME
-        const noDir = join(testDir, 'nonexistent-cleo-home');
-        process.env['CLEO_HOME'] = noDir;
-        resetNexusDbState();
-        // readRegistry should return null (not throw)
-        const registry = await readRegistry();
-        // It may or may not be null depending on whether getNexusDb auto-creates;
-        // the important thing is it doesn't throw
-        expect(registry === null || typeof registry === 'object').toBe(true);
-    });
-    it('readRegistryRequired throws when no projects exist and DB is empty', async () => {
-        // readRegistryRequired only throws if readRegistry returns null.
-        // With SQLite auto-initialization, it returns an empty registry.
-        await nexusInit();
-        const registry = await readRegistryRequired();
-        expect(registry).not.toBeNull();
-        expect(Object.keys(registry.projects)).toHaveLength(0);
-    });
-});
-// =====================================================================
-// 5. MULTI-PROJECT REGISTRATION & LISTING
-// =====================================================================
-describe('multi-project operations', () => {
-    it('registers and lists multiple projects', async () => {
-        const projects = [];
-        for (let i = 0; i < 5; i++) {
-            const dir = join(testDir, `multi-proj-${i}`);
-            await createTestProjectDb(dir, [
-                { id: `T00${i}`, title: `Task ${i}`, status: 'pending', description: `Desc ${i}` },
-            ]);
-            await nexusRegister(dir, `multi-${i}`, 'read');
-            projects.push(`multi-${i}`);
-        }
-        const listed = await nexusList();
-        expect(listed).toHaveLength(5);
-        const names = listed.map((p) => p.name).sort();
-        expect(names).toEqual(projects.sort());
-    });
-    it('nexusSyncAll syncs multiple projects correctly', async () => {
-        for (let i = 0; i < 3; i++) {
-            const dir = join(testDir, `sync-multi-${i}`);
-            await createTestProjectDb(dir, [
-                { id: `T00${i}`, title: `Task ${i}`, status: 'pending', description: `Desc ${i}` },
-            ]);
-            await nexusRegister(dir, `sync-multi-${i}`, 'read');
-        }
-        const result = await nexusSyncAll();
-        expect(result.synced).toBe(3);
-        expect(result.failed).toBe(0);
-    });
-    it('readRegistry returns all projects with correct structure', async () => {
-        const dirA = join(testDir, 'reg-a');
-        const dirB = join(testDir, 'reg-b');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Task A', status: 'pending', description: 'A' },
-        ]);
-        await createTestProjectDb(dirB, [
-            { id: 'T002', title: 'Task B', status: 'done', description: 'B' },
-        ]);
-        await nexusRegister(dirA, 'proj-a', 'read');
-        await nexusRegister(dirB, 'proj-b', 'write');
-        const registry = await readRegistry();
-        expect(registry).not.toBeNull();
-        expect(registry.schemaVersion).toBe('1.0.0');
-        expect(Object.keys(registry.projects)).toHaveLength(2);
-        // Verify project structure
-        const projectA = Object.values(registry.projects).find((p) => p.name === 'proj-a');
-        expect(projectA).toBeDefined();
-        expect(projectA.path).toBe(dirA);
-        expect(projectA.permissions).toBe('read');
-        expect(projectA.taskCount).toBe(1);
-        const projectB = Object.values(registry.projects).find((p) => p.name === 'proj-b');
-        expect(projectB).toBeDefined();
-        expect(projectB.permissions).toBe('write');
-    });
-    it('unregistering one project does not affect others', async () => {
-        const dirA = join(testDir, 'keep-a');
-        const dirB = join(testDir, 'remove-b');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Task A', status: 'pending', description: 'A' },
-        ]);
-        await createTestProjectDb(dirB, [
-            { id: 'T002', title: 'Task B', status: 'pending', description: 'B' },
-        ]);
-        await nexusRegister(dirA, 'keep-a', 'read');
-        await nexusRegister(dirB, 'remove-b', 'read');
-        await nexusUnregister('remove-b');
-        expect(await nexusProjectExists('keep-a')).toBe(true);
-        expect(await nexusProjectExists('remove-b')).toBe(false);
-        const listed = await nexusList();
-        expect(listed).toHaveLength(1);
-        expect(listed[0].name).toBe('keep-a');
-    });
-});
-// =====================================================================
-// 6. CROSS-PROJECT TASK RESOLUTION
-// =====================================================================
-describe('cross-project task resolution', () => {
-    let projADir;
-    let projBDir;
-    beforeEach(async () => {
-        projADir = join(testDir, 'xproj-a');
-        projBDir = join(testDir, 'xproj-b');
-        await createTestProjectDb(projADir, [
-            { id: 'T001', title: 'Auth API', status: 'active', description: 'Auth', labels: ['auth'] },
-            {
-                id: 'T002',
-                title: 'Users API',
-                status: 'pending',
-                description: 'Users',
-                depends: ['T001'],
-            },
-        ]);
-        await createTestProjectDb(projBDir, [
-            {
-                id: 'T100',
-                title: 'Login UI',
-                status: 'blocked',
-                description: 'Login page',
-                labels: ['auth'],
-            },
-            {
-                id: 'T101',
-                title: 'Dashboard',
-                status: 'pending',
-                description: 'Dashboard',
-                depends: ['T100'],
-            },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(projADir, 'backend', 'read');
-        await nexusRegister(projBDir, 'frontend', 'read');
-    });
-    it('resolves task from named project', async () => {
-        const task = await resolveTask('backend:T001');
-        expect(Array.isArray(task)).toBe(false);
-        if (!Array.isArray(task)) {
-            expect(task.id).toBe('T001');
-            expect(task.title).toBe('Auth API');
-            expect(task._project).toBe('backend');
-        }
-    });
-    it('resolves task from a different project', async () => {
-        const task = await resolveTask('frontend:T100');
-        expect(Array.isArray(task)).toBe(false);
-        if (!Array.isArray(task)) {
-            expect(task.id).toBe('T100');
-            expect(task.title).toBe('Login UI');
-            expect(task._project).toBe('frontend');
-        }
-    });
-    it('wildcard resolves matching tasks across projects', async () => {
-        const tasks = await resolveTask('*:T001');
-        expect(Array.isArray(tasks)).toBe(true);
-        if (Array.isArray(tasks)) {
-            expect(tasks.length).toBeGreaterThanOrEqual(1);
-            expect(tasks[0]._project).toBe('backend');
-        }
-    });
-    it('throws for task not found in specific project', async () => {
-        await expect(resolveTask('frontend:T001')).rejects.toThrow(/not found/i);
-    });
-    it('throws for non-existent project', async () => {
-        await expect(resolveTask('nonexistent:T001')).rejects.toThrow(/not found/i);
-    });
-});
-// =====================================================================
-// 7. DEPENDENCY GRAPH WITH CROSS-PROJECT EDGES
-// =====================================================================
-describe('dependency graph', () => {
-    it('builds graph from multiple projects', async () => {
-        const dirA = join(testDir, 'graph-a');
-        const dirB = join(testDir, 'graph-b');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'API Base', status: 'done', description: 'API' },
-            {
-                id: 'T002',
-                title: 'API Routes',
-                status: 'active',
-                description: 'Routes',
-                depends: ['T001'],
-            },
-        ]);
-        await createTestProjectDb(dirB, [
-            { id: 'T010', title: 'UI Shell', status: 'active', description: 'Shell' },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'api', 'read');
-        await nexusRegister(dirB, 'ui', 'read');
-        const graph = await buildGlobalGraph();
-        expect(graph.nodes).toHaveLength(3);
-        expect(graph.edges.length).toBeGreaterThanOrEqual(1);
-        // T002 -> T001 edge within api project
-        const edge = graph.edges.find((e) => e.from === 'T002' && e.to === 'T001');
-        expect(edge).toBeDefined();
-        expect(edge.fromProject).toBe('api');
-        expect(edge.toProject).toBe('api');
-    });
-    it('forward deps for a task with dependencies', async () => {
-        const dirA = join(testDir, 'fwd-a');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Base', status: 'done', description: 'Base' },
-            { id: 'T002', title: 'Mid', status: 'active', description: 'Mid', depends: ['T001'] },
-            { id: 'T003', title: 'Top', status: 'pending', description: 'Top', depends: ['T002'] },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'chain', 'read');
-        const result = await nexusDeps('chain:T003', 'forward');
-        expect(result.depends).toHaveLength(1);
-        expect(result.depends[0].query).toBe('chain:T002');
-    });
-    it('reverse deps shows what depends on a task', async () => {
-        const dirA = join(testDir, 'rev-a');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Base', status: 'done', description: 'Base' },
-            { id: 'T002', title: 'Dep', status: 'pending', description: 'Dep', depends: ['T001'] },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'rev-proj', 'read');
-        const result = await nexusDeps('rev-proj:T001', 'reverse');
-        expect(result.blocking.length).toBeGreaterThanOrEqual(1);
-        expect(result.blocking.some((b) => b.query.includes('T002'))).toBe(true);
-    });
-    it('resolveCrossDeps resolves local dependencies', async () => {
-        const dirA = join(testDir, 'resolve-deps-a');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Base', status: 'done', description: 'Base' },
-            { id: 'T002', title: 'Dep', status: 'pending', description: 'Dep', depends: ['T001'] },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'resolve-proj', 'read');
-        const resolved = await resolveCrossDeps(['T001'], 'resolve-proj');
-        expect(resolved).toHaveLength(1);
-        expect(resolved[0].query).toBe('resolve-proj:T001');
-        expect(resolved[0].status).toBe('done');
-    });
-});
-// =====================================================================
-// 8. ORPHAN DETECTION
-// =====================================================================
-describe('orphan detection', () => {
-    it('detects no orphans when all deps are local', async () => {
-        const dirA = join(testDir, 'orphan-local');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Base', status: 'done', description: 'Base' },
-            { id: 'T002', title: 'Dep', status: 'pending', description: 'Dep', depends: ['T001'] },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'orphan-local', 'read');
-        const orphans = await orphanDetection();
-        expect(orphans).toHaveLength(0);
-    });
-    it('returns empty array for projects with no dependencies', async () => {
-        const dirA = join(testDir, 'no-deps-orphan');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Solo', status: 'done', description: 'Solo' },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'no-deps', 'read');
-        const orphans = await orphanDetection();
-        expect(orphans).toHaveLength(0);
-    });
-});
-// =====================================================================
-// 9. BLOCKING ANALYSIS
-// =====================================================================
-describe('blocking analysis extended', () => {
-    it('handles diamond dependency pattern', async () => {
-        // T001 -> T002 -> T004
-        // T001 -> T003 -> T004
-        const dirA = join(testDir, 'diamond');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Root', status: 'active', description: 'Root' },
-            { id: 'T002', title: 'Left', status: 'pending', description: 'Left', depends: ['T001'] },
-            { id: 'T003', title: 'Right', status: 'pending', description: 'Right', depends: ['T001'] },
-            {
-                id: 'T004',
-                title: 'Join',
-                status: 'pending',
-                description: 'Join',
-                depends: ['T002', 'T003'],
-            },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'diamond', 'read');
-        const result = await blockingAnalysis('diamond:T001');
-        // T001 blocks T002, T003, and transitively T004
-        expect(result.impactScore).toBeGreaterThanOrEqual(3);
-        const blocked = result.blocking.map((b) => b.query);
-        expect(blocked.some((q) => q.includes('T002'))).toBe(true);
-        expect(blocked.some((q) => q.includes('T003'))).toBe(true);
-        expect(blocked.some((q) => q.includes('T004'))).toBe(true);
-    });
-});
-// =====================================================================
-// 10. CRITICAL PATH
-// =====================================================================
-describe('critical path extended', () => {
-    it('returns CriticalPathResult with valid structure', async () => {
-        const dirA = join(testDir, 'crit-chain');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Step 1', status: 'done', description: 'S1' },
-            { id: 'T002', title: 'Step 2', status: 'active', description: 'S2', depends: ['T001'] },
-            { id: 'T003', title: 'Step 3', status: 'pending', description: 'S3', depends: ['T002'] },
-            { id: 'T004', title: 'Step 4', status: 'pending', description: 'S4', depends: ['T003'] },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'crit-proj', 'read');
-        const result = await criticalPath();
-        // criticalPath starts from root nodes (no outgoing dep edges) and traces
-        // their dependency edges. T001 is the only root (depends on nothing).
-        // The algorithm traces outgoing edges from roots; since T001 has no deps,
-        // path = [T001]. length matches criticalPath array length.
-        expect(result).toHaveProperty('criticalPath');
-        expect(result).toHaveProperty('length');
-        expect(result).toHaveProperty('blockedBy');
-        expect(result.length).toBe(result.criticalPath.length);
-        expect(result.length).toBeGreaterThanOrEqual(1);
-        for (const entry of result.criticalPath) {
-            expect(entry).toHaveProperty('query');
-            expect(entry).toHaveProperty('title');
-        }
-    });
-    it('returns blockedBy string (may be empty if all tasks done)', async () => {
-        const dirA = join(testDir, 'crit-blocker');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Done task', status: 'done', description: 'Done' },
-            {
-                id: 'T002',
-                title: 'Pending task',
-                status: 'pending',
-                description: 'Pending',
-                depends: ['T001'],
-            },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'blocker-proj', 'read');
-        const result = await criticalPath();
-        expect(typeof result.blockedBy).toBe('string');
-        // The algorithm finds roots (T001, status done) and traces back.
-        // Since T001 is done, it's not a blocker. blockedBy remains ''.
-        // This is correct behavior for the current algorithm.
-        expect(result.length).toBeGreaterThanOrEqual(1);
-    });
-});
-// =====================================================================
-// 11. DISCOVERY MODULE (discoverRelated, searchAcrossProjects)
-// =====================================================================
-describe('discovery - extractKeywords', () => {
-    it('extracts meaningful keywords from text', () => {
-        const keywords = extractKeywords('the auth module for user login');
-        expect(keywords).toContain('auth');
-        expect(keywords).toContain('module');
-        expect(keywords).toContain('user');
-        expect(keywords).toContain('login');
-        expect(keywords).not.toContain('the');
-        expect(keywords).not.toContain('for');
-    });
-    it('filters short words (2 chars or less)', () => {
-        const keywords = extractKeywords('an is to be or no');
-        expect(keywords).toHaveLength(0);
-    });
-    it('handles empty string', () => {
-        const keywords = extractKeywords('');
-        expect(keywords).toHaveLength(0);
-    });
-    it('lowercases and removes special characters', () => {
-        const keywords = extractKeywords('Authentication! Module: V2.0');
-        expect(keywords).toContain('authentication');
-        expect(keywords).toContain('module');
-    });
-});
-describe('discovery - searchAcrossProjects', () => {
-    let projADir;
-    let projBDir;
-    beforeEach(async () => {
-        projADir = join(testDir, 'search-a');
-        projBDir = join(testDir, 'search-b');
-        await createTestProjectDb(projADir, [
-            {
-                id: 'T001',
-                title: 'Auth API',
-                status: 'active',
-                description: 'Authentication API',
-                labels: ['auth'],
-            },
-            {
-                id: 'T002',
-                title: 'User API',
-                status: 'pending',
-                description: 'User management',
-                labels: ['user'],
-            },
-        ]);
-        await createTestProjectDb(projBDir, [
-            {
-                id: 'T100',
-                title: 'Auth UI',
-                status: 'blocked',
-                description: 'Auth login page',
-                labels: ['auth'],
-            },
-            {
-                id: 'T101',
-                title: 'Dashboard',
-                status: 'pending',
-                description: 'Main dashboard',
-                labels: ['ui'],
-            },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(projADir, 'search-backend', 'read');
-        await nexusRegister(projBDir, 'search-frontend', 'read');
-    });
-    it('searches by keyword across all projects', async () => {
-        const result = await searchAcrossProjects('Auth');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            expect(result.results.length).toBeGreaterThanOrEqual(2);
-            const titles = result.results.map((r) => r.title);
-            expect(titles.some((t) => t.includes('Auth'))).toBe(true);
-        }
-    });
-    it('searches by task ID pattern', async () => {
-        const result = await searchAcrossProjects('T001');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            expect(result.results.length).toBeGreaterThanOrEqual(1);
-            expect(result.results[0].id).toBe('T001');
-        }
-    });
-    it('returns empty results for no match', async () => {
-        const result = await searchAcrossProjects('zzz-no-match-xyz');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            expect(result.results).toHaveLength(0);
-        }
-    });
-    it('respects limit parameter', async () => {
-        const result = await searchAcrossProjects('Auth', undefined, 1);
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            expect(result.results.length).toBeLessThanOrEqual(1);
-        }
-    });
-    it('filters by project when projectFilter is specified', async () => {
-        const result = await searchAcrossProjects('Auth', 'search-backend');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            for (const r of result.results) {
-                expect(r._project).toBe('search-backend');
-            }
-        }
-    });
-    it('returns error for non-existent project filter', async () => {
-        const result = await searchAcrossProjects('Auth', 'nonexistent-project');
-        expect('error' in result).toBe(true);
-        if ('error' in result) {
-            expect(result.error.code).toBe('E_NOT_FOUND');
-        }
-    });
-    it('handles wildcard query syntax (*:T001)', async () => {
-        const result = await searchAcrossProjects('*:T001');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            expect(result.results.length).toBeGreaterThanOrEqual(1);
-        }
-    });
-});
-describe('discovery - discoverRelated', () => {
-    let projADir;
-    let projBDir;
-    beforeEach(async () => {
-        projADir = join(testDir, 'disc-a');
-        projBDir = join(testDir, 'disc-b');
-        await createTestProjectDb(projADir, [
-            {
-                id: 'T001',
-                title: 'Auth module implementation',
-                status: 'active',
-                description: 'Build the authentication module',
-                labels: ['auth', 'security'],
-            },
-            {
-                id: 'T002',
-                title: 'Database setup',
-                status: 'done',
-                description: 'Set up database',
-                labels: ['db'],
-            },
-        ]);
-        await createTestProjectDb(projBDir, [
-            {
-                id: 'T100',
-                title: 'Auth UI component',
-                status: 'blocked',
-                description: 'UI for authentication flow',
-                labels: ['auth', 'ui'],
-            },
-            {
-                id: 'T101',
-                title: 'Dashboard analytics',
-                status: 'pending',
-                description: 'Analytics dashboard',
-                labels: ['ui'],
-            },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(projADir, 'disc-backend', 'read');
-        await nexusRegister(projBDir, 'disc-frontend', 'read');
-    });
-    it('discovers related tasks by labels', async () => {
-        const result = await discoverRelated('disc-backend:T001', 'labels');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            // T100 shares the 'auth' label with T001
-            const authMatch = result.results.find((r) => r.taskId === 'T100');
-            expect(authMatch).toBeDefined();
-            expect(authMatch.type).toBe('labels');
-            expect(authMatch.reason).toContain('auth');
-        }
-    });
-    it('discovers related tasks by description keywords', async () => {
-        const result = await discoverRelated('disc-backend:T001', 'description');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            // T100 shares keywords like "auth", "authentication"
-            const descMatch = result.results.find((r) => r.taskId === 'T100');
-            expect(descMatch).toBeDefined();
-            expect(descMatch.type).toBe('description');
-        }
-    });
-    it('auto method finds results by best match type', async () => {
-        const result = await discoverRelated('disc-backend:T001', 'auto');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            expect(result.results.length).toBeGreaterThan(0);
-            expect(result.method).toBe('auto');
-        }
-    });
-    it('returns error for invalid query syntax', async () => {
-        const result = await discoverRelated('invalid-syntax');
-        expect('error' in result).toBe(true);
-        if ('error' in result) {
-            expect(result.error.code).toBe('E_INVALID_INPUT');
-        }
-    });
-    it('returns error for wildcard queries', async () => {
-        const result = await discoverRelated('*:T001');
-        expect('error' in result).toBe(true);
-        if ('error' in result) {
-            expect(result.error.code).toBe('E_INVALID_INPUT');
-            expect(result.error.message).toContain('Wildcard');
-        }
-    });
-    it('respects limit parameter', async () => {
-        const result = await discoverRelated('disc-backend:T001', 'auto', 1);
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            expect(result.results.length).toBeLessThanOrEqual(1);
-        }
-    });
-    it('results are sorted by score descending', async () => {
-        const result = await discoverRelated('disc-backend:T001', 'auto', 10);
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            for (let i = 1; i < result.results.length; i++) {
-                expect(result.results[i].score).toBeLessThanOrEqual(result.results[i - 1].score);
-            }
-        }
-    });
-    it('each result has correct shape', async () => {
-        const result = await discoverRelated('disc-backend:T001', 'auto');
-        expect('error' in result).toBe(false);
-        if (!('error' in result)) {
-            for (const r of result.results) {
-                expect(r).toHaveProperty('project');
-                expect(r).toHaveProperty('taskId');
-                expect(r).toHaveProperty('title');
-                expect(r).toHaveProperty('score');
-                expect(r).toHaveProperty('type');
-                expect(r).toHaveProperty('reason');
-                expect(typeof r.score).toBe('number');
-                expect(r.score).toBeGreaterThan(0);
-            }
-        }
-    });
-});
-// =====================================================================
-// 12. RECONCILIATION EXTENDED
-// =====================================================================
-describe('reconciliation extended', () => {
-    it('reconcile without projectId falls back to hash-based lookup', async () => {
-        // Create a project without project-info.json
-        const projDir = join(testDir, 'hashonly-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        const hash = await nexusRegister(projDir, 'hashonly-proj', 'read');
-        // Reconcile should find by hash (no project-info.json)
-        const result = await nexusReconcile(projDir);
-        expect(result.status).toBe('ok');
-    });
-    it('auto-registers unknown project without projectId', async () => {
-        const projDir = join(testDir, 'auto-reg-no-id');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        const result = await nexusReconcile(projDir);
-        expect(result.status).toBe('auto_registered');
-        // Verify it's now in the registry
-        const hash = generateProjectHash(projDir);
-        const project = await nexusGetProject(hash);
-        expect(project).not.toBeNull();
-    });
-});
-// =====================================================================
-// 13. EDGE CASES
-// =====================================================================
-describe('edge cases', () => {
-    it('handles project with very long path', async () => {
-        // Create a deeply nested directory
-        const deepPath = join(testDir, 'a'.repeat(50), 'b'.repeat(50), 'c'.repeat(50), 'project');
-        await createTestProjectDb(deepPath, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        const hash = await nexusRegister(deepPath, 'long-path-proj', 'read');
-        expect(hash).toMatch(/^[a-f0-9]{12}$/);
-        const project = await nexusGetProject('long-path-proj');
-        expect(project).not.toBeNull();
-        expect(project.path).toBe(deepPath);
-    });
-    it('empty project path throws', async () => {
-        await expect(nexusRegister('', 'empty-path')).rejects.toThrow(/required/i);
-    });
-    it('empty name or hash for unregister throws', async () => {
-        await expect(nexusUnregister('')).rejects.toThrow(/required/i);
-    });
-    it('empty name or hash for sync throws', async () => {
-        await expect(nexusSync('')).rejects.toThrow(/required/i);
-    });
-    it('nexusInit is idempotent (multiple calls)', async () => {
-        await nexusInit();
-        await nexusInit();
-        await nexusInit();
-        const registry = await readRegistry();
-        expect(registry).not.toBeNull();
-    });
-    it('project with no tasks registers with taskCount=0', async () => {
-        const emptyDir = join(testDir, 'empty-tasks');
-        await createTestProjectDb(emptyDir, []);
-        await nexusRegister(emptyDir, 'empty-proj', 'read');
-        const project = await nexusGetProject('empty-proj');
-        expect(project).not.toBeNull();
-        expect(project.taskCount).toBe(0);
-        expect(project.labels).toEqual([]);
-    });
-    it('project labels are sorted and deduplicated', async () => {
-        const projDir = join(testDir, 'labels-proj');
-        await createTestProjectDb(projDir, [
-            {
-                id: 'T001',
-                title: 'Task 1',
-                status: 'pending',
-                description: 'a',
-                labels: ['z-label', 'a-label'],
-            },
-            {
-                id: 'T002',
-                title: 'Task 2',
-                status: 'pending',
-                description: 'b',
-                labels: ['a-label', 'm-label'],
-            },
-        ]);
-        await nexusRegister(projDir, 'labels-proj', 'read');
-        const project = await nexusGetProject('labels-proj');
-        expect(project.labels).toEqual(['a-label', 'm-label', 'z-label']);
-    });
-    it('nexusGetProject returns null for empty string', async () => {
-        await nexusInit();
-        const project = await nexusGetProject('');
-        expect(project).toBeNull();
-    });
-    it('nexusList returns empty array when nexus.db is fresh', async () => {
-        await nexusInit();
-        const projects = await nexusList();
-        expect(projects).toEqual([]);
-    });
-    it('readRegistry lastUpdated reflects most recent lastSeen', async () => {
-        const projDir = join(testDir, 'last-updated');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'lu-proj', 'read');
-        const registry = await readRegistry();
-        expect(registry).not.toBeNull();
-        expect(registry.lastUpdated).toBeTruthy();
-        const luDate = new Date(registry.lastUpdated);
-        expect(luDate.getTime()).not.toBeNaN();
-    });
-    it('project hash is deterministic and 12 hex chars', () => {
-        const path = '/some/unique/path/to/project';
-        const h1 = generateProjectHash(path);
-        const h2 = generateProjectHash(path);
-        expect(h1).toBe(h2);
-        expect(h1).toMatch(/^[a-f0-9]{12}$/);
-        expect(h1.length).toBe(12);
-    });
-    it('different paths produce different hashes', () => {
-        const h1 = generateProjectHash('/path/a');
-        const h2 = generateProjectHash('/path/b');
-        expect(h1).not.toBe(h2);
-    });
-});
-// =====================================================================
-// 14. QUERY MODULE EXTENDED
-// =====================================================================
-describe('query module extended', () => {
-    it('validateSyntax accepts 3+ digit task IDs', () => {
-        expect(validateSyntax('T001')).toBe(true);
-        expect(validateSyntax('T99999')).toBe(true);
-        expect(validateSyntax('T1234567890')).toBe(true);
-    });
-    it('validateSyntax rejects empty string', () => {
-        expect(validateSyntax('')).toBe(false);
-    });
-    it('validateSyntax rejects task IDs with fewer than 3 digits', () => {
-        expect(validateSyntax('T1')).toBe(false);
-        expect(validateSyntax('T12')).toBe(false);
-    });
-    it('parseQuery with currentProject override', () => {
-        const result = parseQuery('T001', 'override-proj');
-        expect(result.project).toBe('override-proj');
-        expect(result.taskId).toBe('T001');
-    });
-    it('parseQuery dot syntax uses currentProject', () => {
-        const result = parseQuery('.:T001', 'my-proj');
-        expect(result.project).toBe('my-proj');
-    });
-    it('getProjectFromQuery extracts project correctly for all syntaxes', () => {
-        expect(getProjectFromQuery('my-app:T001')).toBe('my-app');
-        expect(getProjectFromQuery('*:T001')).toBe('*');
-        expect(getProjectFromQuery('T001', 'current')).toBe('current');
-        expect(getProjectFromQuery('.:T001', 'current')).toBe('current');
-    });
-});
-// =====================================================================
-// 15. PERMISSION MODULE EXTENDED
-// =====================================================================
-describe('permission module extended', () => {
-    it('permissionLevel returns correct values for all levels', () => {
-        expect(permissionLevel('read')).toBe(1);
-        expect(permissionLevel('write')).toBe(2);
-        expect(permissionLevel('execute')).toBe(3);
-        expect(permissionLevel('invalid')).toBe(0);
-        expect(permissionLevel('')).toBe(0);
-    });
-    it('getPermission returns read for unregistered project', async () => {
-        await nexusInit();
-        const perm = await getPermission('no-such-proj');
-        expect(perm).toBe('read');
-    });
-    it('checkPermissionDetail returns full detail', async () => {
-        const projDir = join(testDir, 'detail-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'detail-proj', 'write');
-        const result = await checkPermissionDetail('detail-proj', 'execute');
-        expect(result.project).toBe('detail-proj');
-        expect(result.required).toBe('execute');
-        expect(result.granted).toBe('write');
-        expect(result.allowed).toBe(false);
-    });
-    it('requirePermission throws with descriptive message', async () => {
-        const projDir = join(testDir, 'require-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'require-proj', 'read');
-        await expect(requirePermission('require-proj', 'execute', 'delete task')).rejects.toThrow(/Permission denied.*execute.*require-proj/);
-    });
-    it('permission hierarchy: write includes read', async () => {
-        const projDir = join(testDir, 'hier-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'hier-proj', 'write');
-        expect(await canRead('hier-proj')).toBe(true);
-        expect(await canWrite('hier-proj')).toBe(true);
-        expect(await canExecute('hier-proj')).toBe(false);
-    });
-    it('NEXUS_SKIP_PERMISSION_CHECK bypasses all checks', async () => {
-        const projDir = join(testDir, 'bypass-proj');
-        await createTestProjectDb(projDir, [
-            { id: 'T001', title: 'Task', status: 'pending', description: 'desc' },
-        ]);
-        await nexusRegister(projDir, 'bypass-proj', 'read');
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        expect(await checkPermission('bypass-proj', 'execute')).toBe(true);
-        await expect(requirePermission('bypass-proj', 'execute')).resolves.toBeUndefined();
-    });
-});
-// =====================================================================
-// 16. GRAPH CACHING
-// =====================================================================
-describe('graph caching', () => {
-    it('invalidateGraphCache forces rebuild', async () => {
-        const dirA = join(testDir, 'cache-proj');
-        await createTestProjectDb(dirA, [
-            { id: 'T001', title: 'Task', status: 'done', description: 'desc' },
-        ]);
-        process.env['NEXUS_SKIP_PERMISSION_CHECK'] = 'true';
-        await nexusRegister(dirA, 'cache-proj', 'read');
-        const graph1 = await buildGlobalGraph();
-        invalidateGraphCache();
-        const graph2 = await buildGlobalGraph();
-        // After invalidation, graph2 should be a new object
-        // (may or may not be strictly === depending on checksum)
-        expect(graph2.nodes).toHaveLength(graph1.nodes.length);
-    });
-});
-//# sourceMappingURL=nexus-e2e.test.js.map