openrouter-agent-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{openrouter_agent_cli-0.2.0 → openrouter_agent_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrouter-agent-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: Standalone terminal agent for OpenRouter with tool actions and context management.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/protostatis/openrouter-agent-cli
@@ -94,11 +94,12 @@ openrouter-agent --workdir ./my-repo \
   --verify-command "pytest tests/test_auth.py"
 ```
 
-The command runs once at the completion boundary. A failing command receives at
-most one generic repair cycle; a timeout or execution error is reported as
-`not_verified` rather than treated as success. The workflow can be exercised
-without credentials or network access with `openrouter-agent-self-test` (or
-`openrouter-agent --self-test`).
+The command runs at the completion boundary (once initially, and once more
+after the single permitted repair cycle when the first check fails). A failing
+command receives at most one generic repair cycle; a timeout or execution error
+is reported as `not_verified` rather than treated as success. The workflow can
+be exercised without credentials or network access with
+`openrouter-agent-self-test` (or `openrouter-agent --self-test`).
 
 ## Useful flags
 
@@ -457,10 +458,12 @@ Evaluator artifacts:
 ## Offline evaluation workflow
 
 The repository includes a small evaluation workflow that runs the real CLI
-engine, real tool layer, and real task verifiers. The mock profile is fully
-offline: it makes no provider calls. Suite manifests and mock scripts are
-trusted operator-provided input: their commands execute on the host inside a
-disposable working directory, so review them like test code before running.
+engine, real tool layer, and real task verifiers. The mock profile is
+provider-offline: it makes no provider calls (mock-generated commands are host
+shell commands, so they are not a network guarantee). Suite manifests and mock
+scripts are trusted operator-provided input: their commands execute on the host
+inside a disposable working directory, so review them like test code before
+running.
 
 After installing the source checkout with `pip install -e .`:
 

{openrouter_agent_cli-0.2.0 → openrouter_agent_cli-0.2.1}/README.md

@@ -67,11 +67,12 @@ openrouter-agent --workdir ./my-repo \
   --verify-command "pytest tests/test_auth.py"
 ```
 
-The command runs once at the completion boundary. A failing command receives at
-most one generic repair cycle; a timeout or execution error is reported as
-`not_verified` rather than treated as success. The workflow can be exercised
-without credentials or network access with `openrouter-agent-self-test` (or
-`openrouter-agent --self-test`).
+The command runs at the completion boundary (once initially, and once more
+after the single permitted repair cycle when the first check fails). A failing
+command receives at most one generic repair cycle; a timeout or execution error
+is reported as `not_verified` rather than treated as success. The workflow can
+be exercised without credentials or network access with
+`openrouter-agent-self-test` (or `openrouter-agent --self-test`).
 
 ## Useful flags
 
@@ -430,10 +431,12 @@ Evaluator artifacts:
 ## Offline evaluation workflow
 
 The repository includes a small evaluation workflow that runs the real CLI
-engine, real tool layer, and real task verifiers. The mock profile is fully
-offline: it makes no provider calls. Suite manifests and mock scripts are
-trusted operator-provided input: their commands execute on the host inside a
-disposable working directory, so review them like test code before running.
+engine, real tool layer, and real task verifiers. The mock profile is
+provider-offline: it makes no provider calls (mock-generated commands are host
+shell commands, so they are not a network guarantee). Suite manifests and mock
+scripts are trusted operator-provided input: their commands execute on the host
+inside a disposable working directory, so review them like test code before
+running.
 
 After installing the source checkout with `pip install -e .`:
 

{openrouter_agent_cli-0.2.0 → openrouter_agent_cli-0.2.1}/openrouter_agent_cli/cli.py

@@ -773,9 +773,11 @@ class OpenRouterAgentCLI:
                     self._batch_allow.clear()
                     self._batch_deny.clear()
                 stored_workdir = data.get("workdir", "")
+                workdir_mismatch = False
                 if stored_workdir:
                     current_workdir = str(Path(self.workdir).resolve())
                     if stored_workdir != current_workdir:
+                        workdir_mismatch = True
                         print(
                             _strip_control_chars(
                                 f"[session] Working directory changed since last session (was {stored_workdir}, now {current_workdir}). "
@@ -800,13 +802,21 @@ class OpenRouterAgentCLI:
                         "last_check": stored_work_order.get("last_check"),
                         "updated_at": stored_work_order.get("updated_at"),
                     }
+                    if workdir_mismatch:
+                        # An acceptance result from another directory does not
+                        # apply here; never display stale verified evidence.
+                        self.work_order["status"] = "not_verified"
+                        self.work_order["last_check"] = None
                 stored_cache = data.get("cache_context")
                 if self.cache_mode != "off" and isinstance(stored_cache, dict):
+                    # Restore only cumulative observations. The pairwise
+                    # stable-prefix fields are transient (there are no stored
+                    # request hashes to back them), so they start fresh and are
+                    # recomputed on the next request instead of displaying a
+                    # stale prefix with no fingerprint.
                     for name in (
                         "requests",
                         "compactions",
-                        "stable_prefix_tokens",
-                        "stable_prefix_messages",
                         "observed_cached_tokens",
                         "provider_cache_observations",
                     ):
@@ -896,6 +906,7 @@ class OpenRouterAgentCLI:
             "exit_code": result.get("exit_code"),
             "timed_out": bool(result.get("timed_out")),
             "duration_ms": result.get("duration_ms"),
+            "checked_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
             "stdout": result.get("stdout", ""),
             "stderr": result.get("stderr", ""),
             "error": result.get("error", ""),
@@ -1563,6 +1574,7 @@ class OpenRouterAgentCLI:
                         "%Y-%m-%dT%H:%M:%SZ", time.gmtime()
                     )
                 self._install_completion_policy()
+                self._save_session()
                 print("Acceptance check re-scoped to the new working directory (status reset to not_verified).")
             print(_strip_control_chars(f"Working directory set to: {self.workdir}"))
             print("Session-scoped permission grants cleared after cwd change.")
@@ -2980,6 +2992,34 @@ class OpenRouterAgentCLI:
             self._display_check_result(result)
             self._last_displayed_check = result
 
+    def _emit_completion_summary(self) -> None:
+        """Emit a deterministic completion notice when a repair response ended
+        with tools and there is no model final text to show.
+
+        One-shot mode promises the assistant reply on stdout; without this the
+        turn would end silently with an empty reply even after verified work.
+        The notice is CLI-generated and clearly labeled, never fabricated
+        model text, and applies only to the user acceptance policy.
+        """
+        if not isinstance(self.checkpoint_hook, UserCompletionPolicy):
+            return
+        if self.completion_policy is None:
+            return
+        result = self.completion_policy.last_result
+        if not result:
+            return
+        status = str(result.get("status") or "not_verified").upper()
+        command = str(result.get("command") or "")
+        exit_code = result.get("exit_code")
+        changed = list(result.get("changed_files") or [])
+        code = f" (exit_code={exit_code})" if exit_code is not None else ""
+        changed_text = f" Changed files: {', '.join(changed)}." if changed else ""
+        summary = (
+            f"[cli] Turn ended after the repair check: {status}: "
+            f"{command}{code}{changed_text}"
+        )
+        self._output_response(summary)
+
     async def _run_user_turn(self, client: httpx.AsyncClient, user_text: str) -> str:
         self._turn_allow.clear()
         self._turn_deny.clear()
@@ -3102,8 +3142,14 @@ class OpenRouterAgentCLI:
                         or ""
                     )
                     self.messages.append(forced_message)
