`e4b7f3b`

Recover blocked HTML structure edits

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 week ago

SHA: e4b7f3b86f48f48c8dc4ba49c71a9ea95b5492f3
Parents: 6925565
Tree: 4d94db3

2 changed files

Status	File	+	-
M	`src/loader/runtime/tool_batches.py`	51	0
M	`tests/test_tool_batches.py`	102	0

src/loader/runtime/tool_batches.pymodified

                      tool_call,
                      outcome.event_content,
+                 )
 +                self._queue_blocked_html_structure_nudge(
 +                    tool_call,
 +                    outcome.event_content,
 +                )
                  self._queue_blocked_html_content_quality_nudge(
                      tool_call,
                      outcome.event_content,
              "mutation succeeds."
+         )
 +    def _queue_blocked_html_structure_nudge(
 +        self,
 +        tool_call: ToolCall,
 +        event_content: str,
 +    ) -> None:
 +        """Recover blocked HTML structure edits without implying the file changed."""
++
 +        if tool_call.name not in {"write", "edit", "patch"}:
 +            return
 +        if "HTML document structure would be invalid" not in event_content:
 +            return
++
 +        target = str(
 +            tool_call.arguments.get("file_path")
 +            or tool_call.arguments.get("path")
 +            or ""
 +        ).strip()
 +        if not target:
 +            return
++
 +        anchor = html_quality_repair_insertion_anchor(target)
 +        if anchor:
 +            self.context.queue_steering_message(
 +                f"The last HTML mutation for `{target}` was blocked before it "
 +                "changed the file. Do not assume the on-disk file is malformed. "
 +                "Stay on this same file and insert the new body content before "
 +                "the existing closing document tail. Use one concrete `edit` or "
 +                "`patch` that preserves exactly one closing tail; do not add a "
 +                "second `</body>` or `</html>`. Exact current closing-tail anchor:\n"
 +                f"```html\n{anchor}\n```\n"
 +                "If using `edit`, make that anchor the `old_string`, and make "
 +                "`new_string` the added substantive sections followed by the same "
 +                "anchor. Do not reread or list unrelated files before retrying."
 +            )
 +            return
++
 +        self.context.queue_steering_message(
 +            f"The last HTML mutation for `{target}` was blocked before it changed "
 +            "the file because the proposed result would have malformed document "
 +            "structure. Retry the same target with one complete HTML document that "
 +            "has exactly one `<html>`, one `<body>`, one `</body>`, one `</html>`, "
 +            "and no content after `</html>`. Do not assume the blocked mutation "
 +            "was applied, do not switch files, and do not claim completion until "
 +            "the mutation succeeds."
 +        )
++
      def _queue_blocked_invalid_mutation_nudge(
          self,
          tool_call: ToolCall,
          "[Blocked - HTML file creation falls outside the current declared artifact set]",
          "[Blocked - HTML page introduces new local targets outside the current declared artifact set]",
          "[Blocked - HTML local asset references do not exist]",
 +        "[Blocked - HTML document structure would be invalid]",
          "[Blocked - HTML content contains placeholder or stub text]",
          "[Blocked - HTML guide chapter content is too thin]",
          "[Blocked - Edited HTML links point to files that do not exist]",

tests/test_tool_batches.pymodified

      assert "not a scaffold or outline" in queued[-1]
 +@pytest.mark.asyncio
 +async def test_tool_batch_runner_blocked_html_structure_guidance_does_not_halt(
 +    temp_dir: Path,
 +) -> None:
 +    async def assess_confidence(
 +        tool_name: str,
 +        tool_args: dict,
 +        context: str,
 +    ) -> ConfidenceAssessment:
 +        raise AssertionError("Confidence scoring should not run in this scenario")
++
 +    async def verify_action(
 +        tool_name: str,
 +        tool_args: dict,
 +        result: str,
 +        expected: str = "",
 +    ) -> ActionVerification:
 +        raise AssertionError("Verification should not run in this scenario")
++
 +    target = temp_dir / "guide" / "chapters" / "08-monitoring.html"
 +    target.parent.mkdir(parents=True)
 +    target.write_text(
 +        "\n".join(
 +            [
 +                "<!DOCTYPE html>",
 +                '<html lang="en">',
 +                "<body>",
 +                "<h1>Monitoring</h1>",
 +                "<p>Existing content.</p>",
 +                "</body>",
 +                "</html>",
 +                "",
 +            ]
 +        )
 +    )
++
 +    context = build_context(
 +        temp_dir=temp_dir,
 +        messages=[],
 +        safeguards=FakeSafeguards(),
 +        assess_confidence=assess_confidence,
 +        verify_action=verify_action,
 +    )
 +    queued: list[str] = []
 +    context.queue_steering_message_callback = queued.append
 +    runner = ToolBatchRunner(context, DefinitionOfDoneStore(temp_dir))
 +    dod = create_definition_of_done("Expand a guide chapter.")
++
 +    tool_calls = [
 +        ToolCall(
 +            id=f"patch-structure-{index}",
 +            name="patch",
 +            arguments={"file_path": str(target), "patch": "@@ malformed"},
 +        )
 +        for index in range(3)
 +    ]
 +    blocked_message = (
 +        "[Blocked - HTML document structure would be invalid] Suggestion: "
 +        "expected exactly one closing </html> tag (found 2); expected exactly "
 +        "one closing </body> tag (found 2). Keep the existing closing document "
 +        "tail intact."
 +    )
 +    executor = FakeExecutor(
 +        [
 +            tool_outcome(
 +                tool_call=tool_call,
 +                output=blocked_message,
 +                is_error=True,
 +                state=ToolExecutionState.BLOCKED,
 +            )
 +            for tool_call in tool_calls
 +        ]
 +    )
 +    events: list[AgentEvent] = []
++
 +    async def emit(event: AgentEvent) -> None:
 +        events.append(event)
++
 +    result = await runner.execute_batch(
 +        tool_calls=tool_calls,
 +        tool_source="native",
 +        pending_tool_calls_seen=set(),
 +        emit=emit,
 +        summary=TurnSummary(final_response=""),
 +        dod=dod,
 +        executor=executor,
 +        on_confirmation=None,
 +        on_user_question=None,
 +        emit_confirmation=None,
 +        consecutive_errors=0,
 +    )
++
 +    assert result.halted is False
 +    assert result.consecutive_errors == 0
 +    assert queued
 +    assert str(target) in queued[-1]
 +    assert "blocked before it changed the file" in queued[-1]
 +    assert "Do not assume the on-disk file is malformed" in queued[-1]
 +    assert "```html\n</body>\n</html>\n```" in queued[-1]
 +    assert "do not add a second `</body>` or `</html>`" in queued[-1]
++
++
  def test_tool_batch_runner_blocked_html_missing_target_after_outputs_exist_prefers_verify(
      temp_dir: Path,
  ) -> None: