bullmq-dash 0.3.0 → 0.3.2

package/dist/index.js

@@ -3,7 +3,64 @@
 // src/app.ts
 import { createCliRenderer } from "@opentui/core";
 
+// src/data/queue-sort.ts
+var QUEUE_SORT_FIELDS = [
+  "name",
+  "task-size",
+  "waiting",
+  "active",
+  "completed",
+  "failed",
+  "delayed"
+];
+function queueSortLabel(sortBy, order) {
+  const label = sortBy === "task-size" ? "size" : sortBy;
+  return `${label} ${order}`;
+}
+function metric(queue, sortBy) {
+  switch (sortBy) {
+    case "name":
+      return queue.name;
+    case "task-size":
+      return queue.total;
+    case "waiting":
+      return queue.counts.wait;
+    case "active":
+      return queue.counts.active;
+    case "completed":
+      return queue.counts.completed;
+    case "failed":
+      return queue.counts.failed;
+    case "delayed":
+      return queue.counts.delayed;
+  }
+}
+function defaultSortOrder(sortBy) {
+  return sortBy === "name" ? "asc" : "desc";
+}
+function sortQueues(queues, sortBy = "name", order = defaultSortOrder(sortBy)) {
+  const direction = order === "asc" ? 1 : -1;
+  return queues.toSorted((a, b) => {
+    const aMetric = metric(a, sortBy);
+    const bMetric = metric(b, sortBy);
+    if (typeof aMetric === "number" && typeof bMetric === "number") {
+      const diff = aMetric - bMetric;
+      if (diff !== 0)
+        return diff * direction;
+      return a.name.localeCompare(b.name);
+    }
+    return String(aMetric).localeCompare(String(bMetric)) * direction;
+  });
+}
+
 // src/state.ts
+var QUEUE_SORT_SEQUENCE = [
+  { sortBy: "name", sortOrder: "asc" },
+  { sortBy: "task-size", sortOrder: "desc" },
+  { sortBy: "failed", sortOrder: "desc" },
+  { sortBy: "waiting", sortOrder: "desc" }
+];
+
 class StateManager {
   state;
   listeners = new Set;
@@ -14,6 +71,8 @@ class StateManager {
       globalMetrics: null,
       queues: [],
       selectedQueueIndex: 0,
+      queueSortBy: "name",
+      queueSortOrder: "asc",
       jobs: [],
       jobsTotal: 0,
       jobsPage: 1,
@@ -84,6 +143,20 @@ class StateManager {
       });
     }
   }
