ltcai 9.9.0 → 9.9.2

package/latticeai/api/chat_intents.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import logging
+import os
+import re
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import HTTPException, Request
 from fastapi.responses import JSONResponse, StreamingResponse
@@ -17,7 +19,43 @@ from latticeai.api.chat_helpers import (
 )
 from latticeai.api.chat_stream import agent_payload_stream, single_answer_response
 from latticeai.core.agent import AgentState
-from latticeai.core.file_generation import generate_file_content, infer_file_target
+from latticeai.core.file_generation import (
+    PREVIEWABLE_EXTENSIONS,
+    generate_file_content,
+    infer_file_target,
+)
+
+
+def next_available_path(root: Path, target: str) -> str:
+    """Return ``target`` unchanged, or a ``name_2.ext``-style variant when the
+    file already exists in the workspace.
+
+    The direct chat write path must never silently overwrite an existing file:
+    overwrites belong to the reviewable-proposal flow. Deterministic suffixing
+    keeps "make me an html page" repeatable without a 409 dead end.
+    """
+    candidate = (root / target)
+    if not candidate.exists():
+        return target
+    stem, suffix = candidate.stem, candidate.suffix
+    # An earlier auto-suffix run may have produced name_2 already; restart the
+    # numbering from the base name so we fill the first free slot.
+    base = re.sub(r"_\d+$", "", stem) or stem
+    for index in range(2, 100):
+        variant = candidate.with_name(f"{base}_{index}{suffix}")
+        if not variant.exists():
+            return str(Path(target).with_name(variant.name))
+    raise HTTPException(
+        status_code=409,
+        detail=f"'{target}' 이름의 파일이 너무 많습니다. 다른 이름을 지정해 주세요.",
+    )
+
+
+def ingest_generated_enabled() -> bool:
+    """Feature toggle for auto-indexing generated files into the Brain."""
+    return os.environ.get("LATTICEAI_INGEST_GENERATED", "1").strip().lower() not in {
+        "0", "false", "off", "no",
+    }
 
 
 class ChatIntentController:
@@ -41,6 +79,7 @@ class ChatIntentController:
         execute_tool: Any,
         agent_controller: Any,
         agent_root: Path,
+        ingestion_pipeline: Any = None,
     ) -> None:
         self.router = model_router
         self.config = config
@@ -59,6 +98,7 @@ class ChatIntentController:
         self.execute_tool = execute_tool
         self.agent_controller = agent_controller
         self.agent_root = Path(agent_root)
+        self.ingestion_pipeline = ingestion_pipeline
 
     def no_model_response(self) -> JSONResponse:
         detail = "No model loaded. Call /models/load first."
@@ -184,13 +224,25 @@ class ChatIntentController:
         )
         return single_answer_response(req, answer, model="client_url")
 
-    async def direct_file_action(self, req: Any, *, model_id: Optional[str]):
+    async def direct_file_action(
+        self,
+        req: Any,
+        *,
+        model_id: Optional[str],
+        effective_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ):
         # An explicit path ("report.txt") wins; otherwise infer one from an
         # explicit type keyword ("html 파일 만들어줘") so weak models never
         # have to drive the JSON tool loop just to create a file.
         target_path = file_action_target(req.message) or infer_file_target(req.message)
         if not target_path:
             return None
+        # Never silently overwrite: an existing target gets a _2/_3 suffix so
+        # regeneration is safe and repeatable without the proposal flow.
+        deduped_path = next_available_path(self.agent_root, target_path)
+        renamed = deduped_path != target_path
+        target_path = deduped_path
         content = inline_file_action_content(req.message)
         generation_meta: Optional[Dict[str, Any]] = None
         if content is None and not model_id:
@@ -227,19 +279,43 @@ class ChatIntentController:
             )
         except self.tool_error as exc:
             raise HTTPException(status_code=400, detail=str(exc)) from exc
