postgresai 0.14.0-beta.13 → 0.14.0-beta.15

package/dist/bin/postgres-ai.js

@@ -13064,7 +13064,7 @@ var {
 // package.json
 var package_default = {
   name: "postgresai",
-  version: "0.14.0-beta.13",
+  version: "0.14.0-beta.15",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -13090,15 +13090,17 @@ var package_default = {
   },
   scripts: {
     "embed-metrics": "bun run scripts/embed-metrics.ts",
-    build: `bun run embed-metrics && bun build ./bin/postgres-ai.ts --outdir ./dist/bin --target node && node -e "const fs=require('fs');const f='./dist/bin/postgres-ai.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env bun','#!/usr/bin/env node'))" && cp -r ./sql ./dist/sql`,
+    "embed-checkup-dictionary": "bun run scripts/embed-checkup-dictionary.ts",
+    "embed-all": "bun run embed-metrics && bun run embed-checkup-dictionary",
+    build: `bun run embed-all && bun build ./bin/postgres-ai.ts --outdir ./dist/bin --target node && node -e "const fs=require('fs');const f='./dist/bin/postgres-ai.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env bun','#!/usr/bin/env node'))" && cp -r ./sql ./dist/sql`,
     prepublishOnly: "npm run build",
     start: "bun ./bin/postgres-ai.ts --help",
     "start:node": "node ./dist/bin/postgres-ai.js --help",
-    dev: "bun run embed-metrics && bun --watch ./bin/postgres-ai.ts",
-    test: "bun run embed-metrics && bun test",
-    "test:fast": "bun run embed-metrics && bun test --coverage=false",
-    "test:coverage": "bun run embed-metrics && bun test --coverage && echo 'Coverage report: cli/coverage/lcov-report/index.html'",
-    typecheck: "bun run embed-metrics && bunx tsc --noEmit"
+    dev: "bun run embed-all && bun --watch ./bin/postgres-ai.ts",
+    test: "bun run embed-all && bun test",
+    "test:fast": "bun run embed-all && bun test --coverage=false",
+    "test:coverage": "bun run embed-all && bun test --coverage && echo 'Coverage report: cli/coverage/lcov-report/index.html'",
+    typecheck: "bun run embed-all && bunx tsc --noEmit"
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.20.2",
@@ -15887,7 +15889,7 @@ var Result = import_lib.default.Result;
 var TypeOverrides = import_lib.default.TypeOverrides;
 var defaults = import_lib.default.defaults;
 // package.json
-var version = "0.14.0-beta.13";
+var version = "0.14.0-beta.15";
 var package_default2 = {
   name: "postgresai",
   version,
@@ -15916,15 +15918,17 @@ var package_default2 = {
   },
   scripts: {
     "embed-metrics": "bun run scripts/embed-metrics.ts",
-    build: `bun run embed-metrics && bun build ./bin/postgres-ai.ts --outdir ./dist/bin --target node && node -e "const fs=require('fs');const f='./dist/bin/postgres-ai.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env bun','#!/usr/bin/env node'))" && cp -r ./sql ./dist/sql`,
+    "embed-checkup-dictionary": "bun run scripts/embed-checkup-dictionary.ts",
+    "embed-all": "bun run embed-metrics && bun run embed-checkup-dictionary",
+    build: `bun run embed-all && bun build ./bin/postgres-ai.ts --outdir ./dist/bin --target node && node -e "const fs=require('fs');const f='./dist/bin/postgres-ai.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env bun','#!/usr/bin/env node'))" && cp -r ./sql ./dist/sql`,
     prepublishOnly: "npm run build",
     start: "bun ./bin/postgres-ai.ts --help",
     "start:node": "node ./dist/bin/postgres-ai.js --help",
-    dev: "bun run embed-metrics && bun --watch ./bin/postgres-ai.ts",
-    test: "bun run embed-metrics && bun test",
-    "test:fast": "bun run embed-metrics && bun test --coverage=false",
-    "test:coverage": "bun run embed-metrics && bun test --coverage && echo 'Coverage report: cli/coverage/lcov-report/index.html'",
-    typecheck: "bun run embed-metrics && bunx tsc --noEmit"
+    dev: "bun run embed-all && bun --watch ./bin/postgres-ai.ts",
+    test: "bun run embed-all && bun test",
+    "test:fast": "bun run embed-all && bun test --coverage=false",
+    "test:coverage": "bun run embed-all && bun test --coverage && echo 'Coverage report: cli/coverage/lcov-report/index.html'",
+    typecheck: "bun run embed-all && bunx tsc --noEmit"
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.20.2",
@@ -24961,7 +24965,11 @@ end $$;`;
     const roleSql = applyTemplate(loadSqlTemplate("01.role.sql"), { ...vars, ROLE_STMT: roleStmt });
     steps.push({ name: "01.role", sql: roleSql });
   }
-  let permissionsSql = applyTemplate(loadSqlTemplate("02.permissions.sql"), vars);
+  steps.push({
+    name: "02.extensions",
+    sql: loadSqlTemplate("02.extensions.sql")
+  });
+  let permissionsSql = applyTemplate(loadSqlTemplate("03.permissions.sql"), vars);
   if (SKIP_ALTER_USER_PROVIDERS.includes(provider)) {
     permissionsSql = permissionsSql.split(`
 `).filter((line) => {
@@ -24973,21 +24981,21 @@ end $$;`;
 `);
   }
   steps.push({
-    name: "02.permissions",
+    name: "03.permissions",
     sql: permissionsSql
   });
   steps.push({
-    name: "05.helpers",
-    sql: applyTemplate(loadSqlTemplate("05.helpers.sql"), vars)
+    name: "06.helpers",
+    sql: applyTemplate(loadSqlTemplate("06.helpers.sql"), vars)
   });
   if (params.includeOptionalPermissions) {
     steps.push({
-      name: "03.optional_rds",
-      sql: applyTemplate(loadSqlTemplate("03.optional_rds.sql"), vars),
+      name: "04.optional_rds",
+      sql: applyTemplate(loadSqlTemplate("04.optional_rds.sql"), vars),
       optional: true
     }, {
-      name: "04.optional_self_managed",
-      sql: applyTemplate(loadSqlTemplate("04.optional_self_managed.sql"), vars),
+      name: "05.optional_self_managed",
+      sql: applyTemplate(loadSqlTemplate("05.optional_self_managed.sql"), vars),
       optional: true
     });
   }
@@ -25055,6 +25063,62 @@ async function applyInitPlan(params) {
   }
   return { applied, skippedOptional };
 }
+async function buildUninitPlan(params) {
+  const monitoringUser = params.monitoringUser || DEFAULT_MONITORING_USER;
+  const database = params.database;
+  const provider = params.provider ?? "self-managed";
+  const dropRole = params.dropRole ?? true;
+  const qRole = quoteIdent(monitoringUser);
+  const qDb = quoteIdent(database);
+  const qRoleLiteral = quoteLiteral(monitoringUser);
+  const steps = [];
+  const vars = {
+    ROLE_IDENT: qRole,
+    DB_IDENT: qDb,
+    ROLE_LITERAL: qRoleLiteral
+  };
+  steps.push({
+    name: "01.drop_helpers",
+    sql: applyTemplate(loadSqlTemplate("uninit/01.helpers.sql"), vars)
+  });
+  steps.push({
+    name: "02.revoke_permissions",
+    sql: applyTemplate(loadSqlTemplate("uninit/02.permissions.sql"), vars)
+  });
+  if (dropRole && !SKIP_ROLE_CREATION_PROVIDERS.includes(provider)) {
+    steps.push({
+      name: "03.drop_role",
+      sql: applyTemplate(loadSqlTemplate("uninit/03.role.sql"), vars)
+    });
+  }
+  return { monitoringUser, database, steps, dropRole };
+}
+async function applyUninitPlan(params) {
+  const applied = [];
+  const errors3 = [];
+  const executeStep = async (step) => {
+    await params.client.query("begin;");
+    try {
+      await params.client.query(step.sql, step.params);
+      await params.client.query("commit;");
+    } catch (e) {
+      try {
+        await params.client.query("rollback;");
+      } catch {}
+      throw e;
+    }
+  };
+  for (const step of params.plan.steps) {
+    try {
+      await executeStep(step);
+      applied.push(step.name);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      errors3.push(`${step.name}: ${msg}`);
+    }
+  }
+  return { applied, errors: errors3 };
+}
 async function verifyInitSetup(params) {
   await params.client.query("begin isolation level repeatable read;");
   try {
@@ -26482,6 +26546,572 @@ function transformMetricRow(row) {
   return result;
 }
 
+// lib/checkup-dictionary-embedded.ts
+var CHECKUP_DICTIONARY_DATA = [
+  {
+    code: "A001",
+    title: "System information",
+    description: "OS, kernel, hardware details",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A002",
+    title: "Postgres major version",
+    description: "Major version and end-of-life status",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A003",
+    title: "Postgres settings",
+    description: "Full list of current settings",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A004",
+    title: "Cluster information",
+    description: "Data directory, cluster name, system identifier",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A005",
+    title: "Extensions",
+    description: "Installed and available extensions",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A006",
+    title: "Postgres setting deviations",
+    description: "Settings that differ from defaults",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A007",
+    title: "Altered settings",
+    description: "Settings changed via ALTER SYSTEM or per-user/database",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A008",
+    title: "Disk usage and file system type",
+    description: "Disk space, mount points, filesystem types",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A009",
+    title: "Tablespaces",
+    description: "Tablespace locations and usage",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A010",
+    title: "Corruption control",
+    description: "Checksums, wal_log_hints, backup safety",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A011",
+    title: "Connection management and pooling",
+    description: "Connection limits and pooler detection",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A012",
+    title: "Anti-crash checks",
+    description: "fsync, full_page_writes, synchronous_commit",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "A013",
+    title: "Postgres minor version",
+    description: "Minor version and available updates",
+    category: "system",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "B001",
+    title: "SLO/SLA, RPO, RTO",
+    description: "Recovery objectives and current capabilities",
+    category: "backup",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "B002",
+    title: "File system and mount flags",
+    description: "Mount options affecting durability",
+    category: "backup",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "B003",
+    title: "Full and incremental backups",
+    description: "Backup tooling and schedule",
+    category: "backup",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "B004",
+    title: "WAL archiving",
+    description: "Archive configuration and status",
+    category: "backup",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "B005",
+    title: "Backup restore testing and monitoring",
+    description: "Restore testing practices and alerting",
+    category: "backup",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "C001",
+    title: "SLO/SLA",
+    description: "Availability objectives",
+    category: "replication",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "C002",
+    title: "Replication mode and method",
+    description: "Sync/async, streaming/WAL shipping",
+    category: "replication",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "C003",
+    title: "Single points of failure",
+    description: "SPOF analysis",
+    category: "replication",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "C004",
+    title: "Failover",
+    description: "Failover mechanism and automation",
+    category: "replication",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "C005",
+    title: "Switchover",
+    description: "Planned switchover procedures",
+    category: "replication",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "C006",
+    title: "Delayed replica",
+    description: "Delayed standby configuration",
+    category: "replication",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "C007",
+    title: "Replication slots and lag",
+    description: "Slot status, lag, standby feedback",
+    category: "replication",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "D001",
+    title: "Logging settings",
+    description: "Log destination, verbosity, rotation",
+    category: "monitoring",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "D002",
+    title: "Useful Linux tools",
+    description: "Recommended OS-level tooling",
+    category: "monitoring",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "D003",
+    title: "Monitoring metrics",
+    description: "Key metrics to track",
+    category: "monitoring",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "D004",
+    title: "pg_stat_statements and pg_stat_kcache",
+    description: "Query stats extension settings",
+    category: "monitoring",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "D005",
+    title: "track_io_timing and auto_explain",
+    description: "I/O timing and plan logging",
+    category: "monitoring",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "D006",
+    title: "Recommended DBA toolsets",
+    description: "Useful third-party tools",
+    category: "monitoring",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "D007",
+    title: "Postgres troubleshooting tools",
+    description: "Built-in and ecosystem diagnostic tools",
+    category: "monitoring",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "E001",
+    title: "WAL and checkpoint settings",
+    description: "WAL size, checkpoint timing, I/O limits",
+    category: "wal",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "E002",
+    title: "Checkpoint and bgwriter activity",
+    description: "Checkpoint frequency, bgwriter stats",
+    category: "wal",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "F001",
+    title: "Autovacuum: current settings",
+    description: "Autovacuum configuration",
+    category: "vacuum",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "F002",
+    title: "Autovacuum: transaction ID wraparound",
+    description: "XID age and wraparound risk",
+    category: "vacuum",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "F003",
+    title: "Autovacuum: dead tuples",
+    description: "Dead tuple counts and cleanup status",
+    category: "vacuum",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "F004",
+    title: "Autovacuum: heap bloat estimate",
+    description: "Estimated table bloat",
+    category: "vacuum",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "F005",
+    title: "Autovacuum: index bloat estimate",
+    description: "Estimated index bloat",
+    category: "vacuum",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "F006",
+    title: "Precise heap bloat analysis",
+    description: "Detailed table bloat measurement",
+    category: "vacuum",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "F007",
+    title: "Precise index bloat analysis",
+    description: "Detailed index bloat measurement",
+    category: "vacuum",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "F008",
+    title: "Autovacuum: resource usage",
+    description: "Autovacuum I/O and CPU impact",
+    category: "vacuum",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "G001",
+    title: "Memory-related settings",
+    description: "shared_buffers, work_mem, maintenance_work_mem",
+    category: "tuning",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "G002",
+    title: "Connections and current activity",
+    description: "Connection usage and active sessions",
+    category: "tuning",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "G003",
+    title: "Timeouts, locks, deadlocks",
+    description: "Lock settings and deadlock stats",
+    category: "tuning",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "G004",
+    title: "Query planner settings",
+    description: "Planner cost and behavior settings",
+    category: "tuning",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "G005",
+    title: "I/O settings",
+    description: "effective_io_concurrency, random_page_cost",
+    category: "tuning",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "G006",
+    title: "Statistics target settings",
+    description: "default_statistics_target and per-column targets",
+    category: "tuning",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "H001",
+    title: "Invalid indexes",
+    description: "Indexes that failed to build",
+    category: "indexes",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "H002",
+    title: "Unused indexes",
+    description: "Indexes with no scans",
+    category: "indexes",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "H003",
+    title: "Non-indexed foreign keys",
+    description: "FKs missing supporting indexes",
+    category: "indexes",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "H004",
+    title: "Redundant indexes",
+    description: "Indexes covered by other indexes",
+    category: "indexes",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "J001",
+    title: "Capacity planning",
+    description: "Growth trends and resource projections",
+    category: "capacity",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "K001",
+    title: "Globally aggregated query metrics",
+    description: "Overall query stats summary",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "K002",
+    title: "Workload type",
+    description: "Read/write/mixed workload classification",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "K003",
+    title: "Top queries by total time",
+    description: "Highest total execution + planning time",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "K004",
+    title: "Top queries by temp bytes written",
+    description: "Queries spilling to disk",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "K005",
+    title: "Top queries by WAL generation",
+    description: "Queries generating most WAL",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "K006",
+    title: "Top queries by shared blocks read",
+    description: "Queries with most disk reads",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "K007",
+    title: "Top queries by shared blocks hit",
+    description: "Queries with most buffer hits",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "K008",
+    title: "Top queries by shared blocks accessed",
+    description: "Queries touching most data",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "L001",
+    title: "Table sizes",
+    description: "Table and toast sizes",
+    category: "schema",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "L002",
+    title: "Data types being used",
+    description: "Column type distribution",
+    category: "schema",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "L003",
+    title: "Integer overflow risks in primary keys",
+    description: "PKs approaching integer limits",
+    category: "schema",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "L004",
+    title: "Tables without primary key",
+    description: "Tables missing PK or unique constraint",
+    category: "schema",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "M001",
+    title: "Top queries by mean execution time",
+    description: "Slowest queries on average",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "M002",
+    title: "Top queries by rows processed",
+    description: "Queries touching most rows",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "M003",
+    title: "Top queries by I/O time",
+    description: "Queries with highest I/O wait",
+    category: "queries",
+    sort_order: null,
+    is_system_report: false
+  },
+  {
+    code: "N001",
+    title: "Wait events by type and query",
+    description: "Wait event analysis",
+    category: "waits",
+    sort_order: null,
+    is_system_report: false
+  }
+];
+
+// lib/checkup-dictionary.ts
+var dictionaryByCode = new Map(CHECKUP_DICTIONARY_DATA.map((entry) => [entry.code.toUpperCase(), entry]));
+function buildCheckInfoMap() {
+  const result = {};
+  for (const entry of CHECKUP_DICTIONARY_DATA) {
+    result[entry.code] = entry.title;
+  }
+  return result;
+}
+
 // lib/checkup.ts
 var __dirname = "/builds/postgres-ai/postgres_ai/cli/lib";
 var SECONDS_PER_DAY = 86400;
@@ -27125,6 +27755,23 @@ async function generateD004(client, nodeName) {
   };
   return report;
 }
+async function generateD001(client, nodeName) {
+  const report = createBaseReport("D001", "Logging settings", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const pgMajorVersion = parseInt(postgresVersion.server_major_ver, 10) || 16;
+  const allSettings = await getSettings(client, pgMajorVersion);
+  const loggingSettings = {};
+  for (const [name, setting] of Object.entries(allSettings)) {
+    if (name.startsWith("log_") || name.startsWith("logging_")) {
+      loggingSettings[name] = setting;
+    }
+  }
+  report.results[nodeName] = {
+    data: loggingSettings,
+    postgres_version: postgresVersion
+  };
+  return report;
+}
 async function generateF001(client, nodeName) {
   const report = createBaseReport("F001", "Autovacuum: current settings", nodeName);
   const postgresVersion = await getPostgresVersion(client);
@@ -27225,32 +27872,88 @@ async function generateG001(client, nodeName) {
   };
   return report;
 }
+async function generateG003(client, nodeName) {
+  const report = createBaseReport("G003", "Timeouts, locks, deadlocks", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const pgMajorVersion = parseInt(postgresVersion.server_major_ver, 10) || 16;
+  const allSettings = await getSettings(client, pgMajorVersion);
+  const lockTimeoutSettingNames = [
+    "lock_timeout",
+    "statement_timeout",
+    "idle_in_transaction_session_timeout",
+    "idle_session_timeout",
+    "deadlock_timeout",
+    "max_locks_per_transaction",
+    "max_pred_locks_per_transaction",
+    "max_pred_locks_per_relation",
+    "max_pred_locks_per_page",
+    "log_lock_waits",
+    "transaction_timeout"
+  ];
+  const lockSettings = {};
+  for (const name of lockTimeoutSettingNames) {
+    if (allSettings[name]) {
+      lockSettings[name] = allSettings[name];
+    }
+  }
+  let deadlockStats = null;
+  let deadlockError = null;
+  try {
+    const statsResult = await client.query(`
+      select
+        coalesce(sum(deadlocks), 0)::bigint as deadlocks,
+        coalesce(sum(conflicts), 0)::bigint as conflicts,
+        min(stats_reset)::text as stats_reset
+      from pg_stat_database
+      where datname = current_database()
+    `);
+    if (statsResult.rows.length > 0) {
+      const row = statsResult.rows[0];
+      deadlockStats = {
+        deadlocks: parseInt(row.deadlocks, 10),
+        conflicts: parseInt(row.conflicts, 10),
+        stats_reset: row.stats_reset || null
+      };
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[G003] Error querying deadlock stats: ${errorMsg}`);
+    deadlockError = errorMsg;
+  }
+  report.results[nodeName] = {
+    data: {
+      settings: lockSettings,
+      deadlock_stats: deadlockStats,
+      ...deadlockError && { deadlock_stats_error: deadlockError }
+    },
+    postgres_version: postgresVersion
+  };
+  return report;
+}
 var REPORT_GENERATORS = {
   A002: generateA002,
   A003: generateA003,
   A004: generateA004,
   A007: generateA007,
   A013: generateA013,
+  D001: generateD001,
   D004: generateD004,
   F001: generateF001,
   G001: generateG001,
+  G003: generateG003,
   H001: generateH001,
   H002: generateH002,
   H004: generateH004
 };
-var CHECK_INFO = {
-  A002: "Postgres major version",
-  A003: "Postgres settings",
-  A004: "Cluster information",
-  A007: "Altered settings",
-  A013: "Postgres minor version",
-  D004: "pg_stat_statements and pg_stat_kcache settings",
-  F001: "Autovacuum: current settings",
-  G001: "Memory-related settings",
-  H001: "Invalid indexes",
-  H002: "Unused indexes",
-  H004: "Redundant indexes"
-};
+var CHECK_INFO = (() => {
+  const fullMap = buildCheckInfoMap();
+  const expressCheckIds = Object.keys(REPORT_GENERATORS);
+  const filtered = {};
+  for (const checkId of expressCheckIds) {
+    filtered[checkId] = fullMap[checkId] || checkId;
+  }
+  return filtered;
+})();
 async function generateAllReports(client, nodeName = "node-01", onProgress) {
   const reports = {};
   const entries = Object.entries(REPORT_GENERATORS);
@@ -27269,6 +27972,12 @@ async function generateAllReports(client, nodeName = "node-01", onProgress) {
   return reports;
 }
 
+// lib/checkup-dictionary.ts
+var dictionaryByCode2 = new Map(CHECKUP_DICTIONARY_DATA.map((entry) => [entry.code.toUpperCase(), entry]));
+function getCheckupEntry(code) {
+  return dictionaryByCode2.get(code.toUpperCase()) ?? null;
+}
+
 // lib/checkup-api.ts
 import * as https from "https";
 import { URL as URL3 } from "url";
@@ -28229,12 +28938,16 @@ program2.command("prepare-db [conn]").description("prepare database for monitori
           if (errAny.code === "42501") {
             if (failedStep === "01.role") {
               console.error("  Context: role creation/update requires CREATEROLE or superuser");
-            } else if (failedStep === "02.permissions") {
+            } else if (failedStep === "03.permissions") {
               console.error("  Context: grants/view/search_path require sufficient GRANT/DDL privileges");
             }
             console.error("  Fix: ensure your Supabase access token has sufficient permissions");
             console.error("  Tip: run with --print-sql to review the exact SQL plan");
           }
+          if (errAny.code === "42P06" || message.includes("already exists") && failedStep === "03.permissions") {
+            console.error("  Hint: postgres_ai schema or objects already exist from a previous setup.");
+            console.error("  Fix: run 'postgresai unprepare-db <connection>' first to clean up, then retry prepare-db.");
+          }
         }
         if (errAny && typeof errAny === "object" && typeof errAny.httpStatus === "number") {
           if (errAny.httpStatus === 401) {
@@ -28498,13 +29211,17 @@ program2.command("prepare-db [conn]").description("prepare database for monitori
         if (errAny.code === "42501") {
           if (failedStep === "01.role") {
             console.error("  Context: role creation/update requires CREATEROLE or superuser");
-          } else if (failedStep === "02.permissions") {
+          } else if (failedStep === "03.permissions") {
             console.error("  Context: grants/view/search_path require sufficient GRANT/DDL privileges");
           }
           console.error("  Fix: connect as a superuser (or a role with CREATEROLE and sufficient GRANT privileges)");
           console.error("  Fix: on managed Postgres, use the provider's admin/master user");
           console.error("  Tip: run with --print-sql to review the exact SQL plan");
         }
+        if (errAny.code === "42P06" || message.includes("already exists") && failedStep === "03.permissions") {
+          console.error("  Hint: postgres_ai schema or objects already exist from a previous setup.");
+          console.error("  Fix: run 'postgresai unprepare-db <connection>' first to clean up, then retry prepare-db.");
+        }
         if (errAny.code === "ECONNREFUSED") {
           console.error("  Hint: check host/port and ensure Postgres is reachable from this machine");
         }
@@ -28525,18 +29242,258 @@ program2.command("prepare-db [conn]").description("prepare database for monitori
     }
   }
 });
-program2.command("checkup [conn]").description("generate health check reports directly from PostgreSQL (express mode)").option("--check-id <id>", `specific check to run: ${Object.keys(CHECK_INFO).join(", ")}, or ALL`, "ALL").option("--node-name <name>", "node name for reports", "node-01").option("--output <path>", "output directory for JSON files").option("--[no-]upload", "upload JSON results to PostgresAI (default: enabled; requires API key)", undefined).option("--project <project>", "project name or ID for remote upload (used with --upload; defaults to config defaultProject; auto-generated on first run)").option("--json", "output JSON to stdout (implies --no-upload)").addHelpText("after", [
+program2.command("unprepare-db [conn]").description("remove monitoring setup: drop monitoring user, views, schema, and revoke permissions").option("--db-url <url>", "PostgreSQL connection URL (admin) (deprecated; pass it as positional arg)").option("-h, --host <host>", "PostgreSQL host (psql-like)").option("-p, --port <port>", "PostgreSQL port (psql-like)").option("-U, --username <username>", "PostgreSQL user (psql-like)").option("-d, --dbname <dbname>", "PostgreSQL database name (psql-like)").option("--admin-password <password>", "Admin connection password (otherwise uses PGPASSWORD if set)").option("--monitoring-user <name>", "Monitoring role name to remove", DEFAULT_MONITORING_USER).option("--keep-role", "Keep the monitoring role (only revoke permissions and drop objects)", false).option("--provider <provider>", "Database provider (e.g., supabase). Affects which steps are executed.").option("--print-sql", "Print SQL plan and exit (no changes applied)", false).option("--force", "Skip confirmation prompt", false).option("--json", "Output result as JSON (machine-readable)", false).addHelpText("after", [
+  "",
+  "Examples:",
+  "  postgresai unprepare-db postgresql://admin@host:5432/dbname",
+  '  postgresai unprepare-db "dbname=dbname host=host user=admin"',
+  "  postgresai unprepare-db -h host -p 5432 -U admin -d dbname",
+  "",
+  "Admin password:",
+  "  --admin-password <password>   or  PGPASSWORD=... (libpq standard)",
+  "",
+  "Keep role but remove objects/permissions:",
+  "  postgresai unprepare-db <conn> --keep-role",
+  "",
+  "Inspect SQL without applying changes:",
+  "  postgresai unprepare-db <conn> --print-sql",
+  "",
+  "Offline SQL plan (no DB connection):",
+  "  postgresai unprepare-db --print-sql",
+  "",
+  "Skip confirmation prompt:",
+  "  postgresai unprepare-db <conn> --force"
+].join(`
+`)).action(async (conn, opts, cmd) => {
+  const jsonOutput = opts.json;
+  const outputJson = (data) => {
+    console.log(JSON.stringify(data, null, 2));
+  };
+  const outputError = (error2) => {
+    if (jsonOutput) {
+      outputJson({
+        success: false,
+        error: error2
+      });
+    } else {
+      console.error(`Error: unprepare-db: ${error2.message}`);
+      if (error2.step)
+        console.error(`  Step: ${error2.step}`);
+      if (error2.code)
+        console.error(`  Code: ${error2.code}`);
+      if (error2.detail)
+        console.error(`  Detail: ${error2.detail}`);
+      if (error2.hint)
+        console.error(`  Hint: ${error2.hint}`);
+    }
+    process.exitCode = 1;
+  };
+  const shouldPrintSql = !!opts.printSql;
+  const dropRole = !opts.keepRole;
+  const providerWarning = validateProvider(opts.provider);
+  if (providerWarning) {
+    console.warn(`\u26A0 ${providerWarning}`);
+  }
+  if (!conn && !opts.dbUrl && !opts.host && !opts.port && !opts.username && !opts.adminPassword) {
+    if (shouldPrintSql) {
+      const database = (opts.dbname ?? process.env.PGDATABASE ?? "postgres").trim();
+      const plan = await buildUninitPlan({
+        database,
+        monitoringUser: opts.monitoringUser,
+        dropRole,
+        provider: opts.provider
+      });
+      console.log(`
+--- SQL plan (offline; not connected) ---`);
+      console.log(`-- database: ${database}`);
+      console.log(`-- monitoring user: ${opts.monitoringUser}`);
+      console.log(`-- provider: ${opts.provider ?? "self-managed"}`);
+      console.log(`-- drop role: ${dropRole}`);
+      for (const step of plan.steps) {
+        console.log(`
+-- ${step.name}`);
+        console.log(step.sql);
+      }
+      console.log(`
+--- end SQL plan ---
+`);
+      return;
+    }
+  }
+  let adminConn;
+  try {
+    adminConn = resolveAdminConnection({
+      conn,
+      dbUrlFlag: opts.dbUrl,
+      host: opts.host ?? process.env.PGHOST,
+      port: opts.port ?? process.env.PGPORT,
+      username: opts.username ?? process.env.PGUSER,
+      dbname: opts.dbname ?? process.env.PGDATABASE,
+      adminPassword: opts.adminPassword,
+      envPassword: process.env.PGPASSWORD
+    });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (jsonOutput) {
+      outputError({ message: msg });
+    } else {
+      console.error(`Error: unprepare-db: ${msg}`);
+      if (typeof msg === "string" && msg.startsWith("Connection is required.")) {
+        console.error("");
+        cmd.outputHelp({ error: true });
+      }
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (!jsonOutput) {
+    console.log(`Connecting to: ${adminConn.display}`);
+    console.log(`Monitoring user: ${opts.monitoringUser}`);
+    console.log(`Drop role: ${dropRole}`);
+  }
+  if (!opts.force && !jsonOutput && !shouldPrintSql) {
+    const answer = await new Promise((resolve6) => {
+      const readline = getReadline();
+      readline.question(`This will remove the monitoring setup for user "${opts.monitoringUser}"${dropRole ? " and drop the role" : ""}. Continue? [y/N] `, (ans) => resolve6(ans.trim().toLowerCase()));
+    });
+    if (answer !== "y" && answer !== "yes") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  let client;
+  try {
+    const connResult = await connectWithSslFallback(Client, adminConn);
+    client = connResult.client;
+    const dbRes = await client.query("select current_database() as db");
+    const database = dbRes.rows?.[0]?.db;
+    if (typeof database !== "string" || !database) {
+      throw new Error("Failed to resolve current database name");
+    }
+    const plan = await buildUninitPlan({
+      database,
+      monitoringUser: opts.monitoringUser,
+      dropRole,
+      provider: opts.provider
+    });
+    if (shouldPrintSql) {
+      console.log(`
+--- SQL plan ---`);
+      for (const step of plan.steps) {
+        console.log(`
+-- ${step.name}`);
+        console.log(step.sql);
+      }
+      console.log(`
+--- end SQL plan ---
+`);
+      return;
+    }
+    const { applied, errors: errors3 } = await applyUninitPlan({ client, plan });
+    if (jsonOutput) {
+      outputJson({
+        success: errors3.length === 0,
+        action: "unprepare",
+        database,
+        monitoringUser: opts.monitoringUser,
+        dropRole,
+        applied,
+        errors: errors3
+      });
+      if (errors3.length > 0) {
+        process.exitCode = 1;
+      }
+    } else {
+      if (errors3.length === 0) {
+        console.log("\u2713 unprepare-db completed");
+        console.log(`Applied ${applied.length} steps`);
+      } else {
+        console.log("\u26A0 unprepare-db completed with errors");
+        console.log(`Applied ${applied.length} steps`);
+        console.log("Errors:");
+        for (const err of errors3) {
+          console.log(`  - ${err}`);
+        }
+        process.exitCode = 1;
+      }
+    }
+  } catch (error2) {
+    const errAny = error2;
+    let message = "";
+    if (error2 instanceof Error && error2.message) {
+      message = error2.message;
+    } else if (errAny && typeof errAny === "object" && typeof errAny.message === "string" && errAny.message) {
+      message = errAny.message;
+    } else {
+      message = String(error2);
+    }
+    if (!message || message === "[object Object]") {
+      message = "Unknown error";
+    }
+    const errorObj = { message };
+    if (errAny && typeof errAny === "object") {
+      if (typeof errAny.code === "string" && errAny.code)
+        errorObj.code = errAny.code;
+      if (typeof errAny.detail === "string" && errAny.detail)
+        errorObj.detail = errAny.detail;
+      if (typeof errAny.hint === "string" && errAny.hint)
+        errorObj.hint = errAny.hint;
+    }
+    if (jsonOutput) {
+      outputJson({
+        success: false,
+        error: errorObj
+      });
+      process.exitCode = 1;
+    } else {
+      console.error(`Error: unprepare-db: ${message}`);
+      if (errAny && typeof errAny === "object") {
+        if (typeof errAny.code === "string" && errAny.code) {
+          console.error(`  Code: ${errAny.code}`);
+        }
+        if (typeof errAny.detail === "string" && errAny.detail) {
+          console.error(`  Detail: ${errAny.detail}`);
+        }
+        if (typeof errAny.hint === "string" && errAny.hint) {
+          console.error(`  Hint: ${errAny.hint}`);
+        }
+      }
+      if (errAny && typeof errAny === "object" && typeof errAny.code === "string") {
+        if (errAny.code === "42501") {
+          console.error("  Context: dropping roles/objects requires sufficient privileges");
+          console.error("  Fix: connect as a superuser (or a role with appropriate DROP privileges)");
+        }
+        if (errAny.code === "ECONNREFUSED") {
+          console.error("  Hint: check host/port and ensure Postgres is reachable from this machine");
+        }
+        if (errAny.code === "ENOTFOUND") {
+          console.error("  Hint: DNS resolution failed; double-check the host name");
+        }
+        if (errAny.code === "ETIMEDOUT") {
+          console.error("  Hint: connection timed out; check network/firewall rules");
+        }
+      }
+      process.exitCode = 1;
+    }
+  } finally {
+    if (client) {
+      try {
+        await client.end();
+      } catch {}
+    }
+    closeReadline();
+  }
+});
+program2.command("checkup [conn]").description("generate health check reports directly from PostgreSQL (express mode)").option("--check-id <id>", `specific check to run (see list below), or ALL`, "ALL").option("--node-name <name>", "node name for reports", "node-01").option("--output <path>", "output directory for JSON files").option("--[no-]upload", "upload JSON results to PostgresAI (default: enabled; requires API key)", undefined).option("--project <project>", "project name or ID for remote upload (used with --upload; defaults to config defaultProject; auto-generated on first run)").option("--json", "output JSON to stdout (implies --no-upload)").addHelpText("after", [
   "",
   "Available checks:",
   ...Object.entries(CHECK_INFO).map(([id, title]) => `  ${id}: ${title}`),
   "",
   "Examples:",
   "  postgresai checkup postgresql://user:pass@host:5432/db",
-  "  postgresai checkup postgresql://user:pass@host:5432/db --check-id A003",
+  "  postgresai checkup postgresql://user:pass@host:5432/db --check-id D001",
   "  postgresai checkup postgresql://user:pass@host:5432/db --output ./reports",
   "  postgresai checkup postgresql://user:pass@host:5432/db --project my_project",
-  "  postgresai set-default-project my_project",
-  "  postgresai checkup postgresql://user:pass@host:5432/db",
   "  postgresai checkup postgresql://user:pass@host:5432/db --no-upload --json"
 ].join(`
 `)).action(async (conn, opts, cmd) => {
@@ -28584,8 +29541,14 @@ program2.command("checkup [conn]").description("generate health check reports di
       const generator = REPORT_GENERATORS[checkId];
       if (!generator) {
         spinner.stop();
-        console.error(`Unknown check ID: ${opts.checkId}`);
-        console.error(`Available: ${Object.keys(CHECK_INFO).join(", ")}, ALL`);
+        const dictEntry = getCheckupEntry(checkId);
+        if (dictEntry) {
+          console.error(`Check ${checkId} (${dictEntry.title}) is not yet available in express mode.`);
+          console.error(`Express-mode checks: ${Object.keys(CHECK_INFO).join(", ")}`);
+        } else {
+          console.error(`Unknown check ID: ${opts.checkId}`);
+          console.error(`See 'postgresai checkup --help' for available checks.`);
+        }
         process.exitCode = 1;
         return;
       }
@@ -28651,14 +29614,14 @@ async function resolveOrInitPaths() {
 }
 function isDockerRunning() {
   try {
-    const result = spawnSync2("docker", ["info"], { stdio: "pipe" });
+    const result = spawnSync2("docker", ["info"], { stdio: "pipe", timeout: 5000 });
     return result.status === 0;
   } catch {
     return false;
   }
 }
 function getComposeCmd() {
-  const tryCmd = (cmd, args) => spawnSync2(cmd, args, { stdio: "ignore" }).status === 0;
+  const tryCmd = (cmd, args) => spawnSync2(cmd, args, { stdio: "ignore", timeout: 5000 }).status === 0;
   if (tryCmd("docker-compose", ["version"]))
     return ["docker-compose"];
   if (tryCmd("docker", ["compose", "version"]))
@@ -28667,7 +29630,7 @@ function getComposeCmd() {
 }
 function checkRunningContainers() {
   try {
-    const result = spawnSync2("docker", ["ps", "--filter", "name=grafana-with-datasources", "--filter", "name=pgwatch", "--format", "{{.Names}}"], { stdio: "pipe", encoding: "utf8" });
+    const result = spawnSync2("docker", ["ps", "--filter", "name=grafana-with-datasources", "--filter", "name=pgwatch", "--format", "{{.Names}}"], { stdio: "pipe", encoding: "utf8", timeout: 5000 });
     if (result.status === 0 && result.stdout) {
       const containers = result.stdout.trim().split(`
 `).filter(Boolean);