ltcai 11.5.1 → 11.5.2

package/README.md

@@ -11,7 +11,7 @@
 [![CI Status](https://github.com/TaeSooPark-PTS/LatticeAI/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/TaeSooPark-PTS/LatticeAI/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 
-![v11.5.1 Living Brain walkthrough](output/release/v11.5.1/gifs/v11.5.1-living-brain-walkthrough.gif)
+![v11.5.2 Living Brain walkthrough](output/release/v11.5.2/gifs/v11.5.2-living-brain-walkthrough.gif)
 
 Chat, files, folders, notes, and web pages all flow into one durable knowledge
 graph on your computer. Any model — local MLX or cloud — can speak with that
@@ -24,10 +24,10 @@ memory. Nothing leaves your machine without explicit consent.
 
 | | |
 | --- | --- |
-| **See your Brain's story in time** — a growth curve, an activity heatmap, and each day's story, rewindable to any past moment ![Brain Chronicle](output/release/v11.5.1/screenshots/13-chronicle.png) | **Chat with a Brain that remembers** — every conversation grows durable, source-linked memory ![Brain Chat](output/release/v11.5.1/screenshots/04-brain-chat-home.png) |
-| **See how knowledge connects** — a real relationship graph, not a file list ![Memory Graph](output/release/v11.5.1/screenshots/05-memory-graph.png) | **Capture anything** — files, whole folders, notes, screenshots, web pages ![Capture](output/release/v11.5.1/screenshots/06-capture.png) |
-| **Automate with review** — agent changes become proposals you approve first ![Review Center](output/release/v11.5.1/screenshots/12-review-center.png) | **Pick a model in one click** — recommended local models for your hardware ![Recommended Models](output/release/v11.5.1/screenshots/02-recommended-models.png) |
-| **Watch a file become memory** — three named steps, not a pipeline diagram ![Material to memory](output/release/v11.5.1/screenshots/11-knowledge-journey.png) | **Say how much it may do alone** — one dial in plain words; dangerous actions stay blocked either way ![Settings](output/release/v11.5.1/screenshots/08-system.png) |
+| **See your Brain's story in time** — a growth curve, an activity heatmap, and each day's story, rewindable to any past moment ![Brain Chronicle](output/release/v11.5.2/screenshots/13-chronicle.png) | **Chat with a Brain that remembers** — every conversation grows durable, source-linked memory ![Brain Chat](output/release/v11.5.2/screenshots/04-brain-chat-home.png) |
+| **See how knowledge connects** — a real relationship graph, not a file list ![Memory Graph](output/release/v11.5.2/screenshots/05-memory-graph.png) | **Capture anything** — files, whole folders, notes, screenshots, web pages ![Capture](output/release/v11.5.2/screenshots/06-capture.png) |
+| **Automate with review** — agent changes become proposals you approve first ![Review Center](output/release/v11.5.2/screenshots/12-review-center.png) | **Pick a model in one click** — recommended local models for your hardware ![Recommended Models](output/release/v11.5.2/screenshots/02-recommended-models.png) |
+| **Watch a file become memory** — three named steps, not a pipeline diagram ![Material to memory](output/release/v11.5.2/screenshots/11-knowledge-journey.png) | **Say how much it may do alone** — one dial in plain words; dangerous actions stay blocked either way ![Settings](output/release/v11.5.2/screenshots/08-system.png) |
 
 ## Why Lattice AI
 
@@ -58,63 +58,94 @@ First-run flow — wake the Brain, pick the owner, load a recommended model:
 
 | | | |
 | --- | --- | --- |
-| ![Login](output/release/v11.5.1/screenshots/01-login.png) | ![Model install](output/release/v11.5.1/screenshots/03-install-load-progress.png) | ![Model library](output/release/v11.5.1/screenshots/07-model-library.png) |
+| ![Login](output/release/v11.5.2/screenshots/01-login.png) | ![Model install](output/release/v11.5.2/screenshots/03-install-load-progress.png) | ![Model library](output/release/v11.5.2/screenshots/07-model-library.png) |
 
 Screenshot index and capture notes:
-[output/release/v11.5.1/SCREENSHOT_INDEX.md](output/release/v11.5.1/SCREENSHOT_INDEX.md)
+[output/release/v11.5.2/SCREENSHOT_INDEX.md](output/release/v11.5.2/SCREENSHOT_INDEX.md)
 
 ## Current Release
 
-The current release is **11.5.1 — Rust Full Loop**:
-
-The two explicitly-remaining items are done: the agent loop orchestrator
-now runs in Rust — proven by replaying the real Python runtime on scripted
-LLM transcripts (**10 trajectories, byte-identical**) and by a live smoke
-against the real worker — and the document-generation context builder is
-native (53 new goldens, 247 total). Every Rust box in the target diagram
-is implemented; Python remains exactly the AI Worker that diagram draws:
-LLM inference, tool-handler execution, and all graph writes behind three
-new fully-covered worker seams with server-side circuit breakers intact.
-
-- **The desktop's front door is now the Rust gateway.** The Tauri shell
-  boots the supervisor + gateway topology by default and the webview
-  lives at the gateway origin. The one real blocker — a CSRF policy
-  bound to the worker's own port — is dissolved by environment
-  injection, proven live against the real Python worker (trusted
-  origins 200, foreign origins 403). Three escape hatches preserve the
-  previous topologies.
-- **The native surface grew fourfold.** `lattice-retrieval` now serves
-  the three-channel service search, graph reads (search /
-  relationships / traverse), the full history read family, and the
-  chat context assembler — **191/191 exact-parity goldens, zero
-  epsilon**. `lattice-ingest` carries the typed chunker (332 golden
-  chunks, and a 26/26 mutation-test pass proving every constant
-  load-bearing) plus the polling folder watcher; writes stay delegated
-  to the worker, the single writer. `lattice-agent` carries the
-  permission kernel — **2,452 exact decision-table verdicts** — and
-  natively executes only validated read-only commands in a replaced
-  environment. `lattice-jobs` closes a documented gap: the durable
-  embed queue now has a scheduler (60s ticks, honest backoff,
-  `/host/jobs` status) driving a new fully-covered drain endpoint.
-- **The honest boundary, stated.** The Python worker keeps the document
-  parser matrix, embedding production, LLM inference, mutating tool
-  execution, and all graph writes. The agent loop orchestration port
-  remains for a future release, for reasons written down in the plan.
-
-All of it lands with the floor intact: **6,861 Python + 1,761 frontend
-tests at 100.00% statement and branch coverage — now 7,006 Python +
-1,761 frontend — and 739 Rust workspace tests**, four bidirectional golden families, mypy/ruff/clippy clean,
-verified on macOS 3.14 and a fresh-resolve python 3.11 environment.
+The current release is **11.5.2 — Tight Ship**:
+
+A cleanup-and-correctness release built from three audits of the settled
+11.5.1 tree — a Rust↔Python duplication map, an arc-level dead-code and
+test audit, and a live front-door parity sweep across 192 endpoints
+(gateway vs. direct worker). The duplication map's verdict was that the
+boundary itself is sound: **zero cross-boundary deletions**, because every
+twin is either the live Python-direct surface or a copy pinned by a parity
+golden. The real duplication was inside each language, and that is what
+this release removes.
+
+- **About 1,100 lines gone.** Six moved-module shims, a multimodal
+  streaming seam that was never wired, roughly 27 zero-caller symbols
+  whose only callers were their own tests, an interface method
+  (`metadata_for`) no consumer ever called, a dead measurement script,
+  and the **legacy Electron shell** — superseded by Tauri, yet still
+  shipping inside the npm tarball. Every deletion came with per-assertion
+  test surgery so the 100% line **and** branch floor never moved, and a
+  new guard forbids the `sys.modules[__name__]` shim pattern from coming
+  back. The 183 coverage work-package test files were all verified
+  load-bearing (ten of them are the sole owners of 79 branch arcs); seven
+  coverage-redundant feature tests were deliberately kept for their
+  regression value.
+- **One home per thing.** The byte-identical embedder pair is
+  single-sourced on the golden-pinned copy — silent vector drift between
+  two write paths was the failure mode. The workspace selector's four
+  verbatim re-derivations now use the canonical rule, an intended
+  behaviour change: chat, agent, upload, computer-use and admin **403 on
+  disagreement** where the copies silently preferred the header. sha256,
+  SSE frame builders, the data-dir default, the mode services and the
+  module-importability probe each collapsed to one implementation, and
+  seven byte-identical Rust copies were consolidated (including a
+  wholesale duplicate of `clock.rs`).
+- **The front door, fixed with live before/after proof.** Proxied
+  redirects now pass through with `Set-Cookie` and `Location` intact —
+  the invite gate was a hard dead-end, SSO login silently never
+  authenticated, and twelve deep links lost their fragment. Absolute
+  `Location` values naming the internal worker are rewritten to the
+  gateway origin. The native `/rust/*` and `/host/status|jobs` lanes are
+  **posture-gated fail-closed**: they used to serve the whole graph
+  unauthenticated while the worker required auth. `X-Forwarded-For/Proto/
+  Host` cross the hop and are honoured only from a loopback or listed
+  trusted-proxy peer, which fixes `--no-spawn` CSRF refusals and the
+  invite links, notifications and SSO URLs that named the internal worker
+  port. The supervisor injects CORS origins alongside the CSRF ones,
+  stale `ws://` CSP entries are gone, and the Tauri shell no longer
+  navigates to a dead origin when the gateway fails to bind.
+- **What the audits surfaced.** `POST /api/search/graph` was allow-listed
+  but unreachable until now; `GET /api/ingestion/multimodal` was
+  documented but unwired. Two golden families were added: a `recent_chat`
+  family pinning the `build_recent_chat_context` the live `/chat` path
+  actually calls — it caught a real divergence, where Python's `limit=0`
+  tail slice keeps everything and Rust returned empty (**Python is the
+  reference; Rust was fixed**) — plus `document_targets` and
+  `agent_profiles` helper goldens, 97 rows. The corpus stands at **251
+  golden files**.
+- **The boundaries, stated plainly.** The native lanes are an
+  open-posture, single-local-owner surface (a closed or unknown posture
+  answers 401). The recent-chat context seam is still owned by the ad-hoc
+  prepends in `/chat` rather than the assembler — wiring it changes the
+  shape of a live prompt, which is a minor-release item, not something to
+  ship quietly here. `workspace_scope_from_request` itself remains
+  lenient for its two remaining callers. And the proxy hop deliberately
+  carries no request timeout: a blanket timeout would kill long-lived SSE.
+
+The floor holds: **7,022 Python tests (11 skipped) at 100.00% statement
+and branch coverage — 40,307 statements, 10,970 branches, `fail_under=100`
+with the pragma budget untouched — 1,761 frontend tests across 101 files
+at 100% on all four metrics, and 760 Rust workspace tests**, with the
+OpenAPI schema regenerated at 421 paths and the whole suite re-verified in
+a fresh-resolve Python 3.11 environment.
 
 Release notes: [RELEASE.md](RELEASE.md) · Full history: [docs/CHANGELOG.md](docs/CHANGELOG.md)
 
-Expected artifacts for 11.5.1 release must use exact filenames:
+Expected artifacts for 11.5.2 release must use exact filenames:
 
-- `dist/ltcai-11.5.1-py3-none-any.whl`
-- `dist/ltcai-11.5.1.tar.gz`
-- `ltcai-11.5.1.tgz`
-- `dist/ltcai-11.5.1.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_11.5.1_aarch64.dmg`
+- `dist/ltcai-11.5.2-py3-none-any.whl`
+- `dist/ltcai-11.5.2.tar.gz`
+- `ltcai-11.5.2.tgz`
+- `dist/ltcai-11.5.2.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_11.5.2_aarch64.dmg`
 
 Do not use wildcard artifact uploads. Package registry publishing remains owner-run.
 
@@ -149,6 +180,7 @@ See [ARCHITECTURE.md](ARCHITECTURE.md) for details and
 
 | Version | Theme |
 | --- | --- |
+| 11.5.2 | Tight Ship |
 | 11.5.1 | Rust Full Loop |
 | 11.5.0 | Rust Complete |
 | 11.4.0 | Rust Foundation |

package/docs/CHANGELOG.md

@@ -4,6 +4,60 @@ The top entry is either the current unreleased main-branch work or the current
 release line. Older entries are historical and may describe behavior as it
 existed at that release.
 
+## [11.5.2] - 2026-08-12 — Tight Ship
+
+### Added
+- `POST /api/search/graph` — 세 번째 검색 채널의 라우트. 허용 목록에는
+  있었지만 도달 경로가 없었습니다(감사 산출).
+- `GET /api/ingestion/multimodal` — FEATURE_STATUS가 사용자 표면으로
+  기술하던 멀티모달 상태 조회를 실제 라우트에 배선.
+- 골든 신규 2계열(코퍼스 총 **251 파일**): 실제 `/chat`이 호출하는
+  `build_recent_chat_context`를 못박는 `recent_chat`, 그리고
+  `document_targets`/`agent_profiles` 헬퍼 97행.
+- 재발 금지 가드: `latticeai/` 아래 `sys.modules[__name__]` shim 패턴
+  금지(legacy-debt 게이트 확장).
+- `scripts/bump_version.py`가 rust workspace **여섯 크레이트 전부**를
+  두 Cargo.lock에서 동기화합니다(11.5.0 이후 Phase 2/3/4 크레이트 세
+  개가 매 bump마다 스테일로 남아 테스트 실행이 트리를 더럽혔습니다).
+
+### Changed
+- **워크스페이스 선택자 통합(동작 변경, 의도됨)**: chat/agent/upload/
+  computer-use/admin의 축자 재구현이 정본 규칙을 사용합니다 — 헤더와
+  쿼리가 불일치하면 조용히 헤더를 택하는 대신 **403**.
+- 임베더 byte-identical 쌍을 골든에 못박힌 사본으로 단일화(두 쓰기
+  경로 사이의 조용한 벡터 드리프트가 실패 양식이었습니다).
+- sha256 헬퍼·SSE 프레임 빌더(출력 byte-identical)·데이터 디렉터리
+  기본값·모드 서비스 삼형제·모듈 임포트 프로브를 각각 한 곳으로.
+- Rust byte-identical 사본 7건 통합(통째로 복사돼 있던 `clock.rs` 포함).
+  `lattice-agent`의 독립 `pystr`는 의도된 경계로 유지.
+- `recent_chat` 골든이 실제 발산을 잡아냄: Python의 `limit=0` 꼬리
+  슬라이스는 전부를 남기는데 Rust는 빈 결과를 돌려주고 있었습니다.
+  **Python이 기준**이며 Rust를 수정했습니다.
+
+### Fixed
+- **프록시 리다이렉트**: 3xx가 `Set-Cookie`·`Location`을 온전히 달고
+  통과합니다. 초대 게이트의 막다른 길, SSO 로그인이 조용히 인증되지
+  않던 문제, 딥링크 12개의 프래그먼트 분실이 함께 해소됩니다. 내부
+  워커 오리진을 가리키는 절대 `Location`은 게이트웨이 오리진으로
+  재작성됩니다.
+- **네이티브 레인 posture 게이팅(fail-closed)**: `/rust/*`와
+  `/host/status|jobs`는 워커가 인증을 요구하는 상태에서 그래프 전체를
+  무인증으로 서빙하고 있었습니다. posture가 닫힘/알 수 없음이면 401.
+- **프록시 신원**: `X-Forwarded-For/Proto/Host`가 홉을 건너가고, 루프백
+  또는 `LATTICEAI_TRUSTED_PROXIES` 피어에서 온 것만 존중됩니다.
+  `--no-spawn` CSRF 거절과 내부 워커 포트를 적어 보내던 초대 링크·
+  권한 알림·SSO 리다이렉트 URL이 고쳐집니다.
+- 수퍼바이저가 CSRF 오리진과 나란히 CORS 오리진도 주입합니다.
+- 존재하지 않는 WebSocket 엔드포인트를 가리키던 CSP `ws://` 항목 제거.
+- 게이트웨이 바인드 실패 시 Tauri 셸이 죽은 오리진으로 이동하지 않습니다.
+
+### Removed
+- 이사 간 모듈 shim 6종, 배선된 적 없는 멀티모달 스트리밍 시임,
+  호출자 0 심볼 약 27개(삭제마다 테스트 수술 동반), 소비자 없는
+  `metadata_for` 인터페이스(ABC + 구현 4곳), 죽은 측정 스크립트,
+  그리고 npm tarball에 아직 실려 나가던 **레거시 Electron 셸**
+  (Tauri가 대체) — 약 1,100줄.
+
 ## [11.5.1] - 2026-08-12 — Rust Full Loop
 
 ### Added

package/docs/COMMUNITY_AND_PLUGINS.md

@@ -1,6 +1,6 @@
 # Community And Plugins
 
-Current release: **11.5.1 — Rust Full Loop**.
+Current release: **11.5.2 — Tight Ship**.
 
 LatticeAI defines the path from a strong local-first framework (8.4.0
 action-aware baseline, 8.5.0 registry+DI hardening, 8.6.0 capture/navigation

package/docs/DEVELOPMENT.md

@@ -3,7 +3,7 @@
 > **Status: canonical** — current contributor guidance, kept in sync with the
 > current release.
 
-Current release: **11.5.1 — Rust Full Loop**.
+Current release: **11.5.2 — Tight Ship**.
 
 This document is for contributors working on the local-first Digital Brain
 codebase. Product positioning and quick start stay in `README.md`; release

package/docs/HYBRID_CLOUD_KG_STREAMING.md

@@ -43,10 +43,14 @@ POST /api/network-boundary/policy
 Users approve cloud-derived memory growth in the existing Review Center.
 
 ### Multimodal / video
-`latticeai/services/multimodal_streaming.py`:
-- Same `NetworkBoundaryMode.CLOUD_ALLOWED` gate
-- Additional `allow_multimodal` policy flag
-- Adapter protocol for future Runway/Luma/Veo-compatible providers
+There is no cloud multi-modal *streaming* path. A `multimodal_streaming` module
+was written to a provider-adapter shape and never wired to a provider or a
+route; 11.5.2 deleted it rather than keep a design sketch reading as a feature.
+
+Multi-modal ingestion itself is local and unrelated to this document's cloud
+boundary — see `lattice_brain/ingestion/routing.py` and the `allow_multimodal`
+gate. If a cloud video provider ever lands, the module is recoverable from git
+history (`latticeai/services/multimodal_streaming.py`, removed in 11.5.2).
 
 ### UI
 `NetworkBoundaryPanel` (React) + `GET /api/network-boundary/ui-state`:

package/docs/MULTI_AGENT_RUNTIME.md

@@ -6,7 +6,7 @@ operationalized in v2.2.0. It sits
 and coordinates a pipeline of named **roles** that hand off work to one another,
 retry on a failing review, and emit a fully observable, replayable timeline.
 
-- **Source of truth:** `latticeai/core/multi_agent.py`
+- **Source of truth:** `lattice_brain/runtime/multi_agent.py`
 - **HTTP surface:** `latticeai/api/agents.py`
 - **Persistence / Knowledge Graph integration:** `latticeai/core/workspace_os.py`
   (`WorkspaceOSStore.record_agent_run`, `replay_agent_run`, `list_handoffs`)

package/docs/ONBOARDING.md

@@ -1,6 +1,6 @@
 # Lattice AI Onboarding
 
-Current release: **11.5.1 — Rust Full Loop**.
+Current release: **11.5.2 — Tight Ship**.
 
 The first-run goal is a five-minute path from "I opened the app" to "my Brain
 has a source, a question, and proof." This page is the product contract behind

package/docs/OPERATIONS.md

@@ -1,4 +1,4 @@
-# Lattice AI — Operations Guide (v11.5.1)
+# Lattice AI — Operations Guide (v11.5.2)
 
 > **Status: canonical** — kept in sync with the current release. Storage layout
 > below reflects the SQLite live Brain store and workspace scoping, not the

package/docs/TRUST_MODEL.md

@@ -1,6 +1,6 @@
 # Lattice AI Trust Model
 
-Current release: **11.5.1 — Rust Full Loop**.
+Current release: **11.5.2 — Tight Ship**.
 
 Lattice AI is local-first, explicit about external communication, and honest
 when a capability is unavailable.

package/docs/WHY_LATTICE.md

@@ -1,6 +1,6 @@
 # Why Lattice AI Exists
 
-Current release: **11.5.1 — Rust Full Loop**.
+Current release: **11.5.2 — Tight Ship**.
 
 **Lattice AI is a local-first Digital Brain that keeps your knowledge durable
 across any AI model.**

package/docs/WORKFLOW_DESIGNER.md

@@ -8,7 +8,7 @@ node to an injected *runner* that calls the real tool registry, skill registry,
 plugin registry, or multi-agent orchestrator.
 
 The execution model lives in
-[`latticeai/core/workflow_engine.py`](../latticeai/core/workflow_engine.py)
+[`lattice_brain/workflow.py`](../lattice_brain/workflow.py)
 (pure logic with injected runners) and the HTTP surface lives in
 [`latticeai/api/workflow_designer.py`](../latticeai/api/workflow_designer.py).
 Persistence reuses the existing `WorkspaceOSStore`, so pre-2.0 workflow history

package/docs/architecture.md

@@ -7,10 +7,10 @@
 > are intentionally frozen at that point in time.
 
 > v3.6.0 — **Knowledge Graph First.** Every data source converges into the graph
-> through one unified ingestion pipeline (`latticeai/services/ingestion.py`), with
+> through one unified ingestion pipeline (`lattice_brain/ingestion/pipeline.py`), with
 > formalized entities/relationships (`docs/kg-schema.md`), browser/web inputs,
 > per-node provenance, and local export/import/backup
-> (`latticeai/services/kg_portability.py`). The agent ecosystem, long-term memory,
+> (`lattice_brain/portability/`). The agent ecosystem, long-term memory,
 > and skills/hooks/tool/MCP registries are all operable from `/app`. Enterprise
 > controls remain future work.
 
@@ -158,8 +158,8 @@ Basic mode and advanced mode have the same feature access.
 | `knowledge_graph.py` | Graph storage, extraction, local folder knowledge graph context |
 | `latticeai/core/context_builder.py` | Graph context for generation |
 | `latticeai/core/workspace_os.py` | Workspace state, timeline, snapshots, durable context |
-| `latticeai/core/multi_agent.py` | Planner/executor/reviewer/researcher orchestration |
-| `latticeai/core/workflow_engine.py` | Workflow definitions and run history |
+| `lattice_brain/runtime/multi_agent.py` | Planner/executor/reviewer/researcher orchestration |
+| `lattice_brain/workflow.py` | Workflow definitions and run history |
 | `latticeai/core/plugins.py` | Plugin manifest, registry, permission boundary |
 | `latticeai/core/security.py` | Local security primitives |
 

package/docs/kg-schema.md

@@ -1,6 +1,6 @@
 # Knowledge Graph Schema
 
-Current release: **11.5.1 — Rust Full Loop**.
+Current release: **11.5.2 — Tight Ship**.
 
 명세 출처: `lattice_ai_full_spec.pptx` 슬라이드 20·21·22
 구현: `lattice_brain/graph/schema.py`

package/docs/v11.5.2_TIGHT_SHIP_PLAN.md

@@ -0,0 +1,144 @@
+# v11.5.2 — Tight Ship (design plan)
+
+Three audits ran against the settled v11.5.1 tree: AUDIT-A (Rust↔Python
+duplication map), AUDIT-B (dead code and no-longer-needed tests, arc-level
+verified against the 100% line+branch gate), AUDIT-C (live front-door parity:
+Rust gateway vs. direct Python worker, 192-endpoint sweep plus targeted
+batteries). This plan is the design synthesis; implementation is delegated in
+two waves. Nothing in this release changes the migration's final form: Python
+remains the AI Worker and the sole client-facing implementation of every
+`/api/*` route; the Rust surface stays pinned by parity goldens.
+
+## Audit verdicts that shape the release
+
+1. **Cross-boundary duplication is all by design.** Every Rust module's Python
+   twin either serves a live route in Python-direct mode or feeds a parity
+   golden. Zero cross-boundary deletions. The real duplication is intra-Python
+   and intra-Rust.
+2. **The dead code is pre-Rust debt.** Six moved-module shims with zero
+   non-test importers, one never-wired streaming seam, and 27 zero-caller
+   symbols whose only callers are their own tests ("dead code wearing a
+   test" — invisible to the coverage gate by construction).
+3. **The 183 `test_cov_wp*` files are all load-bearing.** Ten look deletable
+   by line analysis and are collectively sole owners of 79 branch arcs. The
+   seven coverage-redundant feature-test files carry behavioural regression
+   value and are deliberately kept.
+4. **The front door has seven real gaps (G1–G7)**, one of which (Set-Cookie
+   destroyed on proxied redirects) makes the invite gate a hard dead-end and
+   silently breaks SSO login.
+
+## Workstream 1 — deletions (paired, gate-preserving)
+
+- Six moved-module shims: `latticeai/core/{graph_curator,hooks,multi_agent,workflow_engine}.py`,
+  `latticeai/services/{ingestion,kg_portability}.py` + the shim-existence
+  tests + their `[tool.mypy] files` entries.
+- `latticeai/services/multimodal_streaming.py` (never wired; restorable from
+  git if a provider ever lands).
+- 25 of AUDIT-B's 27 dead symbols, with per-test surgery on the enumerated
+  collateral lines so `fail_under = 100` (lines AND branch arcs) holds.
+  Decisions on the three flagged items: `delete_conversation` **stays**
+  (public store API, exercised as a fixture by the read-equivalence suite);
+  `propose_file_delete` **goes together with** the now-uncreatable
+  `file_delete` limb of `approve()`; `multimodal_status` **is wired, not
+  deleted** (Workstream 3) — FEATURE_STATUS already documents it as
+  user-facing behaviour.
+- `metadata_for` interface method (declared on the vector-index ABC,
+  implemented four times, called zero times) — removed from ABC and all
+  four implementations.
+- `scripts/measure_brain_home_fill.mjs`, `tests/fixtures/filegen/` (12 unread
+  data files), and the legacy `desktop/electron/` shell (hardcodes 4825,
+  injects none of the safety flags, superseded by Tauri) after verifying it is
+  not referenced by any release artifact or workflow.
+- A new guard extends the legacy-shim gate inward: no
+  `sys.modules[__name__] = _impl` shim may exist under `latticeai/` again.
+
+## Workstream 2 — consolidation (behaviour-preserving unless stated)
+
+Python (the canonical copy is named; the direction always keeps
+`lattice_brain` import-free of `latticeai`):
+
+- **Embedder pair**: `latticeai/core/local_embeddings.py` is byte-identical to
+  the golden-pinned `lattice_brain/embeddings.py`. The unpinned copy is
+  deleted and importers rewired — silent vector drift between two write paths
+  was the failure mode.
+- **`workspace_scope_from_request`**: the four verbatim re-derivations
+  (`chat_helpers`, `upload_service`, `computer_use`, `admin`) import the
+  canonical `api/workspace_scope.py`. Behaviour change, intended: the copies
+  silently preferred the header where the canonical rule 403s on
+  disagreement.
+- `_default_data_dir` ×4 → `core/config.py`; sha256-hex ×6 → one helper;
+  SSE frame builders ×5 → one `sse_frame` (byte-identical output);
+  `model_runtime/engines.py` delegator/dead-fragment cleanup;
+  the AST-identical mode-service triplet → a `JsonBackedModeService` base;
+  module-importability ×4 → one helper (`find_spec` default, real-import
+  `strict=True` kept where native-lib load failures matter, e.g. mlx);
+  `parse_iso` → `lattice_brain/utils` (the golden-pinned copy);
+  `_detect_gpu`/`_detect_cpu` → `setup/wizard/detect.py`; the small ×2
+  helpers and the workspace-store mixin where mechanical.
+
+Rust: `gateway/clock.rs` (wholesale copy) deleted in favour of
+`lattice_retrieval::routes::naive_local_now`; `brain_not_found` shared;
+`haystack`/`json_opt` lifted into `shape.rs`; `in_set`/`bad_request` lifted
+within `lattice-agent`; `is_py_space`/`round3` shared from `lattice-core` into
+`lattice-ingest`. `lattice-agent`'s independent `pystr` stays — its
+zero-dependency isolation is a deliberate boundary.
+
+Deliberately **not** done in a patch release: splitting the three oversized
+route factories (`create_workspace_router` 706 lines et al.) — recorded as
+future work, not silently dropped.
+
+## Workstream 3 — front-door and feature gaps
+
+- **G1/G4 (redirects)**: the proxy gets its own reqwest client with redirect
+  following disabled; 3xx responses pass through with their `Set-Cookie` and
+  `Location` intact; absolute `Location` values naming the internal worker
+  origin are rewritten to the request's gateway origin. Fixes the invite
+  gate, SSO login, and the twelve legacy deep links.
+- **G2/G3 (native-lane auth)**: the native `/rust/*` and `/host/*` lanes
+  mirror Python's `trusted_local_owner` posture exactly. The worker's health
+  payload gains the posture facts; the gateway caches them from its existing
+  health polling and **fails closed** (posture unknown → native lanes refuse).
+  With `LATTICEAI_REQUIRE_AUTH=true` the native lanes answer 401 with a
+  machine-readable reason instead of serving the graph unauthenticated (G2)
+  or dying mid-loop on a seam 401 (G3). FEATURE_STATUS states the boundary:
+  the native lanes are an open-posture, single-local-owner surface in 11.5.2.
+- **G5/G7 (proxied identity)**: the proxy adds `X-Forwarded-For/Proto/Host`;
+  the worker computes its effective external origin from `X-Forwarded-Host`
+  only when the direct peer is loopback or listed in
+  `LATTICEAI_TRUSTED_PROXIES`. CSRF's `Origin == Host` fallback and the three
+  absolute-URL producers (admin invite link, permission notifications, SSO
+  redirect default) use it. Threat model note: browsers cannot set
+  `X-Forwarded-Host`, and a local non-browser caller could already forge
+  `Origin`, so this widens nothing.
+- **G6 (CORS)**: the supervisor injects `LATTICEAI_CORS_ALLOWED_ORIGINS` with
+  the gateway origins, mirroring the CSRF injection — the browser extension
+  and any cross-origin local client work through the front door.
+- **Feature gaps surfaced by the audits**: `graph_search` gains its missing
+  route (`POST /api/search/graph` — it was allow-listed but unreachable);
+  `multimodal_status` is wired to the route FEATURE_STATUS describes; the
+  `recent_chat` context seam is investigated and either wired into the live
+  assembler or the golden amended to match reality (whichever the original
+  intent supports — the current state, a golden pinning behaviour the product
+  never executes, is the one option that stays wrong); `tools/documents.py`
+  and `core/agent_profiles.py` — live `/agent` hot-path twins with no golden —
+  enter the fixture generators.
+- Small honest fixes: stale `ws://` removed from both CSPs (no WebSocket
+  endpoint exists); the Tauri shell no longer navigates to a dead origin when
+  the gateway fails to bind.
+
+Recorded, not fixed (with reasons): no request timeout on the proxy hop (a
+blanket timeout would kill long-lived SSE; the 15-minute model endpoints rely
+on the current behaviour), `request.is_disconnected()` seeing the gateway's
+socket (inherent to proxying), per-IP buckets collapsing on loopback (the
+gateway is loopback-only; the direct topology behaved identically).
+
+## Release mechanics
+
+Both waves verified on the settled tree (dev 3.14 + fresh-resolve 3.11) before
+the machinery runs: bump to 11.5.2 (Cargo.lock joins the sync so the suite
+stops dirtying the tree), OpenAPI regenerated (new routes), release theme
+"Tight Ship", OPERATIONS title, screen-claims entry (backend-only:
+all thirteen measured, none gated), release notes / CHANGELOG / README /
+extension README, screenshots + GIF re-shot at 11.5.2, ARCHITECTURE System
+Map labels updated (proxy semantics, posture-gated native lanes), DMG via
+release:artifacts, tag + GitHub Release, main push, CI green.

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "11.5.1"
+__version__ = "11.5.2"
 
 __all__ = [
     "AgentRuntime",

package/lattice_brain/graph/proactive.py

@@ -644,7 +644,7 @@ def gate_ingest_candidate(
     """Score whether new content should be ingested into the graph.
 
     Pure function — no store access, no side effects. Intended adoption point
-    for the ingestion pipeline (``services/ingestion.py`` /
+    for the ingestion pipeline (``lattice_brain.ingestion`` /
     ``lattice_brain.graph.ingest``), which passes a closure over its own
     scoped search, e.g.::
 

package/lattice_brain/graph/projection/v2_schema.py

@@ -516,31 +516,3 @@ class KnowledgeGraphV2SchemaMixin(_Core):
         except Exception as ex:
             logging.debug("knowledge_graph: v2 edge delete mirror skipped: %s", ex)
 
-    def _v2_sync_report(self) -> Dict[str, Any]:
-        """Diagnose the dual-write invariant: legacy node/edge id sets must equal
-        the v2 projection's. Returns counts + any drift (ids missing from / extra
-        in v2). ``in_sync`` is True only when both id sets match exactly.
-
-        All legacy writes go through _upsert_node/_upsert_edge (which dual-write)
-        and every legacy delete is mirrored, so a non-empty drift signals a
-        bypassed write path — this is the runtime guard for that invariant.
-        """
-        if KGStoreV2 is None:
-            return {"available": False, "in_sync": True}
-        with self._connect() as conn:
-            legacy_nodes = {r[0] for r in conn.execute("SELECT id FROM nodes")}
-            v2_nodes = {r[0] for r in conn.execute("SELECT id FROM nodes_v2")}
-            legacy_edges = {r[0] for r in conn.execute("SELECT id FROM edges")}
-            v2_edges = {r[0] for r in conn.execute("SELECT id FROM edges_v2")}
-        return {
-            "available": True,
-            "in_sync": legacy_nodes == v2_nodes and legacy_edges == v2_edges,
-            "nodes_legacy": len(legacy_nodes),
-            "nodes_v2": len(v2_nodes),
-            "edges_legacy": len(legacy_edges),
-            "edges_v2": len(v2_edges),
-            "nodes_missing_from_v2": sorted(legacy_nodes - v2_nodes),
-            "nodes_extra_in_v2": sorted(v2_nodes - legacy_nodes),
-            "edges_missing_from_v2": sorted(legacy_edges - v2_edges),
-            "edges_extra_in_v2": sorted(v2_edges - legacy_edges),
-        }

package/lattice_brain/graph/vector_index/base.py

@@ -142,9 +142,6 @@ class VectorIndex(Protocol):
     def rebuild(self, items: Iterable[IndexItem]) -> None:
         raise NotImplementedError
 
-    def metadata_for(self, id: str) -> Dict[str, Any]:
-        raise NotImplementedError
-
     def search(
         self,
         query: Sequence[float],

package/lattice_brain/graph/vector_index/brute_force.py

@@ -80,10 +80,6 @@ class BruteForceIndex:
         for item_id, vector, metadata in items:
             self.add(item_id, vector, metadata)
 
-    def metadata_for(self, id: str) -> Dict[str, Any]:
-        """Metadata stored alongside ``id`` (empty dict when unknown)."""
-        return dict(self._metadata.get(str(id), {}))
-
     def search(
         self,
         query: Sequence[float],

package/lattice_brain/graph/vector_index/hnsw.py

@@ -150,9 +150,6 @@ class HnswIndex:
             self.add(item_id, vector, metadata)
         self._dirty = True
 
-    def metadata_for(self, id: str) -> Dict[str, Any]:
-        return dict(self._metadata.get(str(id), {}))
-
     # ── graph construction ───────────────────────────────────────────────────
     def _new_graph(self, module: Any, capacity: int) -> Any:
         graph = module.Index(space=self._space, dim=self._dim)

package/lattice_brain/graph/vector_index/quantized.py

@@ -109,9 +109,6 @@ class QuantizedIndex:
         for item_id, vector, metadata in items:
             self.add(item_id, vector, metadata)
 
-    def metadata_for(self, id: str) -> Dict[str, Any]:
-        return dict(self._metadata.get(str(id), {}))
-
     def search(
         self,
         query: Sequence[float],