-                except Exception:
-                    text = ""
+                except Exception as e:
+                    # A loop-breaker failure is still a provider failure. Do not
+                    # fabricate a normal answer: record it like the primary
+                    # request handlers and terminate without grading the turn.
+                    self._log(f"[openrouter] Loop-breaker request failed: {e}")
+                    self.terminal_status = "provider_error"
+                    self._save_session()
+                    return ""
                 if not text:
                     text = "I got stuck in a tool loop and could not make progress."
                 should_continue, result = await self._handle_final_answer(
@@ -3287,6 +3333,7 @@ class OpenRouterAgentCLI:
                     continue
                 self._display_policy_check()
                 if action == "stop" or self._checkpoint_repair_pending:
+                    self._emit_completion_summary()
                     self._save_session()
                     return ""
 
@@ -3300,6 +3347,7 @@ class OpenRouterAgentCLI:
                 )
                 self._display_policy_check()
                 self._apply_checkpoint_decision(decision)
+                self._emit_completion_summary()
                 self._save_session()
                 return ""
 
@@ -3593,6 +3641,17 @@ def main() -> int:
     except KeyboardInterrupt:
         pass
 
+    # One-shot mode must signal provider failures to callers instead of
+    # exiting 0 after an empty turn.
+    if args.prompt is not None and cli.terminal_status != "ok":
+        print(
+            f"[openrouter] request failed; turn ended with terminal_status="
+            f"{cli.terminal_status}",
+            file=sys.stderr,
+        )
+        return 1
+    return 0
+
 
 if __name__ == "__main__":
     raise SystemExit(main())

