ltcai 9.6.0 → 9.7.0

package/latticeai/api/change_proposals.py

@@ -13,10 +13,17 @@ 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,
@@ -32,6 +39,23 @@ def create_change_proposals_router(
         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)
@@ -46,15 +70,20 @@ def create_change_proposals_router(
             raise HTTPException(status_code=400, detail=str(exc))
 
     @router.post("/api/proposals/{item_id}/reject")
-    async def reject_proposal(item_id: str, request: Request):
+    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)
+            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"]
+__all__ = ["create_change_proposals_router", "RejectProposalRequest"]

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

@@ -1194,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/core/agent.py

@@ -319,28 +319,8 @@ class SingleAgentRuntime:
         parse_failures = 0
 
         for _ in range(budget):
-            corrections_hint = (
-                "\n\nCritic corrections from previous attempt:\n"
-                + "\n".join(f"- {c}" for c in ctx.corrections)
-            ) if ctx.corrections else ""
-
             request_workspace = getattr(req, "workspace_id", None)
-            recent_kwargs = {
-                "conversation_id": req.conversation_id,
-                "user_email": current_user or None,
-            }
-            if request_workspace is not None:
-                recent_kwargs["workspace_id"] = request_workspace
-            recent_conversation = d.recent_chat_context(**recent_kwargs) or "(none)"
-            context = (
-                f"{d.executor_prompt}\n\n"
-                f"[LANGUAGE HINT: {lang_hint}]\n"
-                f"Workspace root: {d.agent_root}\n\n"
-                f"PLAN:\n{json.dumps(ctx.plan, ensure_ascii=False)}\n\n"
-                f"Recent conversation:\n{recent_conversation}\n\n"
-                f"User request: {req.message}{corrections_hint}\n\n"
-                f"Execution transcript:\n{json.dumps(ctx.transcript, ensure_ascii=False, indent=2)}"
-            )
+            context = self._executor_context(ctx, req, lang_hint, current_user, request_workspace)
             raw = await d.generate_as(
                 model_id,
                 message="Execute the next step.",
@@ -352,33 +332,8 @@ class SingleAgentRuntime:
                 ctx.trace.repair("execute", repairs=exec_repairs)
             except ValueError as exc:
                 parse_failures += 1
-                ctx.transcript.append({
-                    "state": AgentState.EXECUTING.value, "action": "parse_error",
-                    "raw": str(raw)[:400], "error": str(exc),
-                })
-                if parse_failures >= 3:
-                    ctx.trace.parse_error("execute", error=str(exc), recovered=False)
+                if self._note_parse_failure(ctx, raw, exc, parse_failures):
                     break
-                ctx.trace.parse_error("execute", error=str(exc), recovered=True)
-                # Weak models often need one concrete reminder of the wire
-                # format; feed it through the corrections channel and retry
-                # instead of aborting the whole run on the first slip.
-                hint = (
-                    'Your last reply was not a single JSON action object. Reply with '
-                    'EXACTLY one JSON object like {"thoughts": "...", "action": '
-                    '"tool_name", "args": {...}} and nothing else.'
-                )
-                if parse_failures >= 2:
-                    # Escalate: name the valid tools so the model stops
-                    # inventing action names or prose.
-                    valid = ", ".join(sorted(d.tool_governance.keys()))
-                    hint = (
-                        f"{hint} Valid action values are: {valid}, final. "
-                        'Use {"action": "final", "message": "..."} to finish.'
-                    )
-                if hint not in ctx.corrections:
-                    ctx.corrections.append(hint)
-                    ctx.trace.correction("execute", hint=hint)
                 continue
 
             name     = action.get("action")
@@ -402,14 +357,7 @@ class SingleAgentRuntime:
                 return
 
             # Loop guard
-            exec_steps = [s for s in ctx.transcript if s.get("state") == AgentState.EXECUTING.value]
-            last = exec_steps[-1] if exec_steps else None
-            if (
-                name in d.file_create_actions and last
-                and last.get("action") == name
-                and (last.get("args") or {}) == args
-                and "result" in last
-            ):
+            if self._is_repeated_create(ctx, name, args):
                 ctx.transcript.append({
                     "state": AgentState.EXECUTING.value, "action": name,
                     "error": "LOOP_DETECTED: identical action+args repeated — halted.",
@@ -428,93 +376,203 @@ class SingleAgentRuntime:
             policy = d.policy_for(name, args)
             risk   = d.risk_level(policy)
 
-            # Central change-class governance: create-new runs with minimal
-            # friction, change/delete-existing becomes a review proposal.
-            governor_allows_additive = False
-            if d.change_governor is not None:
-                verdict = d.change_governor.review(
-                    name, args, policy=dict(policy),
-                    user_email=current_user, workspace_id=request_workspace,
-                )
-                if verdict is not None and verdict.get("decision") == "proposed":
-                    proposal = verdict.get("proposal") or {}
-                    ctx.trace.tool("execute", name=name, outcome="proposed", risk=risk)
-                    ctx.transcript.append({
-                        "state": AgentState.EXECUTING.value, "action": name,
-                        "thoughts": thoughts, "args": {k: v for k, v in args.items() if k != "content"},
-                        "risk": risk, "governance": dict(policy),
-                        "result": {
-                            "proposed": True,
-                            "proposal_id": proposal.get("id"),
-                            "note": "기존 내용을 바꾸는 작업이라 변경 제안으로 저장했습니다. 검토함에서 승인하면 적용됩니다.",
-                        },
-                    })
-                    d.audit(
-                        "agent_change_proposed", user_email=current_user,
-                        action=name, proposal_id=proposal.get("id"),
-                        change_class=(verdict.get("classification") or {}).get("change_class"),
-                    )
-                    continue
-                governor_allows_additive = (
-                    verdict is not None and verdict.get("decision") == "allow_additive"
-                )
-
-            if policy["risk"] == "destructive":
-                ctx.trace.tool("execute", name=name, outcome="blocked_destructive", risk=risk)
-                ctx.transcript.append({
-                    "state": AgentState.EXECUTING.value, "action": name,
-                    "thoughts": thoughts, "args": args, "risk": risk,
-                    "governance": dict(policy),
-                    "error": f"BLOCKED: destructive action '{name}' not permitted in agent mode.",
-                })
-                d.audit(
-                    "agent_blocked", user_email=current_user, source=getattr(req, "source", None) or "agent",
-                    action=name, reason="destructive", governance=dict(policy),
-                )
+            proposed, governor_allows_additive = self._governor_review(
+                ctx, name, thoughts, args, policy, risk, current_user, request_workspace,
+                conversation_id=getattr(req, "conversation_id", None),
+            )
+            if proposed:
                 continue
 
-            if not policy["auto_approve"] and not ctx.approved_by_human and not governor_allows_additive:
-                d.audit(
-                    "agent_exec", user_email=current_user, source=getattr(req, "source", None) or "agent",
-                    state=AgentState.EXECUTING.value, action=name, risk=risk,
-                    shell=policy["shell"], network=policy["network"],
-                    destructive=policy["destructive"], sandbox=policy["sandbox"],
-                    rollback=policy["rollback"],
-                    args={k: v for k, v in args.items() if k != "content"},
-                )
-                ctx.trace.tool("execute", name=name, outcome="blocked_approval", risk=risk)
-                ctx.transcript.append({
-                    "state": AgentState.EXECUTING.value, "action": name,
-                    "thoughts": thoughts, "args": args, "risk": risk,
-                    "governance": dict(policy),
-                    "error": f"BLOCKED: action '{name}' requires explicit approval.",
-                })
+            if self._blocked_by_gates(
+                ctx, req, name, thoughts, args, policy, risk,
+                current_user, governor_allows_additive,
+            ):
                 continue
 
-            try:
-                d.check_role(name, current_user)
-                # Shared tool lifecycle: pre_tool (may block) → execute → post_tool.
-                result = dispatch_tool(
-                    d.hooks, name, args,
-                    lambda: d.execute_tool(name, args),
-                    user_email=current_user, source="agent",
-                )
-                ctx.trace.tool("execute", name=name, outcome="ok", risk=risk)
-                ctx.transcript.append({
-                    "state": AgentState.EXECUTING.value, "action": name,
-                    "thoughts": thoughts, "args": args,
-                    "risk": risk, "governance": dict(policy), "result": result,
-                })
-            except (ToolError, KeyError, TypeError, PermissionError) as exc:
-                ctx.trace.tool("execute", name=name, outcome="error", risk=risk)
-                ctx.transcript.append({
-                    "state": AgentState.EXECUTING.value, "action": name,
-                    "thoughts": thoughts, "args": args,
-                    "risk": risk, "governance": dict(policy), "error": str(exc),
-                })
+            self._dispatch_step(ctx, name, thoughts, args, policy, risk, current_user)
 
         ctx.state = AgentState.VERIFYING
 
+    def _executor_context(
+        self, ctx: AgentRunContext, req: Any, lang_hint: str,
+        current_user: str, request_workspace: Optional[str],
+    ) -> str:
+        """Assemble one executor turn's prompt (plan, corrections, recent chat)."""
+        d = self.deps
+        corrections_hint = (
+            "\n\nCritic corrections from previous attempt:\n"
+            + "\n".join(f"- {c}" for c in ctx.corrections)
+        ) if ctx.corrections else ""
+
+        recent_kwargs = {
+            "conversation_id": req.conversation_id,
+            "user_email": current_user or None,
+        }
+        if request_workspace is not None:
+            recent_kwargs["workspace_id"] = request_workspace
+        recent_conversation = d.recent_chat_context(**recent_kwargs) or "(none)"
+        return (
+            f"{d.executor_prompt}\n\n"
+            f"[LANGUAGE HINT: {lang_hint}]\n"
+            f"Workspace root: {d.agent_root}\n\n"
+            f"PLAN:\n{json.dumps(ctx.plan, ensure_ascii=False)}\n\n"
+            f"Recent conversation:\n{recent_conversation}\n\n"
+            f"User request: {req.message}{corrections_hint}\n\n"
+            f"Execution transcript:\n{json.dumps(ctx.transcript, ensure_ascii=False, indent=2)}"
+        )
+
+    def _note_parse_failure(
+        self, ctx: AgentRunContext, raw: Any, exc: ValueError, parse_failures: int,
+    ) -> bool:
+        """Record one executor parse slip; True when the run should stop retrying."""
+        ctx.transcript.append({
+            "state": AgentState.EXECUTING.value, "action": "parse_error",
+            "raw": str(raw)[:400], "error": str(exc),
+        })
+        if parse_failures >= 3:
+            ctx.trace.parse_error("execute", error=str(exc), recovered=False)
+            return True
+        ctx.trace.parse_error("execute", error=str(exc), recovered=True)
+        # Weak models often need one concrete reminder of the wire
+        # format; feed it through the corrections channel and retry
+        # instead of aborting the whole run on the first slip.
+        hint = (
+            'Your last reply was not a single JSON action object. Reply with '
+            'EXACTLY one JSON object like {"thoughts": "...", "action": '
+            '"tool_name", "args": {...}} and nothing else.'
+        )
+        if parse_failures >= 2:
+            # Escalate: name the valid tools so the model stops
+            # inventing action names or prose.
+            valid = ", ".join(sorted(self.deps.tool_governance.keys()))
+            hint = (
+                f"{hint} Valid action values are: {valid}, final. "
+                'Use {"action": "final", "message": "..."} to finish.'
+            )
+        if hint not in ctx.corrections:
+            ctx.corrections.append(hint)
+            ctx.trace.correction("execute", hint=hint)
+        return False
+
+    def _is_repeated_create(self, ctx: AgentRunContext, name: Any, args: dict) -> bool:
+        """Loop guard: the same file-create action+args re-issued right after a result."""
+        exec_steps = [s for s in ctx.transcript if s.get("state") == AgentState.EXECUTING.value]
+        last = exec_steps[-1] if exec_steps else None
+        return bool(
+            name in self.deps.file_create_actions and last
+            and last.get("action") == name
+            and (last.get("args") or {}) == args
+            and "result" in last
+        )
+
+    def _governor_review(
+        self, ctx: AgentRunContext, name: str, thoughts: str, args: dict,
+        policy: dict, risk: str, current_user: str, request_workspace: Optional[str],
+        conversation_id: Optional[str] = None,
+    ) -> Tuple[bool, bool]:
+        """Central change-class governance: create-new runs with minimal
+        friction, change/delete-existing becomes a review proposal.
+
+        Returns ``(proposed, governor_allows_additive)``: ``proposed`` means the
+        step was staged as a proposal (skip execution); ``allows_additive`` lets
+        an additive create pass the classic approval gate.
+        """
+        d = self.deps
+        if d.change_governor is None:
+            return False, False
+        verdict = d.change_governor.review(
+            name, args, policy=dict(policy),
+            user_email=current_user, workspace_id=request_workspace,
+            conversation_id=conversation_id,
+        )
+        if verdict is not None and verdict.get("decision") == "proposed":
+            proposal = verdict.get("proposal") or {}
+            ctx.trace.tool("execute", name=name, outcome="proposed", risk=risk)
+            ctx.transcript.append({
+                "state": AgentState.EXECUTING.value, "action": name,
+                "thoughts": thoughts, "args": {k: v for k, v in args.items() if k != "content"},
+                "risk": risk, "governance": dict(policy),
+                "result": {
+                    "proposed": True,
+                    "proposal_id": proposal.get("id"),
+                    "note": "기존 내용을 바꾸는 작업이라 변경 제안으로 저장했습니다. 검토함에서 승인하면 적용됩니다.",
+                },
+            })
+            d.audit(
+                "agent_change_proposed", user_email=current_user,
+                action=name, proposal_id=proposal.get("id"),
+                change_class=(verdict.get("classification") or {}).get("change_class"),
+            )
+            return True, False
+        return False, (verdict is not None and verdict.get("decision") == "allow_additive")
+
+    def _blocked_by_gates(
+        self, ctx: AgentRunContext, req: Any, name: str, thoughts: str, args: dict,
+        policy: dict, risk: str, current_user: str, governor_allows_additive: bool,
+    ) -> bool:
+        """Classic destructive / explicit-approval gates; True when the step was blocked."""
+        d = self.deps
+        if policy["risk"] == "destructive":
+            ctx.trace.tool("execute", name=name, outcome="blocked_destructive", risk=risk)
+            ctx.transcript.append({
+                "state": AgentState.EXECUTING.value, "action": name,
+                "thoughts": thoughts, "args": args, "risk": risk,
+                "governance": dict(policy),
+                "error": f"BLOCKED: destructive action '{name}' not permitted in agent mode.",
+            })
+            d.audit(
+                "agent_blocked", user_email=current_user, source=getattr(req, "source", None) or "agent",
+                action=name, reason="destructive", governance=dict(policy),
+            )
+            return True
+
+        if not policy["auto_approve"] and not ctx.approved_by_human and not governor_allows_additive:
+            d.audit(
+                "agent_exec", user_email=current_user, source=getattr(req, "source", None) or "agent",
+                state=AgentState.EXECUTING.value, action=name, risk=risk,
+                shell=policy["shell"], network=policy["network"],
+                destructive=policy["destructive"], sandbox=policy["sandbox"],
+                rollback=policy["rollback"],
+                args={k: v for k, v in args.items() if k != "content"},
+            )
+            ctx.trace.tool("execute", name=name, outcome="blocked_approval", risk=risk)
+            ctx.transcript.append({
+                "state": AgentState.EXECUTING.value, "action": name,
+                "thoughts": thoughts, "args": args, "risk": risk,
+                "governance": dict(policy),
+                "error": f"BLOCKED: action '{name}' requires explicit approval.",
+            })
+            return True
+        return False
+
+    def _dispatch_step(
+        self, ctx: AgentRunContext, name: str, thoughts: str, args: dict,
+        policy: dict, risk: str, current_user: str,
+    ) -> None:
+        """Role check + shared tool lifecycle, recorded on the transcript either way."""
+        d = self.deps
+        try:
+            d.check_role(name, current_user)
+            # Shared tool lifecycle: pre_tool (may block) → execute → post_tool.
+            result = dispatch_tool(
+                d.hooks, name, args,
+                lambda: d.execute_tool(name, args),
+                user_email=current_user, source="agent",
+            )
+            ctx.trace.tool("execute", name=name, outcome="ok", risk=risk)
+            ctx.transcript.append({
+                "state": AgentState.EXECUTING.value, "action": name,
+                "thoughts": thoughts, "args": args,
+                "risk": risk, "governance": dict(policy), "result": result,
+            })
+        except (ToolError, KeyError, TypeError, PermissionError) as exc:
+            ctx.trace.tool("execute", name=name, outcome="error", risk=risk)
+            ctx.transcript.append({
+                "state": AgentState.EXECUTING.value, "action": name,
+                "thoughts": thoughts, "args": args,
+                "risk": risk, "governance": dict(policy), "error": str(exc),
+            })
+
     # ── VERIFY ───────────────────────────────────────────────────────
     async def verify(
         self, ctx: AgentRunContext, req: Any, lang_hint: str, current_user: str,