factory-factory 0.4.1 → 0.4.2

package/dist/src/backend/services/workspace/resources/workspace.accessor.js

@@ -1,20 +1,58 @@
 import { prisma } from '../../../../backend/db.js';
-import { KanbanColumn } from '../../../../shared/core/index.js';
+import { flattenWorkspaceAutoIteration, workspaceAutoIterationAccessor, } from '../../../../backend/services/workspace/resources/workspace-auto-iteration.accessor.js';
+import { flattenWorkspacePR, workspacePrAccessor, } from '../../../../backend/services/workspace/resources/workspace-pr.accessor.js';
+import { flattenWorkspaceRatchet, workspaceRatchetAccessor, } from '../../../../backend/services/workspace/resources/workspace-ratchet.accessor.js';
+import { flattenWorkspaceRunScript, workspaceRunScriptAccessor, } from '../../../../backend/services/workspace/resources/workspace-run-script.accessor.js';
+import { deriveRatchetState, } from '../../../../shared/core/index.js';
 const autoIterationExecutionContextSelect = {
     worktreePath: true,
-    autoIterationSessionId: true,
-};
-const runScriptExecutionStateSelect = {
-    runScriptStatus: true,
-    runScriptPid: true,
-    runScriptPort: true,
-    runScriptStartedAt: true,
+    autoIteration: { select: { sessionId: true } },
 };
 const STALE_PROVISIONING_THRESHOLD_MS = 10 * 60 * 1000;
 const STALE_ARCHIVING_THRESHOLD_MS = 10 * 60 * 1000;
