ltcai 6.2.0 → 6.3.0

package/frontend/src/pages/Capture.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { FolderPlus, Globe2, HardDrive, Upload } from "lucide-react";
+import { AlertCircle, CheckCircle2, FolderPlus, Globe2, HardDrive, Loader2, RotateCcw, Upload } from "lucide-react";
 import { latticeApi } from "@/api/client";
 import { ActionButton, DataPanel, EntityList, OperationResult, StructuredView, Tabs } from "@/components/primitives";
 import { Button } from "@/components/ui/button";
@@ -41,10 +41,20 @@ export function CapturePage({ initialTab }: { initialTab?: string }) {
 function FilesPanel() {
   const qc = useQueryClient();
   const docs = useQuery({ queryKey: ["documents"], queryFn: () => latticeApi.documents(200) });
+  const [queue, setQueue] = React.useState<UploadQueueItem[]>([]);
   const upload = useMutation({
-    mutationFn: (files: FileList) => Promise.all(Array.from(files).map((file) => latticeApi.uploadDocument(file))),
-    onSuccess: () => qc.invalidateQueries({ queryKey: ["documents"] }),
+    mutationFn: (files: File[]) => uploadFiles(files, setQueue),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: ["documents"] });
+      void qc.invalidateQueries({ queryKey: ["graphStats"] });
+      void qc.invalidateQueries({ queryKey: ["memoryManager"] });
+    },
   });
+  const beginUpload = React.useCallback((files: FileList | File[]) => {
+    const nextFiles = Array.from(files);
+    if (!nextFiles.length) return;
+    upload.mutate(nextFiles);
+  }, [upload]);
   return (
     <div className="grid gap-4 xl:grid-cols-[0.75fr_1.25fr]">
       <Card>
@@ -53,26 +63,105 @@ function FilesPanel() {
           <CardDescription>Choose files and Lattice will prepare them for search and memory.</CardDescription>
         </CardHeader>
         <CardContent>
-          <label className="flex min-h-56 cursor-pointer flex-col items-center justify-center gap-3 rounded-lg border border-dashed border-border bg-muted/30 p-6 text-center transition hover:bg-muted/50">
+          <label
+            className="flex min-h-56 cursor-pointer flex-col items-center justify-center gap-3 rounded-lg border border-dashed border-border bg-muted/30 p-6 text-center transition hover:bg-muted/50"
+            onDragOver={(event) => event.preventDefault()}
+            onDrop={(event) => {
+              event.preventDefault();
+              beginUpload(event.dataTransfer.files);
+            }}
+          >
             <Upload className="h-7 w-7 text-primary" />
-            <span className="text-lg font-semibold">Choose files</span>
-            <span className="max-w-sm text-sm leading-6 text-muted-foreground">PDF, Office files, notes, markdown, text, and spreadsheets are all welcome.</span>
-            <input type="file" multiple className="sr-only" onChange={(e) => e.target.files && upload.mutate(e.target.files)} />
+            <span className="text-lg font-semibold">Drop files or choose documents</span>
+            <span className="max-w-sm text-sm leading-6 text-muted-foreground">Each file is queued, parsed, written to Memory, and linked into the Brain graph with source metadata.</span>
+            <input type="file" multiple className="sr-only" onChange={(e) => e.target.files && beginUpload(e.target.files)} />
           </label>
-          {upload.data ? (
-            <div className="mt-3 space-y-2">
-              {upload.data.map((item, index) => <OperationResult key={index} result={item} successLabel="Upload completed" />)}
-            </div>
-          ) : null}
+          <DocumentUploadQueue queue={queue} onRetry={(file) => beginUpload([file])} />
         </CardContent>
       </Card>
       <DataPanel title="Uploaded documents" result={docs.data}>
-        {(data) => <EntityList items={(data as Record<string, unknown>).documents || data} titleKey="filename" metaKey="ingest_state" limit={12} />}
+        {(data) => (
+          <div className="space-y-3">
+            <EntityList items={(data as Record<string, unknown>).documents || data} titleKey="filename" metaKey="ingest_state" limit={12} />
+            <div className="rounded-md border border-border bg-background/55 p-3 text-sm text-muted-foreground">
+              Completed uploads appear here after they enter Memory. Graph links may continue building briefly after parsing finishes.
+            </div>
+          </div>
+        )}
       </DataPanel>
     </div>
   );
 }
 
