Skip to main content

Changelog

All notable changes to OMEGA will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[Unreleased]

Added

  • Mode profiles for tool surface gating (Pro): registering 135 MCP tools at handshake spent ~13K schema tokens before the first user message. The new OMEGA_MODE environment variable lets a deploy opt into a smaller surface that matches how it actually uses OMEGA.
    • OMEGA_MODE=solo (the new default) loads core + dreaming + audit + typed — about 28 tools, ~4K tokens of schema. Right for single-agent coding sessions on Claude Code.
    • OMEGA_MODE=team adds coordination + federation — about 86 tools. Right for multi-agent and federated-peer setups.
    • OMEGA_MODE=enterprise (alias all) loads everything, matching the pre-mode behavior.
    • Additive syntax: OMEGA_MODE=solo,federation,oracle picks specific modules on top of a base profile. Per-tool overrides via OMEGA_TOOLS_INCLUDE=tool_a,tool_b and OMEGA_TOOLS_EXCLUDE=tool_c.
    • New omega_mode tool (always loaded, including for free tier) reports the active profile, the loaded/skipped module breakdown, and the exact env-var incantation to expand. Surface bumps appear on the omega_welcome banner so users see the active mode at session start.
    • /health HTTP endpoint grows a mode sub-object with profile + loaded/skipped counts so the admin dashboard and external monitors can read it.
    • Mode is resolved once at server startup. Changing it requires a restart — Claude Code does not honor MCP tools/list_changed (anthropics/claude-code#13646), so runtime gating is not viable.
    • Lunar anti-pattern guard: a new test asserts no two tool schemas across modules share a name, so future module adds can't silently introduce the agent-misfire failure mode.
    • 21 new tests in tests/test_mode_profiles.py.

[1.5.4] - 2026-06-12

Added

  • Context packets in Core: context_packet builds compact, task-aware working context from retrieval seeds, graph chains, sensitivity filters, warning receipts, and a token budget.
  • Context packet eval tooling: eval-context-packet measures packet recall, diagnose-context-packet explains misses, and backfill-context-packet previews candidate memory-chain repairs in dry-run mode.
  • Pro graph repair loop: licensed Pro unlocks backfill-context-packet --apply and maintain-context-packet so packet misses can become durable graph edges for future sessions.

Fixed

  • Published the core package layout expected by Pro 1.5.4, including omega.bridge._core, omega.bridge._ingest, omega.bridge._query, and omega.server.pid_registry, so scheduled dreaming and session coordination imports resolve against public omega-memory==1.5.4.
  • Aligned public Core and private Pro release numbers at 1.5.4. Pro remains a private licensed wheel, not a public PyPI package.

[1.5.1] - 2026-05-25

Added

  • P3.17 domain-typed memory schemas (Pro): closes the last P3 item in the Sovereign Frontier Memory Stack plan. New omega_platform.typed submodule ships four Pydantic models — CalibrationModel, ForecastModel, AnchorModel, OutcomeModel — that turn OMEGA's free-text memory store into a typed store for predictive workloads.
    • Each model extends TypedMemoryBase with ConfigDict(extra="forbid", str_strip_whitespace=True, validate_default=True). A typo'd field fails at the store boundary, not at the consumer's regression model.
    • store_typed(model, entity_id=?, extra_metadata=?) validates, serializes to JSON, and inserts via SQLiteStore.store with skip_inference=True so the embedding-similarity dedup doesn't collapse similar-shaped-but-different observations. Content-hash and canonical-hash dedup still fire (correct semantic for typed rows).
    • query_typed(model_cls, entity_id=?, since=?, until=?, limit=?) uses SQLite's json_extract on the typed_schema metadata discriminator (more reliable than LIKE substring matching) and revalidates each row through the Pydantic class. Rows that fail revalidation are silently skipped with a logged warning so a single corrupt row doesn't take down the query.
    • 3 new MCP tools: omega_typed_store, omega_typed_query, omega_typed_schemas. The _schemas tool returns the full JSON-schema for every registered typed model so callers can discover field constraints before storing.
    • First consumer: Meridian (P4.18–P4.20) — calibration rationale, anchor evolution, and forecast-vs-actual mining all ride on these primitives without each needing its own schema layer.
    • 26 new tests in tests/test_typed_p3_17.py (lint clean).

Plan

  • Sovereign Frontier Memory Stack: P3 8/8 closed. Only P4 (Meridian integration, paused for the partner agent) and marketing copy remain.

[1.5.0] - 2026-05-24

Changed

  • Version bump to 1.5.0: marks the close of the Sovereign Frontier Memory Stack P2 arc and the strategic pivot to Pro-as-paid-only going forward.
    • Public/open-source core (omega-memory on PyPI) enters maintenance mode: bug fixes and merged community contributions only. No new feature work pushed to the public surface unless it ships behind the Pro license gate.
    • All P2.x / P3.x moat features (signed audit chain, federation, dreaming with LLM analyzers, local Ollama backend, parallel fan-out, scheduled autonomy, auto-apply) remain Pro-only and never sync to omega-public.
    • Supersedes the Feb 2026 "community-first open-core" positioning. Rationale: moat features now stand on their own; further open-sourcing of Pro work would erode the paid surface without proportional community gain.

Added

  • P3.16b federation import + merge (Pro): closes the federation moat by shipping the receiving half of the protocol. Pairs with P3.16's export+verify so two OMEGA instances can exchange signed memory subsets end-to-end with cryptographic origin proof, trust gating, and lineage preservation. New module additions in omega_platform.federation:

    • import_federation_manifest(manifest, trust_mode=...) runs the 3-layer verifier, the trust-allowlist gate, then per-memory merge via SQLiteStore.store (bypassing the bridge's auto-capture dedup so the peer's exact content + metadata are preserved). Idempotent: re-imports of the same manifest no-op via (content_hash, entity_id) matching, counted as already_local.
    • add_trusted_key(public_key_pem, label, added_by?), remove_trusted_key(fingerprint), list_trusted_keys(), is_trusted(public_key_pem): trusted-peer allowlist persisted at $OMEGA_HOME/federation/trusted_keys.json (atomic temp-file rename).
    • key_fingerprint(public_key_pem): canonical SHA-256 hex of the raw 32-byte Ed25519 public key (stable across PEM encoding variants).
    • Trust modes: trusted_keys_only (default; refuses unknown peers) and any_valid (accepts any cryptographically valid manifest; operator-verified out-of-band).
    • Lineage: every imported memory's metadata gains a federation_origin block (manifest_id, source_label, peer_fingerprint, source_node_id, imported_at) so downstream queries can filter "memories from peer X" or trace a decision back to its source instance.
    • 4 new MCP tools: omega_federation_trust_add, omega_federation_trust_list, omega_federation_trust_remove, omega_federation_import. Federation handler count: 2 to 6.
    • 22 new tests in tests/test_federation_p3_16b.py (lint clean).

  • P2.8 parallel sub-agent fan-out for dream analyzers (Pro): closes the last literal P2 gap in the Sovereign Frontier Memory Stack plan. A single omega_dream invocation can now partition its input across multiple in-flight LLM calls and aggregate the per-partition results, mirroring (in spirit) Anthropic's "Dreams runs AS A SESSION, parallel sub-agent fan-out" contract. Research-informed defaults from qubytes.substack.com fan-out post-mortem and Anthropic prompt-cache docs — see docs/plans/2026-05-24-p2-8-parallel-fanout-plan-v2.md for the source-cited design.

    • OMEGA_DREAM_CONCURRENCY (default 4, clamped 1..10): max in-flight LLM partitions per dream. Default is 4 rather than 6 because Anthropic's prompt cache only seeds on the first response; firing 6 simultaneous identical-prompt requests duplicates the system prompt 6× with zero cache hits.
    • OMEGA_DREAM_PARTITION_TIMEOUT_S (default 90, floor 5): per-partition LLM timeout via asyncio.wait_for. A slow partition does NOT cancel its siblings — they finish, the slow one times out, the merger decides whether the partial set is usable.
    • OMEGA_DREAM_MAX_INPUT_SESSIONS (default 20, clamped 1..100): cap on input sessions a single dream aggregates over. Anthropic's hard cap is 100; we default lower per their "start small, scale up once curation quality verified" guidance.
    • OMEGA_DREAM_CACHE_STAGGER (default 1): when on, the first partition is awaited fully before partitions 2..N fire — partition 0 takes the cache miss, partitions 1..N take cache hits on the shared system prompt.
    • OMEGA_DREAM_DEDUP_MIN_PER_CHUNK (default 50): dedup's per-partition floor; sub-threshold runs fall back to the single-call SQL scan.
    • Every dream now mints a dream_trace_id (dtr_<hex16>) at create_dream time and propagates it through metadata.dream_trace_id. Future LLM-call propagation will let post-mortems stitch a full pipeline trace from a single ID — Qubytes' six-hour fan-out incident root-caused to "nothing tied the run together with a shared identifier" is the cited reason for making this mandatory rather than opt-in.
    • Op aggregation uses hierarchical pair-merging (tree_merge) rather than flat reduce(). Flat aggregation produced 12× orchestrator-context cost overrun in the Qubytes 7-partition incident; pair-merge keeps the per-merge context bounded.
    • Per-partition outcomes surface in metadata.partition_results[] with completion_status: "full" | "partial" | "inferred", ops_count, error_reason, and per-partition token counts. The legacy metadata.backend block (spec, provider, model, attempts, totals) stays compatible so admin/pro dream cards keep working without special-casing partitioned runs.
    • Failure semantic mirrors Anthropic Dreams: partial output is preserved on failure (no rollback). The dream only fully fails when ALL partitions fail.
    • All four analyzers refactored: llm_consolidate, memory_judge, skill_promotion (clusters are the natural partitions; serial cluster loop replaced with bounded gather) plus dedup (hash-prefix bucket partitioning across worker threads, since LLM-bound concurrency primitives don't help a pure-SQL scan).
    • SQLiteStore.get_thread_local_read_conn() (P2.8.3): opt-in per-thread read connection so dedup's parallel SQL scan doesn't share sqlite3.Connection across threads (unsafe even with check_same_thread=False per ricardoanderegg.com/posts/python-sqlite-thread-safety). Existing single-connection read/write path is unchanged; the helper is additive. Unblocks the long-blocked P3.12b parallel fleet (mem-a97ef1ed2468) as a side benefit.

  • P2.12 dream-pipeline autonomy (Pro): two opt-in knobs that close the human-in-loop bottleneck for proposals carrying zero LLM judgment risk.

    • OMEGA_DREAM_AUTO_APPLY=safe (default off): after create_dream produces ops, auto-apply iff the analyzer was dedup (pure content-hash equality, no LLM in the loop). All LLM-driven analyzers (llm_consolidate, memory_judge, skill_promotion) still require the manual gate. Unknown policy values fall back to off — default-deny is the only acceptable failure mode for an auto-apply gate. Auto-apply writes auto_applied=True + auto_apply_policy + auto_apply_result to dream metadata so the /admin/dreams and /pro/dreams surfaces can distinguish "Jason applied this" from "OMEGA auto-applied this".
    • OMEGA_DREAM_EXPIRY_DAYS=30 (default; 0 disables): expire_stale_dreams() flips pending dreams older than the threshold to discarded. Applied/discarded jobs are immune. Discarded dreams keep their proposed_ops so an expired-by-mistake dream is still inspectable.

  • Sovereign Frontier Memory Stack — dream pipeline (Pro): Anthropic-style proposed-mutation review for memory consolidation. The input store is never mutated until omega_dream_apply is called; omega_dream_discard rejects a proposal cleanly. Four MCP tools (omega_dream, omega_dream_diff, omega_dream_apply, omega_dream_discard) plus four analyzers:

    • dedup: content-hash duplicate detection, no LLM
    • llm_consolidate: LLM proposes merge_memories / mark_superseded / tag_contradiction ops; honors OMEGA_DREAM_CONSOLIDATE_MAX_JUDGE_SCORE pre-filter so high-quality memories are protected from consolidation
    • memory_judge: LLM scores each memory on relevance, specificity, freshness, and confidence plus a combined quality_score; writes to metadata, non-destructive
    • skill_promotion: greedy cosine clustering on bge-small-en-v1.5 embeddings, LLM synthesizes each cluster as a SKILL.md in ~/.claude/skills-jit/ for skill-search MCP discovery; source memories tagged promoted_to_skill non-destructively

  • LLMBackend Protocol + circuit-breaker router (Pro): Provider-agnostic dream-time LLM surface. Five backends ship: Anthropic (system-split kwarg), Groq (OpenAI-flat), xAI (via openai SDK at api.x.ai/v1), Gemini (stdlib urllib, assistant→model rename + systemInstruction lift), and Ollama (stdlib urllib, no auth, /api/chat). The router selects by store llm_backend field (auto / cloud:<provider> / local:<provider> / bare local), falls through providers within a single generate cycle on transient failure, and circuit-breaks on repeated errors (OMEGA_DREAM_BREAKER_THRESHOLD, OMEGA_DREAM_BREAKER_COOLDOWN_S).

  • P2.11 LOCAL-LLM backend — Ollama (Pro, THE MOAT): Dreaming runs air-gapped against a model on the user's machine. No API key (auth-by-locality), no data egress. Default llama3.2 at http://127.0.0.1:11434, both overridable via OMEGA_OLLAMA_MODEL / OMEGA_OLLAMA_BASE_URL. Stores opt in with llm_backend='local:ollama'; bare local still means "skip LLM" for backward compatibility. Connection-refused errors surface ollama serve as the diagnostic. The strategic moat hosted-Memory competitors cannot match by construction.

  • Fleet dreaming (Pro): create_fleet_dream(analyzer, store_ids=None) fans an analyzer out across many stores in one call, returns a flt_<hex16> ID. Per-store failure isolation; fleet ID propagated into each child dream's metadata so get_fleet_dream / apply_fleet_dream / discard_fleet_dream can reassemble. Sequential only — parallel fan-out blocks on a per-thread SQLite connection refactor in the bridge layer.

  • Marker-file scheduled dreaming (Pro): OMEGA_DREAM_CADENCE on a store enables hourly background sweeps via the maintenance hook. ISO-8601 subset (PT*H/PT*M/PT*S/ P*D/P*W and bare seconds). Per-store markers prevent overlapping runs.

  • Optional [llm] extras group: pip install omega-platform[llm] declares the dream-backend SDKs (anthropic>=0.79.0, groq>=1.2.0, openai>=1.0.0; Gemini is stdlib). Included in [full].

  • Code review (omega_review): Multi-agent specialist review panel with 5 agents (correctness, security, performance, consistency, blast radius). Hybrid static+LLM analysis: 12 deterministic pattern checks (zero false positives) plus LLM for novel issues. Memory-powered: uses OMEGA conventions, past incidents, and team preferences for context. Confidence gating with strict/normal/verbose modes. Fast summarize_only mode for risk assessment without LLM. Pre-commit hook at hooks/pre_review.py. Standalone engine: singularityjason/revue.

[1.2.0] - 2026-03-04

Added

  • Hooks in wheel: Claude Code hooks now ship inside the pip package; omega hooks setup auto-configures ~/.claude/settings.json with correct paths
  • Multi-user auth: Google Sign-In, role-based access control, self-service onboarding wizard, per-user data scoping across all admin API routes
  • Auth guards: 46 API routes hardened with session verification
  • LLM provider abstraction: Unified llm.py (Python) and lib/llm.ts (TypeScript) supporting Anthropic, OpenAI, and OpenAI-compatible providers via OMEGA_LLM_PROVIDER
  • LLM usage tracking: Per-call cost tracking with session rollups and admin dashboard
  • Multi-model consultation: omega_consult_gpt and omega_consult_claude tools for cross-model second opinions (replaces omega_lessons)
  • Growth engine: Thompson Sampling bandit for content optimization, attribution engine correlating X metrics with GitHub/PyPI, content genome pipeline
  • Scheduled jobs infrastructure: State machine with retry logic, approval gates, audit trail, SLA escalation, heartbeat monitoring, Vercel cron migration
  • Query expansion: LLM-based retrieval augmentation with strong-signal short-circuit and position-aware reranking (QMD-inspired)
  • System insights: Permanent-TTL insight memories with protocol surfacing, file-triggered hooks, and admin graph visualization
  • Trajectory distillation: Auto-extracts session summaries at session stop with quality gate
  • Project registry: Unified canonical projects table with status tracking and auto-generation at session stop
  • Schema v13: Unique index on forgetting_log to prevent duplicate entries
  • Coordination upgrades: File claim gap closed with read tracking, peer-claimed commit blocking, auto-handoff on session stop, message priority
  • Admin dashboard: Projects tab, LLM Usage tab, Entities tab, Conductor Console, Growth tab, Settings expansion (Profile, Agent, Memory, Projects, Integrations)
  • Website: Next.js 16.1.6, homepage restructure, /pro page redesign, 6 new blog posts, HeroGraph visualization
  • Automation: Target scanner, scan-and-reply cron, daily summary email, @omega_memory multi-account infrastructure

Changed

  • sqlite_store.py split into mixin-based package (7 modules) for maintainability
  • Oracle engine upgraded to thread-safe singleton
  • Hook system abstracted for multi-client support (Claude Code, Cursor, Windsurf, Cline)
  • Protocol adapted for multi-model providers with provider-specific notes
  • Admin theme refined (violet accent, semantic signal colors)

Fixed

  • ~176 bug fixes across security, admin, knowledge, bridge, entities, growth, LLM routing
  • Multi-user data isolation across 29 API routes
  • Thread-safety issues in oracle and embedding engines
  • Knowledge base: SSRF prevention, entity filtering, race conditions
  • Bridge: full memory ID returned from dedup/evolve/reconfirm paths
  • Cloud sync hardening and expanded test coverage

Removed

  • SayDo experimental module (archived)
  • omega_lessons tool (replaced by omega_consult_gpt/omega_consult_claude)

[1.1.0] - 2026-02-25

Added

  • Automatic entity extraction from conversations (Phase 3) with async processing and throttle controls
  • Bi-temporal data model with valid_from/valid_until for point-in-time queries
  • Memory strength scoring with decay, deduplication, and strength_min query filter
  • Memory type classification — auto-classifies on store, filterable via memory_type parameter in omega_query
  • Contradiction detection surfaced in store output
  • Intelligence cards — compact [OMEGA] cards for memory, decision, and learning events at NORMAL+ transparency
  • Entity graph relationships wired into retrieval scoring
  • Campaign Orchestrator v3.0 (Layers 1-3) with automation modules and proposal feed
  • MCP server instructions for automatic memory usage by connected agents
  • Session awareness and agent discipline protocol sections (v1.3.0)
  • Admin dashboard: 3D Memory Graph visualization with bloom and clustering
  • Admin dashboard: Interactive entity knowledge graph
  • Admin dashboard: Skills Graph 3D visualization with manifest and API
  • Admin dashboard: KnowledgeBase rewrite with folder tree, markdown preview, and breadcrumb navigation
  • Admin dashboard: Orchestrator proposals feed, ambient awareness layer, historical coordination view
  • Admin dashboard: Recharts-based Insights tab with memory sparklines and project charts
  • Security hardening — shared validation module, coordinator handler hardening, write-tool rate limiting, CI dependency auditing, Dependabot
  • Windows installer improvements and repair utility
  • Website: downloads page, competitive positioning, OpenAI comparison blog post, dual-account tweet generation

Changed

  • Extracted shared mcp_response/mcp_error helpers to reduce duplication across server handlers
  • Generate button switched from SSE to job polling for reliability
  • Tweet pipeline migrated to EST with slot optimization and reply queue
  • Heavy cron jobs migrated from Vercel to GitHub Actions

Fixed

  • SQLite lock contention reduced with BEGIN IMMEDIATE transactions and WAL checkpoint logic
  • Connection leak in record_metric eliminated with hardened close/reconnect
  • Stale embedding backend state causing tuple.encode() crash resolved
  • Hook resilience improved — retry on startup race, skip informational hooks in fallback mode
  • JIT proxy: bypass MCP SDK 1.26 outputSchema validation errors
  • Router intent classifier no longer unconditionally overwrites session task
  • Cloud sync: per-document error isolation with timeout config
  • FTS5 query sanitization hardened against malformed input

1.0.0 - 2026-02-13

Added

  • Open-core plugin architecture (OmegaPlugin base class, discover_plugins())
  • Graceful degradation for all optional modules (coordination, router, entity, knowledge, profile, cloud)
  • Apache-2.0 license
  • GitHub Actions CI/CD (test matrix: Python 3.11, 3.12, 3.13)
  • PyPI publish workflow with trusted publishers
  • CONTRIBUTING.md, SECURITY.md, NOTICE
  • Issue and PR templates

Changed

  • License: MIT → Apache-2.0
  • Author: → Kokyō Keishō Zaidan Stichting
  • Hook server: conditional coordination handler registration
  • CLI: graceful "requires omega-pro" messages for commercial modules
  • MCP server: commercial tool schemas loaded only when modules available
  • Version bump: 0.6.1 → 1.0.0

0.6.1 - 2026-02-11

Removed

  • Phoenix module deleted — 1,531 lines source + 1,152 lines tests. Fully disconnected dead code: no hooks triggered it, no workflows called its 6 MCP tools, respawn requests wrote to JSON files nothing read. Session context handoff already handled by coordinator's snapshot/recover system.
  • 6 MCP tools removed: omega_phoenix_check, omega_phoenix_request, omega_phoenix_complete, omega_phoenix_requests, omega_phoenix_handoff, omega_phoenix_metrics
  • [phoenix] optional dependency group from pyproject.toml

Changed

  • MCP tool count: 60 (was 66)
  • Test count: 1406 across 29 test files (was 1447 across 31)
  • Renamed _phoenix_recovery → _session_resume in hook_server.py (pure coordinator logic, no Phoenix dependency)
  • [PHOENIX] label → [RESUME] in coord handler output

0.5.0 - 2026-02-10

Added

  • Router auto-warmup on session start, auto-classify on every user prompt
  • Router provider status surfaced in welcome briefing
  • Groq re-added for simple_edit intent (speed mode)
  • 1122+ tests across 28 test files, 0 lint errors

Changed

  • Router classifier status checked on start, hot-reload on config change

0.4.3 - 2026-02-10

Changed

  • Router rewired: xAI/Grok-4 as primary for exploration intent (research/AI trends), Google/Gemini as fallbacks, Groq re-added for simple_edit (speed mode)
  • Router secrets: API keys loaded from ~/.omega/secrets.json — 5/5 providers active (Anthropic, OpenAI, Google, xAI, Groq)
  • CI matrix: dropped Python 3.10 (unsupported), added 3.13
  • Removed phantom litellm dependency from router extras (was never imported)
  • Fixed commitizen changelog_start_rev to existing tag v0.3.0

Fixed

  • 105 ruff lint errors across src/ and tests/ (unused imports, f-strings without placeholders)
  • pre_push_guard test subprocess import path
  • auto_claim_branch path validation
  • Feedback score inflation: clamped to valid range
  • Unbounded state growth in coordination audit log
  • Stale Haiku model ID updated in router defaults
  • Deprecated datetime.utcnow() replaced with timezone-aware alternative
  • Missing thread lock in coordination cleanup path

Added

  • 31 new tests: migration, reingest, reembed, lessons, classifier, concurrency coverage gaps
  • Updated SCORECARD.md to v0.4.3 with post-cleanup metrics (242 memories, 4/5 providers)
  • README rewrite for public audience: problem statement, 60-second quickstart, comparison table (vs Mem0/Zep/Copilot Memory), collapsible advanced details, contributing section, PyPI badge
  • README: corrected test count (1074→1102), tool counts (22 memory + 25 coord), hooks (11)
  • CONTRIBUTING.md: updated test count (1074→1102)
  • SECURITY.md: added 0.3.x and 0.4.x to supported versions

Removed

  • 162 stale Gnosis-era memory artifacts (506→242 memories)
  • Dead code paths identified in diagnostic audit

0.4.2 - 2026-02-10

Added

  • Unified hook system: all 11 hooks via fast_hook.py → daemon UDS dispatch
  • pre_push_guard migrated from standalone script to daemon handler (12 handlers total)
  • _SLOW_HOOKS set with configurable timeout in fast_hook.py
  • 37 new batch protocol tests (daemon batch, client batch, fallback short-circuit, log format)
  • 4 UAT test suites: memory (10 scenarios), router (4), cross-module (4) — 2,153 lines
  • 83 new tests in test_cli.py and test_graphs_coverage.py

Fixed

  • Thread lock added to get_node() in sqlite_store.py (race condition on access_count)
  • Null-guard on access_count arithmetic in bridge.py dedup path
  • 19 bare except: pass replaced with specific exceptions + debug logging
  • cleanup_old_requests() now uses max_age_days parameter (was ignored)
  • Merged 3 separate store.query() calls into 1 in auto_capture() (saves 2 embedding generations)

Removed

  • Dead HAS_NUMPY variable from graphs.py
  • Dead get_model_history() stub from router/engine.py

0.4.1 - 2026-02-10

Fixed

  • omega doctor now loads sqlite-vec extension before checking vec index
  • Circuit breaker cooldown recovery: embeddings resume after transient failures
  • Orphaned vec index entries cleaned up on startup

0.4.0 - 2026-02-10

Added

  • Router module (10 MCP tools): multi-LLM intent classification and routing
    • ONNX prototype classifier (<2ms, no ML deps beyond existing bge-small)
    • 5 intents: coding, creative, logic, exploration, simple_edit
    • 5 providers: Anthropic, OpenAI, Google, Groq, xAI
    • 4 priority modes: cost, speed, quality, balanced
    • Context affinity tracking with switch penalties
    • Large context override (>100K tokens → Gemini)
    • omega_route_prompt, omega_classify_intent, omega_router_status, omega_set_priority_mode, omega_switch_model, omega_get_model_config, omega_get_current_model, omega_router_context, omega_warm_router, omega_router_benchmark
  • filter_tags parameter for omega_query with AND-logic hard filtering
  • CLI compact and stats subcommands
  • scripts/migrate_magma.py for Gnosis MAGMA → OMEGA migration
  • README rewrite covering all tools, architecture diagram, install flow

Changed

  • MCP tool count: 47 → 57 (+10)
  • Optional module loading: try/except ImportError in mcp_server.py
  • pyproject.toml: router/full optional dependency groups
  • Total tests: 779

0.3.2 - 2026-02-10

Added

  • filter_tags parameter on query_structured (AND-logic, 3x over-fetch)
  • 4 utilization gaps closed: auto-tags on store, confidence thresholds, plan capture triggers
  • pre_push_guard enhancements: checkout target parsing, branch claim checks

Changed

  • Hooks manifest aligned with active coordination hooks
  • Utilization scorecard: grade improved from C+ to A- (gap 0.3)

0.3.1 - 2026-02-10

Added

  • 24 coordination MCP tools re-enabled: sessions, file/branch claims, intents, tasks, messaging, audit
  • pre_task_guard hook: blocks edits when file's task is assigned to another agent
  • Utilization scorecard tracking (SCORECARD.md)

Changed

  • Tool optimization: 44 → 22 MCP tools (23% → 91% utilization)
    • Phase 1: Disconnected redundant coordination schemas (44 → 25)
    • Phase 2: Merged omega_status into omega_health, omega_export/omega_import into omega_backup, omega_cross_project_lessons into omega_lessons (25 → 22)
    • Phase 3: Activated 8 dormant tools via hook wiring (session_start: type_stats, list_preferences, auto-backup; session_stop: session_stats, timeline; surface: traverse, phrase_search)
  • MCP idle timeout: 600s → 3600s (1 hour)

0.3.0 - 2026-02-10

Added

  • Real multi-agent file enforcement: PreToolUse pre_file_guard hook blocks Edit/Write/NotebookEdit via sys.exit(2) when the target file is claimed by another agent session
  • Claim TTL auto-expiry: CLAIM_TTL_SECONDS = 600 — file claims expire after 10 minutes of inactivity, independently of the 30-minute stale session timeout
  • Force-claim override: claim_file(force=True) lets agents explicitly steal claims when coordination breaks down, with full audit trail via log_audit(tool_name="file_claim_force")
  • force boolean parameter added to omega_file_claim MCP tool schema
  • _clean_expired_claims() method runs during periodic stale session cleanup
  • TTL-aware check_file() auto-deletes expired claims on read
  • Daemon parity: handle_pre_file_guard handler in hook_server.py dispatch table
  • pre_file_guard added to fast_hook.py fallback scripts table
  • 21 new tests in test_pre_file_guard.py covering blocking, self-claim, TTL expiry, force-claim, fail-open, notebook support
  • Atomic write for profile.json via tempfile + os.replace to prevent corruption on crash

Fixed

  • Deadlock in claim_file: log_audit() was called inside with self._lock: — since threading.Lock is non-reentrant, this caused silent hangs. Audit call moved outside the lock block

Design Decisions

  • Fail-open: OMEGA unavailability never blocks edits — coordination is opt-in safety
  • Standalone hook, not daemon-routed: PreToolUse is on the critical path; standalone is safer if daemon crashes
  • No enforcement in single-agent mode: Empty SESSION_ID skips all file guard checks

0.2.8 - 2026-02-10

Added

  • SECURITY.md with vulnerability reporting policy
  • CHANGELOG.md in Keep-A-Changelog format (backfilled v0.2.0–v0.2.7)
  • CLI memory commands: omega query, omega store, omega remember, omega timeline
  • LLM-agnostic setup: omega setup --client claude-code (decoupled from Claude Code)
  • omega_task_cancel MCP tool with handler and schema (was dead code — coordination method existed but had no MCP path)

Changed

  • Removed 6 zero-utilization MCP tools (deduplicate, extract_preferences, constraints, batch_store, reload, dedup_stats)
  • Removed 3 overhead hooks (post_edit_test, pre_edit_surface, track_file_read), reducing per-edit Python processes from 5 to 3
  • Export/import paths restricted to ~/.omega/ (was entire home directory)
  • Error messages in MCP handlers no longer leak internal details
  • ~/.omega/ directory created with mode 0o700 (owner-only access)
  • Encryption key file created atomically with O_EXCL to prevent TOCTOU race
  • Thread-safe SQLiteStore singleton via double-check locking
  • Hardcoded /opt/homebrew/bin/python3 replaced with dynamic resolution in hooks
  • Silent vec-index delete failures now logged at DEBUG level
  • Dedup regex compiled once at module level instead of per-query
  • Hook log rotation at 5 MB cap to prevent disk fill
  • pre_push_guard now blocks pushes on divergence via sys.exit(2) (was advisory-only)
  • auto_claim_file now surfaces [CONFLICT] warnings instead of silently swallowing claim conflicts
  • Hook timeouts increased: coord_session_start 3s → 10s, coord_session_stop 3s → 8s
  • Git fetch subprocess timeout reduced from 15s to 5s to fit within hook timeouts
  • Replaced deprecated datetime.utcnow() with datetime.now(timezone.utc) in hooks and coordination
  • Coordination tool count: 25 handlers (was 24)

Removed

  • Dead save()/load() compatibility stubs from SQLiteStore
  • Undefined _LOAD_ATTEMPT_COUNT global from graphs.py

Fixed

  • Numeric MCP handler parameters now clamped to safe bounds
  • .gitignore hardened with .env, *.db, *.log, *.key, hook.sock, .omega/
  • cancel_task now enforces owner check — previously any session could cancel another's in-progress work
  • claim_file/claim_branch catch sqlite3.IntegrityError for cross-process race safety
  • check_file reads now guarded by _lock for consistency with write locking discipline
  • check_inbox read + mark-as-read unified under single lock to prevent concurrent read races
  • _snapshot_session preserves session capabilities in metadata for _auto_reregister recovery
  • Push event logging no longer truncates commit hashes (was [:12], causing hash comparison mismatches)

0.2.7 - 2026-02-10

Added

  • Memory visibility UX: capture confirmations, scored surfacing, health pulse, session activity summary
  • Auto-feedback on surfaced memories at session stop
  • Auto-compaction of lessons every 14 days at session start
  • Cross-project lesson surfacing at session start
  • File-extension-to-tag mapping for contextual re-ranking in edit surfacing
  • fast_hook.py stdin bridging for fallback hook scripts
  • Public SQLiteStore API: edge_count(), get_last_capture_time(), get_session_event_counts()
  • 61 tests for hook UX output formatting

Changed

  • Disabled CoreML provider to prevent native memory leak (~700KB/op); CPU-only ONNX used instead
  • Session summaries TTL reduced from LONG_TERM (2 weeks) to SHORT_TERM (1 day)
  • Hooks no longer access SQLiteStore._conn directly (use public API)

Fixed

  • Daemon/standalone hook parity for scored surfacing, capture confirmations, and auto-feedback
  • Stale surfacing file cleanup (both .surfaced and .surfaced.json files older than 24h)
  • Idle watchdog task reference saved to prevent GC cancellation
  • Resolved 23 test failures from broken hook imports
  • Error dedup in hooks: cap at 5 errors/session, deduplicate by first-100-chars hash

0.2.4 - 2026-02-09

Added

  • UDS hook server for fast hook dispatch (~5ms vs ~750ms cold start)
  • Graph traversal (omega_traverse) with BFS over edges table, max 5 hops
  • Memory compaction (omega_compact) with Jaccard clustering and consolidated summaries
  • Contextual re-ranking with context_file and context_tags boost
  • Auto-claim file hook for implicit coordination
  • Orphan process cleanup and proactive stale session GC
  • 24 tests for UDS hook server, idle watchdog, and stale cleanup debounce
  • UAT suite for registration, coordination, and conflict avoidance

Fixed

  • Coordination lifecycle, edge creation, and TTL gaps
  • Batch embedding falls back to single-item ONNX before hash

0.2.3 - 2026-02-09

Added

  • bge-small-en-v1.5 as primary embedding model (384-dim, better quality than all-MiniLM-L6-v2)
  • Periodic TTL garbage collection (at most once per hour via time.monotonic())
  • Git-aware coordination: detect uncoordinated agents via git state
  • Observability: omega doctor, FTS5 repair, backup, timing, plan capture

Changed

  • Python minimum version raised to 3.11+ (3.10 EOL)
  • Test isolation improvements for safety

Fixed

  • bge-small-en-v1.5 HuggingFace download URLs corrected

0.2.2 - 2026-02-09

Added

  • Intelligence layer: constraints, cross-project lessons, smart surfacing
  • Task management with deadlock detection and audit log
  • Defensive hooks: read tracking and read-before-write warning
  • Session recovery: snapshot/recover crashed sessions

Fixed

  • Flaky tests caused by embedding circuit-breaker leak
  • Naive/aware datetime comparison bug in query()
  • 4 documented feature gaps closed

0.2.1 - 2026-02-09

Added

  • omega_similar: find memories similar to a given one
  • omega_timeline: show memories grouped by day
  • omega_consolidate: memory hygiene at scale (dedup, prune, optimize)
  • Auto-tags: extract languages, tools, file paths, project names at store time
  • Auto-relate: create related edges on store (similarity >= 0.45)

Fixed

  • 3 critical bugs found during UAT testing

0.2.0 - 2026-02-09

Added

  • SQLite + sqlite-vec backend replacing in-memory graphs + JSONL sidecar
  • FTS5 full-text search for phrase queries
  • Multi-agent coordination system (12 tools, 38 tests)
  • Encryption at rest with cryptography library
  • omega_remember, omega_store, omega_query, omega_welcome, omega_profile
  • Export/import for backup and restore
  • Batch store for multiple memories in one call
  • 37 handler tests covering all 21 handlers

Changed

  • Complete storage rewrite from JSONL to SQLite
  • Parameterized SQL throughout (no string interpolation)