sqlew 3.2.5 → 3.6.0

package/dist/tests/tasks.dependencies.test.js

@@ -3,36 +3,23 @@
  * Tests add_dependency, remove_dependency, get_dependencies actions
  * and enhanced list/get actions with dependency support
  */
-import { describe, it, beforeEach } from 'node:test';
+import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import Database from 'better-sqlite3';
-import { initializeSchema } from '../schema.js';
-import { migrateToTaskDependencies } from '../migrations/add-task-dependencies.js';
-import { getOrCreateAgent, transaction } from '../database.js';
+import { initializeDatabase, getOrCreateAgent, closeDatabase } from '../database.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 /**
  * Test database instance
  */
 let testDb;
-/**
- * Create an in-memory test database
- */
-function createTestDatabase() {
-    const db = new Database(':memory:');
-    db.pragma('foreign_keys = ON');
-    // Initialize schema
-    initializeSchema(db);
-    // Run task dependencies migration
-    const migrationResult = migrateToTaskDependencies(db);
-    if (!migrationResult.success) {
-        throw new Error(`Migration failed: ${migrationResult.message}`);
-    }
-    return db;
-}
+let tempDir;
+let tempDbPath;
 /**
  * Helper: Create a test task
  */
-function createTestTask(db, title, status = 'todo') {
-    const agentId = getOrCreateAgent(db, 'test-agent');
+async function createTestTask(db, title, status = 'todo') {
+    const agentId = await getOrCreateAgent(db, 'test-agent');
     const statusIdMap = {
         'todo': 1,
         'in_progress': 2,
@@ -42,181 +29,206 @@ function createTestTask(db, title, status = 'todo') {
         'archived': 6
     };
     const statusId = statusIdMap[status];
-    const result = db.prepare(`
-    INSERT INTO t_tasks (title, status_id, priority, created_by_agent_id, assigned_agent_id)
-    VALUES (?, ?, 2, ?, ?)
-  `).run(title, statusId, agentId, agentId);
-    return result.lastInsertRowid;
+    const knex = db.getKnex();
+    const now = Math.floor(Date.now() / 1000);
+    const [taskId] = await knex('t_tasks').insert({
+        title,
+        status_id: statusId,
+        priority: 2,
+        created_by_agent_id: agentId,
+        assigned_agent_id: agentId,
+        created_ts: now,
+        updated_ts: now
+    });
+    return taskId;
 }
 /**
  * Inline implementation of addDependency for testing (avoiding module dependency)
  */
-function addDependencyTest(db, params) {
-    if (!params.blocker_task_id) {
-        throw new Error('Parameter "blocker_task_id" is required');
+async function addDependencyTest(db, params) {
+    if (!params.depends_on_task_id) {
+        throw new Error('Parameter "depends_on_task_id" is required');
     }
-    if (!params.blocked_task_id) {
-        throw new Error('Parameter "blocked_task_id" is required');
+    if (!params.task_id) {
+        throw new Error('Parameter "task_id" is required');
     }
-    return transaction(db, () => {
+    const knex = db.getKnex();
+    return await knex.transaction(async (trx) => {
         const TASK_STATUS_ARCHIVED = 6;
         // Validation 1: No self-dependencies
-        if (params.blocker_task_id === params.blocked_task_id) {
+        if (params.depends_on_task_id === params.task_id) {
             throw new Error('Self-dependency not allowed');
         }
         // Validation 2: Both tasks must exist and check if archived
-        const blockerTask = db.prepare('SELECT id, status_id FROM t_tasks WHERE id = ?').get(params.blocker_task_id);
-        const blockedTask = db.prepare('SELECT id, status_id FROM t_tasks WHERE id = ?').get(params.blocked_task_id);
-        if (!blockerTask) {
-            throw new Error(`Blocker task #${params.blocker_task_id} not found`);
+        const dependsOnTask = await trx('t_tasks')
+            .where({ id: params.depends_on_task_id })
+            .select('id', 'status_id')
+            .first();
+        const task = await trx('t_tasks')
+            .where({ id: params.task_id })
+            .select('id', 'status_id')
+            .first();
+        if (!dependsOnTask) {
+            throw new Error(`Task #${params.depends_on_task_id} not found`);
         }
-        if (!blockedTask) {
-            throw new Error(`Blocked task #${params.blocked_task_id} not found`);
+        if (!task) {
+            throw new Error(`Task #${params.task_id} not found`);
         }
         // Validation 3: Neither task is archived
-        if (blockerTask.status_id === TASK_STATUS_ARCHIVED) {
-            throw new Error(`Cannot add dependency: Task #${params.blocker_task_id} is archived`);
+        if (dependsOnTask.status_id === TASK_STATUS_ARCHIVED) {
+            throw new Error(`Cannot add dependency: Task #${params.depends_on_task_id} is archived`);
         }
-        if (blockedTask.status_id === TASK_STATUS_ARCHIVED) {
-            throw new Error(`Cannot add dependency: Task #${params.blocked_task_id} is archived`);
+        if (task.status_id === TASK_STATUS_ARCHIVED) {
+            throw new Error(`Cannot add dependency: Task #${params.task_id} is archived`);
         }
         // Validation 4: No direct circular (reverse relationship)
-        const reverseExists = db.prepare(`
-      SELECT 1 FROM t_task_dependencies
-      WHERE blocker_task_id = ? AND blocked_task_id = ?
-    `).get(params.blocked_task_id, params.blocker_task_id);
+        const reverseExists = await trx('t_task_dependencies')
+            .where({
+            depends_on_task_id: params.task_id,
+            task_id: params.depends_on_task_id
+        })
+            .first();
         if (reverseExists) {
-            throw new Error(`Circular dependency detected: Task #${params.blocked_task_id} already blocks Task #${params.blocker_task_id}`);
+            throw new Error(`Circular dependency detected: Task #${params.task_id} already depends on Task #${params.depends_on_task_id}`);
         }
         // Validation 5: No transitive circular (check if adding this would create a cycle)
-        const cycleCheck = db.prepare(`
+        const cycleCheck = await trx.raw(`
       WITH RECURSIVE dependency_chain AS (
-        -- Start from the task that would be blocked
-        SELECT blocked_task_id as task_id, 1 as depth
+        -- Start from the task that would have the dependency
+        SELECT task_id, 1 as depth
         FROM t_task_dependencies
-        WHERE blocker_task_id = ?
+        WHERE depends_on_task_id = ?
 
         UNION ALL
 
         -- Follow the chain of dependencies
-        SELECT d.blocked_task_id, dc.depth + 1
+        SELECT d.task_id, dc.depth + 1
         FROM t_task_dependencies d
-        JOIN dependency_chain dc ON d.blocker_task_id = dc.task_id
+        JOIN dependency_chain dc ON d.depends_on_task_id = dc.task_id
         WHERE dc.depth < 100
       )
       SELECT task_id FROM dependency_chain WHERE task_id = ?
-    `).get(params.blocked_task_id, params.blocker_task_id);
-        if (cycleCheck) {
+    `, [params.task_id, params.depends_on_task_id]);
+        const cycleResult = Array.isArray(cycleCheck) ? cycleCheck[0] : cycleCheck;
+        if (cycleResult && cycleResult.task_id) {
             // Build cycle path for error message
-            const cyclePathResult = db.prepare(`
+            const cyclePathResult = await trx.raw(`
         WITH RECURSIVE dependency_chain AS (
-          SELECT blocked_task_id as task_id, 1 as depth,
-                 CAST(blocked_task_id AS TEXT) as path
+          SELECT task_id, 1 as depth,
+                 CAST(task_id AS TEXT) as path
           FROM t_task_dependencies
-          WHERE blocker_task_id = ?
+          WHERE depends_on_task_id = ?
 
           UNION ALL
 
-          SELECT d.blocked_task_id, dc.depth + 1,
-                 dc.path || ' → ' || d.blocked_task_id
+          SELECT d.task_id, dc.depth + 1,
+                 dc.path || ' → ' || d.task_id
           FROM t_task_dependencies d
-          JOIN dependency_chain dc ON d.blocker_task_id = dc.task_id
+          JOIN dependency_chain dc ON d.depends_on_task_id = dc.task_id
           WHERE dc.depth < 100
         )
         SELECT path FROM dependency_chain WHERE task_id = ? ORDER BY depth DESC LIMIT 1
-      `).get(params.blocked_task_id, params.blocker_task_id);
-            const cyclePath = cyclePathResult?.path || `#${params.blocked_task_id} → ... → #${params.blocker_task_id}`;
-            throw new Error(`Circular dependency detected: Task #${params.blocker_task_id} → #${cyclePath} → #${params.blocker_task_id}`);
+      `, [params.task_id, params.depends_on_task_id]);
+            const pathResult = Array.isArray(cyclePathResult) ? cyclePathResult[0] : cyclePathResult;
+            const cyclePath = pathResult?.path || `#${params.task_id} → ... → #${params.depends_on_task_id}`;
+            throw new Error(`Circular dependency detected: Task #${params.depends_on_task_id} → #${cyclePath} → #${params.depends_on_task_id}`);
         }
         // All validations passed - insert dependency
-        const insertStmt = db.prepare(`
-      INSERT INTO t_task_dependencies (blocker_task_id, blocked_task_id)
-      VALUES (?, ?)
-    `);
-        insertStmt.run(params.blocker_task_id, params.blocked_task_id);
+        const now = Math.floor(Date.now() / 1000);
+        await trx('t_task_dependencies').insert({
+            depends_on_task_id: params.depends_on_task_id,
+            task_id: params.task_id,
+            created_ts: now
+        });
         return {
             success: true,
-            message: `Dependency added: Task #${params.blocker_task_id} blocks Task #${params.blocked_task_id}`
+            message: `Dependency added: Task #${params.task_id} depends on Task #${params.depends_on_task_id}`
         };
     });
 }
 /**
  * Inline implementation of removeDependency for testing
  */
-function removeDependencyTest(db, params) {
-    if (!params.blocker_task_id) {
-        throw new Error('Parameter "blocker_task_id" is required');
+async function removeDependencyTest(db, params) {
+    if (!params.depends_on_task_id) {
+        throw new Error('Parameter "depends_on_task_id" is required');
     }
-    if (!params.blocked_task_id) {
-        throw new Error('Parameter "blocked_task_id" is required');
+    if (!params.task_id) {
+        throw new Error('Parameter "task_id" is required');
     }
-    const deleteStmt = db.prepare(`
-    DELETE FROM t_task_dependencies
-    WHERE blocker_task_id = ? AND blocked_task_id = ?
-  `);
-    deleteStmt.run(params.blocker_task_id, params.blocked_task_id);
+    const knex = db.getKnex();
+    await knex('t_task_dependencies')
+        .where({
+        depends_on_task_id: params.depends_on_task_id,
+        task_id: params.task_id
+    })
+        .delete();
     return {
         success: true,
-        message: `Dependency removed: Task #${params.blocker_task_id} no longer blocks Task #${params.blocked_task_id}`
+        message: `Dependency removed: Task #${params.task_id} no longer depends on Task #${params.depends_on_task_id}`
     };
 }
 /**
  * Inline implementation of getDependencies for testing
  */
-function getDependenciesTest(db, params) {
+async function getDependenciesTest(db, params) {
     if (!params.task_id) {
         throw new Error('Parameter "task_id" is required');
     }
     const includeDetails = params.include_details || false;
+    const knex = db.getKnex();
     // Check if task exists
-    const taskExists = db.prepare('SELECT id FROM t_tasks WHERE id = ?').get(params.task_id);
+    const taskExists = await knex('t_tasks')
+        .where({ id: params.task_id })
+        .select('id')
+        .first();
     if (!taskExists) {
         throw new Error(`Task with id ${params.task_id} not found`);
     }
     // Build query based on include_details flag
     let selectFields;
     if (includeDetails) {
-        selectFields = `
-      t.id,
-      t.title,
-      s.name as status,
-      t.priority,
-      aa.name as assigned_to,
-      t.created_ts,
-      t.updated_ts,
-      td.description
-    `;
+        selectFields = [
+            't.id',
+            't.title',
+            's.name as status',
+            't.priority',
+            'aa.name as assigned_to',
+            't.created_ts',
+            't.updated_ts',
+            'td.description'
+        ];
     }
     else {
-        selectFields = `
-      t.id,
-      t.title,
-      s.name as status,
-      t.priority
-    `;
+        selectFields = [
+            't.id',
+            't.title',
+            's.name as status',
+            't.priority'
+        ];
     }
-    // Get blockers (tasks that block this task)
-    const blockersQuery = `
-    SELECT ${selectFields}
-    FROM t_tasks t
-    JOIN t_task_dependencies d ON t.id = d.blocker_task_id
-    LEFT JOIN m_task_statuses s ON t.status_id = s.id
-    LEFT JOIN m_agents aa ON t.assigned_agent_id = aa.id
-    ${includeDetails ? 'LEFT JOIN t_task_details td ON t.id = td.task_id' : ''}
-    WHERE d.blocked_task_id = ?
-  `;
-    const blockers = db.prepare(blockersQuery).all(params.task_id);
-    // Get blocking (tasks this task blocks)
-    const blockingQuery = `
-    SELECT ${selectFields}
-    FROM t_tasks t
-    JOIN t_task_dependencies d ON t.id = d.blocked_task_id
-    LEFT JOIN m_task_statuses s ON t.status_id = s.id
-    LEFT JOIN m_agents aa ON t.assigned_agent_id = aa.id
-    ${includeDetails ? 'LEFT JOIN t_task_details td ON t.id = td.task_id' : ''}
-    WHERE d.blocker_task_id = ?
-  `;
-    const blocking = db.prepare(blockingQuery).all(params.task_id);
+    // Get blockers (tasks that this task depends on)
+    let blockersQuery = knex('t_tasks as t')
+        .join('t_task_dependencies as d', 't.id', 'd.depends_on_task_id')
+        .leftJoin('m_task_statuses as s', 't.status_id', 's.id')
+        .leftJoin('m_agents as aa', 't.assigned_agent_id', 'aa.id')
+        .where('d.task_id', params.task_id)
+        .select(selectFields);
+    if (includeDetails) {
+        blockersQuery = blockersQuery.leftJoin('t_task_details as td', 't.id', 'td.task_id');
+    }
+    const blockers = await blockersQuery;
+    // Get blocking (tasks that depend on this task)
+    let blockingQuery = knex('t_tasks as t')
+        .join('t_task_dependencies as d', 't.id', 'd.task_id')
+        .leftJoin('m_task_statuses as s', 't.status_id', 's.id')
+        .leftJoin('m_agents as aa', 't.assigned_agent_id', 'aa.id')
+        .where('d.depends_on_task_id', params.task_id)
+        .select(selectFields);
+    if (includeDetails) {
+        blockingQuery = blockingQuery.leftJoin('t_task_details as td', 't.id', 'td.task_id');
+    }
+    const blocking = await blockingQuery;
     return {
         task_id: params.task_id,
         blockers,
@@ -226,43 +238,61 @@ function getDependenciesTest(db, params) {
 /**
  * Setup before each test
  */
-beforeEach(() => {
-    // Create fresh database for each test
-    testDb = createTestDatabase();
+beforeEach(async () => {
+    // Create temp directory for test files and database
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sqlew-test-'));
+    tempDbPath = path.join(tempDir, 'test.db');
+    // Initialize database with Knex adapter
+    testDb = await initializeDatabase({
+        databaseType: 'sqlite',
+        connection: {
+            filename: tempDbPath,
+        },
+    });
+});
+afterEach(async () => {
+    await closeDatabase();
+    // Cleanup temp directory
+    if (fs.existsSync(tempDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
 });
 // ============================================================================
 // Task #66: Unit Tests for add_dependency Validation
 // ============================================================================
 describe('add_dependency - Success Cases', () => {
-    it('should add valid dependency', () => {
+    it('should add valid dependency', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
-        const task2 = createTestTask(testDb, 'Task 2');
+        const task1 = await createTestTask(testDb, 'Task 1');
+        const task2 = await createTestTask(testDb, 'Task 2');
         // Act
-        const result = addDependencyTest(testDb, {
-            blocker_task_id: task1,
-            blocked_task_id: task2
+        const result = await addDependencyTest(testDb, {
+            depends_on_task_id: task1,
+            task_id: task2
         });
         // Assert
         assert.strictEqual(result.success, true);
         assert.match(result.message, /Dependency added/);
         // Verify in database
-        const deps = testDb.prepare(`
-      SELECT * FROM t_task_dependencies
-      WHERE blocker_task_id = ? AND blocked_task_id = ?
-    `).get(task1, task2);
+        const knex = testDb.getKnex();
+        const deps = await knex('t_task_dependencies')
+            .where({
+            depends_on_task_id: task1,
+            task_id: task2
+        })
+            .first();
         assert.ok(deps);
     });
-    it('should add valid dependency and verify via get_dependencies', () => {
+    it('should add valid dependency and verify via get_dependencies', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
-        const task2 = createTestTask(testDb, 'Task 2');
+        const task1 = await createTestTask(testDb, 'Task 1');
+        const task2 = await createTestTask(testDb, 'Task 2');
         // Act
-        addDependencyTest(testDb, {
-            blocker_task_id: task1,
-            blocked_task_id: task2
+        await addDependencyTest(testDb, {
+            depends_on_task_id: task1,
+            task_id: task2
         });
-        const result = getDependenciesTest(testDb, { task_id: task2 });
+        const result = await getDependenciesTest(testDb, { task_id: task2 });
         // Assert
         assert.strictEqual(result.task_id, task2);
         assert.strictEqual(result.blockers.length, 1);
@@ -271,14 +301,14 @@ describe('add_dependency - Success Cases', () => {
     });
 });
 describe('add_dependency - Validation: Self-Dependency', () => {
-    it('should reject self-dependency', () => {
+    it('should reject self-dependency', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
+        const task1 = await createTestTask(testDb, 'Task 1');
         // Act & Assert
-        assert.throws(() => {
-            addDependencyTest(testDb, {
-                blocker_task_id: task1,
-                blocked_task_id: task1
+        await assert.rejects(async () => {
+            await addDependencyTest(testDb, {
+                depends_on_task_id: task1,
+                task_id: task1
             });
         }, {
             message: /Self-dependency not allowed/
@@ -286,20 +316,20 @@ describe('add_dependency - Validation: Self-Dependency', () => {
     });
 });
 describe('add_dependency - Validation: Direct Circular', () => {
-    it('should reject direct circular dependency', () => {
+    it('should reject direct circular dependency', async () => {
         // Arrange
-        const taskA = createTestTask(testDb, 'Task A');
-        const taskB = createTestTask(testDb, 'Task B');
-        // Add A blocks B
-        addDependencyTest(testDb, {
-            blocker_task_id: taskA,
-            blocked_task_id: taskB
+        const taskA = await createTestTask(testDb, 'Task A');
+        const taskB = await createTestTask(testDb, 'Task B');
+        // Add A blocks B (B depends on A)
+        await addDependencyTest(testDb, {
+            depends_on_task_id: taskA,
+            task_id: taskB
         });
-        // Act & Assert - Try to add B blocks A
-        assert.throws(() => {
-            addDependencyTest(testDb, {
-                blocker_task_id: taskB,
-                blocked_task_id: taskA
+        // Act & Assert - Try to add B blocks A (A depends on B)
+        await assert.rejects(async () => {
+            await addDependencyTest(testDb, {
+                depends_on_task_id: taskB,
+                task_id: taskA
             });
         }, {
             message: /Circular dependency detected/
@@ -307,51 +337,51 @@ describe('add_dependency - Validation: Direct Circular', () => {
     });
 });
 describe('add_dependency - Validation: Transitive Circular', () => {
-    it('should reject transitive circular dependency (A→B→C→A)', () => {
+    it('should reject transitive circular dependency (A→B→C→A)', async () => {
         // Arrange
-        const taskA = createTestTask(testDb, 'Task A');
-        const taskB = createTestTask(testDb, 'Task B');
-        const taskC = createTestTask(testDb, 'Task C');
-        // Add A blocks B
-        addDependencyTest(testDb, {
-            blocker_task_id: taskA,
-            blocked_task_id: taskB
+        const taskA = await createTestTask(testDb, 'Task A');
+        const taskB = await createTestTask(testDb, 'Task B');
+        const taskC = await createTestTask(testDb, 'Task C');
+        // Add A blocks B (B depends on A)
+        await addDependencyTest(testDb, {
+            depends_on_task_id: taskA,
+            task_id: taskB
         });
-        // Add B blocks C
-        addDependencyTest(testDb, {
-            blocker_task_id: taskB,
-            blocked_task_id: taskC
+        // Add B blocks C (C depends on B)
+        await addDependencyTest(testDb, {
+            depends_on_task_id: taskB,
+            task_id: taskC
         });
-        // Act & Assert - Try to add C blocks A (would create cycle)
-        assert.throws(() => {
-            addDependencyTest(testDb, {
-                blocker_task_id: taskC,
-                blocked_task_id: taskA
+        // Act & Assert - Try to add C blocks A (A depends on C, would create cycle)
+        await assert.rejects(async () => {
+            await addDependencyTest(testDb, {
+                depends_on_task_id: taskC,
+                task_id: taskA
             });
         }, {
             message: /Circular dependency detected/
         });
     });
-    it('should reject transitive circular with cycle path in error message', () => {
+    it('should reject transitive circular with cycle path in error message', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
-        const task2 = createTestTask(testDb, 'Task 2');
-        const task3 = createTestTask(testDb, 'Task 3');
-        // Create chain: 1 → 2 → 3
-        addDependencyTest(testDb, {
-            blocker_task_id: task1,
-            blocked_task_id: task2
+        const task1 = await createTestTask(testDb, 'Task 1');
+        const task2 = await createTestTask(testDb, 'Task 2');
+        const task3 = await createTestTask(testDb, 'Task 3');
+        // Create chain: 1 → 2 → 3 (2 depends on 1, 3 depends on 2)
+        await addDependencyTest(testDb, {
+            depends_on_task_id: task1,
+            task_id: task2
         });
-        addDependencyTest(testDb, {
-            blocker_task_id: task2,
-            blocked_task_id: task3
+        await addDependencyTest(testDb, {
+            depends_on_task_id: task2,
+            task_id: task3
         });
-        // Act & Assert - Try to add 3 → 1
+        // Act & Assert - Try to add 3 → 1 (1 depends on 3)
         let errorMessage = '';
         try {
-            addDependencyTest(testDb, {
-                blocker_task_id: task3,
-                blocked_task_id: task1
+            await addDependencyTest(testDb, {
+                depends_on_task_id: task3,
+                task_id: task1
             });
         }
         catch (error) {
@@ -366,57 +396,57 @@ describe('add_dependency - Validation: Transitive Circular', () => {
     });
 });
 describe('add_dependency - Validation: Non-Existent Tasks', () => {
-    it('should reject dependency with non-existent blocker', () => {
+    it('should reject dependency with non-existent blocker', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
+        const task1 = await createTestTask(testDb, 'Task 1');
         // Act & Assert
-        assert.throws(() => {
-            addDependencyTest(testDb, {
-                blocker_task_id: 999,
-                blocked_task_id: task1
+        await assert.rejects(async () => {
+            await addDependencyTest(testDb, {
+                depends_on_task_id: 999,
+                task_id: task1
             });
         }, {
-            message: /Blocker task #999 not found/
+            message: /Task #999 not found/
         });
     });
-    it('should reject dependency with non-existent blocked', () => {
+    it('should reject dependency with non-existent blocked', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
+        const task1 = await createTestTask(testDb, 'Task 1');
         // Act & Assert
-        assert.throws(() => {
-            addDependencyTest(testDb, {
-                blocker_task_id: task1,
-                blocked_task_id: 999
+        await assert.rejects(async () => {
+            await addDependencyTest(testDb, {
+                depends_on_task_id: task1,
+                task_id: 999
             });
         }, {
-            message: /Blocked task #999 not found/
+            message: /Task #999 not found/
         });
     });
 });
 describe('add_dependency - Validation: Archived Tasks', () => {
-    it('should reject dependency with archived blocker', () => {
+    it('should reject dependency with archived blocker', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1', 'archived');
-        const task2 = createTestTask(testDb, 'Task 2');
+        const task1 = await createTestTask(testDb, 'Task 1', 'archived');
+        const task2 = await createTestTask(testDb, 'Task 2');
         // Act & Assert
-        assert.throws(() => {
-            addDependencyTest(testDb, {
-                blocker_task_id: task1,
-                blocked_task_id: task2
+        await assert.rejects(async () => {
+            await addDependencyTest(testDb, {
+                depends_on_task_id: task1,
+                task_id: task2
             });
         }, {
             message: /Cannot add dependency: Task #\d+ is archived/
         });
     });
-    it('should reject dependency with archived blocked', () => {
+    it('should reject dependency with archived blocked', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
-        const task2 = createTestTask(testDb, 'Task 2', 'archived');
+        const task1 = await createTestTask(testDb, 'Task 1');
+        const task2 = await createTestTask(testDb, 'Task 2', 'archived');
         // Act & Assert
-        assert.throws(() => {
-            addDependencyTest(testDb, {
-                blocker_task_id: task1,
-                blocked_task_id: task2
+        await assert.rejects(async () => {
+            await addDependencyTest(testDb, {
+                depends_on_task_id: task1,
+                task_id: task2
             });
         }, {
             message: /Cannot add dependency: Task #\d+ is archived/
@@ -427,37 +457,37 @@ describe('add_dependency - Validation: Archived Tasks', () => {
 // Task #67: Unit Tests for remove_dependency and get_dependencies
 // ============================================================================
 describe('remove_dependency', () => {
-    it('should remove existing dependency', () => {
+    it('should remove existing dependency', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
-        const task2 = createTestTask(testDb, 'Task 2');
-        addDependencyTest(testDb, {
-            blocker_task_id: task1,
-            blocked_task_id: task2
+        const task1 = await createTestTask(testDb, 'Task 1');
+        const task2 = await createTestTask(testDb, 'Task 2');
+        await addDependencyTest(testDb, {
+            depends_on_task_id: task1,
+            task_id: task2
         });
         // Verify it exists
-        const beforeDeps = getDependenciesTest(testDb, { task_id: task2 });
+        const beforeDeps = await getDependenciesTest(testDb, { task_id: task2 });
         assert.strictEqual(beforeDeps.blockers.length, 1);
         // Act
-        const result = removeDependencyTest(testDb, {
-            blocker_task_id: task1,
-            blocked_task_id: task2
+        const result = await removeDependencyTest(testDb, {
+            depends_on_task_id: task1,
+            task_id: task2
         });
         // Assert
         assert.strictEqual(result.success, true);
         assert.match(result.message, /Dependency removed/);
         // Verify it no longer exists
-        const afterDeps = getDependenciesTest(testDb, { task_id: task2 });
+        const afterDeps = await getDependenciesTest(testDb, { task_id: task2 });
         assert.strictEqual(afterDeps.blockers.length, 0);
     });
-    it('should succeed silently when removing non-existent dependency (idempotent)', () => {
+    it('should succeed silently when removing non-existent dependency (idempotent)', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
-        const task2 = createTestTask(testDb, 'Task 2');
+        const task1 = await createTestTask(testDb, 'Task 1');
+        const task2 = await createTestTask(testDb, 'Task 2');
         // Act - Remove dependency that doesn't exist
-        const result = removeDependencyTest(testDb, {
-            blocker_task_id: task1,
-            blocked_task_id: task2
+        const result = await removeDependencyTest(testDb, {
+            depends_on_task_id: task1,
+            task_id: task2
         });
         // Assert
         assert.strictEqual(result.success, true);
@@ -465,22 +495,22 @@ describe('remove_dependency', () => {
     });
 });
 describe('get_dependencies - Metadata Only', () => {
-    it('should return blockers and blocking (metadata-only)', () => {
+    it('should return blockers and blocking (metadata-only)', async () => {
         // Arrange
-        const taskA = createTestTask(testDb, 'Task A');
-        const taskB = createTestTask(testDb, 'Task B');
-        const taskC = createTestTask(testDb, 'Task C');
-        // A blocks B, B blocks C
-        addDependencyTest(testDb, {
-            blocker_task_id: taskA,
-            blocked_task_id: taskB
+        const taskA = await createTestTask(testDb, 'Task A');
+        const taskB = await createTestTask(testDb, 'Task B');
+        const taskC = await createTestTask(testDb, 'Task C');
+        // A blocks B, B blocks C (B depends on A, C depends on B)
+        await addDependencyTest(testDb, {
+            depends_on_task_id: taskA,
+            task_id: taskB
         });
-        addDependencyTest(testDb, {
-            blocker_task_id: taskB,
-            blocked_task_id: taskC
+        await addDependencyTest(testDb, {
+            depends_on_task_id: taskB,
+            task_id: taskC
         });
         // Act - Get dependencies for B
-        const result = getDependenciesTest(testDb, { task_id: taskB });
+        const result = await getDependenciesTest(testDb, { task_id: taskB });
         // Assert
         assert.strictEqual(result.task_id, taskB);
         // B is blocked by A
@@ -495,11 +525,11 @@ describe('get_dependencies - Metadata Only', () => {
         assert.strictEqual(result.blockers[0].description, undefined);
         assert.strictEqual(result.blocking[0].description, undefined);
     });
-    it('should return empty arrays for task with no dependencies', () => {
+    it('should return empty arrays for task with no dependencies', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
+        const task1 = await createTestTask(testDb, 'Task 1');
         // Act
-        const result = getDependenciesTest(testDb, { task_id: task1 });
+        const result = await getDependenciesTest(testDb, { task_id: task1 });
         // Assert
         assert.strictEqual(result.task_id, task1);
         assert.strictEqual(result.blockers.length, 0);
@@ -507,22 +537,23 @@ describe('get_dependencies - Metadata Only', () => {
     });
 });
 describe('get_dependencies - With Details', () => {
-    it('should return full details when include_details=true', () => {
+    it('should return full details when include_details=true', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
-        const task2 = createTestTask(testDb, 'Task 2');
+        const task1 = await createTestTask(testDb, 'Task 1');
+        const task2 = await createTestTask(testDb, 'Task 2');
         // Add description to task1
-        testDb.prepare(`
-      INSERT INTO t_task_details (task_id, description)
-      VALUES (?, ?)
-    `).run(task1, 'This is task 1 description');
-        // Add dependency
-        addDependencyTest(testDb, {
-            blocker_task_id: task1,
-            blocked_task_id: task2
+        const knex = testDb.getKnex();
+        await knex('t_task_details').insert({
+            task_id: task1,
+            description: 'This is task 1 description'
+        });
+        // Add dependency (task2 depends on task1)
+        await addDependencyTest(testDb, {
+            depends_on_task_id: task1,
+            task_id: task2
         });
         // Act
-        const result = getDependenciesTest(testDb, {
+        const result = await getDependenciesTest(testDb, {
             task_id: task2,
             include_details: true
         });
@@ -531,81 +562,81 @@ describe('get_dependencies - With Details', () => {
         assert.strictEqual(result.blockers[0].id, task1);
         assert.strictEqual(result.blockers[0].description, 'This is task 1 description');
     });
-    it('should not include description by default', () => {
+    it('should not include description by default', async () => {
         // Arrange
-        const task1 = createTestTask(testDb, 'Task 1');
-        const task2 = createTestTask(testDb, 'Task 2');
+        const task1 = await createTestTask(testDb, 'Task 1');
+        const task2 = await createTestTask(testDb, 'Task 2');
         // Add description
-        testDb.prepare(`
-      INSERT INTO t_task_details (task_id, description)
-      VALUES (?, ?)
-    `).run(task1, 'This is task 1 description');
-        addDependencyTest(testDb, {
-            blocker_task_id: task1,
-            blocked_task_id: task2
+        const knex = testDb.getKnex();
+        await knex('t_task_details').insert({
+            task_id: task1,
+            description: 'This is task 1 description'
+        });
+        await addDependencyTest(testDb, {
+            depends_on_task_id: task1,
+            task_id: task2
         });
         // Act
-        const result = getDependenciesTest(testDb, { task_id: task2 });
+        const result = await getDependenciesTest(testDb, { task_id: task2 });
         // Assert
         assert.strictEqual(result.blockers[0].description, undefined);
     });
 });
 describe('get_dependencies - Error Handling', () => {
-    it('should throw error for non-existent task', () => {
+    it('should throw error for non-existent task', async () => {
         // Act & Assert
-        assert.throws(() => {
-            getDependenciesTest(testDb, { task_id: 999 });
+        await assert.rejects(async () => {
+            await getDependenciesTest(testDb, { task_id: 999 });
         }, {
             message: /Task with id 999 not found/
         });
     });
 });
 describe('CASCADE Deletion', () => {
-    it('should cascade delete dependencies when task deleted', () => {
+    it('should cascade delete dependencies when task deleted', async () => {
         // Arrange
-        const taskA = createTestTask(testDb, 'Task A');
-        const taskB = createTestTask(testDb, 'Task B');
-        // Add A blocks B
-        addDependencyTest(testDb, {
-            blocker_task_id: taskA,
-            blocked_task_id: taskB
+        const taskA = await createTestTask(testDb, 'Task A');
+        const taskB = await createTestTask(testDb, 'Task B');
+        // Add A blocks B (B depends on A)
+        await addDependencyTest(testDb, {
+            depends_on_task_id: taskA,
+            task_id: taskB
         });
         // Verify dependency exists
-        const beforeDeps = getDependenciesTest(testDb, { task_id: taskB });
+        const beforeDeps = await getDependenciesTest(testDb, { task_id: taskB });
         assert.strictEqual(beforeDeps.blockers.length, 1);
         // Act - Delete task A
-        testDb.prepare('DELETE FROM t_tasks WHERE id = ?').run(taskA);
+        const knex = testDb.getKnex();
+        await knex('t_tasks').where({ id: taskA }).delete();
         // Assert - Dependency should be deleted
-        const depsInDb = testDb.prepare(`
-      SELECT * FROM t_task_dependencies
-      WHERE blocker_task_id = ? OR blocked_task_id = ?
-    `).all(taskA, taskA);
+        const depsInDb = await knex('t_task_dependencies')
+            .where('depends_on_task_id', taskA)
+            .orWhere('task_id', taskA);
         assert.strictEqual(depsInDb.length, 0);
         // Verify B still exists
-        const taskBExists = testDb.prepare('SELECT id FROM t_tasks WHERE id = ?').get(taskB);
+        const taskBExists = await knex('t_tasks').where({ id: taskB }).first();
         assert.ok(taskBExists);
         // Verify B has no dependencies anymore
-        const afterDeps = getDependenciesTest(testDb, { task_id: taskB });
+        const afterDeps = await getDependenciesTest(testDb, { task_id: taskB });
         assert.strictEqual(afterDeps.blockers.length, 0);
     });
-    it('should cascade delete when blocked task is deleted', () => {
+    it('should cascade delete when blocked task is deleted', async () => {
         // Arrange
-        const taskA = createTestTask(testDb, 'Task A');
-        const taskB = createTestTask(testDb, 'Task B');
-        addDependencyTest(testDb, {
-            blocker_task_id: taskA,
-            blocked_task_id: taskB
+        const taskA = await createTestTask(testDb, 'Task A');
+        const taskB = await createTestTask(testDb, 'Task B');
+        await addDependencyTest(testDb, {
+            depends_on_task_id: taskA,
+            task_id: taskB
         });
         // Act - Delete task B
-        testDb.prepare('DELETE FROM t_tasks WHERE id = ?').run(taskB);
+        const knex = testDb.getKnex();
+        await knex('t_tasks').where({ id: taskB }).delete();
         // Assert - Dependency should be deleted
-        const depsInDb = testDb.prepare(`
-      SELECT * FROM t_task_dependencies
-      WHERE blocked_task_id = ?
-    `).all(taskB);
+        const depsInDb = await knex('t_task_dependencies')
+            .where('task_id', taskB);
         assert.strictEqual(depsInDb.length, 0);
         // Verify A still exists with no dependencies
-        const afterDeps = getDependenciesTest(testDb, { task_id: taskA });
+        const afterDeps = await getDependenciesTest(testDb, { task_id: taskA });
         assert.strictEqual(afterDeps.blocking.length, 0);
     });
 });