ltcai 9.5.0 → 9.7.0

package/latticeai/api/change_proposals.py

@@ -0,0 +1,89 @@
+"""Change proposal API router (v9.6.0).
+
+Read/approve/reject surface over
+:class:`~latticeai.services.change_proposals.ChangeProposalService`. The
+items live in the shared review queue (source ``change_proposal``), so the
+Act review center shows them too; this router adds the proposal-specific
+semantics: **approve applies the staged content exactly as reviewed**,
+reject discards it, and nothing touches disk while a proposal is pending.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+from latticeai.services.change_proposals import ChangeProposalService
+
+
+class RejectProposalRequest(BaseModel):
+    """Optional rejection context — kept in the item's provenance."""
+
+    reason: str = ""
+
+
+def create_change_proposals_router(
+    *,
+    service: ChangeProposalService,
+    require_user: Callable[[Request], str],
+    gate_read: Callable[[Request], Optional[str]],
+    gate_write: Callable[[Request], Optional[str]],
+) -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/api/proposals")
+    async def list_proposals(request: Request):
+        user = require_user(request)
+        scope = gate_read(request)
+        return service.pending(user_email=user, workspace_id=scope)
+
+    # NOTE: declared before /api/proposals/{item_id} so "counts" never
+    # resolves as an item id.
+    @router.get("/api/proposals/counts")
+    async def proposal_counts(request: Request):
+        user = require_user(request)
+        scope = gate_read(request)
+        return service.counts(user_email=user, workspace_id=scope)
+
+    @router.get("/api/proposals/{item_id}")
+    async def get_proposal(item_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return service.get_proposal(item_id, workspace_id=scope)
+        except (KeyError, FileNotFoundError) as exc:
+            raise HTTPException(status_code=404, detail=str(exc))
+
+    @router.post("/api/proposals/{item_id}/approve")
+    async def approve_proposal(item_id: str, request: Request):
+        user = require_user(request)
+        scope = gate_write(request)
+        try:
+            return service.approve_and_apply(
+                item_id, user_email=user, workspace_id=scope
+            )
+        except (KeyError, FileNotFoundError) as exc:
+            raise HTTPException(status_code=404, detail=str(exc))
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc))
+
+    @router.post("/api/proposals/{item_id}/reject")
+    async def reject_proposal(
+        item_id: str, request: Request, req: Optional[RejectProposalRequest] = None
+    ):
+        user = require_user(request)
+        scope = gate_write(request)
+        try:
+            return service.reject(
+                item_id, user_email=user, workspace_id=scope,
+                reason=(req.reason if req else ""),
+            )
+        except (KeyError, FileNotFoundError) as exc:
+            raise HTTPException(status_code=404, detail=str(exc))
+
+    return router
+
+
+__all__ = ["create_change_proposals_router", "RejectProposalRequest"]

package/latticeai/api/chat_agent_http.py

@@ -229,6 +229,7 @@ class AgentHTTPController:
                 "planning_model": req.planning_model or self.model_router.current_model_id,
                 "executing_model": req.executing_model or self.model_router.current_model_id,
                 "reviewing_model": req.reviewing_model or self.model_router.current_model_id,
+                "loop": ctx.trace.summary(),
             }
 
         self.runtime.approve(ctx, current_user, approved_by_human=False)
@@ -306,6 +307,7 @@ class AgentHTTPController:
             "state_history": ctx.state_history,
             "final_state": ctx.state.value,
             "created_files": collect_created_files(ctx.transcript),
