sqlew 3.9.1 → 4.0.0

package/dist/tests/docker/native/task-operations.test.js

@@ -15,7 +15,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 import { createHash } from 'crypto';
-import { runTestsOnAllDatabases, getLayerId, getAgentId, getTagId } from './test-harness.js';
+import { runTestsOnAllDatabases, getLayerId, getTagId } from './test-harness.js';
 // ============================================================================
 // Hash Helper
 // ============================================================================
@@ -32,7 +32,7 @@ function hashConstraintText(text) {
  * Get task status ID by status name
  */
 async function getStatusId(db, statusName) {
-    const status = await db('m_task_statuses').where({ name: statusName }).first();
+    const status = await db('v4_task_statuses').where({ name: statusName }).first();
     assert.ok(status, `Status "${statusName}" should exist`);
     return status.id;
 }
@@ -42,20 +42,17 @@ async function getStatusId(db, statusName) {
 async function insertTask(db, data) {
     const statusId = await getStatusId(db, data.status || 'todo');
     const layerId = data.layer ? await getLayerId(db, data.layer) : await getLayerId(db, 'business');
-    const agentId = await getAgentId(db, data.assigned_agent || 'system');
     const timestamp = Math.floor(Date.now() / 1000);
     const insertData = {
         title: data.title,
         status_id: statusId,
         priority: data.priority || 2,
         layer_id: layerId,
-        assigned_agent_id: agentId,
-        created_by_agent_id: agentId,
         project_id: 1,
         created_ts: timestamp,
         updated_ts: timestamp,
     };
-    const result = await db('t_tasks').insert(insertData);
+    const result = await db('v4_tasks').insert(insertData);
     // Get the inserted ID (different return format across databases)
     let taskId;
     if (Array.isArray(result) && result.length > 0) {
@@ -66,7 +63,7 @@ async function insertTask(db, data) {
     }
     else {
         // Fallback: query the last inserted task
-        const task = await db('t_tasks')
+        const task = await db('v4_tasks')
             .where({ title: data.title, project_id: 1 })
             .orderBy('id', 'desc')
             .first();
@@ -74,7 +71,7 @@ async function insertTask(db, data) {
     }
     // Insert task details if description provided
     if (data.description) {
-        await db('t_task_details').insert({
+        await db('v4_task_details').insert({
             task_id: taskId,
             description: data.description,
         });
@@ -85,10 +82,10 @@ async function insertTask(db, data) {
  * Assert task has expected status
  */
 async function assertTaskHasStatus(db, taskId, expectedStatus) {
-    const task = await db('t_tasks')
-        .join('m_task_statuses', 't_tasks.status_id', 'm_task_statuses.id')
-        .where({ 't_tasks.id': taskId })
-        .select('m_task_statuses.name as status')
+    const task = await db('v4_tasks')
+        .join('v4_task_statuses', 'v4_tasks.status_id', 'v4_task_statuses.id')
+        .where({ 'v4_tasks.id': taskId })
+        .select('v4_task_statuses.name as status')
         .first();
     assert.ok(task, `Task ${taskId} should exist`);
     assert.strictEqual(task.status, expectedStatus, `Task ${taskId} status should be ${expectedStatus}`);
@@ -110,7 +107,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             });
             assert.ok(taskId, 'Should return task ID');
             // Verify task exists
-            const task = await db('t_tasks').where({ id: taskId, project_id: 1 }).first();
+            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
             assert.strictEqual(task.title, 'Implement authentication');
             assert.strictEqual(task.priority, 3);
             await assertTaskHasStatus(db, taskId, 'todo');
@@ -122,16 +119,15 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 description: 'This is a detailed description',
                 priority: 4,
                 layer: 'infrastructure',
-                assigned_agent: 'backend-specialist',
             });
             // Verify core task data
-            const task = await db('t_tasks').where({ id: taskId, project_id: 1 }).first();
+            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
             assert.strictEqual(task.title, 'Complex task with all fields');
             assert.strictEqual(task.priority, 4);
             const layerId = await getLayerId(db, 'infrastructure');
             assert.strictEqual(task.layer_id, layerId);
             // Verify task details
-            const details = await db('t_task_details').where({ task_id: taskId }).first();
+            const details = await db('v4_task_details').where({ task_id: taskId }).first();
             assert.ok(details, 'Task details should exist');
             assert.strictEqual(details.description, 'This is a detailed description');
         });
@@ -142,7 +138,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 priority: 2,
             });
             // Update title and priority
-            await db('t_tasks')
+            await db('v4_tasks')
                 .where({ id: taskId, project_id: 1 })
                 .update({
                 title: 'Updated title',
@@ -150,7 +146,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 updated_ts: Math.floor(Date.now() / 1000),
             });
             // Verify update
-            const task = await db('t_tasks').where({ id: taskId, project_id: 1 }).first();
+            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
             assert.strictEqual(task.title, 'Updated title');
             assert.strictEqual(task.priority, 4);
         });
