Product updates and rollout notes

Local-first should not mean internal-disk-first.

ContextLattice now lets operators place Ollama model data on any explicit absolute path while preserving the existing home-directory default. The runtime verifies what was mounted, not merely what was requested.

• One deliberate override: OLLAMA_DATA moves model blobs without changing quickstart behavior for everyone else.
• Proof before pressure: the storage verifier checks the running container's actual source and fails on mount drift.
• Executable configuration: shipped environment profiles quote human-readable values correctly and can be sourced directly by Bash.
• No new dependency: the feature uses the existing Compose and verification path; no storage daemon or migration service was added.

Paid stopped being a label. It became a cryptographic boundary.

ContextLattice now generates pricing, entitlements, release identity, and buyer-facing feature truth from one contract. The artifact a customer downloads carries its lane, source commit, payload digest, and offline-verifiable runtime license path with it.

• Self-contained delivery: macOS, Windows, and Linux packages embed the tagged payload and hard-fail if it is absent; no public clone fallback exists.
• Signed local access: Ed25519 runtime licenses derive plan, role, and feature permission from signed claims while production enforcement fails closed.
• Private origins stay private: entitled downloads stream through a bounded proxy that verifies SHA-256 before returning bytes and permits only configured redirect origins.
• Drift becomes a failing test: commercial truth, paid/private parity, lane hygiene, release metadata, installer behavior, and secret exclusion are executable gates.

Memory stopped arriving as luggage. It arrives as leverage.

ContextLattice now compresses task truth into one bounded packet that shows its evidence, uncertainty, provenance, next move, continuation state, and permission to act, verify, or abstain.

• One front door: context, resume, remember, finish, correct, and doctor replace lifecycle ceremony without removing advanced surfaces.
• One task, one live session: exact task/native identity is reused; idle, completed, failed, canceled, and expired sessions cannot masquerade as active work.
• No false certainty: stale and duplicate evidence loses rank, contradictions force verification, and unsupported action is stripped from abstaining packets.
• A loop that learns: ordinary completion and correction bind outcomes to the packet that shaped the work; the dashboard exposes transport truth, session truth, and learning truth.

The app and its release machinery now live in the same JavaScript era.

ContextLattice-owned Node surfaces converge on Node 24 LTS, with executable contracts that catch package, container, and GitHub Actions drift before it reaches a user.

• Exact runtime: local version files, strict package engines, Node types, and container images agree on Node 24.18.0.
• Actual execution: CI performs a clean install, full dashboard test suite, and production build on Node 24.
• Supply-chain boundary: reviewed dependency install scripts are version-pinned; unknown future scripts fail closed.
• Release hygiene: every JavaScript action uses a verified Node 24 major instead of relying on GitHub's compatibility override.

Memory links stopped being decorative.

A graph is not intelligence because it stores edges. It earns that name when it recovers evidence ordinary ranking misses, fits inside the prompt budget, and proves the gain without hiding a regression.

• Identity-first repair: explicit references and session continuity reconnect the hot corpus before broader topic or opt-in inferred relationships.
• Measured lift: separate direct seeds and graph targets make graph contribution impossible to fake by denominator dilution.
• Useful evidence: a neighbor must resolve to durable memory and hydrate into a bounded excerpt; dangling edges do not count.
• Clean learning history: inactive Foundry drafts can be retired with immutable operator evidence, no deletion, and no runtime mutation.

Your agent's working truth is no longer trapped on one machine.

Context Passports turn proof-carrying synthesis into a signed, bounded, expiring artifact. Context Mesh encrypts that artifact to explicit project-scoped recipients while keeping transport outside ContextLattice.

• Portable proof: objective state, claims, evidence, lineage, capabilities, redactions, and replay inputs stay bound to one signed digest.
• Trust before action: verify, diff, and dry-run replay expose exactly what arrived; imported content never becomes an executable instruction.
• Encrypted sharing: age v1 X25519 envelopes support multiple explicit recipients, signed grants, local revocation tombstones, and zero ContextLattice delivery calls.
• Conflict safety: identical imports are idempotent and divergent revisions survive as branches instead of overwriting local truth.