+            "loop": ctx.trace.summary(),
         }
 
     async def resume(

package/latticeai/api/review_queue.py

@@ -56,6 +56,18 @@ class SnoozeRequest(BaseModel):
     until: str
 
 
+class DismissRequest(BaseModel):
+    """Optional dismissal context (e.g. why a change proposal was rejected)."""
+
+    reason: str = ""
+
+
+class ReviewCounts(BaseModel):
+    pending: int = 0
+    snoozed: int = 0
+    pending_by_source: Dict[str, int] = Field(default_factory=dict)
+
+
 def create_review_queue_router(
     *,
     service: ReviewQueueService,
@@ -64,7 +76,13 @@ def create_review_queue_router(
     gate_write: Callable[[Request], Optional[str]],
     run_review_item: Callable[..., Any],
     append_audit_event: Callable[..., None],
+    change_proposals: Any = None,
 ) -> APIRouter:
+    """``change_proposals`` (optional) closes the governance loop: approving a
+    ``change_proposal`` item from the Review Center applies the staged content
+    via :class:`~latticeai.services.change_proposals.ChangeProposalService`
+    instead of merely flipping the status — the same single application path
+    the /api/proposals surface uses."""
     router = APIRouter()
 
     @router.get("/automation/reviews", response_model=ReviewItemList)
@@ -95,6 +113,14 @@ def create_review_queue_router(
         append_audit_event("review_item_created", user_email=user, item_id=item["id"])
         return item
 
+    # NOTE: declared before /automation/reviews/{item_id} so "counts" never
+    # resolves as an item id.
+    @router.get("/automation/reviews/counts", response_model=ReviewCounts)
+    async def review_counts(request: Request):
+        user = require_user(request)
+        scope = gate_read(request)
+        return service.counts(workspace_id=scope, user_email=user)
+
     @router.get("/automation/reviews/{item_id}", response_model=ReviewItem)
     async def get_item(item_id: str, request: Request):
         require_user(request)
@@ -106,11 +132,49 @@ def create_review_queue_router(
 
     @router.post("/automation/reviews/{item_id}/approve", response_model=ReviewItem)
     async def approve_item(item_id: str, request: Request):
+        user = require_user(request)
+        scope = gate_write(request)
+        # change_proposal items must apply the staged content on approve —
+        # otherwise the item flips to "approved" while nothing hits disk.
+        if change_proposals is not None:
+            try:
+                stored = service.get(item_id, workspace_id=scope)
+            except FileNotFoundError as exc:
+                raise HTTPException(status_code=404, detail="review item not found") from exc
+            if stored.get("source") == "change_proposal":
+                if stored.get("effective_status") not in ("pending", "snoozed"):
+                    raise HTTPException(
+                        status_code=409,
+                        detail=f"cannot 'approve' a review item in status {stored.get('status')!r}",
+                    )
+                try:
+                    applied = change_proposals.approve_and_apply(
+                        item_id, user_email=user, workspace_id=scope
+                    )
+                except (KeyError, FileNotFoundError) as exc:
+                    raise HTTPException(status_code=404, detail=str(exc)) from exc
+                except ValueError as exc:
+                    raise HTTPException(status_code=400, detail=str(exc)) from exc
+                append_audit_event("review_item_approve", user_email=user, item_id=item_id)
+                return applied["item"]
         return _act(request, item_id, "approve")
 
     @router.post("/automation/reviews/{item_id}/dismiss", response_model=ReviewItem)
-    async def dismiss_item(item_id: str, request: Request):
-        return _act(request, item_id, "dismiss")
+    async def dismiss_item(
+        item_id: str, request: Request, req: Optional[DismissRequest] = None
+    ):
+        user = require_user(request)
+        scope = gate_write(request)
+        try:
+            item = service.dismiss(
+                item_id, workspace_id=scope, reason=(req.reason if req else None)
+            )
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail="review item not found") from exc
+        except InvalidReviewTransition as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+        append_audit_event("review_item_dismiss", user_email=user, item_id=item_id)
+        return item
 
     @router.post("/automation/reviews/{item_id}/snooze", response_model=ReviewItem)
     async def snooze_item(item_id: str, req: SnoozeRequest, request: Request):

package/latticeai/app_factory.py

@@ -169,6 +169,9 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.api.brain_intelligence import create_brain_intelligence_router
     from latticeai.api.command_center import create_command_center_router
     from latticeai.services.command_center import CommandCenterService
+    from latticeai.api.change_proposals import create_change_proposals_router
+    from latticeai.services.change_proposals import ChangeProposalService
+    from latticeai.tools import resolve_workspace_path
     from latticeai.api.memory import create_memory_router
     from latticeai.api.browser import create_browser_router
     from latticeai.api.portability import create_portability_router
@@ -1051,6 +1054,23 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             gate_read=PLATFORM.gate_read,
         )
     )
+    CHANGE_PROPOSALS = ChangeProposalService(
+        review_queue=REVIEW_QUEUE,
+        resolve_path=resolve_workspace_path,
+        audit=append_audit_event,
+    )
+    # Proposal-first mutations: the agent loop consults the governor so
+    # additive creates run with minimal friction while changes/deletions of
+    # existing files are staged for review instead of applied.
+    CHAT_AGENT_RUNTIME.deps.change_governor = CHANGE_PROPOSALS
+    app.include_router(
+        create_change_proposals_router(
+            service=CHANGE_PROPOSALS,
+            require_user=require_user,
+            gate_read=PLATFORM.gate_read,
+            gate_write=PLATFORM.gate_write,
+        )
+    )
 
 
     # ── Health & Info ──────────────────────────────────────────────────────────────
@@ -1174,6 +1194,9 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         gate_write=PLATFORM.gate_write,
         run_review_item=run_review_item,
         append_audit_event=append_audit_event,
+        # Approving a change_proposal from the Review Center applies the
+        # staged content through the same service the agent governor uses.
+        change_proposals=CHANGE_PROPOSALS,
         create_browser_router=create_browser_router,
         ingestion_pipeline=INGESTION_PIPELINE,
         workspace_service=WORKSPACE_SERVICE,

package/latticeai/cli/entrypoint.py

@@ -157,7 +157,9 @@ def _start_tunnel(port: int) -> str | None:
     log_path = Path.home() / ".latticeai" / "tunnel.log"
     log_path.parent.mkdir(parents=True, exist_ok=True)
 
-    proc = subprocess.Popen(
+    # Detached on purpose: the tunnel outlives this helper; the log file is
+    # the observable surface.
+    subprocess.Popen(
         [bin_path, "tunnel", "--url", f"http://localhost:{port}"],
         stdout=open(log_path, "w"),
         stderr=subprocess.STDOUT,