@merittdev/horus 0.10.0 → 0.11.0

package/dist/index.cjs

@@ -65880,7 +65880,7 @@ init_cjs_shims();
 
 // ../../packages/core/src/version.ts
 init_cjs_shims();
-var HORUS_VERSION = true ? "0.10.0" : "dev";
+var HORUS_VERSION = true ? "0.11.0" : "dev";
 var PINNED_SOURCE_VERSION = "1.6.1";
 
 // ../../packages/core/src/evidence.ts
@@ -70251,6 +70251,22 @@ var connectorsSchema = external_exports.object({
     /** Env var holding the base URL. Defaults to "SENTRY_URL". */
     urlEnv: external_exports.string().optional()
   }).optional(),
+  /**
+   * Axiom logs connector (HOR-429). Structured log rows queried with APL become
+   * `kind: 'log'` evidence (message + level + fields), alongside Elasticsearch.
+   */
+  axiom: external_exports.object({
+    /** Dataset to query (the Axiom analogue of an ES index). */
+    dataset: external_exports.string(),
+    /** Direct API token (takes priority over tokenEnv). */
+    token: external_exports.string().optional(),
+    /** Env var holding the API token. Defaults to "AXIOM_TOKEN". */
+    tokenEnv: external_exports.string().optional(),
+    /** Direct base URL (US default https://api.axiom.co; EU https://api.eu.axiom.co). Takes priority over urlEnv. */
+    url: external_exports.string().optional(),
+    /** Env var holding the base URL. Defaults to "AXIOM_URL". */
+    urlEnv: external_exports.string().optional()
+  }).optional(),
   grafana: external_exports.object({
     dashboard: external_exports.string().optional(),
     /** Multiple dashboard UIDs to fetch. Takes precedence over `dashboard` when set. */
@@ -70469,6 +70485,16 @@ function resolveEnvironment(config2, opts) {
       ...url !== void 0 ? { url } : {}
     };
   }
+  if (c4.axiom !== void 0) {
+    const a2 = c4.axiom;
+    const token = a2.token ?? process.env[a2.tokenEnv ?? "AXIOM_TOKEN"];
+    const url = a2.url ?? process.env[a2.urlEnv ?? "AXIOM_URL"];
+    resolved.axiom = {
+      dataset: a2.dataset,
+      ...token !== void 0 ? { token } : {},
+      ...url !== void 0 ? { url } : {}
+    };
+  }
   if (c4.grafana !== void 0) {
     const g4 = c4.grafana;
     resolved.grafana = {
@@ -73724,6 +73750,296 @@ function shortTs2(iso) {
   return `${iso.slice(5, 10)} ${iso.slice(11, 16)}`;
 }
 
+// ../../packages/connectors/src/axiom/client.ts
+init_cjs_shims();
+var REQUEST_TIMEOUT_MS2 = 8e3;
+var APL_PATH = "/v1/datasets/_apl?format=tabular";
+var AxiomClient = class {
+  baseUrl;
+  token;
+  dataset;
+  constructor(opts) {
+    this.baseUrl = (opts.baseUrl ?? "https://api.axiom.co").replace(/\/$/, "");
+    this.token = opts.token;
+    this.dataset = opts.dataset;
+  }
+  async request(method, path, body2) {
+    const url = `${this.baseUrl}${path}`;
+    const init2 = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    };
+    if (body2 !== void 0) init2.body = JSON.stringify(body2);
+    const res = await fetch(url, init2);
+    if (!res.ok) {
+      const text2 = await res.text().catch(() => "");
+      throw new Error(`Axiom ${method} ${path} -> ${res.status}: ${text2.slice(0, 200)}`);
+    }
+    return res.json();
+  }
+  /**
+   * List the datasets reachable with the configured token. Returns [] on any error so
+   * callers degrade gracefully (never throws past here).
+   */
+  async listDatasets() {
+    try {
+      const raw = await this.request("GET", "/v1/datasets");
+      if (!Array.isArray(raw)) return [];
+      return raw.map(parseDataset);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Run an APL query over the configured time window. `startTime`/`endTime` are ISO
+   * strings and bound the query server-side. Returns parsed log records, or [] on any
+   * failure (never throws past here).
+   */
+  async query(apl, startTime, endTime) {
+    try {
+      const raw = await this.request("POST", APL_PATH, { apl, startTime, endTime });
+      return parseTabular(raw);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Cheap reachability probe: list datasets. Returns a structured status; never throws.
+   */
+  async health() {
+    try {
+      await this.request("GET", "/v1/datasets");
+      return { ok: true, detail: `axiom reachable (${this.dataset})` };
+    } catch (err2) {
+      return { ok: false, detail: err2.message };
+    }
+  }
+};
+function parseDataset(raw) {
+  const ds = { name: String(raw["name"] ?? "") };
+  if (typeof raw["description"] === "string" && raw["description"] !== "") {
+    ds.description = raw["description"];
+  }
+  return ds;
+}
+var AXIOM_ERROR_LEVELS = ["error", "warn", "fatal"];
+function datasetRef(dataset) {
+  return `['${dataset.replace(/'/g, "")}']`;
+}
+function searchTerms(hintTerms) {
+  return hintTerms.map((t2) => t2.trim()).filter((t2) => t2.length > 2);
+}
+function searchClause(hintTerms) {
+  const terms = searchTerms(hintTerms);
+  return terms.length > 0 ? ` | search ${terms.map((t2) => `"${t2.replace(/"/g, "")}"`).join(" or ")}` : "";
+}
+function errorLevelClause() {
+  const levels = AXIOM_ERROR_LEVELS.map((l2) => `'${l2}'`).join(", ");
+  return ` | where tolower(tostring(level)) in (${levels})`;
+}
+function buildApl(dataset, hintTerms = [], limit = 100) {
+  const lim = Math.max(1, Math.min(limit, 1e3));
+  return `${datasetRef(dataset)}${searchClause(hintTerms)} | sort by _time desc | limit ${lim}`;
+}
+function buildErrorSignatureApl(dataset, hintTerms = [], topN = 10) {
+  const lim = Math.max(1, Math.min(topN, 1e3));
+  return `${datasetRef(dataset)}${errorLevelClause()}${searchClause(hintTerms)} | summarize ['count'] = count(), ['_time'] = max(_time) by message, level | sort by ['count'] desc | limit ${lim}`;
+}
+function buildRecentErrorsApl(dataset, hintTerms = [], limit = 5) {
+  const lim = Math.max(1, Math.min(limit, 1e3));
+  return `${datasetRef(dataset)}${errorLevelClause()}${searchClause(hintTerms)} | sort by _time desc | limit ${lim}`;
+}
+function parseTabular(raw) {
+  if (raw === null || raw === void 0 || typeof raw !== "object") return [];
+  const tables = raw["tables"];
+  if (!Array.isArray(tables)) return [];
+  const records = [];
+  for (const table of tables) {
+    const fields = table["fields"];
+    if (!Array.isArray(fields)) continue;
+    const names = fields.map((f5) => String(f5["name"] ?? ""));
+    const columns = table["columns"];
+    const rows = table["rows"];
+    if (Array.isArray(columns)) {
+      const first = columns[0];
+      const rowCount = Array.isArray(first) ? first.length : 0;
+      for (let r = 0; r < rowCount; r++) {
+        const row = {};
+        for (let c4 = 0; c4 < names.length; c4++) {
+          const col = columns[c4];
+          if (Array.isArray(col)) row[names[c4]] = col[r];
+        }
+        records.push(toRecord(row));
+      }
+    } else if (Array.isArray(rows)) {
+      for (const rowVals of rows) {
+        if (!Array.isArray(rowVals)) continue;
+        const row = {};
+        for (let c4 = 0; c4 < names.length; c4++) {
+          row[names[c4]] = rowVals[c4];
+        }
+        records.push(toRecord(row));
+      }
+    }
+  }
+  return records;
+}
+function toRecord(fields) {
+  const rec = { fields };
+  const t2 = fields["_time"];
+  if (typeof t2 === "string") rec.timestamp = t2;
+  return rec;
+}
+
+// ../../packages/connectors/src/axiom/provider.ts
+init_cjs_shims();
+var DEFAULT_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var AxiomProvider = class {
+  constructor(client, opts) {
+    this.client = client;
+    this.opts = opts;
+  }
+  client;
+  opts;
+  id = "axiom";
+  kind = "logs";
+  /**
+   * Collect log rows over the window, INCIDENT-AWARE. Rather than a broad newest-first
+   * scan (which on a noisy dataset returns the 15 freshest `info` rows and misses a
+   * high-volume error storm), this runs two error-biased queries in parallel:
+   *
+   *   1. TOP ERROR SIGNATURES — `summarize count() + max(_time) by message, level` over
+   *      error/warn/fatal rows (AND the hint terms), highest-volume first. This is what
+   *      surfaces a 3k-row `level=error` signature that a newest-first scan buries.
+   *   2. RECENT RAW ERRORS — a few newest error rows with full fields, for grounding.
+   *
+   * Signatures lead so high-volume errors aren't crowded out. When NO error-level row
+   * matches (neither query returns anything) it broadens to the all-levels fallback so
+   * non-error datasets still produce evidence. Best-effort: a failing query yields [].
+   * Never throws.
+   */
+  async collect(opts = {}) {
+    const to = opts.to ?? (/* @__PURE__ */ new Date()).toISOString();
+    const from = opts.from ?? new Date(Date.parse(to) - (this.opts.windowMs ?? DEFAULT_WINDOW_MS)).toISOString();
+    const hintTerms = opts.hintTerms ?? [];
+    const limit = this.opts.limit ?? 100;
+    const topN = Math.max(1, Math.min(limit, 10));
+    const recentN = Math.max(1, Math.min(limit, 5));
+    const [signatures, recent] = await Promise.all([
+      this.client.query(buildErrorSignatureApl(this.opts.dataset, hintTerms, topN), from, to),
+      this.client.query(buildRecentErrorsApl(this.opts.dataset, hintTerms, recentN), from, to)
+    ]);
+    if (signatures.length === 0 && recent.length === 0) {
+      return this.client.query(buildApl(this.opts.dataset, hintTerms, limit), from, to);
+    }
+    return [...signatures, ...recent];
+  }
+  /**
+   * Synthesize Evidence from Axiom rows. One `kind: 'log'` Evidence per row, with the
+   * row fields on the payload (under `source: 'axiom'`), a redacted message in the
+   * title, and relevance weighted by hint-term match / recency / level.
+   */
+  toEvidence(records, hintTerms, collectedAt) {
+    const query = `axiom ${this.opts.dataset}`;
+    return records.map(
+      (rec, i3) => this.recordToEvidence(rec, hintTerms, query, collectedAt, i3)
+    );
+  }
+  /**
+   * One-shot evidence query: collect rows + convert to Evidence. Preferred entry point
+   * for the investigation engine. Degrades to [] on any failure so a flaky Axiom never
+   * aborts an investigation.
+   */
+  async queryEvidence(opts = {}) {
+    try {
+      const hintTerms = opts.hintTerms ?? [];
+      const records = await this.collect({
+        ...opts.from !== void 0 ? { from: opts.from } : {},
+        ...opts.to !== void 0 ? { to: opts.to } : {},
+        hintTerms
+      });
+      return this.toEvidence(records, hintTerms, opts.collectedAt ?? (/* @__PURE__ */ new Date()).toISOString());
+    } catch {
+      return [];
+    }
+  }
+  async health() {
+    return this.client.health();
+  }
+  recordToEvidence(rec, hintTerms, query, collectedAt, index2) {
+    const title = buildTitle2(rec, this.opts.dataset);
+    const relevance = computeRelevance2(rec, hintTerms);
+    const payload = {
+      source: "axiom",
+      dataset: this.opts.dataset,
+      ...rec.fields
+    };
+    const ev = {
+      id: `ev_axiom_${index2}`,
+      source: "logs",
+      kind: "log",
+      title,
+      relevance,
+      payload,
+      links: {},
+      provenance: { query, collectedAt }
+    };
+    if (rec.timestamp !== void 0) ev.timestamp = rec.timestamp;
+    return ev;
+  }
+};
+var MESSAGE_FIELDS = ["message", "msg", "body", "event", "log", "_raw"];
+var LEVEL_FIELDS = ["level", "severity", "lvl", "loglevel", "status"];
+function pickField2(fields, candidates) {
+  for (const key of candidates) {
+    const v4 = fields[key];
+    if (typeof v4 === "string" && v4 !== "") return v4;
+    if (typeof v4 === "number") return String(v4);
+  }
+  return void 0;
+}
+function buildTitle2(rec, dataset) {
+  const msg = pickField2(rec.fields, MESSAGE_FIELDS);
+  const level = pickField2(rec.fields, LEVEL_FIELDS);
+  const lvl = level ? `[${level}] ` : "";
+  const body2 = msg ? redactSecrets(msg) : "(log event)";
+  const rawCount = rec.fields["count"];
+  const count = typeof rawCount === "number" && Number.isFinite(rawCount) && rawCount > 1 ? rawCount : void 0;
+  if (count !== void 0) {
+    const latest = rec.timestamp ? ` (latest ${shortTs3(rec.timestamp)})` : "";
+    return `Axiom ${dataset}: ${lvl}${body2} \xD7${count.toLocaleString("en-US")}${latest}`.slice(0, 220);
+  }
+  const ts = rec.timestamp ? ` \xB7 ${shortTs3(rec.timestamp)}` : "";
+  return `Axiom ${dataset}: ${lvl}${body2}${ts}`.slice(0, 220);
+}
+function computeRelevance2(rec, hintTerms, now = Date.now()) {
+  let score = 0.6;
+  const hay = JSON.stringify(rec.fields).toLowerCase();
+  const domainTerms = hintTerms.filter((t2) => t2.length > 2);
+  if (domainTerms.some((t2) => hay.includes(t2.toLowerCase()))) score += 0.2;
+  if (rec.timestamp) {
+    const ageMs = now - Date.parse(rec.timestamp);
+    if (Number.isFinite(ageMs)) {
+      if (ageMs <= 864e5) score += 0.1;
+      else if (ageMs <= 7 * 864e5) score += 0.05;
+    }
+  }
+  const level = (pickField2(rec.fields, LEVEL_FIELDS) ?? "").toLowerCase();
+  if (level === "error" || level === "fatal" || level === "critical") score += 0.1;
+  else if (level === "warn" || level === "warning") score += 0.05;
+  const count = rec.fields["count"];
+  if (typeof count === "number" && count >= 10) score += 0.1;
+  return Math.min(0.95, Math.max(0.5, score));
+}
+function shortTs3(iso) {
+  if (!iso || iso.length < 16) return iso || "\u2014";
+  return `${iso.slice(5, 10)} ${iso.slice(11, 16)}`;
+}
+
 // ../../packages/connectors/src/bullmq/client.ts
 init_cjs_shims();
 var import_ioredis = __toESM(require_built3(), 1);
@@ -74388,6 +74704,18 @@ function sentryForEnv(renv) {
     { org: s5.org, project: s5.project }
   );
 }
+function axiomForEnv(renv) {
+  const a2 = renv.connectors.axiom;
+  if (!a2 || !a2.token || !a2.dataset) return null;
+  return new AxiomProvider(
+    new AxiomClient({
+      token: a2.token,
+      dataset: a2.dataset,
+      ...a2.url !== void 0 ? { baseUrl: a2.url } : {}
+    }),
+    { dataset: a2.dataset }
+  );
+}
 function codeForRepo(config2, repoName) {
   const renv = resolveEnvironment(config2, { project: repoName });
   const c4 = codeForEnv(renv);
@@ -74563,6 +74891,9 @@ init_cjs_shims();
 // ../../packages/connectors/src/sentry/index.ts
 init_cjs_shims();
 
+// ../../packages/connectors/src/axiom/index.ts
+init_cjs_shims();
+
 // ../../packages/connectors/src/bullmq/index.ts
 init_cjs_shims();
 
@@ -90486,6 +90817,32 @@ async function checkEnv(renv, deps) {
       `    ${mark("pending")} ${import_picocolors3.default.bold("Sentry")}          ${import_picocolors3.default.dim("not configured")}`
     );
   }
+  const axiomCfg = renv.connectors.axiom;
+  if (axiomCfg) {
+    const label = axiomCfg.dataset ?? "(no dataset)";
+    const axiom = (deps?.axiomFactory ?? axiomForEnv)(renv);
+    if (axiom) {
+      const h3 = await axiom.health();
+      if (!h3.ok) {
+        console.log(
+          `    ${mark(false)} ${import_picocolors3.default.bold("Axiom")}          ${import_picocolors3.default.dim(`unreachable \xB7 ${label}`)}`
+        );
+        allOk = false;
+      } else {
+        console.log(
+          `    ${mark(true)} ${import_picocolors3.default.bold("Axiom")}           ${import_picocolors3.default.dim(`reachable \xB7 ${label}`)}`
+        );
+      }
+    } else {
+      console.log(
+        `    ${mark(false)} ${import_picocolors3.default.bold("Axiom")}          ${import_picocolors3.default.dim(`configured (${label}) but API token not set`)}`
+      );
+    }
+  } else {
+    console.log(
+      `    ${mark("pending")} ${import_picocolors3.default.bold("Axiom")}           ${import_picocolors3.default.dim("not configured")}`
+    );
+  }
   const redisCfg = renv.connectors.redis;
   if (redisCfg?.url) {
     const server = redisServerLabel(redisCfg.url);
@@ -92915,12 +93272,15 @@ function detectMissingEvidence(r, connectors = {}, mode) {
   if (!hasLog && !sourceImpact) {
     let logWhy;
     let logNextSource;
-    if (!connectors.elasticsearch && !connectors.sentry) {
-      logWhy = "No Elasticsearch connector (nor Sentry) configured for this environment \u2014 no runtime error evidence.";
-      logNextSource = "Add an `elasticsearch` and/or `sentry` connector to the project/environment";
+    if (!connectors.elasticsearch && !connectors.sentry && !connectors.axiom) {
+      logWhy = "No Elasticsearch connector (nor Sentry / Axiom) configured for this environment \u2014 no runtime error evidence.";
+      logNextSource = "Add an `elasticsearch`, `sentry`, and/or `axiom` connector to the project/environment";
     } else if (!connectors.elasticsearch && connectors.sentry) {
       logWhy = connectors.sentryCollected ? "No open Sentry issues matched in the window \u2014 cannot confirm the actual error signatures." : "Sentry collection failed or timed out \u2014 cannot confirm the actual error signatures.";
       logNextSource = connectors.sentryCollected ? "Widen the window (--since) or check the Sentry project for open issues" : "Check the Sentry auth token / project, then retry";
+    } else if (!connectors.elasticsearch && connectors.axiom) {
+      logWhy = connectors.axiomCollected ? "No Axiom log rows matched in the window \u2014 cannot confirm the actual error signatures." : "Axiom log collection failed or timed out \u2014 cannot confirm the actual error signatures.";
+      logNextSource = connectors.axiomCollected ? "Widen the window (--since) or check the Axiom dataset for matching rows" : "Check the Axiom API token / dataset, then retry";
     } else if (connectors.logsCompatibilityError) {
       logWhy = `Elasticsearch field mapping is incompatible with the index \u2014 log collection was blocked. ` + connectors.logsCompatibilityError;
       logNextSource = "Fix fields.* overrides in your connector config or choose the correct preset (meritt / ecs)";
@@ -92931,7 +93291,7 @@ function detectMissingEvidence(r, connectors = {}, mode) {
       logWhy = "No error logs matched in the window \u2014 cannot confirm the actual error signatures.";
       logNextSource = "Widen the window (--since) or inspect `horus logs <service>`";
     }
-    const logRouteHint = !connectors.elasticsearch && !connectors.sentry ? { nextTool: "connect", args: "elasticsearch", reason: logNextSource } : { nextTool: "logs", args: service, reason: logNextSource };
+    const logRouteHint = !connectors.elasticsearch && !connectors.sentry && !connectors.axiom ? { nextTool: "connect", args: "elasticsearch", reason: logNextSource } : { nextTool: "logs", args: service, reason: logNextSource };
     gaps.push({
       dimension: "logs",
       why: logWhy,
@@ -92958,8 +93318,10 @@ function detectMissingEvidence(r, connectors = {}, mode) {
   if (hasQueueTopology && !hasQueueState && !sourceImpact) {
     gaps.push({
       dimension: "queue runtime state",
-      why: connectors.redis ? "Queue topology is known but live depth + failed/delayed counts were not collected." : "Queue topology is known but there is no Redis/BullMQ connector for live depth/failures.",
-      nextSource: connectors.redis ? "Run `horus queues --live` to see real-time queue depths and failed-job counts" : "Add a `redis` connector to read live BullMQ state",
+      why: connectors.redis ? "Queue topology is known but live depth + failed/delayed counts were not collected." : "Queue topology is known but there is no Redis connector for live queue depth/failures.",
+      // Stack-agnostic: the tip names Redis (the connector to add) but NOT a specific queue
+      // library — "BullMQ" is Node-only and was leaking onto Python/Redis repos (HOR-428).
+      nextSource: connectors.redis ? "Run `horus queues --live` to see real-time queue depths and failed-job counts" : "Add a `redis` connector to read live queue state",
       confidenceImpact: 0.1,
       // Redis wired → read live state with `queues --live`; otherwise `connect redis` first.
       routeHint: connectors.redis ? {
@@ -92969,7 +93331,7 @@ function detectMissingEvidence(r, connectors = {}, mode) {
       } : {
         nextTool: "connect",
         args: "redis",
-        reason: "Add a `redis` connector to read live BullMQ state"
+        reason: "Add a `redis` connector to read live queue state"
       }
     });
     blindSpots.push("Cannot determine if the queue is actually backed up.");
@@ -93047,10 +93409,11 @@ function buildEntry(source, configured, evidenceCount, failed, detail) {
 }
 function buildRuntimeSourceStatus(evidence2, connectors) {
   const logsCount = evidence2.filter((e) => e.source === "logs").length;
-  const logsConfigured = !!(connectors.elasticsearch || connectors.sentry);
+  const logsConfigured = !!(connectors.elasticsearch || connectors.sentry || connectors.axiom);
   const esFailed = !!connectors.elasticsearch && !connectors.logsCollected;
   const sentryFailed = !!connectors.sentry && !connectors.sentryCollected;
-  const logsFailed = logsConfigured && logsCount === 0 && (esFailed || sentryFailed);
+  const axiomFailed = !!connectors.axiom && !connectors.axiomCollected;
+  const logsFailed = logsConfigured && logsCount === 0 && (esFailed || sentryFailed || axiomFailed);
   const metricsCount = evidence2.filter((e) => e.source === "metrics").length;
   const metricsConfigured = !!connectors.grafana;
   const metricsFailed = metricsConfigured && !connectors.metricsCollected;
@@ -94016,6 +94379,17 @@ function classifyLogRelevance(sigKey, sigServices, seedTerms, inputService) {
     relevanceReason: "no structural link to seed \u2014 ambient runtime noise"
   };
 }
+var AXIOM_MESSAGE_FIELDS = ["message", "msg", "body", "event", "log", "_raw"];
+var AXIOM_LEVEL_FIELDS = ["level", "severity", "lvl", "loglevel", "status"];
+var AXIOM_SERVICE_FIELDS = ["service", "app", "logger", "source", "namespace"];
+function pickAxiomField(fields, candidates) {
+  for (const key of candidates) {
+    const v4 = fields[key];
+    if (typeof v4 === "string" && v4 !== "") return v4;
+    if (typeof v4 === "number") return String(v4);
+  }
+  return void 0;
+}
 function extractEventCodes(...texts) {
   const RE = /\b(?=[A-Z0-9_]*[0-9_])[A-Z][A-Z0-9_]{3,}\b/g;
   const out2 = [];
@@ -94965,6 +95339,61 @@ async function investigate(input, deps) {
       sentryCollected = false;
     }
   }
+  let axiomCollected = false;
+  if (deps.axiom) {
+    try {
+      const from = logWindowFrom(input.logsSince ?? input.since);
+      const to = (/* @__PURE__ */ new Date()).toISOString();
+      const axiomSeedBase = top ? top.filePath.split("/").pop() ?? "" : "";
+      const axiomTerms = top ? [.../* @__PURE__ */ new Set([...tokenize(hint), ...tokenize(top.name), ...tokenize(axiomSeedBase)])] : [...new Set(tokenize(hint))];
+      const records = await deps.axiom.collect({ from, to, hintTerms: axiomTerms });
+      axiomCollected = true;
+      for (const rec of records.slice(0, 15)) {
+        const msg = pickAxiomField(rec.fields, AXIOM_MESSAGE_FIELDS);
+        const level = pickAxiomField(rec.fields, AXIOM_LEVEL_FIELDS);
+        const svc = pickAxiomField(rec.fields, AXIOM_SERVICE_FIELDS) ?? "";
+        const sigKey = [msg ?? "", svc].filter(Boolean).join(" ");
+        const { relevanceClass, relevanceReason } = classifyLogRelevance(
+          sigKey,
+          svc ? [svc] : [],
+          axiomTerms,
+          input.service
+        );
+        const lvl = level ? `[${level}] ` : "";
+        const body2 = msg ?? "(log event)";
+        const tag = relevanceClass === "ambient" ? " [ambient]" : "";
+        const title = `Axiom log: ${lvl}${body2}${tag}`.slice(0, 220);
+        const isError = ["error", "fatal", "critical"].includes((level ?? "").toLowerCase());
+        const ev = mkEv(
+          "log",
+          title,
+          {
+            source: "axiom",
+            signature: msg ?? null,
+            level: level ?? null,
+            service: svc || null,
+            relevanceClass,
+            relevanceReason,
+            fields: rec.fields
+          },
+          {},
+          rec.timestamp,
+          // Direct: weighted up for error-level rows. Ambient: demoted so unrelated
+          // high-volume log lines don't inflate confidence.
+          relevanceClass === "direct" ? isError ? 0.9 : 0.75 : 0.4
+        );
+        logEvIds.push(ev.id);
+        if (relevanceClass === "direct") {
+          directLogEvIds.push(ev.id);
+          directSignatures.push({ key: msg ?? "(log event)", count: 1, message: msg ?? "" });
+        } else {
+          ambientLogEvIds.push(ev.id);
+        }
+      }
+    } catch {
+      axiomCollected = false;
+    }
+  }
   let stateAnalysis = null;
   const stateEvIds = [];
   const stateCollections = /* @__PURE__ */ new Set();
@@ -95725,6 +96154,10 @@ async function investigate(input, deps) {
     // its collection ran (distinguishes "no open issues" from "collection failed").
     sentry: deps.sentry != null,
     sentryCollected,
+    // Axiom is configured iff a provider was built; axiomCollected tracks whether its
+    // collection ran (distinguishes "no matching rows" from "collection failed").
+    axiom: deps.axiom != null,
+    axiomCollected,
     metricsCollected,
     metricsFailureReason,
     logsCollected,
@@ -95736,6 +96169,8 @@ async function investigate(input, deps) {
     postgres: deps.postgres != null,
     sentry: deps.sentry != null,
     sentryCollected,
+    axiom: deps.axiom != null,
+    axiomCollected,
     grafana: deps.metrics != null,
     queue: deps.queue != null,
     metricsCollected,
@@ -114838,6 +115273,7 @@ async function buildInvestigationContext(renv, opts) {
   const mongo = mongoForEnv(renv);
   const postgres2 = postgresForEnv(renv);
   const sentry = sentryForEnv(renv);
+  const axiom = axiomForEnv(renv);
   const queue = queueForEnv(renv);
   const redisState = redisStateForEnv(renv);
   const metrics = metricsForEnv(renv);
@@ -114854,6 +115290,7 @@ async function buildInvestigationContext(renv, opts) {
     mongo,
     postgres: postgres2,
     sentry,
+    axiom,
     queue,
     redisState,
     metrics,
@@ -114882,6 +115319,7 @@ async function runOneInvestigation(input, ctx, opts = {}) {
       mongo: ctx.mongo,
       postgres: ctx.postgres,
       sentry: ctx.sentry,
+      axiom: ctx.axiom,
       queue: ctx.queue,
       redisState: ctx.redisState,
       metrics: ctx.metrics,
@@ -114892,6 +115330,7 @@ async function runOneInvestigation(input, ctx, opts = {}) {
         mongodb: !!renv.connectors.mongodb?.url,
         postgres: !!renv.connectors.postgres?.url,
         sentry: !!renv.connectors.sentry,
+        axiom: !!renv.connectors.axiom,
         redis: !!renv.connectors.redis?.url,
         queue: !!ctx.queue
       }
@@ -117828,6 +118267,8 @@ function outcomeLabelToJSON(l2) {
     at: l2.at instanceof Date ? l2.at.toISOString() : l2.at
   };
 }
+var DEFAULT_ACCURACY_WINDOW_DAYS = 30;
+var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
 async function runMemoryAccuracy(opts) {
   try {
     let source;
@@ -117839,12 +118280,29 @@ async function runMemoryAccuracy(opts) {
       source = opts.source;
     }
     let since;
-    if (opts.days !== void 0) {
+    let window2;
+    if (opts.all) {
+      window2 = "all time";
+    } else if (opts.since !== void 0) {
+      const parsed = new Date(opts.since);
+      if (Number.isNaN(parsed.getTime())) {
+        console.error(
+          import_picocolors31.default.red("--since must be a parseable date (e.g. 2026-06-01 or an ISO timestamp).")
+        );
+        return 1;
+      }
+      since = parsed;
+      window2 = `since ${parsed.toISOString().slice(0, 10)}`;
+    } else if (opts.days !== void 0) {
       if (!Number.isFinite(opts.days) || opts.days <= 0) {
         console.error(import_picocolors31.default.red("--days must be a positive number."));
         return 1;
       }
-      since = new Date(Date.now() - opts.days * 24 * 60 * 60 * 1e3);
+      since = new Date(Date.now() - opts.days * MS_PER_DAY2);
+      window2 = `last ${opts.days} day(s)`;
+    } else {
+      since = new Date(Date.now() - DEFAULT_ACCURACY_WINDOW_DAYS * MS_PER_DAY2);
+      window2 = `last ${DEFAULT_ACCURACY_WINDOW_DAYS} day(s) (default \u2014 pass --all for full history)`;
     }
     const config2 = await loadConfig(opts.config);
     const project = resolveProject(config2, opts.repo);
@@ -117865,6 +118323,7 @@ async function runMemoryAccuracy(opts) {
               project,
               source: source ?? null,
               since: since ? since.toISOString() : null,
+              window: window2,
               summary,
               labels: labels.map(outcomeLabelToJSON)
             },
@@ -117874,11 +118333,11 @@ async function runMemoryAccuracy(opts) {
         );
       } else {
         const pct = (n4) => `${(n4 * 100).toFixed(0)}%`;
-        console.log(import_picocolors31.default.bold(`Investigation accuracy \u2014 ${project}`));
+        console.log(import_picocolors31.default.bold(`Investigation accuracy \u2014 ${project}`) + import_picocolors31.default.dim(`  \xB7  window: ${window2}`));
         if (summary.evaluated === 0) {
           console.log(
             import_picocolors31.default.dim(
-              "No outcome labels yet. Confirm an investigation (`horus memory confirm <id>`) or leave feedback (`horus feedback <id> --resolved yes|partly|no`) to start the eval set."
+              `No outcome labels in this window (${window2}). Confirm an investigation (\`horus memory confirm <id>\`) or leave feedback (\`horus feedback <id> --resolved yes|partly|no\`) to add to the eval set` + (opts.all ? "." : ", or pass --all to include older labels.")
             )
           );
         } else {
@@ -119060,6 +119519,148 @@ async function checkboxSearch(opts) {
     render();
   });
 }
+async function selectSearch(opts) {
+  const { message, choices } = opts;
+  const pageSize = opts.pageSize ?? 10;
+  const input = opts.input ?? process.stdin;
+  const output = opts.output ?? process.stdout;
+  if (!isInteractive(input)) {
+    throw new Error("selectSearch requires an interactive TTY");
+  }
+  if (choices.length === 0) {
+    throw new ExitPromptError("No choices to select from");
+  }
+  return new Promise((resolve12, reject) => {
+    let filter = "";
+    let cursor = 0;
+    let filtered = choices;
+    let visibleOffset = 0;
+    let lastRenderLines = 0;
+    const wasRaw = input.isRaw;
+    function updateFiltered() {
+      const f5 = filter.toLowerCase();
+      filtered = f5 ? choices.filter((c4) => c4.toLowerCase().includes(f5)) : choices;
+      cursor = Math.min(cursor, Math.max(0, filtered.length - 1));
+      updateVisibleOffset();
+    }
+    function updateVisibleOffset() {
+      if (cursor < visibleOffset) {
+        visibleOffset = cursor;
+      } else if (cursor >= visibleOffset + pageSize) {
+        visibleOffset = cursor - pageSize + 1;
+      }
+      const maxOffset = Math.max(0, filtered.length - pageSize);
+      visibleOffset = Math.max(0, Math.min(visibleOffset, maxOffset));
+    }
+    function clear() {
+      output.write("\x1B[?25l");
+      if (lastRenderLines > 0) {
+        output.write(`\x1B[${lastRenderLines}A`);
+        output.write("\x1B[0J");
+      }
+    }
+    function render() {
+      clear();
+      const lines = [];
+      lines.push(
+        `? ${import_picocolors39.default.bold(message)} ${import_picocolors39.default.dim("(\u2191\u2193 navigate \u2022 enter confirm \u2022 type filter)")}`
+      );
+      const visible = filtered.slice(visibleOffset, visibleOffset + pageSize);
+      for (let i3 = 0; i3 < visible.length; i3++) {
+        const idx = visibleOffset + i3;
+        const choice = visible[i3];
+        const isCursor = idx === cursor;
+        const pointer = isCursor ? import_picocolors39.default.cyan("\u276F") : " ";
+        const label = isCursor ? import_picocolors39.default.cyan(choice) : choice;
+        lines.push(`  ${pointer} ${label}`);
+      }
+      if (filtered.length === 0) {
+        lines.push(import_picocolors39.default.dim("  No matches"));
+      }
+      const statusParts = [`${filtered.length}/${choices.length} matches`];
+      if (filter) statusParts.push(`filter: ${filter}`);
+      lines.push(import_picocolors39.default.dim(`  ${statusParts.join(" \xB7 ")}`));
+      output.write(lines.join("\n"));
+      lastRenderLines = lines.length;
+    }
+    function finish(value) {
+      cleanup();
+      output.write(`
+? ${import_picocolors39.default.bold(message)} ${value}
+`);
+      resolve12(value);
+    }
+    function cancel() {
+      cleanup();
+      reject(new ExitPromptError());
+    }
+    function cleanup() {
+      input.setRawMode(wasRaw);
+      input.pause();
+      input.removeListener("data", onData);
+      output.write("\x1B[?25h");
+    }
+    function onData(chunk) {
+      const s5 = chunk.toString();
+      if (s5 === "") {
+        cancel();
+        return;
+      }
+      if (s5 === "\x1B") {
+        if (filter) {
+          filter = "";
+          cursor = 0;
+          updateFiltered();
+        } else {
+          cancel();
+        }
+        render();
+        return;
+      }
+      if (s5 === "\r" || s5 === "\n") {
+        const choice = filtered[cursor];
+        if (choice !== void 0) finish(choice);
+        return;
+      }
+      if (s5 === "\x7F" || s5 === "\b") {
+        if (filter.length > 0) {
+          filter = filter.slice(0, -1);
+          cursor = 0;
+          updateFiltered();
+        }
+        render();
+        return;
+      }
+      if (s5 === "\x1B[A") {
+        if (cursor > 0) {
+          cursor -= 1;
+          updateVisibleOffset();
+        }
+        render();
+        return;
+      }
+      if (s5 === "\x1B[B") {
+        if (cursor < filtered.length - 1) {
+          cursor += 1;
+          updateVisibleOffset();
+        }
+        render();
+        return;
+      }
+      if (s5.length === 1 && s5.charCodeAt(0) >= 32 && s5.charCodeAt(0) <= 126) {
+        filter += s5;
+        cursor = 0;
+        updateFiltered();
+        render();
+      }
+    }
+    input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+    updateFiltered();
+    render();
+  });
+}
 
 // ../../packages/cli/src/commands/connect-ai.ts
 init_cjs_shims();
@@ -119197,7 +119798,7 @@ function parseDbSpec(spec) {
   }
   return { db, roles };
 }
-var SUPPORTED = ["elasticsearch", "mongodb", "postgres", "sentry", "grafana", "redis"];
+var SUPPORTED = ["elasticsearch", "mongodb", "postgres", "sentry", "axiom", "grafana", "redis"];
 async function runConnect(type, opts) {
   if (type === "ai") {
     return runConnectAi({
@@ -119234,6 +119835,9 @@ async function runConnect(type, opts) {
       case "sentry":
         patch = buildSentryPatch(filled);
         break;
+      case "axiom":
+        patch = buildAxiomPatch(filled);
+        break;
       case "grafana":
         patch = buildGrafanaPatch(filled);
         break;
@@ -119255,7 +119859,7 @@ ${import_picocolors41.default.red(`\u2717 Could not reach ${connectorType}:`)} $
 ${import_picocolors41.default.green("\u2713")} ${connectorType} reachable ${import_picocolors41.default.dim(`(${probeResult.detail})`)}`
       );
     }
-    const hasLiteralCredentials = filled.url !== void 0 || filled.password !== void 0 || filled.username !== void 0 || filled.authToken !== void 0;
+    const hasLiteralCredentials = filled.url !== void 0 || filled.password !== void 0 || filled.username !== void 0 || filled.authToken !== void 0 || filled.token !== void 0;
     if (hasLiteralCredentials) {
       if (isGitTracked(configPath, root)) {
         console.error(
@@ -119332,6 +119936,35 @@ ${import_picocolors41.default.bold(`Connect ${type}`)} ${import_picocolors41.def
       filled.authToken = filled.authToken ?? (await askPassword("Auth token") || void 0);
       filled.url = filled.url ?? (await ask("Base URL (self-hosted)", "https://sentry.io", false) || void 0);
       break;
+    case "axiom": {
+      filled.token = filled.token ?? (await askPassword("Axiom API token") || void 0);
+      if (filled.url === void 0) {
+        filled.url = await askAxiomRegion();
+      }
+      if (filled.dataset === void 0) {
+        const baseUrl = filled.url ?? "https://api.axiom.co";
+        let names = [];
+        if (filled.token) {
+          const client = new AxiomClient({ token: filled.token, dataset: "", baseUrl });
+          names = (await client.listDatasets()).map((d3) => d3.name).filter(Boolean);
+        }
+        if (names.length > 0) {
+          const picked = await askDatasetSelection(names);
+          if (picked) filled.dataset = picked;
+        }
+        if (filled.dataset === void 0) {
+          if (names.length === 0) {
+            console.log(
+              import_picocolors41.default.yellow(
+                "  Couldn't list datasets (check token / network / region) \u2014 enter the name manually."
+              )
+            );
+          }
+          filled.dataset = await ask("Dataset name", "logs");
+        }
+      }
+      break;
+    }
     case "grafana":
       filled.url = filled.url ?? await ask("URL", "https://grafana.example.com");
       filled.username = filled.username ?? (await ask("Username", "", false) || void 0);
@@ -119389,6 +120022,8 @@ function missingRequired(type, opts) {
       return !opts.url;
     case "sentry":
       return !opts.org || !opts.project || !opts.authToken;
+    case "axiom":
+      return !opts.dataset || !opts.token;
     case "grafana":
       return !opts.url;
     case "redis":
@@ -119487,6 +120122,13 @@ function buildSentryPatch(opts) {
   if (opts.url && opts.url.replace(/\/$/, "") !== "https://sentry.io") patch["url"] = opts.url;
   return patch;
 }
+function buildAxiomPatch(opts) {
+  if (!opts.dataset) throw new Error("Dataset is required for axiom");
+  const patch = { dataset: opts.dataset };
+  if (opts.token) patch["token"] = opts.token;
+  if (opts.url && opts.url.replace(/\/$/, "") !== "https://api.axiom.co") patch["url"] = opts.url;
+  return patch;
+}
 function buildGrafanaPatch(opts) {
   const patch = {};
   if (opts.url) patch["url"] = opts.url;
@@ -119622,6 +120264,17 @@ async function probe(type, opts) {
         });
         return client.health();
       }
+      case "axiom": {
+        if (!opts.token || !opts.dataset) {
+          return { ok: true, detail: "skipped (missing dataset/token)" };
+        }
+        const client = new AxiomClient({
+          token: opts.token,
+          dataset: opts.dataset,
+          ...opts.url ? { baseUrl: opts.url } : {}
+        });
+        return client.health();
+      }
       case "grafana": {
         if (!opts.url) return { ok: true, detail: "skipped (no URL)" };
         const headers = { "Content-Type": "application/json" };
@@ -119673,8 +120326,11 @@ function printSummary(type, opts) {
   if (opts.collections) lines.push(`  collections:    ${opts.collections}`);
   if (opts.org) lines.push(`  org:            ${opts.org}`);
   if (opts.project) lines.push(`  project:        ${opts.project}`);
+  if (opts.dataset) lines.push(`  dataset:        ${opts.dataset}`);
   if (opts.authToken)
     lines.push(`  auth-token:     ${"\u2022".repeat(Math.min(opts.authToken.length, 8))}`);
+  if (opts.token)
+    lines.push(`  token:          ${"\u2022".repeat(Math.min(opts.token.length, 8))}`);
   if (opts.dashboardUids && opts.dashboardUids.length > 0) {
     lines.push(`  dashboards:     ${opts.dashboardUids.join(", ")}`);
   } else if (opts.dashboard) {
@@ -119785,6 +120441,63 @@ async function askDashboardSelection(dashboards) {
   }
   return [];
 }
+async function askAxiomRegion() {
+  const US = "US \u2014 api.axiom.co";
+  const EU = "EU \u2014 api.eu.axiom.co";
+  const CUSTOM = "Custom URL\u2026";
+  const US_URL = "https://api.axiom.co";
+  const EU_URL = "https://api.eu.axiom.co";
+  let choice = US;
+  if (isInteractive()) {
+    try {
+      choice = await selectSearch({
+        message: "Axiom server / region",
+        choices: [US, EU, CUSTOM],
+        pageSize: 3
+      });
+    } catch (err2) {
+      if (err2 instanceof ExitPromptError) throw err2;
+      return US_URL;
+    }
+  } else {
+    return US_URL;
+  }
+  if (choice === EU) return EU_URL;
+  if (choice === CUSTOM) {
+    return await ask("Custom Axiom base URL", US_URL) || US_URL;
+  }
+  return US_URL;
+}
+async function askDatasetSelection(names) {
+  if (names.length === 0) return void 0;
+  if (isInteractive()) {
+    try {
+      return await selectSearch({
+        message: "Select an Axiom dataset",
+        choices: names,
+        pageSize: 12
+      });
+    } catch (err2) {
+      if (err2 instanceof ExitPromptError) throw err2;
+    }
+  }
+  const MAX_DISPLAY = 25;
+  const shown = names.slice(0, MAX_DISPLAY);
+  console.log("\n  Available Axiom datasets:");
+  shown.forEach((name2, i3) => {
+    console.log(`  ${import_picocolors41.default.dim(`[${i3 + 1}]`)} ${name2}`);
+  });
+  if (names.length > MAX_DISPLAY) {
+    console.log(import_picocolors41.default.dim(`  \u2026 and ${names.length - MAX_DISPLAY} more`));
+  }
+  const input = (await ask("  Select a dataset (e.g. 1 or Enter to type a name manually)", "", false)).trim();
+  if (!input) return void 0;
+  if (/^\d+$/.test(input)) {
+    const idx = parseInt(input, 10) - 1;
+    if (idx >= 0 && idx < shown.length) return shown[idx];
+  }
+  return input;
+}
 function redisUrlHasPassword(raw) {
   if (!raw) return false;
   try {
@@ -120879,6 +121592,7 @@ async function runReadiness(opts) {
     let anyMongo = false;
     let anyPostgres = false;
     let anySentry = false;
+    let anyAxiom = false;
     let anyRedis = false;
     for (const project of globalConfig2.projects) {
       for (const repo of project.repositories) {
@@ -120891,6 +121605,7 @@ async function runReadiness(opts) {
         if (c4.mongodb) anyMongo = true;
         if (c4.postgres) anyPostgres = true;
         if (c4.sentry) anySentry = true;
+        if (c4.axiom) anyAxiom = true;
         if (c4.redis) anyRedis = true;
       }
     }
@@ -120948,6 +121663,15 @@ async function runReadiness(opts) {
         next: "run `horus connect sentry`"
       }
     );
+    checks.push(
+      anyAxiom ? { label: "Axiom", status: "pass", blocking: false, detail: "configured" } : {
+        label: "Axiom",
+        status: "warn",
+        blocking: false,
+        detail: "not configured \u2014 no runtime log evidence",
+        next: "run `horus connect axiom`"
+      }
+    );
     checks.push(
       anyRedis ? { label: "Redis", status: "pass", blocking: false, detail: "configured" } : {
         label: "Redis",
@@ -122675,8 +123399,8 @@ Examples:
     process.exitCode = await runReadiness({ config: opts.config, ai: opts.ai, aiModel: opts.aiModel });
   });
   program2.command("connect <type>").description(
-    "Add or update a connector (elasticsearch / mongodb / postgres / sentry / grafana / redis / ai) in .horus/config.json"
-  ).option("--env <name>", "target environment (default: first environment in config)").option("--provider <name>", "AI provider for `connect ai` (anthropic / claude / codex / gemini)").option("--api-key <key>", "Anthropic API key for `connect ai`").option("--model <id>", "default model for `connect ai`").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("--schema <name>", "schema to introspect (postgres; default public)").option("--tables <list>", "comma-separated table allowlist (postgres)").option("--auth-token <token>", "Sentry API auth token (required for sentry)").option("--org <slug>", "Sentry org slug (required for sentry)").option("--project <slug>", "Sentry project slug (required for sentry)").option("--dashboard <uid>", "default dashboard uid (grafana)").option(
+    "Add or update a connector (elasticsearch / mongodb / postgres / sentry / axiom / grafana / redis / ai) in .horus/config.json"
+  ).option("--env <name>", "target environment (default: first environment in config)").option("--provider <name>", "AI provider for `connect ai` (anthropic / claude / codex / gemini)").option("--api-key <key>", "Anthropic API key for `connect ai`").option("--model <id>", "default model for `connect ai`").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("--schema <name>", "schema to introspect (postgres; default public)").option("--tables <list>", "comma-separated table allowlist (postgres)").option("--auth-token <token>", "Sentry API auth token (required for sentry)").option("--org <slug>", "Sentry org slug (required for sentry)").option("--project <slug>", "Sentry project slug (required for sentry)").option("--token <token>", "Axiom API token (required for axiom)").option("--dataset <name>", "Axiom dataset to query (required for axiom)").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) => {
@@ -122700,6 +123424,8 @@ Examples:
         authToken: opts.authToken,
         org: opts.org,
         project: opts.project,
+        token: opts.token,
+        dataset: opts.dataset,
         dashboard: opts.dashboard,
         db: opts.db,
         bullmqPrefix: opts.bullmqPrefix,
@@ -122814,7 +123540,7 @@ Examples:
       process.exitCode = await runMemoryDetect(opts);
     }
   );
-  memory.command("accuracy").description("Report Horus's measured hit-rate from the converged outcome-label eval set").option("-c, --config <path>", "path to horus.config.ts").option("--repo <name>", "project/repository to scope to (default: inferred from cwd)").option("--source <source>", "filter to one signal source: feedback | confirm").option("--days <n>", "only count labels from the last N days", (v4) => Number(v4)).option("--limit <n>", "max labels to scan", (v4) => Number(v4)).option("--json", "output JSON").action(
+  memory.command("accuracy").description("Report Horus's measured hit-rate from the converged outcome-label eval set").option("-c, --config <path>", "path to horus.config.ts").option("--repo <name>", "project/repository to scope to (default: inferred from cwd)").option("--source <source>", "filter to one signal source: feedback | confirm").option("--since <date>", "only count labels on/after this date (e.g. 2026-06-01)").option("--days <n>", "only count labels from the last N days", (v4) => Number(v4)).option("--all", "count the full retained history (disable the default recent window)").option("--limit <n>", "max labels to scan", (v4) => Number(v4)).option("--json", "output JSON").action(
     async (opts) => {
       process.exitCode = await runMemoryAccuracy(opts);
     }

package/package.json

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