Outcomes became policy evidence. Repeated wins became skill drafts.

ContextLattice can now learn from completed work without quietly rewriting retrieval or installing generated behavior. Policy candidates move one phase at a time. Skill drafts must reproduce on evidence that was never used to create them.

• Outcome policy: calibration-eligible rows only, explicit policy arms, controlled canary gates, and automatic rollback advice on material regression.
• Skill Foundry: three stable verified runs, three independent holdouts, collision detection, named approval, and inactive export.
• Hard boundary: public promotion never activates runtime policy, and public export never writes into an active skill root.
• Measured control plane: median 100-outcome candidate generation 261342 ns/op; canary gate 1082 ns/op; 20-run skill draft 91512 ns/op.

Memory learned time. Synthesis inherited a burden of proof.

v3.12 can preserve what is true now, what used to be true, what replaced it, and what contests it. The new planner names the evidence a task owes before acting, while Synthesis v2 refuses to turn an uncited retrieval fragment into a confident claim.

• Temporal Claim Graph: validity, provenance, verification, contradiction, supersession, causality, branch, and commit identity survive restart.
• Adaptive planner: evidence obligations, source/query selection, token allocation, graph advice, and stop conditions remain transparent and shadow_only.
• Proof-Carrying Synthesis: every finding exposes support, opposition, temporal state, confidence decomposition, and missing proof; unsupported findings are excluded.
• Measured efficiency: the 1,000-claim lookup holdout fell from 2297993 to 33432 B/op and from 6933 to 7 allocs/op.

The smallest pack still carries proof.

v3.11.2 changes the final context boundary from an empty shell into an evidence kernel. When a full Context Pack exceeds its output contract, ContextLattice now keeps the four highest-ranked compact evidence cards and rebuilds synthesis from those citations.

• Priority: high-impact evidence survives before duplicated prompt structure.
• Truthful accounting: compiler and token-budget metadata report both pre-boundary and returned evidence counts.
• Grounded synthesis: forced-minimal packs retain non-empty findings and evidence trails without using an LLM.

Long-lived agents can find the current install.

v3.11.1 prevents a stale inherited checkout path from hiding valid Pi and Droid adapters after an in-place ContextLattice upgrade. Discovery now consults the installer-owned root and installed contract registry while preserving explicit repository selection.

• Upgrade safety: agents launched before an install refresh no longer need a manual environment rewrite to see the current runner adapters.
• Contract truth: runner capability detection can use the installed, versioned contract registry.
• Boundaries unchanged: ContextLattice still does not install third-party harnesses or auto-dispatch work.

Memory became a decision surface.

v3.11.0 adds deterministic Synthesis Packs, keeps sparse context contract-valid, labels queued retrieval as warming instead of degraded, and closes the outcome loop without letting infrastructure failures poison retrieval calibration.

• Synthesis: CLI and HTTP surfaces turn ranked evidence, topic gravity, graph links, constraints, and open questions into a bounded brief.
• Honest graph proof: project graph quality rose from 20 to 74; saved recall passed 5/5, while measured graph lift remained 0.0, so expansion stays disabled.
• Outcome loop: task completions emit deterministic idempotent outcomes, with calibration-eligible samples counted separately.
• Parity: 14 public-core capabilities and 13 agent profiles now validate across every distribution.
• Runtime: x/crypto is patched and no Python service is part of the active application path.

The feedback loop moved onto the hot path.

v3.10.2 makes /tools/feedback_submit a native Go route with bounded validation, idempotency, preference projection, telemetry, and strict ownership coverage. The active runtime no longer needs a Python backend proxy for agent feedback.

• Native route: /tools/feedback_submit is served by gateway-go.
• Safety: duplicate idempotency keys replay safely; mismatched payloads return conflict.
• Signal: /preferences and /telemetry/memory expose bounded feedback-derived state.

New installs now wire more local agents without another round trip.

