ltcai 11.5.1 → 11.6.0

package/docs/v11.6.0_ONE_DOOR_PLAN.md

@@ -0,0 +1,170 @@
+# v11.6.0 — One Door (설계 문서)
+
+> 상태: 계획 → 구현. 목표는 한 문장이다: **이 릴리스가 끝나면 Python은
+> AI Worker로만 쓰인다.** v11.5.1이 "설계상 최종 형태"로 남겨 둔
+> 플랫폼 라우트 박스(~450 라우트)를 Rust로 옮기고, Python 워커는
+> v11.5.1이 정의한 워커 소유물 — LLM 추론, 도구 핸들러 실행과
+> 그래프·파일 쓰기(단일 작성자), 제안 스테이징, 문서 파서 매트릭스,
+> 임베딩 생산 — 만 남긴다.
+
+## 정찰 확정 수치 (2026-08-14)
+
+- Python 라우트 464개 = KEEP_WORKER **25** + PORT_STATE **313** +
+  PORT_ORCH **108** + STATIC **18**. 클라이언트가 실제 밟는 경로는
+  ~190개(전 계약 문서화됨).
+- Rust 네이티브는 24 라우트(~5%). 프록시는 견고(스트리밍·쿠키·
+  멀티파트·SSE 무손상)하나 게이트웨이 자체 인증은 없다.
+- 결핍 인프라: 인증/세션, 쓰기측 SQLite, 서버 메시지 i18n(한글
+  리터럴 292), CSRF/CORS 네이티브, SSE 파이프, 멀티파트, 레이트리밋,
+  OpenAPI 생성, SPA 서빙, 워크스페이스 스코핑.
+
+## 최종 Python 워커 표면 (25 라우트 — 이것만 남는다)
+
+`/health` · `/agent/{llm,tool,change-proposal}` ·
+`/api/index/{drain,rebuild}` · `/api/embeddings/{status,providers}` ·
+`/models` `/models/{load,switch/*,unload/*,unload-all}` ·
+`/engines/prepare-model{,/stream}` ·
+`/tools/{read_document,pdf_pages,create_docx,create_xlsx,create_pptx,create_pdf}` ·
+`/upload/document` · `/api/ingestion/multimodal` ·
+`/api/capture/voice{,/status}` · (+`/knowledge-graph/ingest` 그래프
+단일 작성자 시임으로 유지)
+
+여기에 v11.6.0 additive 시임을 더한다(§WP-I6): 히스토리 기록
+(redact→audit→store→ingest 체인), 그래프 쓰기 위임, GPU sysinfo.
+셋 다 게이트웨이(루프백 호스트)만 호출한다.
+
+## 설계 결정
+
+1. **토폴로지** — lattice-host 게이트웨이가 제품 서버가 된다. 464개
+   중 439개 라우트를 **기존 경로 그대로** 네이티브 axum 핸들러로
+   서빙한다(클라이언트 무변경). 프록시 폴스루는 워커 시임 25개만
+   통과시키는 allowlist로 뒤집는다 — 남는 프록시가 곧 워커 계약이다.
+2. **저장소 쓰기 분할 (2026-08-14 상향)** — 사용자 기준 확정: **Rust가
+   쓰기 경로 전체의 주인이다.** 플랫폼 상태(사용자/세션, 워크스페이스,
+   리뷰 큐, 제안, 설정, 잡, 히스토리)뿐 아니라 **지식 그래프 쓰기
+   엔진도 Rust로 이관한다**(Wave 2.5 §W1: store write/ingest/projection/
+   provenance/벡터 쓰기 네이티브 — Python 스토어와 행 단위 패리티 골든).
+   Python 워커는 상태를 소유하지 않는 **순수 계산 워커**가 된다:
+   임베딩은 `/worker/embed`가 벡터를 반환하고 Rust가 저장하며, 문서
+   생성은 렌더 시임이 바이트를 반환하고 Rust가 파일을 놓는다. 전환
+   순서상 Wave 2는 상태-시임(`/worker/graph/mutate`,
+   `/worker/chat/record-turn`)에 대고 작업하고, Wave 2.5(§W3)가 그
+   호출부를 네이티브 쓰기 엔진으로 교체한 뒤 해당 시임을 폐지한다.
+   Scout가 찾은 "작성자 3곳"(write_file/edit_file, proposal approve)은
+   lattice-agent sandbox Workspace로 일원화한다(제안 apply 포함 —
+   네이티브).
+3. **인증** — 신규 `lattice-auth` 크레이트: 세션/사용자/로그인/역할/
+   워크스페이스 스코프/레이트리밋 + CSRF Origin 7분기 포트. Python의
+   수제 쿠키 파서 의미론과 **정확한 거부 본문**까지 픽스처로 결속한다.
+   인증은 Python에서 핸들러 본문 안에 있으므로 OpenAPI가 아니라
+   본문 전사로 옮긴다(라우트 WP 명세에 인증 요구를 명기).
+4. **OpenAPI 계약 파이프라인** — `frontend/openapi.json`이 계약의
+   단일 출처로 유지된다. Rust로 간 라우트의 스펙은 크레이트 옆에
+   데이터(JSON 프래그먼트)로 살고, Rust 테스트가 "마운트된 라우트 ==
+   스펙 경로"를 단언한다. `scripts/export_openapi.py`는 워커-전용
+   앱(축소된 app_factory) 스펙 + Rust 프래그먼트를 합성하는 컴포저로
+   재작성한다. 드리프트 게이트는 그대로 문다.
+5. **i18n** — `lattice-core::messages` ko/en 카탈로그. 라우트가
+   이주할 때 해당 한글 리터럴도 함께 이주한다.
+   `check_server_i18n.mjs`의 라우터 목록은 축소분만큼 갱신.
+6. **SSE** — `POST /chat`(오케스트레이션: redact→audit→워커 LLM
+   스트림→store→ingest 시임), `/engines/prepare-model/stream`
+   (워커 프록시 유지 — KEEP), `/agent`(v11.5.1 네이티브 루프 재사용,
+   경로만 게이트웨이가 직접 답함). **Accept 헤더 협상 금지** —
+   VS Code는 body `stream:true`만 보낸다.
+7. **정적/SPA** — 게이트웨이 ServeDir: `/app`, `/static`, `/icons`,
+   `manifest.json`, `favicon.ico`, `sw.js` + `GET /chat` 리다이렉트.
+8. **크레이트 배치** — 신규 3개: `lattice-auth`, `lattice-platform`
+   (workspace·admin·features·permissions·review·proposals·mcp·
+   marketplace·plugins·hooks·registry), `lattice-chat`(채팅
+   오케스트레이션 + hybrid cloud lane). 도메인 적합 라우트는 기존
+   크레이트 확장(retrieval: memory/brain 읽기, ingest: local_files/
+   capture, jobs: index). `RUST_CRATES`(bump/버전일관성) 갱신 필수.
+9. **Python 축소** — `LATTICEAI_WORKER_ONLY=1` 프로필이 아니라
+   **삭제**가 원칙: keep-set(pts_grok 산출) 밖의 latticeai/
+   lattice_brain 모듈과 그 테스트를 지운다. 커버리지 100%는 분모
+   축소로 유지하되 arc 단위로 확인. 게이트 파일 10종 동기화
+   (mypy files 403경로, setuptools packages, wheel smoke 29모듈,
+   MANIFEST, package.json files, product_readiness needle,
+   FEATURE_STATUS `_NOT_HTTP_PATHS`, server_app 분해 테스트,
+   Release History 테스트, i18n 라우터 목록).
+10. **클라이언트/진입점** — SPA·확장·Telegram은 무변경(경로 보존).
+    `bin/ltcai.js`·`cli/entrypoint.py`·src-tauri `direct/external`
+    토폴로지는 lattice-host 프론트 필수로 재배선. 워커 진입점은
+    유지(`server:app`) — 호스트가 스폰한다.
+
+## 검증 규약 (전 WP 공통)
+
+- **캡처-리플레이 패리티**: 삭제 전 Python 구현에서 TestClient로
+  라우트별 골든 요청/응답(정상 + 인증거부 + 오류 분기)을 생성해
+  `rust/fixtures/http/<family>.json`으로 커밋, Rust 테스트가 리플레이.
+  클라이언트가 밟는 ~190 경로는 전 분기, 나머지는 대표 분기.
+- **네이티브 증명**: lattice-host `FakeWorker`로 "워커 요청 0건" 단언
+  (기존 gateway_mounts.rs 패턴).
+- 공유 파일(`rust/Cargo.toml`, `gateway/{mod,mounts}.rs`,
+  `app_factory.py`, `pyproject.toml`)은 **통합자(Fable 5)만** 편집.
+  각 WP는 자기 크레이트/모듈 파일만 소유하고 배선 노트를 남긴다.
+
+## 작업 패키지
+
+Wave 1 — 인프라 (병렬):
+- **I1** `lattice-core::db` 쓰기측(WAL·busy_timeout·풀) + 테이블
+  소유권 지도 + config 구조체 (Opus)
+- **I2** `lattice-auth` + 게이트웨이 인증/CSRF/보안헤더 레이어 (Opus)
+- **I3** `lattice-core::messages` ko/en 카탈로그 + 추출 (pts_grok)
+- **I4** 게이트웨이 정적/SPA 서빙 + ui_redirects + static_routes (Opus)
+- **I5** OpenAPI 컴포저 파이프라인 (Opus)
+- **I6** Python 워커 additive 시임 3종 + 워커-전용 app 프로필 (Opus)
+
+Wave 2 — 라우트 패밀리 (병렬, 픽스처 우선 생성):
+- **R1** workspace(56)+scope+invitations+permissions → platform (Opus)
+- **R2** admin+security_dashboard+features+funnel+setup → platform (Opus)
+- **R3** auth 라우트(login/register/account) → auth (I2에 병합)
+- **R4** chat 전 계열 + hybrid lane → lattice-chat (Opus, 최대 난도)
+- **R5** memory+brain_intelligence+garden+chronicle+command_center+
+  evidence_actions → retrieval/platform (Opus)
+- **R6** knowledge_graph+search+index+local_files+local_knowledge+
+  browser → ingest/retrieval (Opus)
+- **R7** review_queue+change_proposals+automation_intelligence+hooks
+  → platform (Opus)
+- **R8** mcp+marketplace+plugins+agent_registry+agents+tools(비문서)
+  → platform/agent (pts_grok)
+- **R9** portability+network+network_boundary+realtime+
+  project_sessions+voice목록+computer_use표면 → platform (Opus)
+- **R10** models 카탈로그/추천(비MLX)+permission_mode+
+  workflow_designer+잔여 → platform (Opus)
+
+Wave 2.5 — 쓰기 경로 주권 이관 (Rust = 쓰기 주인, Python = 순수 계산):
+- **W1** 네이티브 KG 쓰기 엔진: lattice_brain 그래프 write/ingest/
+  projection/provenance/벡터 쓰기 미러 포트 + 행 단위 패리티 골든
+  (Opus). `/knowledge-graph/ingest`·`/upload/document`·index drain/
+  rebuild가 네이티브가 된다.
+- **W2** Python 순수 계산 시임: `/worker/embed`(벡터 반환),
+  `/worker/render/{docx,xlsx,pptx,pdf}`(바이트 반환), 파싱/ASR/멀티모달
+  시임 정렬; 상태-시임 3종 폐지 준비.
+- **W3** Wave-2 호출부 교체: WorkerSeamClient 상태-시임 호출 →
+  네이티브 쓰기 엔진/감사 싱크; redact 규칙 네이티브 포트; record-turn
+  체인(redact→audit→store→ingest) 전부 Rust.
+- **W4** 뮤테이팅 도구 핸들러 네이티브화: `/agent/tool`은 계산 전용
+  화이트리스트로 축소, 쓰기 도구는 sandbox/graph-write 경유.
+
+Wave 3 — 축소·재배선:
+- **P1** Python 삭제(keep-set 기준) + 테스트 정리 + 게이트 10종 동기화
+- **P2** bin/ltcai.js·entrypoint·tauri 토폴로지 재배선
+- **P3** 죽는 골든 생성기 정리(참조 구현 이관 또는 명시적 폐기)
+
+Wave 4 — 릴리스: bump 11.6.0(31 타겟) → OpenAPI 재생성 →
+releaseTheme "One Door" → 문서 동기화(README 현행 릴리스 문장·미디어
+경로·Release History **11.0.0 미만 제거 + 해당 단언 테스트 갱신**,
+RELEASE_NOTES, CHANGELOG, ARCHITECTURE **System Map 재작성**,
+SECURITY 11.6.x, FEATURE_STATUS, release_screen_claims 11.6.0 엔트리)
+→ build:assets → release:evidence(13샷+GIF) → 4중 로컬 검증
+(fresh venv·비편집 설치·linux 컨테이너·rust 컨테이너) → artifacts →
+main 커밋·푸시 → CI 그린.
+
+## 완성 후 남는 것
+
+Python AI Worker: 추론·도구 실행/그래프 쓰기·제안 스테이징·문서
+파서·임베딩 + additive 시임 3종. HTTP 표면 25(+시임). 그 외 전부
+Rust. 이것이 "One Door": 사용자와 클라이언트가 두드리는 문은
+lattice-host 하나다.

