Anchor stale HTML repairs

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 (
--    assert "Do not call `read`, `edit`, `patch`, TodoWrite" in decision.retry_message
++        "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 f"Immediate next step: edit `{chapter_one.resolve(strict=False)}`" in message
--    assert "`write(file_path=..., content=...)`" in message
++    assert "`edit(file_path=..., old_string=..., new_string=...)`" in message
--    assert "do not call `read`, `edit`, `patch`, or TodoWrite again first" 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 "exactly one `edit(file_path=..., old_string=..., new_string=...)`" in message
--    assert "Do not call `read`, `edit`, `patch`, `TodoWrite`, or summarize." 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

tenseleyflow/loader / `5e2425f`

7 changed files