{openrouter_agent_cli-0.2.0 → openrouter_agent_cli-0.2.1}/openrouter_agent_cli/eval/runner.py

@@ -197,11 +197,18 @@ class SuiteRunner:
             engine.policy = ToolPermissionPolicy(allow={"*"})
             engine.non_interactive_mode = True
             engine.one_shot_prompt = task.prompt
-            if getattr(self, "_sandboxed", False) and not profile.uses_mock:
+            if profile.uses_mock:
+                record["engine"]["execution_mode"] = "mock"
+            elif getattr(self, "_sandboxed", False):
                 from .sandbox import BubblewrapBashRunner
 
                 engine.bash_runner = BubblewrapBashRunner(str(workspace))
                 record["engine"]["sandbox"] = "bubblewrap"
+                record["engine"]["execution_mode"] = "bubblewrap"
+            else:
+                # Explicitly acknowledged host-mode execution (operator dev
+                # checks only; never valid experiment evidence).
+                record["engine"]["execution_mode"] = "host_acknowledged"
             if policy is not None:
                 engine.checkpoint_hook = policy
             if profile.uses_mock:
@@ -324,7 +331,10 @@ class SuiteRunner:
                 expected_task_ids=[task.id for task in self.suite.tasks],
                 expected_profile_names=[profile.name for profile in self.profiles],
                 expected_repeats=self.repeats,
-                require_containment=any(not profile.uses_mock for profile in self.profiles),
+                # Containment is required only for the mode that was actually
+                # executed: an explicitly acknowledged host-mode run is
+                # auditable as host execution, not silently rejected.
+                require_containment=self._sandboxed,
             )
         finally:
             self.cleanup_workspaces(records)

