fix: reduce Convex write conflicts ~125 → <10 per session

Serialize Linear sync (Promise.all → for...of), skip-if-unchanged guard
on syncStatusFromLinear, merge double-patch in dispatches:fail, stagger
cron intervals (5/6/7/8/9m) to reduce overlap.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: sonpiaz

convex/crons.ts

@@ -36,21 +36,23 @@ crons.cron(
   {}
 );
 
-// AGT-215: Alert System — Check for stuck agents every 5 minutes
+// AGT-215: Alert System — Check for stuck agents every 7 minutes
 // Triggers alerts when agents are stuck on a task for >30 minutes
+// Staggered from sync-linear (5m) to reduce write conflicts
 crons.interval(
   "check-stuck-agents",
-  { minutes: 5 },
+  { minutes: 7 },
   internal.alerts.checkStuckAgents,
   {}
 );
 
 // AGT-216: Auto-Recovery — Self-Healing Agent Restart & Retry
 // Checks for crashed agents (heartbeat timeout) and auto-restarts with backoff
 // Circuit breaker stops after 3 consecutive failures
+// Staggered to 6 min to avoid overlap with sync-linear (5m) and stuck-agents (7m)
 crons.interval(
   "auto-recovery-check",
-  { minutes: 5 },
+  { minutes: 6 },
   internal.recovery.runRecoveryCheck,
   {}
 );
@@ -66,11 +68,12 @@ crons.interval(
   {}
 );
 
-// AGT-247: Event Bus — Cleanup expired events every 5 minutes
+// AGT-247: Event Bus — Cleanup expired events every 9 minutes
 // Removes events older than 5 minutes that were never delivered
+// Staggered to reduce cron overlap
 crons.interval(
   "cleanup-expired-events",
-  { minutes: 5 },
+  { minutes: 9 },
   internal.agentEvents.cleanupExpiredEvents,
   {}
 );
@@ -93,11 +96,12 @@ crons.interval(
   {}
 );
 
-// CORE-209 + AGT-337: The Loop — SLA Monitor every 5 minutes
+// CORE-209 + AGT-337: The Loop — SLA Monitor every 8 minutes
 // Detects AND auto-escalates: reply >15min → DM MAX, action >2h → critical MAX, report >24h → broken + CEO dispatch
+// Staggered from sync-linear (5m) to reduce write conflicts
 crons.interval(
   "loop-sla-monitor",
-  { minutes: 5 },
+  { minutes: 8 },
   internal.loopMonitor.checkSLABreaches,
   {}
 );

convex/dispatches.ts

