ltcai 9.9.4 → 9.9.5

package/latticeai/api/chat_agent_http.py

@@ -65,9 +65,7 @@ class AgentHTTPController:
         self.agent_root = Path(agent_root)
         self.ensure_agent_root = ensure_agent_root
         self.funnel_metrics = funnel_metrics
-        self._pending: Dict[str, tuple] = {}
         self._pending_lock = threading.Lock()
-        self._pending_ttl_seconds = 15 * 60
         # awaiting_approval runs: run_id -> paused run state + approval token.
         # Fail-closed: governed steps only ever execute after resume presents
         # the matching, unexpired token for this run (or via the legacy
@@ -250,33 +248,29 @@ class AgentHTTPController:
             model_id=req.planning_model,
         )
 
+        requirements_probe = getattr(self.runtime, "approval_requirements", None)
+
         if req.human_in_loop:
-            context_id = secrets.token_urlsafe(16)
-            with self._pending_lock:
-                self._pending[context_id] = (
-                    ctx,
-                    req,
-                    language_hint,
-                    current_user,
-                    time.monotonic(),
-                )
-            return {
-                "status": "waiting_approval",
-                "context_id": context_id,
-                "plan": ctx.plan,
-                "steps": ctx.transcript,
-                "state_history": ctx.state_history,
-                "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(),
-            }
+            # Deprecated explicit pause (L1 unification, 9.9.5): the legacy
+            # ``human_in_loop`` flow now rides the same durable approval
+            # store as ``awaiting_approval`` — one pause path, one resume
+            # path, restart-safe. The legacy wire contract is preserved:
+            # ``status="waiting_approval"`` + ``context_id`` (token-less,
+            # same-user resume).
+            requirements = (
+                requirements_probe(ctx)
+                if callable(requirements_probe)
+                else {"requires_approval": True, "non_auto_steps": [], "plan_summary": ""}
+            )
+            return self._pause_for_approval(
+                ctx, req, language_hint, current_user, requirements,
+                legacy_context=True,
+            )
 
         # Interactive approval: when the plan needs human approval, pause the
         # run as awaiting_approval (short-TTL token) instead of failing it.
         # ``getattr`` keeps injected fake runtimes without the preview method
         # on the historical fail-closed path.
-        requirements_probe = getattr(self.runtime, "approval_requirements", None)
         if callable(requirements_probe):
             requirements = requirements_probe(ctx)
             if requirements.get("requires_approval"):
@@ -301,8 +295,16 @@ class AgentHTTPController:
         language_hint: str,
         current_user: str,
         requirements: Dict[str, Any],
+        *,
+        legacy_context: bool = False,
     ) -> Dict[str, Any]:
-        """Park a plan that needs approval and hand the user a resume token."""
+        """Park a plan that needs approval and hand the user a resume token.
+
+        ``legacy_context=True`` marks a deprecated ``human_in_loop`` pause:
+        same durable storage, but the response speaks the historical
+        ``waiting_approval``/``context_id`` contract and resume may present
+        the ``context_id`` instead of the approval token (same user only).
+        """
         run_id = secrets.token_urlsafe(16)
         approval_token = secrets.token_urlsafe(32)
         now_monotonic = time.monotonic()
@@ -319,6 +321,7 @@ class AgentHTTPController:
                 "token": approval_token,
                 "expires_monotonic": now_monotonic + self._approval_ttl_seconds,
                 "expires_at": expires_at,
+                "legacy_context": legacy_context,
             }
         # Durable mirror: a restart between pause and resume must not orphan
         # the run. Best-effort — the in-memory pause still answers on failure.
@@ -332,6 +335,7 @@ class AgentHTTPController:
                 token=approval_token,
                 expires_epoch=time.time() + self._approval_ttl_seconds,
                 expires_at=expires_at,
+                legacy_context=legacy_context,
             )
         except Exception as exc:  # noqa: BLE001
             logging.warning("agent run store persist failed: %s", exc)
@@ -345,8 +349,8 @@ class AgentHTTPController:
             "이 작업에는 승인이 필요한 단계가 있어 실행을 잠시 멈췄습니다. "
             "계획을 확인한 뒤 승인하면 이어서 실행합니다."
         )
