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

{python_agent_harness-1.5.6.4/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.4
+Version: 1.5.6.5
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author-email: Huming Chen <chenhuming@gmail.com>
 License-Expression: MIT
@@ -211,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.4 → python_agent_harness-1.5.6.5}/README.md

@@ -177,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.4 → 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.4"
+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.4 → python_agent_harness-1.5.6.5}/python_agent_harness/__init__.py

@@ -7,7 +7,7 @@ from .mcp.config import MCPConfig, MCPServerConfig
 from .mcp.manager import MCPManager
 from .session.session import Session
 
-__version__ = "1.5.6.4"
+__version__ = "1.5.6.5"
 
 __all__ = [
     "Client",

{python_agent_harness-1.5.6.4 → 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:

{python_agent_harness-1.5.6.4 → 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.4 → 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.4 → python_agent_harness-1.5.6.5}/python_agent_harness/entry/cli.py

@@ -272,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)

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

@@ -137,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.
 
@@ -285,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
 
 
@@ -679,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.4 → 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.4 → python_agent_harness-1.5.6.5}/python_agent_harness/session/config.py

@@ -53,6 +53,14 @@ CALIBRATION_MAX = 3.0
 SESSION_DIR = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
 SESSION_SUBDIR = "python-agent-harness/sessions"
 AUTO_SAVE_SESSION = True
+# auto_save is called after every round; the full-conversation rewrite is
+# debounced so a long run does not rewrite the whole file each round.
+# A save is skipped while fewer than AUTO_SAVE_MIN_INTERVAL seconds have
+# passed since the last one AND the message count has not grown by
+# AUTO_SAVE_MIN_GROWTH_MSGS.  flush_auto_save() bypasses the debounce
+# (run end, cancel, compaction).
+AUTO_SAVE_MIN_INTERVAL = 2.0
+AUTO_SAVE_MIN_GROWTH_MSGS = 8
 
 # ---- LLM interaction logs ---------------------------------------------------
 LLM_LOG_ENABLED = False
@@ -111,6 +119,36 @@ BASH_TIMEOUT_SILENCE: float | None = 120.0
 # than this regardless of output.  None disables the cap (default).
 BASH_TIMEOUT_MAX: float | None = None
 
+# Environment variables removed from every Bash command's environment
+# (case-insensitive fnmatch patterns over the variable NAME).  The child
+# would otherwise inherit the harness's whole environment, and a single
+# `printenv` would put API keys and cloud credentials into the model's
+# context (and the provider's logs).  Names listed in the config file's
+# ``bash.env_passthrough`` are kept regardless, and so are variables whose
+# value is an existing absolute path (a pointer to a credentials file, e.g.
+# GOOGLE_APPLICATION_CREDENTIALS, is not itself a secret) or a trivial
+# flag (0/1/true/false/...).  A denylist, not an allowlist: commands keep
+# PATH, toolchain, proxy and SSH-agent settings.
+BASH_ENV_SECRET_PATTERNS: tuple[str, ...] = (
+    "*API_KEY*",
+    "*APIKEY*",
+    "*_KEY",
+    "*PRIVATE_KEY*",
+    "*SECRET*",
+    "*TOKEN",
+    "*PASSWORD*",
+    "*PASSWD*",
+    "*_PASS",
+    "*_PWD",
+    "*_PAT",
+    "*CREDENTIAL*",
+    "*COOKIE*",
+)
+
+# Names that match a secret pattern above but never hold a secret
+# (public keys are public by definition); checked first.
+BASH_ENV_NOT_SECRET_PATTERNS: tuple[str, ...] = ("*PUBLIC_KEY*", "*PUBKEY*")
+
 # ---- LLM client ----------------------------------------------------------------
 DEFAULT_BASE_URL = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1")
 DEFAULT_MODEL = os.environ.get("OPENAI_MODEL", "gpt-5-mini")
