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

{python_agent_harness-1.5.6.4/python_agent_harness.egg-info → python_agent_harness-1.5.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.6.4
+Version: 1.5.6.6
 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.6}/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.6}/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.6"
 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.6}/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.6"
 
 __all__ = [
     "Client",

{python_agent_harness-1.5.6.4 → python_agent_harness-1.5.6.6}/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.6}/python_agent_harness/core/context_manager.py

@@ -65,10 +65,11 @@ class ContextManager:
     def compact(self) -> bool:
         """Compact the conversation; return True on success.
 
-        On success the history is replaced by the summary frame followed
-        by every real user prompt (nudges and other harness-injected
-        messages excluded), so the model keeps the actual requests; the
-        last prompt is the resume request for the next round.
+        On success the history is replaced by the summary frame, every
+        real user prompt (nudges and other harness-injected messages
+        excluded), and a trailing resume message telling the model what
+        is already done — the summary and the prompts alone end on a
+        bare user request, which invites redoing finished work.
         """
         loop = self.loop
         prompts = user_prompt_texts(loop.messages)
@@ -87,8 +88,10 @@ class ContextManager:
             # stays untouched): it is part of the user turn, never a
             # system message.  Every real user prompt (nudges and other
             # harness-injected messages excluded) is preserved verbatim
-            # after the frame, so the model keeps the actual requests.
-            loop.messages = compacted_messages(summary, prompts)
+            # after the frame, so the model keeps the actual requests,
+            # and the trailing resume message states that the summarised
+            # work is done (injected flag: TUI and filters skip it).
+            loop.messages = compacted_messages(summary, prompts, resume=True)
             # The shared conversation now is the compacted one: mirror it
             # onto session.last_messages so the TUI (renders from it) and
             # a later manual /compact start from the summary, not the old

{python_agent_harness-1.5.6.4 → python_agent_harness-1.5.6.6}/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.6}/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.6}/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.6}/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.6/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.6}/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.6}/python_agent_harness/prompts/agent.md

@@ -69,21 +69,6 @@ The user will primarily request you perform software engineering tasks. This inc
 - Batch independent tool calls in a single response to maximize parallelism.
 
 # Tool usage instructions
-**Specialized Tools vs. Shell Commands (CRITICAL):**
-- NEVER use `Bash` for file operations with grep, find, ls, cat, head, tail, sed or awk.
-- ALWAYS use: `Glob`, `Grep`, `Read`, `Edit`, `Write`
-- Reserve `Bash` EXCLUSIVELY for: git, npm, docker, cargo, make, system services and other non-file commands
-- Using bash for file operations violates the tool hierarchy and creates technical debt
-
-**Tool Selection Hierarchy:**
-- File search by name → Use `Glob` (NOT find or ls)
-- Directory listing → Use `Glob` with glob pattern `"*"` (not ls)
-- Content search → Use `Grep` (NOT grep or rg)
-- Read files → Use `Read` (NOT cat/head/tail)
-- Edit files → Use `Edit` (NOT sed/awk)
-- Write files → Use `Write` (NOT echo >/cat <<EOF)
-- System operations → Use `Bash` (for git, npm, docker, etc.)
-
 {{TOOL_INSTRUCTIONS}}
 
 # Code References

{python_agent_harness-1.5.6.4 → python_agent_harness-1.5.6.6}/python_agent_harness/prompts/core.py

@@ -500,7 +500,11 @@ def user_prompt_texts(messages: list) -> list[str]:
     (``remember_user_text`` excludes reminders for title generation —
     a different purpose, so the filters differ.)
     """
-    nudge = config.NUDGE_MESSAGE
+    # Harness-injected one-liners replayed verbatim on every compaction
+    # would accumulate: the completion nudge, and the resume message the
+    # automatic compaction appends (a bare "keep going" carries no task
+    # content — the summary already covers the progress it refers to).
+    injected = {config.NUDGE_MESSAGE, config.RESUME_MESSAGE}
     is_reminder: list[bool] = []
     last_reminder = -1
     for msg in messages:
@@ -523,7 +527,7 @@ def user_prompt_texts(messages: list) -> list[str]:
         if _message_role(msg) != "user":
             continue
         text = _message_text(msg)
-        if not text or text == nudge:
+        if not text or text in injected:
             continue
         if text.startswith(config.COMPACT_HEADER):
             continue
@@ -587,19 +591,29 @@ def compact_summary(
     return summary or None
 
 
-def compacted_messages(summary: str, prompts: list[str]) -> list[Message]:
+def compacted_messages(summary: str, prompts: list[str], resume: bool = False) -> list[Message]:
     """The post-compaction history: the summary frame as a user message
     followed by every preserved user prompt, oldest first.
 
     The summary lives in the user turn (the system prompt is passed
     separately and stays untouched); *prompts* are the real user
     requests (see ``user_prompt_texts``) that must survive compaction.
+
+    *resume* appends ``config.RESUME_MESSAGE`` (flagged ``injected``, so
+    the TUI and the filters skip it) after the prompts: without it the
+    rebuilt history ends with a bare user request and the model may redo
+    work the summary already records.  Only the automatic in-loop
+    compaction passes it — the manual /compact command waits for the
+    next user message instead.
     """
     frame = (config.COMPACT_HEADER + summary + config.COMPACT_SEPARATOR).strip()
-    return [
+    messages = [
         Message(role="user", content=frame),
         *[Message(role="user", content=p) for p in prompts],
     ]
+    if resume:
+        messages.append(Message(role="user", content=config.RESUME_MESSAGE, injected=True))
+    return messages
 
 
 # ---- custom agent discovery -----------------------------------------------

{python_agent_harness-1.5.6.4 → python_agent_harness-1.5.6.6}/python_agent_harness/prompts/subagent.md

@@ -20,26 +20,12 @@ You are an autonomous subagent. Your role is to independently complete well-defi
 You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
 
 # Tool usage instructions
-**Specialized Tools vs. Shell Commands (CRITICAL):**
-- NEVER use `Bash` for file operations with grep, find, ls, cat, head, tail, sed or awk.
-- ALWAYS use: `Glob`, `Grep`, `Read`, `Edit`, `Write`
-- Reserve `Bash` EXCLUSIVELY for: git, npm, docker, cargo, make, system services and other non-file commands
-- Using bash for file operations violates the tool hierarchy and creates technical debt
 
 **Parallel Tool Execution:**
 - Call multiple tools in a single response when tasks are independent
 - Never use placeholders or guess missing parameters
 - Maximize parallel execution to improve efficiency
 
-**Tool Selection Hierarchy:**
-- File search by name → Use `Glob` (NOT find or ls)
-- Directory listing → Use `Glob` with glob pattern `"*"` (not ls)
-- Content search → Use `Grep` (NOT grep or rg)
-- Read files → Use `Read` (NOT cat/head/tail)
-- Edit files → Use `Edit` (NOT sed/awk)
-- Write files → Use `Write` (NOT echo >/cat <<EOF)
-- System operations → Use `Bash` (for git, npm, docker, etc.)
-
 {{TOOL_INSTRUCTIONS}}
 
 # Output Requirements