fix(gateway): fall back to the pooler when the derived direct host is unreachable (#1641)

deriveDirectUrl() swaps the Supabase pooler host to db.<ref>.supabase.co:5432,
which is IPv6-only without the paid IPv4 add-on. On IPv4-only networks the
direct pool could never connect, and initDirectPool()'s throw killed
'gbrain init --url' and migrations with ENOTFOUND/ECONNREFUSED.

getDirectPool() now classifies network-unreachable errors (ENOTFOUND,
ECONNREFUSED, ENETUNREACH, EHOSTUNREACH, ETIMEDOUT, CONNECT_TIMEOUT) via the
new isNetworkUnreachableError(), self-activates the kill-switch, logs one
stderr line pointing at GBRAIN_DIRECT_DATABASE_URL / GBRAIN_DISABLE_DIRECT_POOL,
and returns the read pool. Auth/SQL errors still throw (misconfig, not
unreachability). The failed pool is ended via endPoolBounded so it can't
leak sockets into the now-continuing process.

Also surfaces the kill-switch + override envs in the init.ts IPv6 warnings
and docs/guides/live-sync.md (they were previously undocumented outside
connection-manager.ts).

Fixes #1641

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

docs/guides/live-sync.md

@@ -21,14 +21,17 @@ GBrain is tuned for the Supabase **Transaction pooler** (port 6543): it
 auto-disables prepared statements there and routes `engine.transaction()`
 (migrations, DDL, sync imports) to a derived **direct** connection
 (`db.<ref>.supabase.co:5432`). That direct host is IPv6-only, so on an
-IPv4-only host, reads work but sync **silently skips most pages**. This is the
-number one cause of "sync ran but nothing happened."
+IPv4-only host it is unreachable. When that happens gbrain now falls back to
+the pooler automatically (one stderr warning, then single-pool mode for the
+rest of the process) — but the pooler's ~2-min statement timeout can truncate
+very long migrations or bulk imports.
 
 Fix: make the direct connection reachable over IPv4. Either set
 `GBRAIN_DIRECT_DATABASE_URL` to the **Session pooler** string (port 5432 on the
-`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on. Verify by
-running `gbrain sync` and checking that the page count in `gbrain stats` matches
-the syncable file count in the repo.
+`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on.
+`GBRAIN_DISABLE_DIRECT_POOL=1` skips the direct pool (and the fallback warning)
+entirely. Verify by running `gbrain sync` and checking that the page count in
+`gbrain stats` matches the syncable file count in the repo.
 
 ### The Primitives
 

llms-full.txt

@@ -2720,14 +2720,17 @@ GBrain is tuned for the Supabase **Transaction pooler** (port 6543): it
 auto-disables prepared statements there and routes `engine.transaction()`
 (migrations, DDL, sync imports) to a derived **direct** connection
 (`db.<ref>.supabase.co:5432`). That direct host is IPv6-only, so on an
-IPv4-only host, reads work but sync **silently skips most pages**. This is the
-number one cause of "sync ran but nothing happened."
+IPv4-only host it is unreachable. When that happens gbrain now falls back to
+the pooler automatically (one stderr warning, then single-pool mode for the
+rest of the process) — but the pooler's ~2-min statement timeout can truncate
+very long migrations or bulk imports.
 
 Fix: make the direct connection reachable over IPv4. Either set
 `GBRAIN_DIRECT_DATABASE_URL` to the **Session pooler** string (port 5432 on the
-`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on. Verify by
-running `gbrain sync` and checking that the page count in `gbrain stats` matches
-the syncable file count in the repo.
+`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on.
+`GBRAIN_DISABLE_DIRECT_POOL=1` skips the direct pool (and the fallback warning)
+entirely. Verify by running `gbrain sync` and checking that the page count in
+`gbrain stats` matches the syncable file count in the repo.
 
 ### The Primitives
 

src/commands/doctor.ts

@@ -1551,24 +1551,6 @@ export async function checkRerankerHealth(engine: BrainEngine): Promise<Check> {
       };
     }
 
-    // Historical #2059 rows were logged as `unknown` before missing reranker
-    // auth was classified at the gateway. Surface repeated unknowns instead of
-    // reporting "ok" while every rerank fails open.
-    const unknownFails = failures.filter((f) => f.reason === 'unknown');
-    if (unknownFails.length >= 3) {
-      const setupHint = unknownFails.some((f) => {
-        const summary = String(f.error_summary ?? '');
-        return summary.includes('ZEROENTROPY_API_KEY') || summary.toLowerCase().includes('api key');
-      })
-        ? ' Fix: verify ZEROENTROPY_API_KEY and run `gbrain models doctor`.'
-        : '';
-      return {
-        name: 'reranker_health',
-        status: 'warn',
-        message: `${unknownFails.length} unknown reranker failure(s) in last 7 days.${setupHint}`,
-      };
-    }
-
     return {
       name: 'reranker_health',
       status: 'ok',

src/commands/init.ts

@@ -1078,6 +1078,9 @@ async function initPostgres(opts: {
     console.warn('  Direct connections are IPv6 only and fail in many environments.');
     console.warn('  Use the Transaction pooler connection string instead (port 6543):');
     console.warn('  Supabase Dashboard > Connect (top bar) > Connection String > Transaction pooler');
+    console.warn('  (With a pooler URL, gbrain derives a direct connection for DDL and falls back');
+    console.warn('  to the pooler automatically if that host is unreachable. Power users:');
+    console.warn('  GBRAIN_DIRECT_DATABASE_URL overrides the derived URL; GBRAIN_DISABLE_DIRECT_POOL=1 disables it.)');
     console.warn('');
   }
 
@@ -1091,6 +1094,9 @@ async function initPostgres(opts: {
       if (databaseUrl.includes('supabase.co') && (msg.includes('ECONNREFUSED') || msg.includes('ETIMEDOUT'))) {
         console.error('Connection failed. Supabase direct connections (db.*.supabase.co:5432) are IPv6 only.');
         console.error('Use the Transaction pooler connection string instead (port 6543).');
+        console.error('(gbrain derives its own direct connection from pooler URLs for DDL; if that host is');
+        console.error('unreachable it falls back to the pooler. GBRAIN_DIRECT_DATABASE_URL overrides the');
+        console.error('derived URL; GBRAIN_DISABLE_DIRECT_POOL=1 disables the direct pool entirely.)');
       }
       throw e;
     }

src/core/ai/gateway.ts

@@ -3656,15 +3656,7 @@ export async function rerank(input: RerankInput): Promise<RerankResult[]> {
   // whose request/response shape differs from ZE/llama.cpp (e.g. Voyage with
   // `top_k` / `data[]`) needs separate adapter hooks in a follow-up plan.
   const url = `${compat.baseURL.replace(/\/$/, '')}${tp.path ?? '/models/rerank'}`;
-  let auth: { apiKey?: string; headers?: Record<string, string> };
-  try {
-    auth = applyResolveAuth(recipe, cfg, 'reranker');
-  } catch (err) {
-    if (err instanceof AIConfigError) {
-      throw new RerankError(err.message, 'auth');
-    }
-    throw err;
-  }
+  const auth = applyResolveAuth(recipe, cfg, 'reranker');
   // applyResolveAuth returns { apiKey } for Bearer-style auth (SDK's native
   // path) or { headers } for custom-header providers (Azure). v0.37.6.0:
   // recipes can ALSO declare default_headers (attribution etc.) which flow

src/core/connection-manager.ts

@@ -167,6 +167,25 @@ export function deriveDirectUrl(url: string): string | null {
   }
 }
 
+/**
+ * Error codes that mean "the direct host is unreachable from this network"
+ * (#1641). The auto-derived db.<ref>.supabase.co host is IPv6-only without
+ * the paid IPv4 add-on, so ENOTFOUND/ECONNREFUSED here is expected on
+ * IPv4-only networks — we fall back to the pooler instead of failing init.
+ */
+const NETWORK_UNREACHABLE_CODES = [
+  'ENOTFOUND', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH',
+  'ETIMEDOUT', 'CONNECT_TIMEOUT',
+];
+
+/** True when err looks like a network-unreachable failure (not auth/SQL). */
+export function isNetworkUnreachableError(err: unknown): boolean {
+  const code = (err as { code?: unknown } | null)?.code;
+  if (typeof code === 'string' && NETWORK_UNREACHABLE_CODES.includes(code)) return true;
+  const msg = err instanceof Error ? err.message : String(err);
+  return NETWORK_UNREACHABLE_CODES.some(c => msg.includes(c));
+}
+
 /**
  * Read kill-switch state from env. Subordinate to parent manager's state
  * when present (A2 inheritance).
@@ -319,7 +338,30 @@ export class ConnectionManager {
         throw err;
       });
     }
-    const pool = await this._directInit;
+    let pool: Sql | null;
+    try {
+      pool = await this._directInit;
+    } catch (err) {
+      // #1641: the derived direct host (db.<ref>.supabase.co) is IPv6-only
+      // without Supabase's IPv4 add-on. On IPv4-only networks the direct
+      // pool can never connect — permanently fall back to the read pool
+      // (self-activating kill-switch) instead of failing init/migrations.
+      // Non-network errors (auth, SQL) still throw: they mean misconfig,
+      // not unreachability.
+      if (isNetworkUnreachableError(err)) {
+        const alreadyWarned = this._killSwitch;
+        this._killSwitch = true;
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!alreadyWarned) console.error(
+          `gbrain: direct connection to ${this._directUrl ? this.hostOnly(this._directUrl) : 'unknown host'} unreachable (${msg}); ` +
+          'falling back to the pooler for DDL/bulk (long migrations may hit the pooler statement timeout). ' +
+          'Set GBRAIN_DIRECT_DATABASE_URL to a reachable direct URL (e.g. the Session pooler, port 5432) or enable the Supabase IPv4 add-on; ' +
+          'GBRAIN_DISABLE_DIRECT_POOL=1 silences this.',
+        );
+        return this.getReadPool();
+      }
+      throw err;
+    }
     if (!pool) {
       // Defensive — initDirectPool should have thrown.
       throw new Error('connection-manager: direct pool init returned null');
@@ -350,8 +392,9 @@ export class ConnectionManager {
       },
     };
     const t0 = Date.now();
+    let pool: Sql | null = null;
     try {
-      const pool = postgres(this._directUrl, opts);
+      pool = postgres(this._directUrl, opts);
       // Probe to validate connectivity early.
       await pool`SELECT 1`;
       logConnectionEvent({
@@ -362,6 +405,9 @@ export class ConnectionManager {
       });
       return pool;
     } catch (err) {
+      // Don't leak the failed pool's sockets/timers (#1641 fallback keeps
+      // the process running afterward).
+      if (pool) await endPoolBounded(pool);
       logConnectionEvent({
         pool: 'ddl',
         op: 'error',

test/ai/rerank.test.ts

@@ -154,28 +154,6 @@ describe('gateway.rerank() — happy path', () => {
 describe('gateway.rerank() — error classification', () => {
   beforeEach(() => configureZE());
 
-  test('missing required reranker API key → RerankError(auth) before HTTP call', async () => {
-    configureGateway({
-      reranker_model: 'zeroentropyai:zerank-2',
-      env: {},
-    });
-    let called = false;
-    __setRerankTransportForTests(async () => {
-      called = true;
-      return mockResp({ results: [{ index: 0, relevance_score: 0.5 }] });
-    });
-
-    try {
-      await rerank({ query: 'q', documents: ['d'] });
-      throw new Error('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(RerankError);
-      expect((err as RerankError).reason).toBe('auth');
-      expect((err as Error).message).toContain('ZEROENTROPY_API_KEY');
-      expect(called).toBe(false);
-    }
-  });
-
   test('401 → auth', async () => {
     __setRerankTransportForTests(async () => new Response('Unauthorized', { status: 401 }));
     try {

test/connection-manager.serial.test.ts

@@ -3,6 +3,7 @@ import {
   isSupabasePoolerUrl,
   deriveDirectUrl,
   readKillSwitchEnv,
+  isNetworkUnreachableError,
   resolveDirectPoolSize,
   ConnectionManager,
   DEFAULT_DIRECT_POOL_SIZE,
@@ -238,3 +239,65 @@ describe('ConnectionManager — parent inheritance (A2)', () => {
     }
   });
 });
+
+describe('isNetworkUnreachableError (#1641)', () => {
+  test('classifies network codes as unreachable', () => {
+    for (const code of ['ENOTFOUND', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH', 'ETIMEDOUT', 'CONNECT_TIMEOUT']) {
+      const err = Object.assign(new Error('connect failed'), { code });
+      expect(isNetworkUnreachableError(err)).toBe(true);
+    }
+  });
+
+  test('classifies by message when code absent', () => {
+    expect(isNetworkUnreachableError(new Error('getaddrinfo ENOTFOUND db.abc.supabase.co'))).toBe(true);
+  });
+
+  test('auth/SQL errors are NOT unreachable', () => {
+    expect(isNetworkUnreachableError(new Error('password authentication failed for user "postgres"'))).toBe(false);
+    expect(isNetworkUnreachableError(new Error('syntax error at or near "SELEC"'))).toBe(false);
+    expect(isNetworkUnreachableError(null)).toBe(false);
+  });
+});
+
+describe('ConnectionManager — direct-pool fallback on unreachable host (#1641)', () => {
+  let originalKillSwitch: string | undefined;
+  let originalError: typeof console.error;
+  let errLines: string[];
+  beforeEach(() => {
+    originalKillSwitch = process.env.GBRAIN_DISABLE_DIRECT_POOL;
+    delete process.env.GBRAIN_DISABLE_DIRECT_POOL;
+    originalError = console.error;
+    errLines = [];
+    console.error = (...args: unknown[]) => { errLines.push(args.join(' ')); };
+  });
+  afterEach(() => {
+    console.error = originalError;
+    if (originalKillSwitch === undefined) delete process.env.GBRAIN_DISABLE_DIRECT_POOL;
+    else process.env.GBRAIN_DISABLE_DIRECT_POOL = originalKillSwitch;
+  });
+
+  test('ddl() falls back to the read pool when the direct host is unreachable', async () => {
+    const cm = new ConnectionManager({
+      url: 'postgresql://postgres.abc:p@aws.pooler.supabase.com:6543/db',
+      // 127.0.0.1:9 (discard) → instant ECONNREFUSED, the IPv4-only-network shape.
+      directUrl: 'postgresql://postgres:p@127.0.0.1:9/db',
+    });
+    const fakeReadPool = {} as ReturnType<typeof ConnectionManager.prototype.read>;
+    cm.setReadPool(fakeReadPool);
+    expect(cm.isDualPoolActive()).toBe(true);
+
+    const pool = await cm.ddl(); // without the fix this throws ECONNREFUSED
+    expect(pool).toBe(fakeReadPool);
+    // Self-activating kill-switch: subsequent calls skip the direct pool.
+    expect(cm.isKillSwitchActive()).toBe(true);
+    expect(cm.isDualPoolActive()).toBe(false);
+    expect(cm.describeMode().mode).toBe('single (kill-switch)');
+    // One stderr line mentioning the power-user override.
+    const warning = errLines.filter(l => l.includes('GBRAIN_DIRECT_DATABASE_URL'));
+    expect(warning.length).toBe(1);
+
+    const again = await cm.ddl();
+    expect(again).toBe(fakeReadPool);
+    expect(errLines.filter(l => l.includes('GBRAIN_DIRECT_DATABASE_URL')).length).toBe(1);
+  }, 20000);
+});

test/doctor.test.ts

@@ -2,11 +2,6 @@ import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:tes
 import { mkdirSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { withEnv } from './helpers/with-env.ts';
-import { logRerankFailure } from '../src/core/rerank-audit.ts';
 
 describe('doctor command', () => {
   test('doctor module exports runDoctor', async () => {
@@ -52,34 +47,6 @@ describe('doctor command', () => {
     expect(check.issues![0].action).toContain('trigger');
   });
 
-  test('reranker_health warns on repeated unknown rerank failures', async () => {
-    const { checkRerankerHealth } = await import('../src/commands/doctor.ts');
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gbrain-rerank-doctor-'));
-    try {
-      await withEnv({ GBRAIN_AUDIT_DIR: tmpDir }, async () => {
-        for (let i = 0; i < 3; i++) {
-          logRerankFailure({
-            model: 'zeroentropyai:zerank-2',
-            reason: 'unknown',
-            query_hash: `unknown${i}`,
-            doc_count: 30,
-            error_summary: 'ZeroEntropy reranker requires ZEROENTROPY_API_KEY.',
-          });
-        }
-        const check = await checkRerankerHealth({
-          async getConfig(key: string): Promise<string | null> {
-            return key === 'search.reranker.enabled' ? 'true' : null;
-          },
-        } as any);
-        expect(check.status).toBe('warn');
-        expect(check.message).toContain('unknown');
-        expect(check.message).toContain('ZEROENTROPY_API_KEY');
-      });
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
   test('runDoctor accepts null engine for filesystem-only mode', async () => {
     const { runDoctor } = await import('../src/commands/doctor.ts');
     // runDoctor should accept null engine — it runs filesystem checks only.

test/search/rerank.test.ts

@@ -12,14 +12,9 @@
  */
 
 import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
 import { applyReranker, type RerankerOpts } from '../../src/core/search/rerank.ts';
 import { RerankError, type RerankResult } from '../../src/core/ai/gateway.ts';
-import { readRecentRerankFailures } from '../../src/core/rerank-audit.ts';
 import type { SearchResult } from '../../src/core/types.ts';
-import { withEnv } from '../helpers/with-env.ts';
 
 function makeResult(slug: string, score: number, chunk: string): SearchResult {
   return {
@@ -165,36 +160,6 @@ describe('applyReranker — fail-open on every RerankError reason', () => {
     expect(out).toEqual(results);
   });
 
-  test('missing gateway reranker API key fail-opens and audits auth', async () => {
-    const { configureGateway } = await import('../../src/core/ai/gateway.ts');
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gbrain-rerank-search-'));
-    try {
-      await withEnv({ GBRAIN_AUDIT_DIR: tmpDir }, async () => {
-        configureGateway({
-          reranker_model: 'zeroentropyai:zerank-2',
-          env: {},
-        });
-
-        const results = [makeResult('a', 1.0, 'doc a')];
-        const out = await applyReranker('q', results, {
-          enabled: true,
-          topNIn: 1,
-          topNOut: null,
-          model: 'zeroentropyai:zerank-2',
-        });
-
-        expect(out).toEqual(results);
-        const failures = readRecentRerankFailures(1);
-        expect(failures).toHaveLength(1);
-        expect(failures[0]!.reason).toBe('auth');
-        expect(failures[0]!.error_summary).toContain('ZEROENTROPY_API_KEY');
-      });
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-      configureGateway({ env: { ZEROENTROPY_API_KEY: 'test-key' } });
-    }
-  });
-
   test('fail-open on non-RerankError throw too', async () => {
     const results = [makeResult('a', 1.0, 'a')];
     const opts: RerankerOpts = {