`5e2425f`

Anchor stale HTML repairs

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

SHA: 5e2425f67fcc34e23aeaac86454abb76de2af51a
Parents: 6236b4d
Tree: 2b388e9

7 changed files

Status	File	+	-
M	`src/loader/runtime/repair.py`	24	2
M	`src/loader/runtime/repair_focus.py`	32	0
M	`src/loader/runtime/tool_batches.py`	32	2
M	`src/loader/runtime/turn_completion.py`	23	0
M	`tests/test_repair.py`	8	3
M	`tests/test_tool_batches.py`	6	4
M	`tests/test_turn_completion.py`	5	3

src/loader/runtime/repair.pymodified

  from .repair_focus import (
      ActiveRepairContext,
      extract_active_repair_context,
 +    html_quality_repair_insertion_anchor,
      html_repair_issue_is_structural,
      recent_repair_mutation_context_failed,
      repair_line_is_html_quality,
          if issue_line:
              lines.append(f"- Current verifier issue: {issue_line[2:] if issue_line.startswith('- ') else issue_line}")
          structural_issue = html_repair_issue_is_structural(issue_line)
 -        force_write = structural_issue or recent_repair_mutation_context_failed(
 +        stale_context = recent_repair_mutation_context_failed(
              self.context.session.messages,
              target,
+         )
 -        if force_write:
 +        insertion_anchor = (
 +            html_quality_repair_insertion_anchor(target)
 +            if stale_context and not structural_issue
 +            else None
 +        )
 +        if insertion_anchor:
 +            lines.extend(
 +                [
 +                    "- Recent `edit`/`patch` attempts for this same target failed "
 +                    "against stale or malformed context, but the current file has a "
 +                    "safe closing-tail insertion anchor. Use exactly one "
 +                    "`edit(file_path=..., old_string=..., new_string=...)` call now.",
 +                    "- Use this exact `old_string` value from the current file:\n"
 +                    f"```html\n{insertion_anchor}\n```",
 +                    "- Set `new_string` to the substantive new body sections followed "
 +                    "by that exact `old_string`, so the added content lands before the "
 +                    "closing body/html tags.",
 +                    "- Do not call `read`, `patch`, `write`, TodoWrite, or a final "
 +                    "summary on this retry; emit the `edit` mutation tool call now.",
 +                ]
 +            )
 +        elif structural_issue or stale_context:
              structural_suffix = (
                  " Ensure the replacement has exactly one closing `</body>` tag, "
                  "exactly one closing `</html>` tag, and no content after `</html>`."

src/loader/runtime/repair_focus.pymodified

      "content appears after closing </html>",
      "closing </body> appears after closing </html>",
+ )
 +_HTML_CLOSE_RE = re.compile(r"</html\s*>", re.IGNORECASE)
 +_BODY_CLOSE_RE = re.compile(r"</body\s*>", re.IGNORECASE)
  @dataclass(frozen=True)
      return any(marker in lowered for marker in _HTML_STRUCTURAL_REPAIR_MARKERS)
 +def html_quality_repair_insertion_anchor(raw_path: str) -> str | None:
 +    """Return an exact on-disk closing-tail anchor for bounded HTML expansion."""
++
 +    normalized = normalize_repair_path(raw_path)
 +    if not normalized:
 +        return None
 +    path = Path(normalized)
 +    if not path.is_file():
 +        return None
 +    try:
 +        text = path.read_text()
 +    except (OSError, UnicodeDecodeError):
 +        return None
++
 +    body_matches = list(_BODY_CLOSE_RE.finditer(text))
 +    html_matches = list(_HTML_CLOSE_RE.finditer(text))
 +    if len(body_matches) != 1 or len(html_matches) != 1:
 +        return None
 +    body_match = body_matches[0]
 +    html_match = html_matches[0]
 +    if body_match.start() > html_match.start():
 +        return None
 +    if text[html_match.end() :].strip():
 +        return None
 +    anchor = text[body_match.start() :].rstrip()
 +    if not anchor.strip():
 +        return None
 +    return anchor
++
++
  def normalize_repair_path(raw_path: str) -> str:
      text = str(raw_path or "").strip()
      if not text:

src/loader/runtime/tool_batches.pymodified

  from .recovery import RecoveryContext, detect_missing_mutation_payload
  from .repair_focus import (
      extract_active_repair_context,
 +    html_quality_repair_insertion_anchor,
      html_repair_issue_is_structural,
      path_within_allowed_roots,
      recent_repair_mutation_context_failed,
              self.context.recovery_context,
+         )
          if edit_mismatch_target and _tool_call_targets_path(tool_call, edit_mismatch_target):
 +            insertion_anchor = html_quality_repair_insertion_anchor(edit_mismatch_target)
 +            if insertion_anchor:
 +                self.context.queue_steering_message(
 +                    "Reuse the earlier observation instead of repeating it. "
 +                    f"The last edit on `{edit_mismatch_target}` failed because `old_string` "
 +                    "did not exactly match the current file. Use this exact current "
 +                    "closing-tail anchor as `old_string` in one concrete `edit` call:\n"
 +                    f"```html\n{insertion_anchor}\n```\n"
 +                    "Set `new_string` to the substantive added body sections followed "
 +                    "by that exact `old_string`, so the new content lands before the "
 +                    "closing body/html tags. Do not read the same file again first."
 +                )
 +                return
              self.context.queue_steering_message(
                  "Reuse the earlier observation instead of repeating it. "
                  f"The last edit on `{edit_mismatch_target}` failed because `old_string` "
                  else f"- Improve `{target}` until it satisfies the active content-quality verifier.\n"
+             )
              structural_repair = html_repair_issue_is_structural(repair_issue)
 -            force_write = recent_repair_mutation_context_failed(
 +            stale_context = recent_repair_mutation_context_failed(
                  self.context.session.messages,
                  target,
+             )
 -            if force_write or structural_repair:
 +            insertion_anchor = (
 +                html_quality_repair_insertion_anchor(target)
 +                if stale_context and not structural_repair
 +                else None
 +            )
 +            if insertion_anchor:
 +                immediate_step = (
 +                    f"- Immediate next step: edit `{target}`.\n"
 +                    "- Use one `edit(file_path=..., old_string=..., new_string=...)` "
 +                    "call anchored on the current closing document tail.\n"
 +                    "- Use this exact current closing-tail anchor as `old_string`:\n"
 +                    f"```html\n{insertion_anchor}\n```\n"
 +                    "- Set `new_string` to the substantive added body sections followed "
 +                    "by that exact `old_string`; do not call `read`, `patch`, `write`, "
 +                    "or TodoWrite again first."
 +                )
 +            elif stale_context or structural_repair:
                  structural_suffix = (
                      " Ensure the replacement has exactly one closing `</body>` tag, "
                      "exactly one closing `</html>` tag, and no content after `</html>`."

src/loader/runtime/turn_completion.pymodified

  from .repair import ResponseRepairer
  from .repair_focus import (
      extract_active_repair_context,
 +    html_quality_repair_insertion_anchor,
      html_repair_issue_is_structural,
      recent_repair_mutation_context_failed,
      repair_line_is_html_quality,
+     )
      issue_sentence = f" Current verifier issue: {issue_line}" if issue_line else ""
      structural_issue = html_repair_issue_is_structural(issue_line)
 +    insertion_anchor = (
 +        html_quality_repair_insertion_anchor(target_text)
 +        if stale_context and not structural_issue
 +        else None
 +    )
 +    if insertion_anchor:
 +        prompt = (
 +            "[CONTINUE QUALITY REPAIR]\n"
 +            "You just described a content-quality repair, but did not execute it. "
 +            "Recent `patch`/`edit` attempts for this same file failed because their "
 +            "remembered context was stale or malformed, so anchor the mutation on the "
 +            "current closing document tail. "
 +            f"Emit exactly one `edit(file_path=..., old_string=..., new_string=...)` tool call for `{target_text}` now."
 +            f"{issue_sentence} "
 +            "Use this exact `old_string` value from the current file:\n"
 +            f"```html\n{insertion_anchor}\n```\n"
 +            "Set `new_string` to the substantive new body sections followed by that exact "
 +            "`old_string`, so content is inserted before the closing body/html tags. "
 +            "Do not call `read`, `patch`, `write`, `TodoWrite`, or summarize."
 +        )
 +        return InProgressContinuation(prompt=prompt, target=None)
++
      force_write = stale_context or structural_issue
      if force_write:
          structural_sentence = (

tests/test_repair.pymodified

      assert f"`{second_chapter.resolve(strict=False)}`" in decision.retry_message
 -def test_empty_response_retry_forces_write_after_stale_quality_repair_context(
 +def test_empty_response_retry_uses_exact_anchor_after_stale_quality_repair_context(
      temp_dir: Path,
  ) -> None:
      context = build_context(
      assert decision.should_continue is True
      assert decision.retry_message is not None
 -    assert "Use exactly one `write(file_path=..., content=...)`" in decision.retry_message
 -    assert "Do not call `read`, `edit`, `patch`, TodoWrite" in decision.retry_message
 +    assert (
 +        "Use exactly one `edit(file_path=..., old_string=..., new_string=...)`"
 +        in decision.retry_message
 +    )
 +    assert "Use this exact `old_string` value from the current file" in decision.retry_message
 +    assert "```html\n</body></html>\n```" in decision.retry_message
 +    assert "Do not call `read`, `patch`, `write`, TodoWrite" in decision.retry_message
  def test_empty_response_retry_forces_write_for_structural_html_repair(

tests/test_tool_batches.pymodified

      assert dod.completed_items == completed_before_todowrite
 -def test_todowrite_quality_repair_nudge_forces_write_after_stale_context(
 +def test_todowrite_quality_repair_nudge_uses_exact_anchor_after_stale_context(
      temp_dir: Path,
  ) -> None:
      async def assess_confidence(
      assert queued_messages
      message = queued_messages[-1]
 -    assert f"Immediate next step: rewrite `{chapter_one.resolve(strict=False)}`" in message
 -    assert "`write(file_path=..., content=...)`" in message
 -    assert "do not call `read`, `edit`, `patch`, or TodoWrite again first" in message
 +    assert f"Immediate next step: edit `{chapter_one.resolve(strict=False)}`" in message
 +    assert "`edit(file_path=..., old_string=..., new_string=...)`" in message
 +    assert "Use this exact current closing-tail anchor as `old_string`" in message
 +    assert "```html\n</body></html>\n```" in message
 +    assert "do not call `read`, `patch`, `write`, or TodoWrite again first" in message
  @pytest.mark.asyncio

tests/test_turn_completion.pymodified

  @pytest.mark.asyncio
 -async def test_turn_completion_forces_write_after_stale_quality_repair_context(
 +async def test_turn_completion_uses_exact_anchor_after_stale_quality_repair_context(
      temp_dir: Path,
  ) -> None:
      backend = ScriptedBackend()
      assert decision.action == TurnCompletionAction.CONTINUE
      message = agent.session.messages[-1].content
      assert message.startswith("[CONTINUE QUALITY REPAIR]")
 -    assert "exactly one `write(file_path=..., content=...)`" in message
 -    assert "Do not call `read`, `edit`, `patch`, `TodoWrite`, or summarize." in message
 +    assert "exactly one `edit(file_path=..., old_string=..., new_string=...)`" in message
 +    assert "Use this exact `old_string` value from the current file" in message
 +    assert "```html\n</body></html>\n```" in message
 +    assert "Do not call `read`, `patch`, `write`, `TodoWrite`, or summarize." in message
  @pytest.mark.asyncio