-        return {
-            "status": "awaiting_approval",
+        payload = {
+            "status": "waiting_approval" if legacy_context else "awaiting_approval",
             "run_id": run_id,
             "approval": {
                 "token": approval_token,
@@ -364,6 +368,10 @@ class AgentHTTPController:
             "reviewing_model": req.reviewing_model or self.model_router.current_model_id,
             "loop": ctx.trace.summary(),
         }
+        if legacy_context:
+            # Historical wire field — the run id doubles as the context id.
+            payload["context_id"] = run_id
+        return payload
 
     def _purge_expired_approvals_locked(self, now_monotonic: float) -> None:
         for run_id, entry in list(self._approvals.items()):
@@ -450,6 +458,7 @@ class AgentHTTPController:
             "token_hash": str(record.get("token_hash") or ""),
             "expires_monotonic": time.monotonic() + remaining,
             "expires_at": record.get("expires_at"),
+            "legacy_context": bool(record.get("legacy_context")),
         }
 
     @staticmethod
@@ -565,31 +574,63 @@ class AgentHTTPController:
                 status_code=400,
                 detail="run_id (with approval_token) or context_id is required.",
             )
+        # Deprecated context_id resume (L1 unification, 9.9.5): the legacy
+        # pause lives in the same durable approval store now. Token-less
+        # resume stays allowed for it — bound to the pausing user, and only
+        # for entries that were created through the legacy pause.
+        now_monotonic = time.monotonic()
         with self._pending_lock:
-            now = time.monotonic()
-            for context_id, pending in list(self._pending.items()):
-                if now - pending[4] >= self._pending_ttl_seconds:
-                    self._pending.pop(context_id, None)
-            entry = self._pending.get(req.context_id)
-            if entry and entry[3] == current_user:
-                self._pending.pop(req.context_id, None)
-        if not entry:
-            raise HTTPException(
-                status_code=404,
-                detail="Agent context not found or expired. Start a new request.",
-            )
+            entry = self._approvals.get(req.context_id)
+            if entry is None:
+                try:
+                    entry = self._restore_persisted_approval(req.context_id)
+                except HTTPException as exc:
+                    if exc.status_code == 410:
+                        # Legacy contract never had a distinct expiry answer.
+                        raise HTTPException(
+                            status_code=404,
+                            detail="Agent context not found or expired. Start a new request.",
+                        ) from exc
+                    raise
+            if entry is None or not entry.get("legacy_context"):
+                raise HTTPException(
+                    status_code=404,
+                    detail="Agent context not found or expired. Start a new request.",
+                )
+            if entry["user"] != current_user:
+                raise HTTPException(
+                    status_code=403,
+                    detail="Agent context belongs to another user.",
+                )
+            if now_monotonic >= entry["expires_monotonic"]:
+                self._approvals.pop(req.context_id, None)
+                try:
+                    self.run_store.delete(req.context_id)
+                except Exception:  # noqa: BLE001
+                    pass
+                raise HTTPException(
+                    status_code=404,
+                    detail="Agent context not found or expired. Start a new request.",
+                )
+            self._approvals.pop(req.context_id, None)
+            try:
+                self.run_store.delete(req.context_id)
+            except Exception as exc:  # noqa: BLE001
+                logging.warning("agent run store delete failed: %s", exc)
 
-        ctx, original_request, language_hint, original_user, _created_at = entry
-        if original_user != current_user:
-            raise HTTPException(
-                status_code=403,
-                detail="Agent context belongs to another user.",
-            )
+        ctx = entry["ctx"]
+        original_request = entry["req"]
+        language_hint = entry["language_hint"]
         if not req.approved:
             return {"status": "cancelled", "response": "사용자가 계획을 취소했습니다."}
         if req.modified_plan:
-            ctx.plan = req.modified_plan
-            ctx.transcript[-1].update(ctx.plan)
+            plan, plan_fixes = normalize_plan(req.modified_plan, original_request.message)
+            ctx.plan = plan
+            ctx.transcript.append({
+                "state": AgentState.WAITING_APPROVAL.value,
+                "edited_plan": True,
+                **({"plan_fixes": plan_fixes} if plan_fixes else {}),
+            })
         ctx.executing_model = req.executing_model or ctx.executing_model
         ctx.reviewing_model = req.reviewing_model or ctx.reviewing_model
         # The authenticated owner of this pending context explicitly approved

