fix(run-engine): match classification failures by error name as well as instanceof

The intended thrower of UnclassifiableRunId is an injected classifier,
which can arrive from a separately built bundle carrying its own copy
of the class, where instanceof misses. The class sets its name
explicitly, so the name check keeps the wrap reliable across module
instances. A missed match was already harmless (the error bubbled
unchanged); this preserves the clearer label in the one scenario the
branch exists for.

Author: matt-aitken

internal-packages/run-engine/src/engine/tests/completeWaitpointErrorClassification.test.ts

@@ -49,6 +49,20 @@ describe("completeWaitpoint store-resolution error classification", () => {
     ).rejects.not.toBeInstanceOf(UnclassifiableWaitpointId);
   });
 
+  it("wraps a classification failure from a foreign module instance (matched by name, not instanceof)", async () => {
+    const waitpointId = "waitpoint_foreign_instance";
+    const foreignError = new Error(`Unclassifiable run-ops id: ${waitpointId}`);
+    foreignError.name = "UnclassifiableRunId";
+    const waitpointSystem = createWaitpointSystem(() => Promise.reject(foreignError));
+
+    const caught = (await waitpointSystem
+      .completeWaitpoint({ id: waitpointId })
+      .catch((error: unknown) => error)) as UnclassifiableWaitpointId;
+    expect(caught).toBeInstanceOf(UnclassifiableWaitpointId);
+    expect(caught.waitpointId).toBe(waitpointId);
+    expect(caught.cause).toBe(foreignError);
+  });
+
   it("wraps a genuine UnclassifiableRunId as UnclassifiableWaitpointId with the original as cause", async () => {
     const waitpointId = "waitpoint_unclassifiable";
     const classificationError = new UnclassifiableRunId(waitpointId);

internal-packages/run-engine/src/engine/waitpointCoordinator/legacyPostgresCoordinator.ts

@@ -127,7 +127,11 @@ export class LegacyPostgresWaitpointCoordinator implements WaitpointCoordinator
       // database/infra error (e.g. can't reach the database) can surface here too. Those MUST
       // bubble up unchanged so they keep their original type, retryability, and error grouping
       // instead of being mislabelled as an unclassifiable id.
-      if (error instanceof UnclassifiableRunId) {
+      const isClassificationFailure =
+        error instanceof UnclassifiableRunId ||
+        (error instanceof Error && error.name === "UnclassifiableRunId");
+
+      if (isClassificationFailure) {
         this.logger.error("completeWaitpoint: unclassifiable waitpointId", {
           waitpointId,
           error,