v3.10.1 adds first-class OMP and Mercury agent profiles, default adoption coverage, and installer-managed instruction hooks when those harnesses are detected locally. ContextLattice still does not install third-party agent binaries.

• OMP: detected installs receive a managed ContextLattice block in the OMP user instruction file.
• Mercury: detected installs receive a managed ContextLattice block in the Mercury user instruction file.
• Adoption: contextlattice_adopt integrate, discovery, preflight, and profile parity now include omp and mercury-agent.
• Opt-out: use --no-agent-hooks or --no-install-agent-hooks to avoid writing detected third-party instruction files.

Agents can now do real local runner work without turning ContextLattice into a swarm manager.

v3.10.0 adds optional Pi and Droid runner adapters, task-worker execution through safe repo-local adapters, bounded runner-quality telemetry, and CLI-first operator guidance. ContextLattice coordinates context, contracts, checkpoints, and evidence; external runners still execute the work.

• Runner adapters: Pi and Droid stay optional, explicit, and outside Docker Compose.
• Advisor telemetry: contextlattice_runner_quality and the dashboard show bounded, task-class-aware runner evidence.
• Public interface: CLI is the primary path; dashboard, HTTP, and MCP are companion surfaces.
• Safety: no automatic dispatch, auto-merge, auto-push, raw prompt logging, or gateway-owned runner subprocesses.

The cockpit is quieter, sharper, and harder to misread.

v3.9.1 packages the dashboard polish pass after the outcome-telemetry release: stronger contrast, calmer titles, cleaner Settings, restored topic/mind-map context, and current public guidance for humans and agents landing on the project.

• Dashboard: denser proof cards, clearer disk pressure labels, and less visual noise.
• Settings: real local values, no placeholder model defaults, and paid runtime-key gating.
• Docs: public baseline, install guidance, and LLM guidance now point at v3.9.1.

Agents can now report whether the context pack actually worked.

v3.9.0 closes the loop between context allocation and real agent outcomes. Context packs now carry an outcome-report contract, the adapter can post first-pass/repair/retry facts at completion, and provider token counters stay separate from modeled inference avoidance.

• Agent contract: contextlattice_agent_adapter outcome and completion outcome flags.
• Telemetry: compact provider prompt/completion/total token counters in the quality ledger.
• Dashboard: observed provider tokens shown beside exact prompt savings and modeled avoidance.

Context packs now measure quality, not just size.

v3.8.0 separates exact prompt-token savings from confidence-banded inference avoidance. The new quality ledger records compact pack-quality rows and lets agents post first-pass, repair, retry, and follow-up-token outcomes for calibration.

• Runtime: gateway now uses the MongoDB Go driver v2 line.
• Proof: exact prompt savings stay exact; modeled inference avoidance is labeled as modeled until outcomes calibrate it.
• Storage: bounded NDJSON, no raw prompts, no raw queries, no raw source text.

MongoDB driver advisory closed for the v3.7 train.

v3.7.1 upgrades the Go MongoDB driver past the patched advisory floor while keeping tokenizer-exact prompt economics and bounded token-impact ledger persistence unchanged.

• Security: resolves GHSA-cp6g-7hqx-qxhp in the Go gateway dependency graph.
• Upgrade path: dependency-only patch; no migration required from v3.7.0.

The memory layer now proves its prompt economics with tokenizer-exact accounting.

v3.7.0 upgrades ContextLattice from directional token-savings estimates to a restart-safe prompt economics ledger. Context packs report exact tokenizer counts when the configured encoding is available, and the gateway persists compact proof rows without storing raw prompts or recalled source text.

• Exact accounting: context packs expose tokenizer_exact, estimate_method, and tokenizer_encoding.
• Bounded ledger: token-impact rows are compact, capped, and reloaded on gateway startup.
• Proof cockpit: dashboard labels exact, sampled, and heuristic token savings separately.
• Release hygiene: release notes now reject machine-local paths before publishing.

A fresh agent can now land on the README and wire ContextLattice without a second prompt.