+type UploadQueueItem = {
+  id: string;
+  file: File;
+  name: string;
+  size: number;
+  status: "queued" | "uploading" | "done" | "failed";
+  result?: Awaited<ReturnType<typeof latticeApi.uploadDocument>>;
+};
+
+async function uploadFiles(files: File[], setQueue: React.Dispatch<React.SetStateAction<UploadQueueItem[]>>) {
+  const rows = files.map((file) => ({
+    id: `${file.name}-${file.size}-${file.lastModified}-${Date.now()}`,
+    file,
+    name: file.name,
+    size: file.size,
+    status: "queued" as const,
+  }));
+  setQueue((items) => [...rows, ...items].slice(0, 12));
+  const results = [];
+  for (const row of rows) {
+    setQueue((items) => items.map((item) => item.id === row.id ? { ...item, status: "uploading" } : item));
+    const result = await latticeApi.uploadDocument(row.file);
+    results.push(result);
+    setQueue((items) => items.map((item) => item.id === row.id ? { ...item, status: result.ok ? "done" : "failed", result } : item));
+  }
+  return results;
+}
+
+function DocumentUploadQueue({ queue, onRetry }: { queue: UploadQueueItem[]; onRetry: (file: File) => void }) {
+  if (!queue.length) return null;
+  return (
+    <div className="mt-4 space-y-2">
+      {queue.map((item) => {
+        const detail = uploadResultDetail(item);
+        return (
+          <div key={item.id} className="rounded-md border border-border bg-background/55 p-3 text-sm">
+            <div className="flex flex-wrap items-start justify-between gap-3">
+              <div>
+                <div className="flex items-center gap-2 font-medium">
+                  {item.status === "done" ? <CheckCircle2 className="h-4 w-4 text-emerald-400" /> : item.status === "failed" ? <AlertCircle className="h-4 w-4 text-amber-400" /> : <Loader2 className="h-4 w-4 animate-spin text-primary" />}
+                  {item.name}
+                </div>
+                <div className="mt-1 text-xs text-muted-foreground">
+                  {Math.max(1, Math.round(item.size / 1024))} KB · {detail}
+                </div>
+              </div>
+              {item.status === "failed" ? (
+                <Button size="sm" variant="outline" onClick={() => onRetry(item.file)}>
+                  <RotateCcw className="h-3.5 w-3.5" /> Retry
+                </Button>
+              ) : null}
+            </div>
+            {item.result ? <OperationResult result={item.result} successLabel="Entered Brain and graph queue" /> : null}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+function uploadResultDetail(item: UploadQueueItem) {
+  if (item.status === "queued") return "Waiting in the ingest queue";
+  if (item.status === "uploading") return "Parsing and sending to Memory";
+  if (!item.result?.ok) return item.result?.error || "Ingest failed before it entered the Brain";
+  const data = item.result.data || {};
+  const node = String(data.node_id || data.graph_node || data.provenance_id || "");
+  return node ? `Captured with source metadata · ${node}` : "Captured with source metadata";
+}
+
 function LocalPanel() {
   const qc = useQueryClient();
   const [path, setPath] = React.useState("");

package/frontend/src/pages/Library.tsx

@@ -109,12 +109,20 @@ function ModelsPanel() {
             const profile = (data as Record<string, unknown>).profile as Record<string, unknown> | undefined;
             return (
               <div className="space-y-4">
-                <StatGrid stats={[
-                  { label: "Computer", value: profile?.os ? `${String(profile.os)} ${String(profile.arch || "")}` : "detected" },
-                  { label: "Memory", value: recommendation?.ram_gb ? `${String(recommendation.ram_gb)} GB` : "checking" },
-                  { label: "Top pick", value: topPick?.name || topPick?.id || "choose below" },
-                  { label: "Current", value: current?.name || currentId || "none" },
-                ]} />
+                <ModelRuntimeSummary
+                  profile={profile || {}}
+                  recommendation={recommendation || {}}
+                  current={current}
+                  currentId={currentId}
+                  latestProgress={latestProgress}
+                  lastResult={lastResult}
+                  onReload={() => {
+                    if (current) void prepareModel(String(current.recommended_load_id || current.id || currentId), String(current.recommended_engine || current.engine || "local_mlx"), consent);
+                  }}
+                  onUnload={() => {
+                    if (currentId) void latticeApi.unloadModel(currentId).then(() => qc.invalidateQueries({ queryKey: ["models"] }));
+                  }}
+                />
                 <div className="grid gap-2 md:grid-cols-3 xl:grid-cols-6">
                   {[
                     ["Environment Analysis", true, Cpu],
@@ -296,6 +304,64 @@ function AlternativeModels({ compatibility }: { compatibility: Record<string, un
   );
 }
 
+function ModelRuntimeSummary({
+  profile,
+  recommendation,
+  current,
+  currentId,
+  latestProgress,
+  lastResult,
+  onReload,
+  onUnload,
+}: {
+  profile: Record<string, unknown>;
+  recommendation: Record<string, unknown>;
+  current?: Record<string, unknown>;
+  currentId: string;
+  latestProgress: Record<string, unknown> | null;
+  lastResult: Record<string, unknown> | null;
+  onReload: () => void;
+  onUnload: () => void;
+}) {
+  const loadedName = String(current?.name || current?.id || currentId || "");
+  const engine = String(current?.engine || current?.recommended_engine || latestProgress?.engine || "local_mlx");
+  const cachePath = String(current?.local_path || current?.storage_location || recommendation.cache_path || recommendation.storage_location || "~/.cache/huggingface / ~/.latticeai/models");
+  const progressStage = String(latestProgress?.stage || lastResult?.stage || (loadedName ? "ready" : "idle"));
+  return (
+    <div className="space-y-3">
+      <StatGrid stats={[
+        { label: "Computer", value: profile?.os ? `${String(profile.os)} ${String(profile.arch || "")}` : "detected" },
+        { label: "Engine", value: engine },
+        { label: "Loaded model", value: loadedName || "No local model loaded" },
+        { label: "Runtime state", value: progressStage },
+      ]} />
+      <div className="rounded-lg border border-border bg-background/55 p-3 text-sm">
+        <div className="flex flex-wrap items-start justify-between gap-3">
+          <div>
+            <div className="font-medium">{loadedName ? "Local model runtime is available" : "No model is loaded yet"}</div>
+            <div className="mt-1 text-muted-foreground">Cache/storage: {cachePath}</div>
+          </div>
+          <div className="flex flex-wrap gap-2">
+            <Button variant="outline" size="sm" disabled={!loadedName} onClick={onReload}>Reload</Button>
+            <Button variant="outline" size="sm" disabled={!loadedName} onClick={onUnload}>Unload</Button>
+          </div>
+        </div>
+        {latestProgress ? (
+          <div className="mt-3">
+            <div className="flex justify-between text-xs text-muted-foreground">
+              <span>{String(latestProgress.message || "Preparing model")}</span>
+              <span>{Number(latestProgress.percent || 0)}%</span>
+            </div>
+            <div className="mt-1 h-2 overflow-hidden rounded-full bg-muted">
+              <div className="h-full bg-primary" style={{ width: `${Number(latestProgress.percent || 8)}%` }} />
+            </div>
+          </div>
+        ) : null}
+      </div>
+    </div>
+  );
+}
+
 function ModelRecovery({ error }: { error: Record<string, unknown> }) {
   const guidance = asArray<string>(error.recovery_guidance);
   return (

package/lattice_brain/__init__.py

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

package/lattice_brain/runtime/multi_agent.py

@@ -19,7 +19,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "6.2.0"
+MULTI_AGENT_VERSION = "6.3.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "6.2.0"
+__version__ = "6.3.0"

package/latticeai/app_factory.py

@@ -20,6 +20,11 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from latticeai.runtime.app_context_runtime import build_app_context
 from latticeai.runtime.bootstrap import build_session_runtime
 from latticeai.runtime.brain_runtime import build_brain_runtime
+from latticeai.runtime.chat_wiring import (
+    build_chat_agent_runtime_from_context,
+    build_interaction_contexts,
+    maybe_build_telegram_chat_mirror,
+)
 from latticeai.runtime.config_runtime import build_config_runtime
 from latticeai.runtime.context_runtime import build_context_runtime
 from latticeai.runtime.hooks_runtime import (
@@ -28,12 +33,16 @@ from latticeai.runtime.hooks_runtime import (
     build_hooks_runtime,
 )
 from latticeai.runtime.lifespan_runtime import build_lifespan_runtime
+from latticeai.runtime.model_wiring import (
+    configure_model_runtime_from_context,
+    register_model_runtime_routers,
+)
 from latticeai.runtime.platform_services_runtime import (
     build_brain_network,
-    build_model_service,
 )
 from latticeai.runtime.platform_runtime_wiring import build_platform_automation_runtime
 from latticeai.runtime.persistence_runtime import build_persistence_runtime
+from latticeai.runtime.review_wiring import build_review_run_now_runner
 from latticeai.runtime.router_registration import (
     build_auth_admin_security_router_bundle,
     build_static_routes_bundle,
@@ -44,8 +53,8 @@ from latticeai.runtime.router_registration import (
     register_review_and_brain_tail_routers,
 )
 from latticeai.runtime.security_runtime import build_security_runtime
+from latticeai.runtime.tail_wiring import register_tail_runtime_routers
 from latticeai.runtime.web_runtime import build_web_runtime
-from latticeai.services.router_context import InteractionRouterContext, ToolRouterContext
 
 if TYPE_CHECKING:  # imports for annotations only — keep module import light
     from fastapi import FastAPI
@@ -1089,7 +1098,8 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     OPEN_REGISTRATION = CONFIG.open_registration
     INVITE_CODE = CONFIG.invite_code
     INVITE_GATE_ENABLED = CONFIG.invite_gate_enabled
-    configure_model_runtime(
+    configure_model_runtime_from_context(
+        configure_model_runtime=configure_model_runtime,
         router=router,
         APP_MODE=APP_MODE,
         DEFAULT_HOST=DEFAULT_HOST,
@@ -1236,12 +1246,10 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     # ── Telegram chat mirror: registered only when ENABLE_TELEGRAM is truthy.
     # latticeai.api.chat no longer imports telegram_bot (a 45KB module that
     # mutates os.environ at import); it calls this injected callback instead.
-    on_chat_message = None
-    if ENABLE_TELEGRAM:
-        def _telegram_chat_mirror(role: str, text: str, source: Optional[str] = None) -> None:
-            from latticeai.integrations.telegram_bot import broadcast_web_chat
-            _spawn(broadcast_web_chat(role, text), name="telegram_broadcast")
-        on_chat_message = _telegram_chat_mirror
+    on_chat_message = maybe_build_telegram_chat_mirror(
+        enable_telegram=ENABLE_TELEGRAM,
+        spawn=_spawn,
+    )
 
     def _recent_chat_context(
         limit: int = 10,
@@ -1257,7 +1265,8 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             conversation_id=conversation_id,
         )
 
-    CHAT_AGENT_RUNTIME = build_agent_runtime(
+    CHAT_AGENT_RUNTIME = build_chat_agent_runtime_from_context(
+        build_agent_runtime=build_agent_runtime,
         model_router=router,
         execute_tool=execute_tool,
         recent_chat_context=_recent_chat_context,
@@ -1404,22 +1413,19 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     # ── Health / status / engine-summary router (latticeai.api.health, v1.2.0) ───
     # /health, /mode, /runtime_features, /engines(GET) now live in the health router.
     # Heavier engine mutation endpoints remain below in server_app.
-    MODEL_SERVICE = build_model_service(
+    MODEL_SERVICE = register_model_runtime_routers(
+        app=app,
+        create_health_router=create_health_router,
+        create_models_router=create_models_router,
+        register_health_and_model_routers=register_health_and_model_routers,
         model_router=router,
         runtime_features=runtime_features,
-        is_public=IS_PUBLIC_MODE,
-    )
-    register_health_and_model_routers(
-        app,
-        create_health_router=create_health_router,
-        model_service=MODEL_SERVICE,
+        is_public_mode=IS_PUBLIC_MODE,
         engine_status=engine_status,
         get_current_user=get_current_user,
         require_auth=REQUIRE_AUTH,
         app_version=APP_VERSION,
         app_mode=APP_MODE,
-        create_models_router=create_models_router,
-        model_router=router,
         require_user=require_user,
         load_users=load_users,
         get_user_role=get_user_role,
@@ -1438,7 +1444,6 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         engine_model_catalog=ENGINE_MODEL_CATALOG,
         model_engine_aliases=MODEL_ENGINE_ALIASES,
         cloud_verify_ttl_seconds=CLOUD_VERIFY_TTL_SECONDS,
-        is_public_mode=IS_PUBLIC_MODE,
         allow_local_models=ALLOW_LOCAL_MODELS,
     )
 
@@ -1461,7 +1466,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             return None
         return PLATFORM.allowed_scopes(user)
 
-    tool_router_context = ToolRouterContext(
+    tool_router_context, interaction_router_context = build_interaction_contexts(
         config=CONFIG,
         ingestion_pipeline=INGESTION_PIPELINE,
         data_dir=DATA_DIR,
@@ -1485,15 +1490,10 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         install_mcp=install_mcp,
         mcp_public_item=mcp_public_item,
         hooks=HOOKS_REGISTRY,
-    )
-    interaction_router_context = InteractionRouterContext(
         chat_context=context,
         search_service=SEARCH_SERVICE,
         allowed_workspaces_for=_allowed_workspaces_for,
-        require_user=require_user,
         embedding_info=_embedding_info,
-        tool_context=tool_router_context,
-        hooks=HOOKS_REGISTRY,
         agent_registry=AGENT_REGISTRY,
         memory_service=MEMORY_SERVICE,
         platform=PLATFORM,
@@ -1510,25 +1510,17 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     )
 
     from latticeai.api.review_queue import create_review_queue_router
+    run_review_item = build_review_run_now_runner(PLATFORM, HTTPException)
 
-    def _run_review_item(item, *, user_email, scope):
-        """run_now: re-execute the suggestion's source workflow (preview/regenerate)."""
-        wf_id = (item.get("payload") or {}).get("workflow_id") or (item.get("provenance") or {}).get("workflow_id")
-        if not wf_id:
-            raise HTTPException(status_code=409, detail="review item has no workflow to run")
-        return PLATFORM.run_workflow_by_id(
-            wf_id, user_email, scope, with_agent=False,
-            inputs={"__review_item__": item.get("id")},
-        )
-
-    BRAIN_NETWORK = register_review_and_brain_tail_routers(
-        app,
+    BRAIN_NETWORK = register_tail_runtime_routers(
+        app=app,
         create_review_queue_router=create_review_queue_router,
+        register_review_and_brain_tail_routers=register_review_and_brain_tail_routers,
         review_queue=REVIEW_QUEUE,
         require_user=require_user,
         gate_read=PLATFORM.gate_read,
         gate_write=PLATFORM.gate_write,
-        run_review_item=_run_review_item,
+        run_review_item=run_review_item,
         append_audit_event=append_audit_event,
         create_browser_router=create_browser_router,
         ingestion_pipeline=INGESTION_PIPELINE,

package/latticeai/core/marketplace.py

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

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "6.2.0"
+WORKSPACE_OS_VERSION = "6.3.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/runtime/chat_wiring.py

@@ -0,0 +1,119 @@
+"""Chat and interaction wiring seam for ``latticeai.app_factory``."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from latticeai.services.router_context import InteractionRouterContext, ToolRouterContext
+
+
+def build_chat_agent_runtime_from_context(
+    *,
+    build_agent_runtime: Any,
+    model_router: Any,
+    execute_tool: Any,
+    recent_chat_context: Any,
+    clear_history: Any,
+    knowledge_save: Any,
+    audit: Any,
+    hooks: Any,
+    brain_memory: Any,
+) -> Any:
+    return build_agent_runtime(
+        model_router=model_router,
+        execute_tool=execute_tool,
+        recent_chat_context=recent_chat_context,
+        clear_history=clear_history,
+        knowledge_save=knowledge_save,
+        audit=audit,
+        hooks=hooks,
+        brain_memory=brain_memory,
+    )
+
+
+def build_interaction_contexts(
+    *,
+    config: Any,
+    ingestion_pipeline: Any,
+    data_dir: Any,
+    static_dir: Any,
+    model_router: Any,
+    require_user: Any,
+    require_admin: Any,
+    get_current_user: Any,
+    clear_history: Any,
+    append_audit_event: Any,
+    enforce_rate_limit: Any,
+    bytes_match_extension: Any,
+    classify_sensitive_message: Any,
+    save_to_history: Any,
+    enable_graph: bool,
+    knowledge_graph: Any,
+    require_graph: Any,
+    local_kg_watcher: Any,
+    load_mcp_installs: Any,
+    recommend_mcps: Any,
+    install_mcp: Any,
+    mcp_public_item: Any,
+    hooks: Any,
+    chat_context: Any,
+    search_service: Any,
+    allowed_workspaces_for: Any,
+    embedding_info: Any,
+    agent_registry: Any,
+    memory_service: Any,
+    platform: Any,
+) -> tuple[ToolRouterContext, InteractionRouterContext]:
+    tool_router_context = ToolRouterContext(
+        config=config,
+        ingestion_pipeline=ingestion_pipeline,
+        data_dir=data_dir,
+        static_dir=static_dir,
+        model_router=model_router,
+        require_user=require_user,
+        require_admin=require_admin,
+        get_current_user=get_current_user,
+        clear_history=clear_history,
+        append_audit_event=append_audit_event,
+        enforce_rate_limit=enforce_rate_limit,
+        bytes_match_extension=bytes_match_extension,
+        classify_sensitive_message=classify_sensitive_message,
+        save_to_history=save_to_history,
+        enable_graph=enable_graph,
+        knowledge_graph=knowledge_graph,
+        require_graph=require_graph,
+        local_kg_watcher=local_kg_watcher,
+        load_mcp_installs=load_mcp_installs,
+        recommend_mcps=recommend_mcps,
+        install_mcp=install_mcp,
+        mcp_public_item=mcp_public_item,
+        hooks=hooks,
+    )
+    interaction_router_context = InteractionRouterContext(
+        chat_context=chat_context,
+        search_service=search_service,
+        allowed_workspaces_for=allowed_workspaces_for,
+        require_user=require_user,
+        embedding_info=embedding_info,
+        tool_context=tool_router_context,
+        hooks=hooks,
+        agent_registry=agent_registry,
+        memory_service=memory_service,
+        platform=platform,
+    )
+    return tool_router_context, interaction_router_context
+
+
+def maybe_build_telegram_chat_mirror(
+    *,
+    enable_telegram: bool,
+    spawn: Any,
+) -> Optional[Any]:
+    if not enable_telegram:
+        return None
+
+    def telegram_chat_mirror(role: str, text: str, source: Optional[str] = None) -> None:
+        from latticeai.integrations.telegram_bot import broadcast_web_chat
+        spawn(broadcast_web_chat(role, text), name="telegram_broadcast")
+
+    return telegram_chat_mirror

package/latticeai/runtime/model_wiring.py

@@ -0,0 +1,40 @@
+"""Model/runtime wiring seam for ``latticeai.app_factory``."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from latticeai.runtime.platform_services_runtime import build_model_service
+
+
+def configure_model_runtime_from_context(**kwargs: Any) -> None:
+    configure_model_runtime = kwargs.pop("configure_model_runtime")
+    configure_model_runtime(**kwargs)
+
+
+def register_model_runtime_routers(
+    *,
+    app: Any,
+    create_health_router: Any,
+    create_models_router: Any,
+    register_health_and_model_routers: Any,
+    model_router: Any,
+    runtime_features: Any,
+    is_public_mode: bool,
+    **kwargs: Any,
+) -> Any:
+    model_service = build_model_service(
+        model_router=model_router,
+        runtime_features=runtime_features,
+        is_public=is_public_mode,
+    )
+    register_health_and_model_routers(
+        app,
+        create_health_router=create_health_router,
+        model_service=model_service,
+        create_models_router=create_models_router,
+        model_router=model_router,
+        is_public_mode=is_public_mode,
+        **kwargs,
+    )
+    return model_service

package/latticeai/runtime/platform_runtime_wiring.py

@@ -9,9 +9,6 @@ from __future__ import annotations
 
 from typing import Any, Callable, Dict
 
-from latticeai.runtime.automation_runtime import build_automation_runtime
-from latticeai.services.platform_runtime import PlatformRuntime
-
 
 def build_platform_automation_runtime(
     *,
@@ -34,6 +31,8 @@ def build_platform_automation_runtime(
     ``app_factory._build`` so ``dict(locals())`` continues to expose the legacy
     ``server_app`` compatibility surface.
     """
+    from latticeai.runtime.automation_runtime import build_automation_runtime
+    from latticeai.services.platform_runtime import PlatformRuntime
 
     def _llm_generate_sync(
         message: str,

package/latticeai/runtime/review_wiring.py

@@ -0,0 +1,37 @@
+"""Review Center runtime wiring helpers."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+
+def build_review_run_now_runner(platform: Any, http_exception: type[Exception]) -> Callable[..., Any]:
+    """Build the Review Center run-now runner used by the API router.
+
+    The runner preserves the public contract: "Run now" previews/regenerates the
+    source workflow, records a fresh run id, and leaves approval status unchanged.
+    """
+
+    def run_review_item(
+        item: Dict[str, Any],
+        *,
+        user_email: Optional[str],
+        scope: Optional[str],
+    ) -> Any:
+        payload = item.get("payload") or {}
+        provenance = item.get("provenance") or {}
+        workflow_id = payload.get("workflow_id") or provenance.get("workflow_id")
+        if not workflow_id:
+            raise http_exception(status_code=409, detail="review item has no workflow to run")
+        return platform.run_workflow_by_id(
+            workflow_id,
+            user_email,
+            scope,
+            with_agent=False,
+            inputs={"__review_item__": item.get("id")},
+        )
+
+    return run_review_item
+
+
+__all__ = ["build_review_run_now_runner"]