python-agent-harness 1.5.6.3__tar.gz → 1.5.6.5__tar.gz

{python_agent_harness-1.5.6.3/python_agent_harness.egg-info → python_agent_harness-1.5.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.6.3
+Version: 1.5.6.5
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author-email: Huming Chen <chenhuming@gmail.com>
 License-Expression: MIT
@@ -74,7 +74,7 @@ Edit `~/.config/python-agent-harness/config.json` and set your `base_url`, `api_
 - **FSM-driven execution** — explicit `WAIT` / `TOOL` / `TRET` / `SUPERVISE` / `DONE` / `ERRS` / `ABRT` states. Completion supervision nudges the model when it stops early; failed tool calls are sanitized. Transient API failures (`429` / `5xx`) retry with exponential backoff. Auth-expired codes (configurable via `AUTH_REFRESH_STATUS_CODES` in `config.py`; defaults to `[401, 502]`) trigger automatic API key re-read from config/env.
 - **Context management** — CJK-aware token estimation, per-model context windows, automatic compaction at 70% usage.
 - **Image & text attachments** — attach with `@path` (e.g. `@screenshot.png`, `@README.md`): images (PNG/JPEG/GIF/WebP, up to 20 MB) become multimodal `image_url` parts; text files are inlined. Web URLs supported for images.
-- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Insert`, `Edit` (incl. unified diffs), `Write`, `Mkdir`, `Bash`, `Skill`, `Question`, `LSP`, `PlanExit`. Read-only tool rounds (`Read`, `Glob`, `Grep`, `Skill`, `LSP`) dispatch concurrently; async tools (`Bash`, `Agent`) can also run concurrently. Results always delivered in emitted order.
+- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Edit` (incl. unified diffs), `Write`, `Bash`, `Skill`, `Question`, `PlanExit`. Read-only tool rounds (`Read`, `Glob`, `Grep`, `Skill`) dispatch concurrently; async tools (`Bash`, `Agent`) can also run concurrently. Results always delivered in emitted order.
 - **Plan / Build modes** — plan mode is read-only except for the per-session plan file.
 - **Persistent sessions** — auto-saved after every response to `~/.local/share/python-agent-harness/sessions/`, with LLM-generated titles and `/restore --latest` / `/sessions`.
 - **Focused TUI** — Rich-based with pinned status bar, Todos panel, inline diff rendering, and a `prompt_toolkit` editor with history and completion. `Esc+Enter` submits, `Ctrl-D` quits, `Ctrl-C` cancels.
@@ -191,7 +191,6 @@ All LLM settings live in `~/.config/python-agent-harness/config.json`. Environme
 - **`subagent_llm`** — LLM config for `Agent` tool. Unset values inherit from `llm`. Set `profile` to reuse a `models` entry. Precedence: profile > `subagent_llm` > `llm` > env vars.
 - **`default_agent`** — agent name to use at session start (must exist in `prompts/agents/`). `null` = built-in default.
 - **`paths.context_path` / `paths.skill_path`** — locations for context files and skills. Default: project-local `contexts/` and `skills/`.
-- **`lsp.servers`** — per-extension LSP server overrides for the `LSP` tool. Keys are extensions (`.py`, `.cpp`); each has `command` (argv) and optional `language_id`. Layers on top of `DEFAULT_SERVERS` in `lsp/manager.py`.
 - **`mcp.servers`** — MCP server config (requires `[mcp]` extra). Each supports `transport`, `command`, `args`, `env`, `url`, `headers`, `parallel`, `timeout`, `enabled`.
 - **`headless` / `serve`** — optional budget limits: `max_rounds` (LLM rounds) and `timeout` (wall-clock seconds). `--max-rounds` / `--timeout` override per call; `<= 0` or `null` disables. Unset = unlimited.
 - **Precedence** — code defaults < config file < `OPENAI_*` env vars. Sub-agents also support `OPENAI_SUBAGENT_*` (`_BASE_URL`, `_API_KEY`, `_MODEL`).
@@ -212,7 +211,7 @@ Most of [opencode](https://github.com/anomalyco/opencode)'s prompts and core beh
 | `shell.txt` | `Bash` tool + `agent.md` Git/GitHub guidance |
 | `plan-enter.txt` / `plan-exit.txt` | `PlanExit` tool |
 | `initialize.txt` / `review.txt` / `explain` | `initialize.md` / `review.md` / `commands/explain.md` |
-| compaction / summary / title | `compact.md` / `summary.md` / `title.md` |
+| `compaction` / `summary` / `title` | `compact.md` / `summary.md` / `title.md` |
 | `AGENTS.md` handling | `prompts.py` (`find_agents_md_files`, `load_context_files`) |
 
 ## Development

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/README.md

@@ -40,7 +40,7 @@ Edit `~/.config/python-agent-harness/config.json` and set your `base_url`, `api_
 - **FSM-driven execution** — explicit `WAIT` / `TOOL` / `TRET` / `SUPERVISE` / `DONE` / `ERRS` / `ABRT` states. Completion supervision nudges the model when it stops early; failed tool calls are sanitized. Transient API failures (`429` / `5xx`) retry with exponential backoff. Auth-expired codes (configurable via `AUTH_REFRESH_STATUS_CODES` in `config.py`; defaults to `[401, 502]`) trigger automatic API key re-read from config/env.
 - **Context management** — CJK-aware token estimation, per-model context windows, automatic compaction at 70% usage.
 - **Image & text attachments** — attach with `@path` (e.g. `@screenshot.png`, `@README.md`): images (PNG/JPEG/GIF/WebP, up to 20 MB) become multimodal `image_url` parts; text files are inlined. Web URLs supported for images.
-- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Insert`, `Edit` (incl. unified diffs), `Write`, `Mkdir`, `Bash`, `Skill`, `Question`, `LSP`, `PlanExit`. Read-only tool rounds (`Read`, `Glob`, `Grep`, `Skill`, `LSP`) dispatch concurrently; async tools (`Bash`, `Agent`) can also run concurrently. Results always delivered in emitted order.
+- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Edit` (incl. unified diffs), `Write`, `Bash`, `Skill`, `Question`, `PlanExit`. Read-only tool rounds (`Read`, `Glob`, `Grep`, `Skill`) dispatch concurrently; async tools (`Bash`, `Agent`) can also run concurrently. Results always delivered in emitted order.
 - **Plan / Build modes** — plan mode is read-only except for the per-session plan file.
 - **Persistent sessions** — auto-saved after every response to `~/.local/share/python-agent-harness/sessions/`, with LLM-generated titles and `/restore --latest` / `/sessions`.
 - **Focused TUI** — Rich-based with pinned status bar, Todos panel, inline diff rendering, and a `prompt_toolkit` editor with history and completion. `Esc+Enter` submits, `Ctrl-D` quits, `Ctrl-C` cancels.
@@ -157,7 +157,6 @@ All LLM settings live in `~/.config/python-agent-harness/config.json`. Environme
 - **`subagent_llm`** — LLM config for `Agent` tool. Unset values inherit from `llm`. Set `profile` to reuse a `models` entry. Precedence: profile > `subagent_llm` > `llm` > env vars.
 - **`default_agent`** — agent name to use at session start (must exist in `prompts/agents/`). `null` = built-in default.
 - **`paths.context_path` / `paths.skill_path`** — locations for context files and skills. Default: project-local `contexts/` and `skills/`.
-- **`lsp.servers`** — per-extension LSP server overrides for the `LSP` tool. Keys are extensions (`.py`, `.cpp`); each has `command` (argv) and optional `language_id`. Layers on top of `DEFAULT_SERVERS` in `lsp/manager.py`.
 - **`mcp.servers`** — MCP server config (requires `[mcp]` extra). Each supports `transport`, `command`, `args`, `env`, `url`, `headers`, `parallel`, `timeout`, `enabled`.
 - **`headless` / `serve`** — optional budget limits: `max_rounds` (LLM rounds) and `timeout` (wall-clock seconds). `--max-rounds` / `--timeout` override per call; `<= 0` or `null` disables. Unset = unlimited.
 - **Precedence** — code defaults < config file < `OPENAI_*` env vars. Sub-agents also support `OPENAI_SUBAGENT_*` (`_BASE_URL`, `_API_KEY`, `_MODEL`).
@@ -178,7 +177,7 @@ Most of [opencode](https://github.com/anomalyco/opencode)'s prompts and core beh
 | `shell.txt` | `Bash` tool + `agent.md` Git/GitHub guidance |
 | `plan-enter.txt` / `plan-exit.txt` | `PlanExit` tool |
 | `initialize.txt` / `review.txt` / `explain` | `initialize.md` / `review.md` / `commands/explain.md` |
-| compaction / summary / title | `compact.md` / `summary.md` / `title.md` |
+| `compaction` / `summary` / `title` | `compact.md` / `summary.md` / `title.md` |
 | `AGENTS.md` handling | `prompts.py` (`find_agents_md_files`, `load_context_files`) |
 
 ## Development

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.6.3"
+version = "1.5.6.5"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 authors = [
     {name = "Huming Chen", email = "chenhuming@gmail.com"}

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/__init__.py

@@ -3,20 +3,17 @@
 from .core.models import AgentMode, ImagePart, Message, TextPart, ToolCall, ToolSpec
 from .entry.cli import main  # noqa: F401  (public lib surface: main entry point)
 from .llm.client import Client, LLMClient
-from .lsp.config import LSPConfig, LSPServerConfig
 from .mcp.config import MCPConfig, MCPServerConfig
 from .mcp.manager import MCPManager
 from .session.session import Session
 
-__version__ = "1.5.6.3"
+__version__ = "1.5.6.5"
 
 __all__ = [
     "Client",
     "LLMClient",
     "Session",
     "AgentMode",
-    "LSPConfig",
-    "LSPServerConfig",
     "MCPConfig",
     "MCPManager",
     "MCPServerConfig",

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/core/agent.py

@@ -471,8 +471,9 @@ class AgentLoop:
                     # after successful responses, so without this the
                     # interrupted turn would never reach the session
                     # file — the next turn's save would overwrite it
-                    # without ever containing it.
-                    session.auto_save(salvaged, self.system)
+                    # without ever containing it.  flush bypasses the
+                    # debounce so the partial turn is not lost.
+                    session.flush_auto_save(salvaged)
                     # The title is generated on the first save, not
                     # only on clean completion — an interrupted session
                     # still gets a meaningful name (one-shot; no-op when
@@ -484,6 +485,9 @@ class AgentLoop:
                     # no-op when the title already exists or generation
                     # is in flight)
                     session.generate_session_title()
+                    # The per-round auto_save is debounced; flush at run
+                    # end so the final state always reaches the file.
+                    session.flush_auto_save(salvaged)
         return self.result
 
     def _next_state(self) -> str:
@@ -552,6 +556,20 @@ class AgentLoop:
                         self._just_compacted = True
                         self.info["compacted"] = True
                         return
+                    # Compaction failed (empty summary, no reducible
+                    # prompts, or an exception -- see ContextManager.
+                    # compact): the history is unchanged, so without a
+                    # guard the next WAIT round sees the same
+                    # above-trigger ratio and compacts again, re-billing
+                    # the summary request every round for nothing.
+                    # Remember the current ratio as the floor -- reusing
+                    # the same mechanism as the "still above trigger
+                    # after a successful compaction" case above -- so
+                    # the guard below suppresses re-compaction until the
+                    # context grows meaningfully past it, at which point
+                    # a retry is warranted (the conversation really did
+                    # grow) rather than a no-op loop.
+                    self._compaction_floor = ratio
             else:
                 self._compaction_floor = None
             self._just_compacted = False

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/core/models.py

@@ -69,6 +69,15 @@ class ImagePart:
     path: str | None = None
     url: str | None = None
 
+    def __post_init__(self) -> None:
+        # to_api() runs on every round (token estimation + API payload),
+        # so the base64 data URL is encoded once, not per call.
+        self._data_url: str | None = None
+        if self.data is not None:
+            self._data_url = (
+                f"data:{self.media_type};base64,{base64.b64encode(self.data).decode('ascii')}"
+            )
+
     @classmethod
     def from_url(cls, url: str) -> ImagePart:
         return cls(url=url)
@@ -76,13 +85,9 @@ class ImagePart:
     def to_api(self) -> dict[str, Any]:
         if self.url:
             return {"type": "image_url", "image_url": {"url": self.url}}
-        if self.data is None:
+        if self._data_url is None:
             raise ValueError("ImagePart requires either data or url")
-        b64 = base64.b64encode(self.data).decode("ascii")
-        return {
-            "type": "image_url",
-            "image_url": {"url": f"data:{self.media_type};base64,{b64}"},
-        }
+        return {"type": "image_url", "image_url": {"url": self._data_url}}
 
 
 # Type alias for the individual parts a Message.content list may contain.
@@ -155,6 +160,11 @@ class Message:
     injected: bool = False  # harness-injected (nudge/plan/build-switch), not user input
 
     def to_api(self) -> dict[str, Any]:
+        # Not cached: the per-message dict is cheap to rebuild and
+        # caching it (returning the same object each call) would make a
+        # mutation by any caller corrupt later rounds and token
+        # estimation.  The one expensive step — base64-encoding an image
+        # — is cached on ``ImagePart`` instead (see ImagePart.__post_init__).
         d: dict[str, Any] = {"role": self.role}
         if self.content is not None:
             content = self._api_content()

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/core/token_estimator.py

@@ -45,7 +45,10 @@ def estimate_tokens(text: str) -> int:
     """Estimate tokens in TEXT: Latin ~4 chars/token, CJK ~2 chars/token."""
     if not text:
         return 0
-    cjk = len(_CJK_RE.findall(text))
+    # subn counts CJK chars in one C-speed pass without allocating the
+    # per-match list findall would build (this runs on the full payload
+    # every round).
+    cjk = _CJK_RE.subn("", text)[1]
     latin = len(text) - cjk
     return round(latin / 4.0 + cjk / 2.0)
 

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/entry/cli.py

@@ -45,11 +45,6 @@ def make_session(
     settings = config.load_llm_config(config_path)
     paths = config.load_paths_config(config_path)
     mcp_config = config.load_mcp_config(config_path)
-    # Validate lsp.servers eagerly so a malformed override fails fast at
-    # session start (with a clear message) instead of poisoning the first
-    # LSP tool call mid-session.  The LSP manager re-reads it lazily via
-    # config_path; this call only surfaces config errors early.
-    config.load_lsp_config(config_path)
     model = model or settings["model"]
     # resolve sub-agent overrides against the EFFECTIVE main settings
     # (so a CLI/caller model override is inherited too when the
@@ -277,12 +272,20 @@ def cmd_serve(args: argparse.Namespace) -> int:
 def cmd_config(args: argparse.Namespace) -> int:
     path = config._config_path(args.path)
     if args.init:
-        path.parent.mkdir(parents=True, exist_ok=True)
-        if path.exists():
+        # 0o700 dir / 0o600 file: the config holds the API key, so it must
+        # not be group/world-readable (mode applies to a NEW leaf dir only;
+        # an existing directory keeps its permissions).
+        path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        template = config.CONFIG_TEMPLATE.format(path=str(path).replace("\\", "\\\\"))
+        try:
+            # O_EXCL: create-only, atomically -- no exists()/write race, and
+            # a pre-planted symlink at PATH is refused instead of followed.
+            fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        except FileExistsError:
             print(f"config already exists: {path} (delete it first to overwrite)")
             return 1
-        template = config.CONFIG_TEMPLATE.format(path=str(path).replace("\\", "\\\\"))
-        path.write_text(template, encoding="utf-8")
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(template)
         print(f"wrote config template: {path}")
         return 0
     settings = config.load_llm_config(args.path)
@@ -345,14 +348,6 @@ def cmd_config(args: argparse.Namespace) -> int:
             print(f"  {pattern}: {size}")
     else:
         print("context_windows: (none configured — built-in table in config.py applies)")
-    # Show LSP server overrides (per-extension, layered over the built-ins)
-    lsp_config = config.load_lsp_config(args.path)
-    if lsp_config.servers:
-        print("lsp servers:")
-        for ext, server in sorted(lsp_config.servers.items()):
-            print(f"  {ext}: language_id={server.language_id}, command={' '.join(server.command)}")
-    else:
-        print("lsp servers: (none configured — built-in DEFAULT_SERVERS in lsp/manager.py applies)")
     # Show default agent
     default_agent = config.load_default_agent(args.path)
     print(f"default_agent: {default_agent or '(default: agent.md)'}")

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/entry/headless.py

@@ -59,8 +59,8 @@ def _as_error(value: Any) -> dict[str, Any]:
     ``HeadlessView.errors`` accumulates whatever the notifier passed:
     the agent loop sends a structured ``{"code", "message"}`` for
     classified failures (``budget``/``timeout``), other sites send a
-    plain string whose code is then derived from the text, and the LSP
-    client sends a ``{"message": ...}`` dict.  A nested
+    plain string whose code is then derived from the text, and some
+    callers send a ``{"message": ...}`` dict.  A nested
     ``{"error": {...}}`` shape is unwrapped; a dict carrying only a
     ``code`` falls back to that code for its message so the two never
     disagree on emptiness.
@@ -106,8 +106,7 @@ def error_display_text(value: Any) -> str:
 
     ``notify("error", ...)`` carries either a plain message string or a
     structured ``{"code", "message"}`` payload (the agent loop sends
-    the latter where the outcome is known; the LSP client sends a
-    ``{"message": ...}`` dict too).  Views render this rather than the
+    the latter where the outcome is known).  Views render this rather than the
     raw value, so a structured error does not reach a human as a dict
     repr.
 
@@ -138,6 +137,25 @@ def _cancelled_now(session: Any) -> bool:
     return event is not None and event.is_set() is True
 
 
+def usage_snapshot(session: Any) -> dict[str, Any] | None:
+    """Cumulative input/output tokens and rounds of the current run.
+
+    Reads the CURRENT ``usage_totals`` (``Controller.submit`` swaps in a
+    fresh dict per run, so a reference captured before submit would
+    always snapshot zeros).  None when the session keeps no totals.
+    """
+    totals = getattr(session, "usage_totals", None)
+    if not isinstance(totals, dict):
+        return None
+    usage: dict[str, Any] = {"input": 0, "output": 0, "rounds": 0}
+    with totals.get("_lock", threading.Lock()):
+        for key in ("input", "output", "rounds"):
+            value = totals.get(key)
+            if isinstance(value, (int, float)) and not isinstance(value, bool):
+                usage[key] = int(value)
+    return usage
+
+
 def final_answer_text(session: Session) -> str:
     """The run's final assistant answer, TUI-filtered.
 
@@ -286,69 +304,25 @@ def restore_session(controller: Controller, spec: str, err: TextIO) -> bool:
     file, and restores the saved agent/model.  Returns False (with a
     message on *err*) when no matching session exists.
     """
-    from ..io.persistence import (
-        SessionPersistence,
-        find_session_by_title,
-        parse_saved_body,
-        title_from_filename,
-    )
-
-    if not spec or spec in ("--latest", "latest"):
-        path = SessionPersistence.latest_session()
-    elif os.path.isfile(os.path.expanduser(spec)):
-        path = os.path.expanduser(spec)
-    else:
-        path = find_session_by_title(spec)
+    from .restore import apply_saved_session, load_saved_session, resolve_session_path
+
+    path = resolve_session_path(spec)
     if not path or not os.path.isfile(path):
         err.write(f"no session found: {spec or 'latest'}\n")
         return False
-    # surrogateescape must mirror SessionPersistence.save: the saved body
-    # may carry lone surrogates (the tools read non-UTF-8 files that way),
-    # and a strict decode raised UnicodeDecodeError here.
-    with open(path, encoding="utf-8", errors="surrogateescape") as fh:
-        text = fh.read()
-    meta = SessionPersistence.parse_metadata(text)
-    body = SessionPersistence.strip_metadata(text)
-    messages = parse_saved_body(body)
-    controller.store.file_path = path
-    title = title_from_filename(path)
-    if title:
-        controller.store.title = title
-    agent = meta.get("python-agent-harness--agent")
-    if agent:
-        success, msg = controller.switch_agent(agent)
-        if not success:
-            controller.switch_agent("default")
+    try:
+        saved = load_saved_session(path)
+    except OSError as e:
+        err.write(f"cannot read {path}: {e}\n")
+        return False
+
+    def report(level: str, msg: str) -> None:
+        # headless output is quiet on success: only problems reach stderr
+        if level == "warning":
             err.write(f"warning: {msg}\n")
-    model = meta.get("python-agent-harness--model")
-    if model and model != controller.model:
-        if model == controller.llm_settings.get("model"):
-            # The saved model is the session-start default: the
-            # "default" pseudo-profile restores exactly those settings.
-            controller.switch_model("default")
-        else:
-            success, _ = controller.switch_model(model)
-            if not success:
-                profile = next(
-                    (
-                        name
-                        for name, p in controller.model_profiles.items()
-                        if p.get("model") == model
-                    ),
-                    None,
-                )
-                if profile:
-                    success, _ = controller.switch_model(profile)
-            if not success:
-                err.write(
-                    f"warning: model {model!r} has no matching profile, keeping current model\n"
-                )
-    # Replace conversation history: a new generation, so a stale worker
-    # from a previous run can't clobber the restored session.
-    controller.run_generation += 1
-    controller.last_messages = messages
-    controller.clear_todos()
-    err.write(f"restored: {os.path.basename(path)} ({len(messages)} messages)\n")
+
+    apply_saved_session(controller, saved, report)
+    err.write(f"restored: {os.path.basename(path)} ({len(saved.messages)} messages)\n")
     return True
 
 
@@ -680,20 +654,12 @@ def run_headless_jsonl(
         """The terminal result line: snapshots usage and model so every
         result line — including early failures — carries the same
         fields for the driving process."""
-        usage: dict[str, Any] | None = None
-        # Read the CURRENT usage_totals, not a reference captured before
-        # submit(): Controller.submit swaps in a fresh dict per run, so
-        # a pre-submit reference would always snapshot zeros.
-        totals = getattr(session, "usage_totals", None)
-        if isinstance(totals, dict):
-            usage = {"input": 0, "output": 0, "rounds": 0}
-            with totals.get("_lock", threading.Lock()):
-                for key in ("input", "output", "rounds"):
-                    value = totals.get(key)
-                    if isinstance(value, (int, float)) and not isinstance(value, bool):
-                        usage[key] = int(value)
         view.emit_result(
-            answer, errors=errors, usage=usage, model=session.model, cancelled=cancelled
+            answer,
+            errors=errors,
+            usage=usage_snapshot(session),
+            model=session.model,
+            cancelled=cancelled,
         )
 
     if restore is not None and not restore_session(controller, restore, view.err):

python_agent_harness-1.5.6.5/python_agent_harness/entry/restore.py

@@ -0,0 +1,149 @@
+"""Shared session-restore logic for the TUI's /restore and headless --restore.
+
+Both front ends resolve a saved session the same way (path, title
+substring, or latest), parse it the same way, and apply it to a
+``Controller`` the same way: repoint the session store, restore the
+saved agent and model, and replace the conversation history.  Only the
+reporting differs, so callers pass a ``report(level, message)``
+callback ("ok" for confirmations, "warning" for problems).
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from ..core.models import Message
+from ..io import persistence
+
+if TYPE_CHECKING:
+    from .controller import Controller
+
+AGENT_KEY = "python-agent-harness--agent"
+MODEL_KEY = "python-agent-harness--model"
+PROJECT_KEY = "python-agent-harness--project-dir"
+ROUND_TIMES_KEY = "python-agent-harness--round-times"
+
+Report = Callable[[str, str], None]
+
+
+@dataclass
+class SavedSession:
+    """A parsed session file: its path, metadata and conversation."""
+
+    path: str
+    meta: dict[str, str] = field(default_factory=dict)
+    messages: list[Message] = field(default_factory=list)
+
+    @property
+    def round_times(self) -> list[float]:
+        """Persisted round timestamps; [] when absent or malformed."""
+        raw = self.meta.get(ROUND_TIMES_KEY)
+        if not raw:
+            return []
+        try:
+            return [float(x) for x in raw.split()]
+        except ValueError:
+            return []
+
+
+def resolve_session_path(spec: str) -> str | None:
+    """Map SPEC (empty/"latest"/"--latest", a file path, or a title
+    substring) to a session file path, or None when nothing matches.
+
+    The result is not guaranteed to exist: callers check ``isfile``.
+    """
+    if not spec or spec in ("--latest", "latest"):
+        return persistence.SessionPersistence.latest_session()
+    expanded = os.path.expanduser(spec)
+    if os.path.isfile(expanded):
+        return expanded
+    return persistence.find_session_by_title(spec)
+
+
+def load_saved_session(path: str) -> SavedSession:
+    """Read and parse the session file at PATH.  Raises OSError.
+
+    surrogateescape mirrors ``SessionPersistence.save``: the saved body
+    may carry lone surrogates (non-UTF-8 file content), which a strict
+    decode would reject.
+    """
+    with open(path, encoding="utf-8", errors="surrogateescape") as fh:
+        text = fh.read()
+    store = persistence.SessionPersistence
+    meta = store.parse_metadata(text)
+    messages = persistence.parse_saved_body(store.strip_metadata(text))
+    return SavedSession(path=path, meta=meta, messages=messages)
+
+
+def restore_agent(controller: Controller, agent: str | None, report: Report) -> None:
+    """Switch to the saved AGENT; fall back to the default agent (so no
+    stale tool exclusions linger) when it no longer exists."""
+    if not agent:
+        return
+    try:
+        success, msg = controller.switch_agent(agent)
+        if success:
+            report("ok", msg)
+        else:
+            controller.switch_agent("default")
+            report("warning", msg)
+    except Exception as e:  # noqa: BLE001 - a bad agent must not abort the restore
+        report("warning", f"could not restore agent: {e}")
+
+
+def restore_model(controller: Controller, model: str | None, report: Report) -> None:
+    """Switch back to the saved raw MODEL name through a profile.
+
+    Profile switching also fixes base_url/api_key/temperature, which a
+    bare model-name change would leave pointing at the wrong endpoint.
+    Order: the "default" pseudo-profile when MODEL is the session-start
+    model, else MODEL as a profile name, else a profile whose model
+    matches.  Without a match the current model stays active.
+    """
+    if not model or model == controller.model:
+        return
+    try:
+        if model == controller.llm_settings.get("model"):
+            _, msg = controller.switch_model("default")
+            report("ok", msg)
+            return
+        success, msg = controller.switch_model(model)
+        if not success:
+            profile = next(
+                (name for name, p in controller.model_profiles.items() if p.get("model") == model),
+                None,
+            )
+            if profile:
+                success, msg = controller.switch_model(profile)
+        if success:
+            report("ok", msg)
+        else:
+            report("warning", f"model {model!r} has no matching profile, keeping current model")
+    except Exception as e:  # noqa: BLE001 - a bad model must not abort the restore
+        report("warning", f"could not restore model: {e}")
+
+
+def apply_saved_session(controller: Controller, saved: SavedSession, report: Report) -> None:
+    """Make SAVED the controller's current session.
+
+    The conversation history is replaced in BOTH places the runtime
+    reads it: ``conversation_history`` (what the next run sends) and
+    ``last_messages`` (what the views render).  ``run_generation`` is
+    bumped so a worker still winding down from a cancelled run cannot
+    clobber the restored history with its salvaged one.
+    """
+    store = controller.store
+    store.round_times = saved.round_times
+    store.file_path = saved.path
+    title = persistence.title_from_filename(saved.path)
+    if title:
+        store.title = title
+    restore_agent(controller, saved.meta.get(AGENT_KEY), report)
+    restore_model(controller, saved.meta.get(MODEL_KEY), report)
+    controller.run_generation += 1
+    controller.conversation_history = list(saved.messages)
+    controller.last_messages = list(saved.messages)
+    controller.clear_todos()

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/entry/server.py

@@ -130,7 +130,14 @@ from typing import Any, TextIO
 from ..core.models import api_safe
 from ..session.session import Session
 from .controller import Controller
-from .headless import PROTOCOL_VERSION, JsonlView, _restorable_handler, final_answer_text
+from .headless import (
+    PROTOCOL_VERSION,
+    JsonlView,
+    _cancelled_now,
+    _restorable_handler,
+    final_answer_text,
+    usage_snapshot,
+)
 
 DEFAULT_ANSWER_TIMEOUT = 0.0  # wait forever for a host answer
 
@@ -581,8 +588,7 @@ class AgentServer:
     # -- run execution ------------------------------------------------------------
 
     def _cancelled_now(self) -> bool:
-        event = getattr(self.session, "cancel_event", None)
-        return event is not None and event.is_set() is True
+        return _cancelled_now(self.session)
 
     def _final_answer(self) -> str:
         """The run's final assistant answer, TUI-filtered (headless shape).
@@ -595,16 +601,7 @@ class AgentServer:
 
     def _usage_snapshot(self) -> dict[str, Any] | None:
         """Cumulative input/output tokens and rounds of the current run."""
-        totals = getattr(self.session, "usage_totals", None)
-        if not isinstance(totals, dict):
-            return None
-        usage: dict[str, Any] = {"input": 0, "output": 0, "rounds": 0}
-        with totals.get("_lock", threading.Lock()):
-            for key in ("input", "output", "rounds"):
-                value = totals.get(key)
-                if isinstance(value, (int, float)) and not isinstance(value, bool):
-                    usage[key] = int(value)
-        return usage
+        return usage_snapshot(self.session)
 
     def _execute_run(self, prompt: str, run_id: str) -> None:
         """Run one prompt to completion, streaming lines as they happen.

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/prompts/agent.md

@@ -56,6 +56,7 @@ The user will primarily request you perform software engineering tasks. This inc
 - Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively both in parallel and sequentially.
 - Implement the solution using all tools available to you
 - Verify the solution if possible with tests. NEVER assume specific test framework or test script. Check the README or search codebase to determine the testing approach.
+- Test edge cases to ensure your solution is robust.
 - VERY IMPORTANT:
   - When you have completed a task, you MUST run the lint and typecheck commands (e.g. npm run lint, npm run typecheck, ruff, etc.) with Bash if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask the user for the command to run and if they supply it, proactively suggest writing it to AGENTS.md so that you will know to run it next time.
   - NEVER commit changes unless the user explicitly asks you to.

{python_agent_harness-1.5.6.3 → python_agent_harness-1.5.6.5}/python_agent_harness/prompts/agents/reviewer.md

@@ -3,9 +3,7 @@ name: reviewer
 exclude_tools:
   - Bash
   - Edit
-  - Insert
   - Write
-  - Mkdir
 ---
 
 # Role and Behavior