v3.6.2 makes the public adoption path explicit: clone the canonical repo, run the quickstart, verify the gateway, integrate supported local agent profiles, and run the doctor. The release keeps ContextLattice positioned as the durable operating layer around agent memory rather than another cockpit.

• Agent prompt: README now tells AI agents reading the page to follow the install + integration section directly.
• Canonical repo: the quickstart spells out https://github.com/sheawinkler/ContextLattice.git.
• Integration guardrail: contextlattice_adopt integrate writes managed instruction blocks; it does not install third-party agents.
• Installer lane: public releases and the optional Homebrew cask now point at the v3.6.2 train.
• Operating layer: v3.6 keeps durable writes, scoped packs, Skills Index discovery, async recall steering, runtime policy, template conformance, and local-first storage under one contract.

The public lane now draws the intelligence and profile boundaries explicitly.

Dream Mode is again treated as an LLM-derived synthesis surface, not a deterministic placeholder. Lite stays small, but Local Lite keeps Qdrant-backed recall and memory edges/neighbors as core product intelligence while hosted/Glama Lite remains sidecar-free.

• Dream Mode: fails closed unless model synthesis is available.
• Hosted/Glama Lite: keeps the single-container, topic-rollups-only compliance profile.
• Local Lite: promotes Qdrant as the first-class vector lane and keeps memory edges/neighbors in the default product shape.
• Full/operator: keeps pgvector as a first-class SQL-co-located vector lane behind the same agent contract.
• Premium behavior: public docs describe paid behavior packs only as a capability; internal runtime details stay out of public release surfaces.

The public build lane now targets Go 1.26.4 end to end.

This release updates the Go module and Docker builder surface while packaging the post-v3.4.24 agent/runtime train: Go helper binaries, graph-aware context packs, Review Mode, bounded output contracts, and Qdrant-first writeback closure.

• Go toolchain: gateway and orchestrator modules now declare go 1.26 with toolchain go1.26.4.
• Container builders: Go builder stages now use exact golang:1.26.4 Alpine/Bookworm tags.
• Lite boundary: local Lite keeps topic_rollups + qdrant; hosted/Glama Lite remains topic-rollups-only and sidecar-free.
• Memory writeback: Qdrant is first-class for native writeback surfaces; pgvector remains a Full/operator SQL-co-located vector lane.

One command now tells a new agent whether ContextLattice is ready.

The adoption front door wraps install checks, runtime doctor output, profile detection, profiles, and proof output so Codex, Claude Code, OpenCode, Hermes, web agents, and custom LLM apps can start from the same local contract.

• Status: run contextlattice_adopt status --pretty to inspect gateway, helper, PATH, storage, session-store, and profile readiness.
• Install: run contextlattice_adopt install --pretty from the repo to wire global helpers and Codex hooks.
• Doctor: run contextlattice_doctor --agents codex --skip-provider-smoke --pretty for readiness, proof, and trace evidence in one bounded report.
• Proof: run contextlattice_adopt proof --agents codex --skip-provider-smoke --pretty for the bounded lifecycle proof path.
• Profiles: use contextlattice_agent_adapter profiles --pretty when moving to a new account, machine, or agent surface.

Slow recall can now steer the requesting agent when it finishes.

Staged retrieval still returns fast context first, but continuation progress is now contract-visible across HTTP, CLI, session rollups, traces, and the dashboard. Local agents can watch their own session and receive a bounded steering comment when deeper recall is warming, ready, or terminally degraded.

• Progress contract: responses include retrieval_progress.v1 with progress, confidence, source state, poll URL, and event URL.
• Agent steering: steering_comment.v1 lands in the requesting session as retrieval.continuation.progress, retrieval.continuation.ready, or terminal retrieval.continuation.degraded.
• CLI watch: contextlattice_agent_session watch --session-id <id> --continuation-token <token> --pretty gives agents a compact terminal inbox.
• Dashboard: retrieval flow shows the async lane, source states, progress, confidence, and the agent watch command.