@@ -160,9 +156,9 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 title: 'Task to delete',
             });
             // Delete task
-            await db('t_tasks').where({ id: taskId, project_id: 1 }).delete();
+            await db('v4_tasks').where({ id: taskId, project_id: 1 }).delete();
             // Verify deletion
-            const task = await db('t_tasks').where({ id: taskId, project_id: 1 }).first();
+            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
             assert.strictEqual(task, undefined, 'Task should be deleted');
         });
     });
@@ -172,14 +168,12 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
     describe('Foreign Key Constraints', () => {
         it('should enforce FK constraint on status_id', async () => {
             const db = getDb();
-            const insertPromise = db('t_tasks').insert({
+            const insertPromise = db('v4_tasks').insert({
                 title: 'Invalid status task',
                 status_id: 99999, // Non-existent status
                 priority: 2,
                 project_id: 1,
                 layer_id: 1,
-                assigned_agent_id: 1,
-                created_by_agent_id: 1,
                 created_ts: Math.floor(Date.now() / 1000),
                 updated_ts: Math.floor(Date.now() / 1000),
             });
@@ -190,33 +184,12 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
         it('should enforce FK constraint on layer_id', async () => {
             const db = getDb();
             const statusId = await getStatusId(db, 'todo');
-            const insertPromise = db('t_tasks').insert({
+            const insertPromise = db('v4_tasks').insert({
                 title: 'Invalid layer task',
                 status_id: statusId,
                 priority: 2,
                 project_id: 1,
                 layer_id: 99999, // Non-existent layer
-                assigned_agent_id: 1,
-                created_by_agent_id: 1,
-                created_ts: Math.floor(Date.now() / 1000),
-                updated_ts: Math.floor(Date.now() / 1000),
-            });
-            await assert.rejects(insertPromise, {
-                message: /foreign key constraint|violates foreign key|Cannot add or update a child row/i,
-            });
-        });
-        it('should enforce FK constraint on assigned_agent_id', async () => {
-            const db = getDb();
-            const statusId = await getStatusId(db, 'todo');
-            const layerId = await getLayerId(db, 'business');
-            const insertPromise = db('t_tasks').insert({
-                title: 'Invalid agent task',
-                status_id: statusId,
-                priority: 2,
-                project_id: 1,
-                layer_id: layerId,
-                assigned_agent_id: 99999, // Non-existent agent
-                created_by_agent_id: 1,
                 created_ts: Math.floor(Date.now() / 1000),
                 updated_ts: Math.floor(Date.now() / 1000),
             });
@@ -235,7 +208,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             await assertTaskHasStatus(db, taskId, 'todo');
             // Move to in_progress
             const inProgressId = await getStatusId(db, 'in_progress');
-            await db('t_tasks')
+            await db('v4_tasks')
                 .where({ id: taskId })
                 .update({
                 status_id: inProgressId,
@@ -250,7 +223,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             // Move to done
             const doneId = await getStatusId(db, 'done');
             const completedTs = Math.floor(Date.now() / 1000);
-            await db('t_tasks')
+            await db('v4_tasks')
                 .where({ id: taskId })
                 .update({
                 status_id: doneId,
@@ -259,14 +232,14 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             });
             await assertTaskHasStatus(db, taskId, 'done');
             // Verify completed_ts was set
-            const task = await db('t_tasks').where({ id: taskId }).first();
+            const task = await db('v4_tasks').where({ id: taskId }).first();
             assert.ok(task.completed_ts, 'completed_ts should be set');
         });
         it('should transition to blocked status', async () => {
             const db = getDb();
             const taskId = await insertTask(db, { title: 'Blocked task' });
             const blockedId = await getStatusId(db, 'blocked');
-            await db('t_tasks')
+            await db('v4_tasks')
                 .where({ id: taskId })
                 .update({
                 status_id: blockedId,
@@ -278,7 +251,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const db = getDb();
             const taskId = await insertTask(db, { title: 'Archive task' });
             const archivedId = await getStatusId(db, 'archived');
-            await db('t_tasks')
+            await db('v4_tasks')
                 .where({ id: taskId })
                 .update({
                 status_id: archivedId,
@@ -296,25 +269,25 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const taskId = await insertTask(db, { title: 'Task with files' });
             const timestamp = Math.floor(Date.now() / 1000);
             // First, create file records in m_files
-            const file1Result = await db('m_files').insert({ project_id: 1, path: 'src/auth/login.ts' });
-            const file2Result = await db('m_files').insert({ project_id: 1, path: 'src/auth/types.ts' });
-            const file3Result = await db('m_files').insert({ project_id: 1, path: 'src/auth/old.ts' });
+            const file1Result = await db('v4_files').insert({ project_id: 1, path: 'src/auth/login.ts' });
+            const file2Result = await db('v4_files').insert({ project_id: 1, path: 'src/auth/types.ts' });
+            const file3Result = await db('v4_files').insert({ project_id: 1, path: 'src/auth/old.ts' });
             // Get file IDs
-            const file1 = await db('m_files').where({ path: 'src/auth/login.ts', project_id: 1 }).first();
-            const file2 = await db('m_files').where({ path: 'src/auth/types.ts', project_id: 1 }).first();
-            const file3 = await db('m_files').where({ path: 'src/auth/old.ts', project_id: 1 }).first();
+            const file1 = await db('v4_files').where({ path: 'src/auth/login.ts', project_id: 1 }).first();
+            const file2 = await db('v4_files').where({ path: 'src/auth/types.ts', project_id: 1 }).first();
+            const file3 = await db('v4_files').where({ path: 'src/auth/old.ts', project_id: 1 }).first();
             // Insert file links
-            await db('t_task_file_links').insert([
+            await db('v4_task_file_links').insert([
                 { task_id: taskId, file_id: file1.id, project_id: 1, linked_ts: timestamp },
                 { task_id: taskId, file_id: file2.id, project_id: 1, linked_ts: timestamp },
                 { task_id: taskId, file_id: file3.id, project_id: 1, linked_ts: timestamp },
             ]);
             // Verify file links
-            const fileLinks = await db('t_task_file_links')
-                .join('m_files', 't_task_file_links.file_id', 'm_files.id')
-                .where({ 't_task_file_links.task_id': taskId })
-                .select('t_task_file_links.*', 'm_files.path')
-                .orderBy('m_files.path');
+            const fileLinks = await db('v4_task_file_links')
+                .join('v4_files', 'v4_task_file_links.file_id', 'v4_files.id')
+                .where({ 'v4_task_file_links.task_id': taskId })
+                .select('v4_task_file_links.*', 'v4_files.path')
+                .orderBy('v4_files.path');
             assert.strictEqual(fileLinks.length, 3);
             assert.strictEqual(fileLinks[0].path, 'src/auth/login.ts');
             assert.strictEqual(fileLinks[1].path, 'src/auth/old.ts');
@@ -325,16 +298,16 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const taskId = await insertTask(db, { title: 'Unique file link test' });
             const timestamp = Math.floor(Date.now() / 1000);
             // Create a file record
-            await db('m_files').insert({ project_id: 1, path: 'src/unique-test.ts' });
-            const file = await db('m_files').where({ path: 'src/unique-test.ts', project_id: 1 }).first();
-            await db('t_task_file_links').insert({
+            await db('v4_files').insert({ project_id: 1, path: 'src/unique-test.ts' });
+            const file = await db('v4_files').where({ path: 'src/unique-test.ts', project_id: 1 }).first();
+            await db('v4_task_file_links').insert({
                 task_id: taskId,
                 file_id: file.id,
                 project_id: 1,
                 linked_ts: timestamp,
             });
             // Try to insert duplicate
-            const duplicatePromise = db('t_task_file_links').insert({
+            const duplicatePromise = db('v4_task_file_links').insert({
                 task_id: taskId,
                 file_id: file.id,
                 project_id: 1,
@@ -349,18 +322,18 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const taskId = await insertTask(db, { title: 'Cascade delete file links' });
             const timestamp = Math.floor(Date.now() / 1000);
             // Create a file record
-            await db('m_files').insert({ project_id: 1, path: 'src/cascade-test.ts' });
-            const file = await db('m_files').where({ path: 'src/cascade-test.ts', project_id: 1 }).first();
-            await db('t_task_file_links').insert({
+            await db('v4_files').insert({ project_id: 1, path: 'src/cascade-test.ts' });
+            const file = await db('v4_files').where({ path: 'src/cascade-test.ts', project_id: 1 }).first();
+            await db('v4_task_file_links').insert({
                 task_id: taskId,
                 file_id: file.id,
                 project_id: 1,
                 linked_ts: timestamp,
             });
             // Delete task
-            await db('t_tasks').where({ id: taskId }).delete();
+            await db('v4_tasks').where({ id: taskId }).delete();
             // Verify file links were cascade deleted
-            const fileLinks = await db('t_task_file_links').where({ task_id: taskId });
+            const fileLinks = await db('v4_task_file_links').where({ task_id: taskId });
             assert.strictEqual(fileLinks.length, 0, 'File links should be cascade deleted');
         });
     });
@@ -375,17 +348,17 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const apiTagId = await getTagId(db, 'api');
             const securityTagId = await getTagId(db, 'security');
             const perfTagId = await getTagId(db, 'performance');
-            // Insert tag associations (t_task_tags has no project_id)
-            await db('t_task_tags').insert([
-                { task_id: taskId, tag_id: apiTagId },
-                { task_id: taskId, tag_id: securityTagId },
-                { task_id: taskId, tag_id: perfTagId },
+            // Insert tag associations (v4_task_tags requires project_id)
+            await db('v4_task_tags').insert([
+                { task_id: taskId, tag_id: apiTagId, project_id: 1 },
+                { task_id: taskId, tag_id: securityTagId, project_id: 1 },
+                { task_id: taskId, tag_id: perfTagId, project_id: 1 },
             ]);
             // Verify tags
-            const tags = await db('t_task_tags')
-                .join('m_tags', 't_task_tags.tag_id', 'm_tags.id')
-                .where({ 't_task_tags.task_id': taskId })
-                .select('m_tags.name as tag_name');
+            const tags = await db('v4_task_tags as tt')
+                .join('v4_tags as t', 'tt.tag_id', 't.id')
+                .where({ 'tt.task_id': taskId })
+                .select('t.name as tag_name');
             assert.strictEqual(tags.length, 3);
             const tagNames = tags.map(t => t.tag_name);
             assert.ok(tagNames.includes('api'));
@@ -396,14 +369,15 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const db = getDb();
             const taskId = await insertTask(db, { title: 'Task with tags for cascade' });
             const tagId = await getTagId(db, 'test');
-            await db('t_task_tags').insert({
+            await db('v4_task_tags').insert({
                 task_id: taskId,
                 tag_id: tagId,
+                project_id: 1,
             });
             // Delete task
-            await db('t_tasks').where({ id: taskId }).delete();
+            await db('v4_tasks').where({ id: taskId }).delete();
             // Verify tags were cascade deleted
-            const tags = await db('t_task_tags').where({ task_id: taskId });
+            const tags = await db('v4_task_tags').where({ task_id: taskId });
             assert.strictEqual(tags.length, 0, 'Tags should be cascade deleted');
         });
     });
@@ -416,13 +390,14 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const blockerTaskId = await insertTask(db, { title: 'Blocker task' });
             const blockedTaskId = await insertTask(db, { title: 'Blocked task' });
             // Add dependency: blocker blocks blocked
-            await db('t_task_dependencies').insert({
+            await db('v4_task_dependencies').insert({
                 blocker_task_id: blockerTaskId,
                 blocked_task_id: blockedTaskId,
+                project_id: 1,
                 created_ts: Math.floor(Date.now() / 1000),
             });
             // Verify dependency exists
-            const dependency = await db('t_task_dependencies')
+            const dependency = await db('v4_task_dependencies')
                 .where({ blocker_task_id: blockerTaskId, blocked_task_id: blockedTaskId })
                 .first();
             assert.ok(dependency, 'Dependency should exist');
@@ -431,9 +406,10 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const db = getDb();
             const taskId = await insertTask(db, { title: 'Self-blocking task' });
             // Try to create self-dependency
-            const selfDepPromise = db('t_task_dependencies').insert({
+            const selfDepPromise = db('v4_task_dependencies').insert({
                 blocker_task_id: taskId,
                 blocked_task_id: taskId, // Same task
+                project_id: 1,
                 created_ts: Math.floor(Date.now() / 1000),
             });
             // Should fail (either via trigger or application-level check)
@@ -444,7 +420,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                     await selfDepPromise;
                     // If insert succeeds, check if there's a trigger that prevents it
                     // This is database-specific behavior
-                    const dep = await db('t_task_dependencies')
+                    const dep = await db('v4_task_dependencies')
                         .where({ blocker_task_id: taskId, blocked_task_id: taskId })
                         .first();
                     // If dependency was inserted, we need to check if the application
@@ -483,9 +459,10 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const taskA = await insertTask(db, { title: 'Task A' });
             const taskB = await insertTask(db, { title: 'Task B' });
             // Create A blocks B
-            await db('t_task_dependencies').insert({
+            await db('v4_task_dependencies').insert({
                 blocker_task_id: taskA,
                 blocked_task_id: taskB,
+                project_id: 1,
                 created_ts: Math.floor(Date.now() / 1000),
             });
             // Try to create B blocks A (circular)
@@ -493,9 +470,10 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             // application-level logic or recursive triggers.
             // The schema may allow this at database level.
             // This test documents expected behavior.
-            const circularPromise = db('t_task_dependencies').insert({
+            const circularPromise = db('v4_task_dependencies').insert({
                 blocker_task_id: taskB,
                 blocked_task_id: taskA,
+                project_id: 1,
                 created_ts: Math.floor(Date.now() / 1000),
             });
             // For now, we expect application-level validation to prevent this
@@ -503,7 +481,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             try {
                 await circularPromise;
                 // If it succeeds, verify both dependencies exist
-                const deps = await db('t_task_dependencies')
+                const deps = await db('v4_task_dependencies')
                     .whereIn('blocker_task_id', [taskA, taskB])
                     .whereIn('blocked_task_id', [taskA, taskB]);
                 // Note: Schema allows this, but application should prevent it
@@ -526,17 +504,18 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const db = getDb();
             const blockerTaskId = await insertTask(db, { title: 'Blocker for removal' });
             const blockedTaskId = await insertTask(db, { title: 'Blocked for removal' });
-            await db('t_task_dependencies').insert({
+            await db('v4_task_dependencies').insert({
                 blocker_task_id: blockerTaskId,
                 blocked_task_id: blockedTaskId,
+                project_id: 1,
                 created_ts: Math.floor(Date.now() / 1000),
             });
             // Remove dependency
-            await db('t_task_dependencies')
+            await db('v4_task_dependencies')
                 .where({ blocker_task_id: blockerTaskId, blocked_task_id: blockedTaskId })
                 .delete();
             // Verify removal
-            const dependency = await db('t_task_dependencies')
+            const dependency = await db('v4_task_dependencies')
                 .where({ blocker_task_id: blockerTaskId, blocked_task_id: blockedTaskId })
                 .first();
             assert.strictEqual(dependency, undefined, 'Dependency should be removed');
@@ -545,15 +524,16 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const db = getDb();
             const blockerTaskId = await insertTask(db, { title: 'Blocker for cascade' });
             const blockedTaskId = await insertTask(db, { title: 'Blocked for cascade' });
-            await db('t_task_dependencies').insert({
+            await db('v4_task_dependencies').insert({
                 blocker_task_id: blockerTaskId,
                 blocked_task_id: blockedTaskId,
+                project_id: 1,
                 created_ts: Math.floor(Date.now() / 1000),
             });
             // Delete blocker task
-            await db('t_tasks').where({ id: blockerTaskId }).delete();
+            await db('v4_tasks').where({ id: blockerTaskId }).delete();
             // Verify dependencies were cascade deleted
-            const dependencies = await db('t_task_dependencies')
+            const dependencies = await db('v4_task_dependencies')
                 .where({ blocker_task_id: blockerTaskId })
                 .orWhere({ blocked_task_id: blockerTaskId });
             assert.strictEqual(dependencies.length, 0, 'Dependencies should be cascade deleted');
@@ -564,20 +544,22 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const blocked1Id = await insertTask(db, { title: 'Blocked 1' });
             const blocked2Id = await insertTask(db, { title: 'Blocked 2' });
             // Blocker blocks both blocked tasks
-            await db('t_task_dependencies').insert([
+            await db('v4_task_dependencies').insert([
                 {
                     blocker_task_id: blockerTaskId,
                     blocked_task_id: blocked1Id,
+                    project_id: 1,
                     created_ts: Math.floor(Date.now() / 1000),
                 },
                 {
                     blocker_task_id: blockerTaskId,
                     blocked_task_id: blocked2Id,
+                    project_id: 1,
                     created_ts: Math.floor(Date.now() / 1000),
                 },
             ]);
             // Query what blocker is blocking
-            const blocking = await db('t_task_dependencies')
+            const blocking = await db('v4_task_dependencies')
                 .where({ blocker_task_id: blockerTaskId })
                 .select('blocked_task_id');
             assert.strictEqual(blocking.length, 2);
@@ -591,20 +573,22 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const blocker1Id = await insertTask(db, { title: 'Blocker 1' });
             const blocker2Id = await insertTask(db, { title: 'Blocker 2' });
             // Blocked is blocked by both blockers
-            await db('t_task_dependencies').insert([
+            await db('v4_task_dependencies').insert([
                 {
                     blocker_task_id: blocker1Id,
                     blocked_task_id: blockedTaskId,
+                    project_id: 1,
                     created_ts: Math.floor(Date.now() / 1000),
                 },
                 {
                     blocker_task_id: blocker2Id,
                     blocked_task_id: blockedTaskId,
+                    project_id: 1,
                     created_ts: Math.floor(Date.now() / 1000),
                 },
             ]);
             // Query what is blocking this task
-            const blockers = await db('t_task_dependencies')
+            const blockers = await db('v4_task_dependencies')
                 .where({ blocked_task_id: blockedTaskId })
                 .select('blocker_task_id');
             assert.strictEqual(blockers.length, 2);
@@ -622,27 +606,25 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const taskId = await insertTask(db, { title: 'Task implementing decision' });
             const timestamp = Math.floor(Date.now() / 1000);
             // Create a decision
-            const agentId = await getAgentId(db);
             const layerId = await getLayerId(db, 'business');
             // m_context_keys has no project_id column
-            await db('m_context_keys').insert({
+            await db('v4_context_keys').insert({
                 key: 'test/link-decision',
             });
-            const contextKey = await db('m_context_keys')
+            const contextKey = await db('v4_context_keys')
                 .where({ key: 'test/link-decision' })
                 .first();
-            await db('t_decisions').insert({
+            await db('v4_decisions').insert({
                 key_id: contextKey.id,
                 project_id: 1,
                 value: 'test value',
                 version: '1.0.0',
                 ts: timestamp,
-                agent_id: agentId,
                 layer_id: layerId,
                 status: 1, // 1=active (integer enum, not string)
             });
             // Link task to decision (using decision_key_id, not decision_id)
-            await db('t_task_decision_links').insert({
+            await db('v4_task_decision_links').insert({
                 task_id: taskId,
                 decision_key_id: contextKey.id,
                 project_id: 1,
@@ -650,7 +632,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 linked_ts: timestamp,
             });
             // Verify link
-            const link = await db('t_task_decision_links')
+            const link = await db('v4_task_decision_links')
                 .where({ task_id: taskId, decision_key_id: contextKey.id })
                 .first();
             assert.ok(link, 'Link should exist');
@@ -661,24 +643,22 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const taskId = await insertTask(db, { title: 'Task for cascade link delete' });
             const timestamp = Math.floor(Date.now() / 1000);
             // Create decision and link (simplified)
-            const agentId = await getAgentId(db);
             const layerId = await getLayerId(db, 'business');
             // m_context_keys has no project_id column
-            await db('m_context_keys').insert({ key: 'test/cascade-link' });
-            const contextKey = await db('m_context_keys')
-                .where({ key: 'test/cascade-link' })
+            await db('v4_context_keys').insert({ key_name: 'test/cascade-link' });
+            const contextKey = await db('v4_context_keys')
+                .where({ key_name: 'test/cascade-link' })
                 .first();
-            await db('t_decisions').insert({
+            await db('v4_decisions').insert({
                 key_id: contextKey.id,
                 project_id: 1,
                 value: 'test',
                 version: '1.0.0',
                 ts: timestamp,
-                agent_id: agentId,
                 layer_id: layerId,
                 status: 1, // 1=active (integer enum)
             });
-            await db('t_task_decision_links').insert({
+            await db('v4_task_decision_links').insert({
                 task_id: taskId,
                 decision_key_id: contextKey.id,
                 project_id: 1,
@@ -686,9 +666,9 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 linked_ts: timestamp,
             });
             // Delete task
-            await db('t_tasks').where({ id: taskId }).delete();
+            await db('v4_tasks').where({ id: taskId }).delete();
             // Verify links were cascade deleted
-            const links = await db('t_task_decision_links').where({ task_id: taskId });
+            const links = await db('v4_task_decision_links').where({ task_id: taskId });
             assert.strictEqual(links.length, 0, 'Task-decision links should be cascade deleted');
         });
     });
@@ -700,25 +680,23 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const db = getDb();
             const taskId = await insertTask(db, { title: 'Task with constraint' });
             // Create a constraint
-            const agentId = await getAgentId(db);
             const layerId = await getLayerId(db, 'business');
             // Get constraint category
-            const category = await db('m_constraint_categories')
+            const category = await db('v4_constraint_categories')
                 .where({ name: 'architecture' })
                 .first();
             const constraintText = 'Test constraint for linking';
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintText,
                 constraint_text_hash: hashConstraintText(constraintText),
                 category_id: category.id,
                 priority: 2,
                 project_id: 1,
                 layer_id: layerId,
-                agent_id: agentId,
                 ts: Math.floor(Date.now() / 1000),
                 active: 1,
             });
-            const constraint = await db('t_constraints')
+            const constraint = await db('v4_constraints')
                 .where({ constraint_text: constraintText, project_id: 1 })
                 .first();
             // Link task to constraint
@@ -736,24 +714,22 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const db = getDb();
             const taskId = await insertTask(db, { title: 'Task for constraint cascade' });
             // Create constraint and link (simplified)
-            const agentId = await getAgentId(db);
             const layerId = await getLayerId(db, 'business');
-            const category = await db('m_constraint_categories')
+            const category = await db('v4_constraint_categories')
                 .where({ name: 'architecture' })
                 .first();
             const constraintText = 'Cascade test constraint';
-            await db('t_constraints').insert({
+            await db('v4_constraints').insert({
                 constraint_text: constraintText,
                 constraint_text_hash: hashConstraintText(constraintText),
                 category_id: category.id,
                 priority: 2,
                 project_id: 1,
                 layer_id: layerId,
-                agent_id: agentId,
                 ts: Math.floor(Date.now() / 1000),
                 active: 1,
             });
-            const constraint = await db('t_constraints')
+            const constraint = await db('v4_constraints')
                 .where({ constraint_text: constraintText, project_id: 1 })
                 .first();
             await db('t_task_constraint_links').insert({
@@ -761,7 +737,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 constraint_id: constraint.id,
             });
             // Delete task
-            await db('t_tasks').where({ id: taskId }).delete();
+            await db('v4_tasks').where({ id: taskId }).delete();
             // Verify links were cascade deleted
             const links = await db('t_task_constraint_links').where({ task_id: taskId });
             assert.strictEqual(links.length, 0, 'Task-constraint links should be cascade deleted');
@@ -778,7 +754,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 title: longTitle,
                 priority: 2,
             });
-            const task = await db('t_tasks').where({ id: taskId, project_id: 1 }).first();
+            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
             assert.strictEqual(task.title, longTitle);
         });
         it('should handle special characters in descriptions', async () => {
@@ -788,7 +764,7 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 title: 'Special chars test',
                 description: specialDesc,
             });
-            const details = await db('t_task_details').where({ task_id: taskId }).first();
+            const details = await db('v4_task_details').where({ task_id: taskId }).first();
             assert.strictEqual(details.description, specialDesc);
         });
         it('should handle unicode in task fields', async () => {
@@ -797,24 +773,22 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
             const taskId = await insertTask(db, {
                 title: unicodeTitle,
             });
-            const task = await db('t_tasks').where({ id: taskId, project_id: 1 }).first();
+            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
             assert.strictEqual(task.title, unicodeTitle);
         });
         it('should handle NULL optional fields', async () => {
             const db = getDb();
             const statusId = await getStatusId(db, 'todo');
             const layerId = await getLayerId(db, 'business');
-            const agentId = await getAgentId(db);
-            // Insert with NULL assigned_agent_id
+            // Insert with NULL optional fields (completed_ts is nullable)
             const timestamp = Math.floor(Date.now() / 1000);
-            const result = await db('t_tasks').insert({
-                title: 'Task with NULL agent',
+            const result = await db('v4_tasks').insert({
+                title: 'Task with NULL completed_ts',
                 status_id: statusId,
                 priority: 2,
                 project_id: 1,
                 layer_id: layerId,
-                assigned_agent_id: null, // NULL is allowed
-                created_by_agent_id: agentId,
+                completed_ts: null, // NULL is allowed
                 created_ts: timestamp,
                 updated_ts: timestamp,
             });
@@ -823,13 +797,13 @@ runTestsOnAllDatabases('Task Operations', (getDb, dbType) => {
                 taskId = result[0];
             }
             else {
-                const task = await db('t_tasks')
-                    .where({ title: 'Task with NULL agent', project_id: 1 })
+                const task = await db('v4_tasks')
+                    .where({ title: 'Task with NULL completed_ts', project_id: 1 })
                     .first();
                 taskId = task.id;
             }
-            const task = await db('t_tasks').where({ id: taskId, project_id: 1 }).first();
-            assert.strictEqual(task.assigned_agent_id, null);
+            const task = await db('v4_tasks').where({ id: taskId, project_id: 1 }).first();
+            assert.strictEqual(task.completed_ts, null);
         });
     });
 });