Remove orphaned legacy factory wait methods

Keep current workflow APIs and legacy run-update invalidation without referencing removed high-level factory types.

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

Author: mkdinh

nodejs/src/session.ts

@@ -527,115 +527,6 @@ export class CopilotSession {
         cancel: async (runId) => this.rpc.workflow.cancel({ runId }),
     };
 
-    /**
-     * Resolve a start/resume envelope into the terminal envelope callers expect.
-     *
-     * The CLI may answer `session.factory.run` and `session.factory.resume`
-     * before the run settles, so a non-terminal envelope is followed by a wait
-     * on the run's terminal state.
-     */
-    private settleFactoryRun(envelope: WireFactoryRunResult): Promise<FactoryRunResult> {
-        if (isFactoryRunTerminal(envelope.status)) {
-            return Promise.resolve(envelope);
-        }
-        return this.waitForFactoryRun(envelope.runId);
-    }
-
-    /**
-     * Resolve when a factory run reaches a terminal status.
-     *
-     * The subscription is installed *before* the first read so a transition
-     * landing between the two cannot be missed, and re-reads are serialized so
-     * overlapping invalidation events cannot interleave — the run's revision
-     * advances once per operation, so a burst of events is common and must
-     * collapse into a single in-flight read. A bounded periodic re-read keeps a
-     * dropped invalidation from leaving the wait pending forever.
-     */
-    private waitForFactoryRun(runId: string, signal?: AbortSignal): Promise<FactoryRunResult> {
-        const abortError = (): unknown =>
-            signal?.reason ?? new DOMException("Factory run wait was aborted", "AbortError");
-        if (signal?.aborted === true) {
-            return Promise.reject(abortError());
-        }
-
-        return new Promise<FactoryRunResult>((resolve, reject) => {
-            let settled = false;
-            let reading = false;
-            let rereadRequested = false;
-            let pollHandle: ReturnType<typeof setInterval> | undefined;
-            let unsubscribe: (() => void) | undefined;
-            let onAbort: (() => void) | undefined;
-
-            const finish = (complete: () => void): void => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                if (pollHandle !== undefined) {
-                    clearInterval(pollHandle);
-                }
-                unsubscribe?.();
-                if (onAbort !== undefined) {
-                    signal?.removeEventListener("abort", onAbort);
-                }
-                complete();
-            };
-
-            const read = async (): Promise<void> => {
-                if (settled) {
-                    return;
-                }
-                if (reading) {
-                    rereadRequested = true;
-                    return;
-                }
-                reading = true;
-                try {
-                    do {
-                        rereadRequested = false;
-                        const envelope = await this.rpc.factory.getRun({ runId });
-                        if (isFactoryRunTerminal(envelope.status)) {
-                            finish(() => resolve(envelope));
-                            return;
-                        }
-                    } while (rereadRequested && !settled);
-                } catch (error) {
-                    finish(() => reject(error));
-                } finally {
-                    reading = false;
-                }
-            };
-
-            if (signal !== undefined) {
-                onAbort = (): void => finish(() => reject(abortError()));
-                signal.addEventListener("abort", onAbort, { once: true });
-            }
-
-            const subscribe = this.on.bind(this) as unknown as (
-                eventType: string,
-                handler: (event: SessionEvent) => void
-            ) => () => void;
-            const handleRunUpdated = (event: SessionEvent): void => {
-                const data = event.data as { runId?: unknown };
-                if (data.runId === runId) {
-                    void read();
-                }
-            };
-            const unsubscribeFactory = subscribe("factory.run_updated", handleRunUpdated);
-            const unsubscribeWorkflow = subscribe("workflow.run_updated", handleRunUpdated);
-            unsubscribe = (): void => {
-                unsubscribeFactory();
-                unsubscribeWorkflow();
-            };
-
-            pollHandle = setInterval(() => void read(), 5_000);
-            // The re-read is a safety net, not work the process owes anyone: an
-            // outstanding wait must never keep Node alive on its own.
-            pollHandle.unref?.();
-            void read();
-        });
-    }
-
     private settleWorkflowRun(envelope: WireWorkflowRunResult): Promise<WorkflowRunResult> {
         if (isWorkflowRunTerminal(envelope.status)) {
             return Promise.resolve(envelope);