+function prAggregateChanged(current, observation) {
+    const compared = [
+        'prUrl',
+        'prNumber',
+        'prState',
+        'prReviewState',
+        'prCiStatus',
+        'prHasMergeConflict',
+    ];
+    return compared.some((field) => observation[field] !== undefined && current[field] !== observation[field]);
+}
+function flatten(row) {
+    const { ratchet, pr, runScript, autoIteration, ...rest } = row;
+    const ratchetFields = flattenWorkspaceRatchet(ratchet);
+    const prFields = flattenWorkspacePR(pr);
+    return {
+        ...rest,
+        ...ratchetFields,
+        ...prFields,
+        ...flattenWorkspaceRunScript(runScript),
+        ...flattenWorkspaceAutoIteration(autoIteration),
+        ratchetState: deriveRatchetState({
+            ratchetEnabled: ratchetFields.ratchetEnabled,
+            prState: prFields.prState,
+            prCiStatus: prFields.prCiStatus,
+            prHasMergeConflict: prFields.prHasMergeConflict,
+            prReviewState: prFields.prReviewState,
+        }),
+    };
+}
+const sideTables = {
+    ratchet: true,
+    pr: true,
+    runScript: true,
+    autoIteration: true,
+};
+function withProjectAndPR(row) {
+    const { pr, autoIteration, ...rest } = row;
+    return { ...rest, ...flattenWorkspacePR(pr), ...flattenWorkspaceAutoIteration(autoIteration) };
+}
 class WorkspaceAccessor {
-    create(data) {
-        return prisma.workspace.create({
+    async create(data) {
+        const created = await prisma.workspace.create({
             data: {
                 projectId: data.projectId,
                 name: data.name,
@@ -26,26 +64,31 @@ class WorkspaceAccessor {
                 linearIssueIdentifier: data.linearIssueIdentifier,
                 linearIssueUrl: data.linearIssueUrl,
                 isAutoGeneratedBranch: data.isAutoGeneratedBranch ?? false,
-                ratchetEnabled: data.ratchetEnabled,
+                ratchet: { create: { enabled: data.ratchetEnabled } },
+                pr: { create: {} },
+                runScript: { create: {} },
+                autoIteration: { create: { mode: data.mode, config: data.autoIterationConfig } },
                 defaultSessionProvider: data.defaultSessionProvider,
                 ratchetSessionProvider: data.ratchetSessionProvider,
                 creationSource: data.creationSource,
                 creationMetadata: data.creationMetadata,
-                mode: data.mode,
-                autoIterationConfig: data.autoIterationConfig,
                 periodicTaskId: data.periodicTaskId,
                 parentWorkspaceId: data.parentWorkspaceId,
             },
+            include: sideTables,
         });
+        return flatten(created);
     }
-    findById(id) {
-        return prisma.workspace.findUnique({
+    async findById(id) {
+        const row = await prisma.workspace.findUnique({
             where: { id },
             include: {
                 agentSessions: true,
                 terminalSessions: true,
+                ...sideTables,
             },
         });
+        return row ? flatten(row) : null;
     }
     findRawById(id) {
         return prisma.workspace.findUnique({
@@ -80,96 +123,90 @@ class WorkspaceAccessor {
             },
         });
     }
-    findStatusSnapshot(id) {
-        return prisma.workspace.findUnique({
+    async findStatusSnapshot(id) {
+        const row = await prisma.workspace.findUnique({
             where: { id },
             select: {
                 status: true,
-                prUrl: true,
-                prNumber: true,
                 initCompletedAt: true,
+                pr: { select: { url: true, number: true } },
             },
         });
+        if (!row) {
+            return null;
+        }
+        return {
+            status: row.status,
+            initCompletedAt: row.initCompletedAt,
+            prUrl: row.pr?.url ?? null,
+            prNumber: row.pr?.number ?? null,
+        };
     }
-    findPRContext(id) {
-        return prisma.workspace.findUnique({
+    async findPRContext(id) {
+        const row = await prisma.workspace.findUnique({
             where: { id },
-            select: { branchName: true, prUrl: true },
+            select: { branchName: true, pr: { select: { url: true } } },
         });
+        return row ? { branchName: row.branchName, prUrl: row.pr?.url ?? null } : null;
     }
     findRawByIdOrThrow(id) {
         return prisma.workspace.findUniqueOrThrow({
             where: { id },
         });
     }
-    findAutoIterationExecutionContext(id) {
-        return prisma.workspace.findUnique({
+    async findAutoIterationExecutionContext(id) {
+        const workspace = await prisma.workspace.findUnique({
             where: { id },
             select: autoIterationExecutionContextSelect,
         });
+        if (!workspace) {
+            return null;
+        }
+        return {
+            worktreePath: workspace.worktreePath,
+            autoIterationSessionId: workspace.autoIteration?.sessionId ?? null,
+        };
     }
     findRunScriptExecutionState(id) {
-        return prisma.workspace.findUnique({
-            where: { id },
-            select: runScriptExecutionStateSelect,
-        });
+        return workspaceRunScriptAccessor.findExecutionState(id);
     }
     findRunScriptExecutionStateOrThrow(id) {
-        return prisma.workspace.findUniqueOrThrow({
-            where: { id },
-            select: runScriptExecutionStateSelect,
-        });
+        return workspaceRunScriptAccessor.findExecutionStateOrThrow(id);
     }
-    findByProjectId(projectId, filters) {
-        const where = { projectId };
-        if (filters?.status) {
-            where.status = filters.status;
-        }
-        if (filters?.kanbanColumn) {
-            where.cachedKanbanColumn = filters.kanbanColumn;
-        }
+    findByProjectId(projectId) {
         return prisma.workspace.findMany({
-            where,
-            take: filters?.limit,
-            skip: filters?.offset,
+            where: { projectId },
             orderBy: { updatedAt: 'desc' },
         });
     }
-    findByProjectIdWithSessions(projectId, filters) {
-        if (filters?.status && filters?.excludeStatuses?.length) {
-            throw new Error('Cannot specify both status and excludeStatuses filters');
-        }
+    async findByProjectIdWithSessions(projectId, filters) {
         const where = { projectId };
-        if (filters?.status) {
-            where.status = filters.status;
-        }
         if (filters?.excludeStatuses && filters.excludeStatuses.length > 0) {
             where.status = { notIn: filters.excludeStatuses };
         }
-        if (filters?.kanbanColumn) {
-            where.cachedKanbanColumn = filters.kanbanColumn;
-        }
-        return prisma.workspace.findMany({
+        const rows = await prisma.workspace.findMany({
             where,
-            take: filters?.limit,
-            skip: filters?.offset,
             orderBy: { updatedAt: 'desc' },
             include: {
                 agentSessions: true,
                 terminalSessions: true,
+                ...sideTables,
             },
         });
+        return rows.map(flatten);
     }
-    findAllNonArchivedWithSessionsAndProject() {
-        return prisma.workspace.findMany({
+    async findAllNonArchivedWithSessionsAndProject() {
+        const rows = await prisma.workspace.findMany({
             where: { status: { not: 'ARCHIVED' } },
             include: {
                 agentSessions: true,
                 terminalSessions: true,
                 project: true,
+                ...sideTables,
             },
             orderBy: { updatedAt: 'desc' },
         });
+        return rows.map(flatten);
     }
     update(id, data) {
         return prisma.workspace.update({
@@ -177,25 +214,6 @@ class WorkspaceAccessor {
             data,
         });
     }
-    async updateCachedKanbanColumnIfOwnershipMatches(id, expected, data) {
-        const result = await prisma.workspace.updateMany({
-            where: {
-                id,
-                status: expected.status,
-                prUrl: expected.prUrl,
-                prState: expected.prState,
-                prCiStatus: expected.prCiStatus,
-                prUpdatedAt: expected.prUpdatedAt,
-                ratchetEnabled: expected.ratchetEnabled,
-                ratchetState: expected.ratchetState,
-                ratchetDispatchOutcome: expected.ratchetDispatchOutcome,
-                ratchetDispatchRetryCount: expected.ratchetDispatchRetryCount,
-                cachedKanbanColumn: expected.cachedKanbanColumn,
-            },
-            data,
-        });
-        return result.count === 1;
-    }
     transitionWithCas(id, fromStatus, data) {
         return prisma.workspace.updateMany({
             where: { id, status: fromStatus },
@@ -203,69 +221,37 @@ class WorkspaceAccessor {
         });
     }
     casRunScriptStatusUpdate(id, currentStatus, data) {
-        return prisma.workspace.updateMany({
-            where: { id, runScriptStatus: currentStatus },
-            data,
-        });
+        return workspaceRunScriptAccessor.casExecutionUpdate(id, currentStatus, data);
     }
-    async finishAutoIterationIfSessionMatches(id, sessionId, status) {
-        const result = await prisma.workspace.updateMany({
-            where: { id, autoIterationSessionId: sessionId },
-            data: {
-                autoIterationStatus: status,
-                autoIterationSessionId: null,
-            },
+    async registerInitializedWorktree(id, worktree, commands) {
+        await prisma.$transaction(async (transaction) => {
+            await transaction.workspace.update({ where: { id }, data: worktree });
+            await workspaceRunScriptAccessor.writeCommands(id, commands, transaction);
         });
-        return result.count === 1;
     }
-    async clearAutoIterationSessionIfMatches(id, sessionId) {
-        const result = await prisma.workspace.updateMany({
-            where: { id, autoIterationSessionId: sessionId },
-            data: { autoIterationSessionId: null },
-        });
-        return result.count === 1;
+    setRunScriptCommands(id, commands) {
+        return workspaceRunScriptAccessor.writeCommands(id, commands);
     }
-    async resetStaleAutoIterationStatuses() {
-        const stale = await prisma.workspace.findMany({
-            where: { autoIterationStatus: 'RUNNING' },
-            select: { id: true },
-        });
-        if (stale.length === 0) {
-            return [];
-        }
-        await prisma.workspace.updateMany({
-            where: {
-                id: { in: stale.map((w) => w.id) },
-                autoIterationStatus: 'RUNNING',
-            },
-            data: {
-                autoIterationStatus: 'FAILED',
-                autoIterationSessionId: null,
-            },
-        });
-        return stale;
+    setAutoIterationStatus(id, status) {
+        return workspaceAutoIterationAccessor.setStatus(id, status);
     }
-    async resetStaleRunScriptStatuses() {
-        const stale = await prisma.workspace.findMany({
-            where: { runScriptStatus: { in: ['STARTING', 'STOPPING'] } },
-            select: { id: true, runScriptStatus: true },
-        });
-        if (stale.length === 0) {
-            return [];
-        }
-        await prisma.workspace.updateMany({
-            where: {
-                id: { in: stale.map((w) => w.id) },
-                runScriptStatus: { in: ['STARTING', 'STOPPING'] },
-            },
-            data: {
-                runScriptStatus: 'IDLE',
-                runScriptPid: null,
-                runScriptPort: null,
-                runScriptStartedAt: null,
-            },
-        });
-        return stale;
+    setAutoIterationProgress(id, progress) {
+        return workspaceAutoIterationAccessor.setProgress(id, progress);
+    }
+    setAutoIterationSessionId(id, sessionId) {
+        return workspaceAutoIterationAccessor.setSession(id, sessionId);
+    }
+    finishAutoIterationIfSessionMatches(id, sessionId, status) {
+        return workspaceAutoIterationAccessor.finishIfSessionMatches(id, sessionId, status);
+    }
+    clearAutoIterationSessionIfMatches(id, sessionId) {
+        return workspaceAutoIterationAccessor.clearSessionIfMatches(id, sessionId);
+    }
+    resetStaleAutoIterationStatuses() {
+        return workspaceAutoIterationAccessor.resetStaleRunningStatuses();
+    }
+    resetStaleRunScriptStatuses() {
+        return workspaceRunScriptAccessor.resetStaleTransientStatuses();
     }
     startProvisioningRetryIfAllowed(id, maxRetries) {
         return prisma.workspace.updateMany({
@@ -276,8 +262,6 @@ class WorkspaceAccessor {
             },
             data: {
                 status: 'PROVISIONING',
-                cachedKanbanColumn: KanbanColumn.WORKING,
-                stateComputedAt: new Date(),
                 initRetryCount: { increment: 1 },
                 initStartedAt: new Date(),
                 initErrorMessage: null,
@@ -294,8 +278,6 @@ class WorkspaceAccessor {
             },
             data: {
                 status: 'PROVISIONING',
-                cachedKanbanColumn: KanbanColumn.WORKING,
-                stateComputedAt: new Date(),
                 initRetryCount: { increment: 1 },
                 initStartedAt: new Date(),
                 initErrorMessage: null,
@@ -312,8 +294,6 @@ class WorkspaceAccessor {
             },
             data: {
                 status: 'NEW',
-                cachedKanbanColumn: KanbanColumn.WORKING,
-                stateComputedAt: new Date(),
                 initRetryCount: { increment: 1 },
                 initStartedAt: null,
                 initCompletedAt: null,
@@ -327,9 +307,9 @@ class WorkspaceAccessor {
             where: { id },
         });
     }
-    findNeedingWorktree() {
+    async findNeedingWorktree() {
         const staleThreshold = new Date(Date.now() - STALE_PROVISIONING_THRESHOLD_MS);
-        return prisma.workspace.findMany({
+        const rows = await prisma.workspace.findMany({
             where: {
                 OR: [
                     { status: 'NEW' },
@@ -339,128 +319,29 @@ class WorkspaceAccessor {
                     },
                 ],
             },
-            include: {
-                project: true,
-            },
+            include: { project: true, pr: true, autoIteration: true },
             orderBy: { createdAt: 'asc' },
         });
+        return rows.map(withProjectAndPR);
     }
-    findStaleArchivingWithProject() {
+    async findStaleArchivingWithProject() {
         const staleThreshold = new Date(Date.now() - STALE_ARCHIVING_THRESHOLD_MS);
-        return prisma.workspace.findMany({
+        const rows = await prisma.workspace.findMany({
             where: {
                 status: 'ARCHIVING',
                 updatedAt: { lt: staleThreshold },
             },
-            include: {
-                project: true,
-            },
+            include: { project: true, pr: true, autoIteration: true },
             orderBy: { updatedAt: 'asc' },
         });
+        return rows.map(withProjectAndPR);
     }
-    findByIdWithProject(id) {
-        return prisma.workspace.findUnique({
+    async findByIdWithProject(id) {
+        const row = await prisma.workspace.findUnique({
             where: { id },
-            include: {
-                project: true,
-            },
-        });
-    }
-    findNeedingPRSync(staleThresholdMinutes = 5) {
-        const staleThreshold = new Date(Date.now() - staleThresholdMinutes * 60 * 1000);
-        return prisma.workspace.findMany({
-            where: {
-                status: 'READY',
-                prUrl: { not: null },
-                OR: [{ prUpdatedAt: null }, { prUpdatedAt: { lt: staleThreshold } }],
-            },
-            include: {
-                project: true,
-            },
-            orderBy: { prUpdatedAt: 'asc' },
+            include: { project: true, pr: true, autoIteration: true },
         });
-    }
-    findNeedingPRDiscovery(limit, dueAt = new Date()) {
-        return prisma.workspace.findMany({
-            where: {
-                status: 'READY',
-                prUrl: null,
-                branchName: { not: null },
-                project: {
-                    githubOwner: { not: null },
-                    githubRepo: { not: null },
-                },
-                OR: [{ prDiscoveryNextCheckAt: null }, { prDiscoveryNextCheckAt: { lte: dueAt } }],
-            },
-            include: {
-                project: true,
-            },
-            orderBy: [{ prDiscoveryNextCheckAt: 'asc' }, { updatedAt: 'desc' }],
-            take: limit,
-        });
-    }
-    async claimPRDiscoveryAttempt(id, attempt) {
-        const result = await prisma.workspace.updateMany({
-            where: {
-                id,
-                status: 'READY',
-                prUrl: null,
-                branchName: attempt.branchName,
-                updatedAt: attempt.expectedUpdatedAt,
-                prDiscoveryRetryCount: attempt.expectedRetryCount,
-                prDiscoveryNextCheckAt: attempt.expectedNextCheckAt,
-            },
-            data: {
-                prDiscoveryLastCheckedAt: attempt.checkedAt,
-                prDiscoveryRetryCount: { increment: 1 },
-                prDiscoveryNextCheckAt: attempt.nextCheckAt,
-            },
-        });
-        return result.count > 0;
-    }
-    async attachDiscoveredPRIfClaimMatches(id, prUrl, claim, prUpdatedAt) {
-        const result = await prisma.workspace.updateMany({
-            where: {
-                id,
-                status: 'READY',
-                prUrl: null,
-                branchName: claim.branchName,
-                prDiscoveryLastCheckedAt: claim.checkedAt,
-                prDiscoveryRetryCount: claim.retryCount,
-                prDiscoveryNextCheckAt: claim.nextCheckAt,
-            },
-            data: {
-                prUrl,
-                prUpdatedAt,
-            },
-        });
-        return result.count > 0;
-    }
-    async updatePRSnapshotIfUrlMatches(id, prUrl, snapshot, prUpdatedAt) {
-        const result = await prisma.workspace.updateMany({
-            where: { id, prUrl },
-            data: {
-                ...snapshot,
-                prUpdatedAt,
-            },
-        });
-        return result.count > 0;
-    }
-    async resetPRDiscoveryBackoff(id) {
-        const result = await prisma.workspace.updateMany({
-            where: {
-                id,
-                status: 'READY',
-                prUrl: null,
-                branchName: { not: null },
-            },
-            data: {
-                prDiscoveryLastCheckedAt: null,
-                prDiscoveryRetryCount: 0,
-                prDiscoveryNextCheckAt: null,
-            },
-        });
-        return result.count > 0;
+        return row ? withProjectAndPR(row) : null;
     }
     async markHasHadSessions(id) {
         await prisma.workspace.updateMany({
@@ -468,124 +349,55 @@ class WorkspaceAccessor {
             data: { hasHadSessions: true },
         });
     }
-    async recordRatchetSessionEnd(workspaceId, sessionId, outcome) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetActiveSessionId: sessionId },
-            data: { ratchetActiveSessionId: null, ratchetDispatchOutcome: outcome },
-        });
-        return result.count > 0;
-    }
     applyPrSnapshotWithDispatchReset(workspaceId, observation) {
         return this.applyPrAggregateUpdateWithDispatchReset(workspaceId, observation);
     }
-    applyCIObservationWithDispatchReset(workspaceId, observation) {
-        return this.applyPrAggregateUpdateWithDispatchReset(workspaceId, observation);
-    }
-    async applyPrAggregateUpdateWithDispatchReset(workspaceId, observation) {
-        const snapshotData = {
-            ...(observation.prUrl !== undefined ? { prUrl: observation.prUrl } : {}),
-            ...(observation.prNumber !== undefined ? { prNumber: observation.prNumber } : {}),
-            ...(observation.prState !== undefined ? { prState: observation.prState } : {}),
-            ...(observation.prReviewState !== undefined
-                ? { prReviewState: observation.prReviewState }
-                : {}),
-            ...(observation.prCiStatus !== undefined ? { prCiStatus: observation.prCiStatus } : {}),
-            ...(observation.prCiFailedAt !== undefined ? { prCiFailedAt: observation.prCiFailedAt } : {}),
-            prUpdatedAt: observation.prUpdatedAt,
-            ...(observation.branchName !== undefined ? { branchName: observation.branchName } : {}),
-        };
-        return await prisma.$transaction(async (transaction) => {
-            const current = await transaction.workspace.findUniqueOrThrow({
-                where: { id: workspaceId },
-                select: {
-                    prUrl: true,
-                    prNumber: true,
-                    prState: true,
-                    prReviewState: true,
-                    prCiStatus: true,
-                    prUpdatedAt: true,
-                    ratchetActiveSessionId: true,
-                    ratchetLastCiRunId: true,
-                    ratchetDispatchOutcome: true,
-                    ratchetDispatchRetryCount: true,
-                },
-            });
-            const aggregateChanged = (observation.prNumber !== undefined && current.prNumber !== observation.prNumber) ||
-                (observation.prState !== undefined && current.prState !== observation.prState) ||
-                (observation.prReviewState !== undefined &&
-                    current.prReviewState !== observation.prReviewState) ||
-                (observation.prCiStatus !== undefined && current.prCiStatus !== observation.prCiStatus) ||
-                (observation.prUrl !== undefined && current.prUrl !== observation.prUrl);
-            const shouldReset = aggregateChanged &&
-                (current.ratchetDispatchOutcome === 'COMPLETED' ||
-                    current.ratchetDispatchOutcome === 'DIED');
-            const aggregateGuard = {
-                prUrl: current.prUrl,
-                prNumber: current.prNumber,
-                prState: current.prState,
-                prReviewState: current.prReviewState,
-                prCiStatus: current.prCiStatus,
-                prUpdatedAt: current.prUpdatedAt,
-            };
-            if (shouldReset) {
-                const reset = await transaction.workspace.updateMany({
-                    where: {
-                        id: workspaceId,
-                        ...aggregateGuard,
-                        ratchetActiveSessionId: current.ratchetActiveSessionId,
-                        ratchetLastCiRunId: current.ratchetLastCiRunId,
-                        ratchetDispatchOutcome: current.ratchetDispatchOutcome,
-                        ratchetDispatchRetryCount: current.ratchetDispatchRetryCount,
-                    },
-                    data: {
-                        ...snapshotData,
-                        ratchetDispatchOutcome: null,
-                        ratchetDispatchRetryCount: 0,
-                    },
-                });
-                if (reset.count > 0) {
-                    return { applied: true, dispatchReset: true };
-                }
-            }
-            const fallback = await transaction.workspace.updateMany({
-                where: { id: workspaceId, ...aggregateGuard },
-                data: snapshotData,
-            });
-            return { applied: fallback.count > 0, dispatchReset: false };
-        });
-    }
-    async recordRatchetDispatchIfEnabled(workspaceId, dispatch) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetEnabled: true },
-            data: {
-                ratchetActiveSessionId: dispatch.sessionId,
-                ratchetLastCiRunId: dispatch.snapshotKey,
-                ratchetDispatchOutcome: 'RUNNING',
-                ratchetDispatchRetryCount: dispatch.retryCount,
-            },
-        });
-        return result.count > 0;
+    applyPrObservationWithDispatchReset(workspaceId, observation) {
+        const { expectedPrNumber, ...fields } = observation;
+        return this.applyPrAggregateUpdateWithDispatchReset(workspaceId, fields, expectedPrNumber);
     }
-    async adoptRatchetActiveSessionIfEnabled(workspaceId, sessionId) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetEnabled: true },
-            data: { ratchetActiveSessionId: sessionId, ratchetDispatchOutcome: 'RUNNING' },
+    async recordPrSnapshotWithBranchName(workspaceId, branchName, prFields) {
+        await prisma.$transaction(async (transaction) => {
+            await workspacePrAccessor.writeInTransaction(transaction, workspaceId, prFields);
+            await transaction.workspace.update({ where: { id: workspaceId }, data: { branchName } });
         });
-        return result.count > 0;
     }
-    async transitionRatchetStateIfEnabled(workspaceId, fromState, data) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetEnabled: true, ratchetState: fromState },
-            data,
+    async setBranchNameAndClearDiscoverySchedule(workspaceId, branchName) {
+        await prisma.$transaction(async (transaction) => {
+            await transaction.workspace.update({
+                where: { id: workspaceId },
+                data: { branchName, isAutoGeneratedBranch: false },
+            });
+            await workspacePrAccessor.clearDiscoverySchedule(transaction, workspaceId);
         });
-        return result.count > 0;
     }
-    async settleRatchetIdleWhileDisabled(workspaceId, fromState) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetEnabled: false, ratchetState: fromState },
-            data: { ratchetState: 'IDLE', ratchetLastCheckedAt: new Date() },
+    async applyPrAggregateUpdateWithDispatchReset(workspaceId, observation, expectedPrNumber) {
+        const { branchName, ...prFields } = observation;
+        return await prisma.$transaction(async (transaction) => {
+            const current = await workspacePrAccessor.readAggregate(transaction, workspaceId);
+            if (!current) {
+                return { applied: false, dispatchReset: false };
+            }
+            if (expectedPrNumber !== undefined &&
+                current.prNumber !== null &&
+                current.prNumber !== expectedPrNumber) {
+                return { applied: false, dispatchReset: false };
+            }
+            const dispatch = await workspaceRatchetAccessor.readDispatchGuard(transaction, workspaceId);
+            const shouldReset = prAggregateChanged(current, observation) &&
+                (dispatch?.dispatchOutcome === 'COMPLETED' || dispatch?.dispatchOutcome === 'DIED');
+            const applied = await workspacePrAccessor.applyAggregateIfUnchanged(transaction, workspaceId, current, prFields);
+            if (!applied) {
+                return { applied: false, dispatchReset: false };
+            }
+            if (branchName !== undefined) {
+                await transaction.workspace.update({ where: { id: workspaceId }, data: { branchName } });
+            }
+            const dispatchReset = shouldReset && dispatch
+                ? await workspaceRatchetAccessor.resetSettledDispatch(transaction, workspaceId, dispatch)
+                : false;
+            return { applied: true, dispatchReset };
         });
-        return result.count > 0;
     }
     async appendInitOutput(id, output, maxSize = 50 * 1024) {
         const truncationMarker = '[...truncated...]\n';
@@ -644,71 +456,17 @@ class WorkspaceAccessor {
             },
         });
     }
-    findByIdsWithProject(ids) {
+    async findByIdsWithProject(ids) {
         if (ids.length === 0) {
-            return Promise.resolve([]);
+            return [];
         }
-        return prisma.workspace.findMany({
+        const rows = await prisma.workspace.findMany({
             where: {
                 id: { in: ids },
             },
-            include: {
-                project: true,
-            },
-        });
-    }
-    findWithPRsForRatchet() {
-        return prisma.workspace.findMany({
-            where: {
-                status: 'READY',
-                prUrl: { not: null },
-                ratchetEnabled: true,
-                ratchetState: { not: 'MERGED' },
-                prState: { not: 'CLOSED' },
-            },
-            select: {
-                id: true,
-                prUrl: true,
-                prNumber: true,
-                prState: true,
-                prCiStatus: true,
-                defaultSessionProvider: true,
-                ratchetSessionProvider: true,
-                ratchetEnabled: true,
-                ratchetState: true,
-                ratchetActiveSessionId: true,
-                ratchetLastCiRunId: true,
-                ratchetDispatchOutcome: true,
-                ratchetDispatchRetryCount: true,
-                prReviewLastCheckedAt: true,
-            },
-            orderBy: { ratchetLastCheckedAt: 'asc' },
-        });
-    }
-    findForRatchetById(id) {
-        return prisma.workspace.findFirst({
-            where: {
-                id,
-                status: 'READY',
-                prUrl: { not: null },
-            },
-            select: {
-                id: true,
-                prUrl: true,
-                prNumber: true,
-                prState: true,
-                prCiStatus: true,
-                defaultSessionProvider: true,
-                ratchetSessionProvider: true,
-                ratchetEnabled: true,
-                ratchetState: true,
-                ratchetActiveSessionId: true,
-                ratchetLastCiRunId: true,
-                ratchetDispatchOutcome: true,
-                ratchetDispatchRetryCount: true,
-                prReviewLastCheckedAt: true,
-            },
+            include: { project: true, pr: true, autoIteration: true },
         });
+        return rows.map(withProjectAndPR);
     }
     findChildrenByParentId(parentId) {
         return prisma.workspace.findMany({
@@ -716,18 +474,20 @@ class WorkspaceAccessor {
             orderBy: { createdAt: 'asc' },
         });
     }
-    findChildrenWithStatus(parentId) {
-        return prisma.workspace.findMany({
+    async findChildrenWithStatus(parentId) {
+        const rows = await prisma.workspace.findMany({
             where: { parentWorkspaceId: parentId, status: { not: 'ARCHIVED' } },
-            include: { agentSessions: true, project: true },
+            include: { agentSessions: true, project: true, ...sideTables },
             orderBy: { createdAt: 'asc' },
         });
+        return rows.map(flatten);
     }
-    findParentWorkspace(childId) {
-        return prisma.workspace.findFirst({
+    async findParentWorkspace(childId) {
+        const row = await prisma.workspace.findFirst({
             where: { childWorkspaces: { some: { id: childId } } },
-            include: { project: true },
+            include: { project: true, pr: true, autoIteration: true },
         });
+        return row ? withProjectAndPR(row) : null;
     }
 }
 export const workspaceAccessor = new WorkspaceAccessor();