factory-factory 0.4.0 → 0.4.2

package/dist/src/backend/services/run-script/service/run-script-state-machine.service.test.js

@@ -5,7 +5,7 @@ const mockUpdateMany = vi.fn();
 const mockFindUniqueOrThrow = vi.fn();
 vi.mock('@/backend/db', () => ({
     prisma: {
-        workspace: {
+        workspaceRunScript: {
             findUnique: (...args) => mockFindUnique(...args),
             findMany: (...args) => mockFindMany(...args),
             updateMany: (...args) => mockUpdateMany(...args),
@@ -81,30 +81,30 @@ describe('RunScriptStateMachineService', () => {
     });
     describe('transition', () => {
         it('should transition from IDLE to STARTING', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'IDLE' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'STARTING' };
+            const workspace = { workspaceId: 'ws-1', status: 'IDLE' };
+            const updatedWorkspace = { ...workspace, status: 'STARTING' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
             const result = await runScriptStateMachine.transition('ws-1', 'STARTING');
             expect(result.runScriptStatus).toBe('STARTING');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'IDLE' },
+                where: { workspaceId: 'ws-1', status: 'IDLE' },
                 data: expect.objectContaining({
-                    runScriptStatus: 'STARTING',
-                    runScriptPid: null,
-                    runScriptPort: null,
-                    runScriptStartedAt: null,
+                    status: 'STARTING',
+                    pid: null,
+                    port: null,
+                    startedAt: null,
                 }),
             });
         });
         it('should transition from STARTING to RUNNING with pid and port', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'STARTING' };
+            const workspace = { workspaceId: 'ws-1', status: 'STARTING' };
             const updatedWorkspace = {
                 ...workspace,
-                runScriptStatus: 'RUNNING',
-                runScriptPid: 12_345,
-                runScriptPort: 3000,
+                status: 'RUNNING',
+                pid: 12_345,
+                port: 3000,
             };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
@@ -115,47 +115,47 @@ describe('RunScriptStateMachineService', () => {
             });
             expect(result.runScriptStatus).toBe('RUNNING');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'STARTING' },
+                where: { workspaceId: 'ws-1', status: 'STARTING' },
                 data: expect.objectContaining({
-                    runScriptStatus: 'RUNNING',
-                    runScriptPid: 12_345,
-                    runScriptPort: 3000,
-                    runScriptStartedAt: expect.any(Date),
+                    status: 'RUNNING',
+                    pid: 12_345,
+                    port: 3000,
+                    startedAt: expect.any(Date),
                 }),
             });
         });
         it('should transition from RUNNING to STOPPING', async () => {
             const workspace = {
-                id: 'ws-1',
-                runScriptStatus: 'RUNNING',
-                runScriptPid: 12_345,
-                runScriptPort: 3000,
+                workspaceId: 'ws-1',
+                status: 'RUNNING',
+                pid: 12_345,
+                port: 3000,
             };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'STOPPING' };
+            const updatedWorkspace = { ...workspace, status: 'STOPPING' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
             const result = await runScriptStateMachine.transition('ws-1', 'STOPPING');
             expect(result.runScriptStatus).toBe('STOPPING');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'RUNNING' },
+                where: { workspaceId: 'ws-1', status: 'RUNNING' },
                 data: {
-                    runScriptStatus: 'STOPPING',
+                    status: 'STOPPING',
                 },
             });
         });
         it('should transition from STOPPING to IDLE and clear process details', async () => {
             const workspace = {
-                id: 'ws-1',
-                runScriptStatus: 'STOPPING',
-                runScriptPid: 12_345,
-                runScriptPort: 3000,
+                workspaceId: 'ws-1',
+                status: 'STOPPING',
+                pid: 12_345,
+                port: 3000,
             };
             const updatedWorkspace = {
                 ...workspace,
-                runScriptStatus: 'IDLE',
-                runScriptPid: null,
-                runScriptPort: null,
+                status: 'IDLE',
+                pid: null,
+                port: null,
             };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
@@ -163,53 +163,53 @@ describe('RunScriptStateMachineService', () => {
             const result = await runScriptStateMachine.transition('ws-1', 'IDLE');
             expect(result.runScriptStatus).toBe('IDLE');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'STOPPING' },
+                where: { workspaceId: 'ws-1', status: 'STOPPING' },
                 data: expect.objectContaining({
-                    runScriptStatus: 'IDLE',
-                    runScriptPid: null,
-                    runScriptPort: null,
-                    runScriptStartedAt: null,
+                    status: 'IDLE',
+                    pid: null,
+                    port: null,
+                    startedAt: null,
                 }),
             });
         });
         it('should transition from RUNNING to COMPLETED', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'RUNNING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'COMPLETED' };
+            const workspace = { workspaceId: 'ws-1', status: 'RUNNING' };
+            const updatedWorkspace = { ...workspace, status: 'COMPLETED' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
             const result = await runScriptStateMachine.transition('ws-1', 'COMPLETED');
             expect(result.runScriptStatus).toBe('COMPLETED');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'RUNNING' },
+                where: { workspaceId: 'ws-1', status: 'RUNNING' },
                 data: expect.objectContaining({
-                    runScriptStatus: 'COMPLETED',
-                    runScriptPid: null,
-                    runScriptPort: null,
-                    runScriptStartedAt: null,
+                    status: 'COMPLETED',
+                    pid: null,
+                    port: null,
+                    startedAt: null,
                 }),
             });
         });
         it('should transition from RUNNING to FAILED', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'RUNNING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'FAILED' };
+            const workspace = { workspaceId: 'ws-1', status: 'RUNNING' };
+            const updatedWorkspace = { ...workspace, status: 'FAILED' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
             const result = await runScriptStateMachine.transition('ws-1', 'FAILED');
             expect(result.runScriptStatus).toBe('FAILED');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'RUNNING' },
+                where: { workspaceId: 'ws-1', status: 'RUNNING' },
                 data: expect.objectContaining({
-                    runScriptStatus: 'FAILED',
-                    runScriptPid: null,
-                    runScriptPort: null,
-                    runScriptStartedAt: null,
+                    status: 'FAILED',
+                    pid: null,
+                    port: null,
+                    startedAt: null,
                 }),
             });
         });
         it('should throw RunScriptStateMachineError for invalid transition', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'IDLE' };