-        answer = f"{result.get('path') or target_path} 파일을 만들었습니다."
-        if generation_meta and generation_meta.get("repaired"):
+        final_path = result.get("path") or target_path
+        answer = f"{final_path} 파일을 만들었습니다."
+        if renamed:
+            answer += " (같은 이름의 파일이 있어 새 이름으로 저장했습니다.)"
+        repaired = bool(generation_meta and generation_meta.get("repaired"))
+        if repaired:
             answer += (
                 " (모델 출력이 불완전해 자동 보정을 거쳐 유효한 파일로 저장했습니다.)"
             )
         created_files = [
             {
-                "path": result.get("path") or target_path,
-                "filename": Path(result.get("path") or target_path).name,
+                "path": final_path,
+                "filename": Path(final_path).name,
                 "bytes": result.get("bytes", 0),
                 "action": "write_file",
             }
         ]
+        # Artifact-first contract: every file the request produced, with the
+        # honesty flags the UI needs (valid vs repaired scaffold, previewable).
+        artifacts: List[Dict[str, Any]] = [
+            {
+                "kind": "file",
+                "path": final_path,
+                "filename": Path(final_path).name,
+                "bytes": result.get("bytes", 0),
+                "previewable": Path(final_path).suffix.lower() in PREVIEWABLE_EXTENSIONS,
+                "valid": True,
+                "repaired": repaired,
+            }
+        ]
+        brain_ingest = self._ingest_generated_file(
+            final_path,
+            content,
+            effective_email=effective_email,
+            workspace_id=workspace_id,
+            conversation_id=getattr(req, "conversation_id", None),
+        )
         self.notify("user", req.message, req.source)
         self.notify("assistant", answer, req.source)
         payload = {
@@ -257,11 +333,14 @@ class ChatIntentController:
             "state_history": [AgentState.EXECUTING.value, AgentState.DONE.value],
             "final_state": AgentState.DONE.value,
             "created_files": created_files,
+            "artifacts": artifacts,
             "routed_to_agent": True,
             "action_route": "direct_write_file",
         }
         if generation_meta is not None:
             payload["generation"] = generation_meta
