fix: stop plan-mode execution loops

Author: EvanProgramming

docs/self-evolution.md

@@ -238,7 +238,7 @@ diagnostic only and is not treated as a release claim.
 
 ## Verification snapshot commands
 
-Current repository test count at this snapshot: **239 unittest cases**.
+Current repository test count at this snapshot: **240 unittest cases**.
 
 The post-#54 snapshot ran the repository's current checks and smoke coverage:
 
@@ -275,7 +275,7 @@ git diff --check
 ```
 
 The historical post-#54 verification passed the 130 discovered tests; the current
-repository contains 239 discovered tests. The historical run also covered the API
+repository contains 240 discovered tests. The historical run also covered the API
 health/scoping smoke, the CLI command-loop smoke, and the five-case
 clean/evolved benchmark described above. `make check` reports the live 39-tool
 runtime inventory, including 14 `git_` tools. A new artifact is not immediate:

main.py

@@ -4755,6 +4755,35 @@ def _remove_task_blocks(text: str) -> str:
     return _clean_final_response(text)
 
 
+def _legacy_plan_value(text: str) -> dict[str, Any] | None:
+    """Convert a bounded numbered Plan block into a proposal value."""
+    match = re.search(
+        r"^[ \t]*Plan:[ \t]*\n(?P<body>[\s\S]*?)(?=^[ \t]*(?:Action|TaskList|TaskDone|DefineTool):|\Z)",
+        str(text or ""), re.IGNORECASE | re.MULTILINE,
+    )
+    if not match:
+        return None
+    steps = []
+    for line in match.group("body").splitlines():
+        item = re.match(r"^[ \t]*(?:\d+[.)]|[-*])[ \t]+(.+?)\s*$", line)
+        if item:
+            description = item.group(1).strip()
+            steps.append({
+                "id": f"step-{len(steps) + 1}",
+                "title": description[:120],
+                "description": description,
+                "acceptance": ["Step completed with observable evidence"],
+            })
+    if not 1 <= len(steps) <= 10:
+        return None
+    return {
+        "title": steps[0]["title"],
+        "summary": "Review and approve these steps before execution.",
+        "assumptions": [],
+        "steps": steps,
+    }
+
+
 def _parse_model_response(text: str) -> dict[str, Any]:
     """Parse one model response exactly once for the turn state machine."""
     raw = str(text or "").strip()
@@ -4772,6 +4801,12 @@ def _parse_model_response(text: str) -> dict[str, Any]:
                 name, value = normalized
                 question_value = value if name == "AskUser" else None
                 plan_value = value if name == "PlanProposal" else None
+        if (question_value is None and plan_value is None and tool_calls
+                and _active_interaction_mode.get() == "plan"):
+            plan_value = _legacy_plan_value(raw)
+            if plan_value is not None:
+                # A usable plan wins over provider attempts to execute it early.
+                tool_calls = []
         if question_value is not None:
             question = validate_question_request(question_value)
         if plan_value is not None:
@@ -4784,6 +4819,13 @@ def _parse_model_response(text: str) -> dict[str, Any]:
         or bool(re.search(r"^[ \t]*(?:TaskList|TaskDone|DefineTool):", raw, re.IGNORECASE | re.MULTILINE))
         or (question is not None and plan_proposal is not None)
     )
+    disallowed_plan_action = (
+        _active_interaction_mode.get() == "plan"
+        and any(tool_capability(_operation_action(call.get("action", ""))) not in {"read", "network"}
+                for call in tool_calls)
+    )
+    if disallowed_plan_action:
+        tool_calls = []
     return {
         "raw": raw,
         "clean": _clean_final_response(raw),
@@ -4797,6 +4839,8 @@ def _parse_model_response(text: str) -> dict[str, Any]:
             "AskUser and PlanProposal must be the only control block in a response. "
             "No tool or task action was executed."
             if combined_control else
+            "Plan mode rejected an executable action; no action was executed. Retry with one PlanProposal block."
+            if disallowed_plan_action else
             "The model returned an incomplete or ambiguous unwrapped tool call. "
             "No tool was executed. Retry with one complete structured tool call."
             if malformed_unwrapped else None

tests/test_interaction.py

@@ -190,6 +190,38 @@ def test_provider_shaped_plan_is_normalized_but_actions_are_not(self):
         rejected = main._observe_model_response(executable)
         self.assertIsNone(rejected["plan_proposal"])
 
+    def test_plan_mode_converts_plain_plan_and_discards_early_actions(self):
+        mode_token = main._active_interaction_mode.set("plan")
+        previous_controller = main._interaction_controller
+        main._interaction_controller = self.controller
+        try:
+            parsed = main._parse_model_response(
+                "Plan:\n"
+                "1. Create index.html with the requested heading.\n"
+                "2. Serve it locally and verify HTTP 200.\n"
+                'Action: {"action":"write_file","args":"index.html|unsafe"}'
+            )
+            self.assertEqual(parsed["tool_calls"], [])
+            self.assertIsNone(parsed["protocol_error"])
+            rendered = main._interaction_gate(parsed, "Create a local page")
+            self.assertIn("Create index.html", rendered)
+            self.assertEqual(len(self.controller.state()["pending_plan"]["steps"]), 2)
+            self.assertEqual(
+                self.store.list_events(
+                    "execution.receipt", workspace_id="workspace", session_id="session",
+                ),
+                [],
+            )
+
+            action_only = main._parse_model_response(
+                'Action: {"action":"run_cmd","args":"python -m http.server"}'
+            )
+            self.assertEqual(action_only["tool_calls"], [])
+            self.assertIn("rejected an executable action", action_only["protocol_error"])
+        finally:
+            main._interaction_controller = previous_controller
+            main._active_interaction_mode.reset(mode_token)
+
     def test_control_blocks_combined_with_actions_fail_closed(self):
         parsed = main._observe_model_response(
             'AskUser:\n```json\n{"questions":[{"id":"scope","header":"Scope",'