package/lattice_brain/__init__.py

@@ -1,87 +1,50 @@
-"""lattice-brain — independent Brain Core package for Lattice AI.
-
-Physically hosts the knowledge graph (``lattice_brain.graph``), memory,
-context assembly, conversations, ingestion, agent/hook runtime
-(``lattice_brain.runtime``), workflow engine, portability (backup/restore and
-``.latticebrain`` archives), and the storage abstraction.
-
-The package never imports ``latticeai``; FastAPI and the desktop product
-import this package, not the other way around. Heavy graph modules are
-lazy-loaded so storage and archive utilities remain usable without creating
-runtime globals.
+"""lattice-brain — the compute half of the Brain Core.
+
+This package hosted the knowledge graph, memory, context assembly,
+conversations, the ingest write door, the agent/hook runtime, the workflow
+engine, portability and the storage abstraction. v11.6.0 §Wave 2.5 made Rust
+the single writer of every one of those, and WP-P1 deleted the Python side.
+
+What remains is what a **pure compute worker** needs, and it is deliberately
+small: the always-on hash embedder, the document parser matrix, chunking,
+concept/triple extraction, the multi-modal fact readers, and the ingestion
+vocabulary both sides hash against. The package still never imports
+``latticeai``.
+
+Nothing here is lazy any more, because nothing here is heavy: the modules that
+justified the lazy table (the store, the ANN index, the workflow engine) are
+gone.
 """
 
-from .archive import BrainArchivePaths, EncryptedBrainArchive
-from .core import BrainCore, BrainCoreConfig
-from .storage import (
-    DockerPostgresPlan,
-    DockerPostgresWizard,
-    PostgresConfig,
-    PostgresEngine,
-    SQLiteEngine,
-    SQLiteToPostgresMigrator,
-    StorageCapabilities,
-    StorageEngine,
-    StorageUnavailable,
-    storage_from_env,
+from .embeddings import LocalEmbeddingModel
+from .multimodal import (
+    AudioFacts,
+    ImageFacts,
+    MultimodalPorts,
+    VideoFacts,
+    detect_modality,
+    extract_image_facts,
+    extract_keyframes,
+    ffmpeg_available,
+    parse_subtitles,
+    read_video_facts,
+    transcribe_audio,
 )
 
-__version__ = "11.5.1"
+__version__ = "11.6.0"
 
 __all__ = [
-    "AgentRuntime",
-    "AssembledContext",
-    "BrainArchivePaths",
-    "BrainCore",
-    "BrainCoreConfig",
-    "BrainMemory",
-    "ContextAssembler",
-    "ContextSection",
-    "ConversationStore",
-    "DockerPostgresPlan",
-    "DockerPostgresWizard",
-    "EncryptedBrainArchive",
-    "IngestionItem",
-    "IngestionPipeline",
-    "KGPortabilityService",
-    "KnowledgeGraphStore",
-    "LatticeBrainQuality",
-    "MultiAgentOrchestrator",
-    "PostgresConfig",
-    "PostgresEngine",
-    "SQLiteEngine",
-    "SQLiteToPostgresMigrator",
-    "StorageCapabilities",
-    "StorageEngine",
-    "StorageUnavailable",
-    "WorkflowEngine",
-    "storage_from_env",
+    "AudioFacts",
+    "ImageFacts",
+    "LocalEmbeddingModel",
+    "MultimodalPorts",
+    "VideoFacts",
+    "detect_modality",
+    "extract_image_facts",
+    "extract_keyframes",
+    "ffmpeg_available",
+    "parse_subtitles",
+    "read_video_facts",
+    "transcribe_audio",
     "__version__",
 ]
-
-_LAZY = {
-    "AssembledContext": ("context", "AssembledContext"),
-    "ContextAssembler": ("context", "ContextAssembler"),
-    "ContextSection": ("context", "ContextSection"),
-    "ConversationStore": ("conversations", "ConversationStore"),
-    "BrainMemory": ("memory", "BrainMemory"),
-    "KnowledgeGraphStore": ("graph.store", "KnowledgeGraphStore"),
-    "LatticeBrainQuality": ("quality", "LatticeBrainQuality"),
-    "IngestionItem": ("ingestion", "IngestionItem"),
-    "IngestionPipeline": ("ingestion", "IngestionPipeline"),
-    "KGPortabilityService": ("portability", "KGPortabilityService"),
-    "WorkflowEngine": ("workflow", "WorkflowEngine"),
-    "AgentRuntime": ("runtime.agent_runtime", "AgentRuntime"),
-    "MultiAgentOrchestrator": ("runtime.multi_agent", "MultiAgentOrchestrator"),
-}
-
-
-def __getattr__(name: str):
-    target = _LAZY.get(name)
-    if target is None:
-        raise AttributeError(name)
-    module_path, attr = target
-    import importlib
-
-    module = importlib.import_module(f".{module_path}", __name__)
-    return getattr(module, attr)

package/lattice_brain/graph/__init__.py

@@ -1,28 +1,13 @@
-"""Knowledge graph subsystem of the Brain Core.
-
-Physically hosts the graph schema, store, mixins (write/retrieval/discovery/
-documents/ingest/projection/provenance), device identity, brain network, and
-the graph curator. Heavy modules are lazy-loaded so importing
-``lattice_brain.graph`` stays cheap.
+"""Graph compute: chunking, extraction, parsing, and the embedder fingerprint.
+
+The store, the schema, the write mixins, the ANN index and the retrieval stack
+all moved to ``lattice-core`` / ``lattice-retrieval`` in v11.6.0 §Wave 2.5. This
+package keeps only what turns bytes into structures a writer can use, which is
+why it now exports nothing itself — import the submodule you mean
+(``._kg_common``, ``.documents``, ``.retrieval_vector.fingerprint``,
+``.runtime``).
 """
 
 from __future__ import annotations
 
