@merittdev/horus 0.1.10 → 0.1.12

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.10" : "dev";
+var HORUS_VERSION = true ? "0.1.12" : "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 {
@@ -57339,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];
@@ -57380,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;
@@ -57553,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();
 
@@ -66802,37 +67204,31 @@ async function checkEnv(renv, deps) {
   }
   const redisCfg = renv.connectors.redis;
   if (redisCfg?.url) {
-    const safeUrl = redactRedisUrl(redisCfg.url);
-    const queueProvider = (deps?.queueFactory ?? queueForEnv)(renv);
-    if (queueProvider) {
-      try {
-        const h = await queueProvider.health();
-        if (h.ok) {
-          let queueInfo = "";
-          try {
-            const discovered = await queueProvider.discoverQueues();
-            queueInfo = ` \xB7 ${discovered.length} queue(s)`;
-          } catch {
-          }
-          console.log(
-            `    ${mark(true)} ${import_picocolors.default.bold("Redis")}           ${import_picocolors.default.dim(`reachable \xB7 ${safeUrl}${queueInfo}`)}`
-          );
+    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 {
-          const authFailed = /WRONGPASS|NOAUTH|invalid password/i.test(h.detail);
-          const state = authFailed ? "auth failed" : "unreachable";
-          console.log(
-            `    ${mark(false)} ${import_picocolors.default.bold("Redis")}           ${import_picocolors.default.dim(`${state} \xB7 ${safeUrl} \xB7 ${h.detail}`)}`
-          );
-          allOk = false;
+          detail = `${d.keyCount ?? 0} key(s)`;
         }
-      } finally {
-        await queueProvider.close().catch(() => {
-        });
+        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(`configured \xB7 ${safeUrl}`)}`
-      );
     }
   } else {
     console.log(
@@ -66856,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}`));
@@ -66905,7 +67309,7 @@ Horus ${HORUS_VERSION}`));
       console.error(import_picocolors.default.red(err.message));
       return 1;
     }
-    const ok = await checkEnv(renv, { mongoFactory: opts?._mongoFactory, queueFactory: opts?._queueFactory });
+    const ok = await checkEnv(renv, { mongoFactory: opts?._mongoFactory, redisStatus: opts?._redisStatus });
     return ok ? 0 : 1;
   }
   let allHealthy = true;
@@ -66918,7 +67322,7 @@ Horus ${HORUS_VERSION}`));
       allHealthy = false;
       continue;
     }
-    const ok = await checkEnv(renv, { mongoFactory: opts?._mongoFactory, queueFactory: opts?._queueFactory });
+    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;
@@ -69783,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();
@@ -69817,8 +70237,10 @@ async function investigate(input, deps) {
   const latencyMetricEvIds = [];
   const queueMetricEvIds = [];
   const queueMetricEvIdsByQueue = /* @__PURE__ */ new Map();
+  const nominalMetricEvIds = [];
   let metricsCollected = false;
   let metricsFailureReason;
+  let metricSeriesChecked = 0;
   if (deps.metrics) {
     const ac = new AbortController();
     let metricsTimerId;
@@ -69878,6 +70300,19 @@ async function investigate(input, deps) {
           }
         }
       }
+      metricSeriesChecked = mFindings.length;
+      if (metricEvIds.length === 0 && mFindings.length > 0) {
+        const panels = [...new Set(mFindings.map((f) => f.panelTitle))];
+        const ev = mkEv(
+          "metric",
+          `Metrics checked \u2014 ${mFindings.length} series across ${panels.length} panel(s), no anomalies in window`,
+          { seriesChecked: mFindings.length, panelCount: panels.length, panels: panels.slice(0, 10), anomalies: 0, stance: "neutral" },
+          {},
+          collectedAt2,
+          0.2
+        );
+        nominalMetricEvIds.push(ev.id);
+      }
       metricsCollected = true;
     } catch (metricsErr) {
       metricsFailureReason = metricsErr?.message?.slice(0, 120) ?? "unknown error";
@@ -70016,6 +70451,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));
@@ -70066,6 +70510,13 @@ async function investigate(input, deps) {
       confidence: 0.7,
       evidenceIds: metricEvIds
     });
+  } else if (nominalMetricEvIds.length > 0) {
+    findings2.push({
+      kind: "observation",
+      title: `Metrics nominal \u2014 ${metricSeriesChecked} series checked, no anomalies in window`,
+      confidence: 0.5,
+      evidenceIds: nominalMetricEvIds
+    });
   }
   const causeInputs = [];
   const blastRadius = impact.affected;
