[copilot-finds] Bug: Missing non-Task validation in generator failure recovery path

When an orchestrator catches a failed task exception and then yields a
non-Task value, the success path in resume() correctly throws an error
('The orchestrator generator yielded a non-Task object'), but the failure
recovery path silently returns without updating _previousTask. This
leaves the orchestration context in a broken state where:

1. _previousTask still points to the old failed task
2. The next resume() call re-throws the same exception to the generator
3. The orchestration gets stuck or produces confusing errors

The fix adds the same non-Task validation to the failure recovery path,
making it consistent with the success path. Two new tests verify both
the error case and the normal recovery case.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Copilot

packages/durabletask-js/src/worker/runtime-orchestration-context.ts

@@ -164,6 +164,8 @@ export class RuntimeOrchestrationContext extends OrchestrationContext {
           }
           return;
         }
+
+        throw new Error("The orchestrator generator yielded a non-Task object");
       } else if (this._previousTask.isComplete) {
         while (true) {
           // Resume the generator. This will either return a Task or raise StopIteration if it's done.

packages/durabletask-js/test/orchestration_executor.spec.ts

@@ -1585,6 +1585,79 @@ describe("Orchestration Executor", () => {
     expect(completeAction?.getOrchestrationstatus()).toEqual(pb.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED);
     expect(completeAction?.getResult()?.getValue()).toEqual(JSON.stringify("inner_failed"));
   });
+
+  it("should fail the orchestration when a generator catches a task failure and yields a non-Task value", async () => {
+    const dummyActivity = async (_: ActivityContext) => {
+      // do nothing
+    };
+    // This orchestrator catches the activity failure but then yields a non-Task value (a plain number)
+    const orchestrator: TOrchestrator = async function* (ctx: OrchestrationContext, _: any): any {
+      try {
+        yield ctx.callActivity(dummyActivity);
+      } catch {
+        yield 42 as any; // Bug: yielding a non-Task value after catching an exception
+      }
+      return "done";
+    };
+
+    const registry = new Registry();
+    const name = registry.addOrchestrator(orchestrator);
+    const activityName = registry.addActivity(dummyActivity);
+    const oldEvents = [
+      newOrchestratorStartedEvent(),
+      newExecutionStartedEvent(name, TEST_INSTANCE_ID, undefined),
+      newTaskScheduledEvent(1, activityName),
+    ];
+    const ex = new Error("Activity failed");
+    const newEvents = [newTaskFailedEvent(1, ex)];
+    const executor = new OrchestrationExecutor(registry, testLogger);
+    const result = await executor.execute(TEST_INSTANCE_ID, oldEvents, newEvents);
+
+    const completeAction = getAndValidateSingleCompleteOrchestrationAction(result);
+    expect(completeAction?.getOrchestrationstatus()).toEqual(pb.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED);
+    expect(completeAction?.getFailuredetails()?.getErrormessage()).toContain("non-Task");
+  });
+
+  it("should succeed when a generator catches a task failure and yields a valid new Task", async () => {
+    const failingActivity = async (_: ActivityContext) => {
+      // will fail
+    };
+    const recoveryActivity = async (_: ActivityContext) => {
+      // will succeed
+    };
+    // This orchestrator catches the activity failure and recovers by calling another activity
+    const orchestrator: TOrchestrator = async function* (ctx: OrchestrationContext, _: any): any {
+      try {
+        yield ctx.callActivity(failingActivity);
+      } catch {
+        const result = yield ctx.callActivity(recoveryActivity);
+        return result;
+      }
+    };
+
+    const registry = new Registry();
+    const name = registry.addOrchestrator(orchestrator);
+    const failingName = registry.addActivity(failingActivity);
+    const recoveryName = registry.addActivity(recoveryActivity);
+    const oldEvents = [
+      newOrchestratorStartedEvent(),
+      newExecutionStartedEvent(name, TEST_INSTANCE_ID, undefined),
+      newTaskScheduledEvent(1, failingName),
+    ];
+    const ex = new Error("Activity failed");
+    const newEvents = [
+      newTaskFailedEvent(1, ex),
+      // After the failure is caught, the orchestrator schedules recoveryActivity
+      newTaskScheduledEvent(2, recoveryName),
+      newTaskCompletedEvent(2, JSON.stringify("recovered")),
+    ];
+    const executor = new OrchestrationExecutor(registry, testLogger);
+    const result = await executor.execute(TEST_INSTANCE_ID, oldEvents, newEvents);
+
+    const completeAction = getAndValidateSingleCompleteOrchestrationAction(result);
+    expect(completeAction?.getOrchestrationstatus()).toEqual(pb.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED);
+    expect(completeAction?.getResult()?.getValue()).toEqual(JSON.stringify("recovered"));
+  });
 });
 
 function getAndValidateSingleCompleteOrchestrationAction(