[Fix] Follow-ups start disconnected tasks after delegated work completes

apps/api/src/handlers/github/handlePrComment.ts

@@ -4,6 +4,7 @@ import {
   enqueueTask,
   getTaskUrl,
   routeGitHubTask,
+  SnapshotResumeAlreadyExistsError,
 } from '@roomote/cloud-agents/server';
 import {
   findActiveGitHubPrReviewTask,
@@ -931,7 +932,7 @@ async function deliverFollowUpToExistingTask({
   });
 }
 
-async function resumeExistingTaskAndDeliverFollowUp({
+export async function resumeExistingTaskAndDeliverFollowUp({
   taskId,
   userId,
   sourceRunId,
@@ -1048,18 +1049,32 @@ async function resumeExistingTaskAndDeliverFollowUp({
 
   // Resumes never create tasks and never re-attribute; the resuming human
   // becomes the new run's acting user.
-  const resumeLaunch = await enqueueTask(
-    {
-      task: {
-        type: TaskPayloadKind.SnapshotResume,
-        sourceSnapshotId: sourceRun.snapshotId,
-        sourceRunId: sourceRun.id,
-        payload: resumePayload,
+  let resumeLaunch: Awaited<ReturnType<typeof enqueueTask>>;
+  try {
+    resumeLaunch = await enqueueTask(
+      {
+        task: {
+          type: TaskPayloadKind.SnapshotResume,
+          sourceSnapshotId: sourceRun.snapshotId,
+          sourceRunId: sourceRun.id,
+          payload: resumePayload,
+        },
+        actingUserId: senderUserId,
       },
-      actingUserId: senderUserId,
-    },
-    {},
-  );
+      {},
+    );
+  } catch (error) {
+    if (error instanceof SnapshotResumeAlreadyExistsError) {
+      // Continue through the normal fallback path so this distinct instruction
+      // gets its own linked follow-up task and response instead of being lost.
+      return {
+        success: false as const,
+        error: 'Reusable PR owner is already resuming',
+        status: 409,
+      };
+    }
+    throw error;
+  }
 
   const accepted = await waitForResumeRunToAcceptDeferredPrompt({
     taskId,

apps/api/src/handlers/tasks/sendMessageToTask.ts

@@ -1,5 +1,8 @@
 import { TRPCClientError } from '@trpc/client';
-import { enqueueTask } from '@roomote/cloud-agents/server';
+import {
+  enqueueTask,
+  SnapshotResumeAlreadyExistsError,
+} from '@roomote/cloud-agents/server';
 import {
   notifyFastAgentParentOnPrFeedback,
   withSandboxServerRpcClient,
@@ -593,18 +596,30 @@ async function resumeTaskFromSnapshot({
 
   // Resumes never create tasks and never re-attribute; the follow-up sender
   // becomes the new run's acting user.
-  const resumeLaunch = await enqueueTask(
-    {
-      task: {
-        type: TaskPayloadKind.SnapshotResume,
-        sourceSnapshotId: sourceRun.snapshotId,
-        sourceRunId: sourceRun.id,
-        payload,
+  let resumeLaunch: Awaited<ReturnType<typeof enqueueTask>>;
+  try {
+    resumeLaunch = await enqueueTask(
+      {
+        task: {
+          type: TaskPayloadKind.SnapshotResume,
+          sourceSnapshotId: sourceRun.snapshotId,
+          sourceRunId: sourceRun.id,
+          payload,
+        },
+        actingUserId: userId,
       },
-      actingUserId: userId,
-    },
-    {},
-  );
+      {},
+    );
+  } catch (error) {
+    if (error instanceof SnapshotResumeAlreadyExistsError) {
+      return {
+        success: false,
+        error: 'Task continuation is already in progress. Try again shortly.',
+        status: 409,
+      };
+    }
+    throw error;
+  }
 
   await maybeCreateSlackReplyQuoteContext({
     runId: resumeLaunch.id,
@@ -1266,6 +1281,34 @@ export async function steerMessageToTask({
         });
       }
 
+      const latestRun = await findLatestTaskRun(taskId, {
+        id: true,
+        status: true,
+        sandboxServerUrl: true,
+        actingUserId: true,
+        snapshotId: true,
+        snapshotCreatedAt: true,
+        sourceRunId: true,
+        payload: true,
+        port: true,
+        result: true,
+      });
+      if (latestRun?.id === run.id && isExitedRunStatus(latestRun.status)) {
+        const resumeResult = await resumeTaskFromSnapshot({
+          taskId,
+          userId,
+          message,
+          quoteText,
+          images,
+          sourceRun: latestRun as LatestTaskRun,
+          channelBindings,
+          senderMode,
+        });
+        if (resumeResult) {
+          return resumeResult;
+        }
+      }
+
       if (error instanceof SandboxNotReadyError) {
         return {
           success: false,