-__all__ = [
-    "KnowledgeGraphStore",
-    "KGStoreV2",
-    "NodeType",
-    "EdgeType",
-]
-
-
-def __getattr__(name: str):
-    if name == "KnowledgeGraphStore":
-        from .store import KnowledgeGraphStore
-
-        return KnowledgeGraphStore
-    if name in {"KGStoreV2", "NodeType", "EdgeType"}:
-        from . import schema
-
-        return getattr(schema, name)
-    raise AttributeError(name)
+__all__: list[str] = []

package/lattice_brain/graph/_kg_common/__init__.py

@@ -1,9 +1,15 @@
-"""
-SQLite knowledge graph for Lattice AI workspace memory.
+"""The graph's *compute* vocabulary, in one importable place.
+
+This package was the shared surface of the SQLite knowledge graph: constants,
+path/hash helpers, chunking, concept and triple extraction, and the schema
+handles the write mixins composed into ``KnowledgeGraphStore``. v11.6.0 moved
+every write into ``lattice-core``, and the store went with them.
 
-The graph keeps raw event JSON, normalized node metadata, and edges in one
-portable database so it can later migrate to Neo4j/Postgres without changing
-the ingestion contract.
+What is left is the half that produces *structures*: chunk a document, pull the
+concepts and triples out of a passage, classify a node type, infer an edge verb,
+hash a file. ``POST /worker/parse``, ``POST /worker/embed`` and
+``POST /worker/extract`` are the routes that answer with them; Rust decides what
+to write.
 """
 
 # ruff: noqa: F401,F841
@@ -26,21 +32,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple
 
-try:
-    from ..schema import EdgeType, KGStoreV2, NodeType, _exec_script
-except Exception:  # pragma: no cover - v2 schema is optional at import time
-    KGStoreV2 = None  # type: ignore[assignment,misc]
-    NodeType = None  # type: ignore[assignment,misc]
-    EdgeType = None  # type: ignore[assignment,misc]
-    _exec_script = None  # type: ignore[assignment]
-
 from ...embeddings import LocalEmbeddingModel
-from ..json_utils import _json, _safe_loads
-from ..runtime import get_llm_router, set_llm_router
-
-# Default read source for the graph queries: v2 reconstruction views.
-# Override with LATTICEAI_KG_READ_V2=0 to fall back to the legacy tables.
-_READ_FROM_V2_DEFAULT = os.getenv("LATTICEAI_KG_READ_V2", "1") != "0"
 
 # Static constants (projection/format versions, local-ingestion classification
 # tables, OS exclusion lists) live in ._kg_constants; re-exported here so every
@@ -96,6 +88,8 @@ from .._kg_fsutil import (  # noqa: E402,F401
     _size_limit_for_category,
     _slug,
 )
+from ..json_utils import _json, _safe_loads
+from ..runtime import get_llm_router, set_llm_router
 
 # The logic this module used to hold inline lives in three cohesive submodules
 # (v11.3.0 decomposition). Every name is re-exported below, so the twelve
@@ -172,11 +166,9 @@ __all__ = [
     "Dict",
     "EDGE_VERB",
     "ENABLE_LLM_EXTRACTION",
-    "EdgeType",
     "GRAPH_SCHEMA_VERSION",
     "Iterable",
     "Iterator",
-    "KGStoreV2",
     "LINUX_EXCLUDED_PREFIXES",
     "LOCAL_CODE_EXTENSIONS",
     "LOCAL_DOCUMENT_EXTENSIONS",
@@ -189,7 +181,6 @@ __all__ = [
     "List",
     "LocalEmbeddingModel",
     "MACOS_EXCLUDED_PREFIXES",
-    "NodeType",
     "Optional",
     "Path",
     "SENSITIVE_PATH_KEYWORDS",
@@ -214,7 +205,6 @@ __all__ = [
     "_PROSE_MIN_SPAN_RATIO",
     "_PROSE_STRONG_BOUNDARY_RE",
     "_PROSE_WEAK_BOUNDARY_RE",
-    "_READ_FROM_V2_DEFAULT",
     "_V2_WRITE_MASTER_KEY",
     "_chunks",
     "_classify_node_type",
@@ -224,7 +214,6 @@ __all__ = [
     "_current_os_type",
     "_drive_id_for_path",
     "_excluded_directory_reason",
-    "_exec_script",
     "_extract_concepts",
     "_extract_concepts_rules",
     "_extract_triples",

package/lattice_brain/ingestion/__init__.py

@@ -1,63 +1,34 @@
-"""Unified ingestion pipeline — the single write-side seam into the Knowledge Graph.
+"""Ingestion: what a source *is*, how it hashes, and how good it looks.
 
-v3.6.0 Knowledge Graph First principle: *no data source bypasses the Knowledge
-Graph and no source creates an isolated silo*. Every source — local files,
-connected folders, PDFs/Markdown/text/code, web URLs, browser tabs — is
-normalized into one :class:`IngestionItem` and pushed through one
-:meth:`IngestionPipeline.ingest` entrypoint:
+v3.6.0's Knowledge Graph First principle — *no data source bypasses the
+Knowledge Graph and no source creates an isolated silo* — is still the rule.
+The door it goes through is no longer here: v11.6.0 §Wave 2.5 made Rust the
+single writer of the Brain, so ``IngestionPipeline.ingest``, the per-source
+routing doors, the folder walk, the ``.latticeignore`` reader and the durable
+background queue moved to ``lattice-core`` / ``lattice-ingest`` /
+``lattice-jobs``.
 
-    Source → normalize → content hash → (file | text) ingest → provenance
+What stays is the vocabulary both sides share, and the compute the write path
+asks this worker for:
 
-The pipeline is deliberately thin. It owns normalization, idempotency reporting,
-provenance capture, and — crucially — routing every ingest through the shared
-``dispatch_tool`` lifecycle so ``pre_tool``/``post_tool`` hooks fire on data
-ingestion exactly as they do on tool calls. The heavy graph construction lives in
-:class:`knowledge_graph.KnowledgeGraphStore` (``ingest_document`` for files,
-``ingest_source`` for text/web), which this module composes rather than
-re-implements.
-
-Web ingestion seam
-------------------
-The graph layer never fetches or parses the web. Fetching, rendering,
-readability extraction, and parse quality are the responsibility of the
-*upstream* capture surfaces (browser extension, tools layer, MCP servers):
-they hand this module already-extracted text. :meth:`IngestionPipeline.
-ingest_web_page` is the convenience wrapper for that hand-off — it normalizes
-``(url, extracted_text)`` into an ``IngestionItem(source_type="web_url")`` and
-routes it through the exact same :meth:`IngestionPipeline.ingest` door as every
-other source. If the extracted text is bad, fix the extractor upstream; the
-pipeline will not attempt network access or HTML parsing.
-
-Folder ingestion (:meth:`IngestionPipeline.ingest_folder`) walks a local
-directory, honors a gitignore-like ``.latticeignore`` file at the root
-(blank lines, ``#`` comments, ``fnmatch`` glob patterns, ``dir/`` suffix for
-directories), always skips common noise (``.git``, ``node_modules``,
-``__pycache__``, virtualenvs, ``dist``, hidden entries by default), applies
-size/extension filters, and either ingests inline or schedules through the
-existing :class:`BackgroundIngestionQueue`.
-
-Split into cohesive submodules in v11.3.0 (no behaviour change): ``constants``
-(routing tables + gates), ``quality`` (advisory scoring), ``models`` (item and
-result), ``hashing``, ``folder_scan`` (``.latticeignore``), and the three mixins
-``routing`` / ``folders`` / ``jobs_api`` that ``pipeline`` composes into
-``IngestionPipeline``. This module re-exports every name the single file
-exposed, so ``lattice_brain.ingestion.X`` keeps working.
+* ``constants`` — the routing tables and the multi-modal gates;
+* ``models`` — :class:`IngestionItem` / :class:`IngestionResult`, now the DTOs
+  of a parse request rather than of a write;
+* ``hashing`` — ``content_hash_text`` and the file digest, which decide
+  idempotency and must produce the same bytes on both sides;
+* ``quality`` — the advisory extraction score behind ``POST /worker/parse``;
+* ``pipeline`` — the multi-modal capability probe.
 """
 
 from __future__ import annotations
 
