semora-ui 0.1.0__tar.gz

semora_ui-0.1.0/.env.example

@@ -0,0 +1,2 @@
+OPENROUTER_API_KEY=sk-or-v1-replace-me
+OPENROUTER_MODEL=openai/gpt-4o-mini

semora_ui-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+.venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.coverage
+htmlcov/
+.env
+.env.*
+!.env.example
+
+
+# Local tool/editor state — machine-specific, never pushed.
+.claude/
+.codecanvas/
+.vscode/
+
+
+# Superpowers design/spec scratch — working notes, not project documentation.
+docs/superpowers/
+
+# 로컬 자격증명 — 절대 커밋 금지.
+a.txt
+*.token

semora_ui-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.5
+Name: semora-ui
+Version: 0.1.0
+Summary: A local console for driving Semora runs: chat, tool effects, suspension and resume.
+Project-URL: Homepage, https://github.com/donggyun112/semora
+Project-URL: Source, https://github.com/donggyun112/semora
+Project-URL: Changelog, https://github.com/donggyun112/semora/blob/main/CHANGELOG.md
+Author: donggyun112
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: fastapi<1,>=0.116
+Requires-Dist: langchain-openai<2,>=0.3
+Requires-Dist: loguru<1,>=0.7
+Requires-Dist: python-dotenv<2,>=1.1
+Requires-Dist: semora-store==0.1.0
+Requires-Dist: semora==0.1.0
+Requires-Dist: uvicorn[standard]<1,>=0.35

semora_ui-0.1.0/README.md

@@ -0,0 +1,71 @@
+# Semora Durable Agent Lab
+
+The local UI is an optional module inside the Semora package. Its dependency direction is:
+
+```text
+app → api → execution → AgentRuntime
+          ↘ provider
+          ↘ tools / state
+```
+
+Run it with:
+
+```bash
+uv sync --extra ui
+uv run uvicorn semora_ui.app:app --reload --port 8790
+```
+
+Open <http://127.0.0.1:8790>. Configuration is loaded from `packages/semora-ui/.env`. Supported key
+names are `OPENROUTER_API_KEY`, `OPENROUTER_KEY`, and the imported fixture spelling
+`OPEN_ROTURE`.
+
+The **Pre-tool gate** sample asks permission before `remember_note` crosses the effect boundary. No
+  `post_tool_use` event exists until approval actually executes the tool.
+Tools cannot return a suspension after execution; `suspend` is reserved for `pre_tool_use` policy.
+
+The **Tool failure** sample calls `simulate_api_failure`, which returns a recorded, non-retryable
+503 result. The UI must show `post_tool_use_failure` and a failed Tool Result; neither the agent
+loop nor the demo tool retries the call automatically.
+
+The **Step recovery** sample arms a worker-only fault immediately after a tool result is committed
+to `MemorySteps`, but before the ToolMessage reaches the agent transcript. The UI host remains
+alive, and **Recover from committed Step** calls `AgentRuntime.recover`: the ledger result is
+reused and the demo tool must execute exactly once (`execution_count: 1` remains visible in the
+recovered result). This simulates an execution worker crash, not a full UI server restart; the
+latter requires a persistent StepLog and transcript store.
+
+The UI labels the model output **TOOL REQUEST**, not tool execution. If a new chat message arrives
+while the sample is waiting, the interactive default cancels the unanswered request, writes its
+protocol-closing ToolMessage, and continues the same run with the new message. Approval responses
+use `pending_id`; a late approval for the cancelled request is rejected.
+
+## Subagents
+
+The `SUBAGENTS` row of sample prompts drives every delegation shape the runtime has, against three
+demo children — `note-keeper`, `echoer`, and `flaky`. They are real runs, not canned strings: each
+one goes through `AgentRuntime` on the run id `Subagents` derived for it, on the same ledger the
+parent uses, with `respond_to_parent` in reach.
+
+| Button | What it shows |
+| --- | --- |
+| Sync | The parent's round waits. The child's own stream renders beside it, then its answer. |
+| Handoff | The parent answers immediately; the child appears on the subagent rail as `running` and its answer arrives on a later round. |
+| Fan-out | Two children in one call, both answers in one result. |
+| Open independent | `wait="none"` — no leash, just a run id, listed under INDEPENDENT with a **Talk to it** button. |
+| check_tasks | What the model itself sees of the children it launched. |
+| Child failure | A child reporting a failure, distinct from a child that crashed. |
+
+The rail keeps the two relationships apart because they are different: what is `ON THE PARENT'S
+LEASH` can be cancelled from here and by the model's `cancel_task`; what is `INDEPENDENT` has an
+address and nothing else, which is the entire result of opening one.
+
+**Talk to it** spends that address — the same durable queue a steer crosses, aimed at the child's
+run — and the agent remembers its earlier turns. This console still uses `recording.py` around an
+in-memory transcript so its UI can render each observed message; core callers can instead inject
+that store directly through `AgentRuntime(transcript=...)`. The console's store ends where this
+process does, and `GET /api/transcript/{run_id}` shows exactly what was kept.
+
+One thing to know when testing it: the demo system prompt tells the agent to use a tool whenever
+asked to *recall a note*, so "what did I tell you earlier?" makes it call `recall_note`, find
+nothing, and answer that it does not remember — with the whole conversation sitting in its context.
+Ask without that word and it answers from the transcript.

