@agent-native/core 0.77.8 → 0.77.11

package/corpus/core/src/audit/store.ts

@@ -7,7 +7,8 @@
  * `agent_audit_log`; reads are scoped to the caller's identity in SQL (no
  * shares table — audit rows are never individually shared).
  */
-import { getDbExec, intType, retryOnDdlRace } from "../db/client.js";
+import { getDbExec, intType, isPostgres } from "../db/client.js";
+import { ensureTableExists, ensureIndexExists } from "../db/ddl-guard.js";
 import type {
   AuditEvent,
   AuditQueryFilters,
@@ -20,9 +21,7 @@ export async function ensureAuditTables(): Promise<void> {
   if (!_initPromise) {
     _initPromise = (async () => {
       const client = getDbExec();
-
-      await retryOnDdlRace(() =>
-        client.execute(`
+      const createSql = `
         CREATE TABLE IF NOT EXISTS agent_audit_log (
           id TEXT PRIMARY KEY,
           created_at ${intType()} NOT NULL,
@@ -42,9 +41,41 @@ export async function ensureAuditTables(): Promise<void> {
           owner_email TEXT,
           visibility TEXT NOT NULL DEFAULT 'private'
         )
-      `),
-      );
+      `;
+
+      if (isPostgres()) {
+        // PG-guard: probe information_schema / pg_indexes before issuing DDL to
+        // avoid ACCESS EXCLUSIVE lock contention in fresh background-worker processes.
+        await ensureTableExists("agent_audit_log", createSql);
+        await ensureIndexExists(
+          "idx_audit_owner",
+          `CREATE INDEX IF NOT EXISTS idx_audit_owner ON agent_audit_log (owner_email, created_at)`,
+        );
+        await ensureIndexExists(
+          "idx_audit_org",
+          `CREATE INDEX IF NOT EXISTS idx_audit_org ON agent_audit_log (org_id, created_at)`,
+        );
+        await ensureIndexExists(
+          "idx_audit_target",
+          `CREATE INDEX IF NOT EXISTS idx_audit_target ON agent_audit_log (target_type, target_id, created_at)`,
+        );
+        await ensureIndexExists(
+          "idx_audit_turn",
+          `CREATE INDEX IF NOT EXISTS idx_audit_turn ON agent_audit_log (turn_id)`,
+        );
+        await ensureIndexExists(
+          "idx_audit_actor",
+          `CREATE INDEX IF NOT EXISTS idx_audit_actor ON agent_audit_log (actor_email, created_at)`,
+        );
+        await ensureIndexExists(
+          "idx_audit_created",
+          `CREATE INDEX IF NOT EXISTS idx_audit_created ON agent_audit_log (created_at)`,
+        );
+        return;
+      }
 
+      // SQLite (local dev): no lock problem — keep the original behaviour.
+      await client.execute(createSql);
       const indexes = [
         `CREATE INDEX IF NOT EXISTS idx_audit_owner ON agent_audit_log (owner_email, created_at)`,
         `CREATE INDEX IF NOT EXISTS idx_audit_org ON agent_audit_log (org_id, created_at)`,

package/corpus/core/src/browser-sessions/store.ts

@@ -5,6 +5,7 @@ import {
   retryOnDdlRace,
   safeJsonParse,
 } from "../db/client.js";
+import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
 import type {
   AgentNativeBrowserSession,
   AgentNativeBrowserSessionAction,
@@ -38,8 +39,7 @@ async function ensureTables(): Promise<void> {
   if (!initPromise) {
     initPromise = (async () => {
       const client = getDbExec();
-      await retryOnDdlRace(() =>
-        client.execute(`
+      const createSessionsSql = `
           CREATE TABLE IF NOT EXISTS ${SESSION_TABLE} (
             owner_email TEXT NOT NULL,
             session_id TEXT NOT NULL,
@@ -53,16 +53,8 @@ async function ensureTables(): Promise<void> {
             expires_at ${intType()} NOT NULL,
             PRIMARY KEY (owner_email, session_id)
           )
-        `),
-      );
-      await retryOnDdlRace(() =>
-        client.execute(`
-          CREATE INDEX IF NOT EXISTS agent_native_browser_sessions_owner_seen_idx
-          ON ${SESSION_TABLE} (owner_email, last_seen_at)
-        `),
-      );
-      await retryOnDdlRace(() =>
-        client.execute(`
+        `;
+      const createRequestsSql = `
           CREATE TABLE IF NOT EXISTS ${REQUEST_TABLE} (
             owner_email TEXT NOT NULL,
             session_id TEXT NOT NULL,
@@ -80,8 +72,35 @@ async function ensureTables(): Promise<void> {
             error TEXT,
             PRIMARY KEY (owner_email, request_id)
           )
+        `;
+
+      if (isPostgres()) {
+        // PG-guard: probe information_schema / pg_indexes first (no lock) and
+        // only issue DDL when the table/index is actually missing, wrapped in
+        // a transaction-scoped lock_timeout so a contended lock fails fast.
+        await ensureTableExists(SESSION_TABLE, createSessionsSql);
+        await ensureIndexExists(
+          "agent_native_browser_sessions_owner_seen_idx",
+          `CREATE INDEX IF NOT EXISTS agent_native_browser_sessions_owner_seen_idx ON ${SESSION_TABLE} (owner_email, last_seen_at)`,
+        );
+        await ensureTableExists(REQUEST_TABLE, createRequestsSql);
+        await ensureIndexExists(
+          "agent_native_browser_session_requests_pending_idx",
+          `CREATE INDEX IF NOT EXISTS agent_native_browser_session_requests_pending_idx ON ${REQUEST_TABLE} (owner_email, session_id, status, created_at)`,
+        );
+        return;
+      }
+
+      // SQLite (local dev): no ACCESS EXCLUSIVE lock problem — keep existing
+      // retryOnDdlRace behaviour.
+      await retryOnDdlRace(() => client.execute(createSessionsSql));
+      await retryOnDdlRace(() =>
+        client.execute(`
+          CREATE INDEX IF NOT EXISTS agent_native_browser_sessions_owner_seen_idx
+          ON ${SESSION_TABLE} (owner_email, last_seen_at)
         `),
       );
+      await retryOnDdlRace(() => client.execute(createRequestsSql));
       await retryOnDdlRace(() =>
         client.execute(`
           CREATE INDEX IF NOT EXISTS agent_native_browser_session_requests_pending_idx

package/corpus/core/src/chat-threads/store.ts

@@ -5,7 +5,12 @@ import {
   normalizeThreadRepository,
   normalizeThreadTitle,
 } from "../agent/thread-data-builder.js";
-import { getDbExec, intType } from "../db/client.js";
+import { getDbExec, intType, isPostgres } from "../db/client.js";
+import {
+  ensureColumnExists,
+  ensureIndexExists,
+  ensureTableExists,
+} from "../db/ddl-guard.js";
 import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
 import { emitChatThreadChange } from "./emitter.js";
 
@@ -53,7 +58,7 @@ async function ensureTable(): Promise<void> {
   if (!_initPromise) {
     _initPromise = (async () => {
       const client = getDbExec();
-      await client.execute(`
+      const createSql = `
         CREATE TABLE IF NOT EXISTS chat_threads (
           id TEXT PRIMARY KEY,
           owner_email TEXT NOT NULL,
@@ -69,7 +74,66 @@ async function ensureTable(): Promise<void> {
           pinned_at ${intType()},
           archived_at ${intType()}
         )
-      `);
+      `;
+
+      if (isPostgres()) {
+        // Hot path: the `chat_threads` table and its indexes are virtually
+        // always already present in production. Issuing `CREATE TABLE`/
+        // `CREATE INDEX` still takes a lock that, in a fresh background-worker
+        // process behind a concurrent connection on the shared Neon DB, can
+        // block ~indefinitely (ACCESS EXCLUSIVE for CREATE TABLE; a write-
+        // blocking SHARE lock for CREATE INDEX). The ensure* wrappers probe
+        // `information_schema`/`pg_indexes` first (plain reads, no lock) and
+        // run DDL ONLY for what is actually missing, bounded by a transaction-
+        // scoped `lock_timeout`. If a swallowed lock-timeout leaves the schema
+        // still missing they RE-PROBE and THROW rather than letting init
+        // memoize success against absent schema. `chat_threads` is the
+        // unqualified name even though the table lives in `public`.
+        await ensureTableExists("chat_threads", createSql);
+        // Additive columns — guarded so the hot path (columns already present)
+        // skips the ACCESS EXCLUSIVE ALTER entirely.
+        for (const [col, type] of [
+          ["scope_type", "TEXT"],
+          ["scope_id", "TEXT"],
+          ["scope_label", "TEXT"],
+          ["pinned_at", intType()],
+          ["archived_at", intType()],
+        ] as const) {
+          await ensureColumnExists(
+            "chat_threads",
+            col,
+            `ALTER TABLE chat_threads ADD COLUMN IF NOT EXISTS ${col} ${type}`,
+          );
+        }
+        // Widen millisecond-timestamp columns that older deployments created as
+        // 32-bit `INTEGER`; on Postgres the `Date.now()` written on every turn
+        // overflows int4. No-op once widened / on fresh BIGINT databases.
+        await widenIntColumnsToBigInt("chat_threads", [
+          "created_at",
+          "updated_at",
+          "pinned_at",
+          "archived_at",
+        ]);
+        // Indexes for the hot read paths. Both the sidebar list and the
+        // scoped/per-resource list filter on owner_email (and optionally
+        // scope) and sort by updated_at. Probe pg_indexes first (no lock)
+        // and skip the SHARE-locking CREATE INDEX when already present.
+        await ensureIndexExists(
+          "chat_threads_owner_updated_idx",
+          `CREATE INDEX IF NOT EXISTS chat_threads_owner_updated_idx ON chat_threads (owner_email, updated_at)`,
+        );
+        await ensureIndexExists(
+          "chat_threads_scope_updated_idx",
+          `CREATE INDEX IF NOT EXISTS chat_threads_scope_updated_idx ON chat_threads (scope_type, scope_id, updated_at)`,
+        );
+        // One-time backfill of message_count for legacy rows written before
+        // the column was maintained.
+        await backfillLegacyMessageCounts(client);
+        return;
+      }
+
+      // SQLite (local dev): no lock problem — keep the original behaviour.
+      await client.execute(createSql);
       // Additive migration for existing tables. Both SQLite and Postgres
       // accept `ALTER TABLE ADD COLUMN` and will raise when the column
       // already exists; the try/catch makes the call idempotent across

package/corpus/core/src/checkpoints/store.ts

@@ -1,4 +1,5 @@
-import { getDbExec, intType } from "../db/client.js";
+import { getDbExec, intType, isPostgres } from "../db/client.js";
+import { ensureTableExists } from "../db/ddl-guard.js";
 
 let _initPromise: Promise<void> | undefined;
 
@@ -6,7 +7,7 @@ async function ensureCheckpointTable(): Promise<void> {
   if (!_initPromise) {
     _initPromise = (async () => {
       const client = getDbExec();
-      await client.execute(`
+      const createSql = `
         CREATE TABLE IF NOT EXISTS agent_checkpoints (
           id TEXT PRIMARY KEY,
           thread_id TEXT NOT NULL,
@@ -15,7 +16,17 @@ async function ensureCheckpointTable(): Promise<void> {
           message TEXT NOT NULL DEFAULT '',
           created_at ${intType()} NOT NULL
         )
-      `);
+      `;
+
+      if (isPostgres()) {
+        // PG-guard: probe information_schema before issuing DDL to avoid ACCESS
+        // EXCLUSIVE lock contention in fresh background-worker processes.
+        await ensureTableExists("agent_checkpoints", createSql);
+        return;
+      }
+
+      // SQLite (local dev): no lock problem — keep the original behaviour.
+      await client.execute(createSql);
     })().catch((err) => {
       // Retry init on the next call after a failed startup.
       _initPromise = undefined;

package/corpus/core/src/cli/create.ts

@@ -29,7 +29,16 @@ const STANDALONE_EXACT_DEPENDENCY_OVERRIDES: Record<string, string> = {
 };
 const SENTRY_MINIMUM_RELEASE_AGE_EXCLUDES = [
   '"@sentry/browser"',
+  '"@sentry/browser-utils"',
+  '"@sentry/conventions"',
+  '"@sentry/core"',
+  '"@sentry/feedback"',
   '"@sentry/node"',
+  '"@sentry/node-core"',
+  '"@sentry/opentelemetry"',
+  '"@sentry/replay"',
+  '"@sentry/replay-canvas"',
+  '"@sentry/server-utils"',
 ];
 const FIRST_PARTY_TARBALL_SYMLINK_EXCLUDES = [
   "*/CLAUDE.md",

package/corpus/core/src/collab/awareness.ts

@@ -102,7 +102,7 @@ function pruneIfEmpty(docId: string, map: Map<number, AwarenessEntry>): void {
  *
  * Client sends its awareness state and receives other clients' states.
  *
- * Body: { clientId: number, state: string (base64) }
+ * Body: { clientId: number, state: string | null (JSON-encoded awareness state, or null to clear) }
  * Response: { states: Array<{ clientId: number, state: string }> }
  */
 export const postAwareness = defineEventHandler(async (event: H3Event) => {
@@ -115,28 +115,31 @@ export const postAwareness = defineEventHandler(async (event: H3Event) => {
   const body = await readBody(event);
   const { clientId, state } = body as {
     clientId?: number;
-    state?: string;
+    state?: string | null;
   };
 
-  if (clientId == null || !state) {
+  if (clientId == null || state === undefined) {
     // `!clientId` would wrongly reject clientId === 0, which is a valid
-    // (if rare) Yjs client id. Only reject missing/null ids here.
+    // (if rare) Yjs client id. A null state is valid: it clears this client.
     setResponseStatus(event, 400);
     return { error: "clientId and state required" };
   }
 
   const map = getDocAwareness(docId);
 
-  // Store this client's state
-  map.set(clientId, { clientId, state, lastSeen: Date.now() });
+  if (state === null) {
+    map.delete(clientId);
+  } else {
+    // Store this client's state
+    map.set(clientId, { clientId, state, lastSeen: Date.now() });
+  }
 
   // Clean expired entries, then prune the outer-map entry if it becomes empty.
   // Without pruning, a deployment with many transient docIds (e.g. one per
   // session) would grow _awarenessMap without bound.
   cleanExpired(map);
-  // map has at least the sender's entry so size >= 1 here; pruneIfEmpty is a
-  // no-op in the normal path but guards against edge cases (e.g. clientId 0
-  // that was immediately evicted by a concurrent cleanExpired run).
+  // Null-state clears and expiry can empty the map; prune the outer entry so
+  // transient document ids do not accumulate.
   pruneIfEmpty(docId, map);
 
   // Build the full list of current states (all clients including sender).

package/corpus/core/src/collab/client.ts

@@ -276,11 +276,13 @@ function scheduleAwarenessPush(
   const timer = setTimeout(() => {
     _awarenessThrottleTimers.delete(key);
     const state = getState();
-    if (!state) return;
     fetch(`${baseUrl}/${docId}/awareness`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ clientId, state: JSON.stringify(state) }),
+      body: JSON.stringify({
+        clientId,
+        state: state ? JSON.stringify(state) : null,
+      }),
     }).catch(() => {}); // best-effort; poll cycle is the baseline fallback
   }, 150);
 

package/corpus/core/src/collab/storage.ts

@@ -6,6 +6,7 @@
  */
 
 import { getDbExec, isPostgres } from "../db/client.js";
+import { ensureTableExists, ensureColumnExists } from "../db/ddl-guard.js";
 
 let _initPromise: Promise<void> | undefined;
 
@@ -14,7 +15,7 @@ async function ensureTable(): Promise<void> {
     _initPromise = (async () => {
       const client = getDbExec();
       const nowDefault = isPostgres() ? "NOW()::text" : "datetime('now')";
-      await client.execute(`
+      const createSql = `
         CREATE TABLE IF NOT EXISTS _collab_docs (
           doc_id TEXT PRIMARY KEY,
           yjs_state TEXT NOT NULL,
@@ -22,7 +23,24 @@ async function ensureTable(): Promise<void> {
           version INTEGER NOT NULL DEFAULT 0,
           updated_at TEXT NOT NULL DEFAULT (${nowDefault})
         )
-      `);
+      `;
+
+      if (isPostgres()) {
+        // PG-guard: probe information_schema first (no lock) and only issue
+        // DDL when the table/column is actually missing, wrapped in a
+        // transaction-scoped lock_timeout so a contended lock fails fast.
+        await ensureTableExists("_collab_docs", createSql);
+        await ensureColumnExists(
+          "_collab_docs",
+          "version",
+          `ALTER TABLE _collab_docs ADD COLUMN IF NOT EXISTS version INTEGER NOT NULL DEFAULT 0`,
+        );
+        return;
+      }
+
+      // SQLite (local dev): no ACCESS EXCLUSIVE lock problem — keep existing
+      // create-then-additive-alter behaviour.
+      await client.execute(createSql);
       try {
         await client.execute(
           `ALTER TABLE _collab_docs ADD COLUMN version INTEGER NOT NULL DEFAULT 0`,

package/corpus/core/src/db/ddl-guard.ts

@@ -121,6 +121,118 @@ export async function pgIndexExists(
   }
 }
 
+/**
+ * Probe → guarded-DDL → re-probe sequence for one piece of on-demand schema.
+ *
+ * This is the single safe primitive every `ensureTable()` should use so a
+ * swallowed `lock_timeout` can NEVER poison a store's init memo with missing
+ * schema. The flow:
+ *
+ *   1. `probe()` — cheap, lock-free existence check (pgTableExists / etc.).
+ *      Already present → return `false` (nothing to do; the hot path takes NO
+ *      lock).
+ *   2. Missing → run `ddl` through `runGuardedDdl` (bounded `lock_timeout`).
+ *      - DDL completed → return `true`.
+ *      - DDL was swallowed by a lock-timeout (`runGuardedDdl` returned `false`)
+ *        → RE-PROBE. A concurrent connection virtually always created the
+ *        object meanwhile, so the re-probe usually now reports it present →
+ *        return `true`. But if it is STILL missing, the required schema does
+ *        NOT exist and we must NOT let the caller memoize success — so THROW.
+ *        The caller's `_initPromise` rejects and the next call retries instead
+ *        of running forever against absent schema.
+ *
+ * On SQLite the probe is always `false` (helpers no-op there) and the SQLite
+ * branch of each store keeps its own create-then-catch behaviour, so this is a
+ * Postgres-path primitive in practice. Returns `true` when the object exists
+ * after this call (either pre-existing-after-timeout-race or freshly created),
+ * `false` only when it already existed up front (no DDL issued).
+ */
+export async function ensureSchemaObject(options: {
+  /** Lock-free existence check; `true` ⇒ already present, skip DDL. */
+  probe: () => Promise<boolean>;
+  /** DDL to run only when `probe()` reports the object missing. */
+  ddl: string;
+  /** Human-readable name of what's being ensured, for the error message. */
+  label: string;
+  /** Forwarded to `runGuardedDdl`. */
+  lockTimeout?: string;
+  /** Injectable client for tests. */
+  injectedClient?: DbExec;
+}): Promise<boolean> {
+  const { probe, ddl, label, lockTimeout, injectedClient } = options;
+  if (await probe()) return false;
+  const ran = await runGuardedDdl(ddl, { lockTimeout, injectedClient });
+  if (ran) return true;
+  // The DDL was swallowed by a lock-timeout. The object is virtually always
+  // already correct by the time a contended boot retries (a concurrent
+  // connection created it), so re-probe before giving up.
+  if (await probe()) return true;
+  // Still missing after a swallowed timeout: do NOT memoize success with absent
+  // schema. Throw so the caller's init promise rejects and the next call
+  // retries, rather than leaving ensureTable "initialized" against a table/
+  // column/index that does not exist.
+  throw new Error(
+    `ensureSchemaObject: required schema "${label}" is still missing after a ` +
+      `lock-timed-out DDL; refusing to memoize init success. The next call will retry.`,
+  );
+}
+
+/**
+ * Convenience wrapper: ensure a TABLE exists (probe via `pgTableExists`).
+ * No-op-returns `false` on SQLite (probe is always false there) — callers run
+ * the SQLite create on their own branch, so this is used on the Postgres path.
+ */
+export async function ensureTableExists(
+  table: string,
+  createSql: string,
+  options: { lockTimeout?: string; injectedClient?: DbExec } = {},
+): Promise<boolean> {
+  return ensureSchemaObject({
+    probe: () => pgTableExists(table, options.injectedClient),
+    ddl: createSql,
+    label: `table ${table}`,
+    lockTimeout: options.lockTimeout,
+    injectedClient: options.injectedClient,
+  });
+}
+
+/**
+ * Convenience wrapper: ensure a COLUMN exists (probe via `pgColumnExists`).
+ * `addColumnSql` should be the full `ALTER TABLE … ADD COLUMN IF NOT EXISTS …`.
+ */
+export async function ensureColumnExists(
+  table: string,
+  column: string,
+  addColumnSql: string,
+  options: { lockTimeout?: string; injectedClient?: DbExec } = {},
+): Promise<boolean> {
+  return ensureSchemaObject({
+    probe: () => pgColumnExists(table, column, options.injectedClient),
+    ddl: addColumnSql,
+    label: `column ${table}.${column}`,
+    lockTimeout: options.lockTimeout,
+    injectedClient: options.injectedClient,
+  });
+}
+
+/**
+ * Convenience wrapper: ensure an INDEX exists (probe via `pgIndexExists`).
+ * `createIndexSql` should be the full `CREATE INDEX IF NOT EXISTS <name> …`.
+ */
+export async function ensureIndexExists(
+  indexName: string,
+  createIndexSql: string,
+  options: { lockTimeout?: string; injectedClient?: DbExec } = {},
+): Promise<boolean> {
+  return ensureSchemaObject({
+    probe: () => pgIndexExists(indexName, options.injectedClient),
+    ddl: createIndexSql,
+    label: `index ${indexName}`,
+    lockTimeout: options.lockTimeout,
+    injectedClient: options.injectedClient,
+  });
+}
+
 /** True when an error looks like a Postgres `lock_timeout` (SQLSTATE 55P03). */
 export function isLockTimeoutError(err: unknown): boolean {
   const anyErr = err as { code?: unknown; message?: unknown } | null;

package/corpus/core/src/extensions/store.ts

@@ -5,6 +5,11 @@ import { and, eq, gte, isNull } from "drizzle-orm";
 import { appStatePut } from "../application-state/store.js";
 import { getDbExec, isPostgres, retryOnDdlRace } from "../db/client.js";
 import { createGetDb } from "../db/create-get-db.js";
+import {
+  ensureTableExists,
+  ensureColumnExists,
+  ensureIndexExists,
+} from "../db/ddl-guard.js";
 import { recordChange } from "../server/poll.js";
 import {
   getRequestUserEmail,
@@ -77,6 +82,70 @@ export async function ensureExtensionsTables(): Promise<void> {
     _initPromise = (async () => {
       const client = getDbExec();
       const pg = isPostgres();
+      if (pg) {
+        // PG guard: probe via information_schema, only issue DDL if missing, bounded lock_timeout
+        await ensureTableExists("tools", EXTENSIONS_CREATE_SQL_PG);
+        await migrateMisnamedExtensionsTable(client, pg); // data migration, not DDL — unchanged
+        await ensureTableExists("tool_shares", EXTENSION_SHARES_CREATE_SQL_PG);
+        await ensureTableExists("tool_data", EXTENSION_DATA_CREATE_SQL_PG);
+        await ensureExtensionDataItemId(client, pg); // ADD COLUMN — guarded inside
+        await ensureExtensionDataScope(client, pg); // ADD COLUMN — guarded inside
+        // DROP INDEX (for old index) — safe DDL, runs via client.execute; keep on both paths
+        await client.execute(EXTENSION_DATA_DROP_OLD_INDEX_SQL_PG);
+        await ensureIndexExists(
+          "tool_data_scoped_item_idx",
+          EXTENSION_DATA_ITEM_INDEX_SQL_PG,
+        );
+        await ensureIndexExists("tools_owner_idx", EXTENSIONS_OWNER_INDEX_SQL);
+        await ensureIndexExists("tools_org_idx", EXTENSIONS_ORG_INDEX_SQL);
+        await ensureIndexExists(
+          "tools_updated_at_idx",
+          EXTENSIONS_UPDATED_INDEX_SQL,
+        );
+        await ensureExtensionsGlobalHideColumns(client, pg); // ADD COLUMN — guarded inside
+        await ensureIndexExists(
+          "tools_hidden_at_idx",
+          EXTENSIONS_HIDDEN_AT_INDEX_SQL,
+        );
+        await ensureIndexExists(
+          "tool_shares_resource_idx",
+          EXTENSION_SHARES_RESOURCE_INDEX_SQL,
+        );
+        await ensureTableExists(
+          "tool_hidden_extensions",
+          EXTENSION_HIDES_CREATE_SQL_PG,
+        );
+        await ensureIndexExists(
+          "tool_hidden_extensions_user_tool_idx",
+          EXTENSION_HIDES_UNIQUE_INDEX_SQL,
+        );
+        await ensureIndexExists(
+          "tool_hidden_extensions_owner_idx",
+          EXTENSION_HIDES_OWNER_INDEX_SQL,
+        );
+        await ensureTableExists(
+          "tool_history",
+          EXTENSION_HISTORY_CREATE_SQL_PG,
+        );
+        await ensureIndexExists(
+          "tool_history_tool_version_idx",
+          EXTENSION_HISTORY_VERSION_INDEX_SQL,
+        );
+        await ensureIndexExists(
+          "tool_history_tool_created_idx",
+          EXTENSION_HISTORY_CREATED_INDEX_SQL,
+        );
+        await ensureTableExists(
+          "tool_consents",
+          EXTENSION_CONSENTS_CREATE_SQL_PG,
+        );
+        await ensureIndexExists(
+          "tool_consents_viewer_idx",
+          EXTENSION_CONSENTS_VIEWER_INDEX_SQL,
+        );
+        return;
+      }
+      // SQLite (local dev): keep existing behavior
       await retryOnDdlRace(() =>
         client.execute(pg ? EXTENSIONS_CREATE_SQL_PG : EXTENSIONS_CREATE_SQL),
       );
@@ -192,7 +261,9 @@ async function ensureExtensionDataItemId(
   pg: boolean,
 ): Promise<void> {
   if (pg) {
-    await client.execute(
+    await ensureColumnExists(
+      "tool_data",
+      "item_id",
       `ALTER TABLE tool_data ADD COLUMN IF NOT EXISTS item_id TEXT`,
     );
     return;
@@ -219,7 +290,9 @@ async function ensureExtensionDataScope(
 ): Promise<void> {
   const addCol = (name: string, def: string) => {
     if (pg) {
-      return client.execute(
+      return ensureColumnExists(
+        "tool_data",
+        name,
         `ALTER TABLE tool_data ADD COLUMN IF NOT EXISTS ${name} ${def}`,
       );
     }
@@ -255,7 +328,7 @@ async function ensureExtensionsGlobalHideColumns(
   // does not, so we drop the clause and swallow the duplicate-column error.
   const addCol = (pgSql: string, name: string, def: string) => {
     if (pg) {
-      return retryOnDdlRace(() => client.execute(pgSql));
+      return ensureColumnExists("tools", name, pgSql);
     }
     return client
       .execute(`ALTER TABLE tools ADD COLUMN ${name} ${def}`)