Agent runs now come with a readiness signal, not just a transcript trail.

ContextLattice now attaches a bounded Run Advisor to context packs and session traces. Agents can see prompt readiness, continuation state, objective coherence, graph quality, and concrete next actions before handing work to the next model call.

• Run Advisor: contextlattice_run_advisor "current task" --pretty renders prompt quality, retrieval advice, continuation repair, graph status, and next actions.
• Context packs: /memory/context-pack now includes run_advisor beside ranked evidence, prompt sections, source coverage, and the reference prompt.
• Agent Radar: dashboard traces show Run Advisor posture alongside source coverage, graph touches, handoffs, checkpoints, skills, and timeline evidence.
• Graph audit: memory edge backfill now reports confidence posture, review recommendations, and inferred-candidate counts before writes.
• Safer local launch: Compose services now use scoped project names instead of global singleton container names for Ollama, Letta, Caddy, and MCP proxy helpers.

The proof cockpit can now show what shaped an agent run.

Session traces expose bounded evidence about context packages, source coverage, skills, graph touches, handoffs, checkpoints, risks, and recent timeline events without leaking raw prompts or oversized payloads.

• Trace endpoint: /v1/agents/sessions/<id>/trace returns the contract-valid run-shaping package.
• Terminal view: contextlattice_agent_trace --session-id <id> --tree renders the session as a compact operator trace.
• Run cards: contextlattice_agent_trace --session-id <id> --markdown exports a bounded Markdown handoff for the next agent or model call.
• Dashboard: Agent Radar can inspect traces and export the same run card from the app surface.

One command now proves the agent memory lifecycle across runtimes.

ContextLattice can validate that configured agent profiles share the same bootstrap, context package, checkpoint, handoff, completion, session rollup, and prompt-ready evidence path. The proof reports the skills, context, graph touches, and handoff artifacts that shaped each run.

• Matrix proof: run contextlattice_agent_adoption_proof --pretty after global install, or scripts/agent/agent-adoption-proof-matrix --pretty from the repo.
• Agent coverage: profiles include Codex, Claude Code, OpenCode, Hermes Agent, Pi, ChatGPT web/desktop, and Claude web/desktop patterns.
• Visible inputs: each case reports Skills Index hits, context-package validation, session events, graph touches, checkpoint counts, handoff counts, and reference-prompt size.
• Provider check: optional CLI smoke tests detect available external agent runners without requiring paid provider execution.

Agent runs can now package what matters for the next model call.

ContextLattice now turns a live agent session into a bounded reference package: objective, evidence, source coverage, artifacts, missing checks, risks, and next action. Agents get a sharper handoff than a transcript replay, while operators see prompt readiness in Agent Radar.

• Session rollups: /v1/agents/sessions/<id>/rollup summarizes lifecycle phases, memory contribution, source coverage, artifacts, and risk signals.
• Context package: /v1/agents/sessions/<id>/context-package emits a bounded reference prompt and structured package for the next model call.
• CLI path: contextlattice_agent_session rollup and contextlattice_agent_session context-package give local agents the lowest-overhead access path.
• Capability lookup: contextlattice_skills_index search exposes Skills Index discovery without loading every skill into startup context.
• Memory topology: contextlattice_memory_topology validates the base default path, the richer backend fabric, partition keys, clusters, and graph telemetry.
• Source backfill: the optional dev helper contextlattice_source_backfill imports bounded files, JSONL, JSON, CSV, SQLite, DuckDB/Parquet, or Postgres data through the same memory write contract.
• Runtime confidence: Agent Radar shows prompt package readiness, source coverage, missing evidence, and confidence per session.

The agent memory contract now proves itself in one command.

ContextLattice v3.4.2 adds a live proof pack for the whole agent lifecycle: bootstrap, scoped recall, checkpoint, handoff, completion, status, and runtime telemetry. Not a demo script. A contract probe.