semora_ui-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "semora-ui"
+version = "0.1.0"
+description = "A local console for driving Semora runs: chat, tool effects, suspension and resume."
+requires-python = ">=3.12"
+license = "MIT"
+authors = [{ name = "donggyun112" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Typing :: Typed",
+]
+urls = { Homepage = "https://github.com/donggyun112/semora", Source = "https://github.com/donggyun112/semora", Changelog = "https://github.com/donggyun112/semora/blob/main/CHANGELOG.md" }
+dependencies = [
+  "semora==0.1.0",
+  "semora-store==0.1.0",
+  "fastapi>=0.116,<1",
+  "loguru>=0.7,<1",
+  "langchain-openai>=0.3,<2",
+  "python-dotenv>=1.1,<2",
+  "uvicorn[standard]>=0.35,<1",
+]
+# A demo application, not a library. It is the one package allowed to depend on everything.
+# `semora-store` is declared rather than taken transitively through `semora`: the console names
+# `Transcript` itself, and an import that only works because something else pulled it in is the
+# breakage `tests/test_packaging.py` exists to catch.
+
+[tool.uv.sources]
+semora = { workspace = true }
+semora-store = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/semora_ui"]

semora_ui-0.1.0/src/semora_ui/__init__.py

@@ -0,0 +1 @@
+"""Optional local UI for observing Semora's durable execution path."""

semora_ui-0.1.0/src/semora_ui/api.py

@@ -0,0 +1,253 @@
+"""FastAPI routes for the Semora test console."""
+
+from __future__ import annotations
+
+from typing import Any
+from uuid import uuid4
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from semora import Agent, new_run_id
+from semora.contracts import Tools
+from semora.dispatch import Answer, Prompt, Recover
+from semora.runtime import AgentRuntime
+
+from .config import SETTINGS, SYSTEM_PROMPT
+from .execution import AgentEvent, capped, stream_attempt
+from .policy import permission_controls
+from .provider import openrouter_model
+from .recording import Recorder, history_of
+from .schemas import AttachRequest, CancelRequest, RecoverRequest, ResumeRequest, RunRequest
+from .state import STATE
+
+router = APIRouter(prefix="/api")
+
+
+def _console_agent(model_name: str, tools: Tools) -> Agent:
+    """Bind the console's model selection and toolbox into one agent definition."""
+    return Agent(
+        name="console",
+        description="Semora test console agent",
+        model=openrouter_model(model_name),
+        tools=tools,
+        system_prompt=SYSTEM_PROMPT,
+    )
+
+
+@router.get("/health")
+async def health() -> dict[str, Any]:
+    """Return service health and provider configuration status."""
+    return {
+        "ok": True,
+        "openrouter_configured": SETTINGS.configured,
+        "default_model": SETTINGS.default_model,
+        "engine": "plain while + orchestrator",
+    }
+
+
+@router.get("/steps/{run_id}")
+async def steps(run_id: str) -> dict[str, Any]:
+    """Return the persisted step states for a run."""
+    return {"run_id": run_id, "steps": STATE.step_store.snapshot(run_id)}
+
+
+@router.post("/run")
+async def run_agent(request: RunRequest) -> StreamingResponse:
+    """Start an agent run and stream newline-delimited events."""
+    run_id = request.run_id or new_run_id("ui")
+    session = STATE.session(run_id)
+    session.controls = permission_controls() if request.permission_gate else None
+    prompt_id = f"{run_id}:prompt:{uuid4()}"
+    if request.fault_after_step_commit:
+        STATE.step_store.arm(run_id)
+
+    async def attempt(
+        runtime: AgentRuntime, tools: Tools, on_event: AgentEvent
+    ) -> dict[str, Any]:
+        """Dispatch the prompt through the shared runtime."""
+        try:
+            return await runtime.dispatch(
+                run_id,
+                _console_agent(request.model, tools),
+                Prompt(request.prompt, prompt_id=prompt_id),
+                controls=session.controls,
+                on_event=on_event,
+                should_stop_after_turn=capped,
+            )
+        finally:
+            STATE.step_store.disarm(run_id)
+
+    return StreamingResponse(
+        stream_attempt(run_id, attempt, model=request.model),
+        media_type="application/x-ndjson",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+@router.post("/recover")
+async def recover_agent(request: RecoverRequest) -> StreamingResponse:
+    """Recover a run after a simulated post-commit worker crash.
+
+    The crashed round's model turn replays from the step journal, so nothing is captured
+    host-side; a run with nothing to recover streams an ``InvalidTransition`` error frame.
+    """
+    if request.run_id not in STATE.sessions:
+        raise HTTPException(status_code=404, detail="unknown run_id")
+    session = STATE.sessions[request.run_id]
+
+    async def attempt(
+        runtime: AgentRuntime, tools: Tools, on_event: AgentEvent
+    ) -> dict[str, Any]:
+        """Dispatch the recovery through the shared runtime."""
+        return await runtime.dispatch(
+            request.run_id,
+            _console_agent(request.model, tools),
+            Recover(),
+            controls=session.controls,
+            on_event=on_event,
+            should_stop_after_turn=capped,
+        )
+
+    return StreamingResponse(
+        stream_attempt(request.run_id, attempt, model=request.model),
+        media_type="application/x-ndjson",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+@router.post("/resume")
+async def resume_agent(request: ResumeRequest) -> StreamingResponse:
+    """Resume a suspended tool call with an operator decision."""
+    if request.run_id not in STATE.sessions:
+        raise HTTPException(status_code=404, detail="unknown run_id")
+    session = STATE.sessions[request.run_id]
+    answer = (
+        {"type": "text", "text": "approved by the human"}
+        if request.approved
+        else {"type": "error", "message": "denied by the human"}
+    )
+
+    async def attempt(
+        runtime: AgentRuntime, tools: Tools, on_event: AgentEvent
+    ) -> dict[str, Any]:
+        """Dispatch the operator's answer through the shared runtime."""
+        return await runtime.dispatch(
+            request.run_id,
+            _console_agent(request.model, tools),
+            Answer(request.pending_id, answer),
+            controls=session.controls,
+            on_event=on_event,
+            should_stop_after_turn=capped,
+        )
+
+    return StreamingResponse(
+        stream_attempt(request.run_id, attempt, model=request.model),
+        media_type="application/x-ndjson",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+@router.get("/tasks/{run_id}")
+async def tasks(run_id: str) -> dict[str, Any]:
+    """Return managed tasks and independent children for an agent run.
+
+    Args:
+        run_id: Parent agent run identifier.
+
+    Returns:
+        Mapping containing background task records and independent child addresses.
+    """
+    session = STATE.sessions.get(run_id)
+    if session is None:
+        return {"run_id": run_id, "background": [], "independent": []}
+    return {
+        "run_id": run_id,
+        "background": session.tasks.list(),
+        "independent": list(session.opened),
+    }
+
+
+@router.post("/tasks/cancel")
+async def cancel_task(request: CancelRequest) -> dict[str, Any]:
+    """Cancel a managed background task.
+
+    Args:
+        request: Parent run and task identifiers.
+
+    Returns:
+        Cancelled task identifier and the updated task list.
+
+    Raises:
+        HTTPException: If the run is unknown or the task is not running.
+    """
+    session = STATE.sessions.get(request.run_id)
+    if session is None:
+        raise HTTPException(status_code=404, detail="unknown run_id")
+    if not session.tasks.cancel(request.task_id):
+        raise HTTPException(status_code=409, detail="no running task with that id")
+    return {"cancelled": request.task_id, "background": session.tasks.list()}
+
+
+@router.post("/attach")
+async def attach_agent(request: AttachRequest) -> StreamingResponse:
+    """Submit a prompt to an independent child run.
+
+    Args:
+        request: Child run identifier, prompt, and model selection.
+
+    Returns:
+        Newline-delimited event stream for the child attempt.
+
+    Note:
+        Transcript continuity is provided by the console's recorder and restored as explicit
+        runtime history.
+    """
+
+    async def attempt(
+        runtime: AgentRuntime, tools: Tools, on_event: AgentEvent
+    ) -> dict[str, Any]:
+        """Execute one attempt for the independent child run."""
+        already_said = await history_of(STATE.transcripts, request.run_id)
+        recorder = await Recorder.open(STATE.transcripts, request.run_id, request.prompt)
+
+        async def watched(event: dict[str, Any]) -> None:
+            await recorder.observe(event)
+            await on_event(event)
+
+        try:
+            return await runtime.run(
+                request.run_id,
+                openrouter_model(request.model),
+                tools,
+                request.prompt,
+                on_event=watched,
+                system_prompt=SYSTEM_PROMPT,
+                should_stop_after_turn=capped,
+                history=already_said,
+            )
+        finally:
+            await recorder.closed()
+
+    return StreamingResponse(
+        stream_attempt(request.run_id, attempt, model=request.model),
+        media_type="application/x-ndjson",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+@router.get("/transcript/{run_id}")
+async def transcript(run_id: str) -> dict[str, Any]:
+    """What the console recorded of this run's conversation.
+
+    The panel for the thing that has no panel. `history` is what an attach hands back, so an
+    operator debugging a reattached agent that answers as a stranger can see whether the problem
+    is the recording or the model.
+    """
+    return {
+        "run_id": run_id,
+        "entries": len(await STATE.transcripts.read(run_id)),
+        "history": [
+            {"role": type(message).__name__, "content": str(message.content)[:400]}
+            for message in await history_of(STATE.transcripts, run_id)
+        ],
+    }

semora_ui-0.1.0/src/semora_ui/app.py

@@ -0,0 +1,42 @@
+"""ASGI composition root for the optional Semora test UI."""
+
+from fastapi import FastAPI, Request
+from fastapi.responses import FileResponse, Response
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.base import RequestResponseEndpoint
+
+from .api import router
+from .config import SETTINGS
+
+
+def create_app() -> FastAPI:
+    """Create and configure the test console application."""
+    application = FastAPI(title="Semora Durable Agent Lab")
+
+    @application.middleware("http")
+    async def disable_ui_cache(
+        request: Request, call_next: RequestResponseEndpoint
+    ) -> Response:
+        """Disable browser caching for the UI shell and static assets."""
+        response = await call_next(request)
+        if request.url.path == "/" or request.url.path.startswith("/assets/"):
+            response.headers["Cache-Control"] = "no-store, max-age=0"
+            response.headers["Pragma"] = "no-cache"
+        return response
+
+    application.include_router(router)
+    application.mount(
+        "/assets",
+        StaticFiles(directory=SETTINGS.ui_root / "static"),
+        name="assets",
+    )
+
+    @application.get("/", include_in_schema=False)
+    async def index() -> FileResponse:
+        """Serve the test console entry page."""
+        return FileResponse(SETTINGS.ui_root / "static" / "index.html")
+
+    return application
+
+
+app = create_app()

semora_ui-0.1.0/src/semora_ui/children.py

@@ -0,0 +1,144 @@
+"""Subagent roster and runner adapters for the local test console.
+
+Each child uses ``AgentRuntime`` with the parent's step and transcript stores. The runner adapter
+exposes runtime callbacks as the event stream required by ``Subagents``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from typing import Any
+
+from semora.runtime import AgentRuntime
+from semora.subagents import Answering, Reply, RunnerAgent, Subagent
+
+from .config import SYSTEM_PROMPT
+from .provider import openrouter_model
+from .recording import Recorder, history_of
+from .tools import DemoTools
+
+CHILD_PROMPT = (
+    f"{SYSTEM_PROMPT}\n\n"
+    "You are a subagent. Another agent delegated this task to you. Do the work with your tools, "
+    "then call `respond_to_parent` exactly once with what you found. That call is how your answer "
+    "reaches the agent waiting on it, and it ends your run."
+)
+
+async def _capped(turn: int, _text: str, _calls: list[dict[str, Any]]) -> bool:
+    """Stop a console child after four model turns."""
+    return turn >= 3
+
+
+ROSTER: tuple[tuple[str, str, str], ...] = (
+    (
+        "note-keeper",
+        "Stores and recalls notes. Give it a key and a value, or a key to look up.",
+        "Use `remember_note` to store and `recall_note` to look up.",
+    ),
+    (
+        "echoer",
+        "Echoes text back through a durable tool effect. Useful for testing a round trip.",
+        "Put whatever you are given through the `echo` tool.",
+    ),
+    (
+        "flaky",
+        "Calls an API that always fails. Use it to watch a child report a failure.",
+        "Call `simulate_api_failure` once, then report the failure it returned. A task with no "
+        "detail still gets that call — you exist to fail, so never ask the delegator what to do.",
+    ),
+)
+"""For each console subagent: its name, what the parent reads, and what the child is told.
+
+The third field is why `flaky` fails. Name and description reach the delegating model only; a
+child that is told nothing about its own job answers whatever the roster promised with a question.
+"""
+
+
+def subagents(model: str, store: Any, transcripts: Any) -> list[Subagent]:
+    """Build compiled child definitions for the console roster."""
+    return [
+        RunnerAgent(name, description, _runner(model, store, transcripts, instruction))
+        for name, description, instruction in ROSTER
+    ]
+
+
+def _runner(model: str, store: Any, transcripts: Any, instruction: str) -> Any:
+    """Create a runner backed by durable step and transcript stores."""
+
+    async def run(prompt: str, reply: Reply, run_id: str) -> AsyncIterator[dict[str, Any]]:
+        async for event in _stream_run(
+            AgentRuntime(store=store),
+            run_id,
+            model,
+            Answering(DemoTools(), reply),
+            prompt,
+            transcripts,
+            instruction,
+        ):
+            yield event
+
+    return run
+
+
+async def _stream_run(
+    runtime: AgentRuntime,
+    run_id: str,
+    model: str,
+    tools: Any,
+    prompt: str,
+    transcripts: Any,
+    instruction: str,
+) -> AsyncIterator[dict[str, Any]]:
+    """Run a child and yield its planner events in publication order."""
+    queue: asyncio.Queue[dict[str, Any] | None] = asyncio.Queue()
+    already_said = await history_of(transcripts, run_id)
+    recorder = await Recorder.open(transcripts, run_id, prompt)
+
+    async def on_event(event: dict[str, Any]) -> None:
+        await recorder.observe(event)
+        await queue.put(event)
+
+    async def drive() -> dict[str, Any]:
+        try:
+            # Whatever this child already said. Empty on its first turn, and the reason a second
+            # turn on the same run id continues rather than starting a stranger.
+            return await runtime.run(
+                run_id,
+                openrouter_model(model),
+                tools,
+                prompt,
+                on_event=on_event,
+                system_prompt=f"{CHILD_PROMPT}\n\n{instruction}",
+                should_stop_after_turn=_capped,
+                history=already_said,
+            )
+        finally:
+            await recorder.closed()
+            await queue.put(None)
+
+    task = asyncio.create_task(drive())
+    terminal = False
+    try:
+        while (item := await queue.get()) is not None:
+            terminal = terminal or item.get("type") in {"done", "error"}
+            yield item
+    finally:
+        # Reached on a cancel too — `cancel_task` closes this generator, and a child left running
+        # after its leash was pulled is the thing that cancel exists to prevent.
+        if not task.done():
+            task.cancel()
+    try:
+        outcome = await task
+    except asyncio.CancelledError:
+        raise
+    except Exception as failure:
+        # The one thing the stream cannot carry: a run that raised instead of ending. `_drain`
+        # reads this as a failed child, so the parent is told rather than the exception crossing
+        # into its tool round.
+        yield {"type": "error", "message": f"{type(failure).__name__}: {failure}"}
+        return
+    # `on_event` already carried the terminal event, so re-yielding the outcome would show the
+    # child finishing twice. Yielded only when nothing terminal came through at all.
+    if not terminal:
+        yield outcome

semora_ui-0.1.0/src/semora_ui/config.py

@@ -0,0 +1,63 @@
+"""UI configuration and secret loading."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+UI_ROOT = Path(__file__).resolve().parent
+"""Directory containing the packaged UI assets."""
+
+ENV_FILE = UI_ROOT.parents[1] / ".env"
+"""Development environment file beside the UI package manifest."""
+
+load_dotenv(ENV_FILE)
+
+
+@dataclass(frozen=True, slots=True)
+class Settings:
+    """Store UI and OpenRouter configuration."""
+    ui_root: Path = UI_ROOT
+    default_model: str = "openai/gpt-4o-mini"
+    openrouter_api_key: str = field(default="", repr=False)
+    openrouter_base_url: str = "https://openrouter.ai/api/v1"
+    public_url: str = "http://127.0.0.1:8790"
+
+    @property
+    def configured(self) -> bool:
+        """Return whether an OpenRouter API key is configured."""
+        return bool(self.openrouter_api_key)
+
+    def require_api_key(self) -> str:
+        """Return the configured API key or raise a configuration error."""
+        if not self.openrouter_api_key:
+            raise RuntimeError("OpenRouter API key is missing from packages/semora-ui/.env")
+        return self.openrouter_api_key
+
+    @classmethod
+    def from_environment(cls) -> Settings:
+        """Build settings from supported environment variables."""
+        # OPEN_ROTURE is the spelling used by the imported bug-case fixture.
+        key = (
+            os.getenv("OPENROUTER_API_KEY")
+            or os.getenv("OPENROUTER_KEY")
+            or os.getenv("OPEN_ROTURE")
+            or ""
+        )
+        return cls(
+            default_model=os.getenv("OPENROUTER_MODEL", "openai/gpt-4o-mini"),
+            openrouter_api_key=key,
+        )
+
+
+SETTINGS = Settings.from_environment()
+
+SYSTEM_PROMPT = """You are the Semora runtime test agent. Be concise.
+Use a tool whenever the user explicitly asks you to echo text, remember or recall a note, inspect
+the runtime clock, or simulate an API failure. The simulate_api_failure tool is a harmless test
+fixture: call it immediately when explicitly requested and never ask the user for permission.
+Never claim a tool ran when it did not. Permission approval happens before a tool executes and is
+owned by the runtime, not by a tool result."""