CCR 2

Check the abort signal before running a volatile step producer.

`step()` awaits a progress flush before dispatching, which is an await point,
so `factory.abort` can land between entering the call and running the
producer. The journaled path is covered because its next operation goes
through `awaitFactoryOperation`, which checks the signal before dispatching;
the volatile path returned `producer()` directly and so could start new
extension work on an already-cancelled run.

The regression test aborts mid-run and asserts the producer never runs.
Removing the guard fails it.

Author: MRayermannMSFT

nodejs/src/session.ts

@@ -1363,6 +1363,12 @@ export class CopilotSession {
                         ): Promise<JsonValue> => {
                             await progress.flush();
                             if (options.volatile) {
+                                // The flush above is an await point, so an abort can land
+                                // between entering step() and running the producer. The
+                                // journaled branch is covered by awaitFactoryOperation;
+                                // this one has to check for itself, or a cancelled run
+                                // would still start new extension work.
+                                throwIfFactoryAborted(controller.signal);
                                 return producer();
                             }
                             const cached = await awaitFactoryOperation(

nodejs/test/factory.test.ts

@@ -971,6 +971,49 @@ describe("factories", () => {
         expect(sendRequest).not.toHaveBeenCalled();
     });
 
+    it("does not start a volatile step producer after the run is aborted", async () => {
+        const sendRequest = vi.fn();
+        const session = new CopilotSession("session-volatile-abort", { sendRequest } as never);
+        let producerRan = false;
+        const factory = defineFactory({
+            meta: {
+                name: "volatile-abort",
+                description: "Volatile steps honour cancellation",
+                phases: [],
+            },
+            run: async ({ step, runId }) => {
+                // Abort mid-run, then attempt a volatile step. The producer must
+                // not run: cancellation has to stop new extension work starting,
+                // exactly as it does on the journaled path.
+                await session.clientSessionApis.factory!.abort({
+                    sessionId: session.sessionId,
+                    runId,
+                });
+                await step(
+                    "volatile",
+                    () => {
+                        producerRan = true;
+                        return "should not happen";
+                    },
+                    { volatile: true }
+                );
+                return "completed";
+            },
+        });
+        session.registerFactories([factory]);
+
+        await expect(
+            session.clientSessionApis.factory!.execute({
+                sessionId: session.sessionId,
+                name: "volatile-abort",
+                runId: "run-volatile-abort",
+                executionToken: "execution-token",
+                args: {},
+            })
+        ).rejects.toThrow();
+        expect(producerRan).toBe(false);
+    });
+
     it("rejects a factory result array with an extra own key", async () => {
         const factory = defineFactory({
             meta: {