+        if brain_ingest is not None:
+            payload["brain_ingest"] = brain_ingest
         if req.stream:
             return StreamingResponse(
                 agent_payload_stream(
@@ -275,6 +354,50 @@ class ChatIntentController:
             )
         return JSONResponse(content=payload)
 
+    def _ingest_generated_file(
+        self,
+        rel_path: str,
+        content: Optional[str],
+        *,
+        effective_email: Optional[str],
+        workspace_id: Optional[str],
+        conversation_id: Optional[str],
+    ) -> Optional[Dict[str, Any]]:
+        """Optionally index a just-generated file into the Brain.
+
+        The knowledge promise is "what Lattice makes, Lattice remembers":
+        without this, generated files are invisible to recall until the user
+        re-uploads them. Best-effort and additive — ingestion problems never
+        fail the file creation, and LATTICEAI_INGEST_GENERATED=0 disables it.
+        """
+        if self.ingestion_pipeline is None or not ingest_generated_enabled():
+            return None
+        try:
+            from lattice_brain.ingestion import IngestionItem
+
+            item = IngestionItem(
+                source_type="file",
+                title=Path(rel_path).name,
+                text=content,
+                path=str(self.agent_root / rel_path),
+                source_uri=f"workspace://{rel_path}",
+                owner=effective_email,
+                workspace_id=workspace_id,
+                conversation_id=conversation_id,
+                metadata={"origin": "generated_file", "route": "direct_write_file"},
+            )
+            result = self.ingestion_pipeline.ingest(item, user_email=effective_email)
+            payload = result.as_dict() if hasattr(result, "as_dict") else dict(result or {})
+            return {
+                "status": payload.get("status"),
+                "node_id": payload.get("node_id"),
+                "chunk_count": payload.get("chunk_count", 0),
+                "duplicate": payload.get("duplicate", False),
+            }
+        except Exception as exc:  # noqa: BLE001 — indexing must never break creation
+            logging.warning("generated-file ingest failed: %s", exc)
+            return {"status": "failed", "detail": str(exc)[:200]}
+
     async def route_file_to_agent(
         self,
         req: Any,

package/latticeai/app_factory.py

@@ -911,6 +911,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         chat_service=CHAT_SERVICE,
         context_assembler=CONTEXT_ASSEMBLER,
         brain_memory=BRAIN_MEMORY,
+        ingestion_pipeline=INGESTION_PIPELINE if ENABLE_GRAPH else None,
         chat_agent_runtime=CHAT_AGENT_RUNTIME,
         gardener=gardener,
         hooks=HOOKS_REGISTRY,

package/latticeai/core/agent.py

@@ -32,6 +32,7 @@ from typing import Any, Awaitable, Callable, Dict, FrozenSet, List, Optional, Tu
 from lattice_brain.runtime.hooks import dispatch_tool
 from lattice_brain.runtime.contracts import runtime_boundary_contract, single_agent_contract
 from latticeai.core.agent_trace import LoopTrace
+from latticeai.core.file_generation import infer_file_target, sanitize_write_content
 from latticeai.core.tool_registry import SCOPED_KNOWLEDGE_TOOLS
 from latticeai.tools import ToolError
 
@@ -141,6 +142,91 @@ def extract_action(raw: str) -> Dict:
     return action
 
 
+def normalize_plan(plan: Any, user_message: str) -> Tuple[Dict[str, Any], List[str]]:
+    """Enforce the minimal plan schema so execution never starts adrift.
+
+    A weak planner that returns junk steps / a missing goal previously flowed
+    straight into the executor, which then had to reconstruct intent from the
+    raw request. Normalization keeps the loop honest: ``goal`` is always a
+    non-empty string, ``steps`` only contains dicts with an ``action``, and an
+    empty plan for an obvious file-creation request gets a deterministic
+    single ``write_file`` step instead of leaving the executor to improvise.
+
+    Returns ``(plan, fixes)`` where ``fixes`` names every applied repair —
+    the loop trace records them so plan quality is observable per model.
+    """
+    fixes: List[str] = []
+    if not isinstance(plan, dict):
+        plan = {}
+        fixes.append("plan_not_object")
+    plan = dict(plan)
+
+    goal = str(plan.get("goal") or "").strip()
+    if not goal:
+        plan["goal"] = user_message
+        fixes.append("goal_defaulted")
+
+    raw_steps = plan.get("steps")
+    steps = [
+        s for s in (raw_steps if isinstance(raw_steps, list) else [])
+        if isinstance(s, dict) and s.get("action")
+    ]
+    if raw_steps and steps != raw_steps:
+        fixes.append("steps_filtered")
+    if not steps:
+        inferred = infer_file_target(user_message)
+        if inferred:
+            steps = [{
+                "action": "write_file",
+                "args": {"path": inferred},
+                "description": f"Create {inferred} for: {user_message[:120]}",
+            }]
+            fixes.append("heuristic_file_step")
+    plan["steps"] = steps
+
+    try:
+        estimated = int(plan.get("estimated_steps") or 0)
+    except (TypeError, ValueError):
+        estimated = 0
+        fixes.append("estimated_steps_invalid")
+    plan["estimated_steps"] = max(1, estimated, len(steps))
+    plan["requires_approval"] = bool(plan.get("requires_approval", False))
+    if not isinstance(plan.get("rollback_strategy"), str):
+        plan["rollback_strategy"] = "none"
+    return plan, fixes
+
+
+_TRIVIAL_LEARNING_RE = re.compile(
+    r"^(파일(을|이)?\s*(만들|생성|작성|저장)|작업(을|이)?\s*(완료|성공)|성공적으로"
+    r"|task\s+(was\s+)?complet|file\s+(was\s+)?(creat|written|saved)"
+    r"|(successfully\s+)?(created|completed|finished|done)\b)",
+    re.IGNORECASE,
+)
+
+
+def filter_learnings(learnings: List[Any]) -> List[str]:
+    """Drop trivial/duplicate learnings before they enter the brain.
+
+    "파일을 만들었다"-class statements restate what the transcript already
+    records and pollute recall. A learning survives when it is long enough to
+    carry information and is not a bare completion announcement.
+    """
+    kept: List[str] = []
+    seen: set = set()
+    for raw in learnings or []:
+        text = str(raw or "").strip()
+        if len(text) < 12:
+            continue
+        if _TRIVIAL_LEARNING_RE.match(text) and len(text) < 48:
+            continue
+        key = text.lower()
+        if key in seen:
+            continue
+        seen.add(key)
+        kept.append(text)
+    return kept
+
+
 @dataclass
 class AgentDeps:
     """The ports a :class:`SingleAgentRuntime` needs from the outside world.
@@ -258,6 +344,9 @@ class SingleAgentRuntime:
                 "goal": req.message, "steps": [],
                 "requires_approval": False, "rollback_strategy": "none", "estimated_steps": 1,
             }
+        plan, plan_fixes = normalize_plan(plan, req.message)
+        if plan_fixes:
+            ctx.trace.repair("plan", repairs=plan_fixes)
         ctx.plan = plan
         ctx.transcript.append({
             "state": AgentState.PLANNING.value,
@@ -266,6 +355,7 @@ class SingleAgentRuntime:
             "requires_approval": plan.get("requires_approval", False),
             "rollback_strategy": plan.get("rollback_strategy", "none"),
             "estimated_steps": plan.get("estimated_steps", 1),
+            **({"plan_fixes": plan_fixes} if plan_fixes else {}),
         })
         ctx.state = AgentState.WAITING_APPROVAL
 
@@ -557,6 +647,26 @@ class SingleAgentRuntime:
     ) -> None:
         """Role check + shared tool lifecycle, recorded on the transcript either way."""
         d = self.deps
+        sanitize_meta: Optional[Dict[str, Any]] = None
+        if name == "write_file" and isinstance(args.get("content"), str):
+            # ArtifactWritePipeline: the executor's args.content is untrusted
+            # model output. The same extract→validate→repair guarantee as the
+            # direct chat path applies here, so a weak model driving the JSON
+            # loop can never persist fenced/chatty/truncated payloads.
+            cleaned, meta = sanitize_write_content(
+                str(args.get("path") or ""), args["content"],
+                user_request=str(ctx.plan.get("goal") or thoughts or name),
+            )
+            if meta.get("sanitized"):
+                args = dict(args)
+                args["content"] = cleaned
+                sanitize_meta = meta
+                ctx.trace.repair(
+                    "execute",
+                    repairs=[
+                        "artifact_repair" if meta.get("repaired") else "artifact_sanitize"
+                    ],
+                )
         try:
             d.check_role(name, current_user)
             # Shared tool lifecycle: pre_tool (may block) → execute → post_tool.
@@ -570,6 +680,7 @@ class SingleAgentRuntime:
                 "state": AgentState.EXECUTING.value, "action": name,
                 "thoughts": thoughts, "args": args,
                 "risk": risk, "governance": dict(policy), "result": result,
+                **({"content_sanitize": sanitize_meta} if sanitize_meta else {}),
             })
         except (ToolError, KeyError, TypeError, PermissionError) as exc:
             ctx.trace.tool("execute", name=name, outcome="error", risk=risk)
@@ -791,8 +902,9 @@ class SingleAgentRuntime:
                 context=context, max_tokens=256, temperature=0.1,
             )
             mem = extract_action(str(raw))
-            if mem.get("save_to_knowledge") and mem.get("learnings"):
-                learnings = "\n".join(mem["learnings"])
+            kept_learnings = filter_learnings(mem.get("learnings") or [])
+            if mem.get("save_to_knowledge") and kept_learnings:
+                learnings = "\n".join(kept_learnings)
                 if d.brain_memory is not None:
                     # This runtime is LLM-driven — its learnings are real
                     # experiences and enter the brain with provenance.

package/latticeai/core/file_generation.py

@@ -195,6 +195,14 @@ def validate_file_content(content: str, target_path: str) -> Tuple[bool, str]:
             return False, "not a complete HTML document (missing <!DOCTYPE html>/<html>)"
         if "</html>" not in lower:
             return False, "HTML document is truncated (missing </html>)"
+        # A document that merely *contains* html somewhere is not a valid
+        # file payload: fenced/chat-wrapped replies must fail here so the
+        # extraction pass gets a chance to slice out the real document.
+        stripped = content.lstrip()
+        if not (stripped.lower().startswith("<!doctype") or stripped.lower().startswith("<html")):
+            return False, "HTML document is wrapped in prose or fences"
+        if "```" in content:
+            return False, "output still contains Markdown fences"
         return True, "ok"
     if ext == ".json":
         try:
@@ -359,6 +367,54 @@ def _repair_html(salvage: str, user_request: str) -> str:
     )
 
 
+# Extensions the Brain UI can render inline (preview) after creation.
+PREVIEWABLE_EXTENSIONS = frozenset({
+    ".html", ".htm", ".md", ".markdown", ".txt", ".json", ".css", ".js",
+    ".csv", ".py", ".yaml", ".yml", ".xml", ".sql", ".sh",
+})
+
+
+# ── write-side sanitize (ArtifactWritePipeline) ─────────────────────────
+
+def sanitize_write_content(
+    target_path: str,
+    content: Any,
+    user_request: str = "",
+) -> Tuple[str, Dict[str, Any]]:
+    """Single write-side guarantee for model-produced file content.
+
+    The direct chat path already runs the full generate→validate→repair
+    pipeline, but the agent JSON loop historically wrote ``args.content``
+    verbatim — weak models routinely put fenced/chatty payloads there. This
+    conservative sanitizer closes that gap for *any* write entry point:
+
+    1. content that already validates is returned byte-for-byte unchanged
+       (trusted/user-authored content is never mangled);
+    2. otherwise the extraction pass strips fences/think-blocks/chat noise
+       and is used only when the extracted payload validates;
+    3. otherwise deterministic repair guarantees a structurally valid file.
+
+    Empty content is left untouched (creating an empty file is a legitimate,
+    intentional action — e.g. ``__init__.py``). Returns ``(content, meta)``
+    where meta is ``{"sanitized": bool, "repaired": bool, "reason": str}``.
+    """
+    raw = str(content or "")
+    if not raw.strip():
+        return raw, {"sanitized": False, "repaired": False, "reason": "empty"}
+    ok, reason = validate_file_content(raw, target_path)
+    if ok:
+        return raw, {"sanitized": False, "repaired": False, "reason": "ok"}
+    extracted = extract_file_content(raw, target_path)
+    if extracted:
+        extracted_ok, _ = validate_file_content(extracted, target_path)
+        if extracted_ok:
+            return extracted, {"sanitized": True, "repaired": False, "reason": reason}
+    repaired = repair_file_content(
+        extracted or raw, target_path, user_request or f"content for {target_path}"
+    )
+    return repaired, {"sanitized": True, "repaired": True, "reason": reason}
+
+
 # ── filename inference ──────────────────────────────────────────────────
 
 _CREATE_VERB_RE = re.compile(
@@ -441,11 +497,13 @@ async def generate_file_content(
 
 
 __all__ = [
+    "PREVIEWABLE_EXTENSIONS",
     "build_file_generation_context",
     "extract_file_content",
     "generate_file_content",
     "infer_file_target",
     "looks_like_refusal",
     "repair_file_content",
+    "sanitize_write_content",
     "validate_file_content",
 ]

package/latticeai/core/legacy_compatibility.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 
-LEGACY_COMPATIBILITY_VERSION = "9.9.0"
+LEGACY_COMPATIBILITY_VERSION = "9.9.2"
 
 
 @dataclass(frozen=True)
@@ -40,106 +40,130 @@ class LegacyShim:
 
 
 LEGACY_SHIMS: List[LegacyShim] = [
+    LegacyShim(
+        path="server.py",
+        owner="latticeai.server_app",
+        replacement="from latticeai.server_app import app, main",
+        reason="Deployment docs, Docker CMD, start scripts, and uvicorn targets still use server:app.",
+        removal_phase="major-release-after-9.x",
+    ),
+]
+
+# Shim layers that have completed their compatibility window and were
+# physically deleted. Kept in the report so consumers (docs, tests, release
+# notes) can tell "removed on purpose" apart from "missing by accident".
+# Removing the internal-only layers is the first step of extracting
+# ``lattice_brain`` as a standalone Brain Core package: the package now has
+# exactly one import surface (``lattice_brain.*`` physical paths).
+REMOVED_SHIMS: List[LegacyShim] = [
     LegacyShim(
         path="knowledge_graph.py",
-        owner="lattice_brain.graph",
+        owner="lattice_brain.graph.store",
         replacement="from lattice_brain.graph.store import KnowledgeGraphStore",
-        reason="Historical scripts imported the graph store from the repo root.",
-        removal_phase="major-release-after-8.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="knowledge_graph_api.py",
         owner="latticeai.api.knowledge_graph",
         replacement="from latticeai.api.knowledge_graph import create_knowledge_graph_router",
-        reason="Older API composition roots imported the knowledge graph router from the repo root.",
-        removal_phase="major-release-after-8.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="kg_schema.py",
         owner="lattice_brain.graph.schema",
         replacement="from lattice_brain.graph.schema import ...",
-        reason="Historical graph schema tests and tools referenced root schema symbols.",
-        removal_phase="major-release-after-8.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="ltcai_cli.py",
         owner="latticeai.cli.entrypoint",
         replacement="from latticeai.cli.entrypoint import main",
-        reason="Console entry points and older package installs imported the CLI root module.",
-        removal_phase="major-release-after-8.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="telegram_bot.py",
         owner="latticeai.integrations.telegram_bot",
         replacement="from latticeai.integrations.telegram_bot import run_bot",
-        reason="Existing Telegram automation setups still import the legacy root module.",
-        removal_phase="major-release-after-8.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="p_reinforce.py",
         owner="latticeai.services.p_reinforce",
         replacement="from latticeai.services.p_reinforce import PReinforceGardener",
-        reason="Old gardener scripts referenced the root reinforcement helper.",
-        removal_phase="major-release-after-8.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="mcp_registry.py",
         owner="latticeai.core.mcp_registry",
         replacement="import latticeai.core.mcp_registry",
-        reason="Older integrations imported the MCP registry from the repo root.",
-        removal_phase="major-release-after-9.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="llm_router.py",
         owner="latticeai.models.router",
         replacement="import latticeai.models.router",
-        reason="Historical scripts and tests imported the LLM router from the repo root.",
-        removal_phase="major-release-after-9.x",
-    ),
-    LegacyShim(
-        path="server.py",
-        owner="latticeai.server_app",
-        replacement="from latticeai.server_app import app, main",
-        reason="Deployment docs and local launch scripts historically targeted server.py.",
-        removal_phase="major-release-after-8.x",
-    ),
-    LegacyShim(
-        path="tools/",
-        owner="latticeai.tools",
-        replacement="from latticeai.tools import execute_tool",
-        reason="Existing integrations and tests import the historical root tools package.",
-        removal_phase="major-release-after-9.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="local_knowledge_api.py",
         owner="latticeai.services.local_knowledge",
         replacement="from latticeai.services.local_knowledge import create_local_knowledge_router",
-        reason="Local folder ingestion integrations used the root local knowledge API.",
-        removal_phase="requires-api-route-migration",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="auto_setup.py",
         owner="latticeai.setup.auto_setup",
         replacement="from latticeai.setup.auto_setup import probe, recommend",
-        reason="Historical scripts invoke the zero-config setup module from the repo root.",
-        removal_phase="major-release-after-9.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
     LegacyShim(
         path="setup_wizard.py",
         owner="latticeai.setup.wizard",
         replacement="from latticeai.setup.wizard import scan_environment",
-        reason="Older integrations imported the setup wizard from the repo root.",
-        removal_phase="major-release-after-9.x",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
+    ),
+    LegacyShim(
+        path="tools/",
+        owner="latticeai.tools",
+        replacement="from latticeai.tools import execute_tool",
+        reason="Root compatibility shims completed their window; removed in 9.9.1.",
+        removal_phase="removed-9.9.1",
+        layer="root",
+        status="removed",
     ),
-]
-
-# Shim layers that have completed their compatibility window and were
-# physically deleted. Kept in the report so consumers (docs, tests, release
-# notes) can tell "removed on purpose" apart from "missing by accident".
-# Removing the internal-only layers is the first step of extracting
-# ``lattice_brain`` as a standalone Brain Core package: the package now has
-# exactly one import surface (``lattice_brain.*`` physical paths).
-REMOVED_SHIMS: List[LegacyShim] = [
     LegacyShim(
         path="lattice_brain/store.py",
         owner="lattice_brain.graph.store",

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "9.9.0"
+MARKETPLACE_VERSION = "9.9.2"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")