pi-agent-cli-lc 0.2.0__tar.gz → 0.4.0__tar.gz

pi_agent_cli_lc-0.4.0/.gitignore

@@ -0,0 +1,34 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+!tui/crates/build/
+.pytest_cache/
+.pytest-audit/
+.mypy_cache/
+.ruff_cache/
+.venv/
+.venv-*/
+venv/
+.env
+# Rust TUI workspace (Apache-2.0 fork under tui/)
+tui/target/
+**/*.rs.bk
+
+# Benchmark evaluation cache and trial artifacts
+.cache/
+.pi-eval/
+
+# Temporary files, coverage and logs
+*.log
+*.tmp
+*.bak
+*.swp
+*.orig
+.coverage
+.coverage.*
+coverage.xml
+htmlcov/
+

pi_agent_cli_lc-0.4.0/AGENTS.md

@@ -0,0 +1,57 @@
+# pi-agent-cli
+
+Standard-ACP agent over `AgentHarness`. Two modes:
+
+| Mode | Entry | Purpose |
+|------|-------|---------|
+| ACP stdio | `python -m pi_agent_cli` | TUI-spawned agent; `/new` `/resume` `/quit` map to ACP methods |
+| Headless | `python -m pi_agent_cli -p "prompt"` | One-shot turn, prints assistant text, exits |
+
+Headless flags: `--system-prompt`, `--append-system-prompt`, `--no-context-files`, `--no-git-context` — see `--help`.
+
+## Config
+
+Home: `~/.pi-python/` (override with `PI_HOME`). Two config files with distinct owners:
+
+| File | Owner | Scope |
+|------|-------|-------|
+| `agent.toml` | Python agent | model, permission, skills, prompt overrides |
+| `config.toml` | Rust TUI only | grok-shell settings; Python-only keys break TUI parsing |
+
+`local.env` in home loads `KEY=VALUE` pairs into env without overwriting (secrets stay out of TOML). See `agent.example.toml` for all keys.
+
+## TUI spawn
+
+The Rust TUI (`zypi`) spawns the Python agent via (priority order):
+
+1. `PI_AGENT_COMMAND` env var
+2. `[agent].command` in `agent.toml`
+3. `PI_PYTHON` env var (appends `-m pi_agent_cli`)
+
+## System prompt pipeline
+
+`build_system_prompt` (`system_prompt.py`) assembles:
+
+1. Base prompt with tool snippets and `prompt_guidelines`
+2. `append_system_prompt` (config or CLI flag)
+3. Context files — `context_files.py` walks cwd → repo root collecting `AGENTS.md`, `CLAUDE.md`, `.pi/SYSTEM.md`
+4. Git status — `<git_status>` from `git_context.py` when cwd is a repo (`[git]` / `--no-git-context`)
+5. Skills from `[skills].paths`, formatted as `<available_skills>`
+
+`build_coding_agent_harness_system_prompt` (`create_harness.py`) wraps this for harness use.
+
+## Modules
+
+| Module | Role |
+|--------|------|
+| `agent.py` | `PiAcpAgent` — ACP methods, permission handling, event projection |
+| `config.py` | TOML loading, `pi_home()`, `CliConfig` dataclass |
+| `factory.py` | `create_session_harness` — wires tools, model, stream_fn, skills into harness |
+| `system_prompt.py` | `build_system_prompt`, tool snippet/guideline consumption |
+| `context_files.py` | AGENTS.md / CLAUDE.md / .pi/SYSTEM.md discovery |
+| `git_context.py` | Read-only branch and `git status` snapshot for the system prompt |
+| `headless.py` | `-p` one-shot mode, prompt override application |
+| `events.py` | Internal events → ACP `session_update` projection |
+| `permissions.py` | Tool permission gating (ask / auto / always-approve) |
+| `create_harness.py` | Harness-level system prompt, coding tool wiring |
+| `benchmarks/` | Pelican benchmark suite, evaluator, Docker runner |

{pi_agent_cli_lc-0.2.0 → pi_agent_cli_lc-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pi-agent-cli-lc
-Version: 0.2.0
+Version: 0.4.0
 Summary: Standard ACP agent over AgentHarness (no x.ai extensions)
 Project-URL: Homepage, https://github.com/zy1233/pi-python
 Project-URL: Repository, https://github.com/zy1233/pi-python
@@ -20,8 +20,8 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: agent-client-protocol>=0.12.0
-Requires-Dist: pi-agent-core-lc==0.2.0
-Requires-Dist: pi-agent-harness-lc==0.2.0
+Requires-Dist: pi-agent-core-lc==0.4.0
+Requires-Dist: pi-agent-harness-lc==0.4.0
 Requires-Dist: pydantic>=2.0
 Description-Content-Type: text/markdown
 
@@ -31,6 +31,7 @@ Standard [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) agent o
 
 - stdio entry: `python -m pi_agent_cli` (or console script `pi-agent-cli`)
 - headless one-shot: `python -m pi_agent_cli -p "..."` 
+- Headless prompt overrides (override `agent.toml` `[prompt]`): `--system-prompt`, `--system-prompt-file`, `--append-system-prompt` / `--rules`, `--append-system-prompt-file`, `--no-context-files`
 - Config: `~/.pi-python/agent.toml` (see `agent.example.toml` in this directory)
 - No `x.ai/*` vendor RPCs — core + harness + ACP only
 

{pi_agent_cli_lc-0.2.0 → pi_agent_cli_lc-0.4.0}/README.md

@@ -4,6 +4,7 @@ Standard [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) agent o
 
 - stdio entry: `python -m pi_agent_cli` (or console script `pi-agent-cli`)
 - headless one-shot: `python -m pi_agent_cli -p "..."` 
+- Headless prompt overrides (override `agent.toml` `[prompt]`): `--system-prompt`, `--system-prompt-file`, `--append-system-prompt` / `--rules`, `--append-system-prompt-file`, `--no-context-files`
 - Config: `~/.pi-python/agent.toml` (see `agent.example.toml` in this directory)
 - No `x.ai/*` vendor RPCs — core + harness + ACP only
 

{pi_agent_cli_lc-0.2.0 → pi_agent_cli_lc-0.4.0}/agent.example.toml

@@ -20,3 +20,15 @@ paths = ["~/.pi-python/skills", ".pi/skills"]
 [agent]
 # Used by the Rust TUI when PI_AGENT_COMMAND is unset (Windows: prefer a venv python.exe).
 command = "python -m pi_agent_cli"
+
+[prompt]
+# no_context_files = false
+# custom_system_prompt = "You are a helpful assistant."
+# custom_system_prompt_file = "~/.pi-python/agent/SYSTEM.md"
+# append_system_prompt = "Always run tests after edits."
+# append_system_prompt_file = "~/.pi-python/agent/APPEND_SYSTEM.md"
+
+[git]
+# enabled = true
+# timeout_seconds = 2
+# max_status_lines = 40

pi_agent_cli_lc-0.4.0/pi_agent_cli/__main__.py

@@ -0,0 +1,159 @@
+"""stdio entry: python -m pi_agent_cli
+
+Default: ACP agent on stdio.
+`python -m pi_agent_cli -p "..."`: one-shot headless turn (no TUI).
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+from acp import run_agent
+
+from pi_agent_cli.agent import PiAcpAgent
+from pi_agent_cli.config import load_local_env
+from pi_agent_cli.headless import HeadlessPromptOverrides, resolve_print_prompt, run_print
+
+_PROMPT_CLI_FLAG_NAMES = (
+    "system_prompt",
+    "system_prompt_file",
+    "append_system_prompt",
+    "append_system_prompt_file",
+    "no_context_files",
+    "no_git_context",
+)
+
+
+async def _amain() -> None:
+    await run_agent(PiAcpAgent())
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pi-agent-cli",
+        description="Standard ACP agent over AgentHarness (stdio), or one-shot -p print.",
+    )
+    src = parser.add_mutually_exclusive_group()
+    src.add_argument(
+        "-p",
+        "--print",
+        dest="print_prompt",
+        metavar="PROMPT",
+        help="Run one prompt, print the assistant text, and exit (no TUI, no ACP stdio).",
+    )
+    src.add_argument(
+        "--prompt-json",
+        metavar="JSON",
+        help="Single-turn prompt as a JSON string or list of content blocks.",
+    )
+    src.add_argument(
+        "--prompt-file",
+        metavar="PATH",
+        type=Path,
+        help="Read the single-turn prompt from a file.",
+    )
+    parser.add_argument(
+        "--cwd",
+        metavar="PATH",
+        type=Path,
+        help="Working directory for the headless session (default: process cwd).",
+    )
+    system = parser.add_mutually_exclusive_group()
+    system.add_argument(
+        "--system-prompt",
+        "--system-prompt-override",
+        dest="system_prompt",
+        metavar="TEXT",
+        help="Replace the default system prompt (headless only).",
+    )
+    system.add_argument(
+        "--system-prompt-file",
+        metavar="PATH",
+        type=Path,
+        help="Read the system prompt override from a file (headless only).",
+    )
+    append = parser.add_mutually_exclusive_group()
+    append.add_argument(
+        "--append-system-prompt",
+        "--rules",
+        dest="append_system_prompt",
+        metavar="TEXT",
+        help="Append text to the system prompt (headless only).",
+    )
+    append.add_argument(
+        "--append-system-prompt-file",
+        metavar="PATH",
+        type=Path,
+        help="Read append text from a file (headless only).",
+    )
+    parser.add_argument(
+        "--no-context-files",
+        action="store_true",
+        help="Skip AGENTS.md / CLAUDE.md discovery (headless only).",
+    )
+    parser.add_argument(
+        "--no-git-context",
+        action="store_true",
+        help="Omit the <git_status> section from the system prompt (headless only).",
+    )
+    return parser
+
+
+def _prompt_overrides_from_args(args: argparse.Namespace) -> HeadlessPromptOverrides:
+    return HeadlessPromptOverrides(
+        system_prompt=args.system_prompt,
+        system_prompt_file=args.system_prompt_file,
+        append_system_prompt=args.append_system_prompt,
+        append_system_prompt_file=args.append_system_prompt_file,
+        no_context_files=True if args.no_context_files else None,
+        no_git_context=True if args.no_git_context else None,
+    )
+
+
+def _has_prompt_cli_flags(args: argparse.Namespace) -> bool:
+    return any(getattr(args, name) for name in _PROMPT_CLI_FLAG_NAMES)
+
+
+def main() -> None:
+    load_local_env()
+    parser = _build_parser()
+    args = parser.parse_args()
+    headless = any(
+        value is not None for value in (args.print_prompt, args.prompt_json, args.prompt_file)
+    )
+    if not headless and _has_prompt_cli_flags(args):
+        print(
+            "error: --system-prompt, --append-system-prompt, --no-context-files, "
+            "and --no-git-context require headless mode "
+            "(-p, --prompt-json, or --prompt-file)",
+            file=sys.stderr,
+        )
+        raise SystemExit(2)
+    if headless:
+        try:
+            prompt = resolve_print_prompt(
+                print_prompt=args.print_prompt,
+                prompt_json=args.prompt_json,
+                prompt_file=args.prompt_file,
+            )
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            raise SystemExit(2) from exc
+        raise SystemExit(
+            asyncio.run(
+                run_print(
+                    prompt,
+                    cwd=args.cwd,
+                    prompt_overrides=_prompt_overrides_from_args(args),
+                )
+            )
+        )
+    asyncio.run(_amain())
+
+
+if __name__ == "__main__":
+    main()

{pi_agent_cli_lc-0.2.0 → pi_agent_cli_lc-0.4.0}/pi_agent_cli/agent.py

@@ -3,14 +3,19 @@
 from __future__ import annotations
 
 import asyncio
+import logging
+from dataclasses import replace
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 from acp import PROTOCOL_VERSION, RequestError
 from acp.interfaces import Agent, Client
 from acp.schema import (
     AgentCapabilities,
     AudioContentBlock,
+    AvailableCommand,
+    AvailableCommandInput,
+    AvailableCommandsUpdate,
     ClientCapabilities,
     CloseSessionResponse,
     EmbeddedResourceContentBlock,
@@ -25,6 +30,7 @@ from acp.schema import (
     PromptCapabilities,
     PromptResponse,
     ResourceContentBlock,
+    ResumeSessionResponse,
     SessionCapabilities,
     SessionCloseCapabilities,
     SessionInfo,
@@ -32,10 +38,11 @@ from acp.schema import (
     SessionResumeCapabilities,
     SseMcpServer,
     TextContentBlock,
+    UnstructuredCommandInput,
 )
 
-from pi_agent_cli.config import CliConfig, load_config, pi_home
-from pi_agent_cli.events import project_event
+from pi_agent_cli.config import CliConfig, PermissionMode, load_config, pi_home
+from pi_agent_cli.events import project_event, project_message_replay
 from pi_agent_cli.factory import create_session_harness, default_stream_fn, load_session_resources
 from pi_agent_cli.permissions import (
     PERMISSION_OPTIONS,
@@ -48,6 +55,8 @@ from pi_agent_core.messages import ImageContent
 from pi_agent_core.types import StreamFn
 from pi_agent_harness import AgentHarness, JsonlSessionRepo, Session
 
+logger = logging.getLogger(__name__)
+
 _AGENT_INFO = Implementation(name="pi-agent-cli", title="pi-python ACP agent", version="0.1.0")
 
 
@@ -55,6 +64,7 @@ class PiAcpAgent(Agent):
     """Standard-ACP-only agent. Does not register any vendor extension methods."""
 
     _conn: Client | None
+    _commands_advertised: set[str]
 
     def __init__(
         self,
@@ -63,6 +73,7 @@ class PiAcpAgent(Agent):
         home: Path | str | None = None,
         config: CliConfig | None = None,
         repo: JsonlSessionRepo | None = None,
+        extensions: list[Any] | None = None,
     ) -> None:
         self._conn = None
         self._home = pi_home(home)
@@ -73,6 +84,12 @@ class PiAcpAgent(Agent):
         self._repo = repo if repo is not None else JsonlSessionRepo(sessions_dir)
         self._harnesses: dict[str, AgentHarness] = {}
         self._abort_tasks: set[asyncio.Task[Any]] = set()
+        self._session_cwds: dict[str, str] = {}
+        self._client_capabilities: ClientCapabilities | None = None
+        self._client_info: Implementation | None = None
+        self._extensions: list[Any] = extensions or []
+        self._commands_advertised: set[str] = set()
+        self._background_tasks: set[asyncio.Task[Any]] = set()
 
     def on_connect(self, conn: Client) -> None:
         self._conn = conn
@@ -84,6 +101,8 @@ class PiAcpAgent(Agent):
         client_info: Implementation | None = None,
         **kwargs: Any,
     ) -> InitializeResponse:
+        self._client_capabilities = client_capabilities
+        self._client_info = client_info
         return InitializeResponse(
             protocol_version=min(protocol_version, PROTOCOL_VERSION),
             agent_capabilities=AgentCapabilities(
@@ -111,7 +130,15 @@ class PiAcpAgent(Agent):
         session = await self._repo.create({"cwd": cwd})
         session_id = (await session.get_metadata()).id
         await self._bind_session(session_id, session, cwd)
-        return NewSessionResponse(session_id=session_id)
+        # Defer available_commands_update: Zed only registers the session
+        # AFTER it receives NewSessionResponse, so notifications sent before
+        # that are silently dropped.  Schedule via create_task + sleep(0) so
+        # the response is flushed first.  (See zed#60199, zed#53161.)
+        self._schedule_deferred_advertise(session_id)
+        return NewSessionResponse(
+            session_id=session_id,
+            field_meta=self._session_response_meta(),
+        )
 
     async def load_session(
         self,
@@ -126,7 +153,13 @@ class PiAcpAgent(Agent):
             raise RequestError.resource_not_found(session_id)
         session = await self._repo.open(metadata)
         await self._bind_session(session_id, session, metadata.cwd or cwd)
-        return LoadSessionResponse()
+        if self._conn is not None:
+            context = await session.build_context()
+            for msg in context.messages:
+                for update in project_message_replay(msg):
+                    await self._conn.session_update(session_id=session_id, update=update)
+        self._schedule_deferred_advertise(session_id)
+        return LoadSessionResponse(field_meta=self._session_response_meta())
 
     async def list_sessions(
         self, cwd: str | None = None, cursor: str | None = None, **kwargs: Any
@@ -143,8 +176,27 @@ class PiAcpAgent(Agent):
         ]
         return ListSessionsResponse(sessions=sessions)
 
+    async def resume_session(
+        self,
+        session_id: str,
+        cwd: str,
+        additional_directories: list[str] | None = None,
+        mcp_servers: list[HttpMcpServer | SseMcpServer | McpServerStdio] | None = None,
+        **kwargs: Any,
+    ) -> ResumeSessionResponse:
+        metadata = await self._find_metadata(session_id)
+        if metadata is None:
+            raise RequestError.resource_not_found(session_id)
+        session = await self._repo.open(metadata)
+        await self._bind_session(session_id, session, metadata.cwd or cwd)
+        # ACP session/resume intentionally does not replay history.
+        self._schedule_deferred_advertise(session_id)
+        return ResumeSessionResponse(field_meta=self._session_response_meta())
+
     async def close_session(self, session_id: str, **kwargs: Any) -> CloseSessionResponse | None:
-        self._harnesses.pop(session_id, None)
+        harness = self._harnesses.pop(session_id, None)
+        if harness is not None:
+            await harness.close()
         return CloseSessionResponse()
 
     async def prompt(
@@ -160,6 +212,9 @@ class PiAcpAgent(Agent):
         **kwargs: Any,
     ) -> PromptResponse:
         harness = self._require_harness(session_id)
+        # Fallback: re-advertise commands if the deferred task was missed.
+        if session_id not in self._commands_advertised:
+            await self._advertise_commands(session_id)
         text, images = _prompt_to_text_images(prompt)
         try:
             message = await harness.prompt(text, images or None)
@@ -178,11 +233,42 @@ class PiAcpAgent(Agent):
         task.add_done_callback(self._abort_tasks.discard)
 
     async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        if method == "pi/session/delete":
+            session_id_raw = params.get("sessionId", params.get("session_id"))
+            if not isinstance(session_id_raw, str) or not session_id_raw.strip():
+                raise RequestError.invalid_params(
+                    {"reason": "sessionId is required", "method": method}
+                )
+            session_id = session_id_raw.strip()
+            metadata = await self._find_metadata(session_id)
+            harness = self._harnesses.pop(session_id, None)
+            if harness is not None:
+                await harness.abort()
+            # Idempotent delete: missing session still returns success.
+            if metadata is not None:
+                await self._repo.delete(metadata)
+            return {"sessionId": session_id, "deleted": True}
         raise RequestError.method_not_found(method)
 
     async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
+        mode = _permission_mode_from_notification(method, params)
+        if mode is not None:
+            self._config = replace(self._config, permission=mode)
         return None
 
+    def _session_response_meta(self) -> dict[str, Any] | None:
+        model_id = self._config.model_id.strip()
+        if not model_id:
+            return None
+        meta: dict[str, Any] = {
+            "pi/currentModelId": model_id,
+            "pi/currentModelDisplayName": model_id,
+        }
+        provider = self._config.provider.strip()
+        if provider:
+            meta["pi/provider"] = provider
+        return meta
+
     def _require_harness(self, session_id: str) -> AgentHarness:
         harness = self._harnesses.get(session_id)
         if harness is None:
@@ -204,13 +290,14 @@ class PiAcpAgent(Agent):
             return await self._handle_tool_call(session_id, event)
 
         resources = await load_session_resources(cwd=cwd, config=self._config)
-        harness = create_session_harness(
+        harness = await create_session_harness(
             session=session,
             cwd=cwd,
             config=self._config,
             stream_fn=self._stream_fn,
             resources=resources,
             on_tool_call=on_tool_call,
+            extensions=self._extensions,
         )
 
         async def on_event(event: Any, signal: Any | None = None) -> None:
@@ -218,11 +305,67 @@ class PiAcpAgent(Agent):
 
         harness.subscribe(on_event)
         self._harnesses[session_id] = harness
+        self._session_cwds[session_id] = cwd
+
+        # Eagerly load extensions so slash commands are available.
+        await harness.load_extensions()
+
+    def _schedule_deferred_advertise(self, session_id: str) -> None:
+        """Fire-and-forget: advertise commands after the current response flushes."""
+        task = asyncio.create_task(self._deferred_advertise_commands(session_id))
+        self._background_tasks.add(task)
+        task.add_done_callback(self._background_tasks.discard)
+
+    async def _deferred_advertise_commands(self, session_id: str) -> None:
+        """Advertise commands after yielding the event loop.
+
+        Zed registers ACP sessions only after processing the response to
+        ``session/new``.  Notifications sent *before* that response are
+        silently dropped ("unknown session").  Yielding with ``sleep(0)``
+        lets the response flush first.  (See zed-industries/zed#60199.)
+        """
+        await asyncio.sleep(0)
+        await self._advertise_commands(session_id)
+
+    async def _advertise_commands(self, session_id: str) -> None:
+        """Send ``AvailableCommandsUpdate`` so ACP clients show slash commands."""
+        if self._conn is None:
+            return
+        harness = self._harnesses.get(session_id)
+        if harness is None:
+            return
+        commands = harness.extension_registry.get_commands()
+        if not commands:
+            return
+        available: list[AvailableCommand] = []
+        for name, cmd in commands.items():
+            ac = AvailableCommand(
+                name=name,
+                description=cmd.description,
+                input=AvailableCommandInput(
+                    root=UnstructuredCommandInput(hint="<args>"),
+                ),
+            )
+            available.append(ac)
+        logger.debug(
+            "_advertise_commands: sending %d commands: %s",
+            len(available),
+            [c.name for c in available],
+        )
+        await self._conn.session_update(
+            session_id=session_id,
+            update=AvailableCommandsUpdate(
+                session_update="available_commands_update",
+                available_commands=available,
+            ),
+        )
+        self._commands_advertised.add(session_id)
 
     async def _emit_updates(self, session_id: str, event: Any) -> None:
         if self._conn is None:
             return
-        for update in project_event(event):
+        cwd = self._session_cwds.get(session_id)
+        for update in project_event(event, cwd=cwd):
             await self._conn.session_update(session_id=session_id, update=update)
 
     async def _handle_tool_call(self, session_id: str, event: Any) -> dict[str, Any] | None:
@@ -287,11 +430,43 @@ def _prompt_to_text_images(
 
 
 def _stop_reason(message: Any) -> str:
+    """Map internal AssistantMessage stopReason to ACP PromptResponse stop_reason.
+
+    ACP stopReason enum: 'end_turn' | 'max_tokens' | 'max_turn_requests' | 'refusal' | 'cancelled'.
+    Internal stopReason values: 'stop' | 'length' | 'toolUse' | 'error' | 'aborted'.
+    """
     reason = getattr(message, "stopReason", None) or "stop"
     if reason == "aborted":
         return "cancelled"
     if reason == "length":
         return "max_tokens"
     if reason == "error":
-        return "refusal"
+        err = str(getattr(message, "errorMessage", "") or "")
+        if any(w in err.lower() for w in ("refus", "policy", "filter", "safety")):
+            return "refusal"
+        return "end_turn"
     return "end_turn"
+
+
+def _permission_mode_from_notification(
+    method: str, params: dict[str, Any] | None
+) -> PermissionMode | None:
+    """Best-effort permission mode sync for live sessions.
+
+    TUI settings changes are sent as extension notifications; we accept known
+    suffixes and update in-memory mode so the next tool call in this process
+    uses the new policy immediately.
+    """
+    suffix = method.rsplit("/", 1)[-1].strip().lower()
+    if suffix not in {"yolo_mode_changed", "permission_mode_changed"}:
+        return None
+    payload = params or {}
+    raw = payload.get("permission_mode")
+    if raw is None:
+        raw = payload.get("permissionMode")
+    if not isinstance(raw, str):
+        return None
+    normalized = raw.strip().lower()
+    if normalized not in {"ask", "auto", "always-approve"}:
+        return None
+    return cast(PermissionMode, normalized)

pi_agent_cli_lc-0.4.0/pi_agent_cli/benchmarks/__init__.py

@@ -0,0 +1,56 @@
+"""Benchmark evaluation subsystem for pi-agent-cli and pi-python harness."""
+
+from pi_agent_cli.benchmarks.collector import (
+    format_markdown_report,
+    print_summary_table,
+    save_summary_artifacts,
+)
+from pi_agent_cli.benchmarks.egress_policy import (
+    OFFICIAL_ALLOWED_HOSTS,
+    EgressPolicy,
+    resolve_task_egress_policy,
+)
+from pi_agent_cli.benchmarks.evaluator import run_trial
+from pi_agent_cli.benchmarks.golden_seed import (
+    get_seed_dir,
+    is_seed_ready,
+    load_golden_manifest,
+    provision_golden_seeds,
+)
+from pi_agent_cli.benchmarks.models import (
+    BenchmarkSummary,
+    BenchmarkTask,
+    TrialResult,
+)
+from pi_agent_cli.benchmarks.pelican import (
+    PELICAN_PROMPT,
+    PelicanSvgReport,
+    extract_svg,
+    save_pelican_artifact,
+    validate_pelican_svg,
+)
+from pi_agent_cli.benchmarks.task_loader import discover_tasks, load_task_from_dir
+
+__all__ = [
+    "OFFICIAL_ALLOWED_HOSTS",
+    "PELICAN_PROMPT",
+    "BenchmarkSummary",
+    "BenchmarkTask",
+    "EgressPolicy",
+    "PelicanSvgReport",
+    "TrialResult",
+    "discover_tasks",
+    "extract_svg",
+    "format_markdown_report",
+    "get_seed_dir",
+    "is_seed_ready",
+    "load_golden_manifest",
+    "load_task_from_dir",
+    "print_summary_table",
+    "provision_golden_seeds",
+    "resolve_task_egress_policy",
+    "run_trial",
+    "save_pelican_artifact",
+    "save_summary_artifacts",
+    "validate_pelican_svg",
+]