-# The single file had no ``__all__``, so its public surface was "every module
-# global" — including the names it imported for its own use. Every re-export
-# below therefore uses the redundant-alias form: it reproduces exactly that
-# surface, and it marks each name as deliberate rather than a leftover import.
+# Re-exports use the redundant-alias form: it says "this is a re-export", not a
+# leftover import.
 #
 # Stubbing note: rebinding one of these *here* changes only this module's name.
 # The submodule that calls it holds its own reference, so a test standing in for
 # a helper patches the submodule that uses it.
 from ..gates import FeatureGate as FeatureGate
-from ..ingestion_jobs import JOB_ERRORS_CAP as JOB_ERRORS_CAP
-from ..ingestion_jobs import BackgroundIngestionJob as BackgroundIngestionJob
-from ..ingestion_jobs import BackgroundIngestionQueue as BackgroundIngestionQueue
 from ..multimodal import AUDIO_EXTENSIONS as AUDIO_EXTENSIONS
 from ..multimodal import DEFAULT_KEYFRAMES as DEFAULT_KEYFRAMES
 from ..multimodal import IMAGE_EXTENSIONS as IMAGE_EXTENSIONS
@@ -75,12 +46,8 @@ from ..multimodal import ffmpeg_available as ffmpeg_available
 from ..multimodal import image_quality_score as image_quality_score
 from ..multimodal import read_video_facts as read_video_facts
 from ..multimodal import transcribe_audio as transcribe_audio
