ltcai 11.6.0 → 11.9.0

package/latticeai/runtime/build_phases/features.py

@@ -3,16 +3,18 @@
 The tail of the build order — everything that mounts a router on the finished
 application. WP-P1 replaced two phases (``platform_features`` and
 ``interaction``, ~34 product routers between them) with this one, because the
-worker mounts six things:
+worker mounts four things:
 
 * ``/health`` — the posture the supervisor gates on;
-* the MLX model lifecycle (``/models*``, ``/engines/*``);
-* the embedder report (``/api/embeddings/{status,providers}``);
-* the document parser (``POST /tools/read_document``, ``GET /tools/pdf_pages``);
-* the two capability probes (``/api/ingestion/multimodal``,
-  ``/api/capture/voice/status``);
+* the MLX model lifecycle (``/models*``, ``/engines/prepare-model*``);
+* the embedder report (``GET /api/embeddings/status``);
 * the Rust loop's seam (``POST /agent/llm``, ``POST /agent/tool``).
 
+It mounted three more until v11.8.0 — the ``/tools/*`` document parser, the
+multi-modal capability probe and the voice capability probe. Every one of them
+had no caller in the tree, so the routers, their modules and the construction
+that fed them are gone rather than kept "in case".
+
 The ``/worker/*`` seams are not here: they are mounted by
 :func:`~latticeai.runtime.build_phases.worker_profile.phase_worker_routes`,
 which runs after this phase and is the module that owns the worker contract.
@@ -33,22 +35,15 @@ def phase_features(ctx: RuntimeContext) -> None:
 
     from latticeai.api.agent_worker_seam import create_agent_worker_seam_router
     from latticeai.api.health import create_health_router
-    from latticeai.api.local_files import create_local_files_router
     from latticeai.api.models import create_models_router
     from latticeai.api.search import create_search_router
-    from latticeai.api.tools import create_tools_router
-    from latticeai.api.voice_capture import create_voice_capture_router
     from latticeai.core.model_compat import list_cached_profiles
     from latticeai.runtime.access_runtime import is_externally_reachable
     from latticeai.runtime.platform_services_runtime import build_model_service
     from latticeai.services.model_runtime import (
         ENGINE_MODEL_CATALOG,
         MODEL_ENGINE_ALIASES,
-        download_hf_model,
-        ensure_ollama_server,
         filter_lower_family_versions,
-        local_binary,
-        normalize_local_model_request,
         sse_event,
     )
     from latticeai.services.search_service import SearchService
@@ -81,13 +76,9 @@ def phase_features(ctx: RuntimeContext) -> None:
             model_router=ctx.model_router,
             require_user=ctx.require_user,
             require_admin=ctx.require_admin,
-            normalize_local_model_request=normalize_local_model_request,
-            download_hf_model=download_hf_model,
             prepare_and_load_model=service.prepare_and_load_model,
             prepare_and_load_model_stream=service.prepare_and_load_model_stream,
             sse_event=sse_event,
-            ensure_ollama_server=ensure_ollama_server,
-            local_binary=local_binary,
             engine_status=service.engine_status,
             filter_lower_family_versions=filter_lower_family_versions,
             list_compat_profiles=list_cached_profiles,
@@ -120,20 +111,6 @@ def phase_features(ctx: RuntimeContext) -> None:
         )
     )
 
-    app.include_router(
-        create_tools_router(require_user=ctx.require_user)
-    )
-    app.include_router(
-        create_local_files_router(
-            require_user=ctx.require_user, ingestion_pipeline=ctx.INGESTION_PIPELINE
-        )
-    )
-    app.include_router(
-        create_voice_capture_router(
-            service=ctx.VOICE_CAPTURE, require_user=ctx.require_user
-        )
-    )
-
     # AI-Worker seam (v11.5.1, plan §Y1): the calls the Rust agent loop makes
     # back into Python once orchestration lives in ``lattice-agent``. The tool
     # route stays behind ``LATTICEAI_AGENT_TOOL_SEAM=1``, which only

package/latticeai/runtime/build_phases/foundation.py

@@ -189,16 +189,12 @@ def phase_brain(ctx: RuntimeContext) -> None:
     """
     ctx.enter("brain")
 
-    from lattice_brain.ingestion import IngestionPipeline
     from latticeai.core.embedding_providers import (
         resolve_embedder,
         resolve_embedding_profile,
     )
     from latticeai.runtime.brain_runtime import build_embedder_runtime
-    from latticeai.services.multimodal_ports import (
-        build_multimodal_ports,
-        multimodal_enabled,
-    )
+    from latticeai.services.multimodal_ports import build_multimodal_ports
     from latticeai.services.voice_capture import VoiceCaptureService
 
     # Resolve the configured embedding provider once. Degrades to the offline
@@ -228,18 +224,13 @@ def phase_brain(ctx: RuntimeContext) -> None:
     # The transcriber is resolved through the voice service so a voice memo and
     # a scanned ``.m4a`` are transcribed by the same thing — or, far more often,
     # by the same nothing.
+    #
+    # The service itself is not published on the context: v11.8.0 deleted its
+    # one route (``GET /api/capture/voice/status``, which nothing called), so
+    # what the rest of the build needs from it is the port it resolves, and
+    # that travels in ``MULTIMODAL_PORTS``.
     voice_capture = VoiceCaptureService(transcriber=None)
     multimodal_ports = build_multimodal_ports(
         transcriber=voice_capture.multimodal_ports().transcriber
     )
-    # The capability probe behind ``GET /api/ingestion/multimodal``. It answers
-    # what this machine *could* do with a picture, a recording or a video; the
-    # ingest door itself is native (§W3b), which is why nothing is passed here
-    # for it to write through.
-    ctx.set(
-        VOICE_CAPTURE=voice_capture,
-        MULTIMODAL_PORTS=multimodal_ports,
-        INGESTION_PIPELINE=IngestionPipeline(
-            allow_multimodal=multimodal_enabled(), multimodal=multimodal_ports
-        ),
-    )
+    ctx.set(MULTIMODAL_PORTS=multimodal_ports)

package/latticeai/runtime/build_phases/web.py

@@ -110,9 +110,9 @@ def build_worker_app_shell(ctx: RuntimeContext):
       opaque network error.
     * **The CSRF origin guard** is what makes ``LATTICEAI_CSRF_TRUSTED_ORIGINS``
       load-bearing for the gateway (v11.6.0 gateway integration §3): a proxied
-      browser write — ``POST /models/load``, ``POST /engines/pull-model``,
-      ``POST /tools/read_document`` — arrives carrying the browser's session
-      cookie *and* ``Origin: …:{gateway port}``, and without the host's
+      browser write — ``POST /models/load``, ``POST /engines/prepare-model``,
+      ``DELETE /models/unload/{model_id}`` — arrives carrying the browser's
+      session cookie *and* ``Origin: …:{gateway port}``, and without the host's
       injected trust list this guard would answer 403.
     """
     from fastapi import FastAPI

package/latticeai/runtime/build_phases/worker_profile.py

@@ -29,12 +29,16 @@ from __future__ import annotations
 
 from typing import Any, List, Set, Tuple
 
-#: ``(method, path)`` for each product route v11.6.0 leaves in Python —
+#: ``(method, path)`` for each product route the worker still serves —
 #: docs/v11.6.0_ONE_DOOR_PLAN.md §최종 Python 워커 표면, cross-checked against
 #: the KEEP_WORKER table of the route scout, then narrowed by §W3b (ingest,
-#: drain/rebuild, voice capture and the four document creators went native) and
-#: widened by §4a (the model pull came back). Paths are FastAPI's, converters
-#: included, so this compares to ``APIRoute.path`` without normalisation.
+#: drain/rebuild, voice capture and the four document creators went native),
+#: widened by §4a (the model pull came back) and narrowed again by v11.8.0,
+#: which deleted the eight product routes with no caller anywhere in the tree:
+#: the embedding-provider catalogue, both ``/tools/*`` document reads, the
+#: multi-modal and voice capability probes, and three model-lifecycle doors
+#: (see below). Paths are FastAPI's, converters included, so this compares to
+#: ``APIRoute.path`` without normalisation.
 #:
 #: This tuple, through :func:`worker_route_keys`, is the **one** source of the
 #: gateway's proxy allowlist. ``rust/fixtures/worker_allowlist.json`` is its
@@ -53,27 +57,16 @@ WORKER_ROUTES: Tuple[Tuple[str, str], ...] = (
     ("GET", "/health"),
     # embedding production (drain/rebuild are native — W3b)
     ("GET", "/api/embeddings/status"),
-    ("GET", "/api/embeddings/providers"),
-    # MLX model + engine lifecycle (in-process only)
+    # MLX model + engine lifecycle (in-process only). v11.8.0 dropped
+    # ``/models/switch``, ``/models/unload-all`` and ``/engines/pull-model``:
+    # nothing in the tree called them, and the surfaces that do this work send
+    # ``/models/load`` and ``/engines/prepare-model``, which switch and
+    # download as part of what they already do.
     ("GET", "/models"),
     ("POST", "/models/load"),
-    ("POST", "/models/switch/{model_id:path}"),
     ("DELETE", "/models/unload/{model_id:path}"),
-    ("DELETE", "/models/unload-all"),
     ("POST", "/engines/prepare-model"),
     ("POST", "/engines/prepare-model/stream"),
-    # The download itself is huggingface_hub / ollama running in *this*
-    # interpreter, which is the same reason the six lines above stay: model
-    # management is the worker's box. The gateway proxies it rather than
-    # shipping a native consent check in front of a 501 (v11.6.0 gateway
-    # integration §4a).
-    ("POST", "/engines/pull-model"),
-    # document parser (create_* + upload are native — W3b)
-    ("POST", "/tools/read_document"),
-    ("GET", "/tools/pdf_pages"),
-    ("GET", "/api/ingestion/multimodal"),
-    # local ASR status (POST /api/capture/voice is native — W3b)
-    ("GET", "/api/capture/voice/status"),
 )
 
 #: Retired by W3b — ingest is native. Kept as an empty tuple so imports
@@ -93,8 +86,10 @@ WORKER_SEAM_ROUTES: Tuple[Tuple[str, str], ...] = (
 #: The pure-compute seams of Wave 2.5 §W2 (``latticeai/api/worker_compute.py``).
 #: Kept apart from :data:`WORKER_SEAM_ROUTES` because they age in the opposite
 #: direction: the state seams above are retired once §W3 lands the native write
-#: engine, while these nine are what the worker is *for* once Rust owns every
-#: write. Mounted here and nowhere else.
+#: engine, while these eight are what the worker is *for* once Rust owns every
+#: write. Mounted here and nowhere else. ``/worker/multimodal/describe`` was the
+#: ninth until v11.8.0 — it described an image for a native image ingest that
+#: was never built, and no caller ever appeared.
 WORKER_COMPUTE_ROUTES: Tuple[Tuple[str, str], ...] = (
     ("POST", "/worker/embed"),
     ("POST", "/worker/parse"),
@@ -103,7 +98,6 @@ WORKER_COMPUTE_ROUTES: Tuple[Tuple[str, str], ...] = (
     ("POST", "/worker/render/pptx"),
     ("POST", "/worker/render/pdf"),
     ("POST", "/worker/asr"),
-    ("POST", "/worker/multimodal/describe"),
     ("POST", "/worker/extract"),
 )
 
@@ -148,16 +142,15 @@ def phase_worker_routes(ctx: Any) -> None:
         )
     )
     # The compute seams take the *resolved* embedder and the same injected
-    # multimodal ports the ingestion path holds, so a vector or a caption
-    # produced through HTTP is the one this process would have produced
-    # in-process. ``getattr`` because a worker built without a Brain still boots
-    # — each seam reports the absence rather than failing construction.
+    # transcriber the voice path holds, so a vector or a transcript produced
+    # through HTTP is the one this process would have produced in-process.
+    # ``getattr`` because a worker built without a Brain still boots — each seam
+    # reports the absence rather than failing construction.
     ports = getattr(ctx, "MULTIMODAL_PORTS", None)
     app.include_router(
         create_worker_compute_router(
             embedder=getattr(ctx, "EMBEDDER", None),
             transcriber=getattr(ports, "transcriber", None),
-            multimodal_ports=ports,
             require_user=ctx.require_user,
             enforce_rate_limit=ctx.enforce_rate_limit,
         )

package/latticeai/runtime/runtime_context.py

@@ -81,9 +81,7 @@ class RuntimeContext:
     # ── phase 4: the compute ports ───────────────────────────────────────
     EMBEDDING_PROFILE: Any
     EMBEDDER: Any
-    VOICE_CAPTURE: Any
     MULTIMODAL_PORTS: Any
-    INGESTION_PIPELINE: Any
 
     # ── phase 5: domain singletons ───────────────────────────────────────
     model_router: Any

package/latticeai/services/architecture_readiness.py

@@ -19,7 +19,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-ARCHITECTURE_VERSION_TARGET = "11.6.0"
+ARCHITECTURE_VERSION_TARGET = "11.9.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",
@@ -156,31 +156,28 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             ["from fastapi import HTTPException", "raise HTTPException"],
         )
     )
-    # The Python agent loop package is gone. The compatibility alias is now
-    # scanned on the two Python files that still talk about permission mode.
-    agent_alias_forbidden = [
-        finding
-        for relative_path in (
-            "latticeai/core/agent_permission.py",
-            "latticeai/api/agent_worker_seam.py",
-        )
-        for finding in _forbidden_patterns(
-            root,
-            relative_path,
-            ["AgentRuntime = SingleAgentRuntime"],
-        )
-    ]
+    # The Python agent loop package is gone, and 11.8.0 removed the last of its
+    # gate tables (``core/agent_permission.py``) once the Rust goldens froze.
+    # The compatibility alias is scanned on the one Python file that still
+    # talks about permission mode: the worker seam the native loop calls.
+    agent_alias_forbidden = _forbidden_patterns(
+        root,
+        "latticeai/api/agent_worker_seam.py",
+        ["AgentRuntime = SingleAgentRuntime"],
+    )
 
     gates = [
         ArchitectureGate(
             id="agent-runtime",
             title="AgentRuntime boundary",
             status="complete" if (
-                _symbol_exists("latticeai.core.agent_permission.block_reason_for_tool")
+                _symbol_exists(
+                    "latticeai.api.agent_worker_seam.create_agent_worker_seam_router"
+                )
                 and not agent_alias_forbidden
             ) else "incomplete",
             evidence=[
-                "latticeai.core.agent_permission.block_reason_for_tool",
+                "rust/lattice-agent/src/permission.rs block_reason_for_tool (native owner)",
                 "latticeai.api.agent_worker_seam.create_agent_worker_seam_router",
                 "tests/unit/test_agent_worker_seam.py",
             ],
@@ -256,8 +253,10 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             title="Legacy shim sunset plan",
             status="complete" if shim_report["status"] == "managed" else "incomplete",
             evidence=[
+                # The standalone `check_legacy_debt.mjs` scanner retired once
+                # the shim layer hit zero; `legacy_shim_report` *is* the check
+                # now, and its status is what this gate reads.
                 "latticeai.services.architecture_readiness.legacy_shim_report",
-                "scripts/check_legacy_debt.mjs",
                 "tests/unit/test_legacy_root_shims.py",
             ],
         ),
@@ -291,7 +290,7 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
         "refactoring_order": list(PREFERRED_REFACTORING_ORDER),
         "boundaries": {
             "agent-runtime": {
-                "owner": "latticeai.core.agent_permission.block_reason_for_tool",
+                "owner": "lattice-agent::permission::block_reason_for_tool",
                 "surface": "/agent/llm + /agent/tool",
                 "status": "worker-seam",
             },

package/latticeai/services/process_audit.py

@@ -8,7 +8,7 @@ import os
 import re
 import time
 from pathlib import Path
-from typing import Any, Iterable, Mapping, Optional, Sequence
+from typing import Any, Mapping, Optional, Sequence
 
 _SECRET_RE = re.compile(
     r"(api[_-]?key|access[_-]?token|auth[_-]?token|bearer|client[_-]?secret|password|secret|token)",
@@ -104,27 +104,6 @@ def command_plan(
     }
 
 
-def command_plan_for_commands(
-    commands: Iterable[Sequence[Any]],
-    *,
-    name: str,
-    purpose: str = "installer",
-    cwd: Optional[str] = None,
-    metadata: Optional[Mapping[str, Any]] = None,
-) -> dict[str, Any]:
-    normalized = [_normalize_command(command) for command in commands]
-    digest = _digest_payload({"purpose": purpose, "commands": normalized, "cwd": cwd or ""})
-    return {
-        "name": name,
-        "purpose": purpose,
-        "command_count": len(normalized),
-        "command_hash": digest,
-        "confirmation_token": digest[:16],
-        "cwd": cwd,
-        "metadata": dict(metadata or {}),
-    }
-
-
 def verify_command_confirmation(
     command: Sequence[Any],
     provided_token: Optional[str],

package/latticeai/services/product_readiness.py

@@ -7,8 +7,12 @@ evidence that is probed on disk, so a gate only reports ``complete`` when its
 evidence actually resolves.
 
 v11.6.0 retargeted every needle that named a deleted Python product module
-onto the worker-only tree, the native owner, or the surviving test. The
-assertions themselves were not deleted.
+onto the worker-only tree, the native owner, or the surviving test. 11.8.0 did
+the same for the five needles that named a Python evaluation harness or parity
+generator whose subject is now native: they point at the cargo test or the
+committed golden that actually guards the behaviour. The assertions themselves
+were not deleted — an evidence path is repointed at the owner or it is a gate
+that has stopped meaning anything.
 """
 
 from __future__ import annotations
@@ -19,7 +23,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "11.6.0"
+PRODUCT_VERSION_TARGET = "11.9.0"
 
 
 @dataclass(frozen=True)
@@ -55,7 +59,11 @@ PRODUCT_GATES: List[ProductGate] = [
         title="Answers carry memory proof and citations",
         evidence=[
             "latticeai/api/search.py::embeddings_status",
-            "scripts/brain_quality_eval.py",
+            # 11.8.0: the Python answer-quality harness was deleted with the
+            # loop it drove. The committed agent/retrieval goldens are what a
+            # proof is checked against now, and they are regenerated by no
+            # Python — the manifest is the frozen grid itself.
+            "rust/fixtures/golden/manifest.json",
         ],
     ),
     ProductGate(
@@ -66,7 +74,7 @@ PRODUCT_GATES: List[ProductGate] = [
             "latticeai/tools/documents.py::read_document",
             "latticeai/tools/filesystem.py::read_file",
             "latticeai/core/tool_governor.py::classify_tool_call",
-            "latticeai/core/agent_permission.py::block_reason_for_tool",
+            "rust/lattice-agent/src/permission.rs::pub fn block_reason_for_tool",
             "tests/unit/test_worker_compute.py::test_the_docx_bytes_open_as_a_document_with_the_blocks_that_were_sent",
             "tests/unit/test_tool_registry.py::test_execute_tool_uses_registry",
         ],
@@ -111,10 +119,10 @@ PRODUCT_GATES: List[ProductGate] = [
             f"docs/CHANGELOG.md::## [{PRODUCT_VERSION_TARGET}]",
             "FEATURE_STATUS.md",
             f"RELEASE_NOTES_v{PRODUCT_VERSION_TARGET}.md",
-            "latticeai/core/agent_permission.py::block_reason_for_tool",
+            "rust/lattice-agent/src/permission.rs::pub fn block_reason_for_tool",
             "rust/lattice-agent/src/lib.rs::pub mod agentloop",
             "latticeai/api/agent_worker_seam.py::create_agent_worker_seam_router",
-            "latticeai/core/agent_permission.py::non_auto_plan_steps",
+            "rust/lattice-agent/src/permission.rs::pub fn non_auto_plan_steps",
             "latticeai/worker_app.py::create_worker_app",
             "latticeai/worker_app.py::def create_worker_app",
             "latticeai/services/architecture_readiness.py::lattice-architecture-contract/v1",
@@ -136,22 +144,36 @@ PRODUCT_GATES: List[ProductGate] = [
         title="Graph and ingestion integration coverage guards the Brain",
         evidence=[
             "tests/unit/test_worker_compute.py::test_extract_returns_the_structures_ingestion_consumes",
-            "tests/unit/test_worker_compute.py::test_a_picture_comes_back_as_the_facts_the_ingest_path_would_have_written",
+            # 11.8.0: `POST /worker/multimodal/describe` was deleted with the
+            # rest of the caller-less surface, so its seam test went too. The
+            # guarantee this gate needs — that an image becomes the exact facts
+            # and metadata an ingest writes — is asserted directly against
+            # Brain Core's `extract_image_facts`, which is where the seam only
+            # ever forwarded to. Repointed to the surviving equivalent rather
+            # than dropped: the gate still has to bite on image ingestion.
+            "tests/unit/test_cov_p1b_multimodal.py::test_extract_image_facts_unreadable_skipped_and_full_ports",
             "tests/unit/test_t3_vision_embedding.py",
             "tests/unit/test_lattice_brain_isolation.py",
-            "tests/unit/test_chunking_parity_contract.py",
+            # Chunking is native; the parity gate is the cargo test over the
+            # committed rust/fixtures/chunking goldens.
+            "rust/lattice-ingest/tests/chunking_parity.rs",
         ],
     ),
     ProductGate(
         id="quality-gates",
         title="Quality is guarded by repeatable gates",
         evidence=[
-            "scripts/brain_quality_eval.py",
+            "rust/lattice-retrieval/tests/parity.rs",
             "scripts/product_readiness.py",
             "tests/unit/test_product_readiness.py",
             "tests/visual/v3.surfaces.spec.js::Brain Chat Home",
             ".github/workflows/ci.yml::scripts/product_readiness.py",
-            ".github/workflows/release.yml::npm run lint",
+            # 11.8.0: the release workflow's lint step folded into the CI leg
+            # that already runs it. What this gate has to prove about a release
+            # is that a release *runs the readiness gate*, which is the needle
+            # below — naming a step by its shell text made the assertion track
+            # the workflow's wording rather than its guarantee.
+            ".github/workflows/release.yml::scripts/product_readiness.py",
         ],
     ),
 ]

package/latticeai/services/voice_capture.py

@@ -28,15 +28,18 @@ either, and both say so the same way.
 
 v11.6.0 took the *ingest* half away: ``POST /api/capture/voice`` is a native
 route that stores the memo itself and asks ``POST /worker/asr`` for the words.
-What is left is the transcriber and the two questions only this process can
-answer about it — can it hear, and what will it accept.
+v11.8.0 took the report away too — ``GET /api/capture/voice/status`` had no
+caller, and a capability answer nobody asks for is a second copy of the same
+facts ``/worker/asr`` already returns per call. What is left is the port
+itself: the transcriber, the two module constants ``/worker/asr`` enforces
+against, and the conversion into the shape Brain Core accepts.
 """
 
 from __future__ import annotations
 
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
+from typing import TYPE_CHECKING, Callable, Optional
 
 if TYPE_CHECKING:  # import-time isolation: the port is a callable, not a class
     from lattice_brain.multimodal import MultimodalPorts
@@ -62,35 +65,12 @@ class TranscriptionUnavailable(RuntimeError):
 
 
 class VoiceCaptureService:
-    """The local transcriber, and the honest report of whether there is one."""
+    """The local transcriber port, and the honest refusal when there is none."""
 
     def __init__(
-        self,
-        *,
-        transcriber: Optional[Callable[[str], str]] = None,
-        max_bytes: int = MAX_AUDIO_BYTES,
+        self, *, transcriber: Optional[Callable[[str], str]] = None
     ) -> None:
         self._transcriber = transcriber
-        self._max_bytes = max(1, int(max_bytes))
-
-    # ── capability ───────────────────────────────────────────────────────
-    def status(self) -> Dict[str, Any]:
-        """What this install can actually do with a voice memo, honestly."""
-        return {
-            # Storing the memo is native (``POST /api/capture/voice`` in
-            # lattice-platform), so capture is always available to a caller
-            # that reached this answer through the gateway. Only the
-            # transcriber is a fact about this process.
-            "capture": True,
-            "transcription": self._transcriber is not None,
-            "supported_extensions": sorted(SUPPORTED_AUDIO_EXTENSIONS),
-            "max_bytes": self._max_bytes,
-            "detail": (
-                "음성 메모를 글로 바꿔 Brain에 저장합니다."
-                if self._transcriber is not None
-                else "이 컴퓨터에는 음성 인식기가 없어서, 메모는 저장되지만 글로 바뀌지는 않습니다."
-            ),
-        }
 
     def multimodal_ports(self) -> "MultimodalPorts":
         """This service's transcriber, shaped for the ingestion pipeline.

package/latticeai/tools/__init__.py

@@ -41,54 +41,14 @@ _PLATFORM = platform.system()  # "Darwin" | "Windows" | "Linux"
 AGENT_ROOT = Path(os.getenv("LATTICEAI_AGENT_ROOT") or "agent_workspace").resolve()
 MAX_FILE_BYTES = 512_000
 MAX_COMMAND_SECONDS = 30
-MAX_BUILD_SECONDS = 180
-MAX_DEPLOY_SECONDS = 300
 MAX_COMMAND_OUTPUT = 12_000
 
-BLOCKED_COMMANDS = {
-    "rm",
-    "rmdir",
-    "sudo",
-    "su",
-    "chmod",
-    "chown",
-    "curl",
-    "wget",
-    "ssh",
-    "scp",
-    "rsync",
-    "dd",
-    "mkfs",
-    "diskutil",
-    "launchctl",
-}
-
-ALLOWED_COMMANDS = {
-    "pwd",
-    "ls",
-    "find",
-    "cat",
-    "head",
-    "tail",
-    "wc",
-    "rg",
-    "git",
-}
-
-BUILD_SCRIPT_NAMES = {"build", "compile", "typecheck", "test"}
-DEPLOY_SCRIPT_NAMES = {
-    "deploy",
-    "preview",
-    "release",
-    "package",
-    "dist",
-    "make",
-    "build:installer",
-    "build:pkg",
-    "build:exe",
-    "package:mac",
-    "package:win",
-}
+# The build/deploy script allow-lists and their longer timeouts used to live
+# here too. `run_build` / `run_deploy` are native (`lattice-agent`'s
+# `tools::shell`, which carries its own `BUILD_SCRIPT_NAMES`,
+# `DEPLOY_SCRIPT_NAMES`, `MAX_BUILD_SECONDS` and `MAX_DEPLOY_SECONDS`), so the
+# copies here had no reader in this interpreter — a second, unenforced
+# allow-list that could drift from the one that actually gates a subprocess.
 
 ALLOWED_GIT_SUBCOMMANDS = {"status", "diff", "log", "show"}
 

package/latticeai/tools/commands.py

@@ -1,4 +1,12 @@
-"""Command/build/deploy and read-only git tools (no shell, allow-listed)."""
+"""Read-only git tools (no shell, allow-listed subcommands).
+
+``run_command`` and its sandbox left the worker in v11.6.0 §W4 — execution is
+``lattice-agent``'s. The flag/binary allowlists that only that validator read
+went with it in 11.8.0; what is left here is the four git readers ``POST
+/agent/tool`` still dispatches, and the two argument guards they apply:
+remote targets are refused outright, and a revision may not carry ``..``,
+``:``, ``/``, ``\\`` or a leading ``-``.
+"""
 
 from __future__ import annotations
 
@@ -15,20 +23,6 @@ from latticeai.tools import (
     _resolve_path,
 )
 
-# find(1) flags that execute or delete; checked in run_command.
-_BLOCKED_FIND_FLAGS = {
-    "-delete",
-    "-exec",
-    "-execdir",
-    "-fls",
-    "-fprint",
-    "-fprintf",
-    "-ok",
-    "-okdir",
-}
-_BLOCKED_RG_FLAGS = {"--pre", "--pre-glob"}
-_SAFE_EXECUTABLE_PATH = "/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin:/usr/local/bin"
-
 
 def _run_git(args: List[str], cwd: Optional[str] = None) -> Dict[str, Any]:
     if not args:

package/latticeai/tools/knowledge.py

@@ -11,12 +11,6 @@ from latticeai.services.p_reinforce import BRAIN_DIR, STRUCTURE
 from latticeai.tools import ToolError
 
 
-def _safe_brain_folder(folder: str) -> str:
-    if folder not in STRUCTURE:
-        raise ToolError(f"Unknown knowledge folder: {folder}")
-    return folder
-
-
 def _scope_digest(kind: str, value: str) -> str:
     digest = hashlib.sha256(f"{kind}\0{value}".encode("utf-8")).hexdigest()[:24]
     return f"{kind}-{digest}"