@merittdev/horus 0.1.9 → 0.1.11

package/dist/index.cjs

@@ -49547,7 +49547,7 @@ var require_Redis = __commonJS({
     var lodash_1 = require_lodash();
     var Deque = require_denque();
     var debug = (0, utils_1.Debug)("redis");
-    var Redis2 = class _Redis extends Commander_1.default {
+    var Redis3 = class _Redis extends Commander_1.default {
       constructor(arg1, arg2, arg3) {
         super();
         this.status = "wait";
@@ -50212,12 +50212,12 @@ var require_Redis = __commonJS({
         }).catch(lodash_1.noop);
       }
     };
-    Redis2.Cluster = cluster_1.default;
-    Redis2.Command = Command_1.default;
-    Redis2.defaultOptions = RedisOptions_1.DEFAULT_REDIS_OPTIONS;
-    (0, applyMixin_1.default)(Redis2, events_1.EventEmitter);
-    (0, transaction_1.addTransactionSupport)(Redis2.prototype);
-    exports2.default = Redis2;
+    Redis3.Cluster = cluster_1.default;
+    Redis3.Command = Command_1.default;
+    Redis3.defaultOptions = RedisOptions_1.DEFAULT_REDIS_OPTIONS;
+    (0, applyMixin_1.default)(Redis3, events_1.EventEmitter);
+    (0, transaction_1.addTransactionSupport)(Redis3.prototype);
+    exports2.default = Redis3;
   }
 });
 
@@ -50314,7 +50314,7 @@ init_cjs_shims();
 
 // ../../packages/core/src/version.ts
 init_cjs_shims();
-var HORUS_VERSION = true ? "0.1.9" : "dev";
+var HORUS_VERSION = true ? "0.1.11" : "dev";
 var PINNED_AXON_VERSION = "1.0.7";
 var PINNED_SOURCE_VERSION = PINNED_AXON_VERSION;
 
@@ -54541,6 +54541,37 @@ var repositorySchema = external_exports.object({
    */
   axon: external_exports.object({ hostUrl: external_exports.string().url() }).optional()
 });
