@carllee1983/dbcli 1.2.1 → 1.4.1

package/dist/cli.mjs

@@ -6124,14 +6124,8 @@ var init_validation = __esm(() => {
   EnvRefSchema = exports_external.object({
     $env: exports_external.string()
   }).strict();
-  StringOrEnvRef = exports_external.union([
-    exports_external.string().min(1),
-    EnvRefSchema
-  ]);
-  NumberOrEnvRef = exports_external.union([
-    exports_external.number().int().min(1).max(65535),
-    EnvRefSchema
-  ]);
+  StringOrEnvRef = exports_external.union([exports_external.string().min(1), EnvRefSchema]);
+  NumberOrEnvRef = exports_external.union([exports_external.number().int().min(1).max(65535), EnvRefSchema]);
   ConnectionConfigSchema = exports_external.object({
     system: exports_external.enum(["postgresql", "mysql", "mariadb"]),
     host: StringOrEnvRef,
@@ -6143,7 +6137,9 @@ var init_validation = __esm(() => {
   PermissionSchema = exports_external.enum(["query-only", "read-write", "data-admin", "admin"]).default("query-only");
   MetadataSchema = exports_external.object({
     createdAt: exports_external.string().datetime().optional(),
-    version: exports_external.string().default("1.0")
+    version: exports_external.string().default("1.0"),
+    schemaLastUpdated: exports_external.string().datetime().optional(),
+    schemaTableCount: exports_external.number().int().nonnegative().optional()
   }).optional().default({});
   BlacklistConfigSchema = exports_external.object({
     tables: exports_external.array(exports_external.string()).default([]),
@@ -6163,11 +6159,1458 @@ var init_validation = __esm(() => {
   DbcliConfigV2Schema = exports_external.object({
     version: exports_external.literal(2),
     default: exports_external.string().min(1),
-    connections: exports_external.record(NamedConnectionSchema).refine((conns) => Object.keys(conns).length > 0, { message: "At least one connection is required" }),
+    connections: exports_external.record(NamedConnectionSchema).refine((conns) => Object.keys(conns).length > 0, {
+      message: "At least one connection is required"
+    }),
     schema: exports_external.record(exports_external.any()).optional().default({}),
+    schemas: exports_external.record(exports_external.record(exports_external.any())).optional().default({}),
     metadata: MetadataSchema,
     blacklist: BlacklistConfigSchema
-  }).refine((config) => (config.default in config.connections), { message: "Default connection must exist in connections", path: ["default"] });
+  }).refine((config) => (config.default in config.connections), {
+    message: "Default connection must exist in connections",
+    path: ["default"]
+  });
+});
+
+// node_modules/lru-cache/dist/esm/index.js
+class Stack {
+  heap;
+  length;
+  static #constructing = false;
+  static create(max) {
+    const HeapCls = getUintArray(max);
+    if (!HeapCls)
+      return [];
+    Stack.#constructing = true;
+    const s = new Stack(max, HeapCls);
+    Stack.#constructing = false;
+    return s;
+  }
+  constructor(max, HeapCls) {
+    if (!Stack.#constructing) {
+      throw new TypeError("instantiate Stack using Stack.create(n)");
+    }
+    this.heap = new HeapCls(max);
+    this.length = 0;
+  }
+  push(n) {
+    this.heap[this.length++] = n;
+  }
+  pop() {
+    return this.heap[--this.length];
+  }
+}
+var perf, warned, PROCESS, emitWarning = (msg, type, code, fn) => {
+  typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+}, AC, AS, shouldWarn = (code) => !warned.has(code), TYPE, isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n), getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null, ZeroArray, LRUCache;
+var init_esm = __esm(() => {
+  perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+  warned = new Set;
+  PROCESS = typeof process === "object" && !!process ? process : {};
+  AC = globalThis.AbortController;
+  AS = globalThis.AbortSignal;
+  if (typeof AC === "undefined") {
+    AS = class AbortSignal2 {
+      onabort;
+      _onabort = [];
+      reason;
+      aborted = false;
+      addEventListener(_, fn) {
+        this._onabort.push(fn);
+      }
+    };
+    AC = class AbortController2 {
+      constructor() {
+        warnACPolyfill();
+      }
+      signal = new AS;
+      abort(reason) {
+        if (this.signal.aborted)
+          return;
+        this.signal.reason = reason;
+        this.signal.aborted = true;
+        for (const fn of this.signal._onabort) {
+          fn(reason);
+        }
+        this.signal.onabort?.(reason);
+      }
+    };
+    let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+    const warnACPolyfill = () => {
+      if (!printACPolyfillWarning)
+        return;
+      printACPolyfillWarning = false;
+      emitWarning("AbortController is not defined. If using lru-cache in " + "node 14, load an AbortController polyfill from the " + "`node-abort-controller` package. A minimal polyfill is " + "provided for use by LRUCache.fetch(), but it should not be " + "relied upon in other contexts (eg, passing it to other APIs that " + "use AbortController/AbortSignal might have undesirable effects). " + "You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
+    };
+  }
+  TYPE = Symbol("type");
+  ZeroArray = class ZeroArray extends Array {
+    constructor(size) {
+      super(size);
+      this.fill(0);
+    }
+  };
+  LRUCache = class LRUCache {
+    #max;
+    #maxSize;
+    #dispose;
+    #disposeAfter;
+    #fetchMethod;
+    #memoMethod;
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    static unsafeExposeInternals(c) {
+      return {
+        starts: c.#starts,
+        ttls: c.#ttls,
+        sizes: c.#sizes,
+        keyMap: c.#keyMap,
+        keyList: c.#keyList,
+        valList: c.#valList,
+        next: c.#next,
+        prev: c.#prev,
+        get head() {
+          return c.#head;
+        },
+        get tail() {
+          return c.#tail;
+        },
+        free: c.#free,
+        isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
+        backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
+        moveToTail: (index) => c.#moveToTail(index),
+        indexes: (options) => c.#indexes(options),
+        rindexes: (options) => c.#rindexes(options),
+        isStale: (index) => c.#isStale(index)
+      };
+    }
+    get max() {
+      return this.#max;
+    }
+    get maxSize() {
+      return this.#maxSize;
+    }
+    get calculatedSize() {
+      return this.#calculatedSize;
+    }
+    get size() {
+      return this.#size;
+    }
+    get fetchMethod() {
+      return this.#fetchMethod;
+    }
+    get memoMethod() {
+      return this.#memoMethod;
+    }
+    get dispose() {
+      return this.#dispose;
+    }
+    get disposeAfter() {
+      return this.#disposeAfter;
+    }
+    constructor(options) {
+      const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+      if (max !== 0 && !isPosInt(max)) {
+        throw new TypeError("max option must be a nonnegative integer");
+      }
+      const UintArray = max ? getUintArray(max) : Array;
+      if (!UintArray) {
+        throw new Error("invalid max value: " + max);
+      }
+      this.#max = max;
+      this.#maxSize = maxSize;
+      this.maxEntrySize = maxEntrySize || this.#maxSize;
+      this.sizeCalculation = sizeCalculation;
+      if (this.sizeCalculation) {
+        if (!this.#maxSize && !this.maxEntrySize) {
+          throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+        }
+        if (typeof this.sizeCalculation !== "function") {
+          throw new TypeError("sizeCalculation set to non-function");
+        }
+      }
+      if (memoMethod !== undefined && typeof memoMethod !== "function") {
+        throw new TypeError("memoMethod must be a function if defined");
+      }
+      this.#memoMethod = memoMethod;
+      if (fetchMethod !== undefined && typeof fetchMethod !== "function") {
+        throw new TypeError("fetchMethod must be a function if specified");
+      }
+      this.#fetchMethod = fetchMethod;
+      this.#hasFetchMethod = !!fetchMethod;
+      this.#keyMap = new Map;
+      this.#keyList = new Array(max).fill(undefined);
+      this.#valList = new Array(max).fill(undefined);
+      this.#next = new UintArray(max);
+      this.#prev = new UintArray(max);
+      this.#head = 0;
+      this.#tail = 0;
+      this.#free = Stack.create(max);
+      this.#size = 0;
+      this.#calculatedSize = 0;
+      if (typeof dispose === "function") {
+        this.#dispose = dispose;
+      }
+      if (typeof disposeAfter === "function") {
+        this.#disposeAfter = disposeAfter;
+        this.#disposed = [];
+      } else {
+        this.#disposeAfter = undefined;
+        this.#disposed = undefined;
+      }
+      this.#hasDispose = !!this.#dispose;
+      this.#hasDisposeAfter = !!this.#disposeAfter;
+      this.noDisposeOnSet = !!noDisposeOnSet;
+      this.noUpdateTTL = !!noUpdateTTL;
+      this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+      this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+      this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+      this.ignoreFetchAbort = !!ignoreFetchAbort;
+      if (this.maxEntrySize !== 0) {
+        if (this.#maxSize !== 0) {
+          if (!isPosInt(this.#maxSize)) {
+            throw new TypeError("maxSize must be a positive integer if specified");
+          }
+        }
+        if (!isPosInt(this.maxEntrySize)) {
+          throw new TypeError("maxEntrySize must be a positive integer if specified");
+        }
+        this.#initializeSizeTracking();
+      }
+      this.allowStale = !!allowStale;
+      this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+      this.updateAgeOnGet = !!updateAgeOnGet;
+      this.updateAgeOnHas = !!updateAgeOnHas;
+      this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+      this.ttlAutopurge = !!ttlAutopurge;
+      this.ttl = ttl || 0;
+      if (this.ttl) {
+        if (!isPosInt(this.ttl)) {
+          throw new TypeError("ttl must be a positive integer if specified");
+        }
+        this.#initializeTTLTracking();
+      }
+      if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
+        throw new TypeError("At least one of max, maxSize, or ttl is required");
+      }
+      if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+        const code = "LRU_CACHE_UNBOUNDED";
+        if (shouldWarn(code)) {
+          warned.add(code);
+          const msg = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
+          emitWarning(msg, "UnboundedCacheWarning", code, LRUCache);
+        }
+      }
+    }
+    getRemainingTTL(key) {
+      return this.#keyMap.has(key) ? Infinity : 0;
+    }
+    #initializeTTLTracking() {
+      const ttls = new ZeroArray(this.#max);
+      const starts = new ZeroArray(this.#max);
+      this.#ttls = ttls;
+      this.#starts = starts;
+      this.#setItemTTL = (index, ttl, start = perf.now()) => {
+        starts[index] = ttl !== 0 ? start : 0;
+        ttls[index] = ttl;
+        if (ttl !== 0 && this.ttlAutopurge) {
+          const t2 = setTimeout(() => {
+            if (this.#isStale(index)) {
+              this.#delete(this.#keyList[index], "expire");
+            }
+          }, ttl + 1);
+          if (t2.unref) {
+            t2.unref();
+          }
+        }
+      };
+      this.#updateItemAge = (index) => {
+        starts[index] = ttls[index] !== 0 ? perf.now() : 0;
+      };
+      this.#statusTTL = (status, index) => {
+        if (ttls[index]) {
+          const ttl = ttls[index];
+          const start = starts[index];
+          if (!ttl || !start)
+            return;
+          status.ttl = ttl;
+          status.start = start;
+          status.now = cachedNow || getNow();
+          const age = status.now - start;
+          status.remainingTTL = ttl - age;
+        }
+      };
+      let cachedNow = 0;
+      const getNow = () => {
+        const n = perf.now();
+        if (this.ttlResolution > 0) {
+          cachedNow = n;
+          const t2 = setTimeout(() => cachedNow = 0, this.ttlResolution);
+          if (t2.unref) {
+            t2.unref();
+          }
+        }
+        return n;
+      };
+      this.getRemainingTTL = (key) => {
+        const index = this.#keyMap.get(key);
+        if (index === undefined) {
+          return 0;
+        }
+        const ttl = ttls[index];
+        const start = starts[index];
+        if (!ttl || !start) {
+          return Infinity;
+        }
+        const age = (cachedNow || getNow()) - start;
+        return ttl - age;
+      };
+      this.#isStale = (index) => {
+        const s = starts[index];
+        const t2 = ttls[index];
+        return !!t2 && !!s && (cachedNow || getNow()) - s > t2;
+      };
+    }
+    #updateItemAge = () => {};
+    #statusTTL = () => {};
+    #setItemTTL = () => {};
+    #isStale = () => false;
+    #initializeSizeTracking() {
+      const sizes = new ZeroArray(this.#max);
+      this.#calculatedSize = 0;
+      this.#sizes = sizes;
+      this.#removeItemSize = (index) => {
+        this.#calculatedSize -= sizes[index];
+        sizes[index] = 0;
+      };
+      this.#requireSize = (k, v, size, sizeCalculation) => {
+        if (this.#isBackgroundFetch(v)) {
+          return 0;
+        }
+        if (!isPosInt(size)) {
+          if (sizeCalculation) {
+            if (typeof sizeCalculation !== "function") {
+              throw new TypeError("sizeCalculation must be a function");
+            }
+            size = sizeCalculation(v, k);
+            if (!isPosInt(size)) {
+              throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+            }
+          } else {
+            throw new TypeError("invalid size value (must be positive integer). " + "When maxSize or maxEntrySize is used, sizeCalculation " + "or size must be set.");
+          }
+        }
+        return size;
+      };
+      this.#addItemSize = (index, size, status) => {
+        sizes[index] = size;
+        if (this.#maxSize) {
+          const maxSize = this.#maxSize - sizes[index];
+          while (this.#calculatedSize > maxSize) {
+            this.#evict(true);
+          }
+        }
+        this.#calculatedSize += sizes[index];
+        if (status) {
+          status.entrySize = size;
+          status.totalCalculatedSize = this.#calculatedSize;
+        }
+      };
+    }
+    #removeItemSize = (_i) => {};
+    #addItemSize = (_i, _s, _st) => {};
+    #requireSize = (_k, _v, size, sizeCalculation) => {
+      if (size || sizeCalculation) {
+        throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+      }
+      return 0;
+    };
+    *#indexes({ allowStale = this.allowStale } = {}) {
+      if (this.#size) {
+        for (let i = this.#tail;; ) {
+          if (!this.#isValidIndex(i)) {
+            break;
+          }
+          if (allowStale || !this.#isStale(i)) {
+            yield i;
+          }
+          if (i === this.#head) {
+            break;
+          } else {
+            i = this.#prev[i];
+          }
+        }
+      }
+    }
+    *#rindexes({ allowStale = this.allowStale } = {}) {
+      if (this.#size) {
+        for (let i = this.#head;; ) {
+          if (!this.#isValidIndex(i)) {
+            break;
+          }
+          if (allowStale || !this.#isStale(i)) {
+            yield i;
+          }
+          if (i === this.#tail) {
+            break;
+          } else {
+            i = this.#next[i];
+          }
+        }
+      }
+    }
+    #isValidIndex(index) {
+      return index !== undefined && this.#keyMap.get(this.#keyList[index]) === index;
+    }
+    *entries() {
+      for (const i of this.#indexes()) {
+        if (this.#valList[i] !== undefined && this.#keyList[i] !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield [this.#keyList[i], this.#valList[i]];
+        }
+      }
+    }
+    *rentries() {
+      for (const i of this.#rindexes()) {
+        if (this.#valList[i] !== undefined && this.#keyList[i] !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield [this.#keyList[i], this.#valList[i]];
+        }
+      }
+    }
+    *keys() {
+      for (const i of this.#indexes()) {
+        const k = this.#keyList[i];
+        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield k;
+        }
+      }
+    }
+    *rkeys() {
+      for (const i of this.#rindexes()) {
+        const k = this.#keyList[i];
+        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield k;
+        }
+      }
+    }
+    *values() {
+      for (const i of this.#indexes()) {
+        const v = this.#valList[i];
+        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield this.#valList[i];
+        }
+      }
+    }
+    *rvalues() {
+      for (const i of this.#rindexes()) {
+        const v = this.#valList[i];
+        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield this.#valList[i];
+        }
+      }
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+    [Symbol.toStringTag] = "LRUCache";
+    find(fn, getOptions = {}) {
+      for (const i of this.#indexes()) {
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined)
+          continue;
+        if (fn(value, this.#keyList[i], this)) {
+          return this.get(this.#keyList[i], getOptions);
+        }
+      }
+    }
+    forEach(fn, thisp = this) {
+      for (const i of this.#indexes()) {
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined)
+          continue;
+        fn.call(thisp, value, this.#keyList[i], this);
+      }
+    }
+    rforEach(fn, thisp = this) {
+      for (const i of this.#rindexes()) {
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined)
+          continue;
+        fn.call(thisp, value, this.#keyList[i], this);
+      }
+    }
+    purgeStale() {
+      let deleted = false;
+      for (const i of this.#rindexes({ allowStale: true })) {
+        if (this.#isStale(i)) {
+          this.#delete(this.#keyList[i], "expire");
+          deleted = true;
+        }
+      }
+      return deleted;
+    }
+    info(key) {
+      const i = this.#keyMap.get(key);
+      if (i === undefined)
+        return;
+      const v = this.#valList[i];
+      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+      if (value === undefined)
+        return;
+      const entry = { value };
+      if (this.#ttls && this.#starts) {
+        const ttl = this.#ttls[i];
+        const start = this.#starts[i];
+        if (ttl && start) {
+          const remain = ttl - (perf.now() - start);
+          entry.ttl = remain;
+          entry.start = Date.now();
+        }
+      }
+      if (this.#sizes) {
+        entry.size = this.#sizes[i];
+      }
+      return entry;
+    }
+    dump() {
+      const arr = [];
+      for (const i of this.#indexes({ allowStale: true })) {
+        const key = this.#keyList[i];
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined || key === undefined)
+          continue;
+        const entry = { value };
+        if (this.#ttls && this.#starts) {
+          entry.ttl = this.#ttls[i];
+          const age = perf.now() - this.#starts[i];
+          entry.start = Math.floor(Date.now() - age);
+        }
+        if (this.#sizes) {
+          entry.size = this.#sizes[i];
+        }
+        arr.unshift([key, entry]);
+      }
+      return arr;
+    }
+    load(arr) {
+      this.clear();
+      for (const [key, entry] of arr) {
+        if (entry.start) {
+          const age = Date.now() - entry.start;
+          entry.start = perf.now() - age;
+        }
+        this.set(key, entry.value, entry);
+      }
+    }
+    set(k, v, setOptions = {}) {
+      if (v === undefined) {
+        this.delete(k);
+        return this;
+      }
+      const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
+      let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+      const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
+      if (this.maxEntrySize && size > this.maxEntrySize) {
+        if (status) {
+          status.set = "miss";
+          status.maxEntrySizeExceeded = true;
+        }
+        this.#delete(k, "set");
+        return this;
+      }
+      let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
+      if (index === undefined) {
+        index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
+        this.#keyList[index] = k;
+        this.#valList[index] = v;
+        this.#keyMap.set(k, index);
+        this.#next[this.#tail] = index;
+        this.#prev[index] = this.#tail;
+        this.#tail = index;
+        this.#size++;
+        this.#addItemSize(index, size, status);
+        if (status)
+          status.set = "add";
+        noUpdateTTL = false;
+      } else {
+        this.#moveToTail(index);
+        const oldVal = this.#valList[index];
+        if (v !== oldVal) {
+          if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
+            oldVal.__abortController.abort(new Error("replaced"));
+            const { __staleWhileFetching: s } = oldVal;
+            if (s !== undefined && !noDisposeOnSet) {
+              if (this.#hasDispose) {
+                this.#dispose?.(s, k, "set");
+              }
+              if (this.#hasDisposeAfter) {
+                this.#disposed?.push([s, k, "set"]);
+              }
+            }
+          } else if (!noDisposeOnSet) {
+            if (this.#hasDispose) {
+              this.#dispose?.(oldVal, k, "set");
+            }
+            if (this.#hasDisposeAfter) {
+              this.#disposed?.push([oldVal, k, "set"]);
+            }
+          }
+          this.#removeItemSize(index);
+          this.#addItemSize(index, size, status);
+          this.#valList[index] = v;
+          if (status) {
+            status.set = "replace";
+            const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
+            if (oldValue !== undefined)
+              status.oldValue = oldValue;
+          }
+        } else if (status) {
+          status.set = "update";
+        }
+      }
+      if (ttl !== 0 && !this.#ttls) {
+        this.#initializeTTLTracking();
+      }
+      if (this.#ttls) {
+        if (!noUpdateTTL) {
+          this.#setItemTTL(index, ttl, start);
+        }
+        if (status)
+          this.#statusTTL(status, index);
+      }
+      if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+        const dt = this.#disposed;
+        let task;
+        while (task = dt?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+      return this;
+    }
+    pop() {
+      try {
+        while (this.#size) {
+          const val = this.#valList[this.#head];
+          this.#evict(true);
+          if (this.#isBackgroundFetch(val)) {
+            if (val.__staleWhileFetching) {
+              return val.__staleWhileFetching;
+            }
+          } else if (val !== undefined) {
+            return val;
+          }
+        }
+      } finally {
+        if (this.#hasDisposeAfter && this.#disposed) {
+          const dt = this.#disposed;
+          let task;
+          while (task = dt?.shift()) {
+            this.#disposeAfter?.(...task);
+          }
+        }
+      }
+    }
+    #evict(free) {
+      const head = this.#head;
+      const k = this.#keyList[head];
+      const v = this.#valList[head];
+      if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
+        v.__abortController.abort(new Error("evicted"));
+      } else if (this.#hasDispose || this.#hasDisposeAfter) {
+        if (this.#hasDispose) {
+          this.#dispose?.(v, k, "evict");
+        }
+        if (this.#hasDisposeAfter) {
+          this.#disposed?.push([v, k, "evict"]);
+        }
+      }
+      this.#removeItemSize(head);
+      if (free) {
+        this.#keyList[head] = undefined;
+        this.#valList[head] = undefined;
+        this.#free.push(head);
+      }
+      if (this.#size === 1) {
+        this.#head = this.#tail = 0;
+        this.#free.length = 0;
+      } else {
+        this.#head = this.#next[head];
+      }
+      this.#keyMap.delete(k);
+      this.#size--;
+      return head;
+    }
+    has(k, hasOptions = {}) {
+      const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+      const index = this.#keyMap.get(k);
+      if (index !== undefined) {
+        const v = this.#valList[index];
+        if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === undefined) {
+          return false;
+        }
+        if (!this.#isStale(index)) {
+          if (updateAgeOnHas) {
+            this.#updateItemAge(index);
+          }
+          if (status) {
+            status.has = "hit";
+            this.#statusTTL(status, index);
+          }
+          return true;
+        } else if (status) {
+          status.has = "stale";
+          this.#statusTTL(status, index);
+        }
+      } else if (status) {
+        status.has = "miss";
+      }
+      return false;
+    }
+    peek(k, peekOptions = {}) {
+      const { allowStale = this.allowStale } = peekOptions;
+      const index = this.#keyMap.get(k);
+      if (index === undefined || !allowStale && this.#isStale(index)) {
+        return;
+      }
+      const v = this.#valList[index];
+      return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+    }
+    #backgroundFetch(k, index, options, context) {
+      const v = index === undefined ? undefined : this.#valList[index];
+      if (this.#isBackgroundFetch(v)) {
+        return v;
+      }
+      const ac = new AC;
+      const { signal } = options;
+      signal?.addEventListener("abort", () => ac.abort(signal.reason), {
+        signal: ac.signal
+      });
+      const fetchOpts = {
+        signal: ac.signal,
+        options,
+        context
+      };
+      const cb = (v2, updateCache = false) => {
+        const { aborted } = ac.signal;
+        const ignoreAbort = options.ignoreFetchAbort && v2 !== undefined;
+        if (options.status) {
+          if (aborted && !updateCache) {
+            options.status.fetchAborted = true;
+            options.status.fetchError = ac.signal.reason;
+            if (ignoreAbort)
+              options.status.fetchAbortIgnored = true;
+          } else {
+            options.status.fetchResolved = true;
+          }
+        }
+        if (aborted && !ignoreAbort && !updateCache) {
+          return fetchFail(ac.signal.reason);
+        }
+        const bf2 = p;
+        if (this.#valList[index] === p) {
+          if (v2 === undefined) {
+            if (bf2.__staleWhileFetching) {
+              this.#valList[index] = bf2.__staleWhileFetching;
+            } else {
+              this.#delete(k, "fetch");
+            }
+          } else {
+            if (options.status)
+              options.status.fetchUpdated = true;
+            this.set(k, v2, fetchOpts.options);
+          }
+        }
+        return v2;
+      };
+      const eb = (er) => {
+        if (options.status) {
+          options.status.fetchRejected = true;
+          options.status.fetchError = er;
+        }
+        return fetchFail(er);
+      };
+      const fetchFail = (er) => {
+        const { aborted } = ac.signal;
+        const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+        const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+        const noDelete = allowStale || options.noDeleteOnFetchRejection;
+        const bf2 = p;
+        if (this.#valList[index] === p) {
+          const del = !noDelete || bf2.__staleWhileFetching === undefined;
+          if (del) {
+            this.#delete(k, "fetch");
+          } else if (!allowStaleAborted) {
+            this.#valList[index] = bf2.__staleWhileFetching;
+          }
+        }
+        if (allowStale) {
+          if (options.status && bf2.__staleWhileFetching !== undefined) {
+            options.status.returnedStale = true;
+          }
+          return bf2.__staleWhileFetching;
+        } else if (bf2.__returned === bf2) {
+          throw er;
+        }
+      };
+      const pcall = (res, rej) => {
+        const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+        if (fmp && fmp instanceof Promise) {
+          fmp.then((v2) => res(v2 === undefined ? undefined : v2), rej);
+        }
+        ac.signal.addEventListener("abort", () => {
+          if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+            res(undefined);
+            if (options.allowStaleOnFetchAbort) {
+              res = (v2) => cb(v2, true);
+            }
+          }
+        });
+      };
+      if (options.status)
+        options.status.fetchDispatched = true;
+      const p = new Promise(pcall).then(cb, eb);
+      const bf = Object.assign(p, {
+        __abortController: ac,
+        __staleWhileFetching: v,
+        __returned: undefined
+      });
+      if (index === undefined) {
+        this.set(k, bf, { ...fetchOpts.options, status: undefined });
+        index = this.#keyMap.get(k);
+      } else {
+        this.#valList[index] = bf;
+      }
+      return bf;
+    }
+    #isBackgroundFetch(p) {
+      if (!this.#hasFetchMethod)
+        return false;
+      const b = p;
+      return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC;
+    }
+    async fetch(k, fetchOptions = {}) {
+      const {
+        allowStale = this.allowStale,
+        updateAgeOnGet = this.updateAgeOnGet,
+        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+        ttl = this.ttl,
+        noDisposeOnSet = this.noDisposeOnSet,
+        size = 0,
+        sizeCalculation = this.sizeCalculation,
+        noUpdateTTL = this.noUpdateTTL,
+        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
+        allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
+        ignoreFetchAbort = this.ignoreFetchAbort,
+        allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
+        context,
+        forceRefresh = false,
+        status,
+        signal
+      } = fetchOptions;
+      if (!this.#hasFetchMethod) {
+        if (status)
+          status.fetch = "get";
+        return this.get(k, {
+          allowStale,
+          updateAgeOnGet,
+          noDeleteOnStaleGet,
+          status
+        });
+      }
+      const options = {
+        allowStale,
+        updateAgeOnGet,
+        noDeleteOnStaleGet,
+        ttl,
+        noDisposeOnSet,
+        size,
+        sizeCalculation,
+        noUpdateTTL,
+        noDeleteOnFetchRejection,
+        allowStaleOnFetchRejection,
+        allowStaleOnFetchAbort,
+        ignoreFetchAbort,
+        status,
+        signal
+      };
+      let index = this.#keyMap.get(k);
+      if (index === undefined) {
+        if (status)
+          status.fetch = "miss";
+        const p = this.#backgroundFetch(k, index, options, context);
+        return p.__returned = p;
+      } else {
+        const v = this.#valList[index];
+        if (this.#isBackgroundFetch(v)) {
+          const stale = allowStale && v.__staleWhileFetching !== undefined;
+          if (status) {
+            status.fetch = "inflight";
+            if (stale)
+              status.returnedStale = true;
+          }
+          return stale ? v.__staleWhileFetching : v.__returned = v;
+        }
+        const isStale = this.#isStale(index);
+        if (!forceRefresh && !isStale) {
+          if (status)
+            status.fetch = "hit";
+          this.#moveToTail(index);
+          if (updateAgeOnGet) {
+            this.#updateItemAge(index);
+          }
+          if (status)
+            this.#statusTTL(status, index);
+          return v;
+        }
+        const p = this.#backgroundFetch(k, index, options, context);
+        const hasStale = p.__staleWhileFetching !== undefined;
+        const staleVal = hasStale && allowStale;
+        if (status) {
+          status.fetch = isStale ? "stale" : "refresh";
+          if (staleVal && isStale)
+            status.returnedStale = true;
+        }
+        return staleVal ? p.__staleWhileFetching : p.__returned = p;
+      }
+    }
+    async forceFetch(k, fetchOptions = {}) {
+      const v = await this.fetch(k, fetchOptions);
+      if (v === undefined)
+        throw new Error("fetch() returned undefined");
+      return v;
+    }
+    memo(k, memoOptions = {}) {
+      const memoMethod = this.#memoMethod;
+      if (!memoMethod) {
+        throw new Error("no memoMethod provided to constructor");
+      }
+      const { context, forceRefresh, ...options } = memoOptions;
+      const v = this.get(k, options);
+      if (!forceRefresh && v !== undefined)
+        return v;
+      const vv = memoMethod(k, v, {
+        options,
+        context
+      });
+      this.set(k, vv, options);
+      return vv;
+    }
+    get(k, getOptions = {}) {
+      const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+      const index = this.#keyMap.get(k);
+      if (index !== undefined) {
+        const value = this.#valList[index];
+        const fetching = this.#isBackgroundFetch(value);
+        if (status)
+          this.#statusTTL(status, index);
+        if (this.#isStale(index)) {
+          if (status)
+            status.get = "stale";
+          if (!fetching) {
+            if (!noDeleteOnStaleGet) {
+              this.#delete(k, "expire");
+            }
+            if (status && allowStale)
+              status.returnedStale = true;
+            return allowStale ? value : undefined;
+          } else {
+            if (status && allowStale && value.__staleWhileFetching !== undefined) {
+              status.returnedStale = true;
+            }
+            return allowStale ? value.__staleWhileFetching : undefined;
+          }
+        } else {
+          if (status)
+            status.get = "hit";
+          if (fetching) {
+            return value.__staleWhileFetching;
+          }
+          this.#moveToTail(index);
+          if (updateAgeOnGet) {
+            this.#updateItemAge(index);
+          }
+          return value;
+        }
+      } else if (status) {
+        status.get = "miss";
+      }
+    }
+    #connect(p, n) {
+      this.#prev[n] = p;
+      this.#next[p] = n;
+    }
+    #moveToTail(index) {
+      if (index !== this.#tail) {
+        if (index === this.#head) {
+          this.#head = this.#next[index];
+        } else {
+          this.#connect(this.#prev[index], this.#next[index]);
+        }
+        this.#connect(this.#tail, index);
+        this.#tail = index;
+      }
+    }
+    delete(k) {
+      return this.#delete(k, "delete");
+    }
+    #delete(k, reason) {
+      let deleted = false;
+      if (this.#size !== 0) {
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+          deleted = true;
+          if (this.#size === 1) {
+            this.#clear(reason);
+          } else {
+            this.#removeItemSize(index);
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+              v.__abortController.abort(new Error("deleted"));
+            } else if (this.#hasDispose || this.#hasDisposeAfter) {
+              if (this.#hasDispose) {
+                this.#dispose?.(v, k, reason);
+              }
+              if (this.#hasDisposeAfter) {
+                this.#disposed?.push([v, k, reason]);
+              }
+            }
+            this.#keyMap.delete(k);
+            this.#keyList[index] = undefined;
+            this.#valList[index] = undefined;
+            if (index === this.#tail) {
+              this.#tail = this.#prev[index];
+            } else if (index === this.#head) {
+              this.#head = this.#next[index];
+            } else {
+              const pi = this.#prev[index];
+              this.#next[pi] = this.#next[index];
+              const ni = this.#next[index];
+              this.#prev[ni] = this.#prev[index];
+            }
+            this.#size--;
+            this.#free.push(index);
+          }
+        }
+      }
+      if (this.#hasDisposeAfter && this.#disposed?.length) {
+        const dt = this.#disposed;
+        let task;
+        while (task = dt?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+      return deleted;
+    }
+    clear() {
+      return this.#clear("delete");
+    }
+    #clear(reason) {
+      for (const index of this.#rindexes({ allowStale: true })) {
+        const v = this.#valList[index];
+        if (this.#isBackgroundFetch(v)) {
+          v.__abortController.abort(new Error("deleted"));
+        } else {
+          const k = this.#keyList[index];
+          if (this.#hasDispose) {
+            this.#dispose?.(v, k, reason);
+          }
+          if (this.#hasDisposeAfter) {
+            this.#disposed?.push([v, k, reason]);
+          }
+        }
+      }
+      this.#keyMap.clear();
+      this.#valList.fill(undefined);
+      this.#keyList.fill(undefined);
+      if (this.#ttls && this.#starts) {
+        this.#ttls.fill(0);
+        this.#starts.fill(0);
+      }
+      if (this.#sizes) {
+        this.#sizes.fill(0);
+      }
+      this.#head = 0;
+      this.#tail = 0;
+      this.#free.length = 0;
+      this.#calculatedSize = 0;
+      this.#size = 0;
+      if (this.#hasDisposeAfter && this.#disposed) {
+        const dt = this.#disposed;
+        let task;
+        while (task = dt?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+    }
+  };
+});
+
+// src/utils/schema-path.ts
+import { join as join2 } from "path";
+function resolveSchemaPath(dbcliPath, connectionName) {
+  if (!connectionName)
+    return join2(dbcliPath, "schemas");
+  return join2(dbcliPath, "schemas", connectionName);
+}
+var init_schema_path = () => {};
+
+// src/core/schema-cache.ts
+import { join as join3 } from "path";
+
+class SchemaCacheManager {
+  cache;
+  index = null;
+  hotSchemas = new Map;
+  dbcliPath;
+  schemaRoot;
+  maxItems;
+  maxSize;
+  constructor(dbcliPath, options) {
+    this.dbcliPath = dbcliPath;
+    this.schemaRoot = resolveSchemaPath(dbcliPath, options?.connectionName);
+    this.maxItems = options?.maxCacheItems || 100;
+    this.maxSize = options?.maxCacheSize || 52428800;
+    this.cache = new LRUCache({
+      max: this.maxItems,
+      maxSize: this.maxSize,
+      sizeCalculation: (schema) => JSON.stringify(schema).length,
+      allowStale: false,
+      updateAgeOnGet: true,
+      updateAgeOnHas: false
+    });
+  }
+  async initialize() {
+    try {
+      const indexPath = join3(this.schemaRoot, "index.json");
+      const indexFile = Bun.file(indexPath);
+      if (await indexFile.exists()) {
+        const indexContent = await indexFile.text();
+        this.index = JSON.parse(indexContent);
+      }
+      const hotPath = join3(this.schemaRoot, "hot-schemas.json");
+      const hotFile = Bun.file(hotPath);
+      if (await hotFile.exists()) {
+        const hotContent = await hotFile.text();
+        const hotData = JSON.parse(hotContent);
+        const schemasObj = hotData.schemas || hotData;
+        for (const [tableName, schema] of Object.entries(schemasObj)) {
+          const tableSchema = schema;
+          this.hotSchemas.set(tableName, tableSchema);
+          this.cache.set(tableName, tableSchema);
+        }
+      }
+    } catch (error) {
+      console.error("Failed to load schema index/hot-schemas:", error);
+      this.index = null;
+    }
+  }
+  async getTableSchema(tableName) {
+    if (this.hotSchemas.has(tableName)) {
+      return this.hotSchemas.get(tableName);
+    }
+    const cached = this.cache.get(tableName);
+    if (cached) {
+      return cached;
+    }
+    if (!this.index) {
+      return null;
+    }
+    const tableInfo = this.index.tables[tableName];
+    if (!tableInfo) {
+      return null;
+    }
+    try {
+      const filePath = join3(this.schemaRoot, tableInfo.file);
+      const file = Bun.file(filePath);
+      if (!await file.exists()) {
+        console.error(`Cold table file not found: ${tableInfo.file} for table ${tableName}`);
+        return null;
+      }
+      const content = await file.text();
+      const data = JSON.parse(content);
+      const schema = data.schemas?.[tableName] || data[tableName];
+      if (schema) {
+        this.cache.set(tableName, schema);
+      }
+      return schema || null;
+    } catch (error) {
+      console.error(`Failed to load cold schema for table ${tableName}:`, error);
+      return null;
+    }
+  }
+  async findFieldsByName(fieldName) {
+    const results = [];
+    for (const [tableName, schema] of this.hotSchemas.entries()) {
+      const column = schema.columns.find((c) => c.name === fieldName);
+      if (column) {
+        results.push({ table: tableName, column });
+      }
+    }
+    return results;
+  }
+  invalidateTable(tableName) {
+    this.hotSchemas.delete(tableName);
+    this.cache.delete(tableName);
+  }
+  refreshTable(tableName, schema) {
+    this.hotSchemas.set(tableName, schema);
+    this.cache.set(tableName, schema);
+  }
+  getStats() {
+    const cacheSize = this.cache.calculatedSize || 0;
+    const cacheHitRate = this.cache.max && this.cache.max > 0 ? Math.round(this.cache.size / this.cache.max * 100) : 0;
+    return {
+      hotTables: this.hotSchemas.size,
+      cachedTables: this.cache.size,
+      cacheSize,
+      cacheHitRate: `${cacheHitRate}%`,
+      maxItems: this.maxItems,
+      maxSize: this.maxSize
+    };
+  }
+}
+var init_schema_cache = __esm(() => {
+  init_esm();
+  init_schema_path();
+});
+
+// src/core/schema-index.ts
+import { join as join4 } from "path";
+
+class SchemaIndexBuilder {
+  static async loadIndex(dbcliPath, connectionName) {
+    try {
+      const indexPath = join4(resolveSchemaPath(dbcliPath, connectionName), "index.json");
+      const file = Bun.file(indexPath);
+      if (!await file.exists()) {
+        return null;
+      }
+      const content = await file.text();
+      return JSON.parse(content);
+    } catch (error) {
+      console.error("Failed to load schema index:", error);
+      return null;
+    }
+  }
+  static async buildIndex(config, options) {
+    const hotTableThreshold = options?.hotTableThreshold || 20;
+    const schema = config.schema || {};
+    const tableEntries = Object.entries(schema).map(([tableName, tableData]) => {
+      const size = JSON.stringify(tableData).length;
+      return { tableName, size, data: tableData };
+    });
+    tableEntries.sort((a, b) => b.size - a.size);
+    const hotCount = Math.max(1, Math.ceil(tableEntries.length * hotTableThreshold / 100));
+    const hotTableNames = tableEntries.slice(0, hotCount).map((e) => e.tableName);
+    const index = {
+      tables: {},
+      hotTables: hotTableNames,
+      metadata: {
+        version: "1.0",
+        lastRefreshed: new Date().toISOString(),
+        totalTables: tableEntries.length
+      }
+    };
+    for (const { tableName, size } of tableEntries) {
+      const location = hotTableNames.includes(tableName) ? "hot" : "cold";
+      const file = location === "hot" ? "hot-schemas.json" : `cold/${this.getFileForTable(tableName)}`;
+      index.tables[tableName] = {
+        location,
+        file,
+        estimatedSize: size,
+        lastModified: new Date().toISOString()
+      };
+    }
+    return index;
+  }
+  static async saveIndex(dbcliPath, index, connectionName) {
+    try {
+      const schemasDir = resolveSchemaPath(dbcliPath, connectionName);
+      await this.ensureDir(schemasDir);
+      const indexPath = join4(schemasDir, "index.json");
+      const indexFile = Bun.file(indexPath);
+      await indexFile.write(JSON.stringify(index, null, 2));
+    } catch (error) {
+      throw new Error(`Failed to save schema index: ${error}`);
+    }
+  }
+  static calculateFileMapping(index) {
+    const mapping = {
+      hot: [],
+      cold: []
+    };
+    for (const [tableName, tableInfo] of Object.entries(index.tables)) {
+      mapping[tableInfo.location].push({
+        table: tableName,
+        file: tableInfo.file
+      });
+    }
+    return mapping;
+  }
+  static async ensureDir(dirPath) {
+    const { mkdirSync } = await import("fs");
+    try {
+      mkdirSync(dirPath, { recursive: true });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw new Error(`Failed to ensure directory ${dirPath}: ${error}`);
+      }
+    }
+  }
+  static getFileForTable(tableName) {
+    if (/^(old_|legacy_|archive_)/.test(tableName)) {
+      return "legacy.json";
+    }
+    return "infrequent.json";
+  }
+}
+var init_schema_index = __esm(() => {
+  init_schema_path();
+});
+
+// src/core/schema-loader.ts
+var exports_schema_loader = {};
+__export(exports_schema_loader, {
+  SchemaLayeredLoader: () => SchemaLayeredLoader2
+});
+import { join as join5 } from "path";
+
+class SchemaLayeredLoader2 {
+  dbcliPath;
+  connectionName;
+  options;
+  cache = null;
+  index = null;
+  loadTime = 0;
+  constructor(dbcliPath, options) {
+    this.dbcliPath = dbcliPath;
+    this.connectionName = options?.connectionName;
+    this.options = {
+      maxCacheItems: options?.maxCacheItems || 100,
+      maxCacheSize: options?.maxCacheSize || 52428800,
+      hotTableThreshold: options?.hotTableThreshold || 20,
+      enableStreaming: options?.enableStreaming || false,
+      streamingTimeout: options?.streamingTimeout || 30000
+    };
+  }
+  async initialize() {
+    const startTime = performance.now();
+    try {
+      await this.ensureDirectories();
+      this.index = await SchemaIndexBuilder.loadIndex(this.dbcliPath, this.connectionName);
+      this.cache = new SchemaCacheManager(this.dbcliPath, {
+        maxCacheItems: this.options.maxCacheItems,
+        maxCacheSize: this.options.maxCacheSize,
+        connectionName: this.connectionName
+      });
+      await this.cache.initialize();
+      this.loadTime = performance.now() - startTime;
+      if (this.loadTime > 50) {
+        console.warn(`Schema initialization took ${this.loadTime.toFixed(2)}ms (target: < 100ms)`);
+      }
+      return {
+        cache: this.cache,
+        index: this.index,
+        loadTime: this.loadTime
+      };
+    } catch (error) {
+      console.error("Failed to initialize schema loader:", error);
+      this.loadTime = performance.now() - startTime;
+      if (!this.cache) {
+        this.cache = new SchemaCacheManager(this.dbcliPath, {
+          maxCacheItems: this.options.maxCacheItems,
+          maxCacheSize: this.options.maxCacheSize,
+          connectionName: this.connectionName
+        });
+      }
+      return {
+        cache: this.cache,
+        index: this.index,
+        loadTime: this.loadTime
+      };
+    }
+  }
+  async loadColdTable(tableName, cache) {
+    try {
+      return await cache.getTableSchema(tableName);
+    } catch (error) {
+      console.error(`Failed to load cold table ${tableName}:`, error);
+      return null;
+    }
+  }
+  async ensureDirectories() {
+    const base = resolveSchemaPath(this.dbcliPath, this.connectionName);
+    const dirs = [base, join5(base, "cold")];
+    for (const dir of dirs) {
+      try {
+        const dirFile = Bun.file(dir);
+        if (!await dirFile.exists()) {
+          const proc = Bun.spawn(["mkdir", "-p", dir]);
+          const exitCode = await proc.exited;
+          if (exitCode !== 0) {
+            console.error(`Failed to create directory: ${dir}`);
+          }
+        }
+      } catch (error) {
+        console.error(`Error ensuring directory ${dir}:`, error);
+      }
+    }
+  }
+  getBenchmark() {
+    if (!this.cache || !this.index) {
+      return {
+        initTime: this.loadTime,
+        hotTables: 0,
+        totalTables: 0,
+        estimatedSize: 0
+      };
+    }
+    const estimatedSize = Object.values(this.index.tables).reduce((sum, table) => sum + (table.estimatedSize || 0), 0);
+    return {
+      initTime: this.loadTime,
+      hotTables: this.index.hotTables.length,
+      totalTables: this.index.metadata.totalTables,
+      estimatedSize
+    };
+  }
+}
+var init_schema_loader = __esm(() => {
+  init_schema_cache();
+  init_schema_index();
+  init_schema_path();
 });
 
 // node_modules/@inquirer/core/dist/esm/lib/key.mjs