package/latticeai/api/chat_contracts.py

@@ -45,7 +45,7 @@ class AgentResumeRequest(BaseModel):
     modified_plan: Optional[dict] = None
     executing_model: Optional[str] = None
     reviewing_model: Optional[str] = None
-    # awaiting_approval flow (v9.10): run_id + short-TTL approval token.
+    # awaiting_approval flow (v9.9.x): run_id + short-TTL approval token.
     run_id: Optional[str] = None
     approval_token: Optional[str] = None
     approve: Optional[bool] = None

package/latticeai/core/agent.py

@@ -340,6 +340,77 @@ def compact_transcript(
     return summarized
 
 
+def files_written(
+    transcript: List[Dict[str, Any]],
+    file_create_actions: FrozenSet[str],
+) -> List[str]:
+    """Ordered unique paths of files this run successfully wrote (review L5).
+
+    Later executor steps get this as explicit context, so "만들고 이어서
+    설명해" multi-step work sees its own output instead of a stale
+    workspace picture.
+    """
+    seen: List[str] = []
+    for step in transcript:
+        if step.get("state") != AgentState.EXECUTING.value:
+            continue
+        if step.get("action") not in file_create_actions:
+            continue
+        if not isinstance(step.get("result"), dict):
+            continue
+        path = step["result"].get("path") or (step.get("args") or {}).get("path")
+        if path and str(path) not in seen:
+            seen.append(str(path))
+    return seen
+
+
+def artifact_checklist(
+    transcript: List[Dict[str, Any]],
+    file_create_actions: FrozenSet[str],
+) -> List[Dict[str, Any]]:
+    """Deterministic artifact facts for the critic (review L4).
+
+    The critic previously judged file work from prose alone; this surfaces
+    the sanitize/repair honesty flags per written file so a repaired
+    placeholder can never pass as a fulfilled request unchecked.
+    """
+    checklist: List[Dict[str, Any]] = []
+    for step in transcript:
+        if step.get("state") != AgentState.EXECUTING.value:
+            continue
+        if step.get("action") not in file_create_actions:
+            continue
+        if not isinstance(step.get("result"), dict):
+            continue
+        path = step["result"].get("path") or (step.get("args") or {}).get("path")
+        if not path:
+            continue
+        sanitize_meta = step.get("content_sanitize") or {}
+        checklist.append({
+            "path": str(path),
+            "sanitized": bool(sanitize_meta.get("sanitized")),
+            "repaired": bool(sanitize_meta.get("repaired")),
+        })
+    return checklist
+
+
+def _format_artifact_checklist(checklist: List[Dict[str, Any]]) -> str:
+    lines = []
+    for item in checklist:
+        state = (
+            "auto-REPAIRED scaffold" if item["repaired"]
+            else ("sanitized model output" if item["sanitized"] else "written as produced")
+        )
+        lines.append(f"- {item['path']}: {state}")
+    return (
+        "Artifact checklist (deterministic, from the transcript):\n"
+        + "\n".join(lines)
+        + "\nVerify each artifact actually fulfills the user's request. An "
+        "auto-repaired scaffold is NOT completion unless its content "
+        "satisfies what was asked."
+    )
+
+
 @dataclass(frozen=True)
 class TranscriptBudget:
     """Executor/critic prompt shaping caps (review Wave 0.3).
@@ -450,6 +521,16 @@ class AgentDeps:
     # state machine does not shell out directly. Tests can pass a recorder.
     rollback_file: Optional[Callable[[str], Dict[str, Any]]] = None
 
+    # ── snapshot rollback ports (optional, review L7) ────────────────
+    # git-only rollback left non-git workspaces and newly created files
+    # unrecoverable. ``snapshot_file(path)`` captures pre-write state
+    # ({"existed", "content", "too_large"}) before a file-create action;
+    # ``restore_snapshot(path, content)`` restores it (content=None deletes
+    # a file the run created). Both are production-wired with workspace
+    # path safety; tests pass recorders.
+    snapshot_file: Optional[Callable[[str], Dict[str, Any]]] = None
+    restore_snapshot: Optional[Callable[[str, Optional[str]], Dict[str, Any]]] = None
+
     # ── lifecycle hooks port (optional) ──────────────────────────────
     # When present, every tool execution fires the shared pre_tool/post_tool
     # lifecycle, so the agent tool path no longer bypasses hooks.
@@ -791,11 +872,18 @@ class SingleAgentRuntime:
             window=budget.window,
             result_chars=budget.result_chars,
         )
+        # Mid-run workspace awareness (review L5): later steps must see what
+        # this run already produced instead of a stale workspace picture.
+        written = files_written(ctx.transcript, d.file_create_actions)
+        written_hint = (
+            "\n\nFiles written by this run so far (they exist in the workspace now):\n"
+            + "\n".join(f"- {path}" for path in written)
+        ) if written else ""
         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"PLAN:\n{json.dumps(ctx.plan, ensure_ascii=False)}{written_hint}\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(bounded_transcript, ensure_ascii=False, indent=2)}"
@@ -961,6 +1049,22 @@ class SingleAgentRuntime:
             if s.get("state") == AgentState.EXECUTING.value
             and s.get("action") not in (None, "final", "parse_error")
         )
+        if (
+            name in d.file_create_actions
+            and d.snapshot_file is not None
+            and args.get("path")
+        ):
+            # Pre-write snapshot (review L7): the first capture per path is
+            # the true pre-run state — later writes to the same path must
+            # not overwrite it. Best-effort: a snapshot failure never
+            # blocks the write, it only narrows rollback options.
+            path_str = str(args["path"])
+            if not any(entry.get("path") == path_str for entry in ctx.rollback_log):
+                try:
+                    pre = d.snapshot_file(path_str)
+                    ctx.rollback_log.append({"path": path_str, **(pre or {})})
+                except Exception as exc:  # noqa: BLE001
+                    logging.warning("pre-write snapshot failed for %s: %s", path_str, exc)
         try:
             d.check_role(name, current_user)
             # Shared tool lifecycle: pre_tool (may block) → execute → post_tool.
@@ -1025,11 +1129,17 @@ class SingleAgentRuntime:
         verify_transcript = _truncate_strings(
             ctx.transcript, self.transcript_budget.verify_chars
         )
+        # Deterministic artifact facts (review L4): the critic sees the
+        # sanitize/repair honesty flags per written file, not just prose.
+        checklist = artifact_checklist(ctx.transcript, d.file_create_actions)
+        checklist_hint = (
+            f"\n\n{_format_artifact_checklist(checklist)}" if checklist else ""
+        )
         context = (
             f"{d.critic_prompt}\n\n"
             f"[LANGUAGE HINT: {lang_hint}]\n\n"
             f"Original request: {req.message}\n"
-            f"Plan goal: {ctx.plan.get('goal', req.message)}\n\n"
+            f"Plan goal: {ctx.plan.get('goal', req.message)}{checklist_hint}\n\n"
             f"Full transcript:\n{json.dumps(verify_transcript, ensure_ascii=False, indent=2)}"
         )
         raw = await d.generate_as(
@@ -1162,40 +1272,68 @@ class SingleAgentRuntime:
             ctx.state = AgentState.FAILED
 
     # ── ROLLBACK ─────────────────────────────────────────────────────
+    def _snapshot_for(self, ctx: AgentRunContext, path: str) -> Optional[Dict[str, Any]]:
+        for entry in ctx.rollback_log:
+            if entry.get("path") == path:
+                return entry
+        return None
+
+    def _rollback_one(self, ctx: AgentRunContext, path: str, gov: Dict[str, Any]) -> Dict[str, Any]:
+        """Recover one path: git when governed and available, else the
+        pre-write snapshot, else an honest ``mode="none"`` (review L7)."""
+        d = self.deps
+        if gov.get("rollback") == "git" and d.rollback_file is not None:
+            try:
+                result = dict(d.rollback_file(str(path)))
+            except Exception as exc:  # noqa: BLE001
+                result = {"path": path, "ok": False, "error": str(exc)}
+            if result.get("ok"):
+                result["mode"] = "git"
+                return result
+        snapshot = self._snapshot_for(ctx, str(path))
+        if snapshot is not None and d.restore_snapshot is not None and not snapshot.get("too_large"):
+            content = snapshot.get("content") if snapshot.get("existed") else None
+            try:
+                restored = dict(d.restore_snapshot(str(path), content))
+            except Exception as exc:  # noqa: BLE001
+                restored = {"path": path, "ok": False, "error": str(exc)}
+            restored.setdefault("path", path)
+            restored["mode"] = "snapshot"
+            return restored
+        return {
+            "path": path, "ok": False, "mode": "none",
+            "error": "no rollback available (git not applicable, no usable snapshot)",
+        }
+
     def rollback(self, ctx: AgentRunContext, current_user: str) -> None:
-        """ROLLBACK: attempt git checkout for each edited file, then FAILED."""
+        """ROLLBACK: recover written files (git → snapshot → none), then FAILED."""
         d = self.deps
         rolled: List[dict] = []
+        seen_paths: set = set()
         for step in ctx.transcript:
             if step.get("state") != AgentState.EXECUTING.value:
                 continue
-            gov = step.get("governance", {})
-            if gov.get("rollback") != "git":
+            if not isinstance(step.get("result"), dict):
                 continue
-            result = step.get("result", {})
-            if not isinstance(result, dict):
-                result = {}
-            path = result.get("path") or (step.get("args") or {}).get("path", "")
-            if not path:
+            gov = step.get("governance", {}) or {}
+            path = step["result"].get("path") or (step.get("args") or {}).get("path", "")
+            if not path or str(path) in seen_paths:
                 continue
-            if d.rollback_file is None:
-                rolled.append({"path": path, "ok": False, "error": "rollback_file port is not configured"})
+            if gov.get("rollback") != "git" and step.get("action") not in d.file_create_actions:
                 continue
-            try:
-                rolled.append(d.rollback_file(str(path)))
-            except Exception as exc:
-                rolled.append({"path": path, "ok": False, "error": str(exc)})
+            seen_paths.add(str(path))
+            rolled.append(self._rollback_one(ctx, str(path), gov))
 
         ctx.transcript.append({"state": AgentState.ROLLBACK.value, "rolled_back": rolled})
         ctx.trace.decision(
             "rollback", decision="rolled_back",
             attempted=len(rolled), recovered=sum(1 for r in rolled if r.get("ok")),
         )
-        recovered = [r["path"] for r in rolled if r.get("ok")]
+        recovered = [f"{r['path']} ({r.get('mode')})" for r in rolled if r.get("ok")]
         ctx.final_message = (
             f"실행 실패로 롤백했습니다. 복구 파일: {recovered}"
             if recovered
-            else "롤백을 시도했으나 복구할 파일이 없거나 git이 초기화되지 않았습니다."
+            else "롤백을 시도했으나 복구할 파일이 없거나 git/스냅샷 복구 수단이 없습니다."
         )
         d.audit("agent_rollback", user_email=current_user, rolled_back=rolled)
         self._emit_step(ctx, "rollback", "rolled_back", recovered=len(recovered))

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.4"
+LEGACY_COMPATIBILITY_VERSION = "9.9.5"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

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

package/latticeai/core/run_store.py

@@ -113,6 +113,7 @@ class AgentRunStore:
         token: str,
         expires_epoch: float,
         expires_at: str,
+        legacy_context: bool = False,
     ) -> bool:
         """Persist a paused run. Best-effort: returns False on any failure."""
         path = self._path_for(run_id)
@@ -126,6 +127,7 @@ class AgentRunStore:
             "token_hash": hash_approval_token(token),
             "expires_epoch": float(expires_epoch),
             "expires_at": expires_at,
+            "legacy_context": bool(legacy_context),
             "req": req_payload,
             "ctx": serialize_run_context(ctx),
         }

package/latticeai/core/workspace_os.py

@@ -49,7 +49,7 @@ __all__ = [
     "remove_skill_directory",
 ]
 
-WORKSPACE_OS_VERSION = "9.9.4"
+WORKSPACE_OS_VERSION = "9.9.5"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type