Horus

Changelog

What's new in Horus

Release history for the Horus CLI and its paired horus-source backend. Latest: CLI 0.22.0 paired with horus-source 0.22.0.

  • 0.22.02026-08-02horus-source 0.22.0

    Trace the shortest path through your codebase and inspect its graph

    • horus trace <from> <to> finds the shortest relationship path between two symbols across calls, imports, inheritance, implementations, and type usage. It walks both directions, supports --max-depth and --relations, shows every hop with source locations and confidence, and provides structured --json output for agents and scripts.
    • horus insights surfaces the codebase's most-connected symbols, cross-community bridges, and grounded follow-up questions from the canonical source graph. Tune the result with --hubs and --bridges or consume the same data as JSON.
    • Graph-aware log reconciliation connects Elasticsearch evidence back to indexed source paths through matching CLI, HTTP, MCP, and Horus Cloud surfaces. SQLite is the canonical local graph backend; the legacy Kuzu path does not gate the new analytics.
  • 0.21.92026-07-13

    Work the Lens backlog directly — client-reported issues as a queue, not just evidence

    • horus lens — the client-report work queue. horus investigate already folds Lens reports in as incident evidence; now horus lens lists every bug report your users filed, newest first, so an agent (or you) can work the backlog straight through. horus lens show <id> opens one in full — comment, route, release/git SHA, failing requests, and the code seed (file:line — the raising frame to fix), resolved with the same machinery an investigation uses. Filter with --status / --since / --limit, add --json for agents. Reports merge across all Lens sites in the workspace.
    • Exposed to agents over MCP. Two new MCP tools — list_lens_reports and get_lens_report — let a coding agent pull the backlog and jump to each report's raise site without leaving its editor. These are the first cloud-backed MCP tools; the existing local knowledge tools are unchanged.
    • Native, same as the connector. No horus connect, no config: horus lens lights up when you're logged in (horus login) and the repo is cloud-linked (horus cloud link), and degrades to a one-line remedy (with valid JSON under --json) otherwise. Read-only; comments and errors are secret-redacted and reporter identity is never read.
  • 0.21.82026-07-11

    Lens reports feed investigations — user-filed bugs become evidence, zero setup

    • Every bug report your users file through Lens (comment, captured frontend errors, failing network calls, route, release/git SHA) now folds into horus investigate as first-class evidence. A report's top stack frame is a direct code seed — same machinery as Sentry's — so a user-reported error lands the investigation on the raising code, and the report's comment matches the hint like an error signature. Reports are scoped to the incident window and relevance-classified: a report about an unrelated page is demoted to ambient and never inflates confidence.
    • Zero configuration — it's native. There is no horus connect lens and no config stanza: the connector lights up automatically when you're logged into Horus Cloud (horus login) and the repo is cloud-linked (horus cloud link). Not logged in? It silently stays out of the way. Privacy holds the usual line: comments and error messages are secret-redacted, reporter identity is never read, and console bodies never leave the cloud.
  • 0.21.72026-07-04

    Shared team memory — promote a decision once, teammates pull it (vectors stay local)

    • horus memory promote <id> and horus memory pull. A memory item you've captured — a decision, a pitfall, a convention — can be promoted to your team once. It becomes a cloud-owned team item, and teammates pull it into their local cache. Pulled items show who promoted them and keep their confidence, so recall ranks them honestly (attribution never inflates rank). The local store is a disposable read-cache: the cloud is the source of truth for shared items (server wins — a re-promote is an idempotent no-op, no way to silently un-share), and pull refreshes the cache for the repo you run it in. Requires a repo linked to Horus Cloud (horus login + horus cloud link).
    • Your embeddings never leave the device. Promotion sends only the claim text and metadata — never a vector. Pulled team items are re-embedded locally into your own semantic index. Confirmed-outcome memories are refused from promotion (they stay private), enforced on both the client and the server.
  • 0.21.62026-07-04horus-source 0.21.6

    Blast radius understands inheritance, embeddings resume, re-exports resolve across files

    • Blast radius now follows inheritance. Changing a base class or interface surfaces everything that extends or implements it, not just its direct callers — the relationships were already indexed, but the impact walk never traversed them, so a base type reported a near-empty radius. typebox blast-radius TSchema now reports 36 affected symbols (TString, TInteger, TAny, … and their callers) where it used to show ~0. Takes effect after your next horus init (or --reindex); an older index says so with a one-line hint, and horus update refreshes it in the background.
    • Interrupted embeddings resume instead of restarting. The semantic-index pass used to be all-or-nothing: kill it partway and it had persisted nothing, so the next run recomputed every vector. Vectors now persist incrementally and a resume computes only the missing ones — measured on typebox, killed after 768 of 4,763 vectors, the resume computed exactly the remaining 3,995. (Switching embedding models still recomputes everything — those vectors live in a different space.)
    • Re-exports under a new name resolve to the implementation, across files. export { BaseComponent as Component } from './component' — a rename re-exported from another module — now redirects to the real code: preact explain Component lands on BaseComponent in src/component.js (with its actual callers and impact) instead of the src/index.d.ts type declaration. Completes the .d.ts-demotion work from 0.21.5 for the cross-module case. Lights up after your next horus init.
  • 0.21.52026-07-04

    Implementations win over their .d.ts type declarations

    • When a symbol exists both as real code and as a .d.ts re-declaration, explain / search / blast-radius now land on the implementation instead of the declaration stub — dayjs Dayjs resolves to the class in src/index.js (not a plugin .d.ts), commander Option to lib/option.js (not typings/index.d.ts). A .d.ts only wins when it is the sole match (a genuinely type-only export). Takes effect immediately, no re-index needed.
  • 0.21.42026-07-04

    The resolver finds a library's real API even when the export has no name

    • Anonymous & default exports now resolve to the implementation, not a test file. When a package's public API has no named symbol — module.exports = function (jsonwebtoken's sign, winston's createLogger), module.exports = class Application (koa), module.exports = X.extend({}) (joi), a cast/satisfies-wrapped const arrow (Vue's createApp, zustand's createStore), or a prototype method (preact's BaseComponent.prototype.render) — Horus synthesizes a resolvable named symbol at index time. explain / search / blast-radius land on the real code (e.g. sign.js) instead of a same-named test helper that used to win by default, and cross-command answers agree (joi's explain object and blast-radius object now resolve to the same symbol). Re-exports under a different name (export { X as Y }) record an alias edge so a lookup on the public name redirects to the implementation. These light up after your next horus init (or --reindex).
  • 0.21.32026-07-04

    Init durability — large monorepos onboard

    • horus init no longer times out on large repos. It used to block on the full embedding pass, so big monorepos hit the analyze cap and left nothing usable. Init now returns as soon as the structural index is built (symbols + relationships) and embeddings warm in the background — medusa (22,966 files) onboards in 40s and vendure in ~22s, both of which previously timed out with no config written. search, explain, blast-radius, and queues all work immediately; init tells you "index ready (semantic search warming up)" while semantic ranking sharpens.
    • Honest progress + adaptive timeout. Long indexing runs stream phase/files/elapsed liveness instead of looking hung, and the analyze timeout scales with repo size (overridable via HORUS_ANALYZE_TIMEOUT_MS). A structural-complete index whose embeddings are still warming is no longer mistaken for a broken index and needlessly re-analyzed.
    • No more false "dead code" from same-file calls. A cross-language call-blocklist was dropping real same-file/imported calls in other languages, so a live function like prettier's format reported isDead:true with zero callers — a verdict you could act on by deleting working code. The blocklist now never drops a call that resolves to a same-file or imported definition.
  • 0.21.22026-07-04

    Zero-infrastructure local persistence + the dogfood fix batch

    • Zero-infrastructure local persistence. Your investigation history now lives in an embedded database at `~/.horus` — there is nothing to install, start, or `docker compose up`. The local-Postgres tier is gone: the bundled `docker-compose.yml`, the `DATABASE_URL` runtime setting, and the `database` config block are all removed (the block still parses, now with a deprecation warning). Migrating from an older local-Postgres setup is one command — `horus db import`, which defaults to `$DATABASE_URL`. Teams that want shared, multi-user state use Horus Cloud.
    • Single-file installs no longer crash. `horus blast-radius` and `horus queues` degrade gracefully when a slim build can't reach an optional asset instead of aborting, and `install.sh` now ships the embedded-database assets, so a curl install has working persistence out of the box.
    • A stricter machine-JSON contract for agents. A `--json` command that fails now always prints exactly one parseable JSON error object — never a stack trace or a half-written document. `horus search --json` returns `{ "results": [...] }` instead of a bare array; `horus explain --json` alternatives carry a `truncatedCount` so you know how many were elided; and every JSON packet now includes the repo identity it was produced for.
    • Quieter queue detection. Enum members declared in TypeScript type files (`.d.ts`, `.interface.ts`) are no longer mistaken for queue names, so type-only declarations stop inflating `horus queues`.
    • Sharper external-system detection in `horus architecture`. Matches are word-bounded and skip comments and JSDoc, `.yarn/` and generated trees are excluded, and Horus no longer reports its own plugin integrations as external systems — cutting false integrations from vendored code, config, and prose.
    • Resolver prefers real code over test namesakes. On a qualified lookup (`Class.method`), product code now outranks an identically named symbol defined in a test, and `.tst.*` files are recognized as tests alongside the existing test conventions.
    • A failed `horus init` leaves your repo clean. The `.git/info/exclude` entry that hides `.horus/` is now written before analysis runs, so an init that errors partway through no longer leaves an untracked `.horus/` dirtying `git status`.
    • More honest deployment-regression causes. A `chore` commit can no longer be anchored as the cause of a deployment regression, and Horus now intersects each candidate commit against the implicated symbol's exact line range (via `git log -L`) — so a commit that touched the file but not the relevant lines is not blamed.
  • 0.21.12026-07-03

    Dogfood fixes — clean repo on init, honest queues, externals, and change windows

    • horus init no longer dirties your repo. It ignored .horus/ by writing to the tracked .gitignore, which left the working tree dirty and made Horus's own what-changed report its setup edit as evidence. It now writes to the repo-local .git/info/exclude (never a tracked file). After init, git status is clean.
    • Resolver stops landing on non-product code. Its product-over-tests filter had drifted from the shared path classifier and missed bench/, benchmark/, perf/, docs-site trees (www/, site/), and jscodeshift __testfixtures__/. Qualified lookups like ZodObject.parse now resolve to the real method instead of a packages/bench/ file.
    • horus queues stops inventing queues from constants. Enum/constant string literals were extracted as queues — bullmq's OpenTelemetry attributes became 35 fake queues. Dotted-attribute names (bullmq.job.id), SCREAMING_SNAKE enum members, and same-file enum self-matches are now rejected; real queues (which have a named worker) are unaffected.
    • horus architecture external systems stop matching data/docs. Word-list & dataset files, lockfiles, config, and docs-site content no longer count as integrations (e.g. drizzle's kafka/django/clerk from seed name datasets). Detection is now product-source-only.
    • Honest change windows. On a dormant repo the auto change-window label now names the anchor date — "the 14 days before the last commit (2023-05-10)" — instead of "the last 14 days", so an old commit no longer reads as recent.
    • Loud on incomplete indexing. If source analysis times out mid-embedding (symbols present, 0 vectors), horus init now fails with a resume hint instead of exiting 0 and leaving every later command to fail.
  • 0.21.02026-07-03

    Config/cwd is the project — one resolver, agent-ready JSON, honest reports

    • Config/cwd is the only project identity. --name and --project targeting are gone from every command: the repo you run in (its .horus/config.json) is the project, --config <path> or cd targets another repo, and --repo selects a repository within the loaded config. connect uses --sentry-project for the Sentry slug; horus cloud link takes the target positionally. Outside a configured repo you get one clear line: "No Horus config found. Run from a configured repo or pass --config <path>."
    • One canonical symbol resolver. search, explain, investigate, and blast-radius now resolve the same query to the same symbol. Qualified lookups (Reply.hijack, reply.hijack, app.use, Class.method, path/to/file:symbol) prefer the real method over a fuzzy or test-file match; product code outranks tests/examples by default (--include-tests / --full to include them); and genuine ties stay deterministic with the alternatives disclosed instead of a silent guess.
    • Agent-ready machine JSON. --json added to status, investigations, and scores. investigate, changes, timeline, and what-changed emit compact JSON by default (bounded top commits/files, counts, and truncation metadata) with --full for the raw structure — a timeline --json that was ~2.6 MB is now ~18 KB. JSON stdout is always a single parseable document, even on failure.
    • Reports follow the config. With no runtime connectors configured, investigations no longer say "source-only" or pitch horus connect — they state the evidence basis and route to useful follow-ups. A connector that's configured but unavailable this run (missing secret / URL) is now named "configured but unavailable" and routed to horus doctor, distinct from "not configured".
    • Git truth in change reports. timeline and what-changed surface working-tree state (staged/unstaged/untracked, ±lines), so a 0-commit window over uncommitted work says so instead of "0 commits". changes HEAD HEAD short-circuits to empty, synthetic graph nodes are filtered, and git truth (files by status, ±lines, runtime/test/docs/config buckets) is reported before the source-index structural impact. Weak-evidence reports also stop contradicting themselves across summary, causes, hypotheses, and cause chains.
    • Queue topology truth. horus queues and horus architecture share one hygiene pass, so test-fixture, placeholder, and generic queue names (<name>, name, SEED_PRODUCTS, emails, code fragments) never appear — real production queues survive. queues --live guidance only shows when a queues-role Redis connector is configured.
    • Friendlier connector + cloud setup. horus connect sentry now lists your orgs and projects to pick from instead of typing slugs (with a live credential probe that blocks saving a key that doesn't authenticate); horus cloud link and horus context use let you pick from your accessible cloud projects rather than typing the org/workspace/project triple. horus init --reindex forces a full source re-analysis to purge stale graph edges after a backend update.
  • 0.20.02026-07-03

    One codebase, one bundle — a single horus init

    • One codebase, one bundle. The source-intelligence backend now lives only in the horus repo and ships inside the horus bundle — a Python wheel built at release time and included in the npm package, the Homebrew archives, and the GitHub release. Nothing is published to PyPI anymore. horus init installs the backend from the bundled wheel automatically, horus update keeps it in lockstep, and the backend version IS the horus version. (Python 3.11+ with uv remains the only backend prerequisite.)
    • One onboarding command. horus setup, horus init, and horus index are now a single horus init: it checks prerequisites (backend + Postgres, advisory), writes and registers .horus/config.json, starts the source-intelligence host, indexes the repo, and stitches queue boundaries. Getting started is horus init → horus connect <type> → horus investigate "<hint>". Re-running is idempotent; --changed --fast keeps the pre-push knowledge refresh, --reindex forces a full source re-analysis, and --source <url> records an external host. The old setup/index names — and generate-config — are fully removed and fail as unknown commands.
    • Config/cwd is the only project identity. --name and --project targeting are gone from every command: the repo you run in (its .horus/config.json) is the identity, --config <path> targets another repo, and --repo selects a repository within the loaded config. connect uses --sentry-project for the Sentry slug; cloud link takes the target positionally.
    • Agent-ready JSON. status, investigations, and scores gained --json; investigate, changes, timeline, and what-changed emit compact JSON by default (bounded top commits/files with truncation metadata) with --full for the raw structure. explain and blast-radius resolve queries through one shared, deterministic symbol resolver — qualified Class.method / receiver.method lookups prefer the real method over test/fuzzy matches, and the same query resolves to the same symbol across search, explain, investigate, and blast-radius.
    • Connector trust hardening. One shared HTTP transport for Elasticsearch/Grafana/Sentry/Axiom (timeouts everywhere, bounded retry with backoff). Secrets are redacted from every connector error message, health detail, and evidence payload. Connector failures are honest — a down or misconfigured connector surfaces as an explicit evidence gap ("configured but unavailable", "collection failed") with a confidence impact, instead of silently reading as "no evidence found". Queue topology is filtered so test-fixture and placeholder queue names never appear.
  • 0.19.12026-07-01horus-source 2.1.0

    Clearer Shopify connect + safer connector setup

    • horus connect shopify now asks which auth model you're using up front — static Admin API token or Client-Credentials app — and prompts only that mode's fields. The credential is required: the wizard re-prompts on a blank secret, and horus connect now refuses to save any connector that's still missing a required field (previously a Shopify connector could save with no token and wrongly report success). Secrets stay masked on input and in the summary, and encrypted at rest.
  • 0.19.02026-07-01horus-source 2.1.0

    Shopify Admin connector — your store's data in investigations

    • New Shopify Admin connector. horus connect shopify wires up a store with either a static Admin API access token or a Client-Credentials app (access id + secret, which Horus exchanges for a short-lived token automatically); you enter just the store subdomain (.myshopify.com is added for you) and the secret is encrypted at rest like every other connector. The connector embeds no queries — you supply the Admin GraphQL query at investigation time (horus investigate --shopify-query @orders.graphql, a raw string, or - for stdin), or declare default queries in config for horus watch. Each result folds into the report as application-state evidence alongside logs, metrics, and code, and shows up in horus status / doctor / readiness. Read-only.
  • 0.18.02026-06-30horus-source 2.1.0

    Go, Java & Rust support + sharper causes

    • Horus now indexes Go, Java, and Rust repositories (paired horus-source 2.1.0): functions/methods, structs/classes/records/enums, interfaces/traits, imports, call graphs, and heritage (Java extends/implements, Rust impl Trait for Type); Spring annotations feed entrypoint detection. Verified end-to-end on real OSS repos. (HOR-459/460/461)
    • Sharper causes when nothing is structurally linked to the implicated code: investigations now surface a symptom-matching runtime signal — a warn-level event whose code names the symptom (e.g. SALE_028 “Sale with link not found” for “sale links broken”) — as a hedged cause ranked above a speculative deployment guess, instead of defaulting to “a recent commit may have caused this”. Precision-gated so a loud unrelated warning can't false-match. (HOR-453)
  • 0.17.12026-06-30horus-source 2.0.2

    horus notify command

    • New horus notify command to configure the watch outbound sink (0.17.0) without hand-editing config: horus notify set --url <webhook> [--secret <s>] [--min-confidence 0.6] [--cloud], plus show, test (sends a sample dispatch to verify the webhook), and remove. The webhook signing secret is stored encrypted in .horus/secrets.local.json — never plaintext in config — consistent with connector-secret encryption. (HOR-454)
  • 0.17.02026-06-30horus-source 2.0.2

    horus watch can notify you

    • horus watch now dispatches confident auto-investigations to an outbound sink. When it auto-investigates a new incident and the result clears a configurable confidence threshold, it sends the one-line cause to a generic webhook (Slack-compatible JSON, HMAC-signed with X-Horus-Signature when you set a secret) and/or pushes it to Horus Cloud. Configure per environment under notify: { minConfidence, webhook: { url, secret }, cloud }. Best-effort and resilient — a failed dispatch is logged and the watch loop keeps running. No daemon; watch stays a poller. (HOR-454)
  • 0.16.12026-06-30horus-source 2.0.2

    Honest root causes for sweeping commits

    • A broad, sweeping commit (e.g. a large integration touching dozens of files) that merely included the implicated file is no longer presented as the confident root cause of an unrelated symptom. When the most-focused recent change to that file is still broad and nothing else corroborates it, the investigation now says “No specific cause identified from the available evidence” instead of naming the commit. (HOR-451)
  • 0.16.02026-06-30horus-source 2.0.2

    Encrypted connector secrets + more trustworthy root causes

    • Connector credentials are now encrypted at rest. Tokens, passwords and connection URLs are AES-256-GCM encrypted into a gitignored .horus/secrets.local.json, with the 32-byte master key held by your OS keychain (macOS Keychain, Linux libsecret, Windows DPAPI) — never the repo (HORUS_SECRET_KEY overrides for CI). config.json keeps only non-secret fields and stays safe to share. New horus secrets status|migrate|key, and horus doctor now warns when .horus/ isn't gitignored or config still holds a plaintext secret. Backward-compatible — existing plaintext config still resolves. (HOR-452)
    • More trustworthy root causes on real systems, from live connector dogfooding. A recent commit that only touched documentation or reformatted code is no longer blamed as a regression; a broad, diffuse commit that merely touched the implicated file is down-weighted so an evidence-backed runtime cause isn't outranked by it; and an informational/diagnostic log signal can no longer be presented as a confident root cause. (HOR-451)
  • 0.15.22026-06-30horus-source 2.0.2

    Data-flow cause reaches one hop out

    • The source-only data-flow cause (0.15.0) now looks one hop out from the seed — into the function it calls or a closely-related function — so it can name a mechanism that lives in a reducer, a library helper, or a sibling method rather than only the entry point. It also recognizes an exact-equality database lookup with no normalization (a value differing only in case/whitespace returns no rows). Still hedged and source-only; never outranks a genuine evidence-backed cause. (HOR-448)
  • 0.15.12026-06-30horus-source 2.0.2

    More accurate seeds on TypeScript/GraphQL apps

    • Investigations no longer anchor on auto-generated code (e.g. a Cart type in graphql/generated.tsx) or other type declarations when a real same-named function exists — the actual implementation (a reducer, a service method, …) is chosen as the seed, which also lets the source-only data-flow cause (0.15.0) read the right code. A type you explicitly point at still surfaces. (HOR-447)
  • 0.15.02026-06-30horus-source 2.0.2

    Sharper root causes from code alone

    • When investigating with no runtime connectors, Horus now reads the implicated function's own code and proposes a concrete mechanism — a fixed polling cadence, an in-place state mutation, an unawaited async write, or a hardcoded threshold/retry limit (including reference-equality bail-outs) — instead of always falling back to 'a recent commit may have caused this'. It stays a hedged, clearly source-only suggestion (verify against runtime evidence) that never outranks a genuine evidence-backed cause. (HOR-446)
  • 0.14.12026-06-30horus-source 2.0.2

    Fix: investigate degrades instead of aborting on an unusual seed

    • Fixed: horus investigate no longer aborts when a source query fails on an unusual symbol. A seed that resolved to a #private class method made the impact lookup 404 (the # truncated the request URL) and the whole investigation errored out. The symbol id is now encoded correctly, and a failed impact/flows query degrades gracefully instead of sinking the run. (HOR-445)
  • 0.14.02026-06-30horus-source 2.0.2

    Horus learns from your feedback (local reranker)

    • Horus can now learn from your outcome feedback: a local, per-tenant reranker (horus train) fits on your own corpus and reorders candidate causes so the right one surfaces more often, measured honestly against a held-out baseline. It's a ranking aid only — it reorders among causes that already clear Horus's confidence gates and never changes a score, a confidence, or a verdict. Your corpus never leaves your machine; it ships OFF and only activates a model that has beaten the baseline (HORUS_RERANK=1). (HOR-404)
  • 0.13.22026-06-30horus-source 2.0.2

    Feedback at the right moment

    • Horus now asks for an investigation's outcome at the right time — once, on a later run, for a prior investigation that's still unresolved — instead of prompting prematurely right after the investigation. Rate-limited, dismissible, and never in scripts/CI (--no-input / HORUS_NO_INPUT). This raises the outcome-label rate that powers Horus's measured accuracy over time. (HOR-431)
  • 0.13.12026-06-30horus-source 2.0.2

    Discoverable bug/gap reporting

    • The horus report bug/gap path is now fully discoverable: an unexpected crash nudges you to file an issue, and the command is documented in the CLI reference. Completes the surfacing for the reporting path. (HOR-439)
  • 0.13.02026-06-29horus-source 2.0.2

    Code-grounded benign-variance + feedback & reporting

    • Benign-variance from code alone: when a service splits work per segment — separate per-market/region/tenant queues, or a dispatcher like manageSalesForMarket(market) fanned out per market — Horus recognizes the natural per-segment duration variance directly from the code, no telemetry required, so an expected artifact is no longer reported as a confident wrong root cause. (HOR-438)
    • horus feedback no longer needs an investigation id — it defaults to your most recent investigation, with a footer nudge after each investigation. (HOR-431)
    • New horus report command and report_issue MCP tool: file a Horus bug or capability gap as a pre-filled GitHub issue with an environment block. Agents can report gaps mid-task. No auth, nothing sent automatically. (HOR-439)
    • When the CLI and source-intelligence backend versions drift, the version-pin guard now points you to horus update to realign. (HOR-436)
  • 0.12.52026-06-29

    Doctor checks every connector

    • horus doctor now health-checks every configured connector, not just the first — misconfigured integrations surface up front. (HOR-437)
  • 0.12.42026-06-29

    Reasoning & confidence calibration

    • Investigations no longer over-anchor on an alert's suggested cause: alert-suggested causes are de-anchored, confidence is recalibrated, and a benign-variance hypothesis is weighed so an expected fluctuation isn't promoted to a confident root cause. (HOR-435)
    • Duration-anomaly investigations get real distribution signal: runtime logs are grouped by dimension/region and bimodal (two-population) metrics are detected. (HOR-434)
  • 0.12.32026-06-29horus-source 2.0.2

    Self-healing upgrades + per-investigation memory

    • Self-healing upgrades: upgrading from a pre-2.0 (KuzuDB-era) install now auto-recovers — a legacy or zero-embedding index is detected on host start and re-extracted + re-embedded automatically, no manual reset. (HOR-433)
    • Each investigation records a context-only memory; recurring incidents consolidate into a single item with a recurrence count. (HOR-432)
  • 0.12.22026-06-28horus-source 2.0.1

    Improved investigation accuracy

    • Seed ranking now weights semantic similarity above raw keyword matching, so investigations surface real core code instead of same-named example/test/demo symbols. (HOR-430)
  • 0.12.12026-06-28

    horus stop reliability fix + README refresh

    • Fixed: `horus stop` reliably stops its own source host even after an automatic port fallback.
    • Docs: README refreshed.
  • 0.12.02026-06-28horus-source 2.0.0

    Storage engine rewrite — KuzuDB to SQLite

    • Source-intelligence storage migrated from KuzuDB to SQLite + sqlite-vec (+ FTS5). Lighter install, EOL KuzuDB dependency retired, re-index automatic on upgrade.
    • KuzuDB stays opt-in via HORUS_SOURCE_STORAGE_BACKEND=kuzu + the [kuzu] extra through the 2.x line, and will be removed in horus-source 3.0.0. (Major: horus-source 2.0.0.)
  • 0.11.02026-06-28

    Axiom connector

    • horus connect axiom (token, region, live dataset pick); Axiom logs flow into investigations as evidence with provenance.
  • 0.10.02026-06-28horus-source 1.6.1

    Quality + knowledge graph

    • Interactive Knowledge Graph (Explore + Timeline).
    • Evidence-v2: subject + typed findings, per-investigation Provenance view.
    • Per-tenant accuracy / Insights dashboard.
    • Memory-to-memory link graph (supersedes / contradicts / recurs-with).
    • Large batch of investigation-quality fixes from dogfooding on 50+ real repositories.
  • 0.9.02026-06-28

    Memory + dashboard

    • Memory system: capture / recall / confirm.
    • Eval/outcome store and self-routing investigations.
    • Cloud dashboard.
  • 0.8.x2026-06-24

    Hardening

    • Dogfood-driven fixes and connector hardening across many real repositories (2026-06-24 to 06-27).
  • 0.1.0–0.7.02026-06-17

    Initial development

    • The core investigation engine, source intelligence, the first connectors, and the CLI foundations (2026-06-17 to 06-23).