@@ -116,19 +116,19 @@ export const fail = mutation({
     const currentRetry = dispatch.retryCount ?? 0;
     const maxRetries = dispatch.maxRetries ?? MAX_RETRIES;
 
-    await ctx.db.patch(dispatchId, {
-      status: "failed",
-      completedAt: Date.now(),
-      error,
-      retryCount: currentRetry,
-    });
-
     // AGT-308: Auto-retry with exponential backoff
     if (currentRetry < maxRetries) {
       const backoffMs = RETRY_BACKOFF_MS[Math.min(currentRetry, RETRY_BACKOFF_MS.length - 1)];
       const nextRetryAt = Date.now() + backoffMs;
 
-      await ctx.db.patch(dispatchId, { nextRetryAt });
+      // Single patch with all fields to avoid write conflicts
+      await ctx.db.patch(dispatchId, {
+        status: "failed",
+        completedAt: Date.now(),
+        error,
+        retryCount: currentRetry,
+        nextRetryAt,
+      });
 
       await ctx.scheduler.runAfter(backoffMs, internal.dispatches.retryFailedDispatch, {
         originalDispatchId: dispatchId,
@@ -138,7 +138,13 @@ export const fail = mutation({
         `[AutoRetry] Dispatch ${dispatchId} failed (attempt ${currentRetry + 1}/${maxRetries}). Retrying in ${backoffMs / 60000}m.`
       );
     } else {
-      // Max retries exhausted — escalate to MAX
+      // Max retries exhausted — single patch, then escalate to MAX
+      await ctx.db.patch(dispatchId, {
+        status: "failed",
+        completedAt: Date.now(),
+        error,
+        retryCount: currentRetry,
+      });
       await ctx.scheduler.runAfter(0, internal.dispatches.escalateFailedDispatch, {
         dispatchId,
       });

convex/linearSync.ts

@@ -206,40 +206,41 @@ export const syncAll = internalAction({
         return undefined;
       }
 
-      // Upsert each task
-      const results = await Promise.all(
-        linearIssues.map(async (issue) => {
-          // Try to match assignee by name
-          let assigneeId: Id<"agents"> | undefined = undefined;
-          if (issue.assigneeName) {
-            const matchedAgent = agents.find(
-              (a: { name: string; _id: Id<"agents"> }) => a.name.toLowerCase() === issue.assigneeName?.toLowerCase()
-            );
-            assigneeId = matchedAgent?._id;
-          }
+      // Upsert each task sequentially to avoid write conflicts on tasks table
+      // (Promise.all caused ~80 OCC conflicts per sync cycle)
+      const results: Array<{ created: boolean }> = [];
+      for (const issue of linearIssues) {
+        // Try to match assignee by name
+        let assigneeId: Id<"agents"> | undefined = undefined;
+        if (issue.assigneeName) {
+          const matchedAgent = agents.find(
+            (a: { name: string; _id: Id<"agents"> }) => a.name.toLowerCase() === issue.assigneeName?.toLowerCase()
+          );
+          assigneeId = matchedAgent?._id;
+        }
 
-          // AGT-142: Parse agent from description first, fallback to "max" (PM owns unassigned)
-          const parsedAgent = parseAgentFromDescription(issue.description);
-          const taskAgentName = parsedAgent ?? "max";
-
-          // AGT-175: Use taskAgentName for activity attribution (not hardcoded "max")
-          return await ctx.runMutation(api.tasks.upsertByLinearId, {
-            agentName: taskAgentName,
-            taskAgentName,
-            projectId: evoxProject._id,
-            linearId: issue.linearId,
-            linearIdentifier: issue.linearIdentifier,
-            linearUrl: issue.linearUrl,
-            title: issue.title,
-            description: issue.description,
-            status: issue.status,
-            priority: issue.priority,
-            assignee: assigneeId,
-            createdAt: issue.createdAt,
-            updatedAt: issue.updatedAt,
-          });
-        })
-      );
+        // AGT-142: Parse agent from description first, fallback to "max" (PM owns unassigned)
+        const parsedAgent = parseAgentFromDescription(issue.description);
+        const taskAgentName = parsedAgent ?? "max";
+
+        // AGT-175: Use taskAgentName for activity attribution (not hardcoded "max")
+        const result = await ctx.runMutation(api.tasks.upsertByLinearId, {
+          agentName: taskAgentName,
+          taskAgentName,
+          projectId: evoxProject._id,
+          linearId: issue.linearId,
+          linearIdentifier: issue.linearIdentifier,
+          linearUrl: issue.linearUrl,
+          title: issue.title,
+          description: issue.description,
+          status: issue.status,
+          priority: issue.priority,
+          assignee: assigneeId,
+          createdAt: issue.createdAt,
+          updatedAt: issue.updatedAt,
+        });
+        results.push(result);
+      }
 
       const created = results.filter((r: { created: boolean }) => r.created).length;
       const updated = results.filter((r: { created: boolean }) => !r.created).length;

convex/tasks.ts

@@ -978,6 +978,12 @@ export const syncStatusFromLinear = mutation({
     };
 
     const mappedStatus = statusMap[status] || "backlog";
+
+    // Skip write if status hasn't changed (avoids conflicts from webhook retries)
+    if (task.status === mappedStatus) {
+      return task._id;
+    }
+
     const now = Date.now();
 
     await ctx.db.patch(task._id, {