@@ -70162,7 +70613,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 } : {}
   };
@@ -72122,6 +72573,167 @@ function refinedToJSON(r, v) {
   );
 }
 
+// ../../packages/engine/src/qa.ts
+init_cjs_shims();
+var CONTRADICTS_RE = /\b(contradict|contradicts|argues?\s+against|evidence\s+against|rule\s+out|disprove|refute|weaken)\b/i;
+var MISSING_RE = /\b(missing|absent|gaps?|don'?t\s+have|do\s+not\s+have|lack(?:ing)?|what\s+else)\b/i;
+var CONFIDENCE_RE = /\b(confidence|confident|certainty|sure|why\s+(?:is\s+)?(?:it\s+)?not\s+higher)\b/i;
+function detectQuestion(text2) {
+  const t = text2.toLowerCase();
+  if (CONFIDENCE_RE.test(t)) return "confidence";
+  if (CONTRADICTS_RE.test(t)) return "contradicts";
+  if (MISSING_RE.test(t)) return "missing-evidence";
+  return null;
+}
+function categoriesForTopic(text2) {
+  const t = text2.toLowerCase();
+  for (const [topic, entry2] of Object.entries(TOPIC_MAP)) {
+    if (topic === t.trim()) return { topic, categories: entry2.categories };
+    if (entry2.keywords.some((kw) => new RegExp(`\\b${kw}\\b`).test(t))) {
+      return { topic, categories: entry2.categories };
+    }
+  }
+  return null;
+}
+function evidenceById(report) {
+  return new Map(report.evidence.map((e) => [e.id, e]));
+}
+function answerContradicts(report, question) {
+  const matched = categoriesForTopic(question);
+  const byId = evidenceById(report);
+  const hyps = matched ? report.hypotheses.filter((h) => matched.categories.includes(h.category)) : [];
+  if (matched && hyps.length === 0) {
+    const evaluated = [...new Set(report.hypotheses.map((h) => h.category))];
+    return {
+      question,
+      kind: "contradicts",
+      headline: `"${matched.topic}" was not among the evaluated hypotheses \u2014 no evidence supports it.`,
+      details: evaluated.length > 0 ? [`Hypotheses evaluated: ${evaluated.join(", ")}.`] : ["No hypotheses were formed for this investigation."],
+      evidence: []
+    };
+  }
+  if (hyps.length === 0) {
+    const ids3 = [...new Set(report.hypotheses.flatMap((h) => h.contradictingEvidenceIds))];
+    const ev2 = ids3.map((id) => byId.get(id)).filter((e) => e !== void 0);
+    return {
+      question,
+      kind: "contradicts",
+      headline: ev2.length > 0 ? `${ev2.length} item(s) contradict the leading hypotheses.` : "No contradicting evidence was recorded for any hypothesis.",
+      details: ev2.length > 0 ? [] : ["Evidence either supports or is neutral to the hypotheses."],
+      evidence: ev2
+    };
+  }
+  const ids2 = [...new Set(hyps.flatMap((h) => h.contradictingEvidenceIds))];
+  const ev = ids2.map((id) => byId.get(id)).filter((e) => e !== void 0);
+  const verdicts = [...new Set(hyps.map((h) => h.verdict))].join(", ");
+  if (ev.length === 0) {
+    return {
+      question,
+      kind: "contradicts",
+      headline: `No evidence contradicts "${matched?.topic ?? "this"}" (verdict: ${verdicts}).`,
+      details: hyps.map((h) => `${h.category}: ${h.rationale ?? h.statement}`),
+      evidence: []
+    };
+  }
+  return {
+    question,
+    kind: "contradicts",
+    headline: `${ev.length} item(s) contradict "${matched?.topic ?? "this"}" (verdict: ${verdicts}).`,
+    details: hyps.map((h) => `${h.category}: ${h.rationale ?? h.statement}`),
+    evidence: ev
+  };
+}
+function answerMissing(report, question) {
+  const { gaps, blindSpots } = report.gapAnalysis;
+  const hypMissing = [...new Set(report.hypotheses.flatMap((h) => h.missingEvidence))];
+  if (gaps.length === 0 && hypMissing.length === 0) {
+    return {
+      question,
+      kind: "missing-evidence",
+      headline: "No evidence gaps \u2014 all expected dimensions were collected.",
+      details: [],
+      evidence: []
+    };
+  }
+  const details = gaps.map(
+    (g) => `${g.dimension}: ${g.why} \u2192 ${g.nextSource} (\u2212${(g.confidenceImpact * 100).toFixed(0)}% ceiling)`
+  );
+  if (hypMissing.length > 0) {
+    details.push(`To confirm hypotheses: ${hypMissing.join("; ")}.`);
+  }
+  for (const bs of blindSpots) details.push(`Blind spot: ${bs}`);
+  return {
+    question,
+    kind: "missing-evidence",
+    headline: `${gaps.length} evidence gap(s) limit this investigation.`,
+    details,
+    evidence: []
+  };
+}
+function answerConfidence(report, question) {
+  const { gaps, confidenceCeiling } = report.gapAnalysis;
+  const ceilingPct = Math.round(confidenceCeiling * 100);
+  const actualPct = Math.round(report.confidence * 100);
+  const limiting = [...gaps].sort((a, b2) => b2.confidenceImpact - a.confidenceImpact);
+  const details = [];
+  if (limiting.length > 0) {
+    details.push(`Confidence is capped at ${ceilingPct}% by missing evidence:`);
+    for (const g of limiting) {
+      details.push(`  \u2022 ${g.dimension} (\u2212${(g.confidenceImpact * 100).toFixed(0)}%): ${g.why}`);
+    }
+  } else {
+    details.push("No evidence gaps cap the ceiling.");
+  }
+  const weak = report.hypotheses.filter((h) => h.verdict === "weakened" || h.verdict === "unconfirmed");
+  if (weak.length > 0) {
+    details.push(
+      `Unconfirmed/weakened hypotheses: ${weak.map((h) => `${h.category} (${h.verdict})`).join(", ")}.`
+    );
+  }
+  return {
+    question,
+    kind: "confidence",
+    headline: `Confidence is ${actualPct}% (ceiling ${ceilingPct}%). ${limiting.length > 0 ? "Missing evidence is the main limiter." : "Limited by hypothesis support, not gaps."}`,
+    details,
+    evidence: []
+  };
+}
+function answerQuestion(report, question) {
+  const kind = detectQuestion(question);
+  if (kind === null) return null;
+  if (kind === "contradicts") return answerContradicts(report, question);
+  if (kind === "missing-evidence") return answerMissing(report, question);
+  return answerConfidence(report, question);
+}
+function renderQAAnswer(a) {
+  const lines = [];
+  lines.push(`Q: ${a.question}`);
+  lines.push("");
+  lines.push(a.headline);
+  for (const d of a.details) lines.push(d.startsWith("  ") ? d : `  ${d}`);
+  if (a.evidence.length > 0) {
+    lines.push("");
+    lines.push("Evidence:");
+    for (const e of a.evidence) {
+      lines.push(`  [${e.id.slice(0, 8)}] (${e.kind}) ${e.title}`);
+    }
+  }
+  return lines.join("\n");
+}
+function qaToJSON(a) {
+  return JSON.stringify(
+    {
+      question: a.question,
+      kind: a.kind,
+      headline: a.headline,
+      details: a.details,
+      evidence: a.evidence.map((e) => ({ id: e.id, kind: e.kind, title: e.title }))
+    },
+    null,
+    2
+  );
+}
+
 // ../../packages/engine/src/onboard.ts
 init_cjs_shims();
 function tokenize2(text2) {
@@ -73201,6 +73813,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);
@@ -73213,6 +73826,7 @@ async function runInvestigate(hint, opts) {
           logs,
           mongo,
           queue,
+          redisState,
           metrics,
           repoPath: renv.path,
           connectors: {
@@ -73283,6 +73897,12 @@ async function runChanges(base2, compare, opts) {
 // ../../packages/cli/src/commands/timeline.ts
 init_cjs_shims();
 var import_picocolors7 = __toESM(require_picocolors(), 1);
+var DEFAULT_SINCE = "7 days ago";
+function resolveTimelineWindow(opts) {
+  const usingDefault = !opts.all && opts.since === void 0;
+  const since = opts.all ? void 0 : opts.since ?? DEFAULT_SINCE;
+  return { since, usingDefault };
+}
 async function runTimeline(service, opts) {
   try {
     const config = await loadConfig(opts.config);
@@ -73294,11 +73914,24 @@ async function runTimeline(service, opts) {
       return 1;
     }
     const { code } = createConnectors(config);
+    const { since, usingDefault: usingDefaultWindow } = resolveTimelineWindow(opts);
     const t = await reconstructChangeTimeline(
-      { repoPath: renv.path, since: opts.since, until: opts.until, service },
+      { repoPath: renv.path, since, until: opts.until, service },
       { code }
     );
-    console.log(opts.json ? changeTimelineToJSON(t) : renderChangeTimeline(t));
+    if (opts.json) {
+      console.log(changeTimelineToJSON(t));
+    } else {
+      console.log(renderChangeTimeline(t));
+      if (usingDefaultWindow) {
+        console.log(
+          import_picocolors7.default.dim(
+            `
+  Showing the last 7 days (default). Widen with ${import_picocolors7.default.bold('--since "30 days ago"')}, pin a range with ${import_picocolors7.default.bold("--since <when> --until <when>")}, or see everything with ${import_picocolors7.default.bold("--all")}.`
+          )
+        );
+      }
+    }
     return 0;
   } catch (err) {
     console.error(import_picocolors7.default.red(err.message));
@@ -73309,7 +73942,7 @@ async function runTimeline(service, opts) {
 // ../../packages/cli/src/commands/what-changed.ts
 init_cjs_shims();
 var import_picocolors8 = __toESM(require_picocolors(), 1);
-var DEFAULT_SINCE = "7 days ago";
+var DEFAULT_SINCE2 = "7 days ago";
 async function runWhatChanged(service, opts) {
   try {
     const config = await loadConfig(opts.config);
@@ -73321,7 +73954,7 @@ async function runWhatChanged(service, opts) {
       return 1;
     }
     const { code } = createConnectors(config);
-    const since = opts.since ?? DEFAULT_SINCE;
+    const since = opts.since ?? DEFAULT_SINCE2;
     const r = await whatChanged(
       { repoPath: renv.path, since, until: opts.until, service },
       { code }
@@ -73782,6 +74415,11 @@ async function runAsk(id, directive, opts) {
       return 1;
     }
     const report = migrateReport(row.report);
+    const answer = answerQuestion(report, directive);
+    if (answer) {
+      console.log(opts.json ? qaToJSON(answer) : renderQAAnswer(answer));
+      return 0;
+    }
     const v = refineInvestigation(report, directive);
     console.log(opts.json ? refinedToJSON(report, v) : renderRefined(report, v));
     if (!opts.json && report.aiJudgment) {
@@ -74665,6 +75303,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)) {
@@ -74809,6 +75461,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;
     }
   }
@@ -74916,8 +75576,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) {
@@ -74973,36 +75689,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)}`);
@@ -76078,7 +76781,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,
@@ -76090,6 +76801,9 @@ Examples:
         database: opts.database,
         collections: opts.collections,
         dashboard: opts.dashboard,
+        db: opts.db,
+        bullmqPrefix: opts.bullmqPrefix,
+        scanDbs: opts.scanDbs,
         noTest: opts.test === false
       });
     }
@@ -76170,13 +76884,14 @@ Examples:
   });
   program2.command("timeline [service]").description(
     "Reconstruct what changed in a time window (git + change-impact) \u2014 evidence, not conclusions"
-  ).option("-c, --config <path>", "path to horus.config.ts").option("--repo <name>", "repository name from config").option("--since <when>", 'git --since (e.g. "7 days ago", a date)').option("--until <when>", "git --until").option("--json", "output JSON").action(
+  ).option("-c, --config <path>", "path to horus.config.ts").option("--repo <name>", "repository name from config").option("--since <when>", 'git --since (default "7 days ago"; e.g. "30 days ago", a date)').option("--until <when>", "git --until").option("--all", "include all history instead of the default recent window").option("--json", "output JSON").action(
     async (service, opts) => {
       process.exitCode = await runTimeline(service, {
         config: opts.config,
         repo: opts.repo,
         since: opts.since,
         until: opts.until,
+        all: opts.all,
         json: opts.json
       });
     }
@@ -76274,7 +76989,7 @@ Examples:
     process.exitCode = await runScore(id, { config: opts.config, json: opts.json });
   });
   program2.command("ask <id> <directive>").description(
-    'Refine a saved investigation with a follow-up directive (e.g. "focus on queue behavior", "ignore deployment changes") \u2014 reuses evidence, no re-query'
+    'Ask about or refine a saved investigation \u2014 reuses evidence, no re-query.\n  Questions (direct answers):\n    "what evidence contradicts <topic>?"  \xB7 "what evidence is missing?"\n    "why is confidence not higher?"\n  Topic filters (deterministic scoping):\n    "focus on queue behavior" \xB7 "ignore deployment changes" \xB7 "retry"'
   ).option("-c, --config <path>", "path to horus.config.ts").option("--json", "output JSON").action(async (id, directive, opts) => {
     process.exitCode = await runAsk(id, directive, { config: opts.config, json: opts.json });
   });

package/package.json

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