+var REDIS_ROLES = [
+  "cache",
+  "state",
+  "locks",
+  "rate-limit",
+  "session",
+  "dedupe",
+  "bullmq",
+  "queues"
+];
+var redisRoleSchema = external_exports.enum(REDIS_ROLES);
+var REDIS_QUEUE_ROLES = ["bullmq", "queues"];
+function redisDbFromUrl(url) {
+  if (!url) return 0;
+  try {
+    const seg = new URL(url).pathname.replace(/^\//, "");
+    const n = Number.parseInt(seg, 10);
+    return Number.isInteger(n) && n >= 0 ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+function redisUrlForDb(url, db) {
+  try {
+    const u = new URL(url);
+    u.pathname = `/${db}`;
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
 var connectorsSchema = external_exports.object({
   elasticsearch: external_exports.object({
     indexPattern: external_exports.string().optional(),
@@ -54619,7 +54650,33 @@ var connectorsSchema = external_exports.object({
     /** Direct URL value (takes priority over urlEnv). */
     url: external_exports.string().optional(),
     /** Name of the env var holding the Redis URL. Defaults to "REDIS_URL". */
-    urlEnv: external_exports.string().optional()
+    urlEnv: external_exports.string().optional(),
+    /**
+     * Logical databases on the same Redis server (HOR-201). Redis is a general
+     * runtime-evidence connector — a single server commonly holds BullMQ queues in
+     * one DB and cache/locks/rate-limit/session keys in others. Declaring them here
+     * (with roles) lets `queues --live` target the queue DB and lets investigation
+     * collectors target cache/state/locks DBs. When omitted, the DB index in `url`
+     * (default 0) is treated as a single configured database (backward compatible).
+     */
+    databases: external_exports.array(
+      external_exports.object({
+        /** Logical DB index on the server (0–15 by default Redis config). */
+        db: external_exports.number().int().min(0).max(15),
+        /** Friendly name for display (e.g. "cache", "queues"). */
+        name: external_exports.string().optional(),
+        /** What this DB holds — drives which collectors/commands use it. */
+        roles: external_exports.array(redisRoleSchema).default([]),
+        /** BullMQ settings when this DB has the bullmq/queues role. */
+        bullmq: external_exports.object({ prefix: external_exports.string().default("bull") }).optional(),
+        /** Sampled-scan settings for cache/state/locks DBs. */
+        scan: external_exports.object({
+          enabled: external_exports.boolean().default(true),
+          sampleLimit: external_exports.number().int().positive().default(500),
+          patterns: external_exports.array(external_exports.string()).default([])
+        }).optional()
+      })
+    ).optional()
   }).optional()
 }).default({});
 var environmentSchema = external_exports.object({
@@ -54762,8 +54819,28 @@ function resolveEnvironment(config, opts) {
   }
   if (c.redis !== void 0) {
     const r = c.redis;
+    const url = r.url ?? process.env[r.urlEnv ?? "REDIS_URL"];
+    let databases;
+    if (r.databases !== void 0 && r.databases.length > 0) {
+      databases = r.databases.map((d) => ({
+        db: d.db,
+        ...d.name !== void 0 ? { name: d.name } : {},
+        roles: d.roles,
+        bullmqPrefix: d.bullmq?.prefix ?? "bull",
+        ...d.scan !== void 0 ? {
+          scan: {
+            enabled: d.scan.enabled,
+            sampleLimit: d.scan.sampleLimit,
+            patterns: d.scan.patterns
+          }
+        } : {}
+      }));
+    } else {
+      databases = [{ db: redisDbFromUrl(url), roles: [], bullmqPrefix: "bull" }];
+    }
     resolved.redis = {
-      url: r.url ?? process.env[r.urlEnv ?? "REDIS_URL"]
+      ...url !== void 0 ? { url } : {},
+      databases
     };
   }
   return {
@@ -57084,12 +57161,16 @@ var BullMQRedisClient = class {
     );
   }
   /**
-   * Discover queue names by scanning for BullMQ wait-list keys.
+   * Discover queue names by scanning for BullMQ `:meta` keys.
+   *
+   * `:meta` is written when a Queue is instantiated and persists regardless of job
+   * state, so it finds idle queues too. Scanning `:wait` (the previous approach) only
+   * surfaced queues with pending jobs, so idle-but-real queues were invisible.
    * Returns at most `limit` queue names.
    */
   async discoverQueues(limit = 50) {
-    const pattern = `${this.prefix}:*:wait`;
-    const suffixLen = ":wait".length;
+    const pattern = `${this.prefix}:*:meta`;
+    const suffixLen = ":meta".length;
     const prefixLen = this.prefix.length + 1;
     const names = [];
     let cursor = "0";
@@ -57272,6 +57353,10 @@ var BullMQRuntimeProvider = class {
     const queues = await Promise.all(names.map((name) => this.inspectQueue(name)));
     return { prefix: this.client.prefix, collectedAt, queues };
   }
+  /** Discover queue names present in Redis under the configured prefix. */
+  discoverQueues() {
+    return this.client.discoverQueues();
+  }
   async inspectQueue(name) {
     const [waiting, active, failed, delayed, completed, paused] = await Promise.all([
       this.client.listLen(this.client.queueKey(name, "wait")),
@@ -57331,6 +57416,174 @@ var BullMQRuntimeProvider = class {
   }
 };
 
+// ../../packages/connectors/src/redis/state-provider.ts
+init_cjs_shims();
+
+// ../../packages/connectors/src/redis/scan-client.ts
+init_cjs_shims();
+var import_ioredis2 = __toESM(require_built3(), 1);
+var SAMPLE_DEFAULT = 500;
+var SCAN_BATCH = 200;
+var RedisScanClient = class {
+  redis;
+  db;
+  constructor(opts) {
+    this.db = opts.db ?? 0;
+    const redisOpts = {
+      db: this.db,
+      lazyConnect: true,
+      enableReadyCheck: false,
+      maxRetriesPerRequest: 1,
+      connectTimeout: 5e3
+    };
+    this.redis = new import_ioredis2.Redis(opts.url, redisOpts);
+    this.redis.on("error", () => {
+    });
+  }
+  /** Ping the server (also exercises AUTH). */
+  async health() {
+    try {
+      await this.redis.ping();
+      return { ok: true, detail: `Redis reachable (db ${this.db})` };
+    } catch (err) {
+      return { ok: false, detail: err.message };
+    }
+  }
+  /** Total number of keys in this DB (DBSIZE). */
+  async dbSize() {
+    return this.redis.dbsize();
+  }
+  /**
+   * Sample up to `limit` keys and group them by their leading segment (before the
+   * first ':'), returning the most common prefixes. Used to characterise a cache/
+   * state DB without reading values. Optional `patterns` restrict the scan.
+   */
+  async samplePrefixes(limit = SAMPLE_DEFAULT, patterns) {
+    const counts = /* @__PURE__ */ new Map();
+    let sampled = 0;
+    const scanPatterns = patterns && patterns.length > 0 ? patterns : ["*"];
+    for (const pattern of scanPatterns) {
+      let cursor = "0";
+      do {
+        const [next, batch] = await this.redis.scan(
+          cursor,
+          "MATCH",
+          pattern,
+          "COUNT",
+          SCAN_BATCH
+        );
+        cursor = next;
+        for (const key of batch) {
+          const prefix = key.includes(":") ? key.slice(0, key.indexOf(":")) : key;
+          counts.set(prefix, (counts.get(prefix) ?? 0) + 1);
+          if (++sampled >= limit) break;
+        }
+      } while (cursor !== "0" && sampled < limit);
+      if (sampled >= limit) break;
+    }
+    return [...counts.entries()].map(([prefix, count]) => ({ prefix, count })).sort((a, b2) => b2.count - a.count);
+  }
+  /**
+   * Detect BullMQ queue names in this DB by scanning `{prefix}:*:meta`. `:meta` exists
+   * for every instantiated queue (even idle ones), so this finds all queues, not just
+   * those with pending jobs. Returns at most `limit` names.
+   */
+  async detectBullmqQueues(prefix = "bull", limit = 200) {
+    const pattern = `${prefix}:*:meta`;
+    const suffixLen = ":meta".length;
+    const prefixLen = prefix.length + 1;
+    const names = [];
+    let cursor = "0";
+    do {
+      const [next, batch] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", SCAN_BATCH);
+      cursor = next;
+      for (const key of batch) {
+        names.push(key.slice(prefixLen, key.length - suffixLen));
+        if (names.length >= limit) return names;
+      }
+    } while (cursor !== "0" && names.length < limit);
+    return names;
+  }
+  async close() {
+    this.redis.disconnect();
+  }
+};
+
+// ../../packages/connectors/src/redis/state-provider.ts
+var LOCK_RE = /lock/i;
+var RATELIMIT_RE = /rate.?limit|throttle/i;
+var RedisStateRuntimeProvider = class {
+  constructor(dbs, mkClient = (d) => new RedisScanClient({ url: d.url, db: d.db })) {
+    this.dbs = dbs;
+    this.mkClient = mkClient;
+  }
+  dbs;
+  mkClient;
+  async analyzeRedisState() {
+    const collectedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const databases = [];
+    const signals = [];
+    for (const d of this.dbs) {
+      const client = this.mkClient(d);
+      try {
+        const health = await client.health();
+        if (!health.ok) continue;
+        const keyCount = await client.dbSize();
+        const prefixes = await client.samplePrefixes(d.scan?.sampleLimit ?? 500, d.scan?.patterns);
+        databases.push({
+          db: d.db,
+          ...d.name !== void 0 ? { name: d.name } : {},
+          roles: d.roles,
+          keyCount,
+          prefixes
+        });
+        if (keyCount === 0) continue;
+        const roleLabel = d.roles.length > 0 ? d.roles.join("/") : "state";
+        const topPrefixes = prefixes.slice(0, 10);
+        const topText = topPrefixes.map((p) => p.prefix).join(" ");
+        signals.push({
+          db: d.db,
+          title: `Redis DB ${d.db} (${roleLabel}): ${keyCount} key(s), top prefixes ${topPrefixes.slice(0, 4).map((p) => `${p.prefix}:*`).join(", ")}`,
+          payload: { db: d.db, roles: d.roles, keyCount, topPrefixes },
+          relevance: 0.4,
+          matchText: `${roleLabel} ${topText}`.toLowerCase()
+        });
+        const lockPrefixes = prefixes.filter((p) => LOCK_RE.test(p.prefix));
+        if (d.roles.includes("locks") || lockPrefixes.length > 0) {
+          const lockKeys = lockPrefixes.reduce((n, p) => n + p.count, 0);
+          if (lockKeys > 0) {
+            signals.push({
+              db: d.db,
+              title: `Redis DB ${d.db}: ${lockKeys} lock key(s) present (${lockPrefixes.map((p) => `${p.prefix}:*`).join(", ")})`,
+              payload: { db: d.db, lockKeys, lockPrefixes },
+              relevance: 0.6,
+              matchText: `lock locks ${lockPrefixes.map((p) => p.prefix).join(" ")}`.toLowerCase()
+            });
+          }
+        }
+        const rlPrefixes = prefixes.filter((p) => RATELIMIT_RE.test(p.prefix));
+        if (d.roles.includes("rate-limit") || rlPrefixes.length > 0) {
+          const rlKeys = rlPrefixes.reduce((n, p) => n + p.count, 0);
+          if (rlKeys > 0) {
+            signals.push({
+              db: d.db,
+              title: `Redis DB ${d.db}: ${rlKeys} rate-limit key(s) present`,
+              payload: { db: d.db, rateLimitKeys: rlKeys, prefixes: rlPrefixes },
+              relevance: 0.6,
+              matchText: `rate limit throttle ${rlPrefixes.map((p) => p.prefix).join(" ")}`.toLowerCase()
+            });
+          }
+        }
+      } finally {
+        await client.close();
+      }
+    }
+    return { collectedAt, databases, signals };
+  }
+  async close() {
+  }
+};
+
 // ../../packages/connectors/src/factory.ts
 function codeForEnv(renv) {
   const repo = renv.repositories[0];
@@ -57372,10 +57625,43 @@ function metricsForEnv(renv) {
     { defaultStep: 60, dashboardUids: g.dashboards }
   );
 }
+function dbHasRole(db, roles) {
+  return db.roles.some((r) => roles.includes(r));
+}
+function queueDatabaseForEnv(renv) {
+  const dbs = renv.connectors.redis?.databases;
+  if (!dbs || dbs.length === 0) return null;
+  return dbs.find((d) => dbHasRole(d, REDIS_QUEUE_ROLES)) ?? (dbs.length === 1 ? dbs[0] : null);
+}
+var STATE_ROLES = ["cache", "state", "locks", "rate-limit", "session", "dedupe"];
+function stateDatabasesForEnv(renv) {
+  const dbs = renv.connectors.redis?.databases ?? [];
+  return dbs.filter((d) => dbHasRole(d, STATE_ROLES));
+}
+function redisStateForEnv(renv) {
+  const r = renv.connectors.redis;
+  if (!r?.url) return null;
+  const stateDbs = stateDatabasesForEnv(renv);
+  if (stateDbs.length === 0) return null;
+  const baseUrl = r.url;
+  return new RedisStateRuntimeProvider(
+    stateDbs.map((d) => ({
+      db: d.db,
+      ...d.name !== void 0 ? { name: d.name } : {},
+      roles: d.roles,
+      url: redisUrlForDb(baseUrl, d.db),
+      ...d.scan !== void 0 ? { scan: { sampleLimit: d.scan.sampleLimit, patterns: d.scan.patterns } } : {}
+    }))
+  );
+}
 function queueForEnv(renv) {
   const r = renv.connectors.redis;
   if (!r?.url) return null;
-  return new BullMQRuntimeProvider(new BullMQRedisClient({ url: r.url }));
+  const queueDb = queueDatabaseForEnv(renv);
+  if (!queueDb) return null;
+  return new BullMQRuntimeProvider(
+    new BullMQRedisClient({ url: redisUrlForDb(r.url, queueDb.db), prefix: queueDb.bullmqPrefix })
+  );
 }
 function mongoForEnv(renv) {
   const m = renv.connectors.mongodb;
@@ -57545,6 +57831,130 @@ init_cjs_shims();
 // ../../packages/connectors/src/bullmq/index.ts
 init_cjs_shims();
 
+// ../../packages/connectors/src/redis/index.ts
+init_cjs_shims();
+
+// ../../packages/connectors/src/redis/discovery.ts
+init_cjs_shims();
+function inferStateRoles(prefixes) {
+  const roles = /* @__PURE__ */ new Set(["cache", "state"]);
+  for (const { prefix } of prefixes) {
+    const p = prefix.toLowerCase();
+    if (/lock/.test(p)) roles.add("locks");
+    if (/rate.?limit|throttle/.test(p)) roles.add("rate-limit");
+    if (/session|sess/.test(p)) roles.add("session");
+    if (/dedup/.test(p)) roles.add("dedupe");
+  }
+  return [...roles];
+}
+async function probeRedisDatabases(baseUrl, opts = {}) {
+  const dbRange = opts.dbRange ?? Array.from({ length: 16 }, (_, i) => i);
+  const sampleLimit = opts.sampleLimit ?? 500;
+  const bullmqPrefix = opts.bullmqPrefix ?? "bull";
+  const probes = [];
+  for (const db of dbRange) {
+    const client = new RedisScanClient({ url: baseUrl, db });
+    try {
+      const health = await client.health();
+      if (!health.ok) {
+        probes.push({
+          db,
+          reachable: false,
+          detail: health.detail,
+          keyCount: 0,
+          prefixes: [],
+          bullmqQueues: [],
+          suggestedRoles: []
+        });
+        break;
+      }
+      const keyCount = await client.dbSize();
+      if (keyCount === 0) {
+        probes.push({ db, reachable: true, keyCount: 0, prefixes: [], bullmqQueues: [], suggestedRoles: [] });
+        continue;
+      }
+      const bullmqQueues = await client.detectBullmqQueues(bullmqPrefix);
+      if (bullmqQueues.length > 0) {
+        probes.push({
+          db,
+          reachable: true,
+          keyCount,
+          prefixes: [],
+          bullmqQueues,
+          bullmqPrefix,
+          suggestedRoles: ["bullmq", "queues"]
+        });
+      } else {
+        const prefixes = await client.samplePrefixes(sampleLimit);
+        probes.push({
+          db,
+          reachable: true,
+          keyCount,
+          prefixes,
+          bullmqQueues: [],
+          suggestedRoles: inferStateRoles(prefixes)
+        });
+      }
+    } finally {
+      await client.close();
+    }
+  }
+  return probes;
+}
+
+// ../../packages/connectors/src/redis/status.ts
+init_cjs_shims();
+async function redisServerStatus(renv) {
+  const r = renv.connectors.redis;
+  if (!r?.url) return null;
+  const url = r.url;
+  let reachable = false;
+  let authFailed = false;
+  const databases = [];
+  for (const d of r.databases) {
+    const client = new RedisScanClient({ url: redisUrlForDb(url, d.db), db: d.db });
+    try {
+      const health = await client.health();
+      const isQueue = d.roles.some((role) => REDIS_QUEUE_ROLES.includes(role));
+      if (!health.ok) {
+        if (/WRONGPASS|NOAUTH|invalid password/i.test(health.detail)) authFailed = true;
+        databases.push({
+          db: d.db,
+          ...d.name !== void 0 ? { name: d.name } : {},
+          roles: d.roles,
+          reachable: false,
+          detail: health.detail
+        });
+        continue;
+      }
+      reachable = true;
+      if (isQueue) {
+        const queues = await client.detectBullmqQueues(d.bullmqPrefix);
+        databases.push({
+          db: d.db,
+          ...d.name !== void 0 ? { name: d.name } : {},
+          roles: d.roles,
+          reachable: true,
+          queueCount: queues.length,
+          bullmqPrefix: d.bullmqPrefix
+        });
+      } else {
+        const keyCount = await client.dbSize();
+        databases.push({
+          db: d.db,
+          ...d.name !== void 0 ? { name: d.name } : {},
+          roles: d.roles,
+          reachable: true,
+          keyCount
+        });
+      }
+    } finally {
+      await client.close();
+    }
+  }
+  return { reachable, authFailed, databases };
+}
+
 // ../../packages/db/src/index.ts
 init_cjs_shims();
 
@@ -66794,10 +67204,32 @@ async function checkEnv(renv, deps) {
   }
   const redisCfg = renv.connectors.redis;
   if (redisCfg?.url) {
-    const safeUrl = redactRedisUrl(redisCfg.url);
-    console.log(
-      `    ${mark("pending")} ${import_picocolors.default.bold("Redis")}           ${import_picocolors.default.dim(`configured \xB7 ${safeUrl}`)}`
-    );
+    const server = redisServerLabel(redisCfg.url);
+    const status = await (deps?.redisStatus ?? redisServerStatus)(renv);
+    if (!status) {
+      console.log(`    ${mark("pending")} ${import_picocolors.default.bold("Redis")}           ${import_picocolors.default.dim(`configured \xB7 ${server}`)}`);
+    } else if (!status.reachable) {
+      const state = status.authFailed ? "auth failed" : "unreachable";
+      console.log(`    ${mark(false)} ${import_picocolors.default.bold("Redis")}           ${import_picocolors.default.dim(`${state} \xB7 ${server}`)}`);
+      allOk = false;
+    } else {
+      console.log(`    ${mark(true)} ${import_picocolors.default.bold("Redis")}           ${import_picocolors.default.dim(`reachable \xB7 ${server}`)}`);
+      for (const d of status.databases) {
+        const roleLabel = d.roles.length > 0 ? d.roles.join("/") : "unrolled";
+        const name = d.name ? ` ${d.name}` : "";
+        let detail;
+        if (!d.reachable) {
+          detail = `${/WRONGPASS|NOAUTH/i.test(d.detail ?? "") ? "auth failed" : "unreachable"}`;
+        } else if (d.queueCount !== void 0) {
+          detail = `${d.queueCount} queue(s), prefix ${d.bullmqPrefix}`;
+        } else {
+          detail = `${d.keyCount ?? 0} key(s)`;
+        }
+        console.log(
+          `      ${mark(d.reachable)} ${import_picocolors.default.bold(`DB ${d.db}`)}${name} ${import_picocolors.default.dim(`${roleLabel} \xB7 ${detail}`)}`
+        );
+      }
+    }
   } else {
     console.log(
       `    ${mark("pending")} ${import_picocolors.default.bold("Redis")}           ${import_picocolors.default.dim("not configured")}`
@@ -66820,6 +67252,14 @@ function redactRedisUrl(raw) {
     return raw.replace(/\/\/:?[^@]*@/, "//:***@");
   }
 }
+function redisServerLabel(raw) {
+  try {
+    const u = new URL(raw);
+    return `${u.hostname}:${u.port || "6379"}`;
+  } catch {
+    return redactRedisUrl(raw);
+  }
+}
 async function runStatus(configPath, opts) {
   console.log(import_picocolors.default.bold(`
 Horus ${HORUS_VERSION}`));
@@ -66869,7 +67309,7 @@ Horus ${HORUS_VERSION}`));
       console.error(import_picocolors.default.red(err.message));
       return 1;
     }
-    const ok = await checkEnv(renv, { mongoFactory: opts?._mongoFactory });
+    const ok = await checkEnv(renv, { mongoFactory: opts?._mongoFactory, redisStatus: opts?._redisStatus });
     return ok ? 0 : 1;
   }
   let allHealthy = true;
@@ -66882,7 +67322,7 @@ Horus ${HORUS_VERSION}`));
       allHealthy = false;
       continue;
     }
-    const ok = await checkEnv(renv, { mongoFactory: opts?._mongoFactory });
+    const ok = await checkEnv(renv, { mongoFactory: opts?._mongoFactory, redisStatus: opts?._redisStatus });
     if (!ok) allHealthy = false;
   }
   return checks.some((c) => c.ok === false && c.fatal) ? 1 : 0;
@@ -67348,7 +67788,14 @@ async function runQueues(name, opts) {
     const config = await loadConfig(opts.config, { name: opts.name });
     const { db, sql: sql2 } = createDb(config.database.url);
     try {
-      const rows = await listQueueEdges(db, { project: opts.project, queueName: name });
+      let project = opts.project;
+      if (project === void 0) {
+        try {
+          project = resolveEnvironment(config, { project: opts.project }).project;
+        } catch {
+        }
+      }
+      const rows = await listQueueEdges(db, { project, queueName: name });
       console.log(
         import_picocolors4.default.bold("Queue topology") + import_picocolors4.default.dim("  \xB7  source: code / source intelligence  \xB7  static (run horus index to refresh)")
       );
@@ -67455,8 +67902,15 @@ async function runLiveMode(config, rows, nameFilter) {
       console.log(import_picocolors4.default.red(`  \u2717 Redis unreachable: ${health.detail}`));
       return;
     }
-    const topologyNames = [...buildQueueMap(rows).keys()];
-    const queueNames = nameFilter !== void 0 ? [nameFilter] : topologyNames.length > 0 ? topologyNames : void 0;
+    const staticNames = new Set(buildQueueMap(rows).keys());
+    let queueNames;
+    if (nameFilter !== void 0) {
+      queueNames = [nameFilter];
+    } else {
+      const discovered = await queueProvider.discoverQueues().catch(() => []);
+      const union2 = /* @__PURE__ */ new Set([...staticNames, ...discovered]);
+      queueNames = union2.size > 0 ? [...union2] : void 0;
+    }
     const state = await queueProvider.analyzeQueues({ queueNames });
     const collectedAt = new Date(state.collectedAt).toLocaleTimeString();
     console.log(
@@ -67473,7 +67927,7 @@ async function runLiveMode(config, rows, nameFilter) {
       );
       return;
     }
-    printLiveTable(state.queues);
+    printLiveTable(state.queues, staticNames);
   } catch (err) {
     if (!headerPrinted) {
       console.log(import_picocolors4.default.bold("Live queue state") + import_picocolors4.default.dim("  \xB7  source: Redis/BullMQ"));
@@ -67484,7 +67938,7 @@ async function runLiveMode(config, rows, nameFilter) {
     });
   }
 }
-function printLiveTable(queues) {
+function printLiveTable(queues, staticNames = /* @__PURE__ */ new Set()) {
   const nameWidth = Math.max(10, ...queues.map((q) => q.queueName.length));
   const numWidth = 7;
   const header = "  " + "queue".padEnd(nameWidth) + "  " + "waiting".padStart(numWidth) + "  " + "active".padStart(numWidth) + "  " + "failed".padStart(numWidth) + "  " + "delayed".padStart(numWidth) + "  " + "paused".padStart(numWidth);
@@ -67495,6 +67949,9 @@ function printLiveTable(queues) {
     const color = hasIssue ? import_picocolors4.default.yellow : (s) => s;
     const row = "  " + q.queueName.padEnd(nameWidth) + "  " + String(q.waiting).padStart(numWidth) + "  " + String(q.active).padStart(numWidth) + "  " + String(q.failed).padStart(numWidth) + "  " + String(q.delayed).padStart(numWidth) + "  " + (q.isPaused ? import_picocolors4.default.yellow("paused") : String(q.paused).padStart(numWidth));
     console.log(color(row));
+    if (!staticNames.has(q.queueName)) {
+      console.log(import_picocolors4.default.dim("    runtime-only \xB7 no static producer/worker mapping"));
+    }
     if (q.oldestWaitingMs !== void 0) {
       const age = formatAge(q.oldestWaitingMs);
       console.log(import_picocolors4.default.dim(`    oldest waiting: ${age}`));
@@ -69730,6 +70187,22 @@ async function investigate(input, deps) {
       stateAnalysis = null;
     }
   }
+  let redisStateAnalysis = null;
+  const redisStateEvIds = [];
+  if (deps.redisState) {
+    try {
+      redisStateAnalysis = await deps.redisState.analyzeRedisState();
+      const redisTerms = [...new Set(tokenize(hint))];
+      for (const s of redisStateAnalysis.signals) {
+        const matched = redisTerms.some((t) => t.length > 2 && s.matchText.includes(t));
+        const relevance = matched ? Math.min(1, s.relevance + 0.3) : s.relevance;
+        const ev = mkEv("redis-key", s.title, s.payload, {}, redisStateAnalysis.collectedAt, relevance);
+        redisStateEvIds.push(ev.id);
+      }
+    } catch {
+      redisStateAnalysis = null;
+    }
+  }
   let queueRuntimeState = null;
   const queueRuntimeEvIds = [];
   const queueRuntimeEvIdsByQueue = /* @__PURE__ */ new Map();
@@ -69963,6 +70436,15 @@ async function investigate(input, deps) {
       evidenceIds: stateEvIds
     });
   }
+  if (redisStateAnalysis !== null && redisStateEvIds.length > 0) {
+    const dbCount = redisStateAnalysis.databases.filter((d) => d.keyCount > 0).length;
+    findings2.push({
+      kind: "observation",
+      title: `Redis runtime state: ${redisStateEvIds.length} signal(s) across ${dbCount} DB(s)`,
+      confidence: 0.5,
+      evidenceIds: redisStateEvIds
+    });
+  }
   if (queueRuntimeState !== null && queueRuntimeEvIds.length > 0) {
     const starved = queueRuntimeState.queues.filter((q) => q.waiting >= 10 && q.active === 0);
     const starvedNames = new Set(starved.map((q) => q.queueName));
@@ -70109,7 +70591,7 @@ async function investigate(input, deps) {
   const providerReliability = {
     code: 0.8,
     ...deps.logs != null ? { logs: 0.7 } : {},
-    ...deps.mongo != null ? { state: 0.85 } : {},
+    ...deps.mongo != null || deps.redisState != null ? { state: 0.85 } : {},
     ...deps.queue != null ? { queue: 0.9 } : {},
     ...deps.metrics != null ? { metrics: 0.75 } : {}
   };
@@ -73148,6 +73630,7 @@ async function runInvestigate(hint, opts) {
     const logs = logsForEnv(renv);
     const mongo = mongoForEnv(renv);
     const queue = queueForEnv(renv);
+    const redisState = redisStateForEnv(renv);
     const metrics = metricsForEnv(renv);
     const service = opts.service ?? renv.connectors.elasticsearch?.serviceName;
     const { db, sql: sql2 } = createDb(config.database.url);
@@ -73160,6 +73643,7 @@ async function runInvestigate(hint, opts) {
           logs,
           mongo,
           queue,
+          redisState,
           metrics,
           repoPath: renv.path,
           connectors: {
@@ -74612,6 +75096,20 @@ async function checkboxSearch(opts) {
 }
 
 // ../../packages/cli/src/commands/connect.ts
+function parseDbSpec(spec) {
+  const [dbPart, rolesPart] = spec.split(":");
+  const db = Number.parseInt((dbPart ?? "").trim(), 10);
+  if (!Number.isInteger(db) || db < 0 || db > 15) {
+    throw new Error(`Invalid --db spec "${spec}": DB index must be 0\u201315 (e.g. 1:bullmq,queues)`);
+  }
+  const roles = (rolesPart ?? "").split(",").map((r) => r.trim()).filter(Boolean);
+  for (const role of roles) {
+    if (!REDIS_ROLES.includes(role)) {
+      throw new Error(`Invalid role "${role}" in --db spec "${spec}". Valid roles: ${REDIS_ROLES.join(", ")}`);
+    }
+  }
+  return { db, roles };
+}
 var SUPPORTED = ["elasticsearch", "mongodb", "grafana", "redis"];
 async function runConnect(type, opts) {
   if (!SUPPORTED.includes(type)) {
@@ -74756,6 +75254,14 @@ ${import_picocolors27.default.bold(`Connect ${type}`)} ${import_picocolors27.def
           filled.url = injectRedisPassword(filled.url, pw);
         }
       }
+      if (filled.db && filled.db.length > 0) {
+        filled.redisDatabases = filled.db.map(parseDbSpec);
+      } else if (filled.url && filled.scanDbs !== false && isInteractive()) {
+        const scan = await askScanDbs();
+        if (scan) {
+          filled.redisDatabases = await discoverAndSelectDbs(filled.url, filled.bullmqPrefix ?? "bull");
+        }
+      }
       break;
     }
   }
@@ -74863,8 +75369,64 @@ function buildGrafanaPatch(opts) {
 function buildRedisPatch(opts) {
   const patch = {};
   if (opts.url) patch["url"] = opts.url;
+  const dbs = opts.redisDatabases ?? (opts.db ? opts.db.map(parseDbSpec) : void 0);
+  if (dbs && dbs.length > 0) {
+    const prefix = opts.bullmqPrefix ?? "bull";
+    patch["databases"] = dbs.map((d) => {
+      const isQueue = d.roles.some((r) => r === "bullmq" || r === "queues");
+      return {
+        db: d.db,
+        ...d.name ? { name: d.name } : {},
+        roles: d.roles,
+        ...isQueue ? { bullmq: { prefix } } : {}
+      };
+    });
+  }
   return patch;
 }
+async function askScanDbs() {
+  const answer = (await ask("Scan Redis DBs 0-15 to detect queues vs cache?", "yes", false)).trim().toLowerCase();
+  return answer === "" || answer === "y" || answer === "yes";
+}
+function describeProbe(p) {
+  if (!p.reachable) return `unreachable (${p.detail ?? "error"})`;
+  if (p.keyCount === 0) return "empty";
+  if (p.bullmqQueues.length > 0) {
+    const sample = p.bullmqQueues.slice(0, 3).join(", ");
+    return `${p.bullmqQueues.length} BullMQ queue(s) \xB7 prefix ${p.bullmqPrefix} \xB7 ${sample}`;
+  }
+  const examples = p.prefixes.slice(0, 3).map((x) => `${x.prefix}:*`).join(", ");
+  return `${p.keyCount} keys \xB7 ${p.suggestedRoles.join("/")}${examples ? ` \xB7 ${examples}` : ""}`;
+}
+async function discoverAndSelectDbs(url, bullmqPrefix) {
+  console.log(import_picocolors27.default.dim("\n  Scanning DBs 0-15 (read-only, sampled)\u2026"));
+  const probes = await probeRedisDatabases(url, { bullmqPrefix });
+  const nonEmpty = probes.filter((p) => p.reachable && p.keyCount > 0);
+  if (nonEmpty.length === 0) {
+    console.log(import_picocolors27.default.dim("  No populated DBs found."));
+    return [];
+  }
+  for (const p of nonEmpty) {
+    console.log(`  ${import_picocolors27.default.bold(`DB ${p.db}`)} ${import_picocolors27.default.dim("\xB7 " + describeProbe(p))}`);
+  }
+  const byLabel = /* @__PURE__ */ new Map();
+  const choices = nonEmpty.map((p) => {
+    const label = `DB ${p.db} \u2014 ${p.suggestedRoles.join("/") || "unrolled"} (${describeProbe(p)})`;
+    byLabel.set(label, p);
+    return label;
+  });
+  let selected;
+  try {
+    selected = await checkboxSearch({ message: "Select DBs to save", choices, pageSize: 12 });
+  } catch (err) {
+    if (err instanceof ExitPromptError) throw err;
+    selected = choices;
+  }
+  return selected.map((label) => {
+    const p = byLabel.get(label);
+    return { db: p.db, name: p.suggestedRoles.includes("bullmq") ? "queues" : "cache", roles: p.suggestedRoles };
+  });
+}
 async function probe(type, opts) {
   try {
     switch (type) {
@@ -74920,36 +75482,23 @@ async function probe(type, opts) {
       }
       case "redis": {
         if (!opts.url) return { ok: true, detail: "skipped (no URL)" };
-        const url = new URL(opts.url);
-        const port = parseInt(url.port || "6379", 10);
-        const host = url.hostname;
-        const reachable = await tcpProbe(host, port);
-        return reachable ? { ok: true, detail: `TCP ${host}:${port} reachable` } : { ok: false, detail: `Could not connect to ${host}:${port}` };
+        const client = new RedisScanClient({ url: opts.url });
+        try {
+          const h = await client.health();
+          const host = new URL(opts.url).hostname;
+          const port = new URL(opts.url).port || "6379";
+          if (h.ok) return { ok: true, detail: `PING ok at ${host}:${port}` };
+          const authFailed = /WRONGPASS|NOAUTH|invalid password/i.test(h.detail);
+          return { ok: false, detail: authFailed ? `auth failed (${h.detail})` : h.detail };
+        } finally {
+          await client.close();
+        }
       }
     }
   } catch (err) {
     return { ok: false, detail: err.message };
   }
 }
-function tcpProbe(host, port, timeoutMs = 3e3) {
-  return new Promise((resolve8) => {
-    const { createConnection } = require("net");
-    const sock = createConnection({ host, port });
-    const timer2 = setTimeout(() => {
-      sock.destroy();
-      resolve8(false);
-    }, timeoutMs);
-    sock.on("connect", () => {
-      clearTimeout(timer2);
-      sock.destroy();
-      resolve8(true);
-    });
-    sock.on("error", () => {
-      clearTimeout(timer2);
-      resolve8(false);
-    });
-  });
-}
 function printSummary(type, opts) {
   const lines = [];
   if (opts.url) lines.push(`  url:            ${redactUrl(opts.url)}`);
@@ -76025,7 +76574,15 @@ Examples:
   });
   program2.command("connect <type>").description(
     "Add or update a runtime connector (elasticsearch / mongodb / grafana / redis) in .horus/config.json"
-  ).option("--env <name>", "target environment (default: first environment in config)").option("--url <url>", "connector URL or connection string (Redis with auth: redis://:password@host:6379)").option("--username <user>", "username (elasticsearch / grafana)").option("--password <pass>", "password (elasticsearch / grafana; for Redis embed in --url)").option("--index-pattern <pattern>", "Elasticsearch index pattern (required for elasticsearch)").option("--service <name>", "service name scope for log queries").option("--database <name>", "database name (required for mongodb)").option("--collections <list>", "comma-separated collection allowlist (mongodb)").option("--dashboard <uid>", "default dashboard uid (grafana)").option("--no-test", "skip live connection probe").action(
+  ).option("--env <name>", "target environment (default: first environment in config)").option("--url <url>", "connector URL or connection string (Redis with auth: redis://:password@host:6379)").option("--username <user>", "username (elasticsearch / grafana)").option("--password <pass>", "password (elasticsearch / grafana; for Redis embed in --url)").option("--index-pattern <pattern>", "Elasticsearch index pattern (required for elasticsearch)").option("--service <name>", "service name scope for log queries").option("--database <name>", "database name (required for mongodb)").option("--collections <list>", "comma-separated collection allowlist (mongodb)").option("--dashboard <uid>", "default dashboard uid (grafana)").option(
+    "--db <spec>",
+    "redis logical DB as db:role1,role2 (e.g. 0:cache,state or 1:bullmq,queues); repeatable",
+    (val, acc) => {
+      acc.push(val);
+      return acc;
+    },
+    []
+  ).option("--bullmq-prefix <prefix>", "BullMQ key prefix for redis queue DBs (default: bull)").option("--no-scan-dbs", "skip interactive Redis DB scan").option("--no-test", "skip live connection probe").action(
     async (type, opts) => {
       process.exitCode = await runConnect(type, {
         env: opts.env,
@@ -76037,6 +76594,9 @@ Examples:
         database: opts.database,
         collections: opts.collections,
         dashboard: opts.dashboard,
+        db: opts.db,
+        bullmqPrefix: opts.bullmqPrefix,
+        scanDbs: opts.scanDbs,
         noTest: opts.test === false
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merittdev/horus",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Local-first, source-aware production-incident investigation engine",
   "type": "module",
   "bin": {