• One command: run contextlattice_agent_runtime_proof --pretty after global install, or scripts/agent/agent-runtime-proof-pack --pretty from the repo.
• Real writes: the proof starts a real session, retrieves bounded context, writes a checkpoint, creates a handoff, and completes the session.
• Runtime evidence: the proof verifies final session status and confirms the session is visible in /telemetry/agents/runtime.
• Installer surface: macOS/Linux and Windows global installers now expose the proof command beside the universal adapter.

The agent runtime contract gets its first field hardening patch.

ContextLattice v3.4.1 tightens the local memory spine after real operator pressure: storage governance now follows the mounted data lane, Codex transcript storage gets an explicit doctor check, and the LanceDB adapter clears the public PyArrow security alert.

• Storage truth: gateway-go now receives ORCH_STORAGE_GOVERNANCE_DISK_ROOT=/data so status checks measure the memory lane, not container overlay.
• Mount guard: scripts/verify_storage_mounts.sh now rejects unset, relative, root, or overlay-oriented storage-governance roots.
• Codex doctor: session-store audits resolve symlinked transcript paths and warn on external/TCC-managed storage before resume failures look like corruption.
• Security: pyarrow is pinned to 23.0.1 for the LanceDB adapter, resolving GHSA-rgxp-2hwp-jwgg / CVE-2026-25087.

Agents now get one local memory contract instead of every stack inventing its own.

ContextLattice now gives agents a shared runtime: session identity, scoped recall, checkpoints, handoffs, objective state, behavior provenance, and completion all move through one durable local contract.

• Universal adapter: contextlattice_agent_adapter handles bootstrap, context-pack, lifecycle state, checkpoint, handoff, event, and complete flows.
• Agent discovery: contextlattice_agent_discover reports best-effort process, profile, hook, and repo-instruction evidence for local agents.
• Runtime sessions: live agent work is tracked through /v1/agents/sessions with typed events and Agent Radar telemetry.
• Objective contract: preflight, context-pack, and Dream Mode return objective_runtime_state.v1 with action, evidence, delta, risk, and next-action fields.
• Agent coverage: templates and conformance checks cover Codex, Claude Code, OpenCode, Hermes Agent, ChatGPT web/desktop, and Claude web/desktop patterns.
• Operational hygiene: stale objective-runtime audit sessions can be reviewed with contextlattice-session sweep-stale-audits --all-projects --pretty before any confirmed cleanup.

Public main now documents spike-lab as advanced opt-in with one-lane controls

We kept spike benchmarking transparent for advanced operators while reducing default-user risk: public startup remains clean, and spike-lab now has explicit lane-by-lane control and published benchmark references.

• No default runtime expansion: default profiles stay core,llm,observability.
• One-lane operator controls: gmake mem-spike-ls, gmake mem-spike-up SPIKE_LANE=<lane>, gmake mem-spike-down SPIKE_LANE=<lane>.
• Resource guardrail: documented Docker VM RSS guard policy for spike services (DOCKER_VM_RSS_GUARD_*).
• Published benchmark transparency: bench/results/backend_lane_matrix_latest.json, bench/results/memory_bank_spike_direct_matrix_latest.json, and docs/perf_v3_spike_matrix.md.
• Included commit train since v3.3.0: gateway-go telemetry route cutover, mongo_raw+mindsdb go-native sync, build-integrity restore, and env/runtime stability hardening.

Lite mode now ships sqlite WAL + FTS5 BM25 acceleration with optional sqlite-vec detection

The public lite lane was upgraded for single-container deployments: topic rollup search now uses a local sqlite acceleration index with fail-open fallback, while full multi-backend mode remains unchanged.

• Lite architecture: topic_rollups + sqlite outbox + sqlite rollup index (WAL + FTS5 BM25).
• Full architecture: staged fast lane topic_rollups + qdrant in local lite, Qdrant plus pgvector in full/operator stacks, plus deep async continuation mindsdb + mongo_raw + letta + memory_bank.
• Optional vector lane: sqlite-vec capability is auto-detected and remains fail-open when unavailable.
• Correctness guardrail: sqlite rollup search is only used when sqlite generation marker matches the active in-memory rollup snapshot.
• A/B snapshot: topic rollup lookup average 85.065ms → 50.225ms (1.694x faster) in single-container benchmark artifact bench/results/glama_lite_topic_rollup_sqlite_ab_20260324.json.

Finalized install/deployment mode copy to match staged retrieval runtime lanes

Completed a final launch-readiness docs pass so installation and deployment-mode guidance clearly reflects current v3.2 runtime behavior.

• Installation mode summaries now call out Gateway-Go frontdoor ownership.
• Lite mode now explicitly lists the fast staged lane: topic_rollups + qdrant.
• Full mode now explicitly lists deep async continuation lane sources: mindsdb + mongo_raw + letta + memory_bank.
• Release assets include DMG (macOS), MSI (Windows), and Linux bootstrap tarball.

Synced README + website diagrams to current staged retrieval/runtime ownership

Reviewed architecture graphics and corrected source-lane/runtime ownership drift so GitHub README visuals and website architecture pages now match live v3.2 behavior.

• Updated shared SVG architecture panels used by both README and website.
• Reflected current staged retrieval lanes: fast topic_rollups + qdrant in local lite, Qdrant plus pgvector for full/operator stacks, deep async mindsdb + mongo_raw + letta + memory_bank.
• Updated runtime ownership copy to show Go ingress on :8075, Rust hot path, and Python fallback on :18075.
• Bumped architecture asset cache keys so updated diagrams render immediately.

Unified configuration paths under config/ and verified Python fallback utility

We standardized configuration layout to one canonical root and completed a Python fallback audit to confirm runtime-critical Python remains justified while Go/Rust stay primary.

• Moved former configs/ content to config/mcp/ and rewired compose/script paths.
• Kept runtime lock authority at config/env/strict_runtime.env.
• Added compatibility file config/mcp/memorybank-gateway.config.json for override workflows.
• Published audit: docs/audits/python_fallback_audit_v3.2.1.md.
• Fallback lane health verified on :18075 for /health, /migration/runtime, and /memory/search.

Go-first read runtime is now default on public V3 (Python moved to fallback lane)

Public V3 now serves through gateway-go on :8075 by default, with Python retained as a rollback-only fallback lane. We also promoted full icm_spike memory-bank policy wiring into gateway runtime and moved memory-bank to async slow-source continuation.

• Primary path switch: /memory/search executes in Go staged retrieval by default; Python fallback is exposed on :18075.
• Memory-bank reliability fix: gateway now consumes ORCH_MEMORY_BANK_SEARCH_BACKEND=icm_spike and configured fallback chain.
• A/B artifact: bench/results/live_runtime_comparison_v3.2.0_cutover.json (20 interleaved runs per lane).
• Measured delta: p50 0.202s → 0.139s (31.1% faster), p95 0.429s → 0.268s (37.5% faster), mean 0.255s → 0.157s (38.5% faster).
• Result parity in benchmark: median result count 4 on both lanes with identical returned-now source mode.

Qdrant staged-fetch caps tuned by retrieval mode + compose passthrough hardening

Added mode-specific Qdrant sync timeout caps in gateway-go and exposed tuning envs in compose so operators can tune fast/balanced/deep behavior without code edits.

• New knobs: ORCH_RETRIEVAL_QDRANT_SYNC_TIMEOUT_CAP_FAST_SECS, ..._BALANCED_..., ..._DEEP_....
• A/B artifact pair: bench/results/qdrant_tuning_20260313T004405Z.json vs bench/results/qdrant_tuning_20260313T213430Z.json.
• Observed p95 delta (same harness): baseline 593.575ms → 84.843ms (~7.00x), deep-tail 995.125ms → 162.870ms (~6.11x), fast-path 686.621ms → 603.521ms (~1.14x).
• Companion matrix artifact: bench/results/perf_shortlist_matrix_20260313T213440Z.json.

Published V3 roadmap for issues #68-#72

We published the V3 execution roadmap to show how performance, deep-read stability, recall quality, and runner interoperability will be integrated and tested as one program.

• Roadmap page: roadmap.html
• Includes grouped tracks, integration scope, and benchmark + recall + security gates.
• Focus is application efficacy: more correct outcomes per request with lower tail latency.

Rust+Go runtime is now default; Python retained as legacy fallback

We ran a live A/B on the same /memory/search path before and after cutover. Test profile: tooling/python/bench/phase1_runtime_comparison.py, 8 requests, 20s timeout.

• Cutover ON (Rust+Go): mean 3557ms, p50 2334ms, p95 8494ms, p99 9359ms, errors 0/8.
• Legacy OFF (Python): mean 17565ms, p50 20006ms, p95 20008ms, p99 20008ms, errors 7/8 (timeouts).
• Observed delta: mean 4.94x faster, p50 8.57x faster, p95 2.36x faster.
• Compose defaults now start with Rust+Go enabled; Python is rollback/legacy path only.

Channel command bridge live, with optional Qdrant Cloud gRPC validation

• Added orchestrator-native messaging endpoints for OpenClaw/ZeroClaw, Telegram, and Slack command routing.
• Added command parsing for @ContextLattice remember|recall|status with project/topic directives.
• Added a one-shot 04:30 MT launch gate scheduler command and status/cancel controls.
• Added Qdrant Cloud BYO connectivity check script that validates both HTTP and gRPC paths while keeping local-first default behavior.

Public beta hardening and release packaging complete

• Added launch-readiness gate automation for authenticated load, queue drain, backup/restore drill, and production security preflight simulation.
• Published release image lockfile for reproducible deployments with pinned digest references.
• Finalized legal package (terms, privacy, DPA baseline, acceptable use, subprocessors, commercial licensing baseline).
• Published public messaging package and next-track messaging-surface expansion plan.

New integrations guide, dark visual refresh, and faster sink fanout tuning

• Added a dedicated Integrations page for ChatGPT app, Claude chat apps (desktop and web), Claude Code, Codex, and OpenClaw/ZeroClaw wiring.
• Moved public overview pages to a dark-first theme and aligned navigation across Home, Architecture, Updates, Installation, and Troubleshooting.
• Expanded compose env passthrough for fanout and Mongo pool tuning to speed queue drain and improve sustained write throughput.
• Documented the default launch path (gmake mem-up) and explicit full/lite commands for local-first deployment.

Landing page now explains each service and why it exists

• Added component-by-component breakdown for Orchestrator, Memory Bank, Qdrant, Mongo, MindsDB, Letta, outbox, and retention.
• Added explicit “benefit + why” summaries so operators understand service intent at a glance.
• Connected these components directly to learning retrieval outcomes and ranking quality over time.

New pilot landing page published

We shipped a new public pilot page with a clearer value narrative and current platform capabilities.

• Headline focus: fix context drift before it burns token budget.
• Pilot structure: week-by-week baseline, optimization, and ROI readout.
• Capability highlights: coalesced fanout, backlog-aware Letta admission, and sink retention.
• Trust framing: private-by-default, BYOK-compatible, local-first operation.

Orchestrator learning schema + Letta RAG emphasis

The orchestrator becomes more accurate over time by learning from feedback signals and applying preference-aware reranking during retrieval. This learned ranking is further supported by RAG via Letta archival memory, alongside Qdrant semantic recall and raw-source fallbacks.

• Learning loop reinforces what sources and patterns are actually useful in your workflows.
• Federated retrieval merges Qdrant, Mongo raw, MindsDB, Letta, and memory-bank lexical fallback.
• Result quality improves iteratively as the learning schema accumulates real operator feedback.

Queue and storage safety upgrades

• Fanout coalescer reduces duplicate hot-file writes before they hit outbox depth.
• Letta admission control protects throughput by shedding low-value Letta writes under backlog.
• Low-value retention sweeps for Qdrant and Letta keep storage pressure bounded.
• Shared HTTP client pools and batched fanout improve write-path efficiency.