test(runner): cover the registered "completed" recovery branch

`readyMessage` was the only `workflow-runner:registered` payload the suite
built, so `handleRegistered`'s `completed` branch never ran. Dropping its
pending hand-off loop would leave a runner that reconnects after the controller
persisted its terminal payload hanging until the Pod deadline, with the suite
still green.

Two cases, split so each assertion exercises the path it names:

- A pending `hand-off-child` resolves with the command id as `childRunId`. That
  is the invariant tying the runner to `queueHandOffChild`, which mints
  `{ childRunId: commandId }`.
- A `completed` reply before any job was handed out settles `waitForJob()` with
  `null`. On the reconnect-after-hand-off path the job is already settled, so
  `resolveJob(null)` is a no-op there and asserting it would prove nothing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KUPpJPtxAaHWrBsjytRGyM

Author: chrisleekr

test/runner/ws-client.test.ts

@@ -106,6 +106,20 @@ function readyMessage(clientFenceMs = 25, heartbeatIntervalMs = 10, includeJob =
   };
 }
 
+/**
+ * The controller's answer when it has already persisted this attempt's terminal
+ * payload: the runner reconnected after the result landed, so there is no job
+ * and no session to install.
+ */
+function completedMessage(): unknown {
+  return {
+    type: "workflow-runner:registered",
+    id: crypto.randomUUID(),
+    timestamp: Date.now(),
+    payload: { state: "completed" },
+  };
+}
+
 function sentMessage(
   socket: FakeWebSocket,
   type: string,
@@ -165,6 +179,57 @@ describe("WorkflowRunnerClient attempt fence", () => {
     expect(client.signal.aborted).toBe(true);
   });
 
+  it("settles a pending hand-off and the job wait when the controller reports the attempt completed", async () => {
+    jest.useFakeTimers();
+    const client = makeClient();
+    client.connect();
+    const first = FakeWebSocket.instances[0];
+    if (first === undefined) throw new Error("Expected first workflow runner socket");
+    first.fireOpen();
+    first.fireMessage(readyMessage(2_500, 500));
+    await client.waitForJob();
+
+    const handOffPromise = client.command({
+      type: "hand-off-child",
+      workflowName: "implement",
+      target: { type: "issue", owner: "acme", repo: "widgets", number: 16 },
+      parentStepIndex: 0,
+      state: { phase: "handing-off" },
+      humanMessage: "Handing off to the child run.",
+    });
+    const handOff = sentMessage(first, "workflow-runner:command");
+    first.fireClose();
+    jest.advanceTimersByTime(1_000);
+
+    const second = FakeWebSocket.instances[1];
+    if (second === undefined) throw new Error("Expected reconnected workflow runner socket");
+    second.fireOpen();
+    // The controller answers `completed`: it already stored the terminal payload
+    // for this attempt, so it hands back no job and installs no session.
+    second.fireMessage(completedMessage());
+
+    // The command id IS the child run id. `queueHandOffChild` mints
+    // `{ childRunId: commandId }` (`workflow-runner-controller.ts:500`), so the
+    // runner can settle the promise without the controller replaying a receipt.
+    expect(await handOffPromise).toEqual({ childRunId: handOff.id });
+    expect(client.signal.aborted).toBe(false);
+  });
+
+  it("settles the job wait with null when the attempt completed before the runner registered", async () => {
+    const client = makeClient();
+    client.connect();
+    const socket = FakeWebSocket.instances[0];
+    if (socket === undefined) throw new Error("Expected first workflow runner socket");
+    socket.fireOpen();
+    // No job was ever handed out, so this is the branch that actually settles
+    // `waitForJob`. Resolving it with `null` is what lets `main.ts` exit rather
+    // than waiting out the Pod's activeDeadlineSeconds.
+    socket.fireMessage(completedMessage());
+
+    expect(await client.waitForJob()).toBeNull();
+    expect(client.signal.aborted).toBe(false);
+  });
+
   it("replays stable command and result messages after reconnecting before the fence", async () => {
     jest.useFakeTimers();
     const client = makeClient();