Drain document lifecycle events through a durable processor

Before this commit `createDocumentWithLifecycle` enqueued ledger rows
inside the save transaction but consumed them from an in-memory
`pendingSideEffects` array straight after commit. A crash between the
commit and the drain stranded rows as `pending` forever; a crash mid
handler left them as `running`; and there was no retry budget.

The new `DocumentLifecycleProcessor` is the single drainer. It:

  - claims work via `claimPendingBatch`, an atomic `UPDATE … RETURNING`
    that flips rows from `pending` to `running` while incrementing
    `attempts`, so two drainers cannot race onto the same row;
  - dispatches each row through a handler registered by `hookType`,
    parsing the frozen `payload_json` back into the call arguments;
  - records `succeeded` / `failed` / `retryable` outcomes through the
    ledger, so a transient failure stays on the queue until the attempt
    cap expires, after which it is marked `failed` for operators;
  - reclaims rows stuck in `running` past `staleRunningMs` back to
    `pending` on every sweep tick plus at startup, so a crashed process
    never leaves a row orphaned;
  - runs a periodic sweep so every document — including those whose
    immediate post-commit drain failed — is eventually advanced.

`createDocumentWithLifecycle` now only enqueues and then calls
`lifecycleProcessor.drainForDocument` for the immediate happy-path pass.
Handlers live in `document-lifecycle-handlers.ts` so the processor stays
free of service-graph knowledge. The processor is constructed in
`bootstrap-application`, started there, and stopped on `before-quit`.

src/main/main-runtime-support.ts

@@ -13,6 +13,7 @@ import { registerOAuthIpcHandlers } from "./ipc-oauth-handlers";
 import { fail } from "./ipc-core-common";
 import type { ThreadIntegrationService } from "./thread-integration";
 import type { createCheckpointEngine } from "./checkpoint-engine";
+import type { DocumentLifecycleProcessor } from "./document-lifecycle-processor";
 
 type BootstrapResult = Awaited<ReturnType<typeof bootstrapApplication>>;
 
@@ -23,6 +24,7 @@ interface MainRuntimeState {
   ipcSupport: BootstrapResult["ipcSupport"] | null;
   threadIntegration: ThreadIntegrationService | null;
   checkpointEngine: ReturnType<typeof createCheckpointEngine> | null;
+  lifecycleProcessor: DocumentLifecycleProcessor | null;
 }
 
 export function createMainRuntimeSupport(state: MainRuntimeState) {
@@ -109,6 +111,13 @@ export function createMainRuntimeSupport(state: MainRuntimeState) {
     return state.checkpointEngine;
   }
 
+  function requireLifecycleProcessor() {
+    if (!state.lifecycleProcessor) {
+      throw new Error("Document lifecycle processor is not initialized.");
+    }
+    return state.lifecycleProcessor;
+  }
+
   function emitEvent(event: Parameters<BootstrapResult["ipcSupport"]["emitEvent"]>[0]) {
     requireIpcSupport().emitEvent(event);
   }
@@ -209,6 +218,7 @@ export function createMainRuntimeSupport(state: MainRuntimeState) {
       },
       threadIntegration: requireThreadIntegration(),
       checkpointEngine: requireCheckpointEngine(),
+      lifecycleProcessor: requireLifecycleProcessor(),
     });
 
     const piRuntime = requireServiceGraph().getPiRuntime();