@@ -252,6 +290,10 @@ CONFIG_TEMPLATE = """\
     "timeout": null
   }},
   "default_agent": null,
+  "bash": {{
+    "_comment": "Secret-looking environment variables (names matching *API_KEY*, *SECRET*, *TOKEN, *PASSWORD*, ... see BASH_ENV_SECRET_PATTERNS in config.py) are removed from Bash commands' environment so `printenv` cannot leak them to the model (variables holding an existing file path are kept). List variable names here to pass specific ones through anyway, e.g. [\\"GH_TOKEN\\"] for `gh`.",
+    "env_passthrough": []
+  }},
   "paths": {{
     "_comment": "Optional overrides for context and skill directories. Absolute paths or ~ expansion supported.",
     "context_path": null,
@@ -497,6 +539,27 @@ def load_paths_config(path: str | os.PathLike | None = None) -> dict:
     return settings
 
 
+def load_bash_env_passthrough(path: str | os.PathLike | None = None) -> frozenset[str]:
+    """Names from ``bash.env_passthrough``: secret-looking environment
+    variables the user explicitly lets Bash commands see (e.g. GH_TOKEN
+    for `gh`).
+
+    Fails closed: a missing/broken file or a malformed section yields
+    an empty set, so secrets stay stripped.
+    """
+    try:
+        data = _read_config(path)
+    except ValueError:
+        return frozenset()
+    section = data.get("bash")
+    if not isinstance(section, dict):
+        return frozenset()
+    names = section.get("env_passthrough")
+    if not isinstance(names, list):
+        return frozenset()
+    return frozenset(n.strip().upper() for n in names if isinstance(n, str) and n.strip())
+
+
 def load_mcp_config(path: str | os.PathLike | None = None) -> MCPConfig:
     """Load MCP server settings from the config file's ``mcp`` object.
 

{python_agent_harness-1.5.6.4 → python_agent_harness-1.5.6.5}/python_agent_harness/session/session.py

@@ -195,6 +195,10 @@ class Session:
         self.todos: list[dict] = []
         self.pending_user_prompts: list[str] = []
         self._save_error: str | None = None
+        # auto_save debounce state (see config.AUTO_SAVE_*): the last
+        # successful save's wall time and conversation length
+        self._last_save_at: float | None = None
+        self._last_save_len: int = 0
         self.last_messages: list = []
         self.cancel_event = threading.Event()
         # Named LLM profiles for runtime switching via /model command
@@ -680,6 +684,39 @@ class Session:
     def auto_save(self, messages: list, system: str | None) -> None:
         if not config.AUTO_SAVE_SESSION:
             return
+        # Debounce the full-conversation rewrite: auto_save runs after
+        # every round, but the file only needs refreshing when enough
+        # time has passed AND the conversation grew.  The growth check
+        # is on the message count (cheap) before the expensive
+        # _conversation_text serialization.
+        now = time.monotonic()
+        # getattr: test doubles built via __new__ skip __init__ and never
+        # set the debounce state; treat a missing state as "never saved".
+        last = getattr(self, "_last_save_at", None)
+        if last is not None:
+            elapsed = now - last
+            grew = (
+                len(messages) - getattr(self, "_last_save_len", 0)
+                >= config.AUTO_SAVE_MIN_GROWTH_MSGS
+            )
+            # skip while inside the min interval and the conversation has
+            # not grown enough; a big round (grew) or the interval
+            # elapsing forces a save
+            if elapsed < config.AUTO_SAVE_MIN_INTERVAL and not grew:
+                return
+        self._do_save(messages)
+
+    def flush_auto_save(self, messages: list) -> None:
+        """Save immediately, bypassing the auto_save debounce.
+
+        Called at run end / cancel / compaction, where the conversation
+        must reach the session file regardless of the debounce window.
+        """
+        if not config.AUTO_SAVE_SESSION:
+            return
+        self._do_save(messages)
+
+    def _do_save(self, messages: list) -> None:
         text = self._conversation_text(messages)
         # retry once: transient failures (NFS hiccup, brief lock) clear
         # on the second attempt; permanent ones (disk full, read-only)
@@ -689,6 +726,8 @@ class Session:
             try:
                 self.store.save(text)
                 self._save_error = None
+                self._last_save_at = time.monotonic()
+                self._last_save_len = len(messages)
                 return
             except (OSError, UnicodeError) as e:
                 # UnicodeError too: a save failure must never escape into
@@ -983,7 +1022,7 @@ class Session:
             # preserved verbatim after the frame, so the model keeps
             # the actual requests.
             self.last_messages = compacted_messages(summary, user_prompt_texts(messages))
-            self.auto_save(self.last_messages, self.system_prompt)
+            self.flush_auto_save(self.last_messages)
             self.notify("compact")
             return True, "Session compacted successfully."
         except Exception as e:  # noqa: BLE001 - compaction failure is non-fatal
@@ -1019,7 +1058,7 @@ class Session:
         if not summary:
             return "Summary failed: empty response."
         self.last_messages.append(Msg(role="assistant", content=summary))
-        self.auto_save(self.last_messages, self.system_prompt)
+        self.flush_auto_save(self.last_messages)
         return "Summary appended."