`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: