Product updates

A healthy container is not enough when retrieval stalls behind an unindexed filter.

• Large-store proof: bounded retrieval was exercised against more than 707,000 live points without restart or OOM churn.
• Security baseline: the shipped dashboard dependency tree reports zero known npm audit vulnerabilities.
• Honest macOS lane: unsigned artifacts remain available as technical previews, never presented as notarized consumer downloads.

A self-healer should restore the service, not fight the machine beneath it.

• One outage, one attempt: gateway and VM recovery both latch until full health returns.
• Graceful means graceful: the supervisor has no force-stop or process-kill path.
• Truthful operations: unload failures retain configuration and report failure instead of manufacturing success.

The intelligence layer now ships a dashboard with no development-mode disguise.

• No HMR theater: production startup removes Fast Refresh, development overlays, and surprise runtime package fetching.
• No false alarms: local mode skips hosted-only billing probes while retaining the complete runtime status surface.
• No horizontal escape: project and topic identifiers wrap without flattening the hierarchy or shrinking the graph.

The intelligence layer can now prove what it is, where it runs, and what every lane includes.

• CLI first: installation, adoption, context, continuity, correction, and diagnosis all begin from one prescribed interface.
• Visible intelligence: the dashboard exposes continuity, explainable retrieval, portable context, verified learning, and controlled Aggregate Signal truth.
• Forward-only release proof: immutable tags, lane projections, installers, Homebrew, and the live site must agree before a release is called current.

Fail closed. Not false closed.

• Same runtime: Aggregate Signal behavior, consent, suppression, accounting, and product boundaries were unchanged.
• Sharper gate: the public status shim was accepted while every real paid governance marker remained forbidden.
• Immutable lineage: v4.0.0 remains untouched and asset-free; v4.0.1 is preserved as the installer-complete first public v4 release.

Memory that compounds without giving itself away.

• Local by default: preview, queue, accounting, reporting, and opt-out perform zero external network calls.
• Privacy has hard edges: clipping, cohort suppression, composition budgets, replay rejection, expiry, and revocation are enforced contracts.
• No fake finish line: paid production contribution/reporting remains blocked while independent attack and utility reviews are pending.

Open an agent. Already there.

• Zero-entry manifest: packet, checkpoint, profile, preparation, repository commit, provenance, risks, and next move share one digest.
• Fail-closed continuity: multiple objectives abstain; stale or conflicting evidence rejects rather than guessing.
• Execution stays external: entitled automation governs push and workspace-preparation intent, not transport, runners, Git, or worktrees.

Memory now compounds into capability.

• Proof-qualified candidates: discovery joins persisted utility and session evidence before Foundry handoff.
• Atomic evolution: workflow material, evaluation, and updated draft commit as one replay-safe transaction.
• Human-governed lifecycle: activation, replacement, retirement, monitoring, and exact-receipt rollback require explicit approval.

The work can move. The trust boundary does not.

• Least privilege: collaborative grants are recipient-, project-, purpose-, time-, usage-, delegation-, and revocation-bound.
• Proof-preserving movement: deterministic import plans retain provenance while external workers own execution.
• No sync-service creep: ContextLattice stores neither continuation plaintext nor ciphertext and performs no delivery.

The memory layer learned how each agent works.

• Live steering: durable events, replay cursors, acknowledgements, backpressure, and honest pull fallback survive reconnects.
• Adaptive briefings: explicit, stored, and generic profiles resolve deterministically against capabilities and context limits.
• Execution boundary: selection receipts are advisory; external workers retain cwd, process, approval, model, and mutation ownership.

Retrieval policy stopped running on vibes.

• Evidence-gated policy: same-snapshot simulation and promotion receipts separate predicted deltas from observed outcomes.
• Reversible memory evolution: retirement, contradiction resolution, and hot/warm/deep/retired movement preserve history and legal holds.
• Governed scale: Operator and Enterprise add scoped activation, canaries, review queues, due schedules, and bounded batches.

Recall stopped being a black box.

• Trust isolation: prompt overrides, secret exfiltration, encoded instructions, destructive claims, and coordinated risky paraphrases fail closed.
• Counterfactual proof: same-snapshot ablation reports exact result, rank, and citation deltas without inventing utility.
• Learning with brakes: verified outcomes create review-only regressions and advisory evidence reputation, never silent promotion.
• CLI first: inspect Context Pack receipts locally and govern entitled operations with contextlattice retrieval-governance.

The artifact gate passed. The claim gate did not. Nothing shipped.

• One metric contract: causal utility, exact denominators, latency, cost, storage, failures, rollback, review, and entitlement proof travel together.
• Clean product boundary: Starter and Team keep read analytics; governed efficiency-policy operations require Operator or Enterprise.
• Failure stays evidence: the paid v3.20.2 tag remains immutable and asset-free instead of being patched in place.
• CLI first: local utility receipts remain available from the primary command-line workflow.

The comparator found one line of drift. Nothing shipped.

• One test source: canonical and public-paid now prove commercial truth and storage controls with byte-identical code.
• No boundary blur: developer-only configuration remains excluded from every paid artifact.
• No artifact roulette: the paid candidate must match the approved release proof before compilation begins.
• No quiet rewrite: the failed paid patch stays asset-free and v3.20.2 receives a fresh immutable proof chain.

The gate caught the drift. The patch killed the loophole.

• Current means current: the active T3 activation, tested source, evidence hashes, and release provenance must agree.
• History stays provable: older T2 evidence verifies from immutable hashes without hijacking the current-release record.
• No gate weakening: the failed paid release remains asset-free; runtime behavior is unchanged.
• One product truth: public, paid, and development lanes share the v3.20.1 patch baseline.

Context economics grew a spine.

• Exact where exact matters: model-visible ContextLattice tokens never blend with wire or provider totals.
• Two actors, one witnessed result: reporting and verification are distinct CLI receipts, with self-verification rejected.
• Failure is data: negative gains, exclusions, timeouts, costs, and tool calls remain in the ledger.
• Policy stays advisory: paid gates can recommend; they cannot silently rewrite retrieval behavior.

The release gate stayed sharp.

• Shared means identical: every approved shared proof source now matches byte for byte.
• Private means private: Frontier program regression logic executes only in the private proof lane.
• No ghost release: the failed v3.19.1 paid artifact remains empty and is superseded by v3.19.2.
• No runtime drift: packet, proof, session, storage, entitlement, and rollback behavior is unchanged.

Complete means complete.

• Panic removed: complete and fail accept a flag-only summary safely.
• Canonical lifecycle: the CLI emits session.completed and session.failed.
• Backward-compatible repair: the gateway canonicalizes legacy singular aliases before applying terminal state.
• No product-boundary drift: storage, entitlement, packet, proof, and integration contracts remain unchanged.

Less context baggage. More evidence.

• Digest-verified deltas: acknowledged bases, canonical operations, tombstones, and reconstruction digests preserve exact model-visible context.
• Safe fallback: stale, tampered, mismatched, expired, or uneconomic bases return the full packet instead of gambling on compression.
• Proof without theater: absent or corrupt evidence becomes an explicit gap; provider calls and authoritative mutations remain outside the projection.
• Governed collaboration: paid shared retention and workspace timelines require entitlement, bounded storage, receipts, and explicit rollback.

Agents stop starting over.

• Holdout-proven continuity: the locked scorer resolves the release holdout with zero false merges and no provider calls.
• Living objective history: shared graphs expose bounded nodes, edges, and transitions without flattening time.
• Witnessed decisions: independent review and immutable core anchors travel with every governed change.
• Hard rollback: force-disable, restart, functional deactivation, and previous-image recovery preserve stored evidence.

State stops haunting recall.

• Latest-only by construction: state mirrors overwrite their canonical file and never enter ordinary history, rollups, graph confidence, or semantic fanout.
• Source-agnostic suppression: the gateway filters stale state at the final retrieval boundary, regardless of which backend returned it.
• Bounded privacy repair: owner-only migration streams fixed-size batches, persists durable receipts, and keeps startup responsive.
• No registry, no guess: readers retain safety instead of treating missing classification as permission to index everything.

The boundary caught the residue. The patch made the boundary permanent.

• No tag games: the failed release remains immutable and the correction ships as a new patch.
• No runtime churn: every v3.17.3 storage, approval, temporal, routing, and ownership hardening remains unchanged.
• No porous boundary: public artifact builds reject paid machine-binding vocabulary before packaging.

Before memory gets more magical, its floor gets harder.

• Owner-only means owner-only: sensitive files use restrictive POSIX modes or protected Windows ACLs, with bounded resumable migration and symlink containment.
• No approval, no work: blocked tasks stop before routing, context expansion, inference, adapters, or memory writeback.
• Advice earns its confidence: sparse runners stay visible, but recommendations require a real sample floor.
• History stays honest: retracted claims leave default current-state recall while remaining explicitly queryable.
• One contract, one gateway: task guidance uses canonical routes and strict native ownership is tested against the registered mux.

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

• 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.

• 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 local development stays keyless only in an explicit non-production, feature-complete mode; production authorization rejects that bypass.
• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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: 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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

• 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

• 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

• 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

• 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

• 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)

• 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

• 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

• 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

• 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.

Messaging bridge + Qdrant Cloud validation

• Added native OpenClaw/ZeroClaw, Telegram, and Slack command routes.
• Added @ContextLattice remember|recall|status with project/topic directives.
• Added one-shot launch-gate scheduling with status and cancel controls.
• Added BYO Qdrant Cloud HTTP + gRPC validation; local-first remains default.

Public beta release gates

• Automated authenticated load, queue drain, restore, and security preflight gates.
• Published a digest-pinned release image lockfile.
• Finalized terms, privacy, DPA, acceptable-use, subprocessor, and licensing baselines.
• Published public messaging and its next expansion track.

More integrations; faster fanout

• Added wiring guides for ChatGPT, Claude, Claude Code, Codex, and OpenClaw/ZeroClaw.
• Aligned public pages on one dark-first theme and navigation.
• Expanded fanout and Mongo pool tuning for faster sustained writes.
• Documented gmake mem-up plus explicit full/lite launch commands.

Each service now explains its job

• Mapped Orchestrator, Memory Bank, Qdrant, Mongo, MindsDB, Letta, outbox, and retention.
• Added one-line benefit and purpose summaries.
• Connected each service to retrieval and ranking outcomes.

New pilot landing page published

• 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

• 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 guards

• Fanout coalescing removes duplicate hot-file writes before outbox.
• Letta admission sheds low-value writes under backlog.
• Qdrant and Letta retention sweeps bound storage pressure.
• Shared HTTP pools and batched fanout reduce write overhead.