{openrouter_agent_cli-0.2.0 → openrouter_agent_cli-0.2.1}/openrouter_agent_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrouter-agent-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: Standalone terminal agent for OpenRouter with tool actions and context management.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/protostatis/openrouter-agent-cli
@@ -94,11 +94,12 @@ openrouter-agent --workdir ./my-repo \
   --verify-command "pytest tests/test_auth.py"
 ```
 
-The command runs once at the completion boundary. A failing command receives at
-most one generic repair cycle; a timeout or execution error is reported as
-`not_verified` rather than treated as success. The workflow can be exercised
-without credentials or network access with `openrouter-agent-self-test` (or
-`openrouter-agent --self-test`).
+The command runs at the completion boundary (once initially, and once more
+after the single permitted repair cycle when the first check fails). A failing
+command receives at most one generic repair cycle; a timeout or execution error
+is reported as `not_verified` rather than treated as success. The workflow can
+be exercised without credentials or network access with
+`openrouter-agent-self-test` (or `openrouter-agent --self-test`).
 
 ## Useful flags
 
@@ -457,10 +458,12 @@ Evaluator artifacts:
 ## Offline evaluation workflow
 
 The repository includes a small evaluation workflow that runs the real CLI
-engine, real tool layer, and real task verifiers. The mock profile is fully
-offline: it makes no provider calls. Suite manifests and mock scripts are
-trusted operator-provided input: their commands execute on the host inside a
-disposable working directory, so review them like test code before running.
+engine, real tool layer, and real task verifiers. The mock profile is
+provider-offline: it makes no provider calls (mock-generated commands are host
+shell commands, so they are not a network guarantee). Suite manifests and mock
+scripts are trusted operator-provided input: their commands execute on the host
+inside a disposable working directory, so review them like test code before
+running.
 
 After installing the source checkout with `pip install -e .`:
 

{openrouter_agent_cli-0.2.0 → openrouter_agent_cli-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrouter-agent-cli"
-version = "0.2.0"
+version = "0.2.1"
 description = "Standalone terminal agent for OpenRouter with tool actions and context management."
 readme = "README.md"
 license = "MIT"

{openrouter_agent_cli-0.2.0 → openrouter_agent_cli-0.2.1}/tests/test_eval_runner.py

@@ -298,3 +298,43 @@ def test_unknown_assisted_profile_is_rejected(tmp_path: Path, suite: Path) -> No
             None,
             assisted_profiles={"worker", "ghost"},
         )
+
+
+def test_host_mode_audit_uses_actual_containment(
+    tmp_path: Path, suite: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """An explicitly acknowledged host-mode real run must be audited as host
+    execution (require_containment follows _sandboxed), not rejected."""
+    from openrouter_agent_cli.eval.records import make_record, new_run_id
+
+    monkeypatch.setenv("OPENROUTER_API_KEY", "test-key")
+    monkeypatch.setenv("AGENT_EVAL_ALLOW_HOST_EXECUTION", "1")
+    monkeypatch.setenv("AGENT_EVAL_SANDBOX", "0")
+    loaded = load_suite(suite)
+    runner = SuiteRunner(
+        loaded,
+        [Profile(name="real", prompt="P", model="m")],
+        eval_dir=tmp_path / "eval",
+    )
+    assert runner._sandboxed is False
+
+    captured: dict = {}
+    monkeypatch.setattr(
+        "openrouter_agent_cli.eval.runner.assert_audited",
+        lambda records, **kwargs: captured.update(kwargs),
+    )
+
+    async def fake_run():
+        r = make_record(
+            run_id=new_run_id(), suite_id=loaded.suite_id,
+            task_id=loaded.tasks[0].id, cluster_id=loaded.tasks[0].cluster_id,
+            profile_name="real", profile_prompt="P", model="m",
+            transport="openrouter", workdir=str(tmp_path), scheduled_index=0,
+        )
+        r["engine"] = {"execution_mode": "host_acknowledged", "error": None}
+        r["verdict"] = "infrastructure_error"
+        return [r]
+
+    monkeypatch.setattr(runner, "run", fake_run)
+    asyncio.run(runner.run_and_verify())
+    assert captured.get("require_containment") is False

{openrouter_agent_cli-0.2.0 → openrouter_agent_cli-0.2.1}/tests/test_long_running.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import os
 import shlex
 import sys
@@ -303,3 +304,193 @@ async def test_provider_failure_sets_terminal_status(tmp_path, monkeypatch):
     async with httpx.AsyncClient() as client:
         await cli._run_user_turn(client, "hi")
     assert cli.terminal_status == "provider_error"
+
+
+@pytest.mark.asyncio
+async def test_loop_breaker_failure_is_provider_error(tmp_path, monkeypatch):
+    """A failed forced loop-breaker call must be recorded as a provider error
+    and terminate, not fabricate a normal answer."""
+    session_dir = tmp_path / "sessions"
+    monkeypatch.setenv("OPENROUTER_AGENT_SESSION_DIR", str(session_dir))
+    cli = OpenRouterAgentCLI(
+        api_key="test-key",
+        model="test-model",
+        session_id="loop-break-test",
+        workdir=str(tmp_path),
+        max_turns=10,
+        max_history_messages=60,
+        command_timeout=5,
+        tools_enabled=True,
+        system_prompt=DEFAULT_SYSTEM_PROMPT,
+        discovery_mode="off",
+    )
+    cli.non_interactive_mode = True
+    cli.policy = ToolPermissionPolicy(allow={"*"})
+    repeated = {"name": "run_bash", "arguments": {"command": "true"}}
+
+    class FailingLoopBreaker:
+        def __init__(self):
+            self.requests = 0
+
+        async def __call__(self, client, **kwargs):
+            self.requests += 1
+            if kwargs.get("tool_choice") == "none":
+                raise RuntimeError("loop-breaker provider failure")
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "role": "assistant",
+                            "content": None,
+                            "tool_calls": [
+                                {
+                                    "id": f"tc-{self.requests}",
+                                    "type": "function",
+                                    "function": {
+                                        "name": "run_bash",
+                                        "arguments": '{"command": "true"}',
+                                    },
+                                }
+                            ],
+                        },
+                        "finish_reason": "tool_calls",
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 1,
+                    "completion_tokens": 1,
+                    "total_tokens": 2,
+                },
+            }
+
+    transport = FailingLoopBreaker()
+    cli.model_transport = transport
+    async with httpx.AsyncClient() as client:
+        result = await cli._run_user_turn(client, "do it")
+    assert result == ""
+    assert cli.terminal_status == "provider_error"
+    # The repeated tool call was nudged; the forced request failed once.
+    assert transport.requests == 3
+
+
+@pytest.mark.asyncio
+async def test_tool_repair_emits_completion_notice(
+    tmp_path, monkeypatch, capsys
+):
+    """The tool-using repair path must print a deterministic completion notice
+    so one-shot mode is not left with an empty stdout."""
+    engine = _engine_with_task(
+        tmp_path,
+        monkeypatch,
+        task="Create marker.txt",
+        verify_command="test -f marker.txt",
+        responses=[
+            {"tool_calls": [
+                {"name": "write_file",
+                 "arguments": {"path": "tmp.txt", "content": "x\n"}}
+            ]},
+            {"text": "I wrote tmp.txt, marker is next"},
+            {"tool_calls": [
+                {"name": "write_file",
+                 "arguments": {"path": "marker.txt", "content": "ok\n"}}
+            ]},
+            {"text": "must not be requested"},
+        ],
+    )
+    async with httpx.AsyncClient() as client:
+        await engine._run_user_turn(client, "Do the work.")
+    out = capsys.readouterr().out
+    assert "Turn ended after the repair check: VERIFIED" in out
+
+
+def test_cached_prefix_is_not_restored_on_resume(tmp_path, monkeypatch):
+    """Session loading restores cumulative counters but never transient
+    stable-prefix state (there are no stored request hashes to back it)."""
+    session_dir = tmp_path / "sessions"
+    monkeypatch.setenv("OPENROUTER_AGENT_SESSION_DIR", str(session_dir))
+    kwargs = {
+        "api_key": "test-key",
+        "model": "test-model",
+        "workdir": str(tmp_path),
+        "max_turns": 2,
+        "max_history_messages": 60,
+        "command_timeout": 5,
+        "tools_enabled": True,
+        "system_prompt": DEFAULT_SYSTEM_PROMPT,
+        "discovery_mode": "off",
+    }
+    first = OpenRouterAgentCLI(**kwargs, session_id="cache-resume")
+    prefix = [
+        {"role": "system", "content": "stable-system"},
+        {"role": "user", "content": "hello"},
+    ]
+    first.cache_context.observe_request(prefix)
+    first.cache_context.observe_request(prefix + [{"role": "assistant", "content": "hi"}])
+    assert first.cache_context.stable_prefix_tokens > 0
+    first._save_session()
+
+    resumed = OpenRouterAgentCLI(**kwargs, session_id="cache-resume")
+    assert resumed.cache_context.stable_prefix_tokens == 0
+    assert resumed.cache_context.stable_prefix_messages == 0
+    # Cumulative observations survive.
+    assert resumed.cache_context.requests == 2
+
+
+def test_workdir_mismatch_invalidates_acceptance(tmp_path, monkeypatch):
+    """An acceptance result from another directory must never be shown as
+    verified after resuming in a different workdir."""
+    session_dir = tmp_path / "sessions"
+    other = tmp_path / "other"
+    other.mkdir()
+    monkeypatch.setenv("OPENROUTER_AGENT_SESSION_DIR", str(session_dir))
+    kwargs = {
+        "api_key": "test-key",
+        "model": "test-model",
+        "max_turns": 2,
+        "max_history_messages": 60,
+        "command_timeout": 5,
+        "tools_enabled": True,
+        "system_prompt": DEFAULT_SYSTEM_PROMPT,
+        "discovery_mode": "off",
+    }
+    first = OpenRouterAgentCLI(
+        **kwargs, session_id="workdir-switch", workdir=str(tmp_path),
+        task="Task X", verify_command="pytest -q",
+    )
+    first.work_order["status"] = "verified"
+    first._save_session()
+
+    resumed = OpenRouterAgentCLI(
+        **kwargs, session_id="workdir-switch", workdir=str(other)
+    )
+    assert resumed.work_order["objective"] == "Task X"
+    assert resumed.work_order["status"] == "not_verified"
+    assert resumed.work_order["last_check"] is None
+
+
+@pytest.mark.asyncio
+async def test_cwd_change_persists_contract_reset(tmp_path, monkeypatch):
+    session_dir = tmp_path / "sessions"
+    other = tmp_path / "other-project"
+    other.mkdir()
+    monkeypatch.setenv("OPENROUTER_AGENT_SESSION_DIR", str(session_dir))
+    cli = OpenRouterAgentCLI(
+        api_key="test-key",
+        model="test-model",
+        session_id="cwd-persist",
+        workdir=str(tmp_path),
+        max_turns=2,
+        max_history_messages=60,
+        command_timeout=5,
+        tools_enabled=True,
+        system_prompt=DEFAULT_SYSTEM_PROMPT,
+        discovery_mode="off",
+        task="Task X",
+        verify_command="pytest -q",
+    )
+    cli.work_order["status"] = "verified"
+    await cli._handle_command(None, f"/cwd {other}")
+
+    persisted = json.loads(cli._session_path.read_text())
+    assert persisted["work_order"]["status"] == "not_verified"
+    assert persisted["work_order"]["verify_command"] == "pytest -q"