Corrige quatro defeitos de runtime do worker e dos scripts operacionais

Os quatro apareceram ao exercitar o layout de runtime da imagem — apenas
node_modules de produção, src, scripts e migrations — e nenhum aparecia na
suíte de testes nem no build. Os dois primeiros formavam uma armadilha mútua.

1. O CLI do `tsx` cria processo filho (PIDs medidos: 20840 contra 21096).
   O SIGTERM do `docker stop` pararia no pai, o worker nunca rodaria o
   handler, o lock esperaria o TTL de 120s e o `stop_grace_period` só
   atrasaria um SIGKILL. Passa a ser `node --import tsx`, mesmo processo.
2. Top-level await nos scripts falha com `--import tsx`, porque sem
   `"type": "module"` o esbuild gera CJS. `migrate`, `worker`, `seed-staging`,
   `flag`, `cleanup` e `check-bucket` não executariam: a migração não rodaria
   e o worker não subiria. `runScript`/`runWithDb` resolvem sem mudar o
   module type do projeto.
3. `import "server-only"` em `worker-loop.ts`: o pacote lança fora do bundler
   do Next, e o worker morria no start.
4. `@react-pdf/renderer` carregado no import de `process-job.ts` falha com
   ERR_PACKAGE_PATH_NOT_EXPORTED ao resolver a hifenização fora do bundler,
   derrubando worker e cleanup. O PDF sai sob demanda no download, então o
   import passou a ser tardio, dentro do ramo que o usa.

Além disso:

- O loop do worker saiu do script para `worker-loop.ts`, testável sem subir
  processo. O script cuida só de sinais, cadência e bootstrap.
- Desligamento gracioso espera o tick corrente para o `finally` liberar o
  lock. Um job que ainda não começou fica `queued`: nada pela metade.
- Heartbeat por tick, lido pelo healthcheck do contêiner. Processo vivo mas
  travado passa em qualquer verificação de PID.
- O worker recusa iniciar com migration pendente, e relê o contexto do dono a
  cada job: papel e feature flag podem ter mudado desde o enfileiramento.
- `verify-config`, `check-bucket`, `seed-staging` e `smoke-staging` novos. O
  smoke tem fase autenticada que só roda com credencial fornecida pela
  operação e, sem ela, reporta PENDENTE em vez de aprovado.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

scripts/_bootstrap.ts

@@ -0,0 +1,67 @@
+import path from "node:path";
+import { adapterEnv, identityShimEnabled, isDeployedEnv, requireDatabaseUrl } from "../src/config/env";
+import { exitOnInvalidConfig } from "../src/config/fail-fast";
+import { createFileDb } from "../src/infra/db/pglite";
+import { createPostgresDb } from "../src/infra/db/postgres";
+import type { Db } from "../src/infra/db/types";
+
+/**
+ * Banco para os scripts operacionais. Em staging e produção `DATABASE_URL` é
+ * obrigatória: cair em PGlite com um segredo ausente faria uma migração
+ * silenciosa num arquivo local parecer sucesso.
+ */
+export async function openOperationalDb(): Promise<Db> {
+  const databaseUrl = requireDatabaseUrl();
+  if (databaseUrl) return createPostgresDb(databaseUrl);
+  if (isDeployedEnv()) {
+    throw new Error("DATABASE_URL é obrigatória fora de development.");
+  }
+  const dataDir = path.join(process.cwd(), ".data", "pglite");
+  const { mkdir } = await import("node:fs/promises");
+  await mkdir(dataDir, { recursive: true });
+  return createFileDb(dataDir);
+}
+
+/** Recusa configuração inválida antes de tocar em qualquer recurso externo. */
+export function bootstrapScript(name: string): void {
+  exitOnInvalidConfig(process.env);
+  console.log(`[${name}] ambiente=${adapterEnv()} shim_identidade=${identityShimEnabled() ? "sim" : "nao"}`);
+}
+
+export function describeTarget(): string {
+  return process.env.DATABASE_URL ? "postgres" : "pglite local";
+}
+
+/**
+ * Executa o corpo do script.
+ *
+ * Existe para que nenhum script use top-level await: `tsx` compila `.ts` como
+ * CommonJS quando o `package.json` não declara `"type": "module"`, e aí top-level
+ * await é erro de transformação. Isso impedia rodar os scripts com
+ * `node --import tsx`, que é a forma que entrega SIGTERM ao nosso processo — o
+ * CLI do `tsx` cria um processo filho e o sinal não chega ao handler.
+ */
+export function runScript(name: string, body: () => Promise<void>): void {
+  body().then(
+    () => {
+      process.exitCode ??= 0;
+    },
+    (error: unknown) => {
+      const label = error instanceof Error ? `${error.name}: ${error.message}` : "erro";
+      console.error(`[${name}] ${label}`);
+      process.exit(1);
+    },
+  );
+}
+
+/** Abre o banco, executa e fecha, mesmo em caso de falha. */
+export function runWithDb(name: string, body: (db: Db) => Promise<void>): void {
+  runScript(name, async () => {
+    const db = await openOperationalDb();
+    try {
+      await body(db);
+    } finally {
+      await db.close().catch(() => undefined);
+    }
+  });
+}