-from ..multimodal import video_frame_dir as video_frame_dir
 from ..multimodal import video_quality_score as video_quality_score
-from ..multimodal import write_image_memory as write_image_memory
-from ..multimodal import write_video_memory as write_video_memory
 from ..quiet import quiet as quiet
-from ..runtime.hooks import dispatch_tool as dispatch_tool
 from ..utils import utc_now_iso as utc_now_iso
 from .constants import _MEMORY_NODE_TYPES as _MEMORY_NODE_TYPES
 from .constants import ALLOW_MULTIMODAL_ENV as ALLOW_MULTIMODAL_ENV
@@ -107,15 +74,10 @@ from .constants import MULTIMODAL_GATE as MULTIMODAL_GATE
 from .constants import TEXT_SOURCE_TYPES as TEXT_SOURCE_TYPES
 from .constants import VIDEO_GATE as VIDEO_GATE
 from .constants import VIDEO_SOURCE_TYPES as VIDEO_SOURCE_TYPES
-from .folder_scan import _load_latticeignore as _load_latticeignore
-from .folder_scan import _matches_ignore as _matches_ignore
-from .folders import IngestionFolderMixin as IngestionFolderMixin
 from .hashing import _file_digest as _file_digest
 from .hashing import content_hash_text as content_hash_text
-from .jobs_api import IngestionJobsMixin as IngestionJobsMixin
 from .models import IngestionItem as IngestionItem
 from .models import IngestionResult as IngestionResult
-from .pipeline import VECTOR_TICK_LIMIT as VECTOR_TICK_LIMIT
 from .pipeline import IngestionPipeline as IngestionPipeline
 from .quality import _BOILERPLATE_LINE_MARKERS as _BOILERPLATE_LINE_MARKERS
 from .quality import _CAPTURE_REASON_LABELS as _CAPTURE_REASON_LABELS
@@ -127,4 +89,3 @@ from .quality import QUALITY_LOW_WARNING as QUALITY_LOW_WARNING
 from .quality import _quality_level as _quality_level
 from .quality import assess_extraction_quality as assess_extraction_quality
 from .quality import capture_quality_verdict as capture_quality_verdict
-from .routing import IngestionRoutingMixin as IngestionRoutingMixin