@@ -6427,7 +7870,7 @@ function isUnicodeSupported() {
   return Boolean(process2.env["WT_SESSION"]) || Boolean(process2.env["TERMINUS_SUBLIME"]) || process2.env["ConEmuTask"] === "{cmd::Cmder}" || process2.env["TERM_PROGRAM"] === "Terminus-Sublime" || process2.env["TERM_PROGRAM"] === "vscode" || process2.env["TERM"] === "xterm-256color" || process2.env["TERM"] === "alacritty" || process2.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
 }
 var common, specialMainSymbols, specialFallbackSymbols, mainSymbols, fallbackSymbols, shouldUseMain, figures, esm_default, replacements;
-var init_esm = __esm(() => {
+var init_esm2 = __esm(() => {
   common = {
     circleQuestionMark: "(?)",
     questionMarkPrefix: "(?)",
@@ -6713,7 +8156,7 @@ var init_esm = __esm(() => {
 // node_modules/@inquirer/core/dist/esm/lib/theme.mjs
 var import_yoctocolors_cjs, defaultTheme;
 var init_theme = __esm(() => {
-  init_esm();
+  init_esm2();
   import_yoctocolors_cjs = __toESM(require_yoctocolors_cjs(), 1);
   defaultTheme = {
     prefix: {
@@ -8925,12 +10368,12 @@ class Separator {
 }
 var import_yoctocolors_cjs2;
 var init_Separator = __esm(() => {
-  init_esm();
+  init_esm2();
   import_yoctocolors_cjs2 = __toESM(require_yoctocolors_cjs(), 1);
 });
 
 // node_modules/@inquirer/core/dist/esm/index.mjs
-var init_esm2 = __esm(() => {
+var init_esm3 = __esm(() => {
   init_use_prefix();
   init_use_state();
   init_use_effect();
@@ -8984,10 +10427,10 @@ function normalizeChoices(choices) {
   });
 }
 var import_yoctocolors_cjs3, import_ansi_escapes2, checkboxTheme, esm_default2;
-var init_esm3 = __esm(() => {
-  init_esm2();
-  init_esm();
+var init_esm4 = __esm(() => {
+  init_esm3();
   init_esm2();
+  init_esm3();
   import_yoctocolors_cjs3 = __toESM(require_yoctocolors_cjs(), 1);
   import_ansi_escapes2 = __toESM(require_ansi_escapes(), 1);
   checkboxTheme = {
@@ -18489,8 +19932,8 @@ var require_main = __commonJS((exports) => {
 // node_modules/@inquirer/editor/dist/esm/index.mjs
 import { AsyncResource as AsyncResource4 } from "async_hooks";
 var import_external_editor, esm_default3;
-var init_esm4 = __esm(() => {
-  init_esm2();
+var init_esm5 = __esm(() => {
+  init_esm3();
   import_external_editor = __toESM(require_main(), 1);
   esm_default3 = createPrompt((config, done) => {
     const { waitForUseInput = true, postfix = ".txt", validate = () => true } = config;
@@ -18553,8 +19996,8 @@ var init_esm4 = __esm(() => {
 
 // node_modules/@inquirer/confirm/dist/esm/index.mjs
 var esm_default4;
-var init_esm5 = __esm(() => {
-  init_esm2();
+var init_esm6 = __esm(() => {
+  init_esm3();
   esm_default4 = createPrompt((config, done) => {
     const { transformer = (answer) => answer ? "yes" : "no" } = config;
     const [status, setStatus] = useState("pending");
@@ -18589,8 +20032,8 @@ var init_esm5 = __esm(() => {
 
 // node_modules/@inquirer/input/dist/esm/index.mjs
 var esm_default5;
-var init_esm6 = __esm(() => {
-  init_esm2();
+var init_esm7 = __esm(() => {
+  init_esm3();
   esm_default5 = createPrompt((config, done) => {
     const { required, validate = () => true } = config;
     const theme = makeTheme(config.theme);
@@ -18669,8 +20112,8 @@ function validateNumber(value, { min, max, step }) {
   return true;
 }
 var esm_default6;
-var init_esm7 = __esm(() => {
-  init_esm2();
+var init_esm8 = __esm(() => {
+  init_esm3();
   esm_default6 = createPrompt((config, done) => {
     const { validate = () => true, min = -Infinity, max = Infinity, step = 1, required = false } = config;
     const theme = makeTheme(config.theme);
@@ -18753,8 +20196,8 @@ function normalizeChoices2(choices) {
   });
 }
 var import_yoctocolors_cjs4, helpChoice, esm_default7;
-var init_esm8 = __esm(() => {
-  init_esm2();
+var init_esm9 = __esm(() => {
+  init_esm3();
   import_yoctocolors_cjs4 = __toESM(require_yoctocolors_cjs(), 1);
   helpChoice = {
     key: "h",
@@ -18867,8 +20310,8 @@ function normalizeChoices3(choices) {
   });
 }
 var import_yoctocolors_cjs5, numberRegex, esm_default8;
-var init_esm9 = __esm(() => {
-  init_esm2();
+var init_esm10 = __esm(() => {
+  init_esm3();
   import_yoctocolors_cjs5 = __toESM(require_yoctocolors_cjs(), 1);
   numberRegex = /\d+/;
   esm_default8 = createPrompt((config, done) => {
@@ -18930,8 +20373,8 @@ var init_esm9 = __esm(() => {
 
 // node_modules/@inquirer/password/dist/esm/index.mjs
 var import_ansi_escapes3, esm_default9;
-var init_esm10 = __esm(() => {
-  init_esm2();
+var init_esm11 = __esm(() => {
+  init_esm3();
   import_ansi_escapes3 = __toESM(require_ansi_escapes(), 1);
   esm_default9 = createPrompt((config, done) => {
     const { validate = () => true } = config;
@@ -19010,9 +20453,9 @@ function normalizeChoices4(choices) {
   });
 }
 var import_yoctocolors_cjs6, searchTheme, esm_default10;
-var init_esm11 = __esm(() => {
+var init_esm12 = __esm(() => {
+  init_esm3();
   init_esm2();
-  init_esm();
   import_yoctocolors_cjs6 = __toESM(require_yoctocolors_cjs(), 1);
   searchTheme = {
     icon: { cursor: esm_default.pointer },
@@ -19179,9 +20622,9 @@ function normalizeChoices5(choices) {
   });
 }
 var import_yoctocolors_cjs7, import_ansi_escapes4, selectTheme, esm_default11;
-var init_esm12 = __esm(() => {
+var init_esm13 = __esm(() => {
+  init_esm3();
   init_esm2();
-  init_esm();
   import_yoctocolors_cjs7 = __toESM(require_yoctocolors_cjs(), 1);
   import_ansi_escapes4 = __toESM(require_ansi_escapes(), 1);
   selectTheme = {
@@ -19312,8 +20755,7 @@ __export(exports_esm, {
   checkbox: () => esm_default2,
   Separator: () => Separator
 });
-var init_esm13 = __esm(() => {
-  init_esm3();
+var init_esm14 = __esm(() => {
   init_esm4();
   init_esm5();
   init_esm6();
@@ -19323,6 +20765,7 @@ var init_esm13 = __esm(() => {
   init_esm10();
   init_esm11();
   init_esm12();
+  init_esm13();
 });
 
 // node_modules/postgres-array/index.js
@@ -43012,7 +44455,7 @@ var require_named_placeholders = __commonJS((exports, module) => {
       }
       return s;
     }
-    function join3(tree) {
+    function join7(tree) {
       if (tree.length === 1) {
         return tree;
       }
@@ -43038,7 +44481,7 @@ var require_named_placeholders = __commonJS((exports, module) => {
       if (cache && (tree = cache.get(query))) {
         return toArrayParams(tree, paramsObj);
       }
-      tree = join3(parse(query));
+      tree = join7(parse(query));
       if (cache) {
         cache.set(query, tree);
       }
@@ -46864,7 +48307,7 @@ var {
 // package.json
 var package_default = {
   name: "@carllee1983/dbcli",
-  version: "1.2.1",
+  version: "1.4.1",
   description: "Database CLI for AI agents",
   type: "module",
   publishConfig: {
@@ -47066,9 +48509,27 @@ Hint: run 'export {envKey}=<value>' and retry`
     formats: "Supported formats: json, csv",
     exported: "Exported {count} rows to {file}"
   },
+  upgrade: {
+    description: "Check for updates and upgrade dbcli to the latest version",
+    checking: "Checking for updates...",
+    already_up_to_date: "\u2713 Already up to date (v{version})",
+    new_version_available: "New version available: v{version}",
+    current_version: "Current version : v{version}",
+    latest_version: "Latest version  : v{version}",
+    update_hint: '[INFO] dbcli v{version} available. Run "dbcli upgrade" to upgrade.',
+    install_hint: 'Run "dbcli upgrade" to install the update.',
+    upgrading: "Upgrading...",
+    success: "\u2713 Successfully upgraded to v{version}",
+    skill_recheck_hint: 'Hint: If you have installed AI skills, run "dbcli skill --install <platform>" to ensure they are up to date.',
+    failed: "\u2717 Upgrade failed. Try running manually:",
+    manual_hint: "bun add -g @carllee1983/dbcli@latest",
+    network_error: "\u26A0 Could not check for updates (network error or registry unavailable)"
+  },
   skill: {
     description: "Generate AI skill documentation",
-    installed: "Skill installed to {path}"
+    installed: "Skill installed to {path}",
+    update_available: "Skill updates available for the following platforms:",
+    update_hint: 'Run "dbcli skill --install <platform>" to update.'
   },
   blacklist: {
     description: "Manage sensitive data blacklist to prevent AI access",
@@ -47238,9 +48699,27 @@ var messages_default2 = {
     formats: "\u652F\u63F4\u7684\u683C\u5F0F\uFF1Ajson\u3001csv",
     exported: "\u5DF2\u5C07 {count} \u5217\u532F\u51FA\u81F3 {file}"
   },
+  upgrade: {
+    description: "\u6AA2\u67E5\u66F4\u65B0\u4E26\u5C07 dbcli \u5347\u7D1A\u81F3\u6700\u65B0\u7248\u672C",
+    checking: "\u6B63\u5728\u6AA2\u67E5\u66F4\u65B0...",
+    already_up_to_date: "\u2713 \u5DF2\u7D93\u662F\u6700\u65B0\u7248\u672C (v{version})",
+    new_version_available: "\u767C\u73FE\u65B0\u7248\u672C\uFF1Av{version}",
+    current_version: "\u76EE\u524D\u7248\u672C\uFF1Av{version}",
+    latest_version: "\u6700\u65B0\u7248\u672C\uFF1Av{version}",
+    update_hint: '[\u63D0\u793A] dbcli v{version} \u5DF2\u767C\u5E03\u3002\u57F7\u884C "dbcli upgrade" \u9032\u884C\u5347\u7D1A\u3002',
+    install_hint: '\u57F7\u884C "dbcli upgrade" \u5B89\u88DD\u66F4\u65B0\u3002',
+    upgrading: "\u6B63\u5728\u5347\u7D1A...",
+    success: "\u2713 \u6210\u529F\u5347\u7D1A\u81F3 v{version}",
+    skill_recheck_hint: '\u63D0\u793A\uFF1A\u82E5\u5DF2\u5B89\u88DD AI \u6280\u80FD\uFF0C\u8ACB\u57F7\u884C "dbcli skill --install <platform>" \u78BA\u8A8D\u6280\u80FD\u70BA\u6700\u65B0\u7248\u672C\u3002',
+    failed: "\u2717 \u5347\u7D1A\u5931\u6557\u3002\u8ACB\u5617\u8A66\u624B\u52D5\u57F7\u884C\uFF1A",
+    manual_hint: "bun add -g @carllee1983/dbcli@latest",
+    network_error: "\u26A0 \u7121\u6CD5\u6AA2\u67E5\u66F4\u65B0\uFF08\u7DB2\u8DEF\u932F\u8AA4\u6216\u8A3B\u518A\u8868\u4E0D\u53EF\u7528\uFF09"
+  },
   skill: {
     description: "\u751F\u6210 AI \u6280\u80FD\u6587\u6A94",
-    installed: "\u6280\u80FD\u5DF2\u5B89\u88DD\u81F3 {path}"
+    installed: "\u6280\u80FD\u5DF2\u5B89\u88DD\u81F3 {path}",
+    update_available: "\u4EE5\u4E0B\u5E73\u53F0\u7684\u6280\u80FD\u9700\u8981\u66F4\u65B0\uFF1A",
+    update_hint: '\u57F7\u884C "dbcli skill --install <platform>" \u9032\u884C\u66F4\u65B0\u3002'
   },
   blacklist: {
     description: "\u7BA1\u7406\u654F\u611F\u8CC7\u6599\u9ED1\u540D\u55AE\u4EE5\u9632\u6B62 AI \u5B58\u53D6",
@@ -47444,7 +48923,7 @@ function getLogger() {
 }
 
 // src/commands/init.ts
-import { join as join3 } from "path";
+import { join as join7 } from "path";
 
 // src/utils/errors.ts
 class EnvParseError extends Error {
@@ -47631,13 +49110,51 @@ async function writeV2Config(path, config) {
   const json = JSON.stringify(config, null, 2);
   await Bun.write(configPath, json);
 }
+async function patchConnectionSchema(dbcliPath, connectionName, schema, metadataUpdate) {
+  const v2Config = await readV2Config(dbcliPath);
+  const updated = {
+    ...v2Config,
+    schemas: {
+      ...v2Config.schemas,
+      [connectionName]: schema
+    },
+    metadata: {
+      ...v2Config.metadata,
+      ...metadataUpdate ?? {}
+    }
+  };
+  await writeV2Config(dbcliPath, updated);
+}
 
 // src/core/config.ts
-import { join as join2 } from "path";
+import { join as join6 } from "path";
 var _globalConnectionName;
 function setGlobalConnectionName(name) {
   _globalConnectionName = name;
 }
+function getGlobalConnectionName() {
+  return _globalConnectionName;
+}
+async function getSchemaIsolationConnectionName(dbcliPath) {
+  const effectiveName = getGlobalConnectionName();
+  try {
+    const stat = await Bun.file(dbcliPath).stat();
+    const isDirectory = stat?.isDirectory() ?? false;
+    if (!isDirectory)
+      return;
+    const configJsonPath = join6(dbcliPath, "config.json");
+    const configFile = Bun.file(configJsonPath);
+    if (!await configFile.exists())
+      return;
+    const raw = JSON.parse(await configFile.text());
+    if (detectConfigVersion(raw) !== 2)
+      return;
+    const v2Config = DbcliConfigV2Schema.parse(raw);
+    return resolveConnection(v2Config, effectiveName).name;
+  } catch {
+    return;
+  }
+}
 var DEFAULT_CONFIG = {
   connection: {
     system: "postgresql",
@@ -47705,7 +49222,7 @@ var configModule = {
         isDirectory = false;
       }
       if (isDirectory) {
-        const configPath = join2(path, "config.json");
+        const configPath = join6(path, "config.json");
         const configFile = Bun.file(configPath);
         const configExists = await configFile.exists();
         if (configExists) {
@@ -47715,7 +49232,7 @@ var configModule = {
             const v2Config = DbcliConfigV2Schema.parse(config);
             const resolved = resolveConnection(v2Config, effectiveConnectionName);
             await loadConnectionEnv(resolved, path);
-            const envLocalPath = join2(path, ".env.local");
+            const envLocalPath = join6(path, ".env.local");
             const envLocalFile = Bun.file(envLocalPath);
             let legacyPassword = null;
             if (await envLocalFile.exists()) {
@@ -47729,16 +49246,35 @@ var configModule = {
             if (!resolvedConnection.password && legacyPassword) {
               resolvedConnection.password = legacyPassword;
             }
+            let schema = (v2Config.schemas ?? {})[resolved.name] ?? v2Config.schema;
+            try {
+              const { SchemaLayeredLoader: SchemaLayeredLoader3 } = await Promise.resolve().then(() => (init_schema_loader(), exports_schema_loader));
+              const loader = new SchemaLayeredLoader3(path, { connectionName: resolved.name });
+              const { cache, index } = await loader.initialize();
+              if (index && Object.keys(index.tables).length > 0) {
+                const layeredSchema = {};
+                for (const tableName of Object.keys(index.tables)) {
+                  const s = await cache.getTableSchema(tableName);
+                  if (s)
+                    layeredSchema[tableName] = s;
+                }
+                if (Object.keys(layeredSchema).length > 0) {
+                  schema = layeredSchema;
+                }
+              }
+            } catch (error) {
+              console.warn("Warning: Failed to load layered schema cache, falling back to config.json");
+            }
             return DbcliConfigSchema.parse({
               connection: resolvedConnection,
               permission: resolved.permission,
-              schema: v2Config.schema,
+              schema,
               metadata: v2Config.metadata,
               blacklist: v2Config.blacklist
             });
           }
           const resolvedConfig = resolveEnvReferences(config, process.env, undefined, false);
-          const envPath = join2(path, ".env.local");
+          const envPath = join6(path, ".env.local");
           const envFile = Bun.file(envPath);
           if (await envFile.exists()) {
             const envContent = await envFile.text();
@@ -47805,7 +49341,7 @@ var configModule = {
       if (isDirectory || path.endsWith(".dbcli")) {
         const hasEnvReferences = isEnvReference(config.connection.password);
         if (hasEnvReferences) {
-          const configPath = join2(path, "config.json");
+          const configPath = join6(path, "config.json");
           const configJson = JSON.stringify(config, null, 2);
           await Bun.file(configPath).write(configJson);
         } else {
@@ -47818,11 +49354,11 @@ var configModule = {
             }
           };
           delete configWithoutPassword.connection.password;
-          const configPath = join2(path, "config.json");
+          const configPath = join6(path, "config.json");
           const configJson = JSON.stringify(configWithoutPassword, null, 2);
           await Bun.file(configPath).write(configJson);
           if (password) {
-            const envPath = join2(path, ".env.local");
+            const envPath = join6(path, ".env.local");
             const envContent = `# Database Credentials - DO NOT commit to git
 
 DBCLI_PASSWORD=${password}
@@ -47879,7 +49415,7 @@ async function text(message, defaultValue) {
     return answer.trim() || defaultValue || "";
   }
   try {
-    const { text: inquirerText } = await Promise.resolve().then(() => (init_esm13(), exports_esm));
+    const { text: inquirerText } = await Promise.resolve().then(() => (init_esm14(), exports_esm));
     return await inquirerText({ message, default: defaultValue });
   } catch {
     const displayMessage = defaultValue ? `${message} [${defaultValue}]: ` : `${message}: `;
@@ -47901,7 +49437,7 @@ async function select(message, choices) {
     return choices[0];
   }
   try {
-    const { select: inquirerSelect } = await Promise.resolve().then(() => (init_esm13(), exports_esm));
+    const { select: inquirerSelect } = await Promise.resolve().then(() => (init_esm14(), exports_esm));
     return await inquirerSelect({ message, choices });
   } catch {
     console.log(message);
@@ -47922,7 +49458,7 @@ async function confirm(message) {
     return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
   }
   try {
-    const { confirm: inquirerConfirm } = await Promise.resolve().then(() => (init_esm13(), exports_esm));
+    const { confirm: inquirerConfirm } = await Promise.resolve().then(() => (init_esm14(), exports_esm));
     return await inquirerConfirm({ message });
   } catch {
     const answer = await readLineFromStdin(`${message} (y/n): `);
@@ -48618,7 +50154,7 @@ class AdapterFactory {
 var VALID_PERMISSIONS = ["query-only", "read-write", "data-admin", "admin"];
 async function checkOverwrite(configPath, shouldPrompt, force) {
   const fileExists = await Bun.file(configPath).exists();
-  const dirConfigExists = await Bun.file(join3(configPath, "config.json")).exists();
+  const dirConfigExists = await Bun.file(join7(configPath, "config.json")).exists();
   if (!fileExists && !dirConfigExists || force)
     return true;
   if (shouldPrompt) {
@@ -48632,7 +50168,7 @@ async function checkOverwrite(configPath, shouldPrompt, force) {
   throw new Error(t("init.config_exists_use_force"));
 }
 async function handleRemove(configPath, name) {
-  const configFile = Bun.file(join3(configPath, "config.json"));
+  const configFile = Bun.file(join7(configPath, "config.json"));
   if (!await configFile.exists()) {
     throw new Error(t("init.config_not_found"));
   }
@@ -48667,7 +50203,7 @@ async function handleRename(configPath, renameArg) {
   if (!oldName || !newName) {
     throw new Error(t("init.rename_invalid_format"));
   }
-  const configFile = Bun.file(join3(configPath, "config.json"));
+  const configFile = Bun.file(join7(configPath, "config.json"));
   if (!await configFile.exists()) {
     throw new Error(t("init.config_not_found"));
   }
@@ -48692,7 +50228,7 @@ async function handleRename(configPath, renameArg) {
   console.log(t_vars("init.connection_renamed", { oldName, newName }));
 }
 async function writeV2InitConfig(configPath, connectionName, connection, permission, envFile) {
-  const configJsonPath = join3(configPath, "config.json");
+  const configJsonPath = join7(configPath, "config.json");
   const configFile = Bun.file(configJsonPath);
   let existingV2 = null;
   if (await configFile.exists()) {
@@ -49266,6 +50802,582 @@ class SchemaDiffEngine {
   }
 }
 
+// src/core/index.ts
+init_schema_loader();
+init_schema_index();
+init_schema_cache();
+
+// src/core/schema-writer.ts
+init_schema_index();
+import { join as join8 } from "path";
+
+// src/core/atomic-writer.ts
+class AtomicFileWriter {
+  async write(filePath, content, options) {
+    const startTime = Date.now();
+    const timeout = options?.timeout || 5000;
+    const createBackup = options?.createBackup ?? true;
+    const timestamp = Date.now();
+    const tempPath = `${filePath}.${timestamp}.tmp`;
+    const backupPath = `${filePath}.backup.${timestamp}`;
+    let backupCreated = false;
+    let tempFileCreated = false;
+    try {
+      this.checkTimeout(startTime, timeout, "write initialization");
+      const buffer = typeof content === "string" ? Buffer.from(content, "utf-8") : content;
+      const tempFile = Bun.file(tempPath);
+      await Bun.write(tempFile, buffer);
+      tempFileCreated = true;
+      this.checkTimeout(startTime, timeout, "temp file write");
+      if (createBackup) {
+        const originalFile = Bun.file(filePath);
+        if (await originalFile.exists()) {
+          const originalContent = await originalFile.arrayBuffer();
+          const backupFile = Bun.file(backupPath);
+          await Bun.write(backupFile, originalContent);
+          backupCreated = true;
+        }
+      }
+      this.checkTimeout(startTime, timeout, "backup creation");
+      const moveResult = await Bun.spawn(["mv", tempPath, filePath]).exited;
+      if (moveResult !== 0) {
+        throw new Error(`Atomic rename failed with exit code ${moveResult}`);
+      }
+      tempFileCreated = false;
+      const writtenFile = Bun.file(filePath);
+      const written = await writtenFile.exists();
+      if (!written) {
+        throw new Error("Verification failed: file not found after write");
+      }
+      const sizeBytes = writtenFile.size || buffer.length;
+      return {
+        filePath,
+        sizeBytes,
+        timestamp: new Date().toISOString(),
+        backupCreated,
+        backupPath: backupCreated ? backupPath : undefined
+      };
+    } catch (error) {
+      await this.cleanup(tempPath, tempFileCreated);
+      throw new Error(`Atomic write failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async writeJSON(filePath, data, options) {
+    const jsonContent = JSON.stringify(data, null, 2);
+    return this.write(filePath, jsonContent, options);
+  }
+  async read(filePath, timeout = 5000) {
+    const startTime = Date.now();
+    this.checkTimeout(startTime, timeout, "read start");
+    const file = Bun.file(filePath);
+    if (!await file.exists()) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    this.checkTimeout(startTime, timeout, "file existence check");
+    return await file.text();
+  }
+  async backup(filePath) {
+    const file = Bun.file(filePath);
+    if (!await file.exists()) {
+      return null;
+    }
+    const timestamp = Date.now();
+    const backupPath = `${filePath}.backup.${timestamp}`;
+    const content = await file.arrayBuffer();
+    const backupFile = Bun.file(backupPath);
+    await Bun.write(backupFile, content);
+    return backupPath;
+  }
+  async restore(backupPath, targetPath) {
+    try {
+      const backupFile = Bun.file(backupPath);
+      if (!await backupFile.exists()) {
+        throw new Error(`Backup file not found: ${backupPath}`);
+      }
+      const content = await backupFile.arrayBuffer();
+      const result = await this.write(targetPath, Buffer.from(content), {
+        createBackup: false
+      });
+      return !!result;
+    } catch (error) {
+      throw new Error(`File restore failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  checkTimeout(startTime, timeout, stage) {
+    const elapsed = Date.now() - startTime;
+    if (elapsed > timeout) {
+      throw new Error(`Operation timeout exceeded at ${stage}: ${elapsed}ms > ${timeout}ms`);
+    }
+  }
+  async cleanup(tempPath, tempExists) {
+    if (!tempExists)
+      return;
+    try {
+      const tempFile = Bun.file(tempPath);
+      if (await tempFile.exists()) {
+        await Bun.spawn(["rm", "-f", tempPath]).exited;
+      }
+    } catch (error) {
+      console.error(`Cleanup failed for temp file ${tempPath}:`, error);
+    }
+  }
+}
+
+// src/core/schema-writer.ts
+init_schema_path();
+
+class SchemaWriter {
+  dbcliPath;
+  writer;
+  constructor(dbcliPath) {
+    this.dbcliPath = dbcliPath;
+    this.writer = new AtomicFileWriter;
+  }
+  async save(schema, connectionName) {
+    const schemaRoot = resolveSchemaPath(this.dbcliPath, connectionName);
+    const index = await SchemaIndexBuilder.buildIndex({ schema });
+    await SchemaIndexBuilder.saveIndex(this.dbcliPath, index, connectionName);
+    const mapping = SchemaIndexBuilder.calculateFileMapping(index);
+    const hotSchemas = {};
+    for (const item of mapping.hot) {
+      hotSchemas[item.table] = schema[item.table];
+    }
+    await this.writer.writeJSON(join8(schemaRoot, "hot-schemas.json"), hotSchemas);
+    const coldGroups = {};
+    for (const item of mapping.cold) {
+      if (!coldGroups[item.file]) {
+        coldGroups[item.file] = {};
+      }
+      coldGroups[item.file][item.table] = schema[item.table];
+    }
+    const coldDir = join8(schemaRoot, "cold");
+    await this.ensureDir(coldDir);
+    for (const [fileName, tables] of Object.entries(coldGroups)) {
+      const filePath = join8(schemaRoot, fileName);
+      await this.writer.writeJSON(filePath, tables);
+    }
+  }
+  async clear(connectionName) {
+    const schemaRoot = resolveSchemaPath(this.dbcliPath, connectionName);
+    try {
+      const dir = Bun.file(schemaRoot);
+      const s = await dir.stat();
+      if (s.isDirectory()) {
+        await Bun.spawn(["rm", "-rf", schemaRoot]).exited;
+      }
+    } catch {}
+  }
+  async ensureDir(path) {
+    const { mkdirSync } = await import("fs");
+    try {
+      mkdirSync(path, { recursive: true });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw new Error(`Error ensuring directory ${path}: ${error}`);
+      }
+    }
+  }
+}
+// src/core/column-index.ts
+class ColumnIndexBuilder {
+  index = {
+    columns: new Map,
+    totalColumns: 0,
+    totalTables: 0,
+    timestamp: new Date().toISOString()
+  };
+  build(schemas) {
+    this.index = {
+      columns: new Map,
+      totalColumns: 0,
+      totalTables: Object.keys(schemas).length,
+      timestamp: new Date().toISOString()
+    };
+    for (const [tableName, table] of Object.entries(schemas)) {
+      for (const column of table.columns) {
+        this.addColumnEntry(tableName, column);
+      }
+    }
+    return this.index;
+  }
+  addColumnEntry(tableName, column) {
+    const colName = column.name.toLowerCase();
+    if (!this.index.columns.has(colName)) {
+      this.index.columns.set(colName, {
+        name: column.name,
+        tables: []
+      });
+      this.index.totalColumns++;
+    }
+    const entry = this.index.columns.get(colName);
+    entry.tables.push({
+      tableName,
+      column
+    });
+  }
+  findColumn(columnName) {
+    const entry = this.index.columns.get(columnName.toLowerCase());
+    return entry?.tables || [];
+  }
+  findColumnsMatching(pattern) {
+    const regex = typeof pattern === "string" ? new RegExp(pattern, "i") : pattern;
+    const results = [];
+    for (const [colName, entry] of this.index.columns.entries()) {
+      if (regex.test(entry.name)) {
+        results.push({
+          columnName: entry.name,
+          tables: entry.tables
+        });
+      }
+    }
+    return results;
+  }
+  getTableColumns(tableName) {
+    const results = [];
+    for (const entry of this.index.columns.values()) {
+      const tableEntry = entry.tables.find((t2) => t2.tableName === tableName);
+      if (tableEntry) {
+        results.push(tableEntry.column);
+      }
+    }
+    return results;
+  }
+  findColumnsByType(type) {
+    const results = [];
+    const typePattern = new RegExp(type, "i");
+    for (const entry of this.index.columns.values()) {
+      for (const tableEntry of entry.tables) {
+        if (typePattern.test(tableEntry.column.type)) {
+          results.push(tableEntry);
+        }
+      }
+    }
+    return results;
+  }
+  findPrimaryKeys() {
+    const results = [];
+    for (const entry of this.index.columns.values()) {
+      for (const tableEntry of entry.tables) {
+        if (tableEntry.column.primaryKey) {
+          results.push(tableEntry);
+        }
+      }
+    }
+    return results;
+  }
+  findNullableColumns() {
+    const results = [];
+    for (const entry of this.index.columns.values()) {
+      for (const tableEntry of entry.tables) {
+        if (tableEntry.column.nullable) {
+          results.push(tableEntry);
+        }
+      }
+    }
+    return results;
+  }
+  getStats() {
+    return {
+      totalColumns: this.index.totalColumns,
+      totalTables: this.index.totalTables,
+      uniqueColumnNames: this.index.columns.size,
+      averageTablesPerColumn: this.index.columns.size > 0 ? Array.from(this.index.columns.values()).reduce((sum, entry) => sum + entry.tables.length, 0) / this.index.columns.size : 0,
+      timestamp: this.index.timestamp
+    };
+  }
+  export() {
+    const serialized = {
+      columns: Array.from(this.index.columns.entries()).reduce((acc, [key2, value]) => {
+        acc[key2] = value;
+        return acc;
+      }, {}),
+      totalColumns: this.index.totalColumns,
+      totalTables: this.index.totalTables,
+      timestamp: this.index.timestamp
+    };
+    return serialized;
+  }
+  import(exported) {
+    this.index = {
+      columns: new Map(Object.entries(exported.columns)),
+      totalColumns: exported.totalColumns,
+      totalTables: exported.totalTables,
+      timestamp: exported.timestamp
+    };
+  }
+}
+// src/core/blacklist-manager.ts
+class BlacklistManager {
+  config;
+  state;
+  overrideEnabled;
+  constructor(config, overrideEnvValue) {
+    this.config = config;
+    this.overrideEnabled = (overrideEnvValue ?? Bun.env.DBCLI_OVERRIDE_BLACKLIST ?? "") === "true";
+    this.state = this.loadBlacklist();
+  }
+  loadBlacklist() {
+    const tables = new Set;
+    const columns = new Map;
+    const blacklistConfig = this.config.blacklist;
+    if (!blacklistConfig) {
+      return { tables, columns };
+    }
+    if (Array.isArray(blacklistConfig.tables)) {
+      for (const tableName of blacklistConfig.tables) {
+        if (typeof tableName === "string") {
+          tables.add(tableName.toLowerCase());
+        } else {
+          console.warn(`[BlacklistManager] Invalid table name in blacklist config: ${JSON.stringify(tableName)}`);
+        }
+      }
+    } else if (blacklistConfig.tables !== undefined) {
+      console.warn("[BlacklistManager] blacklist.tables must be an array, ignoring");
+    }
+    if (blacklistConfig.columns && typeof blacklistConfig.columns === "object" && !Array.isArray(blacklistConfig.columns)) {
+      for (const [tableName, cols] of Object.entries(blacklistConfig.columns)) {
+        if (typeof tableName !== "string") {
+          console.warn(`[BlacklistManager] Invalid table name key in columns config: ${JSON.stringify(tableName)}`);
+          continue;
+        }
+        if (!Array.isArray(cols)) {
+          console.warn(`[BlacklistManager] blacklist.columns["${tableName}"] must be an array, ignoring`);
+          continue;
+        }
+        const columnSet = new Set;
+        for (const col of cols) {
+          if (typeof col === "string") {
+            columnSet.add(col);
+          } else {
+            console.warn(`[BlacklistManager] Invalid column name in blacklist.columns["${tableName}"]: ${JSON.stringify(col)}`);
+          }
+        }
+        if (columnSet.size > 0) {
+          columns.set(tableName, columnSet);
+        }
+      }
+    } else if (blacklistConfig.columns !== undefined) {
+      console.warn("[BlacklistManager] blacklist.columns must be an object, ignoring");
+    }
+    return { tables, columns };
+  }
+  isTableBlacklisted(tableName) {
+    return this.state.tables.has(tableName.toLowerCase());
+  }
+  isColumnBlacklisted(tableName, columnName) {
+    const columnSet = this.state.columns.get(tableName);
+    if (!columnSet) {
+      return false;
+    }
+    return columnSet.has(columnName);
+  }
+  getBlacklistedColumns(tableName) {
+    const columnSet = this.state.columns.get(tableName);
+    if (!columnSet) {
+      return [];
+    }
+    return Array.from(columnSet);
+  }
+  canOverrideBlacklist() {
+    return this.overrideEnabled;
+  }
+  getState() {
+    return this.state;
+  }
+}
+// src/types/blacklist.ts
+class BlacklistError extends Error {
+  tableName;
+  operation;
+  constructor(message, tableName, operation) {
+    super(message);
+    this.tableName = tableName;
+    this.operation = operation;
+    this.name = "BlacklistError";
+  }
+}
+
+// src/core/blacklist-validator.ts
+class BlacklistValidator {
+  manager;
+  constructor(manager) {
+    this.manager = manager;
+  }
+  checkTableBlacklist(operation, tableName, _tableList = []) {
+    if (this.manager.canOverrideBlacklist()) {
+      const message = t_vars("warnings.blacklist_override_used", {
+        operation,
+        table: tableName
+      });
+      console.error(message);
+      return;
+    }
+    if (this.manager.isTableBlacklisted(tableName)) {
+      const message = t_vars("errors.table_blacklisted", {
+        table: tableName,
+        operation
+      });
+      throw new BlacklistError(message, tableName, operation);
+    }
+  }
+  filterColumns(tableName, rows, columnList) {
+    const blacklistedColumns = this.manager.getBlacklistedColumns(tableName);
+    if (blacklistedColumns.length === 0) {
+      return { filteredRows: rows, omittedColumns: [] };
+    }
+    const omittedColumns = columnList.filter((col) => blacklistedColumns.includes(col));
+    if (omittedColumns.length === 0) {
+      return { filteredRows: rows, omittedColumns: [] };
+    }
+    const filteredRows = rows.map((row) => {
+      const newRow = {};
+      for (const [key2, value] of Object.entries(row)) {
+        if (!omittedColumns.includes(key2)) {
+          newRow[key2] = value;
+        }
+      }
+      return newRow;
+    });
+    return { filteredRows, omittedColumns };
+  }
+  buildSecurityNotification(_tableName, omittedColumns) {
+    if (omittedColumns.length === 0) {
+      return "";
+    }
+    return t_vars("security.columns_omitted", {
+      count: omittedColumns.length
+    });
+  }
+}
+
+// src/core/index.ts
+init_size_category();
+
+// src/core/health-checker.ts
+init_size_category();
+
+class HealthChecker {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async check(schema, options = {}) {
+    const checks = options.checks || ["nulls", "duplicates", "orphans", "emptyStrings", "rowCount"];
+    const sample2 = options.sample || 1e4;
+    const blacklisted = options.blacklistedColumns || new Set;
+    const visibleColumns = schema.columns.filter((c) => !blacklisted.has(`${schema.name}.${c.name}`));
+    const countResult = await this.adapter.execute(`SELECT COUNT(*) as count FROM \`${schema.name}\``);
+    const rowCount = countResult[0]?.count || 0;
+    const nulls = checks.includes("nulls") ? await this.checkNulls(schema.name, visibleColumns, rowCount, sample2) : [];
+    const orphans = checks.includes("orphans") ? await this.checkOrphans(schema.name, visibleColumns) : [];
+    const duplicates = checks.includes("duplicates") ? await this.checkDuplicates(schema.name, schema.indexes || []) : [];
+    const emptyStrings = checks.includes("emptyStrings") ? await this.checkEmptyStrings(schema.name, visibleColumns) : [];
+    const issues = orphans.length + duplicates.length;
+    const warnings = nulls.filter((n) => n.nullPercent > 50).length + emptyStrings.length;
+    const clean = Math.max(0, checks.length - (issues > 0 ? 1 : 0) - (warnings > 0 ? 1 : 0));
+    return {
+      table: schema.name,
+      rowCount,
+      sizeCategory: getSizeCategory(schema.estimatedRowCount),
+      checks: { nulls, orphans, duplicates, emptyStrings },
+      summary: { issues, warnings, clean },
+      skippedColumns: blacklisted.size > 0 ? Array.from(blacklisted).filter((c) => c.startsWith(`${schema.name}.`)) : undefined
+    };
+  }
+  async checkNulls(tableName, columns, totalRows, sample2) {
+    if (totalRows === 0)
+      return [];
+    const nullableColumns = columns.filter((c) => c.nullable);
+    const results = [];
+    for (const col of nullableColumns) {
+      try {
+        const useSample = totalRows > sample2;
+        const sql = useSample ? `SELECT COUNT(*) - COUNT(\`${col.name}\`) as null_count FROM (SELECT \`${col.name}\` FROM \`${tableName}\` LIMIT ${sample2}) sub` : `SELECT COUNT(*) - COUNT(\`${col.name}\`) as null_count FROM \`${tableName}\``;
+        const result = await this.adapter.execute(sql);
+        const nullCount = result[0]?.null_count || 0;
+        if (nullCount > 0) {
+          const sampleSize = Math.min(totalRows, sample2);
+          results.push({
+            column: col.name,
+            nullCount,
+            nullPercent: Number((nullCount / sampleSize * 100).toFixed(1))
+          });
+        }
+      } catch {}
+    }
+    return results;
+  }
+  async checkOrphans(tableName, columns) {
+    const fkColumns = columns.filter((c) => c.foreignKey);
+    const results = [];
+    for (const col of fkColumns) {
+      if (!col.foreignKey)
+        continue;
+      try {
+        const sql = `
+          SELECT COUNT(*) as orphan_count
+          FROM \`${tableName}\` child
+          LEFT JOIN \`${col.foreignKey.table}\` parent
+            ON child.\`${col.name}\` = parent.\`${col.foreignKey.column}\`
+          WHERE child.\`${col.name}\` IS NOT NULL
+            AND parent.\`${col.foreignKey.column}\` IS NULL
+        `;
+        const result = await this.adapter.execute(sql);
+        const orphanCount = result[0]?.orphan_count || 0;
+        if (orphanCount > 0) {
+          results.push({
+            column: col.name,
+            references: `${col.foreignKey.table}.${col.foreignKey.column}`,
+            orphanCount
+          });
+        }
+      } catch {}
+    }
+    return results;
+  }
+  async checkDuplicates(tableName, indexes) {
+    const uniqueIndexes = indexes.filter((idx) => idx.unique);
+    const results = [];
+    for (const idx of uniqueIndexes) {
+      try {
+        const colList = idx.columns.map((c) => `\`${c}\``).join(", ");
+        const sql = `
+          SELECT COUNT(*) as dup_count FROM (
+            SELECT ${colList}
+            FROM \`${tableName}\`
+            GROUP BY ${colList}
+            HAVING COUNT(*) > 1
+          ) dups
+        `;
+        const result = await this.adapter.execute(sql);
+        const dupCount = result[0]?.dup_count || 0;
+        if (dupCount > 0) {
+          results.push({
+            columns: idx.columns,
+            indexName: idx.name,
+            duplicateCount: dupCount
+          });
+        }
+      } catch {}
+    }
+    return results;
+  }
+  async checkEmptyStrings(tableName, columns) {
+    const stringColumns = columns.filter((c) => /varchar|text|char/i.test(c.type));
+    const results = [];
+    for (const col of stringColumns) {
+      try {
+        const sql = `SELECT COUNT(*) as empty_count FROM \`${tableName}\` WHERE \`${col.name}\` = ''`;
+        const result = await this.adapter.execute(sql);
+        const count = result[0]?.empty_count || 0;
+        if (count > 0) {
+          results.push({ column: col.name, count });
+        }
+      } catch {}
+    }
+    return results;
+  }
+}
 // src/commands/schema.ts
 init_validation();
 var ALLOWED_FORMATS2 = ["table", "json"];
@@ -49278,17 +51390,29 @@ async function schemaAction(table, options) {
       console.error("Database not configured. Run: dbcli init");
       process.exit(1);
     }
+    const connectionName = await getSchemaIsolationConnectionName(options.config);
+    let existingSchemaCount;
+    if (connectionName !== undefined) {
+      try {
+        const v2Raw = await readV2Config(options.config);
+        existingSchemaCount = Object.keys(v2Raw.schemas?.[connectionName] ?? {}).length;
+      } catch {
+        existingSchemaCount = 0;
+      }
+    } else {
+      existingSchemaCount = Object.keys(config.schema ?? {}).length;
+    }
     const adapter = AdapterFactory.createAdapter(config.connection);
     await adapter.connect();
     try {
       if (options.reset) {
-        await handleSchemaReset(adapter, config, options);
+        await handleSchemaReset(adapter, config, options, connectionName, existingSchemaCount);
       } else if (options.refresh) {
-        await handleSchemaRefresh(adapter, config, options);
+        await handleSchemaRefresh(adapter, config, options, connectionName);
       } else if (table) {
         await handleSingleTableSchema(adapter, table, options.format);
       } else {
-        await handleFullDatabaseScan(adapter, config, options);
+        await handleFullDatabaseScan(adapter, config, options, connectionName, existingSchemaCount);
       }
     } finally {
       await adapter.disconnect();
@@ -49348,10 +51472,18 @@ Indexes:`);
     }
   }
 }
-async function handleSchemaRefresh(adapter, config, options) {
+async function handleSchemaRefresh(adapter, config, options, connectionName) {
   const diffEngine = new SchemaDiffEngine(adapter, config);
   const report = await diffEngine.diff();
   if (report.tablesAdded.length === 0 && report.tablesRemoved.length === 0 && Object.keys(report.tablesModified).length === 0) {
+    const updatedConfig2 = configModule.merge(config, {
+      metadata: {
+        ...config.metadata,
+        schemaLastUpdated: new Date().toISOString(),
+        schemaTableCount: Object.keys(config.schema || {}).length
+      }
+    });
+    await writeSchema(options.config, updatedConfig2, connectionName);
     console.log("\u2705 Schema is up-to-date (no changes detected)");
     return;
   }
@@ -49375,27 +51507,37 @@ async function handleSchemaRefresh(adapter, config, options) {
       schemaTableCount: Object.keys(newSchema).length
     }
   });
-  await configModule.write(options.config, updatedConfig);
+  const writer = new SchemaWriter(options.config);
+  await writer.save(newSchema, connectionName);
+  console.log(`\u2705 Schema persisted to layered storage (.dbcli/schemas/${connectionName || ""})`);
+  await writeSchema(options.config, updatedConfig, connectionName);
   console.log(`\u2705 Schema updated in .dbcli`);
 }
-async function handleSchemaReset(adapter, config, options) {
-  const existingCount = config.schema ? Object.keys(config.schema).length : 0;
+async function handleSchemaReset(adapter, config, options, connectionName, existingCount) {
   if (existingCount > 0 && !options.force) {
-    console.log(`\u26A0 This will clear ${existingCount} existing table schemas and re-fetch from database.`);
-    console.log("  Use --force to confirm.");
+    const { SchemaLayeredLoader: SchemaLayeredLoader3 } = await Promise.resolve().then(() => (init_schema_loader(), exports_schema_loader));
+    const loader = new SchemaLayeredLoader3(options.config, { connectionName });
+    const { index } = await loader.initialize();
+    if (!index || Object.keys(index.tables).length === 0) {
+      console.log(`\u26A0 This will clear ${existingCount} existing table schemas and re-fetch from database.`);
+      console.log("\uD83D\uDCA1 Hint: Schema found in config.json but layered cache files are missing.");
+      console.log("   Use --force to migrate to optimized layered storage.");
+    } else {
+      console.log(`\u26A0 This will clear ${existingCount} existing table schemas and re-fetch from database.`);
+      console.log("  Use --force to confirm.");
+    }
     return;
   }
   console.log("\uD83D\uDDD1 Clearing existing schema data...");
+  const emptyMeta = { schemaLastUpdated: undefined, schemaTableCount: 0 };
   const configWithoutSchema = {
     ...config,
     schema: {},
-    metadata: {
-      ...config.metadata,
-      schemaLastUpdated: undefined,
-      schemaTableCount: 0
-    }
+    metadata: { ...config.metadata, ...emptyMeta }
   };
-  await configModule.write(options.config, configWithoutSchema);
+  await writeSchema(options.config, configWithoutSchema, connectionName);
+  const writer = new SchemaWriter(options.config);
+  await writer.clear(connectionName);
   console.log(t("schema.scanning_database"));
   const tables = await adapter.listTables();
   console.log(t_vars("schema.tables_found", { count: tables.length }));
@@ -49428,7 +51570,9 @@ async function handleSchemaReset(adapter, config, options) {
       schemaTableCount: tables.length
     }
   };
-  await configModule.write(options.config, updatedConfig);
+  await writer.save(schemaData, connectionName);
+  console.log(`\u2705 Schema persisted to layered storage (.dbcli/schemas/${connectionName || ""})`);
+  await writeSchema(options.config, updatedConfig, connectionName);
   if (existingCount > 0) {
     console.log(`
 \u2705 Schema reset complete \u2014 cleared ${existingCount} old tables, fetched ${tables.length} tables from database`);
@@ -49437,7 +51581,7 @@ async function handleSchemaReset(adapter, config, options) {
 \u2705 Schema fetched \u2014 ${tables.length} tables from database`);
   }
 }
-async function handleFullDatabaseScan(adapter, config, options) {
+async function handleFullDatabaseScan(adapter, config, options, connectionName, existingSchemaCount) {
   console.log(t("schema.scanning_database"));
   const tables = await adapter.listTables();
   console.log(t_vars("schema.tables_found", { count: tables.length }));
@@ -49461,26 +51605,50 @@ async function handleFullDatabaseScan(adapter, config, options) {
       console.log(t_vars("schema.processing_tables", { processed, total: tables.length }));
     }
   }
-  if (config.schema && Object.keys(config.schema).length > 0 && !options.force) {
-    console.log(`
+  if (existingSchemaCount > 0 && !options.force) {
+    const { SchemaLayeredLoader: SchemaLayeredLoader3 } = await Promise.resolve().then(() => (init_schema_loader(), exports_schema_loader));
+    const loader = new SchemaLayeredLoader3(options.config, { connectionName });
+    const { index } = await loader.initialize();
+    if (!index || Object.keys(index.tables).length === 0) {
+      console.log(`
+` + t("schema.schema_exists_warning"));
+      console.log("\uD83D\uDCA1 Hint: Schema found in config.json but layered cache files are missing.");
+      console.log("   Run with --force to migrate your schema to optimized layered storage.");
+    } else {
+      console.log(`
 ` + t("schema.schema_exists_warning"));
-    console.log(t("schema.use_force_to_override"));
+      console.log(t("schema.use_force_to_override"));
+    }
     process.exit(0);
   }
+  const now = new Date().toISOString();
   const updatedConfig = {
     ...config,
     schema: schemaData,
     metadata: {
       ...config.metadata,
-      schemaLastUpdated: new Date().toISOString(),
+      schemaLastUpdated: now,
       schemaTableCount: tables.length
     }
   };
-  await configModule.write(options.config, updatedConfig);
+  const writer = new SchemaWriter(options.config);
+  await writer.save(schemaData, connectionName);
+  console.log(`\u2705 Schema persisted to layered storage (.dbcli/schemas/${connectionName || ""})`);
+  await writeSchema(options.config, updatedConfig, connectionName);
   console.log(`
 \u2705 Schema updated in .dbcli`);
   console.log(`   ${tables.length} tables with full column details and relationships`);
-  console.log(`   Timestamp: ${updatedConfig.metadata.schemaLastUpdated}`);
+  console.log(`   Timestamp: ${now}`);
+}
+async function writeSchema(configPath, config, connectionName) {
+  if (connectionName !== undefined) {
+    await patchConnectionSchema(configPath, connectionName, config.schema ?? {}, {
+      schemaLastUpdated: config.metadata?.schemaLastUpdated,
+      schemaTableCount: config.metadata?.schemaTableCount
+    });
+  } else {
+    await configModule.write(configPath, config);
+  }
 }
 
 // src/core/permission-guard.ts
@@ -50007,151 +52175,6 @@ function inferColumnType(value) {
   return "unknown";
 }
 
-// src/core/blacklist-manager.ts
-class BlacklistManager {
-  config;
-  state;
-  overrideEnabled;
-  constructor(config, overrideEnvValue) {
-    this.config = config;
-    this.overrideEnabled = (overrideEnvValue ?? Bun.env.DBCLI_OVERRIDE_BLACKLIST ?? "") === "true";
-    this.state = this.loadBlacklist();
-  }
-  loadBlacklist() {
-    const tables = new Set;
-    const columns = new Map;
-    const blacklistConfig = this.config.blacklist;
-    if (!blacklistConfig) {
-      return { tables, columns };
-    }
-    if (Array.isArray(blacklistConfig.tables)) {
-      for (const tableName of blacklistConfig.tables) {
-        if (typeof tableName === "string") {
-          tables.add(tableName.toLowerCase());
-        } else {
-          console.warn(`[BlacklistManager] Invalid table name in blacklist config: ${JSON.stringify(tableName)}`);
-        }
-      }
-    } else if (blacklistConfig.tables !== undefined) {
-      console.warn("[BlacklistManager] blacklist.tables must be an array, ignoring");
-    }
-    if (blacklistConfig.columns && typeof blacklistConfig.columns === "object" && !Array.isArray(blacklistConfig.columns)) {
-      for (const [tableName, cols] of Object.entries(blacklistConfig.columns)) {
-        if (typeof tableName !== "string") {
-          console.warn(`[BlacklistManager] Invalid table name key in columns config: ${JSON.stringify(tableName)}`);
-          continue;
-        }
-        if (!Array.isArray(cols)) {
-          console.warn(`[BlacklistManager] blacklist.columns["${tableName}"] must be an array, ignoring`);
-          continue;
-        }
-        const columnSet = new Set;
-        for (const col of cols) {
-          if (typeof col === "string") {
-            columnSet.add(col);
-          } else {
-            console.warn(`[BlacklistManager] Invalid column name in blacklist.columns["${tableName}"]: ${JSON.stringify(col)}`);
-          }
-        }
-        if (columnSet.size > 0) {
-          columns.set(tableName, columnSet);
-        }
-      }
-    } else if (blacklistConfig.columns !== undefined) {
-      console.warn("[BlacklistManager] blacklist.columns must be an object, ignoring");
-    }
-    return { tables, columns };
-  }
-  isTableBlacklisted(tableName) {
-    return this.state.tables.has(tableName.toLowerCase());
-  }
-  isColumnBlacklisted(tableName, columnName) {
-    const columnSet = this.state.columns.get(tableName);
-    if (!columnSet) {
-      return false;
-    }
-    return columnSet.has(columnName);
-  }
-  getBlacklistedColumns(tableName) {
-    const columnSet = this.state.columns.get(tableName);
-    if (!columnSet) {
-      return [];
-    }
-    return Array.from(columnSet);
-  }
-  canOverrideBlacklist() {
-    return this.overrideEnabled;
-  }
-  getState() {
-    return this.state;
-  }
-}
-
-// src/types/blacklist.ts
-class BlacklistError extends Error {
-  tableName;
-  operation;
-  constructor(message, tableName, operation) {
-    super(message);
-    this.tableName = tableName;
-    this.operation = operation;
-    this.name = "BlacklistError";
-  }
-}
-
-// src/core/blacklist-validator.ts
-class BlacklistValidator {
-  manager;
-  constructor(manager) {
-    this.manager = manager;
-  }
-  checkTableBlacklist(operation, tableName, _tableList = []) {
-    if (this.manager.canOverrideBlacklist()) {
-      const message = t_vars("warnings.blacklist_override_used", {
-        operation,
-        table: tableName
-      });
-      console.error(message);
-      return;
-    }
-    if (this.manager.isTableBlacklisted(tableName)) {
-      const message = t_vars("errors.table_blacklisted", {
-        table: tableName,
-        operation
-      });
-      throw new BlacklistError(message, tableName, operation);
-    }
-  }
-  filterColumns(tableName, rows, columnList) {
-    const blacklistedColumns = this.manager.getBlacklistedColumns(tableName);
-    if (blacklistedColumns.length === 0) {
-      return { filteredRows: rows, omittedColumns: [] };
-    }
-    const omittedColumns = columnList.filter((col) => blacklistedColumns.includes(col));
-    if (omittedColumns.length === 0) {
-      return { filteredRows: rows, omittedColumns: [] };
-    }
-    const filteredRows = rows.map((row) => {
-      const newRow = {};
-      for (const [key2, value] of Object.entries(row)) {
-        if (!omittedColumns.includes(key2)) {
-          newRow[key2] = value;
-        }
-      }
-      return newRow;
-    });
-    return { filteredRows, omittedColumns };
-  }
-  buildSecurityNotification(_tableName, omittedColumns) {
-    if (omittedColumns.length === 0) {
-      return "";
-    }
-    return t_vars("security.columns_omitted", {
-      count: omittedColumns.length
-    });
-  }
-}
-
 // src/commands/query.ts
 init_validation();
 var ALLOWED_FORMATS3 = ["table", "json", "csv"];
@@ -50904,6 +52927,7 @@ async function exportCommand(sql, options) {
 }
 
 // src/commands/skill.ts
+var {$ } = globalThis.Bun;
 import * as path from "path";
 import { homedir } from "os";
 function findPackageRoot() {
@@ -50917,6 +52941,7 @@ function findPackageRoot() {
   return path.resolve(import.meta.dir, "../..");
 }
 var SKILL_SOURCE_PATH = path.join(findPackageRoot(), "assets", "SKILL.md");
+var SUPPORTED_PLATFORMS = ["claude", "gemini", "copilot", "cursor"];
 async function skillCommand(_program, options) {
   try {
     const skillFile = Bun.file(SKILL_SOURCE_PATH);
@@ -50943,6 +52968,28 @@ async function skillCommand(_program, options) {
     process.exit(1);
   }
 }
+async function checkSkillUpdates() {
+  const outdated = [];
+  try {
+    const sourceFile = Bun.file(SKILL_SOURCE_PATH);
+    if (!await sourceFile.exists())
+      return [];
+    const sourceContent = await sourceFile.text();
+    for (const platform of SUPPORTED_PLATFORMS) {
+      try {
+        const installPath = getInstallPath(platform);
+        const installedFile = Bun.file(installPath);
+        if (await installedFile.exists()) {
+          const installedContent = await installedFile.text();
+          if (installedContent !== sourceContent) {
+            outdated.push(platform);
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+  return outdated;
+}
 function getInstallPath(platform) {
   const home = process.env.HOME || homedir();
   const platformLower = platform.toLowerCase();
@@ -50956,7 +53003,7 @@ function getInstallPath(platform) {
     case "cursor":
       return path.join(process.cwd(), ".cursor", "rules", "dbcli.mdc");
     default:
-      throw new Error(`Unknown platform: ${platform}. Supported platforms: claude, gemini, copilot, cursor`);
+      throw new Error(`Unknown platform: ${platform}. Supported platforms: ${SUPPORTED_PLATFORMS.join(", ")}`);
   }
 }
 async function ensureDir(dirPath) {
@@ -51148,132 +53195,6 @@ columnCmd.command("remove <table.column>").description("Remove column from black
   }
 });
 
-// src/core/health-checker.ts
-init_size_category();
-
-class HealthChecker {
-  adapter;
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  async check(schema, options = {}) {
-    const checks = options.checks || ["nulls", "duplicates", "orphans", "emptyStrings", "rowCount"];
-    const sample2 = options.sample || 1e4;
-    const blacklisted = options.blacklistedColumns || new Set;
-    const visibleColumns = schema.columns.filter((c) => !blacklisted.has(`${schema.name}.${c.name}`));
-    const countResult = await this.adapter.execute(`SELECT COUNT(*) as count FROM \`${schema.name}\``);
-    const rowCount = countResult[0]?.count || 0;
-    const nulls = checks.includes("nulls") ? await this.checkNulls(schema.name, visibleColumns, rowCount, sample2) : [];
-    const orphans = checks.includes("orphans") ? await this.checkOrphans(schema.name, visibleColumns) : [];
-    const duplicates = checks.includes("duplicates") ? await this.checkDuplicates(schema.name, schema.indexes || []) : [];
-    const emptyStrings = checks.includes("emptyStrings") ? await this.checkEmptyStrings(schema.name, visibleColumns) : [];
-    const issues = orphans.length + duplicates.length;
-    const warnings = nulls.filter((n) => n.nullPercent > 50).length + emptyStrings.length;
-    const clean = Math.max(0, checks.length - (issues > 0 ? 1 : 0) - (warnings > 0 ? 1 : 0));
-    return {
-      table: schema.name,
-      rowCount,
-      sizeCategory: getSizeCategory(schema.estimatedRowCount),
-      checks: { nulls, orphans, duplicates, emptyStrings },
-      summary: { issues, warnings, clean },
-      skippedColumns: blacklisted.size > 0 ? Array.from(blacklisted).filter((c) => c.startsWith(`${schema.name}.`)) : undefined
-    };
-  }
-  async checkNulls(tableName, columns, totalRows, sample2) {
-    if (totalRows === 0)
-      return [];
-    const nullableColumns = columns.filter((c) => c.nullable);
-    const results = [];
-    for (const col of nullableColumns) {
-      try {
-        const useSample = totalRows > sample2;
-        const sql = useSample ? `SELECT COUNT(*) - COUNT(\`${col.name}\`) as null_count FROM (SELECT \`${col.name}\` FROM \`${tableName}\` LIMIT ${sample2}) sub` : `SELECT COUNT(*) - COUNT(\`${col.name}\`) as null_count FROM \`${tableName}\``;
-        const result = await this.adapter.execute(sql);
-        const nullCount = result[0]?.null_count || 0;
-        if (nullCount > 0) {
-          const sampleSize = Math.min(totalRows, sample2);
-          results.push({
-            column: col.name,
-            nullCount,
-            nullPercent: Number((nullCount / sampleSize * 100).toFixed(1))
-          });
-        }
-      } catch {}
-    }
-    return results;
-  }
-  async checkOrphans(tableName, columns) {
-    const fkColumns = columns.filter((c) => c.foreignKey);
-    const results = [];
-    for (const col of fkColumns) {
-      if (!col.foreignKey)
-        continue;
-      try {
-        const sql = `
-          SELECT COUNT(*) as orphan_count
-          FROM \`${tableName}\` child
-          LEFT JOIN \`${col.foreignKey.table}\` parent
-            ON child.\`${col.name}\` = parent.\`${col.foreignKey.column}\`
-          WHERE child.\`${col.name}\` IS NOT NULL
-            AND parent.\`${col.foreignKey.column}\` IS NULL
-        `;
-        const result = await this.adapter.execute(sql);
-        const orphanCount = result[0]?.orphan_count || 0;
-        if (orphanCount > 0) {
-          results.push({
-            column: col.name,
-            references: `${col.foreignKey.table}.${col.foreignKey.column}`,
-            orphanCount
-          });
-        }
-      } catch {}
-    }
-    return results;
-  }
-  async checkDuplicates(tableName, indexes) {
-    const uniqueIndexes = indexes.filter((idx) => idx.unique);
-    const results = [];
-    for (const idx of uniqueIndexes) {
-      try {
-        const colList = idx.columns.map((c) => `\`${c}\``).join(", ");
-        const sql = `
-          SELECT COUNT(*) as dup_count FROM (
-            SELECT ${colList}
-            FROM \`${tableName}\`
-            GROUP BY ${colList}
-            HAVING COUNT(*) > 1
-          ) dups
-        `;
-        const result = await this.adapter.execute(sql);
-        const dupCount = result[0]?.dup_count || 0;
-        if (dupCount > 0) {
-          results.push({
-            columns: idx.columns,
-            indexName: idx.name,
-            duplicateCount: dupCount
-          });
-        }
-      } catch {}
-    }
-    return results;
-  }
-  async checkEmptyStrings(tableName, columns) {
-    const stringColumns = columns.filter((c) => /varchar|text|char/i.test(c.type));
-    const results = [];
-    for (const col of stringColumns) {
-      try {
-        const sql = `SELECT COUNT(*) as empty_count FROM \`${tableName}\` WHERE \`${col.name}\` = ''`;
-        const result = await this.adapter.execute(sql);
-        const count = result[0]?.empty_count || 0;
-        if (count > 0) {
-          results.push({ column: col.name, count });
-        }
-      } catch {}
-    }
-    return results;
-  }
-}
-
 // src/commands/check.ts
 init_size_category();
 init_validation();
@@ -51615,7 +53536,8 @@ var statusCommand = new Command("status").description("Show current configuratio
 
 // src/commands/doctor.ts
 init_validation();
-import { join as join5 } from "path";
+init_schema_path();
+import { join as join10 } from "path";
 var ALLOWED_FORMATS7 = ["text", "json"];
 var SENSITIVE_PATTERNS = [
   "password",
@@ -51633,6 +53555,15 @@ var SENSITIVE_PATTERNS = [
   "ssn",
   "credit_card"
 ];
+function resolveSchemaLastUpdated(indexJson, configMetadata) {
+  if (indexJson && typeof indexJson === "object") {
+    const idx = indexJson;
+    const fromIndex = idx.metadata?.lastRefreshed ?? idx.updatedAt;
+    if (fromIndex)
+      return fromIndex;
+  }
+  return configMetadata?.schemaLastUpdated ?? null;
+}
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
   const pb = b.split(".").map(Number);
@@ -51677,7 +53608,7 @@ var runDoctorChecks = {
     }
   },
   async checkConfigExists(configPath, existsFn) {
-    const exists = existsFn ? await existsFn(configPath) : await Bun.file(configPath).exists() || await Bun.file(join5(configPath, "config.json")).exists();
+    const exists = existsFn ? await existsFn(configPath) : await Bun.file(configPath).exists() || await Bun.file(join10(configPath, "config.json")).exists();
     return {
       group: "Configuration",
       label: "Config exists",
@@ -51771,7 +53702,7 @@ var runDoctorChecks = {
   },
   async checkV2Config(configPath) {
     const results = [];
-    const configFile = Bun.file(join5(configPath, "config.json"));
+    const configFile = Bun.file(join10(configPath, "config.json"));
     if (!await configFile.exists())
       return results;
     let raw;
@@ -51811,7 +53742,7 @@ var runDoctorChecks = {
     }
     for (const [name, conn] of Object.entries(config.connections)) {
       if (conn.envFile) {
-        const envPath = join5(configPath, "..", conn.envFile);
+        const envPath = join10(configPath, "..", conn.envFile);
         const exists = await Bun.file(envPath).exists();
         results.push({
           group: "Configuration",
@@ -51907,17 +53838,17 @@ var doctorCommand = new Command("doctor").description("Run diagnostic checks on
           logger.debug("Could not list tables for blacklist/large table check");
         }
         try {
-          const indexPath = join5(configPath, "schemas", "index.json");
+          const schemaConnName = await getSchemaIsolationConnectionName(configPath);
+          const indexPath = join10(resolveSchemaPath(configPath, schemaConnName), "index.json");
           const indexFile = Bun.file(indexPath);
+          let indexParsed = null;
           if (await indexFile.exists()) {
-            const indexContent = await indexFile.text();
-            const index = JSON.parse(indexContent);
-            results.push(runDoctorChecks.checkSchemaCacheFreshness(index.updatedAt ?? null));
-          } else {
-            results.push(runDoctorChecks.checkSchemaCacheFreshness(null));
+            indexParsed = JSON.parse(await indexFile.text());
           }
+          const lastUpdated = resolveSchemaLastUpdated(indexParsed, config.metadata);
+          results.push(runDoctorChecks.checkSchemaCacheFreshness(lastUpdated));
         } catch {
-          results.push(runDoctorChecks.checkSchemaCacheFreshness(null));
+          results.push(runDoctorChecks.checkSchemaCacheFreshness(config.metadata?.schemaLastUpdated ?? null));
         }
         await adapter.disconnect();
       } catch (error) {
@@ -51949,7 +53880,7 @@ var doctorCommand = new Command("doctor").description("Run diagnostic checks on
 });
 
 // src/commands/completion.ts
-import { join as join6 } from "path";
+import { join as join11 } from "path";
 import { homedir as homedir2 } from "os";
 function extractCommands(program2) {
   return program2.commands.map((cmd) => ({
@@ -52054,11 +53985,11 @@ function getInstallPath2(shell) {
   const home = homedir2();
   switch (shell) {
     case "bash":
-      return join6(home, ".bashrc");
+      return join11(home, ".bashrc");
     case "zsh":
-      return join6(home, ".zshrc");
+      return join11(home, ".zshrc");
     case "fish":
-      return join6(home, ".config", "fish", "completions", "dbcli.fish");
+      return join11(home, ".config", "fish", "completions", "dbcli.fish");
     default:
       throw new Error(`Unsupported shell: ${shell}. Supported: bash, zsh, fish`);
   }
@@ -52078,7 +54009,7 @@ var MARKER_END = "# <<< dbcli completion <<<";
 async function installCompletion(shell, script) {
   const targetPath = getInstallPath2(shell);
   if (shell === "fish") {
-    const dir = join6(homedir2(), ".config", "fish", "completions");
+    const dir = join11(homedir2(), ".config", "fish", "completions");
     await Bun.$`mkdir -p ${dir}`.quiet();
     await Bun.file(targetPath).write(script);
     console.log(colors.success(`\u2713 Fish completion installed to ${targetPath}`));
@@ -52220,22 +54151,34 @@ async function checkForUpdate(currentVersion, cachePath, existingCache) {
 
 // src/commands/upgrade.ts
 function formatAlreadyUpToDate(version) {
-  return colors.success(`\u2713 Already up to date (v${version})`);
+  return colors.success(t_vars("upgrade.already_up_to_date", { version }));
 }
 function formatUpgradeMessage(currentVersion, latestVersion) {
   return [
-    colors.info(`  Current version : v${currentVersion}`),
-    colors.success(`  Latest version  : v${latestVersion}`)
+    colors.info(`  ${t_vars("upgrade.current_version", { version: currentVersion })}`),
+    colors.success(`  ${t_vars("upgrade.latest_version", { version: latestVersion })}`)
   ].join(`
 `);
 }
 function formatUpdateHint(latestVersion) {
-  return colors.warn(`[INFO] dbcli v${latestVersion} available. Run "dbcli upgrade" to upgrade.`);
+  return colors.warn(t_vars("upgrade.update_hint", { version: latestVersion }));
+}
+function formatSkillUpdateReminder(platforms) {
+  if (platforms.length === 0)
+    return "";
+  return [
+    colors.warn(`
+  ${t("skill.update_available")}`),
+    ...platforms.map((p) => colors.info(`  - ${p}`)),
+    colors.dim(`
+  ${t("skill.update_hint")}`)
+  ].join(`
+`);
 }
-var upgradeCommand = new Command("upgrade").description("Check for updates and upgrade dbcli to the latest version").option("--check", "Only check for updates, do not upgrade").action(async (options) => {
+var upgradeCommand = new Command("upgrade").description(t("upgrade.description")).option("--check", "Only check for updates, do not upgrade").action(async (options) => {
   const configPath = upgradeCommand.parent?.opts().config ?? ".dbcli";
   const currentVersion = package_default.version;
-  console.log(colors.bold("Checking for updates..."));
+  console.log(colors.bold(t("upgrade.checking")));
   let cachePath = null;
   try {
     const file = Bun.file(configPath);
@@ -52247,41 +54190,53 @@ var upgradeCommand = new Command("upgrade").description("Check for updates and u
     cachePath = null;
   }
   const result = await checkForUpdate(currentVersion, cachePath);
+  const outdatedSkills = await checkSkillUpdates();
   if (!result) {
-    console.error(colors.warn("\u26A0 Could not check for updates (network error or registry unavailable)"));
+    console.error(colors.warn(t("upgrade.network_error")));
+    if (outdatedSkills.length > 0) {
+      console.log(formatSkillUpdateReminder(outdatedSkills));
+    }
     process.exit(0);
   }
   if (!result.hasUpdate) {
     console.log(formatAlreadyUpToDate(currentVersion));
+    if (outdatedSkills.length > 0) {
+      console.log(formatSkillUpdateReminder(outdatedSkills));
+    }
     process.exit(0);
   }
   console.log(colors.warn(`
-  New version available: v${result.latestVersion}`));
+  ${t_vars("upgrade.new_version_available", { version: result.latestVersion })}`));
   console.log(formatUpgradeMessage(currentVersion, result.latestVersion));
   console.log();
   if (options.check) {
-    console.log(colors.dim('  Run "dbcli upgrade" to install the update.'));
+    console.log(colors.dim(`  ${t("upgrade.install_hint")}`));
+    if (outdatedSkills.length > 0) {
+      console.log(formatSkillUpdateReminder(outdatedSkills));
+    }
     process.exit(0);
   }
-  console.log(colors.bold("Upgrading..."));
-  console.log(colors.dim(`  bun add -g @carllee1983/dbcli@latest`));
+  console.log(colors.bold(t("upgrade.upgrading")));
+  console.log(colors.dim(`  ${t("upgrade.manual_hint")}`));
   console.log();
   const proc = Bun.$`bun add -g @carllee1983/dbcli@latest`.nothrow();
   const result2 = await proc;
   if (result2.exitCode === 0) {
     console.log(colors.success(`
-\u2713 Successfully upgraded to v${result.latestVersion}`));
+${t_vars("upgrade.success", { version: result.latestVersion })}`));
+    console.log(colors.dim(`
+  ${t("upgrade.skill_recheck_hint")}`));
   } else {
     console.error(colors.error(`
-\u2717 Upgrade failed. Try running manually:`));
-    console.error(colors.dim("  bun add -g @carllee1983/dbcli@latest"));
+${t("upgrade.failed")}`));
+    console.error(colors.dim(`  ${t("upgrade.manual_hint")}`));
     process.exit(1);
   }
 });
 
 // src/commands/shell.ts
 import { createInterface as createInterface2 } from "readline";
-import { join as join7 } from "path";
+import { join as join12 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/core/repl/types.ts
@@ -52969,7 +54924,7 @@ function matchWithSuffix(candidates, prefix) {
 
 // src/commands/shell.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
-var HISTORY_PATH = join7(homedir3(), ".dbcli_history");
+var HISTORY_PATH = join12(homedir3(), ".dbcli_history");
 var shellCommand = new Command("shell").description("Interactive database shell with auto-completion and syntax highlighting").option("--sql", "SQL-only mode (skip dbcli command parsing)").action(async (options) => {
   const globalOpts = shellCommand.optsWithGlobals?.() ?? {};
   const configPath = globalOpts.config ?? ".dbcli";
@@ -53868,7 +55823,7 @@ addExecOpts(migrateCommand.command("drop-enum <name>").description(t("migrate.dr
 });
 
 // src/commands/use.ts
-import { join as join8 } from "path";
+import { join as join13 } from "path";
 async function switchDefault(configPath, name, config) {
   if (!config.connections[name]) {
     const available = Object.keys(config.connections).join(", ");
@@ -53890,7 +55845,7 @@ function listConnectionsForDisplay(config) {
   });
 }
 async function ensureV2Config(configPath) {
-  const configFile = Bun.file(join8(configPath, "config.json"));
+  const configFile = Bun.file(join13(configPath, "config.json"));
   if (!await configFile.exists()) {
     throw new ConfigError(t("init.config_not_found"));
   }
@@ -53927,7 +55882,7 @@ var useCommand = new Command("use").description("Switch or display the default d
 });
 
 // src/cli.ts
-import { join as join9 } from "path";
+import { join as join14 } from "path";
 var _bgVersionCheckResult;
 var program2 = new Command().name("dbcli").description("Database CLI for AI agents").version(package_default.version).option("--no-color", "Disable colored output").option("-v, --verbose", "Increase verbosity (-v verbose, -vv debug)", (_, prev) => prev + 1, 0).option("-q, --quiet", "Suppress non-essential output").option("--config <path>", "Path to .dbcli config file", ".dbcli").option("--use <connection>", "Use a specific named connection (v2 config)");
 program2.hook("preAction", (thisCommand, actionCommand) => {
@@ -53953,7 +55908,7 @@ program2.hook("preAction", (thisCommand, actionCommand) => {
       try {
         let cache = null;
         try {
-          const cacheFile = Bun.file(join9(configPath, "version-check.json"));
+          const cacheFile = Bun.file(join14(configPath, "version-check.json"));
           if (await cacheFile.exists()) {
             cache = await cacheFile.json();
           }
@@ -53966,16 +55921,24 @@ program2.hook("preAction", (thisCommand, actionCommand) => {
     })();
   }
 });
-program2.hook("postAction", () => {
+program2.hook("postAction", async (thisCommand, actionCommand) => {
   if (_bgVersionCheckResult?.hasUpdate) {
     process.stderr.write(formatUpdateHint(_bgVersionCheckResult.latestVersion) + `
 `);
   }
+  const isUpgradeOrSkill = ["upgrade", "skill"].includes(actionCommand.name());
+  if (!thisCommand.opts().quiet && !isUpgradeOrSkill) {
+    const outdatedSkills = await checkSkillUpdates();
+    if (outdatedSkills.length > 0) {
+      process.stderr.write(formatSkillUpdateReminder(outdatedSkills) + `
+`);
+    }
+  }
 });
 program2.addCommand(initCommand);
 program2.addCommand(listCommand);
 program2.addCommand(schemaCommand);
-program2.command("query <sql>").description(t("query.description")).option("--format <type>", "Output format: table, json, csv", "table").option("--limit <number>", "Limit result rows (overrides auto-limit)", undefined, parseInt).option("--no-limit", "Disable auto-limit in query-only mode").action(async (sql, options) => {
+program2.command("query <sql>").description(t("query.description")).option("--format <type>", "Output format: table, json, csv", "table").option("--limit <number>", "Limit result rows (overrides auto-limit)", (val) => parseInt(val, 10)).option("--no-limit", "Disable auto-limit in query-only mode").action(async (sql, options) => {
   try {
     await queryCommand(sql, options);
   } catch (error) {