Reorganize worker entry layer into worker/entry/ (M8 part 1/3)

Pulls the worker process entry point, parent<->worker IPC plumbing, message validation schema, and crash-recovery handler into a single src/main/worker/entry/ module. No runtime behavior changes — only directory + file-name renames plus import-path updates: worker-entry.ts -> entry/index.ts, worker-message-handler.ts -> entry/message-handler.ts, worker-rpc.ts -> entry/rpc.ts, worker-crash-recovery.ts -> entry/crash-recovery.ts, worker-types.ts -> entry/types.ts. electron.vite.config.ts, worker-service.ts, handlers/*.ts, pi-agent-factory.ts, and worker-runner.ts updated to point at the new locations.

src/main/worker/entry/message-handler.ts

@@ -0,0 +1,98 @@
+import type { RuntimeBridge, RuntimeMessageInjector } from "../../agent-runtime";
+import type { workerMessageSchema } from "./types";
+import { handleRunLog } from "../handlers/run-log-handler";
+import { handleRunStatus } from "../handlers/run-status-handler";
+import { handleRunFinished } from "../handlers/run-finished-handler";
+import type { HandlerContext, HandlerDeps } from "../handlers/handler-context";
+
+export async function handleWorkerMessage(
+  message: unknown,
+  worker: ReturnType<typeof import("electron").utilityProcess.fork> | null,
+  deps: HandlerDeps & {
+    getRuntimeBridge?: () => RuntimeBridge | null;
+    getRuntimeMessageInjector?: () => RuntimeMessageInjector | null;
+  },
+  workerMessageSchemaRef: typeof workerMessageSchema,
+  destroyed: boolean,
+  MAX_RETRY_ATTEMPTS: number,
+  RETRY_COOLDOWN_MS: number,
+  consecutiveWakeMap: Map<string, number>,
+  MAX_CONSECUTIVE_WAKES: number,
+  pendingRetryTimers: Set<ReturnType<typeof setTimeout>>,
+  leaseRenewalMap: Map<string, number>,
+) {
+  const parsed = workerMessageSchemaRef.safeParse(message);
+  if (!parsed.success) {
+    deps.logger.error("[worker] invalid message payload", parsed.error);
+    return;
+  }
+  const event = parsed.data;
+
+  const context: HandlerContext = {
+    destroyed,
+    MAX_RETRY_ATTEMPTS,
+    RETRY_COOLDOWN_MS,
+    MAX_CONSECUTIVE_WAKES,
+    consecutiveWakeMap,
+    pendingRetryTimers,
+    leaseRenewalMap,
+  };
+
+  switch (event.type) {
+    case "run-log":
+      await handleRunLog(event, deps, context);
+      return;
+    case "run-status":
+      handleRunStatus(event, deps, context);
+      return;
+    case "run-finished": {
+      try {
+        handleRunFinished(event, deps, context);
+      } finally {
+        deps.getRuntimeBridge?.()?.releaseRunResources(event.runId);
+      }
+      return;
+    }
+    case "agent-event": {
+      const bridge = deps.getRuntimeBridge?.();
+      if (bridge) {
+        bridge.handleAgentEvent({
+          runId: event.runId,
+          agentId: event.agentId,
+          companyId: event.companyId,
+          taskId: event.taskId,
+          emittedAt: event.emittedAt,
+          event: event.event,
+        });
+      }
+      return;
+    }
+    case "rpc-request": {
+      const bridge = deps.getRuntimeBridge?.();
+      const response = bridge
+        ? await bridge.handleRpc({
+            rpcId: event.rpcId,
+            runId: event.runId,
+            method: event.method,
+            payload: event.payload,
+          })
+        : { ok: false as const, error: "RuntimeBridge not initialised." };
+      try {
+        worker?.postMessage({ type: "rpc-response", rpcId: event.rpcId, response });
+      } catch (error) {
+        deps.logger.error(
+          `[worker] rpc-response postMessage failed: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+      return;
+    }
+    case "run-agent-state": {
+      deps.getRuntimeBridge?.()?.setRunAgentState(event.runId, event.state);
+      return;
+    }
+    case "steer-ack": {
+      deps.getRuntimeMessageInjector?.()?.handleSteerAck(event.correlationId, event.accepted);
+      return;
+    }
+  }
+}