+  cycleQueueSort() {
+    const { queueSortBy, queueSortOrder } = this.state;
+    const currentIndex = QUEUE_SORT_SEQUENCE.findIndex((option) => option.sortBy === queueSortBy && option.sortOrder === queueSortOrder);
+    const next = QUEUE_SORT_SEQUENCE[(currentIndex + 1) % QUEUE_SORT_SEQUENCE.length];
+    const sortedQueues = sortQueues(this.state.queues, next.sortBy, next.sortOrder);
+    this.setState({
+      queues: sortedQueues,
+      queueSortBy: next.sortBy,
+      queueSortOrder: next.sortOrder,
+      selectedQueueIndex: 0,
+      selectedJobIndex: 0,
+      jobsPage: 1
+    });
+  }
   selectNextJob() {
     const { jobs, selectedJobIndex } = this.state;
     if (selectedJobIndex < jobs.length - 1) {
@@ -230,1049 +303,170 @@ class StateManager {
 }
 var stateManager = new StateManager;
 
-// src/errors.ts
-function writeError(message, code, details) {
-  process.stderr.write(JSON.stringify({ error: message, code, details }) + `
-`);
-}
+// src/data/queues.ts
+import { Queue } from "bullmq";
 
-// src/profiles.ts
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function coerceOptionalPositiveInt(value) {
-  if (value === undefined)
-    return;
-  const numberValue = Number(value);
-  if (!Number.isInteger(numberValue) || numberValue <= 0)
-    return null;
-  return numberValue;
+// src/redis-options.ts
+function redisConnectionOptions(config) {
+  return {
+    host: config.redis.host,
+    port: config.redis.port,
+    username: config.redis.username,
+    password: config.redis.password,
+    db: config.redis.db,
+    ...config.redis.tls ? { tls: {} } : {}
+  };
 }
-var PROFILE_ALLOWED_KEYS = ["redis", "pollInterval", "prefix", "queues", "retentionMs"];
-var PROFILES_FILE_ALLOWED_KEYS = ["defaultProfile", "profiles"];
-function unknownKeyMessage(path, key, allowed) {
-  return `unknown key '${key}' in ${path} (allowed: ${allowed.join(", ")})`;
+
+// src/data/queues.ts
+var QUEUE_NAMES_CACHE_TTL = 5000;
+var SCAN_COUNT = 1000;
+var DEL_BATCH_SIZE = 500;
+function getQueue(ctx, queueName) {
+  const cached = ctx.queueCache.get(queueName);
+  if (cached)
+    return cached;
+  const queue = new Queue(queueName, {
+    prefix: ctx.config.prefix,
+    connection: redisConnectionOptions(ctx.config)
+  });
+  ctx.queueCache.set(queueName, queue);
+  return queue;
 }
-function validateProfile(value, path, errors) {
-  if (!isRecord(value)) {
-    errors.push(`${path} must be an object`);
-    return null;
+async function discoverQueueNames(ctx) {
+  if (ctx.config.queueNames && ctx.config.queueNames.length > 0) {
+    return ctx.config.queueNames;
   }
-  for (const key of Object.keys(value)) {
-    if (!PROFILE_ALLOWED_KEYS.includes(key)) {
-      errors.push(unknownKeyMessage(path, key, PROFILE_ALLOWED_KEYS));
-    }
+  const now = Date.now();
+  if (ctx.queueNamesCache && now - ctx.queueNamesCache.timestamp < QUEUE_NAMES_CACHE_TTL) {
+    return ctx.queueNamesCache.names;
   }
-  const profile = {};
-  if (value.redis !== undefined) {
-    if (!isRecord(value.redis)) {
-      errors.push(`${path}.redis must be an object`);
-    } else {
-      for (const key of Object.keys(value.redis)) {
-        if (key !== "url")
-          errors.push(unknownKeyMessage(`${path}.redis`, key, ["url"]));
-      }
-      if (typeof value.redis.url !== "string") {
-        errors.push(`${path}.redis.url must be a string`);
-      } else {
-        profile.redis = { url: value.redis.url };
+  const queueNames = new Set;
+  const prefix = ctx.config.prefix + ":";
+  let cursor = "0";
+  do {
+    const [nextCursor, keys] = await ctx.redis.scan(cursor, "MATCH", `${ctx.config.prefix}:*`, "COUNT", SCAN_COUNT);
+    cursor = nextCursor;
+    for (const key of keys) {
+      if (key.startsWith(prefix)) {
+        const rest = key.slice(prefix.length);
+        const colonIdx = rest.indexOf(":");
+        const queueName = colonIdx === -1 ? rest : rest.slice(0, colonIdx);
+        if (queueName) {
+          queueNames.add(queueName);
+        }
       }
     }
-  }
-  const pollInterval = coerceOptionalPositiveInt(value.pollInterval);
-  if (pollInterval === null)
-    errors.push(`${path}.pollInterval must be a positive integer`);
-  else if (pollInterval !== undefined)
-    profile.pollInterval = pollInterval;
-  if (value.prefix !== undefined) {
-    if (typeof value.prefix !== "string")
-      errors.push(`${path}.prefix must be a string`);
-    else
-      profile.prefix = value.prefix;
-  }
-  if (value.queues !== undefined) {
-    if (!Array.isArray(value.queues) || value.queues.some((queue) => typeof queue !== "string")) {
-      errors.push(`${path}.queues must be an array of strings`);
-    } else {
-      profile.queues = value.queues;
-    }
-  }
-  const retentionMs = coerceOptionalPositiveInt(value.retentionMs);
-  if (retentionMs === null)
-    errors.push(`${path}.retentionMs must be a positive integer`);
-  else if (retentionMs !== undefined)
-    profile.retentionMs = retentionMs;
-  return profile;
+  } while (cursor !== "0");
+  const sortedNames = Array.from(queueNames).toSorted();
+  ctx.queueNamesCache = {
+    names: sortedNames,
+    timestamp: now
+  };
+  return sortedNames;
 }
-function validateProfilesFile(value) {
-  const errors = [];
-  if (!isRecord(value))
-    return ["config file must be an object"];
-  for (const key of Object.keys(value)) {
-    if (!PROFILES_FILE_ALLOWED_KEYS.includes(key)) {
-      errors.push(unknownKeyMessage("config file", key, PROFILES_FILE_ALLOWED_KEYS));
-    }
-  }
-  const file = { profiles: {} };
-  if (value.defaultProfile !== undefined) {
-    if (typeof value.defaultProfile !== "string")
-      errors.push("defaultProfile must be a string");
-    else
-      file.defaultProfile = value.defaultProfile;
-  }
-  if (value.profiles !== undefined) {
-    if (!isRecord(value.profiles)) {
-      errors.push("profiles must be an object");
-    } else {
-      for (const [name, profileValue] of Object.entries(value.profiles)) {
-        const profile = validateProfile(profileValue, `profiles.${name}`, errors);
-        if (profile)
-          file.profiles[name] = profile;
-      }
-    }
-  }
-  return errors.length > 0 ? errors : file;
+async function getQueueStats(ctx, queueName) {
+  const queue = getQueue(ctx, queueName);
+  const [counts, isPaused, schedulersCount] = await Promise.all([
+    queue.getJobCounts(),
+    queue.isPaused(),
+    queue.getJobSchedulersCount()
+  ]);
+  const waitCount = (counts.waiting || 0) + (counts.prioritized || 0);
+  return {
+    name: queueName,
+    counts: {
+      wait: waitCount,
+      active: counts.active || 0,
+      completed: counts.completed || 0,
+      failed: counts.failed || 0,
+      delayed: counts.delayed || 0,
+      schedulers: schedulersCount || 0
+    },
+    isPaused,
+    total: waitCount + (counts.active || 0) + (counts.completed || 0) + (counts.failed || 0) + (counts.delayed || 0)
+  };
 }
-function resolveConfigPath(explicitPath, env = process.env) {
-  if (explicitPath)
-    return explicitPath;
-  if (env.BULLMQ_DASH_CONFIG)
-    return env.BULLMQ_DASH_CONFIG;
-  const xdg = env.XDG_CONFIG_HOME;
-  if (xdg)
-    return join(xdg, "bullmq-dash", "config.json");
-  return join(homedir(), ".config", "bullmq-dash", "config.json");
+async function getAllQueueStats(ctx) {
+  const queueNames = await discoverQueueNames(ctx);
+  const stats = await Promise.all(queueNames.map((name) => getQueueStats(ctx, name)));
+  return stats;
 }
-var ENV_REF = /^\$\{([A-Z_][A-Z0-9_]*)\}$/;
-function expandEnvRefs(value, env = process.env) {
-  if (typeof value === "string") {
-    const match = value.match(ENV_REF);
-    if (!match)
-      return value;
-    const key = match[1];
-    const resolved = env[key];
-    if (resolved === undefined) {
-      throw new Error(`Environment variable '${key}' referenced in profile is not set`);
+async function closeAllQueues(ctx) {
+  const closePromises = Array.from(ctx.queueCache.values()).map((queue) => queue.close());
+  await Promise.all(closePromises);
+  ctx.queueCache.clear();
+  ctx.queueNamesCache = null;
+}
+async function deleteQueue(ctx, queueName, dryRun = false) {
+  const queue = getQueue(ctx, queueName);
+  const counts = await queue.getJobCounts();
+  const result = {
+    name: queueName,
+    counts: {
+      wait: (counts.waiting || 0) + (counts.prioritized || 0),
+      active: counts.active || 0,
+      completed: counts.completed || 0,
+      failed: counts.failed || 0,
+      delayed: counts.delayed || 0
     }
-    return resolved;
-  }
-  if (Array.isArray(value)) {
-    return value.map((v) => expandEnvRefs(v, env));
-  }
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = expandEnvRefs(v, env);
+  };
+  if (!dryRun) {
+    await queue.obliterate({ force: true });
+    const escapedQueueName = queueName.replace(/[[*?]/g, "\\$&");
+    const repeatKeyPattern = `${ctx.config.prefix}:${escapedQueueName}:*`;
+    const allKeys = [];
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await ctx.redis.scan(cursor, "MATCH", repeatKeyPattern, "COUNT", SCAN_COUNT);
+      cursor = nextCursor;
+      allKeys.push(...keys);
+    } while (cursor !== "0");
+    if (allKeys.length > 0) {
+      for (let i = 0;i < allKeys.length; i += DEL_BATCH_SIZE) {
+        const batch = allKeys.slice(i, i + DEL_BATCH_SIZE);
+        await ctx.redis.del(...batch);
+      }
+    }
+    await queue.close();
+    ctx.queueCache.delete(queueName);
+    if (ctx.queueNamesCache) {
+      ctx.queueNamesCache.names = ctx.queueNamesCache.names.filter((n) => n !== queueName);
     }
-    return out;
   }
-  return value;
+  return result;
 }
-function loadProfile(opts = {}) {
-  const env = opts.env ?? process.env;
-  const explicitConfig = !!opts.configPath || !!env.BULLMQ_DASH_CONFIG;
-  const explicitProfile = !!opts.profileName;
-  const path = resolveConfigPath(opts.configPath, env);
-  if (!existsSync(path)) {
-    if (explicitConfig || explicitProfile) {
-      writeError(`Config file not found: ${path}`, "CONFIG_ERROR", explicitConfig ? "Check the path passed to --config or $BULLMQ_DASH_CONFIG." : `--profile requires a config file. Create one at ${path} or pass --config <path>.`);
-      process.exit(2);
-    }
+
+// src/data/duration.ts
+var DURATION_PATTERN = /^(\d+)([smhd])$/;
+var MS_PER_UNIT = {
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 24 * 60 * 60 * 1000
+};
+var DEFAULT_RETRY_PAGE_SIZE = 1000;
+var MAX_RETRY_PAGE_SIZE = 1e4;
+function parseDuration(raw) {
+  const match = DURATION_PATTERN.exec(raw);
+  if (!match)
     return null;
-  }
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync(path, "utf-8"));
-  } catch (error) {
-    writeError(`Failed to parse config file: ${path}`, "CONFIG_ERROR", error instanceof Error ? error.message : String(error));
-    process.exit(2);
-  }
-  const parsed = validateProfilesFile(raw);
-  if (Array.isArray(parsed)) {
-    writeError(`Invalid config file: ${path}`, "CONFIG_ERROR", parsed.join("; "));
-    process.exit(2);
-  }
-  const file = parsed;
-  const name = opts.profileName ?? file.defaultProfile;
-  if (!name)
-    return null;
-  const profile = file.profiles[name];
-  if (!profile) {
-    const available = Object.keys(file.profiles);
-    writeError(`Profile '${name}' not found in ${path}`, "CONFIG_ERROR", available.length > 0 ? `Available profiles: ${available.join(", ")}` : "No profiles are defined in the config file.");
-    process.exit(2);
-  }
-  let expanded;
-  try {
-    expanded = expandEnvRefs(profile, env);
-  } catch (error) {
-    writeError(`Failed to resolve env vars in profile '${name}'`, "CONFIG_ERROR", error instanceof Error ? error.message : String(error));
-    process.exit(2);
-  }
-  return { sourcePath: path, name, profile: expanded };
-}
-function decodeUrlAuthField(raw, field) {
-  try {
-    return decodeURIComponent(raw);
-  } catch {
-    throw new Error(`Invalid percent-encoding in URL ${field}`);
-  }
-}
-function redactUrl(input) {
-  return input.replace(/(:\/\/)[^/]*@/, "$1[REDACTED]@");
-}
-function parseRedisUrl(input) {
-  let parsed;
-  try {
-    parsed = new URL(input);
-  } catch {
-    throw new Error(`Not a valid URL: ${redactUrl(input)}`);
-  }
-  if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
-    throw new Error(`Unsupported scheme '${parsed.protocol}' (expected redis:// or rediss://)`);
-  }
-  if (!parsed.hostname) {
-    throw new Error(`Missing host in URL: ${redactUrl(input)}`);
-  }
-  if (parsed.search || parsed.hash) {
-    throw new Error("Query parameters and fragments are not supported in Redis URLs. " + "For TLS, use rediss:// (not ?ssl=true).");
-  }
-  const username = parsed.username ? decodeUrlAuthField(parsed.username, "username") : undefined;
-  const password = parsed.password ? decodeUrlAuthField(parsed.password, "password") : undefined;
-  let db;
-  if (parsed.pathname && parsed.pathname !== "/") {
-    const trimmed = parsed.pathname.replace(/^\//, "");
-    if (!/^\d+$/.test(trimmed)) {
-      throw new Error(`Database in URL must be a non-negative integer, got '/${trimmed}'`);
-    }
-    db = Number(trimmed);
-  }
-  const port = parsed.port ? Number(parsed.port) : 6379;
-  return {
-    host: parsed.hostname,
-    port,
-    username,
-    password,
-    db,
-    tls: parsed.protocol === "rediss:"
-  };
-}
-
-// src/config.ts
-var DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-function coercePositiveInt(value, fallback) {
-  if (value === undefined)
-    return fallback;
-  const numberValue = Number(value);
-  if (!Number.isInteger(numberValue) || numberValue <= 0)
-    return null;
-  return numberValue;
-}
-function coerceNonNegativeInt(value, fallback) {
-  if (value === undefined)
-    return fallback;
-  const numberValue = Number(value);
-  if (!Number.isInteger(numberValue) || numberValue < 0)
-    return null;
-  return numberValue;
-}
-function coerceString(value, fallback) {
-  if (value === undefined)
-    return fallback;
-  return typeof value === "string" ? value : null;
-}
-function coerceOptionalString(value) {
-  if (value === undefined)
-    return;
-  return typeof value === "string" ? value : null;
-}
-var CONFIG_ALLOWED_KEYS = ["redis", "pollInterval", "prefix", "queueNames", "retentionMs"];
-var CONFIG_REDIS_ALLOWED_KEYS = ["host", "port", "username", "password", "db", "tls"];
-function validateConfig(raw) {
-  const errors = [];
-  for (const key of Object.keys(raw)) {
-    if (!CONFIG_ALLOWED_KEYS.includes(key)) {
-      errors.push(`unknown key '${key}' in config (allowed: ${CONFIG_ALLOWED_KEYS.join(", ")})`);
-    }
-  }
-  for (const key of Object.keys(raw.redis)) {
-    if (!CONFIG_REDIS_ALLOWED_KEYS.includes(key)) {
-      errors.push(`unknown key '${key}' in config.redis (allowed: ${CONFIG_REDIS_ALLOWED_KEYS.join(", ")})`);
-    }
-  }
-  const redis = raw.redis;
-  const host = coerceString(redis.host, "localhost");
-  if (host === null)
-    errors.push("redis.host must be a string");
-  const port = coercePositiveInt(redis.port, 6379);
-  if (port === null)
-    errors.push("redis.port must be a positive integer");
-  const username = coerceOptionalString(redis.username);
-  if (username === null)
-    errors.push("redis.username must be a string");
-  const password = coerceOptionalString(redis.password);
-  if (password === null)
-    errors.push("redis.password must be a string");
-  const db = coerceNonNegativeInt(redis.db, 0);
-  if (db === null)
-    errors.push("redis.db must be a non-negative integer");
-  const tls = redis.tls;
-  if (tls !== undefined && typeof tls !== "boolean") {
-    errors.push("redis.tls must be a boolean");
-  }
-  const pollInterval = coercePositiveInt(raw.pollInterval, 3000);
-  if (pollInterval === null)
-    errors.push("pollInterval must be a positive integer");
-  const prefix = coerceString(raw.prefix, "bull");
-  if (prefix === null)
-    errors.push("prefix must be a string");
-  const queueNames = raw.queueNames;
-  if (queueNames !== undefined && (!Array.isArray(queueNames) || queueNames.some((name) => typeof name !== "string"))) {
-    errors.push("queueNames must be an array of strings");
-  }
-  const retentionMs = coercePositiveInt(raw.retentionMs, DEFAULT_RETENTION_MS);
-  if (retentionMs === null)
-    errors.push("retentionMs must be a positive integer");
-  if (errors.length > 0) {
-    return { success: false, errors };
-  }
-  const config = {
-    redis: {
-      host,
-      port,
-      db
-    },
-    pollInterval,
-    prefix,
-    retentionMs
-  };
-  if (username !== undefined && username !== null)
-    config.redis.username = username;
-  if (password !== undefined && password !== null)
-    config.redis.password = password;
-  if (tls !== undefined)
-    config.redis.tls = tls;
-  if (queueNames !== undefined)
-    config.queueNames = queueNames;
-  return { success: true, data: config };
-}
-function loadConfig(cliArgs, profile) {
-  const p = profile?.profile;
-  const url = cliArgs.redisUrl ?? p?.redis?.url;
-  let parts;
-  if (url) {
-    try {
-      parts = parseRedisUrl(url);
-    } catch (error) {
-      writeError(cliArgs.redisUrl ? "Invalid --redis-url" : `Invalid redis.url in profile '${profile?.name}'`, "CONFIG_ERROR", error instanceof Error ? error.message : String(error));
-      process.exit(2);
-    }
-  }
-  const raw = {
-    redis: {
-      host: parts?.host,
-      port: parts?.port,
-      username: parts?.username,
-      password: parts?.password,
-      db: parts?.db,
-      tls: parts?.tls
-    },
-    pollInterval: cliArgs.pollInterval ?? p?.pollInterval,
-    prefix: cliArgs.prefix ?? p?.prefix,
-    queueNames: cliArgs.queues ?? p?.queues,
-    retentionMs: p?.retentionMs
-  };
-  const result = validateConfig(raw);
-  if (!result.success) {
-    writeError("Configuration error", "CONFIG_ERROR", result.errors.join("; "));
-    process.exit(2);
-  }
-  return result.data;
-}
-function createConfigFromPrompt(redisUrl, cliArgs) {
-  return loadConfig({ ...cliArgs, redisUrl });
-}
-var configInstance = null;
-function setConfig(config) {
-  configInstance = config;
-}
-function getConfig() {
-  if (!configInstance) {
-    throw new Error("Config not initialized. Call setConfig() first.");
-  }
-  return configInstance;
-}
-
-// src/data/queues.ts
-import { Queue } from "bullmq";
-
-// src/data/redis.ts
-import { RedisConnection } from "bullmq";
-var redisConnection = null;
-var redisClientPromise = null;
-async function getRedisClient() {
-  if (!redisClientPromise) {
-    const config = getConfig();
-    redisConnection = new RedisConnection({
-      host: config.redis.host,
-      port: config.redis.port,
-      username: config.redis.username,
-      password: config.redis.password,
-      db: config.redis.db,
-      ...config.redis.tls ? { tls: {} } : {},
-      lazyConnect: true,
-      retryStrategy: (times) => {
-        if (times > 3) {
-          return null;
-        }
-        return Math.min(times * 200, 2000);
-      }
-    }, { blocking: false });
-    redisClientPromise = redisConnection.client.catch((err) => {
-      redisClientPromise = null;
-      redisConnection = null;
-      throw err;
-    });
-  }
-  return redisClientPromise;
-}
-async function connectRedis() {
-  await getRedisClient();
-}
-async function disconnectRedis() {
-  if (redisConnection) {
-    await redisConnection.close();
-    redisConnection = null;
-    redisClientPromise = null;
-  }
-}
-
-// src/data/queues.ts
-var queueCache = new Map;
-var queueNamesCache = null;
-var QUEUE_NAMES_CACHE_TTL = 5000;
-var SCAN_COUNT = 1000;
-var DEL_BATCH_SIZE = 500;
-function getQueue(queueName) {
-  if (!queueCache.has(queueName)) {
-    const config = getConfig();
-    const queue = new Queue(queueName, {
-      prefix: config.prefix,
-      connection: {
-        host: config.redis.host,
-        port: config.redis.port,
-        username: config.redis.username,
-        password: config.redis.password,
-        db: config.redis.db,
-        ...config.redis.tls ? { tls: {} } : {}
-      }
-    });
-    queueCache.set(queueName, queue);
-  }
-  return queueCache.get(queueName);
-}
-async function discoverQueueNames() {
-  const config = getConfig();
-  if (config.queueNames && config.queueNames.length > 0) {
-    return config.queueNames;
-  }
-  const now = Date.now();
-  if (queueNamesCache && now - queueNamesCache.timestamp < QUEUE_NAMES_CACHE_TTL) {
-    return queueNamesCache.names;
-  }
-  const redis = await getRedisClient();
-  const queueNames = new Set;
-  const prefix = config.prefix + ":";
-  let cursor = "0";
-  do {
-    const [nextCursor, keys] = await redis.scan(cursor, "MATCH", `${config.prefix}:*`, "COUNT", SCAN_COUNT);
-    cursor = nextCursor;
-    for (const key of keys) {
-      if (key.startsWith(prefix)) {
-        const rest = key.slice(prefix.length);
-        const colonIdx = rest.indexOf(":");
-        const queueName = colonIdx === -1 ? rest : rest.slice(0, colonIdx);
-        if (queueName) {
-          queueNames.add(queueName);
-        }
-      }
-    }
-  } while (cursor !== "0");
-  const sortedNames = Array.from(queueNames).toSorted();
-  queueNamesCache = {
-    names: sortedNames,
-    timestamp: now
-  };
-  return sortedNames;
-}
-async function getQueueStats(queueName) {
-  const queue = getQueue(queueName);
-  const [counts, isPaused, schedulersCount] = await Promise.all([
-    queue.getJobCounts(),
-    queue.isPaused(),
-    queue.getJobSchedulersCount()
-  ]);
-  const waitCount = (counts.waiting || 0) + (counts.prioritized || 0);
-  return {
-    name: queueName,
-    counts: {
-      wait: waitCount,
-      active: counts.active || 0,
-      completed: counts.completed || 0,
-      failed: counts.failed || 0,
-      delayed: counts.delayed || 0,
-      schedulers: schedulersCount || 0
-    },
-    isPaused,
-    total: waitCount + (counts.active || 0) + (counts.completed || 0) + (counts.failed || 0) + (counts.delayed || 0)
-  };
-}
-async function getAllQueueStats() {
-  const queueNames = await discoverQueueNames();
-  const stats = await Promise.all(queueNames.map((name) => getQueueStats(name)));
-  return stats;
-}
-async function closeAllQueues() {
-  const closePromises = Array.from(queueCache.values()).map((queue) => queue.close());
-  await Promise.all(closePromises);
-  queueCache.clear();
-  queueNamesCache = null;
-}
-async function deleteQueue(queueName, dryRun = false) {
-  const queue = getQueue(queueName);
-  const counts = await queue.getJobCounts();
-  const result = {
-    name: queueName,
-    counts: {
-      wait: (counts.waiting || 0) + (counts.prioritized || 0),
-      active: counts.active || 0,
-      completed: counts.completed || 0,
-      failed: counts.failed || 0,
-      delayed: counts.delayed || 0
-    }
-  };
-  if (!dryRun) {
-    await queue.obliterate({ force: true });
-    const config = getConfig();
-    const redis = await getRedisClient();
-    const escapedQueueName = queueName.replace(/[[*?]/g, "\\$&");
-    const repeatKeyPattern = `${config.prefix}:${escapedQueueName}:*`;
-    const allKeys = [];
-    let cursor = "0";
-    do {
-      const [nextCursor, keys] = await redis.scan(cursor, "MATCH", repeatKeyPattern, "COUNT", SCAN_COUNT);
-      cursor = nextCursor;
-      allKeys.push(...keys);
-    } while (cursor !== "0");
-    if (allKeys.length > 0) {
-      for (let i = 0;i < allKeys.length; i += DEL_BATCH_SIZE) {
-        const batch = allKeys.slice(i, i + DEL_BATCH_SIZE);
-        await redis.del(...batch);
-      }
-    }
-    await queue.close();
-    queueCache.delete(queueName);
-    if (queueNamesCache) {
-      queueNamesCache.names = queueNamesCache.names.filter((n) => n !== queueName);
-    }
-  }
-  return result;
-}
-
-// src/data/duration.ts
-var DURATION_PATTERN = /^(\d+)([smhd])$/;
-var MS_PER_UNIT = {
-  s: 1000,
-  m: 60 * 1000,
-  h: 60 * 60 * 1000,
-  d: 24 * 60 * 60 * 1000
-};
-var DEFAULT_RETRY_PAGE_SIZE = 1000;
-var MAX_RETRY_PAGE_SIZE = 1e4;
-function parseDuration(raw) {
-  const match = DURATION_PATTERN.exec(raw);
-  if (!match)
-    return null;
-  const n = parseInt(match[1], 10);
-  const unit = match[2];
-  if (!Number.isFinite(n) || n <= 0)
-    return null;
-  const unitMs = MS_PER_UNIT[unit];
-  if (!unitMs)
-    return null;
-  return n * unitMs;
-}
-
-// src/data/sqlite.ts
-import { Database } from "bun:sqlite";
-var db = null;
-var SCHEMA = `
-CREATE TABLE IF NOT EXISTS jobs (
-  id TEXT NOT NULL,
-  queue TEXT NOT NULL,
-  name TEXT,
-  state TEXT NOT NULL,
-  timestamp INTEGER,
-  data_preview TEXT,
-  removed_at INTEGER,
-  PRIMARY KEY (queue, id)
-);
-
-CREATE INDEX IF NOT EXISTS idx_jobs_queue_state ON jobs(queue, state);
-CREATE INDEX IF NOT EXISTS idx_jobs_name ON jobs(name);
-CREATE INDEX IF NOT EXISTS idx_jobs_timestamp ON jobs(timestamp);
-CREATE INDEX IF NOT EXISTS idx_jobs_active
-  ON jobs(queue, state, timestamp) WHERE removed_at IS NULL;
--- Covers the disconnected-fallback "latest" view: queue + removed_at IS NULL,
--- ordered by timestamp DESC. Without this, the planner falls back to
--- idx_jobs_queue_state + a TEMP B-TREE sort, which is O(n log n) over the
--- queue's live rows and becomes the bottleneck at multi-million row scale.
-CREATE INDEX IF NOT EXISTS idx_jobs_queue_timestamp_live
-  ON jobs(queue, timestamp DESC) WHERE removed_at IS NULL;
-`;
-var QUEUES_SCHEMA = `
-CREATE TABLE IF NOT EXISTS queues (
-  name TEXT PRIMARY KEY,
-  wait_count INTEGER NOT NULL DEFAULT 0,
-  active_count INTEGER NOT NULL DEFAULT 0,
-  completed_count INTEGER NOT NULL DEFAULT 0,
-  failed_count INTEGER NOT NULL DEFAULT 0,
-  delayed_count INTEGER NOT NULL DEFAULT 0,
-  schedulers_count INTEGER NOT NULL DEFAULT 0,
-  is_paused INTEGER NOT NULL DEFAULT 0
-);
-`;
-var SCHEDULERS_SCHEMA = `
-CREATE TABLE IF NOT EXISTS schedulers (
-  queue TEXT NOT NULL,
-  key TEXT NOT NULL,
-  name TEXT NOT NULL,
-  pattern TEXT,
-  every INTEGER,
-  next INTEGER,
-  iteration_count INTEGER,
-  tz TEXT,
-  PRIMARY KEY (queue, key)
-);
-`;
-function migrateRemovedAtColumn(database) {
-  const cols = database.prepare("PRAGMA table_info(jobs)").all();
-  if (cols.length === 0)
-    return;
-  if (cols.some((c) => c.name === "removed_at"))
-    return;
-  database.exec("ALTER TABLE jobs ADD COLUMN removed_at INTEGER");
-}
-var FTS_SCHEMA = `
-CREATE VIRTUAL TABLE IF NOT EXISTS jobs_fts USING fts5(
-  id,
-  queue,
-  name,
-  data_preview,
-  content='jobs',
-  content_rowid='rowid'
-);
-
--- Keep FTS in sync via triggers
-CREATE TRIGGER IF NOT EXISTS jobs_ai AFTER INSERT ON jobs BEGIN
-  INSERT INTO jobs_fts(rowid, id, queue, name, data_preview)
-  VALUES (new.rowid, new.id, new.queue, new.name, new.data_preview);
-END;
-
-CREATE TRIGGER IF NOT EXISTS jobs_ad AFTER DELETE ON jobs BEGIN
-  INSERT INTO jobs_fts(jobs_fts, rowid, id, queue, name, data_preview)
-  VALUES ('delete', old.rowid, old.id, old.queue, old.name, old.data_preview);
-END;
-
-CREATE TRIGGER IF NOT EXISTS jobs_au AFTER UPDATE ON jobs BEGIN
-  INSERT INTO jobs_fts(jobs_fts, rowid, id, queue, name, data_preview)
-  VALUES ('delete', old.rowid, old.id, old.queue, old.name, old.data_preview);
-  INSERT INTO jobs_fts(rowid, id, queue, name, data_preview)
-  VALUES (new.rowid, new.id, new.queue, new.name, new.data_preview);
-END;
-`;
-var SYNC_STATE_SCHEMA = `
-CREATE TABLE IF NOT EXISTS sync_state (
-  queue TEXT PRIMARY KEY,
-  job_count INTEGER NOT NULL DEFAULT 0,
-  synced_at INTEGER NOT NULL DEFAULT 0
-);
-`;
-function createSqliteDb(dbPath) {
-  const config = getConfig();
-  const path = dbPath ?? `/tmp/bullmq-dash-${config.redis.host}-${config.redis.port}.db`;
-  db = new Database(path);
-  db.exec("PRAGMA journal_mode=WAL");
-  db.exec("PRAGMA synchronous=NORMAL");
-  migrateRemovedAtColumn(db);
-  db.exec(SCHEMA);
-  db.exec(QUEUES_SCHEMA);
-  db.exec(SCHEDULERS_SCHEMA);
-  db.exec(FTS_SCHEMA);
-  db.exec(SYNC_STATE_SCHEMA);
-  return db;
-}
-function getSqliteDb() {
-  if (!db) {
-    return createSqliteDb();
-  }
-  return db;
-}
-function closeSqliteDb() {
-  if (db) {
-    db.close();
-    db = null;
-  }
-}
-function viewClause(view, alias) {
-  const col = `${alias}removed_at`;
-  switch (view) {
-    case "live":
-      return `${col} IS NULL`;
-    case "history":
-      return `${col} IS NOT NULL`;
-    case "all":
-      return "";
-  }
-}
-function appendStateClause(conditions, values, state, prefix) {
-  if (Array.isArray(state)) {
-    conditions.push(`${prefix}state IN (${state.map(() => "?").join(",")})`);
-    values.push(...state);
-  } else if (state && state !== "all") {
-    conditions.push(`${prefix}state = ?`);
-    values.push(state);
-  }
-}
-function upsertQueueStats(queues) {
-  const database = getSqliteDb();
-  const stmt = database.prepare(`
-    INSERT INTO queues (
-      name,
-      wait_count,
-      active_count,
-      completed_count,
-      failed_count,
-      delayed_count,
-      schedulers_count,
-      is_paused
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(name) DO UPDATE SET
-      wait_count = excluded.wait_count,
-      active_count = excluded.active_count,
-      completed_count = excluded.completed_count,
-      failed_count = excluded.failed_count,
-      delayed_count = excluded.delayed_count,
-      schedulers_count = excluded.schedulers_count,
-      is_paused = excluded.is_paused
-  `);
-  const replaceObservedQueues = database.transaction((items) => {
-    if (items.length === 0) {
-      database.prepare("DELETE FROM queues").run();
-      database.prepare("DELETE FROM schedulers").run();
-      return;
-    }
-    for (const queue of items) {
-      stmt.run(queue.name, queue.counts.wait, queue.counts.active, queue.counts.completed, queue.counts.failed, queue.counts.delayed, queue.counts.schedulers, queue.isPaused ? 1 : 0);
-    }
-    const placeholders = items.map(() => "?").join(",");
-    const names = items.map((queue) => queue.name);
-    database.prepare(`DELETE FROM queues WHERE name NOT IN (${placeholders})`).run(...names);
-    database.prepare(`DELETE FROM schedulers WHERE queue NOT IN (${placeholders})`).run(...names);
-  });
-  replaceObservedQueues(queues);
-}
-function upsertSchedulers(queue, schedulers) {
-  const database = getSqliteDb();
-  const stmt = database.prepare(`
-    INSERT INTO schedulers (queue, key, name, pattern, every, next, iteration_count, tz)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(queue, key) DO UPDATE SET
-      name = excluded.name,
-      pattern = excluded.pattern,
-      every = excluded.every,
-      next = excluded.next,
-      iteration_count = excluded.iteration_count,
-      tz = excluded.tz
-  `);
-  const replaceForQueue = database.transaction((items) => {
-    if (items.length === 0) {
-      database.prepare("DELETE FROM schedulers WHERE queue = ?").run(queue);
-      return;
-    }
-    for (const s of items) {
-      stmt.run(queue, s.key, s.name, s.pattern ?? null, s.every ?? null, s.next ?? null, s.iterationCount ?? null, s.tz ?? null);
-    }
-    const placeholders = items.map(() => "?").join(",");
-    database.prepare(`DELETE FROM schedulers WHERE queue = ? AND key NOT IN (${placeholders})`).run(queue, ...items.map((s) => s.key));
-  });
-  replaceForQueue(schedulers);
-}
-function querySchedulers(queue, page = 1, pageSize = 25) {
-  const database = getSqliteDb();
-  const offset = (page - 1) * pageSize;
-  const { total } = database.prepare("SELECT COUNT(*) as total FROM schedulers WHERE queue = ?").get(queue);
-  const rows = database.prepare(`
-      SELECT key, name, pattern, every, next, iteration_count, tz
-      FROM schedulers
-      WHERE queue = ?
-      ORDER BY key ASC
-      LIMIT ? OFFSET ?
-    `).all(queue, pageSize, offset);
-  const schedulers = rows.map((row) => ({
-    key: row.key,
-    name: row.name,
-    pattern: row.pattern ?? undefined,
-    every: row.every ?? undefined,
-    next: row.next ?? undefined,
-    iterationCount: row.iteration_count ?? undefined,
-    tz: row.tz ?? undefined
-  }));
-  return { schedulers, total };
-}
-function queryQueueStats() {
-  const database = getSqliteDb();
-  const rows = database.prepare(`
-      SELECT
-        name,
-        wait_count,
-        active_count,
-        completed_count,
-        failed_count,
-        delayed_count,
-        schedulers_count,
-        is_paused
-      FROM queues
-      ORDER BY name ASC
-    `).all();
-  return rows.map((row) => {
-    const counts = {
-      wait: row.wait_count,
-      active: row.active_count,
-      completed: row.completed_count,
-      failed: row.failed_count,
-      delayed: row.delayed_count,
-      schedulers: row.schedulers_count
-    };
-    return {
-      name: row.name,
-      counts,
-      isPaused: row.is_paused === 1,
-      total: counts.wait + counts.active + counts.completed + counts.failed + counts.delayed
-    };
-  });
-}
-function queryJobs(params) {
-  const database = getSqliteDb();
-  const {
-    queue,
-    search,
-    state,
-    sort = "timestamp",
-    order = "desc",
-    page = 1,
-    pageSize = 25,
-    view = "live"
-  } = params;
-  const validSorts = ["id", "name", "state", "timestamp"];
-  const sortCol = validSorts.includes(sort) ? sort : "timestamp";
-  const sortOrder = order === "asc" ? "ASC" : "DESC";
-  const offset = (page - 1) * pageSize;
-  if (Array.isArray(state) && state.length === 0) {
-    return { jobs: [], total: 0 };
-  }
-  if (search) {
-    const conditions2 = ["j.queue = ?"];
-    const values2 = [queue];
-    appendStateClause(conditions2, values2, state, "j.");
-    const viewSql2 = viewClause(view, "j.");
-    if (viewSql2)
-      conditions2.push(viewSql2);
-    const where2 = conditions2.join(" AND ");
-    const ftsMatch = `${search}*`;
-    const countSql2 = `SELECT COUNT(*) as total FROM jobs j JOIN jobs_fts fts ON j.rowid = fts.rowid WHERE ${where2} AND jobs_fts MATCH ?`;
-    const total2 = database.prepare(countSql2).get(...values2, ftsMatch).total;
-    const qualifiedSort = `j.${sortCol}`;
-    const sql2 = `SELECT j.* FROM jobs j JOIN jobs_fts fts ON j.rowid = fts.rowid WHERE ${where2} AND jobs_fts MATCH ? ORDER BY ${qualifiedSort} ${sortOrder} LIMIT ? OFFSET ?`;
-    const jobs2 = database.prepare(sql2).all(...values2, ftsMatch, pageSize, offset);
-    return { jobs: jobs2, total: total2 };
-  }
-  const conditions = ["queue = ?"];
-  const values = [queue];
-  appendStateClause(conditions, values, state, "");
-  const viewSql = viewClause(view, "");
-  if (viewSql)
-    conditions.push(viewSql);
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const countSql = `SELECT COUNT(*) as total FROM jobs ${where}`;
-  const total = database.prepare(countSql).get(...values).total;
-  const sql = `SELECT * FROM jobs ${where} ORDER BY ${sortCol} ${sortOrder} LIMIT ? OFFSET ?`;
-  const jobs = database.prepare(sql).all(...values, pageSize, offset);
-  return { jobs, total };
-}
-function safeDataPreview(data) {
-  if (data === undefined || data === null)
+  const n = parseInt(match[1], 10);
+  const unit = match[2];
+  if (!Number.isFinite(n) || n <= 0)
     return null;
-  try {
-    return JSON.stringify(data).slice(0, 500);
-  } catch {
+  const unitMs = MS_PER_UNIT[unit];
+  if (!unitMs)
     return null;
-  }
-}
-function upsertJobs(queue, jobs) {
-  const database = getSqliteDb();
-  const stmt = database.prepare(`
-    INSERT INTO jobs (id, queue, name, state, timestamp, data_preview)
-    VALUES (?, ?, ?, ?, ?, ?)
-    ON CONFLICT(queue, id) DO UPDATE SET
-      name = excluded.name,
-      state = excluded.state,
-      timestamp = excluded.timestamp,
-      data_preview = excluded.data_preview
-  `);
-  const upsert = database.transaction((items) => {
-    for (const job of items) {
-      const dataPreview = safeDataPreview(job.data);
-      stmt.run(job.id, queue, job.name, job.state, job.timestamp, dataPreview);
-    }
-  });
-  upsert(jobs);
-}
-function upsertJobStubs(queue, jobs) {
-  const database = getSqliteDb();
-  const stmt = database.prepare(`
-    INSERT INTO jobs (id, queue, name, state, timestamp, data_preview)
-    VALUES (?, ?, NULL, ?, NULL, NULL)
-    ON CONFLICT(queue, id) DO UPDATE SET
-      state = excluded.state
-  `);
-  const upsert = database.transaction((items) => {
-    for (const job of items) {
-      stmt.run(job.id, queue, job.state);
-    }
-  });
-  upsert(jobs);
-}
-function upsertSyncState(queue, input) {
-  const database = getSqliteDb();
-  database.prepare(`
-    INSERT INTO sync_state (queue, job_count, synced_at)
-    VALUES (?, ?, ?)
-    ON CONFLICT(queue) DO UPDATE SET
-      job_count = excluded.job_count,
-      synced_at = excluded.synced_at
-  `).run(queue, input.jobCount, input.syncedAt);
-}
-function createSyncStaging() {
-  const database = getSqliteDb();
-  database.exec(`
-    DROP TABLE IF EXISTS main.sync_staging;
-    DROP TABLE IF EXISTS temp.sync_staging;
-    CREATE TEMP TABLE sync_staging (
-      id TEXT NOT NULL,
-      queue TEXT NOT NULL,
-      state TEXT NOT NULL,
-      PRIMARY KEY (queue, id)
-    );
-  `);
-}
-function insertStagingBatch(queue, jobs) {
-  if (jobs.length === 0)
-    return;
-  const database = getSqliteDb();
-  const stmt = database.prepare("INSERT OR IGNORE INTO sync_staging (id, queue, state) VALUES (?, ?, ?)");
-  const insert = database.transaction((items) => {
-    for (const job of items) {
-      stmt.run(job.id, queue, job.state);
-    }
-  });
-  insert(jobs);
-}
-function findResurrectedIdsByStagingDiff(queue) {
-  const database = getSqliteDb();
-  const rows = database.prepare(`
-    SELECT s.id FROM sync_staging s
-    JOIN jobs j ON s.queue = j.queue AND s.id = j.id
-    WHERE s.queue = ? AND j.removed_at IS NOT NULL
-  `).all(queue);
-  return rows.map((r) => r.id);
-}
-function findNewIdsByStagingDiff(queue) {
-  const database = getSqliteDb();
-  return database.prepare(`
-    SELECT s.id, s.state FROM sync_staging s
-    LEFT JOIN jobs j ON s.queue = j.queue AND s.id = j.id
-    WHERE s.queue = ? AND j.id IS NULL
-  `).all(queue);
-}
-function findChangedIdsByStagingDiff(queue) {
-  const database = getSqliteDb();
-  return database.prepare(`
-    SELECT s.id, s.state FROM sync_staging s
-    JOIN jobs j ON s.queue = j.queue AND s.id = j.id
-    WHERE s.queue = ? AND j.removed_at IS NULL AND s.state != j.state
-  `).all(queue);
-}
-function findStaleIdsByStagingDiff(queue) {
-  const database = getSqliteDb();
-  const rows = database.prepare(`
-    SELECT j.id FROM jobs j
-    LEFT JOIN sync_staging s ON j.queue = s.queue AND j.id = s.id
-    WHERE j.queue = ? AND j.removed_at IS NULL AND s.id IS NULL
-  `).all(queue);
-  return rows.map((r) => r.id);
-}
-function softDeleteJobsByIds(queue, ids, now) {
-  if (ids.length === 0)
-    return 0;
-  const database = getSqliteDb();
-  const BATCH_SIZE = 900;
-  const run = database.transaction(() => {
-    for (let i = 0;i < ids.length; i += BATCH_SIZE) {
-      const batch = ids.slice(i, i + BATCH_SIZE);
-      const placeholders = batch.map(() => "?").join(",");
-      database.prepare(`UPDATE jobs SET removed_at = ? WHERE queue = ? AND id IN (${placeholders})`).run(now, queue, ...batch);
-    }
-  });
-  run();
-  return ids.length;
-}
-function compactRemovedJobs(now, retentionMs) {
-  const database = getSqliteDb();
-  const cutoff = now - retentionMs;
-  const filter = "removed_at IS NOT NULL AND removed_at < ?";
-  const run = database.transaction(() => {
-    const { n } = database.prepare(`SELECT COUNT(*) as n FROM jobs WHERE ${filter}`).get(cutoff);
-    if (n > 0) {
-      database.prepare(`DELETE FROM jobs WHERE ${filter}`).run(cutoff);
-    }
-    return n;
-  });
-  return run();
-}
-function dropSyncStaging() {
-  const database = getSqliteDb();
-  database.exec("DROP TABLE IF EXISTS sync_staging");
+  return n * unitMs;
 }
 
 // src/data/jobs.ts
 var PAGE_SIZE = 25;
 var DEFAULT_MAX_RESULTS = 1000;
-var SYNC_JOB_TYPES = [
-  "active",
-  "waiting",
-  "completed",
-  "failed",
-  "delayed",
-  "prioritized"
-];
-var SYNC_PAGE_SIZE = 5000;
 var VALID_JOB_STATUSES = ["wait", "active", "completed", "failed", "delayed"];
-async function getAllJobs(queueName, status, maxResults = DEFAULT_MAX_RESULTS, includeData = false) {
-  const queue = getQueue(queueName);
+async function getAllJobs(ctx, queueName, status, maxResults = DEFAULT_MAX_RESULTS, includeData = false) {
+  const queue = getQueue(ctx, queueName);
   const end = maxResults - 1;
   let tagged;
   let total;
@@ -1346,27 +540,8 @@ async function getAllJobs(queueName, status, maxResults = DEFAULT_MAX_RESULTS, i
   });
   return { jobs: jobSummaries, total };
 }
-async function* getAllJobIds(queueName) {
-  const queue = getQueue(queueName);
-  for (const type of SYNC_JOB_TYPES) {
-    let offset = 0;
-    while (true) {
-      const end = offset + SYNC_PAGE_SIZE - 1;
-      const ids = await queue.getRanges([type], offset, end);
-      if (ids.length === 0)
-        break;
-      const batch = ids.filter((id) => typeof id === "string" && id !== "").map((id) => ({ id, state: type }));
-      if (batch.length > 0) {
-        yield batch;
-      }
-      if (ids.length < SYNC_PAGE_SIZE)
-        break;
-      offset += SYNC_PAGE_SIZE;
-    }
-  }
-}
-async function getJobs(queueName, status, page = 1, pageSize = PAGE_SIZE, includeData = false) {
-  const queue = getQueue(queueName);
+async function getJobs(ctx, queueName, status, page = 1, pageSize = PAGE_SIZE, includeData = false) {
+  const queue = getQueue(ctx, queueName);
   const start = (page - 1) * pageSize;
   const end = start + pageSize - 1;
   let tagged;
@@ -1431,7 +606,7 @@ async function getJobs(queueName, status, page = 1, pageSize = PAGE_SIZE, includ
         total = delayedCounts.delayed || 0;
         break;
       case "schedulers":
-        throw new Error("Cannot fetch schedulers via getJobs(). Use getJobSchedulers() instead.");
+        throw new Error("Cannot fetch schedulers via getJobs(). Use getAllJobSchedulers() instead.");
       default:
         tagged = [];
         total = 0;
@@ -1457,45 +632,8 @@ async function getJobs(queueName, status, page = 1, pageSize = PAGE_SIZE, includ
     totalPages: Math.ceil(total / pageSize)
   };
 }
-function rowToJobSummary(row) {
-  return {
-    id: row.id,
-    name: row.name ?? "unknown",
-    state: row.state,
-    timestamp: row.timestamp ?? 0
-  };
-}
-function storeStateFilter(status) {
-  switch (status) {
-    case "latest":
-      return;
-    case "wait":
-      return ["waiting", "prioritized"];
-    case "schedulers":
-      throw new Error("Cannot fetch schedulers via getJobsFromStore(). Use getJobSchedulers() instead.");
-    default:
-      return status;
-  }
-}
-async function getJobsFromStore(queueName, status, page = 1, pageSize = PAGE_SIZE) {
-  const result = queryJobs({
-    queue: queueName,
-    state: storeStateFilter(status),
-    sort: "timestamp",
-    order: "desc",
-    page,
-    pageSize
-  });
-  return {
-    jobs: result.jobs.map(rowToJobSummary),
-    total: result.total,
-    page,
-    pageSize,
-    totalPages: Math.ceil(result.total / pageSize)
-  };
-}
-async function getJobDetail(queueName, jobId) {
-  const queue = getQueue(queueName);
+async function getJobDetail(ctx, queueName, jobId) {
+  const queue = getQueue(ctx, queueName);
   const job = await queue.getJob(jobId);
   if (!job) {
     return null;
@@ -1519,8 +657,8 @@ async function getJobDetail(queueName, jobId) {
     delay: job.delay
   };
 }
-async function deleteJob(queueName, jobId) {
-  const queue = getQueue(queueName);
+async function deleteJob(ctx, queueName, jobId) {
+  const queue = getQueue(ctx, queueName);
   const job = await queue.getJob(jobId);
   if (!job) {
     return false;
@@ -1529,7 +667,7 @@ async function deleteJob(queueName, jobId) {
   return true;
 }
 var SAMPLE_ID_COUNT = 5;
-async function retryFailedJobs(queueName, options) {
+async function retryFailedJobs(ctx, queueName, options) {
   const pageSize = Math.min(options.pageSize ?? DEFAULT_RETRY_PAGE_SIZE, MAX_RETRY_PAGE_SIZE);
   const dryRun = options.dryRun ?? false;
   let cutoffMs;
@@ -1540,22 +678,51 @@ async function retryFailedJobs(queueName, options) {
     }
     cutoffMs = Date.now() - durationMs;
   }
-  const queue = getQueue(queueName);
-  const [failedJobs, counts] = await Promise.all([
+  const queue = getQueue(ctx, queueName);
+  let failedJobs;
+  let truncated = false;
+  const countsPromise = queue.getJobCounts("failed");
+  if (options.jobId !== undefined) {
+    const [job, counts2] = await Promise.all([queue.getJob(options.jobId), countsPromise]);
+    const totalFailed2 = counts2.failed || 0;
+    if (!job) {
+      return {
+        matched: 0,
+        retried: 0,
+        errors: [],
+        sampleJobIds: [],
+        totalFailed: totalFailed2,
+        truncated: false
+      };
+    }
+    const state = await job.getState();
+    failedJobs = state === "failed" ? [job] : [];
+    const matched2 = applyRetryFilters(failedJobs, cutoffMs, options.name);
+    return retryMatchedJobs(matched2, totalFailed2, false, dryRun);
+  }
+  const [fetchedFailedJobs, counts] = await Promise.all([
     queue.getFailed(0, pageSize - 1),
-    queue.getJobCounts("failed")
+    countsPromise
   ]);
   const totalFailed = counts.failed || 0;
-  const matched = failedJobs.filter((job) => {
+  failedJobs = fetchedFailedJobs;
+  truncated = totalFailed > failedJobs.length;
+  const matched = applyRetryFilters(failedJobs, cutoffMs, options.name);
+  return retryMatchedJobs(matched, totalFailed, truncated, dryRun);
+}
+function applyRetryFilters(jobs, cutoffMs, name) {
+  return jobs.filter((job) => {
     if (cutoffMs !== undefined) {
       const whenFailed = job.finishedOn ?? job.timestamp ?? 0;
       if (whenFailed < cutoffMs)
         return false;
     }
-    if (options.name !== undefined && job.name !== options.name)
+    if (name !== undefined && job.name !== name)
       return false;
     return true;
   });
+}
+async function retryMatchedJobs(matched, totalFailed, truncated, dryRun) {
   const matchedIds = matched.map((job) => job.id).filter((id) => typeof id === "string" && id.length > 0);
   const sampleIds = matchedIds.slice(0, SAMPLE_ID_COUNT);
   if (dryRun) {
@@ -1565,7 +732,7 @@ async function retryFailedJobs(queueName, options) {
       errors: [],
       sampleJobIds: sampleIds,
       totalFailed,
-      truncated: totalFailed > failedJobs.length
+      truncated
     };
   }
   let retried = 0;
@@ -1587,7 +754,7 @@ async function retryFailedJobs(queueName, options) {
     errors,
     sampleJobIds: sampleIds,
     totalFailed,
-    truncated: totalFailed > failedJobs.length
+    truncated
   };
 }
 function formatRelativeTime(timestamp) {
@@ -1615,8 +782,8 @@ function formatTimestamp(timestamp) {
 
 // src/data/schedulers.ts
 var DEFAULT_MAX_RESULTS2 = 1000;
-async function getAllJobSchedulers(queueName, maxResults = DEFAULT_MAX_RESULTS2) {
-  const queue = getQueue(queueName);
+async function getAllJobSchedulers(ctx, queueName, maxResults = DEFAULT_MAX_RESULTS2) {
+  const queue = getQueue(ctx, queueName);
   const end = maxResults - 1;
   const [schedulers, total] = await Promise.all([
     queue.getJobSchedulers(0, end, false),
@@ -1633,8 +800,8 @@ async function getAllJobSchedulers(queueName, maxResults = DEFAULT_MAX_RESULTS2)
   }));
   return { schedulers: summaries, total };
 }
-async function getJobSchedulerDetail(queueName, schedulerKey) {
-  const queue = getQueue(queueName);
+async function getJobSchedulerDetail(ctx, queueName, schedulerKey) {
+  const queue = getQueue(ctx, queueName);
   const schedulers = await queue.getJobSchedulers(0, -1, false);
   const scheduler = schedulers.find((s) => s.key === schedulerKey);
   if (!scheduler) {
@@ -1801,219 +968,522 @@ var metricsTracker = new MetricsTracker;
 function resetMetricsTracker() {
   metricsTracker.reset();
 }
-function aggregateJobCounts(queues) {
-  const jobCounts = {
-    wait: 0,
-    active: 0,
-    completed: 0,
-    failed: 0,
-    delayed: 0,
-    total: 0
-  };
-  for (const { counts } of queues) {
-    jobCounts.wait += counts.wait;
-    jobCounts.active += counts.active;
-    jobCounts.completed += counts.completed;
-    jobCounts.failed += counts.failed;
-    jobCounts.delayed += counts.delayed;
+function aggregateJobCounts(queues) {
+  const jobCounts = {
+    wait: 0,
+    active: 0,
+    completed: 0,
+    failed: 0,
+    delayed: 0,
+    total: 0
+  };
+  for (const { counts } of queues) {
+    jobCounts.wait += counts.wait;
+    jobCounts.active += counts.active;
+    jobCounts.completed += counts.completed;
+    jobCounts.failed += counts.failed;
+    jobCounts.delayed += counts.delayed;
+  }
+  jobCounts.total = jobCounts.wait + jobCounts.active + jobCounts.completed + jobCounts.failed + jobCounts.delayed;
+  return jobCounts;
+}
+function calculateGlobalMetricsFromQueueStats(queues, rates) {
+  return {
+    queueCount: queues.length,
+    jobCounts: aggregateJobCounts(queues),
+    rates
+  };
+}
+function updateMetricsTracker(queues) {
+  return metricsTracker.update(aggregateJobCounts(queues));
+}
+
+// src/data/sqlite.ts
+import { Database } from "bun:sqlite";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS jobs (
+  id TEXT NOT NULL,
+  queue TEXT NOT NULL,
+  name TEXT,
+  state TEXT NOT NULL,
+  timestamp INTEGER,
+  data_preview TEXT,
+  data_json TEXT,
+  opts_json TEXT,
+  attempts_made INTEGER,
+  failed_reason TEXT,
+  stacktrace_json TEXT,
+  returnvalue_json TEXT,
+  processed_on INTEGER,
+  finished_on INTEGER,
+  progress_json TEXT,
+  repeat_job_key TEXT,
+  delay INTEGER,
+  last_observed_at INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (queue, id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_jobs_queue_state ON jobs(queue, state);
+CREATE INDEX IF NOT EXISTS idx_jobs_name ON jobs(name);
+CREATE INDEX IF NOT EXISTS idx_jobs_timestamp ON jobs(timestamp);
+CREATE INDEX IF NOT EXISTS idx_jobs_last_observed ON jobs(last_observed_at);
+CREATE INDEX IF NOT EXISTS idx_jobs_queue_timestamp
+  ON jobs(queue, timestamp DESC);
+`;
+var QUEUES_SCHEMA = `
+CREATE TABLE IF NOT EXISTS queues (
+  name TEXT PRIMARY KEY,
+  wait_count INTEGER NOT NULL DEFAULT 0,
+  active_count INTEGER NOT NULL DEFAULT 0,
+  completed_count INTEGER NOT NULL DEFAULT 0,
+  failed_count INTEGER NOT NULL DEFAULT 0,
+  delayed_count INTEGER NOT NULL DEFAULT 0,
+  schedulers_count INTEGER NOT NULL DEFAULT 0,
+  is_paused INTEGER NOT NULL DEFAULT 0,
+  last_observed_at INTEGER NOT NULL DEFAULT 0
+);
+`;
+var SCHEDULERS_SCHEMA = `
+CREATE TABLE IF NOT EXISTS schedulers (
+  queue TEXT NOT NULL,
+  key TEXT NOT NULL,
+  name TEXT NOT NULL,
+  pattern TEXT,
+  every INTEGER,
+  next INTEGER,
+  iteration_count INTEGER,
+  tz TEXT,
+  last_observed_at INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (queue, key)
+);
+`;
+function tableColumns(database, table) {
+  const cols = database.prepare(`PRAGMA table_info(${table})`).all();
+  return new Set(cols.map((c) => c.name));
+}
+function addColumnIfMissing(database, table, columns, sql) {
+  const match = sql.match(/ADD COLUMN\s+([a-z_]+)/i);
+  const name = match?.[1];
+  if (!name || columns.has(name))
+    return false;
+  database.exec(`ALTER TABLE ${table} ${sql}`);
+  columns.add(name);
+  return true;
+}
+function migrateCacheColumns(database, now) {
+  const jobCols = tableColumns(database, "jobs");
+  if (jobCols.size > 0) {
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN data_json TEXT");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN opts_json TEXT");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN attempts_made INTEGER");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN failed_reason TEXT");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN stacktrace_json TEXT");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN returnvalue_json TEXT");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN processed_on INTEGER");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN finished_on INTEGER");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN progress_json TEXT");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN repeat_job_key TEXT");
+    addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN delay INTEGER");
+    if (addColumnIfMissing(database, "jobs", jobCols, "ADD COLUMN last_observed_at INTEGER NOT NULL DEFAULT 0")) {
+      database.prepare("UPDATE jobs SET last_observed_at = ?").run(now);
+    }
+  }
+  const queueCols = tableColumns(database, "queues");
+  if (queueCols.size > 0 && addColumnIfMissing(database, "queues", queueCols, "ADD COLUMN last_observed_at INTEGER NOT NULL DEFAULT 0")) {
+    database.prepare("UPDATE queues SET last_observed_at = ?").run(now);
+  }
+  const schedulerCols = tableColumns(database, "schedulers");
+  if (schedulerCols.size > 0 && addColumnIfMissing(database, "schedulers", schedulerCols, "ADD COLUMN last_observed_at INTEGER NOT NULL DEFAULT 0")) {
+    database.prepare("UPDATE schedulers SET last_observed_at = ?").run(now);
   }
-  jobCounts.total = jobCounts.wait + jobCounts.active + jobCounts.completed + jobCounts.failed + jobCounts.delayed;
-  return jobCounts;
-}
-function calculateGlobalMetricsFromQueueStats(queues, rates) {
-  return {
-    queueCount: queues.length,
-    jobCounts: aggregateJobCounts(queues),
-    rates
-  };
-}
-function updateMetricsTracker(queues) {
-  return metricsTracker.update(aggregateJobCounts(queues));
 }
+var FTS_SCHEMA = `
+CREATE VIRTUAL TABLE IF NOT EXISTS jobs_fts USING fts5(
+  id,
+  queue,
+  name,
+  data_preview,
+  content='jobs',
+  content_rowid='rowid'
+);
 
-// src/data/sync.ts
-var syncInProgress = false;
-var syncLockAcquiredAt = null;
-var SYNC_LOCK_TIMEOUT_MS = 10 * 60 * 1000;
+-- Keep FTS in sync via triggers
+CREATE TRIGGER IF NOT EXISTS jobs_ai AFTER INSERT ON jobs BEGIN
+  INSERT INTO jobs_fts(rowid, id, queue, name, data_preview)
+  VALUES (new.rowid, new.id, new.queue, new.name, new.data_preview);
+END;
 
-class JobResurrectionError extends Error {
-  constructor(queueName, ids) {
-    super(`Resurrected job IDs detected in queue "${queueName}": ` + `${ids.join(", ")}. ` + `Soft-deleted IDs are not allowed to reappear in Redis.`);
-    this.name = "JobResurrectionError";
-  }
-}
+CREATE TRIGGER IF NOT EXISTS jobs_ad AFTER DELETE ON jobs BEGIN
+  INSERT INTO jobs_fts(jobs_fts, rowid, id, queue, name, data_preview)
+  VALUES ('delete', old.rowid, old.id, old.queue, old.name, old.data_preview);
+END;
 
-class FullSyncInvariantError extends Error {
-  errors;
-  constructor(errors) {
-    super(`SQLite full sync invariant violation in ${errors.length} queue(s): ` + errors.map((e) => `${e.queue}: ${e.error}`).join("; "));
-    this.errors = errors;
-    this.name = "FullSyncInvariantError";
+CREATE TRIGGER IF NOT EXISTS jobs_au AFTER UPDATE ON jobs BEGIN
+  INSERT INTO jobs_fts(jobs_fts, rowid, id, queue, name, data_preview)
+  VALUES ('delete', old.rowid, old.id, old.queue, old.name, old.data_preview);
+  INSERT INTO jobs_fts(rowid, id, queue, name, data_preview)
+  VALUES (new.rowid, new.id, new.queue, new.name, new.data_preview);
+END;
+`;
+function createSqliteDb(config, dbPath) {
+  const path = dbPath ?? `/tmp/bullmq-dash-${config.redis.host}-${config.redis.port}.db`;
+  const handle = new Database(path);
+  handle.exec("PRAGMA journal_mode=WAL");
+  handle.exec("PRAGMA synchronous=NORMAL");
+  migrateCacheColumns(handle, Date.now());
+  handle.exec(SCHEMA);
+  handle.exec(QUEUES_SCHEMA);
+  handle.exec(SCHEDULERS_SCHEMA);
+  handle.exec(FTS_SCHEMA);
+  return handle;
+}
+function appendStateClause(conditions, values, state, prefix) {
+  if (Array.isArray(state)) {
+    conditions.push(`${prefix}state IN (${state.map(() => "?").join(",")})`);
+    values.push(...state);
+  } else if (state && state !== "all") {
+    conditions.push(`${prefix}state = ?`);
+    values.push(state);
   }
 }
-function tryAcquireSyncLock() {
-  if (syncInProgress && syncLockAcquiredAt !== null) {
-    const heldForMs = Date.now() - syncLockAcquiredAt;
-    if (heldForMs <= SYNC_LOCK_TIMEOUT_MS) {
-      return { ok: false, heldForMs };
+function upsertQueueStats(ctx, queues, observedAt = Date.now()) {
+  const database = ctx.db;
+  const stmt = database.prepare(`
+    INSERT INTO queues (
+      name,
+      wait_count,
+      active_count,
+      completed_count,
+      failed_count,
+      delayed_count,
+      schedulers_count,
+      is_paused,
+      last_observed_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(name) DO UPDATE SET
+      wait_count = excluded.wait_count,
+      active_count = excluded.active_count,
+      completed_count = excluded.completed_count,
+      failed_count = excluded.failed_count,
+      delayed_count = excluded.delayed_count,
+      schedulers_count = excluded.schedulers_count,
+      is_paused = excluded.is_paused,
+      last_observed_at = excluded.last_observed_at
+  `);
+  const runUpsert = database.transaction((items) => {
+    for (const queue of items) {
+      stmt.run(queue.name, queue.counts.wait, queue.counts.active, queue.counts.completed, queue.counts.failed, queue.counts.delayed, queue.counts.schedulers, queue.isPaused ? 1 : 0, observedAt);
     }
-    console.error(`Sync lock held for ${heldForMs}ms (> ${SYNC_LOCK_TIMEOUT_MS}ms timeout) \u2014 stealing.`);
-  }
-  syncInProgress = true;
-  syncLockAcquiredAt = Date.now();
-  return { ok: true };
+  });
+  runUpsert(queues);
 }
-function releaseSyncLock() {
-  syncInProgress = false;
-  syncLockAcquiredAt = null;
+function upsertSchedulers(ctx, queue, schedulers, observedAt = Date.now()) {
+  const database = ctx.db;
+  const stmt = database.prepare(`
+    INSERT INTO schedulers (
+      queue,
+      key,
+      name,
+      pattern,
+      every,
+      next,
+      iteration_count,
+      tz,
+      last_observed_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(queue, key) DO UPDATE SET
+      name = excluded.name,
+      pattern = excluded.pattern,
+      every = excluded.every,
+      next = excluded.next,
+      iteration_count = excluded.iteration_count,
+      tz = excluded.tz,
+      last_observed_at = excluded.last_observed_at
+  `);
+  const runUpsert = database.transaction((items) => {
+    for (const s of items) {
+      stmt.run(queue, s.key, s.name, s.pattern ?? null, s.every ?? null, s.next ?? null, s.iterationCount ?? null, s.tz ?? null, observedAt);
+    }
+  });
+  runUpsert(schedulers);
 }
-var recentlyPolledWrites = new Map;
-var RECENT_POLL_WINDOW_MS = 120000;
-var RECENT_POLL_MAX_ENTRIES = 50000;
-function pruneRecentlyPolled() {
-  const cutoff = Date.now() - RECENT_POLL_WINDOW_MS;
-  for (const [key, ts] of recentlyPolledWrites) {
-    if (ts < cutoff)
-      recentlyPolledWrites.delete(key);
-  }
+function querySchedulers(ctx, queue, page = 1, pageSize = 25) {
+  const database = ctx.db;
+  const offset = (page - 1) * pageSize;
+  const { total } = database.prepare("SELECT COUNT(*) as total FROM schedulers WHERE queue = ?").get(queue);
+  const rows = database.prepare(`
+      SELECT key, name, pattern, every, next, iteration_count, tz, last_observed_at
+      FROM schedulers
+      WHERE queue = ?
+      ORDER BY key ASC
+      LIMIT ? OFFSET ?
+    `).all(queue, pageSize, offset);
+  const schedulers = rows.map((row) => ({
+    key: row.key,
+    name: row.name,
+    pattern: row.pattern ?? undefined,
+    every: row.every ?? undefined,
+    next: row.next ?? undefined,
+    iterationCount: row.iteration_count ?? undefined,
+    tz: row.tz ?? undefined,
+    lastObservedAt: row.last_observed_at
+  }));
+  return { schedulers, total };
 }
-function markPolledWrites(queue, jobIds) {
-  const now = Date.now();
-  for (const id of jobIds) {
-    recentlyPolledWrites.set(`${queue}:${id}`, now);
+function queryQueueStats(ctx) {
+  const database = ctx.db;
+  const rows = database.prepare(`
+      SELECT
+        name,
+        wait_count,
+        active_count,
+        completed_count,
+        failed_count,
+        delayed_count,
+        schedulers_count,
+        is_paused,
+        last_observed_at
+      FROM queues
+      ORDER BY name ASC
+    `).all();
+  return rows.map((row) => {
+    const counts = {
+      wait: row.wait_count,
+      active: row.active_count,
+      completed: row.completed_count,
+      failed: row.failed_count,
+      delayed: row.delayed_count,
+      schedulers: row.schedulers_count
+    };
+    return {
+      name: row.name,
+      counts,
+      isPaused: row.is_paused === 1,
+      total: counts.wait + counts.active + counts.completed + counts.failed + counts.delayed,
+      lastObservedAt: row.last_observed_at
+    };
+  });
+}
+function queryJobs(ctx, params) {
+  const database = ctx.db;
+  const {
+    queue,
+    search,
+    state,
+    sort = "timestamp",
+    order = "desc",
+    page = 1,
+    pageSize = 25
+  } = params;
+  const validSorts = ["id", "name", "state", "timestamp"];
+  const sortCol = validSorts.includes(sort) ? sort : "timestamp";
+  const sortOrder = order === "asc" ? "ASC" : "DESC";
+  const offset = (page - 1) * pageSize;
+  if (Array.isArray(state) && state.length === 0) {
+    return { jobs: [], total: 0 };
   }
-  if (recentlyPolledWrites.size > RECENT_POLL_MAX_ENTRIES) {
-    pruneRecentlyPolled();
+  if (search) {
+    const conditions2 = ["j.queue = ?"];
+    const values2 = [queue];
+    appendStateClause(conditions2, values2, state, "j.");
+    const where2 = conditions2.join(" AND ");
+    const ftsMatch = `${search}*`;
+    const countSql2 = `SELECT COUNT(*) as total FROM jobs j JOIN jobs_fts fts ON j.rowid = fts.rowid WHERE ${where2} AND jobs_fts MATCH ?`;
+    const total2 = database.prepare(countSql2).get(...values2, ftsMatch).total;
+    const qualifiedSort = `j.${sortCol}`;
+    const sql2 = `SELECT j.* FROM jobs j JOIN jobs_fts fts ON j.rowid = fts.rowid WHERE ${where2} AND jobs_fts MATCH ? ORDER BY ${qualifiedSort} ${sortOrder} LIMIT ? OFFSET ?`;
+    const jobs2 = database.prepare(sql2).all(...values2, ftsMatch, pageSize, offset);
+    return { jobs: jobs2, total: total2 };
   }
+  const conditions = ["queue = ?"];
+  const values = [queue];
+  appendStateClause(conditions, values, state, "");
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const countSql = `SELECT COUNT(*) as total FROM jobs ${where}`;
+  const total = database.prepare(countSql).get(...values).total;
+  const sql = `SELECT * FROM jobs ${where} ORDER BY ${sortCol} ${sortOrder} LIMIT ? OFFSET ?`;
+  const jobs = database.prepare(sql).all(...values, pageSize, offset);
+  return { jobs, total };
 }
-function wasPolledSince(queue, jobId, threshold) {
-  const ts = recentlyPolledWrites.get(`${queue}:${jobId}`);
-  return ts !== undefined && ts >= threshold;
+function safeDataPreview(data) {
+  if (data === undefined || data === null)
+    return null;
+  try {
+    return JSON.stringify(data).slice(0, 500);
+  } catch {
+    return null;
+  }
 }
-async function syncQueue(queueName) {
-  const lock = tryAcquireSyncLock();
-  if (!lock.ok) {
-    const message = `Refusing to sync queue "${queueName}": another sync is in progress ` + `(held ${lock.heldForMs}ms). syncQueue/fullSync share a single staging ` + `table and cannot run concurrently.`;
-    console.error(message);
-    return {
-      inserted: 0,
-      stateUpdated: 0,
-      softDeleted: 0,
-      total: 0,
-      error: message
-    };
+function safeJson(data) {
+  if (data === undefined || data === null)
+    return null;
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return null;
   }
-  const syncStart = Date.now();
-  const syncDb = getSqliteDb();
-  const assertSameConnection = () => {
-    if (getSqliteDb() !== syncDb) {
-      throw new Error(`syncQueue("${queueName}") aborted: SQLite connection was closed mid-sync`);
+}
+function upsertJobs(ctx, queue, jobs, observedAt = Date.now()) {
+  const database = ctx.db;
+  const stmt = database.prepare(`
+    INSERT INTO jobs (
+      id,
+      queue,
+      name,
+      state,
+      timestamp,
+      data_preview,
+      data_json,
+      opts_json,
+      attempts_made,
+      failed_reason,
+      stacktrace_json,
+      returnvalue_json,
+      processed_on,
+      finished_on,
+      progress_json,
+      repeat_job_key,
+      delay,
+      last_observed_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(queue, id) DO UPDATE SET
+      name = excluded.name,
+      state = excluded.state,
+      timestamp = excluded.timestamp,
+      data_preview = excluded.data_preview,
+      data_json = excluded.data_json,
+      opts_json = excluded.opts_json,
+      attempts_made = excluded.attempts_made,
+      failed_reason = excluded.failed_reason,
+      stacktrace_json = excluded.stacktrace_json,
+      returnvalue_json = excluded.returnvalue_json,
+      processed_on = excluded.processed_on,
+      finished_on = excluded.finished_on,
+      progress_json = excluded.progress_json,
+      repeat_job_key = excluded.repeat_job_key,
+      delay = excluded.delay,
+      last_observed_at = excluded.last_observed_at
+  `);
+  const upsert = database.transaction((items) => {
+    for (const job of items) {
+      const dataPreview = safeDataPreview(job.data);
+      stmt.run(job.id, queue, job.name, job.state, job.timestamp, dataPreview, safeJson(job.data), safeJson(job.opts), job.attemptsMade ?? null, job.failedReason ?? null, safeJson(job.stacktrace), safeJson(job.returnvalue), job.processedOn ?? null, job.finishedOn ?? null, safeJson(job.progress), job.repeatJobKey ?? null, job.delay ?? null, observedAt);
     }
+  });
+  upsert(jobs);
+}
+
+// src/data/queue-store.ts
+var DEFAULT_PAGE_SIZE = 25;
+function stateFilter(state) {
+  switch (state) {
+    case undefined:
+    case "latest":
+    case "all":
+      return;
+    case "wait":
+      return ["waiting", "prioritized"];
+    case "schedulers":
+      throw new Error("Cannot list schedulers via listJobs(). Use listSchedulers() instead.");
+    default:
+      return state;
+  }
+}
+function rowToSummary(row) {
+  return {
+    id: row.id,
+    name: row.name ?? "unknown",
+    state: row.state,
+    timestamp: row.timestamp ?? 0,
+    lastObservedAt: row.last_observed_at
   };
-  try {
-    createSyncStaging();
-    let total = 0;
-    for await (const batch of getAllJobIds(queueName)) {
-      assertSameConnection();
-      insertStagingBatch(queueName, batch);
-      total += batch.length;
-    }
-    assertSameConnection();
-    const resurrected = findResurrectedIdsByStagingDiff(queueName);
-    if (resurrected.length > 0) {
-      throw new JobResurrectionError(queueName, resurrected);
-    }
-    const newStubs = findNewIdsByStagingDiff(queueName);
-    if (newStubs.length > 0) {
-      upsertJobStubs(queueName, newStubs);
-    }
-    const changed = findChangedIdsByStagingDiff(queueName).filter((row) => !wasPolledSince(queueName, row.id, syncStart));
-    if (changed.length > 0) {
-      upsertJobStubs(queueName, changed);
-    }
-    const staleIds = findStaleIdsByStagingDiff(queueName).filter((id) => !wasPolledSince(queueName, id, syncStart));
-    const now = Date.now();
-    const softDeleted = softDeleteJobsByIds(queueName, staleIds, now);
-    upsertSyncState(queueName, {
-      jobCount: total,
-      syncedAt: now
-    });
-    return {
-      inserted: newStubs.length,
-      stateUpdated: changed.length,
-      softDeleted,
-      total
-    };
-  } catch (error) {
-    if (error instanceof JobResurrectionError) {
-      throw error;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`SQLite sync failed for queue "${queueName}":`, error);
+}
+function listQueues(ctx) {
+  return queryQueueStats(ctx);
+}
+function listJobs(ctx, queue, options = {}) {
+  const page = options.page ?? 1;
+  const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+  const result = queryJobs(ctx, {
+    queue,
+    state: stateFilter(options.state),
+    sort: "timestamp",
+    order: "desc",
+    page,
+    pageSize
+  });
+  return {
+    jobs: result.jobs.map(rowToSummary),
+    total: result.total,
+    page,
+    pageSize,
+    totalPages: Math.ceil(result.total / pageSize)
+  };
+}
+function listSchedulers(ctx, queue, options = {}) {
+  const page = options.page ?? 1;
+  const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+  const result = querySchedulers(ctx, queue, page, pageSize);
+  return {
+    schedulers: result.schedulers,
+    total: result.total,
+    page,
+    pageSize,
+    totalPages: Math.ceil(result.total / pageSize)
+  };
+}
+function recordObservedQueues(ctx, queues, options = {}) {
+  upsertQueueStats(ctx, queues, options.observedAt ?? Date.now());
+  return { observed: queues.length };
+}
+function recordObservedJobs(ctx, queue, jobs, options = {}) {
+  upsertJobs(ctx, queue, jobs, options.observedAt ?? Date.now());
+  return { observed: jobs.length };
+}
+function recordObservedSchedulers(ctx, queue, schedulers, options = {}) {
+  upsertSchedulers(ctx, queue, schedulers, options.observedAt ?? Date.now());
+  return { observed: schedulers.length };
+}
+function staleCutoff(ctx, now) {
+  return now - ctx.config.cacheTtlMs;
+}
+function expireStaleRecords(ctx, options = {}) {
+  const database = ctx.db;
+  const cutoff = staleCutoff(ctx, options.now ?? Date.now());
+  return database.transaction(() => {
+    const expiredQueues = database.prepare("SELECT name FROM queues WHERE last_observed_at < ?").all(cutoff);
+    const queueNames = expiredQueues.map((row) => row.name);
+    let cascadedSchedulers = 0;
+    if (queueNames.length > 0) {
+      const placeholders = queueNames.map(() => "?").join(",");
+      cascadedSchedulers = database.prepare(`DELETE FROM schedulers WHERE queue IN (${placeholders})`).run(...queueNames).changes;
+      database.prepare(`DELETE FROM queues WHERE name IN (${placeholders})`).run(...queueNames);
+    }
+    const staleSchedulers = database.prepare("DELETE FROM schedulers WHERE last_observed_at < ?").run(cutoff).changes;
+    const staleJobs = database.prepare("DELETE FROM jobs WHERE last_observed_at < ?").run(cutoff).changes;
     return {
-      inserted: 0,
-      stateUpdated: 0,
-      softDeleted: 0,
-      total: 0,
-      error: message
+      queuesDeleted: queueNames.length,
+      schedulersDeleted: cascadedSchedulers + staleSchedulers,
+      jobsDeleted: staleJobs
     };
-  } finally {
-    if (getSqliteDb() === syncDb) {
-      try {
-        dropSyncStaging();
-      } catch (cleanupError) {
-        console.error(`Failed to drop sync_staging for queue "${queueName}":`, cleanupError);
-      }
-    }
-    releaseSyncLock();
-  }
+  })();
 }
-async function fullSync() {
-  let queues;
+
+// src/data/queue-store-lifecycle.ts
+var CLEANUP_INTERVAL_MS = 60000;
+function runQueueStoreCleanupIfDue(ctx, now = Date.now()) {
+  const lastCleanupAt = ctx.queueStore.lastCleanupAt;
+  if (lastCleanupAt !== null && now - lastCleanupAt < CLEANUP_INTERVAL_MS) {
+    return;
+  }
+  ctx.queueStore.lastCleanupAt = now;
   try {
-    queues = await discoverQueueNames();
+    expireStaleRecords(ctx, { now });
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error("SQLite full sync: queue discovery failed:", error);
-    return {
-      queues: 0,
-      totalInserted: 0,
-      totalSoftDeleted: 0,
-      totalCompacted: 0,
-      errors: [{ queue: "", error: message }]
-    };
-  }
-  let totalInserted = 0;
-  let totalSoftDeleted = 0;
-  const errors = [];
-  const invariantErrors = [];
-  for (const q of queues) {
-    try {
-      const result = await syncQueue(q);
-      if (result.error) {
-        errors.push({ queue: q, error: result.error });
-      } else {
-        totalInserted += result.inserted;
-        totalSoftDeleted += result.softDeleted;
-      }
-    } catch (error) {
-      if (!(error instanceof JobResurrectionError)) {
-        throw error;
-      }
-      invariantErrors.push({ queue: q, error: error.message });
-    }
-  }
-  if (invariantErrors.length > 0) {
-    throw new FullSyncInvariantError(invariantErrors);
+    console.warn("Failed to expire stale queue-store records:", error instanceof Error ? error.message : error);
   }
-  const totalCompacted = compactRemovedJobs(Date.now(), getConfig().retentionMs);
-  return {
-    queues: queues.length,
-    totalInserted,
-    totalSoftDeleted,
-    totalCompacted,
-    errors
-  };
 }
 
 // src/polling.ts
@@ -2044,6 +1514,10 @@ function schedulersViewState(schedulers, total) {
     jobsTotalPages: 0
   };
 }
+function pageSchedulers(schedulers, page, pageSize = SCHEDULER_PAGE_SIZE) {
+  const start = (page - 1) * pageSize;
+  return schedulers.slice(start, start + pageSize);
+}
 var EMPTY_QUEUE_VIEW = {
   jobs: [],
   jobsTotal: 0,
@@ -2055,20 +1529,36 @@ var EMPTY_QUEUE_VIEW = {
 function clampQueueIndex(queues, currentIndex) {
   return queues.length > 0 ? Math.min(currentIndex, queues.length - 1) : 0;
 }
+function selectedQueueIndexAfterSort(queues, previousQueues, previousIndex) {
+  const previousName = previousQueues[previousIndex]?.name;
+  if (previousName) {
+    const nextIndex = queues.findIndex((queue) => queue.name === previousName);
+    if (nextIndex !== -1)
+      return nextIndex;
+  }
+  return clampQueueIndex(queues, previousIndex);
+}
 
 class PollingManager {
   intervalId = null;
   isRunning = false;
   isPolling = false;
-  start() {
+  ctx = null;
+  requireCtx() {
+    if (!this.ctx) {
+      throw new Error("PollingManager.start(ctx) must be called before refresh*/poll");
+    }
+    return this.ctx;
+  }
+  start(ctx) {
     if (this.isRunning)
       return;
-    const config = getConfig();
+    this.ctx = ctx;
     this.isRunning = true;
     this.poll();
     this.intervalId = setInterval(() => {
       this.poll();
-    }, config.pollInterval);
+    }, ctx.config.pollInterval);
   }
   stop() {
     if (this.intervalId) {
@@ -2076,21 +1566,25 @@ class PollingManager {
       this.intervalId = null;
     }
     this.isRunning = false;
+    this.ctx = null;
   }
   async poll() {
     if (this.isPolling)
       return;
+    if (!this.ctx)
+      return;
     this.isPolling = true;
+    const ctx = this.ctx;
     const wasConnected = stateManager.getState().connected;
     try {
       stateManager.setState({ isLoading: true });
-      const observedQueues = await getAllQueueStats();
-      upsertQueueStats(observedQueues);
-      const queues = queryQueueStats();
+      const observedQueues = await getAllQueueStats(ctx);
+      recordObservedQueues(ctx, observedQueues);
+      const currentState = stateManager.getState();
+      const queues = sortQueues(listQueues(ctx), currentState.queueSortBy, currentState.queueSortOrder);
       const rates = updateMetricsTracker(queues);
       const globalMetrics = calculateGlobalMetricsFromQueueStats(queues, rates);
-      const currentState = stateManager.getState();
-      const clampedIndex = clampQueueIndex(queues, currentState.selectedQueueIndex);
+      const clampedIndex = selectedQueueIndexAfterSort(queues, currentState.queues, currentState.selectedQueueIndex);
       stateManager.setState({
         queues,
         globalMetrics,
@@ -2103,8 +1597,7 @@ class PollingManager {
         if (currentState.jobsStatus === "schedulers") {
           const observed = await this.fetchAllSchedulers(selectedQueue.name);
           this.persistObservedSchedulers(selectedQueue.name, observed.schedulers);
-          const storeResult = querySchedulers(selectedQueue.name, currentState.schedulersPage, SCHEDULER_PAGE_SIZE);
-          stateManager.setState(schedulersViewState(storeResult.schedulers, observed.total));
+          stateManager.setState(schedulersViewState(pageSchedulers(observed.schedulers, currentState.schedulersPage), observed.total));
         } else {
           const observedJobsResult = await this.fetchVisibleJobs(selectedQueue.name, currentState.jobsStatus, currentState.jobsPage);
           this.persistObservedJobs(selectedQueue.name, observedJobsResult.jobs);
@@ -2119,31 +1612,39 @@ class PollingManager {
       if (wasConnected) {
         resetMetricsTracker();
       }
-      await this.applyDisconnectedFallback(errorMessage);
+      await this.applyDisconnectedFallback(ctx, errorMessage);
     } finally {
+      runQueueStoreCleanupIfDue(ctx);
       this.isPolling = false;
     }
   }
-  async applyDisconnectedFallback(errorMessage) {
+  async applyDisconnectedFallback(ctx, errorMessage) {
     try {
-      const queues = queryQueueStats();
+      const queues = listQueues(ctx);
       const currentState = stateManager.getState();
-      const clampedIndex = clampQueueIndex(queues, currentState.selectedQueueIndex);
-      const selectedQueue = queues[clampedIndex];
+      const sortedQueues = sortQueues(queues, currentState.queueSortBy, currentState.queueSortOrder);
+      const clampedIndex = selectedQueueIndexAfterSort(sortedQueues, currentState.queues, currentState.selectedQueueIndex);
+      const selectedQueue = sortedQueues[clampedIndex];
       let viewState;
       if (selectedQueue && currentState.jobsStatus === "schedulers") {
-        const storeResult = querySchedulers(selectedQueue.name, currentState.schedulersPage, SCHEDULER_PAGE_SIZE);
+        const storeResult = listSchedulers(ctx, selectedQueue.name, {
+          page: currentState.schedulersPage,
+          pageSize: SCHEDULER_PAGE_SIZE
+        });
         viewState = schedulersViewState(storeResult.schedulers, storeResult.total);
       } else if (selectedQueue) {
-        const jobsResult = await getJobsFromStore(selectedQueue.name, currentState.jobsStatus, currentState.jobsPage);
+        const jobsResult = listJobs(ctx, selectedQueue.name, {
+          state: currentState.jobsStatus,
+          page: currentState.jobsPage
+        });
         viewState = jobsViewState(jobsResult);
       } else {
         viewState = EMPTY_QUEUE_VIEW;
       }
       stateManager.setState({
-        queues,
+        queues: sortedQueues,
         selectedQueueIndex: clampedIndex,
-        globalMetrics: calculateGlobalMetricsFromQueueStats(queues, ZERO_RATES),
+        globalMetrics: calculateGlobalMetricsFromQueueStats(sortedQueues, ZERO_RATES),
         connected: false,
         error: errorMessage,
         isLoading: false,
@@ -2159,26 +1660,26 @@ class PollingManager {
     }
   }
   async fetchVisibleJobs(queueName, status, page) {
-    return getJobs(queueName, status, page, undefined, true);
+    return getJobs(this.requireCtx(), queueName, status, page, undefined, true);
   }
   persistObservedJobs(queueName, jobs) {
+    const ctx = this.requireCtx();
     try {
-      upsertJobs(queueName, jobs);
-      markPolledWrites(queueName, jobs.map((j) => j.id));
+      recordObservedJobs(ctx, queueName, jobs);
     } catch (error) {
       console.warn(`Failed to persist observed jobs for "${queueName}":`, error instanceof Error ? error.message : error);
     }
   }
   async fetchAllSchedulers(queueName) {
-    const firstBatch = await getAllJobSchedulers(queueName);
+    const firstBatch = await getAllJobSchedulers(this.requireCtx(), queueName);
     if (firstBatch.schedulers.length >= firstBatch.total) {
       return firstBatch;
     }
-    return getAllJobSchedulers(queueName, firstBatch.total);
+    return getAllJobSchedulers(this.requireCtx(), queueName, firstBatch.total);
   }
   persistObservedSchedulers(queueName, schedulers) {
     try {
-      upsertSchedulers(queueName, schedulers);
+      recordObservedSchedulers(this.requireCtx(), queueName, schedulers);
     } catch (error) {
       console.warn(`Failed to persist observed schedulers for "${queueName}":`, error instanceof Error ? error.message : error);
     }
@@ -2205,7 +1706,10 @@ class PollingManager {
       } catch (error) {
         console.error("Failed to observe jobs:", error instanceof Error ? error.message : error);
       }
-      const jobsResult = observedJobsResult ?? await getJobsFromStore(selectedQueue.name, state.jobsStatus, state.jobsPage);
+      const jobsResult = observedJobsResult ?? listJobs(this.requireCtx(), selectedQueue.name, {
+        state: state.jobsStatus,
+        page: state.jobsPage
+      });
       stateManager.setState({
         jobs: jobsResult.jobs,
         jobsTotal: jobsResult.total,
@@ -2233,17 +1737,95 @@ class PollingManager {
     } catch (error) {
       console.error("Failed to refresh schedulers:", error instanceof Error ? error.message : error);
     }
-    const storeResult = querySchedulers(selectedQueue.name, state.schedulersPage, SCHEDULER_PAGE_SIZE);
-    const total = observed?.total ?? storeResult.total;
+    if (observed) {
+      stateManager.setState({
+        schedulers: pageSchedulers(observed.schedulers, state.schedulersPage),
+        schedulersTotal: observed.total,
+        schedulersTotalPages: Math.ceil(observed.total / SCHEDULER_PAGE_SIZE)
+      });
+      return;
+    }
+    const storeResult = listSchedulers(this.requireCtx(), selectedQueue.name, {
+      page: state.schedulersPage,
+      pageSize: SCHEDULER_PAGE_SIZE
+    });
     stateManager.setState({
       schedulers: storeResult.schedulers,
-      schedulersTotal: total,
-      schedulersTotalPages: Math.ceil(total / SCHEDULER_PAGE_SIZE)
+      schedulersTotal: storeResult.total,
+      schedulersTotalPages: Math.ceil(storeResult.total / SCHEDULER_PAGE_SIZE)
     });
   }
 }
 var pollingManager = new PollingManager;
 
+// src/context.ts
+import { RedisConnection } from "bullmq";
+function createRedisClient(config) {
+  let connection = null;
+  let clientPromise = null;
+  const getClient = () => {
+    if (!clientPromise) {
+      connection = new RedisConnection({
+        ...redisConnectionOptions(config),
+        lazyConnect: true,
+        retryStrategy: (times) => {
+          if (times > 3) {
+            return null;
+          }
+          return Math.min(times * 200, 2000);
+        }
+      }, { blocking: false });
+      connection.on("error", () => {});
+      clientPromise = connection.client.catch((err) => {
+        clientPromise = null;
+        connection = null;
+        throw err;
+      });
+    }
+    return clientPromise;
+  };
+  return {
+    get status() {
+      return connection?.status ?? "wait";
+    },
+    async connect() {
+      await getClient();
+    },
+    async quit() {
+      if (!connection)
+        return;
+      await connection.close();
+      connection = null;
+      clientPromise = null;
+    },
+    async scan(cursor, ...args) {
+      const client = await getClient();
+      return client.scan(cursor, ...args);
+    },
+    async del(...keys) {
+      const client = await getClient();
+      return client.del(...keys);
+    }
+  };
+}
+function createContext(config, opts = {}) {
+  const redis = createRedisClient(config);
+  const db = createSqliteDb(config, opts.dbPath);
+  return {
+    config,
+    redis,
+    db,
+    queueCache: new Map,
+    queueNamesCache: null,
+    queueStore: { lastCleanupAt: null }
+  };
+}
+async function closeContext(ctx) {
+  await closeAllQueues(ctx);
+  await ctx.redis.quit().catch(() => {});
+  ctx.db.close();
+}
+
 // src/ui/layout.ts
 import { BoxRenderable, TextRenderable, t, fg, bold } from "@opentui/core";
 
@@ -2397,6 +1979,14 @@ import {
   SelectRenderable,
   SelectRenderableEvents
 } from "@opentui/core";
+function formatQueueTaskBar(total, maxTotal, width = 8) {
+  if (width <= 0)
+    return "";
+  if (maxTotal <= 0 || total <= 0)
+    return ".".repeat(width);
+  const filled = Math.max(1, Math.round(total / maxTotal * width));
+  return "#".repeat(filled).padEnd(width, ".");
+}
 function createQueueList(renderer, parent) {
   const container = new BoxRenderable2(renderer, {
     id: "queue-list-container",
@@ -2454,9 +2044,10 @@ function createQueueList(renderer, parent) {
   });
   return { container, title, select, emptyText };
 }
-function updateQueueList(elements, queues, selectedIndex, isFocused) {
+function updateQueueList(elements, queues, selectedIndex, isFocused, sortBy = "name", sortOrder = "asc") {
   const { select, emptyText, title } = elements;
-  title.content = isFocused ? " QUEUES [*]" : " QUEUES";
+  const sortText = queueSortLabel(sortBy, sortOrder);
+  title.content = isFocused ? ` QUEUES [*] ${sortText}` : ` QUEUES ${sortText}`;
   title.bg = isFocused ? colors.surface1 : colors.surface0;
   if (queues.length === 0) {
     select.visible = false;
@@ -2465,9 +2056,10 @@ function updateQueueList(elements, queues, selectedIndex, isFocused) {
   }
   select.visible = true;
   emptyText.visible = false;
+  const maxTotal = Math.max(...queues.map((queue) => queue.total), 0);
   const options = queues.map((queue) => ({
     name: queue.name,
-    description: `${queue.total} jobs | ${queue.isPaused ? "PAUSED" : "active"}`,
+    description: `${formatQueueTaskBar(queue.total, maxTotal)} ${queue.total} jobs | fail ${queue.counts.failed} | ${queue.isPaused ? "PAUSED" : "active"}`,
     value: queue
   }));
   select.options = options;
@@ -3449,10 +3041,16 @@ function updatePageJump(elements, visible, inputValue, currentPage, totalPages)
 
 // src/app.ts
 class App {
+  ctx;
   renderer = null;
   elements = null;
   unsubscribeState = null;
-  syncIntervalId = null;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  requireCtx() {
+    return this.ctx;
+  }
   async start() {
     this.renderer = await createCliRenderer({
       exitOnCtrlC: false,
@@ -3464,15 +3062,13 @@ class App {
     this.unsubscribeState = stateManager.subscribe(() => {
       this.render();
     });
-    createSqliteDb();
-    pollingManager.start();
-    const runFullSync = () => {
-      fullSync().catch((error) => {
-        console.error("SQLite full sync failed:", error);
-      });
-    };
-    runFullSync();
-    this.syncIntervalId = setInterval(runFullSync, 60000);
+    const ctx = this.ctx;
+    try {
+      await ctx.redis.connect();
+    } catch (error) {
+      console.error("Redis connection failed at startup:", error instanceof Error ? error.message : error);
+    }
+    pollingManager.start(ctx);
     this.render();
   }
   createElements() {
@@ -3602,6 +3198,12 @@ class App {
       case "r":
         await pollingManager.refresh();
         break;
+      case "s":
+        if (state.focusedPane === "queues") {
+          stateManager.cycleQueueSort();
+          await pollingManager.refresh();
+        }
+        break;
       case "g":
         if (state.focusedPane === "jobs") {
           if (state.jobsStatus === "schedulers" && state.schedulersTotalPages > 1) {
@@ -3638,7 +3240,7 @@ class App {
     if (!selectedJob || !selectedQueue)
       return;
     try {
-      const detail = await getJobDetail(selectedQueue.name, selectedJob.id);
+      const detail = await getJobDetail(this.requireCtx(), selectedQueue.name, selectedJob.id);
       if (detail) {
         stateManager.openJobDetail(detail);
       }
@@ -3650,7 +3252,7 @@ class App {
     if (!selectedScheduler || !selectedQueue)
       return;
     try {
-      const detail = await getJobSchedulerDetail(selectedQueue.name, selectedScheduler.key);
+      const detail = await getJobSchedulerDetail(this.requireCtx(), selectedQueue.name, selectedScheduler.key);
       if (detail) {
         stateManager.openSchedulerDetail(detail);
       }
@@ -3663,7 +3265,7 @@ class App {
     if (!schedulerDetail?.nextJob || !selectedQueue)
       return;
     try {
-      const jobDetail = await getJobDetail(selectedQueue.name, schedulerDetail.nextJob.id);
+      const jobDetail = await getJobDetail(this.requireCtx(), selectedQueue.name, schedulerDetail.nextJob.id);
       if (jobDetail) {
         stateManager.closeSchedulerDetail();
         stateManager.openJobDetail(jobDetail);
@@ -3685,7 +3287,7 @@ class App {
       return;
     }
     try {
-      await deleteJob(selectedQueue.name, jobId);
+      await deleteJob(this.requireCtx(), selectedQueue.name, jobId);
       stateManager.hideDeleteConfirm();
       stateManager.closeJobDetail();
       await pollingManager.refresh();
@@ -3727,10 +3329,10 @@ class App {
       confirmDialog,
       pageJump
     } = this.elements;
-    const config = getConfig();
-    updateHeaderStatus(layout.headerStatus, state.connected, state.error, config.redis.host, config.redis.port);
+    const headerConfig = this.ctx.config;
+    updateHeaderStatus(layout.headerStatus, state.connected, state.error, headerConfig.redis.host, headerConfig.redis.port);
     updateGlobalMetrics(globalMetrics, state.globalMetrics);
-    updateQueueList(queueList, state.queues, state.selectedQueueIndex, state.focusedPane === "queues");
+    updateQueueList(queueList, state.queues, state.selectedQueueIndex, state.focusedPane === "queues", state.queueSortBy, state.queueSortOrder);
     const selectedQueue = stateManager.getSelectedQueue();
     updateQueueStats(queueStats, selectedQueue);
     updateStatusFilter(statusFilter, state.jobsStatus);
@@ -3754,28 +3356,254 @@ class App {
     }
     updatePageJump(pageJump, state.showPageJump, state.pageJumpInput, isSchedulersView ? state.schedulersPage : state.jobsPage, isSchedulersView ? state.schedulersTotalPages : state.jobsTotalPages);
   }
-  async cleanup() {
-    pollingManager.stop();
-    if (this.syncIntervalId) {
-      clearInterval(this.syncIntervalId);
-      this.syncIntervalId = null;
-    }
-    if (this.unsubscribeState) {
-      this.unsubscribeState();
-    }
-    await closeAllQueues();
-    await disconnectRedis();
-    closeSqliteDb();
-    if (this.renderer) {
-      this.renderer.destroy();
+  async cleanup() {
+    pollingManager.stop();
+    if (this.unsubscribeState) {
+      this.unsubscribeState();
+    }
+    await closeContext(this.ctx);
+    if (this.renderer) {
+      this.renderer.destroy();
+    }
+    process.exit(0);
+  }
+}
+
+// src/cli.ts
+import { parseArgs } from "util";
+
+// src/errors.ts
+function writeError(message, code, details) {
+  process.stderr.write(JSON.stringify({ error: message, code, details }) + `
+`);
+}
+
+// src/profiles.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function coerceOptionalPositiveInt(value) {
+  if (value === undefined)
+    return;
+  const numberValue = Number(value);
+  if (!Number.isInteger(numberValue) || numberValue <= 0)
+    return null;
+  return numberValue;
+}
+var PROFILE_ALLOWED_KEYS = ["redis", "pollInterval", "prefix", "queues", "cacheTtlMs"];
+var PROFILES_FILE_ALLOWED_KEYS = ["defaultProfile", "profiles"];
+function unknownKeyMessage(path, key, allowed) {
+  return `unknown key '${key}' in ${path} (allowed: ${allowed.join(", ")})`;
+}
+function validateProfile(value, path, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${path} must be an object`);
+    return null;
+  }
+  for (const key of Object.keys(value)) {
+    if (!PROFILE_ALLOWED_KEYS.includes(key)) {
+      errors.push(unknownKeyMessage(path, key, PROFILE_ALLOWED_KEYS));
+    }
+  }
+  const profile = {};
+  if (value.redis !== undefined) {
+    if (!isRecord(value.redis)) {
+      errors.push(`${path}.redis must be an object`);
+    } else {
+      for (const key of Object.keys(value.redis)) {
+        if (key !== "url")
+          errors.push(unknownKeyMessage(`${path}.redis`, key, ["url"]));
+      }
+      if (typeof value.redis.url !== "string") {
+        errors.push(`${path}.redis.url must be a string`);
+      } else {
+        profile.redis = { url: value.redis.url };
+      }
+    }
+  }
+  const pollInterval = coerceOptionalPositiveInt(value.pollInterval);
+  if (pollInterval === null)
+    errors.push(`${path}.pollInterval must be a positive integer`);
+  else if (pollInterval !== undefined)
+    profile.pollInterval = pollInterval;
+  if (value.prefix !== undefined) {
+    if (typeof value.prefix !== "string")
+      errors.push(`${path}.prefix must be a string`);
+    else
+      profile.prefix = value.prefix;
+  }
+  if (value.queues !== undefined) {
+    if (!Array.isArray(value.queues) || value.queues.some((queue) => typeof queue !== "string")) {
+      errors.push(`${path}.queues must be an array of strings`);
+    } else {
+      profile.queues = value.queues;
+    }
+  }
+  const cacheTtlMs = coerceOptionalPositiveInt(value.cacheTtlMs);
+  if (cacheTtlMs === null)
+    errors.push(`${path}.cacheTtlMs must be a positive integer`);
+  else if (cacheTtlMs !== undefined)
+    profile.cacheTtlMs = cacheTtlMs;
+  return profile;
+}
+function validateProfilesFile(value) {
+  const errors = [];
+  if (!isRecord(value))
+    return ["config file must be an object"];
+  for (const key of Object.keys(value)) {
+    if (!PROFILES_FILE_ALLOWED_KEYS.includes(key)) {
+      errors.push(unknownKeyMessage("config file", key, PROFILES_FILE_ALLOWED_KEYS));
+    }
+  }
+  const file = { profiles: {} };
+  if (value.defaultProfile !== undefined) {
+    if (typeof value.defaultProfile !== "string")
+      errors.push("defaultProfile must be a string");
+    else
+      file.defaultProfile = value.defaultProfile;
+  }
+  if (value.profiles !== undefined) {
+    if (!isRecord(value.profiles)) {
+      errors.push("profiles must be an object");
+    } else {
+      for (const [name, profileValue] of Object.entries(value.profiles)) {
+        const profile = validateProfile(profileValue, `profiles.${name}`, errors);
+        if (profile)
+          file.profiles[name] = profile;
+      }
+    }
+  }
+  return errors.length > 0 ? errors : file;
+}
+function resolveConfigPath(explicitPath, env = process.env) {
+  if (explicitPath)
+    return explicitPath;
+  if (env.BULLMQ_DASH_CONFIG)
+    return env.BULLMQ_DASH_CONFIG;
+  const xdg = env.XDG_CONFIG_HOME;
+  if (xdg)
+    return join(xdg, "bullmq-dash", "config.json");
+  return join(homedir(), ".config", "bullmq-dash", "config.json");
+}
+var ENV_REF = /^\$\{([A-Z_][A-Z0-9_]*)\}$/;
+function expandEnvRefs(value, env = process.env) {
+  if (typeof value === "string") {
+    const match = value.match(ENV_REF);
+    if (!match)
+      return value;
+    const key = match[1];
+    const resolved = env[key];
+    if (resolved === undefined) {
+      throw new Error(`Environment variable '${key}' referenced in profile is not set`);
+    }
+    return resolved;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => expandEnvRefs(v, env));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = expandEnvRefs(v, env);
+    }
+    return out;
+  }
+  return value;
+}
+function loadProfile(opts = {}) {
+  const env = opts.env ?? process.env;
+  const explicitConfig = !!opts.configPath || !!env.BULLMQ_DASH_CONFIG;
+  const explicitProfile = !!opts.profileName;
+  const path = resolveConfigPath(opts.configPath, env);
+  if (!existsSync(path)) {
+    if (explicitConfig || explicitProfile) {
+      writeError(`Config file not found: ${path}`, "CONFIG_ERROR", explicitConfig ? "Check the path passed to --config or $BULLMQ_DASH_CONFIG." : `--profile requires a config file. Create one at ${path} or pass --config <path>.`);
+      process.exit(2);
+    }
+    return null;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (error) {
+    writeError(`Failed to parse config file: ${path}`, "CONFIG_ERROR", error instanceof Error ? error.message : String(error));
+    process.exit(2);
+  }
+  const parsed = validateProfilesFile(raw);
+  if (Array.isArray(parsed)) {
+    writeError(`Invalid config file: ${path}`, "CONFIG_ERROR", parsed.join("; "));
+    process.exit(2);
+  }
+  const file = parsed;
+  const name = opts.profileName ?? file.defaultProfile;
+  if (!name)
+    return null;
+  const profile = file.profiles[name];
+  if (!profile) {
+    const available = Object.keys(file.profiles);
+    writeError(`Profile '${name}' not found in ${path}`, "CONFIG_ERROR", available.length > 0 ? `Available profiles: ${available.join(", ")}` : "No profiles are defined in the config file.");
+    process.exit(2);
+  }
+  let expanded;
+  try {
+    expanded = expandEnvRefs(profile, env);
+  } catch (error) {
+    writeError(`Failed to resolve env vars in profile '${name}'`, "CONFIG_ERROR", error instanceof Error ? error.message : String(error));
+    process.exit(2);
+  }
+  return { sourcePath: path, name, profile: expanded };
+}
+function decodeUrlAuthField(raw, field) {
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    throw new Error(`Invalid percent-encoding in URL ${field}`);
+  }
+}
+function redactUrl(input) {
+  return input.replace(/(:\/\/)[^/]*@/, "$1[REDACTED]@");
+}
+function parseRedisUrl(input) {
+  let parsed;
+  try {
+    parsed = new URL(input);
+  } catch {
+    throw new Error(`Not a valid URL: ${redactUrl(input)}`);
+  }
+  if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
+    throw new Error(`Unsupported scheme '${parsed.protocol}' (expected redis:// or rediss://)`);
+  }
+  if (!parsed.hostname) {
+    throw new Error(`Missing host in URL: ${redactUrl(input)}`);
+  }
+  if (parsed.search || parsed.hash) {
+    throw new Error("Query parameters and fragments are not supported in Redis URLs. " + "For TLS, use rediss:// (not ?ssl=true).");
+  }
+  const username = parsed.username ? decodeUrlAuthField(parsed.username, "username") : undefined;
+  const password = parsed.password ? decodeUrlAuthField(parsed.password, "password") : undefined;
+  let db;
+  if (parsed.pathname && parsed.pathname !== "/") {
+    const trimmed = parsed.pathname.replace(/^\//, "");
+    if (!/^\d+$/.test(trimmed)) {
+      throw new Error(`Database in URL must be a non-negative integer, got '/${trimmed}'`);
     }
-    process.exit(0);
+    db = Number(trimmed);
   }
+  const port = parsed.port ? Number(parsed.port) : 6379;
+  return {
+    host: parsed.hostname,
+    port,
+    username,
+    password,
+    db,
+    tls: parsed.protocol === "rediss:"
+  };
 }
-
 // src/cli.ts
-import { parseArgs } from "util";
-var PACKAGE_VERSION = "0.3.0";
+var PACKAGE_VERSION = "0.3.2";
 var HELP_TEXT = `
 bullmq-dash - Terminal UI dashboard for BullMQ queue monitoring
 
@@ -3787,8 +3615,9 @@ Commands:
   queues list                            List all queues with job counts
   queues delete <queue>                  Delete a queue and all its jobs
   jobs list <queue>                      List jobs in a queue
+  jobs failed <queue>                    List failed jobs in a queue
   jobs get <queue> <job-id>              Get full detail for a single job
-  jobs retry <queue>                     Bulk-retry failed jobs (supports --dry-run)
+  jobs retry <queue>                     Retry failed jobs (supports --dry-run/--yes)
   schedulers list <queue>                List schedulers in a queue
   schedulers get <queue> <scheduler-id>  Get detail for a single scheduler
 
@@ -3821,8 +3650,10 @@ Examples:
   bullmq-dash queues list --redis-url redis://localhost:6379
   bullmq-dash queues list --profile prod
   bullmq-dash queues list --redis-url redis://localhost --human-friendly
+  bullmq-dash jobs failed email --redis-url redis://localhost
   bullmq-dash jobs list email --redis-url redis://localhost --job-state failed
   bullmq-dash jobs get email 123 --redis-url redis://localhost
+  bullmq-dash jobs retry email --redis-url redis://localhost --job-id 123 --dry-run
   bullmq-dash jobs retry email --redis-url redis://localhost --job-state failed --since 1h --dry-run
 `;
 var CONNECTION_OPTIONS_HELP = `
@@ -3850,11 +3681,19 @@ var QUEUES_LIST_HELP = `
 Usage: bullmq-dash queues list [options]
 
 List all discovered queues with their job counts per state.
+
+Options:
+  --sort-by <field>       Sort queues by: name | task-size | waiting | active | completed | failed | delayed
+                           Aliases: size, total, wait
+  --sort-order <order>    Sort order: asc | desc
+                           Defaults to asc for name, desc for metrics.
 ${CONNECTION_OPTIONS_HELP}
 
 Examples:
   bullmq-dash queues list --redis-url redis://localhost
   bullmq-dash queues list --redis-url redis://localhost:6380
+  bullmq-dash queues list --redis-url redis://localhost --sort-by task-size
+  bullmq-dash queues list --redis-url redis://localhost --sort-by failed
   bullmq-dash queues list --redis-url redis://localhost | jq '.queues[] | select(.counts.failed > 0)'
 `;
 var QUEUES_DELETE_HELP = `
@@ -3877,11 +3716,27 @@ Usage: bullmq-dash jobs <action> <queue> [options]
 
 Actions:
   list <queue>             List jobs in a queue
+  failed <queue>           List failed jobs in a queue
   get <queue> <job-id>     Get full detail for a single job
-  retry <queue>            Bulk-retry failed jobs (supports --dry-run)
+  retry <queue>            Retry failed jobs (supports --dry-run/--yes)
 
 Run 'bullmq-dash jobs <action> --help' for action-specific help.
 `;
+var JOBS_FAILED_HELP = `
+Usage: bullmq-dash jobs failed <queue> [options]
+
+List failed jobs in a queue. This is equivalent to:
+  bullmq-dash jobs list <queue> --job-state failed
+
+Options:
+  --page-size <n>          Max results to return (default: 1000)
+${CONNECTION_OPTIONS_HELP}
+
+Examples:
+  bullmq-dash jobs failed email --redis-url redis://localhost
+  bullmq-dash jobs failed email --redis-url redis://localhost | jq '.jobs[] | {id, name, timestamp}'
+  bullmq-dash jobs retry email --redis-url redis://localhost --job-id 42 --dry-run
+`;
 var JOBS_LIST_HELP = `
 Usage: bullmq-dash jobs list <queue> [options]
 
@@ -3910,13 +3765,14 @@ Examples:
   bullmq-dash jobs get email 123 --redis-url redis://localhost | jq '.job.data'
 `;
 var JOBS_RETRY_HELP = `
-Usage: bullmq-dash jobs retry <queue> --job-state failed [options]
+Usage: bullmq-dash jobs retry <queue> (--job-id <id> | --job-state failed) [options]
 
-Bulk-retry failed jobs in a queue. Operates on failed jobs only in v1.
+Retry one failed job by ID, or bulk-retry failed jobs in a queue.
 Always use --dry-run first to see what would be retried.
 
-Required:
-  --job-state failed       Must be 'failed' (other states not supported in v1)
+Required, choose one:
+  --job-id <id>            Retry one failed job by ID
+  --job-state failed       Bulk-retry failed jobs (other states not supported)
 
 Filters:
   --since <duration>       Only jobs that failed within this window.
@@ -3927,21 +3783,24 @@ Filters:
 Safety:
   --dry-run                Show what WOULD be retried without enqueueing anything.
                            Prints matched count and sample job IDs.
+  --yes                   Skip confirmation prompt (required in non-interactive scripts).
 
 Exit codes:
   0  Success (dry-run complete, or all matched jobs retried). Includes empty-match.
   1  Runtime / fetch error (e.g. Redis connection failed)
-  2  Config error (invalid flags, missing --job-state, --page-size > 10000)
+  2  Config error (invalid flags, missing --job-id/--job-state, --page-size > 10000)
   3  Partial failure \u2014 some jobs retried, some errored (see errors[])
 
 ${CONNECTION_OPTIONS_HELP}
 
 Examples:
   # Always start with a dry-run
+  bullmq-dash jobs retry payments --redis-url redis://localhost --job-id 42 --dry-run
   bullmq-dash jobs retry payments --redis-url redis://localhost --job-state failed --since 1h --dry-run
 
   # Then retry for real
-  bullmq-dash jobs retry payments --redis-url redis://localhost --job-state failed --since 1h
+  bullmq-dash jobs retry payments --redis-url redis://localhost --job-id 42 --yes
+  bullmq-dash jobs retry payments --redis-url redis://localhost --job-state failed --since 1h --yes
 
   # Filter by job name
   bullmq-dash jobs retry email --redis-url redis://localhost --job-state failed --name welcome-email --dry-run
@@ -3983,7 +3842,7 @@ Examples:
   bullmq-dash schedulers get email my-cron --redis-url redis://localhost | jq '.scheduler.recentJobs'
 `;
 var RESOURCE_COMMANDS = new Set(["queues", "jobs", "schedulers"]);
-var ACTIONS = new Set(["list", "get", "retry", "delete"]);
+var ACTIONS = new Set(["list", "failed", "get", "retry", "delete"]);
 function extractSubcommand(argv) {
   const firstFlagIndex = argv.findIndex((arg) => arg.startsWith("-"));
   if (firstFlagIndex === -1) {
@@ -4012,7 +3871,37 @@ function getRequiredArg(positionals, index, name, usage) {
   }
   return arg;
 }
-function parseSubcommand(positionals, help, jobState, pageSize, since, name, dryRun, yes = false) {
+function parseQueueSortBy(rawValue) {
+  if (rawValue === undefined)
+    return;
+  switch (rawValue) {
+    case "size":
+    case "total":
+    case "task-size":
+      return "task-size";
+    case "wait":
+    case "waiting":
+      return "waiting";
+    case "name":
+    case "active":
+    case "completed":
+    case "failed":
+    case "delayed":
+      return rawValue;
+    default:
+      writeError(`Invalid --sort-by value: '${rawValue}'`, "CONFIG_ERROR", `Valid queue sort fields: ${QUEUE_SORT_FIELDS.join(", ")}. Aliases: size, total, wait.`);
+      process.exit(2);
+  }
+}
+function parseSortOrder(rawValue) {
+  if (rawValue === undefined)
+    return;
+  if (rawValue === "asc" || rawValue === "desc")
+    return rawValue;
+  writeError(`Invalid --sort-order value: '${rawValue}'`, "CONFIG_ERROR", "Valid sort orders: asc, desc.");
+  process.exit(2);
+}
+function parseSubcommand(positionals, help, jobState, pageSize, since, name, retryJobId, dryRun, yes = false, sortBy, sortOrder) {
   if (positionals.length === 0)
     return;
   const resource = positionals[0];
@@ -4044,7 +3933,13 @@ function parseSubcommand(positionals, help, jobState, pageSize, since, name, dry
         if (help)
           showSubcommandHelp(QUEUES_LIST_HELP);
         assertArgCount(positionals, 2, "queues list [options]");
-        return { kind: "queues-list" };
+        const parsedSortBy = parseQueueSortBy(sortBy);
+        const parsedSortOrder = parseSortOrder(sortOrder);
+        return {
+          kind: "queues-list",
+          sortBy: parsedSortBy,
+          sortOrder: parsedSortOrder ?? (parsedSortBy ? defaultSortOrder(parsedSortBy) : undefined)
+        };
       }
       if (action === "delete") {
         if (help)
@@ -4066,6 +3961,18 @@ function parseSubcommand(positionals, help, jobState, pageSize, since, name, dry
         assertArgCount(positionals, 3, usage);
         return { kind: "jobs-list", queue, jobState, pageSize };
       }
+      if (action === "failed") {
+        if (help)
+          showSubcommandHelp(JOBS_FAILED_HELP);
+        const usage = "jobs failed <queue> [--page-size <n>]";
+        const queue = getRequiredArg(positionals, 2, "queue", usage);
+        assertArgCount(positionals, 3, usage);
+        if (jobState && jobState !== "failed") {
+          writeError("--job-state cannot override 'jobs failed'", "CONFIG_ERROR", "Use 'jobs list <queue> --job-state <state>' for other states.");
+          process.exit(2);
+        }
+        return { kind: "jobs-list", queue, jobState: "failed", pageSize };
+      }
       if (action === "get") {
         if (help)
           showSubcommandHelp(JOBS_GET_HELP);
@@ -4078,20 +3985,29 @@ function parseSubcommand(positionals, help, jobState, pageSize, since, name, dry
       if (action === "retry") {
         if (help)
           showSubcommandHelp(JOBS_RETRY_HELP);
-        const usage = "jobs retry <queue> --job-state failed [--since <duration>] [--name <pattern>] [--dry-run]";
+        const usage = "jobs retry <queue> (--job-id <id> | --job-state failed) [--since <duration>] [--name <pattern>] [--dry-run|--yes]";
         const queue = getRequiredArg(positionals, 2, "queue", usage);
         assertArgCount(positionals, 3, usage);
-        if (!jobState) {
-          writeError("--job-state is required for 'jobs retry'", "CONFIG_ERROR", "Use --job-state failed. Other states are not currently supported.");
+        if (!jobState && !retryJobId) {
+          writeError("--job-id or --job-state is required for 'jobs retry'", "CONFIG_ERROR", "Use --job-id <id> for one failed job or --job-state failed for a filtered batch.");
           process.exit(2);
         }
-        if (jobState !== "failed") {
+        if (jobState && jobState !== "failed") {
           writeError(`Unsupported --job-state '${jobState}' for 'jobs retry'`, "CONFIG_ERROR", "Only --job-state failed is currently supported.");
           process.exit(2);
         }
-        return { kind: "jobs-retry", queue, jobState, since, name, pageSize, dryRun };
+        return {
+          kind: "jobs-retry",
+          queue,
+          jobState: "failed",
+          jobId: retryJobId,
+          since,
+          name,
+          pageSize,
+          dryRun
+        };
       }
-      writeError(`Invalid action '${action}' for jobs`, "CONFIG_ERROR", "Available actions: list, get, retry. Use --help for usage.");
+      writeError(`Invalid action '${action}' for jobs`, "CONFIG_ERROR", "Available actions: list, failed, get, retry. Use --help for usage.");
       process.exit(2);
     }
     case "schedulers": {
@@ -4149,8 +4065,11 @@ function parseCliArgs() {
         "job-state": { type: "string" },
         "page-size": { type: "string" },
         "human-friendly": { type: "boolean" },
+        "sort-by": { type: "string" },
+        "sort-order": { type: "string" },
         since: { type: "string" },
         name: { type: "string" },
+        "job-id": { type: "string" },
         "dry-run": { type: "boolean" },
         yes: { type: "boolean" },
         profile: { type: "string" },
@@ -4177,7 +4096,15 @@ function parseCliArgs() {
       writeError(`Invalid --since value '${since}'`, "CONFIG_ERROR", "Expected format: 30s, 5m, 1h, 24h, 7d. Must be a positive integer followed by s/m/h/d.");
       process.exit(2);
     }
-    const subcommand = parseSubcommand(positionals, !!values.help, values["job-state"], pageSize, since, nameFilter, dryRun, yes ?? false);
+    const subcommand = parseSubcommand(positionals, !!values.help, values["job-state"], pageSize, since, nameFilter, values["job-id"], dryRun, yes ?? false, values["sort-by"], values["sort-order"]);
+    if (values["sort-by"] && (!subcommand || subcommand.kind !== "queues-list")) {
+      writeError("--sort-by can only be used with 'queues list'", "CONFIG_ERROR", "Usage: queues list --sort-by task-size");
+      process.exit(2);
+    }
+    if (values["sort-order"] && (!subcommand || subcommand.kind !== "queues-list")) {
+      writeError("--sort-order can only be used with 'queues list'", "CONFIG_ERROR", "Usage: queues list --sort-by task-size --sort-order desc");
+      process.exit(2);
+    }
     if (subcommand?.kind === "jobs-retry" && pageSize !== undefined && pageSize > MAX_RETRY_PAGE_SIZE) {
       writeError(`--page-size exceeds ${MAX_RETRY_PAGE_SIZE}`, "CONFIG_ERROR", `--page-size is capped at ${MAX_RETRY_PAGE_SIZE}. For larger batches, run multiple passes with narrower filters (--since, --name).`);
       process.exit(2);
@@ -4198,6 +4125,10 @@ function parseCliArgs() {
       writeError("--name can only be used with 'jobs retry'", "CONFIG_ERROR", "Usage: jobs retry <queue> --job-state failed --name <pattern>");
       process.exit(2);
     }
+    if (values["job-id"] && (!subcommand || subcommand.kind !== "jobs-retry")) {
+      writeError("--job-id can only be used with 'jobs retry'", "CONFIG_ERROR", "Usage: jobs retry <queue> --job-id <id> --dry-run");
+      process.exit(2);
+    }
     if (humanFriendly && !subcommand) {
       writeError("--human-friendly can only be used with subcommands", "CONFIG_ERROR", "Usage: bullmq-dash <command> --human-friendly. Use --help for usage.");
       process.exit(2);
@@ -4210,12 +4141,12 @@ function parseCliArgs() {
       writeError("--dry-run can only be used with 'jobs retry' or 'queues delete'", "CONFIG_ERROR", "Usage: jobs retry <queue> --job-state failed --dry-run  or  queues delete <queue> --dry-run");
       process.exit(2);
     }
-    if (yes && (!subcommand || subcommand.kind !== "queues-delete")) {
-      writeError("--yes can only be used with 'queues delete'", "CONFIG_ERROR", "Usage: queues delete <queue> --yes");
+    if (yes && (!subcommand || subcommand.kind !== "queues-delete" && subcommand.kind !== "jobs-retry")) {
+      writeError("--yes can only be used with 'queues delete' or 'jobs retry'", "CONFIG_ERROR", "Usage: queues delete <queue> --yes  or  jobs retry <queue> --job-state failed --yes");
       process.exit(2);
     }
     if (dryRun && yes) {
-      writeError("--dry-run and --yes cannot be used together", "CONFIG_ERROR", "Usage: queues delete <queue> [--dry-run] or queues delete <queue> --yes");
+      writeError("--dry-run and --yes cannot be used together", "CONFIG_ERROR", "Usage: queues delete <queue> [--dry-run|--yes] or jobs retry <queue> [--dry-run|--yes]");
       process.exit(2);
     }
     if (humanFriendly && values.tui) {
@@ -4271,6 +4202,141 @@ function shouldLoadProfile(cliArgs) {
   return !cliArgs.redisUrl || !!cliArgs.profile || !!cliArgs.configPath;
 }
 
+// src/config.ts
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+function coercePositiveInt(value, fallback) {
+  if (value === undefined)
+    return fallback;
+  const numberValue = Number(value);
+  if (!Number.isInteger(numberValue) || numberValue <= 0)
+    return null;
+  return numberValue;
+}
+function coerceNonNegativeInt(value, fallback) {
+  if (value === undefined)
+    return fallback;
+  const numberValue = Number(value);
+  if (!Number.isInteger(numberValue) || numberValue < 0)
+    return null;
+  return numberValue;
+}
+function coerceString(value, fallback) {
+  if (value === undefined)
+    return fallback;
+  return typeof value === "string" ? value : null;
+}
+function coerceOptionalString(value) {
+  if (value === undefined)
+    return;
+  return typeof value === "string" ? value : null;
+}
+var CONFIG_ALLOWED_KEYS = ["redis", "pollInterval", "prefix", "queueNames", "cacheTtlMs"];
+var CONFIG_REDIS_ALLOWED_KEYS = ["host", "port", "username", "password", "db", "tls"];
+function validateConfig(raw) {
+  const errors = [];
+  for (const key of Object.keys(raw)) {
+    if (!CONFIG_ALLOWED_KEYS.includes(key)) {
+      errors.push(`unknown key '${key}' in config (allowed: ${CONFIG_ALLOWED_KEYS.join(", ")})`);
+    }
+  }
+  for (const key of Object.keys(raw.redis)) {
+    if (!CONFIG_REDIS_ALLOWED_KEYS.includes(key)) {
+      errors.push(`unknown key '${key}' in config.redis (allowed: ${CONFIG_REDIS_ALLOWED_KEYS.join(", ")})`);
+    }
+  }
+  const redis = raw.redis;
+  const host = coerceString(redis.host, "localhost");
+  if (host === null)
+    errors.push("redis.host must be a string");
+  const port = coercePositiveInt(redis.port, 6379);
+  if (port === null)
+    errors.push("redis.port must be a positive integer");
+  const username = coerceOptionalString(redis.username);
+  if (username === null)
+    errors.push("redis.username must be a string");
+  const password = coerceOptionalString(redis.password);
+  if (password === null)
+    errors.push("redis.password must be a string");
+  const db = coerceNonNegativeInt(redis.db, 0);
+  if (db === null)
+    errors.push("redis.db must be a non-negative integer");
+  const tls = redis.tls;
+  if (tls !== undefined && typeof tls !== "boolean") {
+    errors.push("redis.tls must be a boolean");
+  }
+  const pollInterval = coercePositiveInt(raw.pollInterval, 3000);
+  if (pollInterval === null)
+    errors.push("pollInterval must be a positive integer");
+  const prefix = coerceString(raw.prefix, "bull");
+  if (prefix === null)
+    errors.push("prefix must be a string");
+  const queueNames = raw.queueNames;
+  if (queueNames !== undefined && (!Array.isArray(queueNames) || queueNames.some((name) => typeof name !== "string"))) {
+    errors.push("queueNames must be an array of strings");
+  }
+  const cacheTtlMs = coercePositiveInt(raw.cacheTtlMs, DEFAULT_CACHE_TTL_MS);
+  if (cacheTtlMs === null)
+    errors.push("cacheTtlMs must be a positive integer");
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  const config = {
+    redis: {
+      host,
+      port,
+      db
+    },
+    pollInterval,
+    prefix,
+    cacheTtlMs
+  };
+  if (username !== undefined && username !== null)
+    config.redis.username = username;
+  if (password !== undefined && password !== null)
+    config.redis.password = password;
+  if (tls !== undefined)
+    config.redis.tls = tls;
+  if (queueNames !== undefined)
+    config.queueNames = queueNames;
+  return { success: true, data: config };
+}
+function loadConfig(cliArgs, profile) {
+  const p = profile?.profile;
+  const url = cliArgs.redisUrl ?? p?.redis?.url;
+  let parts;
+  if (url) {
+    try {
+      parts = parseRedisUrl(url);
+    } catch (error) {
+      writeError(cliArgs.redisUrl ? "Invalid --redis-url" : `Invalid redis.url in profile '${profile?.name}'`, "CONFIG_ERROR", error instanceof Error ? error.message : String(error));
+      process.exit(2);
+    }
+  }
+  const raw = {
+    redis: {
+      host: parts?.host,
+      port: parts?.port,
+      username: parts?.username,
+      password: parts?.password,
+      db: parts?.db,
+      tls: parts?.tls
+    },
+    pollInterval: cliArgs.pollInterval ?? p?.pollInterval,
+    prefix: cliArgs.prefix ?? p?.prefix,
+    queueNames: cliArgs.queues ?? p?.queues,
+    cacheTtlMs: p?.cacheTtlMs
+  };
+  const result = validateConfig(raw);
+  if (!result.success) {
+    writeError("Configuration error", "CONFIG_ERROR", result.errors.join("; "));
+    process.exit(2);
+  }
+  return result.data;
+}
+function createConfigFromPrompt(redisUrl, cliArgs) {
+  return loadConfig({ ...cliArgs, redisUrl });
+}
+
 // src/ui/config-prompt.ts
 import * as readline from "readline";
 var cyan = (text) => `\x1B[36m${text}\x1B[0m`;
@@ -4548,6 +4614,8 @@ var MAX_DISPLAYED_ERRORS = 10;
 function formatJobsRetry(r) {
   const lines = [];
   const filterParts = [`state=${r.filter.jobState}`];
+  if (r.filter.jobId)
+    filterParts.push(`jobId=${r.filter.jobId}`);
   if (r.filter.since)
     filterParts.push(`since=${r.filter.since}`);
   if (r.filter.name)
@@ -4586,7 +4654,7 @@ function formatJobsRetry(r) {
   }
   if (r.dryRun) {
     lines.push("");
-    lines.push("Run without --dry-run to retry these jobs.");
+    lines.push("Run with --yes and without --dry-run to retry these jobs from scripts.");
   }
   return lines.join(`
 `);
@@ -4600,10 +4668,28 @@ function createResponse(data) {
     ...data
   };
 }
-async function fetchQueuesOverview() {
-  const queueNames = await discoverQueueNames();
-  const queues = await Promise.all(queueNames.map((name) => getQueueStats(name)));
-  const jobCounts = queues.reduce((acc, q) => ({
+function omitObservationMetadata(item) {
+  const copy = { ...item };
+  delete copy.lastObservedAt;
+  return copy;
+}
+function publicJobSummary(job) {
+  return {
+    id: job.id,
+    name: job.name,
+    state: job.state,
+    timestamp: job.timestamp
+  };
+}
+async function fetchQueuesOverview(ctx, sortBy = "name", sortOrder = defaultSortOrder(sortBy)) {
+  const queueNames = await discoverQueueNames(ctx);
+  const queues = await Promise.all(queueNames.map((name) => getQueueStats(ctx, name)));
+  const sortedQueues = sortQueues(queues, sortBy, sortOrder);
+  const observedAt = Date.now();
+  try {
+    recordObservedQueues(ctx, sortedQueues, { observedAt });
+  } catch {}
+  const jobCounts = sortedQueues.reduce((acc, q) => ({
     wait: acc.wait + q.counts.wait,
     active: acc.active + q.counts.active,
     completed: acc.completed + q.counts.completed,
@@ -4612,15 +4698,15 @@ async function fetchQueuesOverview() {
     total: acc.total + q.total
   }), { wait: 0, active: 0, completed: 0, failed: 0, delayed: 0, total: 0 });
   return createResponse({
-    queues,
+    queues: sortedQueues.map(omitObservationMetadata),
     metrics: {
-      queueCount: queues.length,
+      queueCount: sortedQueues.length,
       jobCounts
     }
   });
 }
-async function fetchQueuesDelete(queueName, dryRun) {
-  const result = await deleteQueue(queueName, dryRun);
+async function fetchQueuesDelete(ctx, queueName, dryRun) {
+  const result = await deleteQueue(ctx, queueName, dryRun);
   return createResponse({
     queue: queueName,
     deleted: !dryRun,
@@ -4629,22 +4715,16 @@ async function fetchQueuesDelete(queueName, dryRun) {
     totalJobs: result.counts.wait + result.counts.active + result.counts.completed + result.counts.failed + result.counts.delayed
   });
 }
-async function fetchJobsList(queueName, jobState, maxResults) {
-  const { jobs, total } = await getAllJobs(queueName, jobState, maxResults, true);
+async function fetchJobsList(ctx, queueName, jobState, maxResults) {
+  const { jobs, total } = await getAllJobs(ctx, queueName, jobState, maxResults, true);
+  const observedAt = Date.now();
   try {
-    upsertJobs(queueName, jobs.map((j) => ({
-      id: j.id,
-      name: j.name,
-      state: j.state,
-      timestamp: j.timestamp,
-      data: j.data
-    })));
-    markPolledWrites(queueName, jobs.map((j) => j.id));
+    recordObservedJobs(ctx, queueName, jobs, { observedAt });
   } catch {}
   return createResponse({
     queue: queueName,
     jobState: jobState ?? "all",
-    jobs,
+    jobs: jobs.map(publicJobSummary),
     total
   });
 }
@@ -4653,9 +4733,11 @@ function computeRetryExitCode(result) {
     return 3;
   return 0;
 }
-async function fetchJobsRetry(queueName, jobState, since, name, pageSize, dryRun) {
-  const result = await retryFailedJobs(queueName, { since, name, pageSize, dryRun });
+async function fetchJobsRetry(ctx, queueName, jobState, jobId, since, name, pageSize, dryRun) {
+  const result = await retryFailedJobs(ctx, queueName, { jobId, since, name, pageSize, dryRun });
   const filter = { jobState };
+  if (jobId !== undefined)
+    filter.jobId = jobId;
   if (since !== undefined)
     filter.since = since;
   if (name !== undefined)
@@ -4673,40 +4755,52 @@ async function fetchJobsRetry(queueName, jobState, since, name, pageSize, dryRun
     truncated: result.truncated
   });
 }
-async function fetchJobDetail(queueName, jobId) {
-  const job = await getJobDetail(queueName, jobId);
+async function fetchJobDetail(ctx, queueName, jobId) {
+  const job = await getJobDetail(ctx, queueName, jobId);
   if (!job) {
     writeError(`Job '${jobId}' not found in queue '${queueName}'`, "RUNTIME_ERROR");
     try {
-      await cleanup();
+      await closeContext(ctx);
     } catch {}
     process.exit(1);
   }
+  const observedAt = Date.now();
+  try {
+    recordObservedJobs(ctx, queueName, [job], { observedAt });
+  } catch {}
   return createResponse({
     queue: queueName,
-    job
+    job: omitObservationMetadata(job)
   });
 }
-async function fetchSchedulersList(queueName, maxResults) {
-  const { schedulers, total } = await getAllJobSchedulers(queueName, maxResults);
+async function fetchSchedulersList(ctx, queueName, maxResults) {
+  const { schedulers, total } = await getAllJobSchedulers(ctx, queueName, maxResults);
+  const observedAt = Date.now();
+  try {
+    recordObservedSchedulers(ctx, queueName, schedulers, { observedAt });
+  } catch {}
   return createResponse({
     queue: queueName,
-    schedulers,
+    schedulers: schedulers.map(omitObservationMetadata),
     total
   });
 }
-async function fetchSchedulerDetail(queueName, schedulerKey) {
-  const scheduler = await getJobSchedulerDetail(queueName, schedulerKey);
+async function fetchSchedulerDetail(ctx, queueName, schedulerKey) {
+  const scheduler = await getJobSchedulerDetail(ctx, queueName, schedulerKey);
   if (!scheduler) {
     writeError(`Scheduler '${schedulerKey}' not found in queue '${queueName}'`, "RUNTIME_ERROR");
     try {
-      await cleanup();
+      await closeContext(ctx);
     } catch {}
     process.exit(1);
   }
+  const observedAt = Date.now();
+  try {
+    recordObservedSchedulers(ctx, queueName, [scheduler], { observedAt });
+  } catch {}
   return createResponse({
     queue: queueName,
-    scheduler
+    scheduler: omitObservationMetadata(scheduler)
   });
 }
 function validateJobState(jobState) {
@@ -4730,33 +4824,40 @@ function promptConfirmation(message) {
     });
   });
 }
-async function cleanup() {
-  await closeAllQueues();
-  await disconnectRedis();
-  closeSqliteDb();
+function jobsRetryConfirmationMessage(subcommand) {
+  if (subcommand.jobId) {
+    return `Retry failed job '${subcommand.jobId}' in queue '${subcommand.queue}'?`;
+  }
+  const filters = [];
+  if (subcommand.since)
+    filters.push(`since=${subcommand.since}`);
+  if (subcommand.name)
+    filters.push(`name=${subcommand.name}`);
+  const suffix = filters.length > 0 ? ` matching ${filters.join(", ")}` : "";
+  return `Retry failed jobs in queue '${subcommand.queue}'${suffix}?`;
 }
-async function routeAndFetch(subcommand) {
+async function routeAndFetch(ctx, subcommand) {
   switch (subcommand.kind) {
     case "queues-list":
-      return fetchQueuesOverview();
+      return fetchQueuesOverview(ctx, subcommand.sortBy, subcommand.sortOrder);
     case "queues-delete":
-      return fetchQueuesDelete(subcommand.queue, subcommand.dryRun ?? false);
+      return fetchQueuesDelete(ctx, subcommand.queue, subcommand.dryRun ?? false);
     case "jobs-list": {
       const validState = validateJobState(subcommand.jobState);
-      return fetchJobsList(subcommand.queue, validState, subcommand.pageSize);
+      return fetchJobsList(ctx, subcommand.queue, validState, subcommand.pageSize);
     }
     case "jobs-get":
-      return fetchJobDetail(subcommand.queue, subcommand.jobId);
+      return fetchJobDetail(ctx, subcommand.queue, subcommand.jobId);
     case "jobs-retry": {
       const validState = validateJobState(subcommand.jobState);
       if (!validState)
         throw new Error("jobs retry requires --job-state");
-      return fetchJobsRetry(subcommand.queue, validState, subcommand.since, subcommand.name, subcommand.pageSize, subcommand.dryRun);
+      return fetchJobsRetry(ctx, subcommand.queue, validState, subcommand.jobId, subcommand.since, subcommand.name, subcommand.pageSize, subcommand.dryRun);
     }
     case "schedulers-list":
-      return fetchSchedulersList(subcommand.queue, subcommand.pageSize);
+      return fetchSchedulersList(ctx, subcommand.queue, subcommand.pageSize);
     case "schedulers-get":
-      return fetchSchedulerDetail(subcommand.queue, subcommand.schedulerId);
+      return fetchSchedulerDetail(ctx, subcommand.queue, subcommand.schedulerId);
     default: {
       const _exhaustive = subcommand;
       throw new Error(`Unhandled subcommand: ${_exhaustive.kind}`);
@@ -4788,15 +4889,14 @@ function formatOutput(result, subcommand, humanFriendly) {
     }
   }
 }
-async function runJsonMode(config, subcommand, humanFriendly = false, dryRun = false, yes = false) {
-  setConfig(config);
-  if (subcommand.kind === "queues-delete" && !yes && !dryRun) {
+async function runJsonMode(ctx, subcommand, humanFriendly = false, yes = false) {
+  if (subcommand.kind === "queues-delete" && !yes && !(subcommand.dryRun ?? false)) {
     if (process.stdin.isTTY) {
       const confirmed = await promptConfirmation(`Delete queue '${subcommand.queue}' and all its jobs? This cannot be undone.`);
       if (!confirmed) {
         process.stderr.write(`Cancelled.
 `);
-        await cleanup();
+        await closeContext(ctx);
         process.exit(1);
       }
     } else {
@@ -4804,16 +4904,33 @@ async function runJsonMode(config, subcommand, humanFriendly = false, dryRun = f
       process.exit(2);
     }
   }
+  if (subcommand.kind === "jobs-retry" && !yes && !subcommand.dryRun) {
+    if (process.stdin.isTTY) {
+      const confirmed = await promptConfirmation(jobsRetryConfirmationMessage(subcommand));
+      if (!confirmed) {
+        process.stderr.write(`Cancelled.
+`);
+        await closeContext(ctx);
+        process.exit(1);
+      }
+    } else {
+      writeError("Confirmation required: run with --yes flag in non-interactive mode", "CONFIG_ERROR", "Use --yes to retry failed jobs in scripts, or run in interactive terminal.");
+      process.exit(2);
+    }
+  }
   try {
-    await connectRedis();
+    await ctx.redis.connect();
   } catch (error) {
     writeError("Redis connection failed", "REDIS_ERROR", error instanceof Error ? error.message : String(error));
+    try {
+      await closeContext(ctx);
+    } catch {}
     process.exit(1);
   }
-  createSqliteDb();
   let exitCode = 0;
   try {
-    const result = await routeAndFetch(subcommand);
+    const result = await routeAndFetch(ctx, subcommand);
+    runQueueStoreCleanupIfDue(ctx);
     const output = formatOutput(result, subcommand, humanFriendly);
     process.stdout.write(output + `
 `);
@@ -4823,11 +4940,11 @@ async function runJsonMode(config, subcommand, humanFriendly = false, dryRun = f
   } catch (error) {
     writeError("Failed to fetch data", "RUNTIME_ERROR", error instanceof Error ? error.message : String(error));
     try {
-      await cleanup();
+      await closeContext(ctx);
     } catch {}
     process.exit(1);
   }
-  await cleanup();
+  await closeContext(ctx);
   process.exit(exitCode);
 }
 
@@ -4852,7 +4969,8 @@ async function main() {
       process.exit(2);
     }
     const config = loadConfig(cliArgs, profile);
-    await runJsonMode(config, cliArgs.subcommand, cliArgs.humanFriendly, cliArgs.dryRun, cliArgs.yes);
+    const ctx = createContext(config);
+    await runJsonMode(ctx, cliArgs.subcommand, cliArgs.humanFriendly, cliArgs.yes);
     return;
   }
   if (cliArgs.tui) {
@@ -4865,9 +4983,9 @@ async function main() {
       const url = await runConfigPrompt();
       config = createConfigFromPrompt(url, cliArgs);
     }
-    setConfig(config);
     try {
-      const app = new App;
+      const ctx = createContext(config);
+      const app = new App(ctx);
       await app.start();
     } catch (error) {
       writeError("Failed to start application", "RUNTIME_ERROR", error instanceof Error ? error.message : String(error));