+            const workspace = { workspaceId: 'ws-1', status: 'IDLE' };
             mockFindUnique.mockResolvedValue(workspace);
             await expect(runScriptStateMachine.transition('ws-1', 'RUNNING')).rejects.toThrow(RunScriptStateMachineError);
             await expect(runScriptStateMachine.transition('ws-1', 'RUNNING')).rejects.toThrow(/Invalid run script state transition: IDLE \u2192 RUNNING/);
@@ -219,18 +219,18 @@ describe('RunScriptStateMachineService', () => {
             await expect(runScriptStateMachine.transition('non-existent', 'STARTING')).rejects.toThrow('Workspace not found: non-existent');
         });
         it('should throw on concurrent state change (CAS failure)', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'IDLE' };
+            const workspace = { workspaceId: 'ws-1', status: 'IDLE' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 0 });
             mockFindUnique.mockResolvedValueOnce(workspace);
-            mockFindUnique.mockResolvedValueOnce({ ...workspace, runScriptStatus: 'STARTING' });
+            mockFindUnique.mockResolvedValueOnce({ ...workspace, status: 'STARTING' });
             await expect(runScriptStateMachine.transition('ws-1', 'STARTING')).rejects.toThrow(/Concurrent state change detected/);
         });
     });
     describe('start', () => {
         it('should transition from IDLE to STARTING', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'IDLE' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'STARTING' };
+            const workspace = { workspaceId: 'ws-1', status: 'IDLE' };
+            const updatedWorkspace = { ...workspace, status: 'STARTING' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -239,17 +239,17 @@ describe('RunScriptStateMachineService', () => {
         });
         it('should return null when already RUNNING', async () => {
             const workspace = {
-                id: 'ws-1',
-                runScriptStatus: 'RUNNING',
-                runScriptPid: process.pid,
+                workspaceId: 'ws-1',
+                status: 'RUNNING',
+                pid: process.pid,
             };
             mockFindUnique.mockResolvedValue(workspace);
             const result = await runScriptStateMachine.start('ws-1');
             expect(result).toBeNull();
         });
         it('should transition from COMPLETED to STARTING (restart)', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'COMPLETED' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'STARTING' };
+            const workspace = { workspaceId: 'ws-1', status: 'COMPLETED' };
+            const updatedWorkspace = { ...workspace, status: 'STARTING' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -257,8 +257,8 @@ describe('RunScriptStateMachineService', () => {
             expect(result?.runScriptStatus).toBe('STARTING');
         });
         it('should transition from FAILED to STARTING (restart)', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'FAILED' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'STARTING' };
+            const workspace = { workspaceId: 'ws-1', status: 'FAILED' };
+            const updatedWorkspace = { ...workspace, status: 'STARTING' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -268,28 +268,28 @@ describe('RunScriptStateMachineService', () => {
     });
     describe('markRunning', () => {
         it('should transition from STARTING to RUNNING with pid', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'STARTING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'RUNNING', runScriptPid: 12_345 };
+            const workspace = { workspaceId: 'ws-1', status: 'STARTING' };
+            const updatedWorkspace = { ...workspace, status: 'RUNNING', pid: 12_345 };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
             const result = await runScriptStateMachine.markRunning('ws-1', { pid: 12_345 });
             expect(result.runScriptStatus).toBe('RUNNING');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'STARTING' },
+                where: { workspaceId: 'ws-1', status: 'STARTING' },
                 data: expect.objectContaining({
-                    runScriptPid: 12_345,
-                    runScriptStartedAt: expect.any(Date),
+                    pid: 12_345,
+                    startedAt: expect.any(Date),
                 }),
             });
         });
         it('should transition from STARTING to RUNNING with pid and port', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'STARTING' };
+            const workspace = { workspaceId: 'ws-1', status: 'STARTING' };
             const updatedWorkspace = {
                 ...workspace,
-                runScriptStatus: 'RUNNING',
-                runScriptPid: 12_345,
-                runScriptPort: 3000,
+                status: 'RUNNING',
+                pid: 12_345,
+                port: 3000,
             };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
@@ -297,19 +297,19 @@ describe('RunScriptStateMachineService', () => {
             const result = await runScriptStateMachine.markRunning('ws-1', { pid: 12_345, port: 3000 });
             expect(result.runScriptStatus).toBe('RUNNING');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'STARTING' },
+                where: { workspaceId: 'ws-1', status: 'STARTING' },
                 data: expect.objectContaining({
-                    runScriptPid: 12_345,
-                    runScriptPort: 3000,
-                    runScriptStartedAt: expect.any(Date),
+                    pid: 12_345,
+                    port: 3000,
+                    startedAt: expect.any(Date),
                 }),
             });
         });
     });
     describe('beginStopping', () => {
         it('should transition from RUNNING to STOPPING', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'RUNNING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'STOPPING' };
+            const workspace = { workspaceId: 'ws-1', status: 'RUNNING' };
+            const updatedWorkspace = { ...workspace, status: 'STOPPING' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -319,8 +319,8 @@ describe('RunScriptStateMachineService', () => {
     });
     describe('completeStopping', () => {
         it('should transition from STOPPING to IDLE', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'STOPPING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'IDLE' };
+            const workspace = { workspaceId: 'ws-1', status: 'STOPPING' };
+            const updatedWorkspace = { ...workspace, status: 'IDLE' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -330,8 +330,8 @@ describe('RunScriptStateMachineService', () => {
     });
     describe('markCompleted', () => {
         it('should transition from RUNNING to COMPLETED', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'RUNNING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'COMPLETED' };
+            const workspace = { workspaceId: 'ws-1', status: 'RUNNING' };
+            const updatedWorkspace = { ...workspace, status: 'COMPLETED' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -339,8 +339,8 @@ describe('RunScriptStateMachineService', () => {
             expect(result.runScriptStatus).toBe('COMPLETED');
         });
         it('should transition from STARTING to COMPLETED (fast process exit)', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'STARTING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'COMPLETED' };
+            const workspace = { workspaceId: 'ws-1', status: 'STARTING' };
+            const updatedWorkspace = { ...workspace, status: 'COMPLETED' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -350,8 +350,8 @@ describe('RunScriptStateMachineService', () => {
     });
     describe('markFailed', () => {
         it('should transition from STARTING to FAILED (spawn error)', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'STARTING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'FAILED' };
+            const workspace = { workspaceId: 'ws-1', status: 'STARTING' };
+            const updatedWorkspace = { ...workspace, status: 'FAILED' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -359,8 +359,8 @@ describe('RunScriptStateMachineService', () => {
             expect(result.runScriptStatus).toBe('FAILED');
         });
         it('should transition from RUNNING to FAILED (process error)', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'RUNNING' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'FAILED' };
+            const workspace = { workspaceId: 'ws-1', status: 'RUNNING' };
+            const updatedWorkspace = { ...workspace, status: 'FAILED' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -370,8 +370,8 @@ describe('RunScriptStateMachineService', () => {
     });
     describe('reset', () => {
         it('should transition from COMPLETED to IDLE', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'COMPLETED' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'IDLE' };
+            const workspace = { workspaceId: 'ws-1', status: 'COMPLETED' };
+            const updatedWorkspace = { ...workspace, status: 'IDLE' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -379,8 +379,8 @@ describe('RunScriptStateMachineService', () => {
             expect(result.runScriptStatus).toBe('IDLE');
         });
         it('should transition from FAILED to IDLE', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'FAILED' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'IDLE' };
+            const workspace = { workspaceId: 'ws-1', status: 'FAILED' };
+            const updatedWorkspace = { ...workspace, status: 'IDLE' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -391,9 +391,9 @@ describe('RunScriptStateMachineService', () => {
     describe('verifyRunning', () => {
         it('should return RUNNING when process exists', async () => {
             const workspace = {
-                id: 'ws-1',
-                runScriptStatus: 'RUNNING',
-                runScriptPid: process.pid,
+                workspaceId: 'ws-1',
+                status: 'RUNNING',
+                pid: process.pid,
             };
             mockFindUnique.mockResolvedValue(workspace);
             const result = await runScriptStateMachine.verifyRunning('ws-1');
@@ -401,28 +401,28 @@ describe('RunScriptStateMachineService', () => {
         });
         it('should mark as FAILED when process does not exist', async () => {
             const workspace = {
-                id: 'ws-1',
-                runScriptStatus: 'RUNNING',
-                runScriptPid: 999_999,
+                workspaceId: 'ws-1',
+                status: 'RUNNING',
+                pid: 999_999,
             };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'FAILED' };
+            const updatedWorkspace = { ...workspace, status: 'FAILED' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
             const result = await runScriptStateMachine.verifyRunning('ws-1');
             expect(result).toBe('FAILED');
             expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: { id: 'ws-1', runScriptStatus: 'RUNNING' },
+                where: { workspaceId: 'ws-1', status: 'RUNNING' },
                 data: expect.objectContaining({
-                    runScriptStatus: 'FAILED',
+                    status: 'FAILED',
                 }),
             });
         });
         it('should return current status when not RUNNING', async () => {
             const workspace = {
-                id: 'ws-1',
-                runScriptStatus: 'IDLE',
-                runScriptPid: null,
+                workspaceId: 'ws-1',
+                status: 'IDLE',
+                pid: null,
             };
             mockFindUnique.mockResolvedValue(workspace);
             const result = await runScriptStateMachine.verifyRunning('ws-1');
@@ -454,27 +454,27 @@ describe('RunScriptStateMachineService', () => {
     describe('verifyRunning edge cases', () => {
         it('should handle race condition when markFailed throws', async () => {
             const workspace = {
-                id: 'ws-1',
-                runScriptStatus: 'RUNNING',
-                runScriptPid: 999_999,
+                workspaceId: 'ws-1',
+                status: 'RUNNING',
+                pid: 999_999,
             };
             const refreshedWorkspace = {
                 ...workspace,
-                runScriptStatus: 'IDLE',
+                status: 'IDLE',
             };
             mockFindUnique.mockResolvedValueOnce(workspace);
             mockFindUnique.mockResolvedValueOnce(workspace);
             mockUpdateMany.mockResolvedValueOnce({ count: 0 });
-            mockFindUnique.mockResolvedValueOnce({ ...workspace, runScriptStatus: 'IDLE' });
+            mockFindUnique.mockResolvedValueOnce({ ...workspace, status: 'IDLE' });
             mockFindUnique.mockResolvedValueOnce(refreshedWorkspace);
             const result = await runScriptStateMachine.verifyRunning('ws-1');
             expect(result).toBe('IDLE');
         });
         it('should return RUNNING status when pid is null (no process to verify)', async () => {
             const workspace = {
-                id: 'ws-1',
-                runScriptStatus: 'RUNNING',
-                runScriptPid: null,
+                workspaceId: 'ws-1',
+                status: 'RUNNING',
+                pid: null,
             };
             mockFindUnique.mockResolvedValue(workspace);
             const result = await runScriptStateMachine.verifyRunning('ws-1');
@@ -483,9 +483,9 @@ describe('RunScriptStateMachineService', () => {
         it('should return status directly for non-RUNNING states', async () => {
             for (const status of ['IDLE', 'STARTING', 'STOPPING', 'COMPLETED', 'FAILED']) {
                 mockFindUnique.mockResolvedValueOnce({
-                    id: 'ws-1',
-                    runScriptStatus: status,
-                    runScriptPid: null,
+                    workspaceId: 'ws-1',
+                    status,
+                    pid: null,
                 });
                 const result = await runScriptStateMachine.verifyRunning('ws-1');
                 expect(result).toBe(status);
@@ -497,8 +497,8 @@ describe('RunScriptStateMachineService', () => {
             runScriptStateMachine.removeAllListeners();
         });
         it('emits run_script_status_changed after successful transition', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'IDLE' };
-            const updatedWorkspace = { ...workspace, runScriptStatus: 'STARTING' };
+            const workspace = { workspaceId: 'ws-1', status: 'IDLE' };
+            const updatedWorkspace = { ...workspace, status: 'STARTING' };
             mockFindUnique.mockResolvedValue(workspace);
             mockUpdateMany.mockResolvedValue({ count: 1 });
             mockFindUniqueOrThrow.mockResolvedValue(updatedWorkspace);
@@ -515,10 +515,10 @@ describe('RunScriptStateMachineService', () => {
             });
         });
         it('does NOT emit on CAS failure', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'IDLE' };
+            const workspace = { workspaceId: 'ws-1', status: 'IDLE' };
             mockFindUnique
                 .mockResolvedValueOnce(workspace)
-                .mockResolvedValueOnce({ ...workspace, runScriptStatus: 'STARTING' });
+                .mockResolvedValueOnce({ ...workspace, status: 'STARTING' });
             mockUpdateMany.mockResolvedValue({ count: 0 });
             const events = [];
             runScriptStateMachine.on(RUN_SCRIPT_STATUS_CHANGED, (event) => {
@@ -528,7 +528,7 @@ describe('RunScriptStateMachineService', () => {
             expect(events).toHaveLength(0);
         });
         it('does NOT emit on invalid transition', async () => {
-            const workspace = { id: 'ws-1', runScriptStatus: 'IDLE' };
+            const workspace = { workspaceId: 'ws-1', status: 'IDLE' };
             mockFindUnique.mockResolvedValue(workspace);
             const events = [];
             runScriptStateMachine.on(RUN_SCRIPT_STATUS_CHANGED, (event) => {
@@ -542,13 +542,13 @@ describe('RunScriptStateMachineService', () => {
             runScriptStateMachine.on(RUN_SCRIPT_STATUS_CHANGED, (event) => {
                 events.push(event);
             });
-            mockFindUnique.mockResolvedValueOnce({ id: 'ws-1', runScriptStatus: 'IDLE' });
+            mockFindUnique.mockResolvedValueOnce({ workspaceId: 'ws-1', status: 'IDLE' });
             mockUpdateMany.mockResolvedValueOnce({ count: 1 });
-            mockFindUniqueOrThrow.mockResolvedValueOnce({ id: 'ws-1', runScriptStatus: 'STARTING' });
+            mockFindUniqueOrThrow.mockResolvedValueOnce({ workspaceId: 'ws-1', status: 'STARTING' });
             await runScriptStateMachine.transition('ws-1', 'STARTING');
-            mockFindUnique.mockResolvedValueOnce({ id: 'ws-1', runScriptStatus: 'STARTING' });
+            mockFindUnique.mockResolvedValueOnce({ workspaceId: 'ws-1', status: 'STARTING' });
             mockUpdateMany.mockResolvedValueOnce({ count: 1 });
-            mockFindUniqueOrThrow.mockResolvedValueOnce({ id: 'ws-1', runScriptStatus: 'RUNNING' });
+            mockFindUniqueOrThrow.mockResolvedValueOnce({ workspaceId: 'ws-1', status: 'RUNNING' });
             await runScriptStateMachine.transition('ws-1', 'RUNNING');
             expect(events).toHaveLength(2);
             expect(events[0]).toEqual({
@@ -571,8 +571,8 @@ describe('RunScriptStateMachineService', () => {
         });
         it('resets stale workspaces and emits status-changed events', async () => {
             const stale = [
-                { id: 'ws-1', runScriptStatus: 'STARTING' },
-                { id: 'ws-2', runScriptStatus: 'STOPPING' },
+                { workspaceId: 'ws-1', status: 'STARTING' },
+                { workspaceId: 'ws-2', status: 'STOPPING' },
             ];
             mockFindMany.mockResolvedValue(stale);
             mockUpdateMany.mockResolvedValue({ count: 2 });