`7b1c338`

Require edits during repair audits

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

SHA: 7b1c3380b91870e0bc4f654b0ad887525fd570ea
Parents: b69a3fe
Tree: 1f79d21

4 changed files

Status	File	+	-
M	`src/loader/runtime/hooks.py`	21	3
M	`src/loader/runtime/safeguard_services.py`	47	0
M	`tests/test_permissions.py`	87	0
M	`tests/test_safeguard_services.py`	44	0

src/loader/runtime/hooks.pymodified

                      roots_preview = ", ".join(f"`{root}`" for root in completed_scope[:2])
                      if len(completed_scope) > 2:
                          roots_preview += ", ..."
 +                    repair = extract_active_repair_context(
 +                        getattr(self.session, "messages", [])
 +                    )
 +                    if repair is not None and repair.allowed_paths:
 +                        repair_preview = ", ".join(
 +                            f"`{path}`" for path in repair.allowed_paths[:3]
 +                        )
 +                        if len(repair.allowed_paths) > 3:
 +                            repair_preview += ", ..."
 +                        suggestion = (
 +                            "make one concrete edit, patch, or write to the active "
 +                            f"repair file(s) {repair_preview}. Do not finish with a "
 +                            "final response while these verification repair targets remain."
 +                        )
 +                    else:
 +                        suggestion = (
 +                            "finish with a final response so Loader can verify automatically, "
 +                            "or make one concrete edit for a specific mismatch inside "
 +                            f"{roots_preview} instead of more rereads."
 +                        )
                      return HookResult(
                          decision=HookDecision.DENY,
                          message=(
                              "[Blocked - post-build audit loop: all explicitly planned artifacts "
                              "already exist and the current output set has already been inspected "
 -                            "several times.] Suggestion: finish with a final response so Loader "
 -                            "can verify automatically, or make one concrete edit for a specific mismatch inside "
 -                            f"{roots_preview} instead of more rereads."
 +                            f"several times.] Suggestion: {suggestion}"
                          ),
                          terminal_state="blocked",
+                     )

src/loader/runtime/safeguard_services.pymodified

                      severity="block",
+                 )
 +        html_link_scope_result = self._validate_html_write_local_link_scope(
 +            str(file_path),
 +            str(content),
 +        )
 +        if not html_link_scope_result.valid:
 +            return html_link_scope_result
++
          html_declared_target_result = self._validate_html_declared_target_set(
              str(file_path),
              str(content),
              "\n".join(added_fragments),
+         )
 +    def _validate_html_write_local_link_scope(
 +        self,
 +        file_path: str,
 +        content: str,
 +    ) -> ValidationResult:
 +        normalized = Path(file_path).expanduser()
 +        if normalized.suffix.lower() not in {".html", ".htm"}:
 +            return ValidationResult(valid=True)
++
 +        root = (
 +            normalized.parent
 +            if normalized.name.lower() in {"index.html", "index.htm"}
 +            else self._resolve_html_artifact_root(normalized)
 +        )
 +        outside_missing: list[str] = []
 +        for href, resolved in self._collect_local_html_targets(normalized, content):
 +            if resolved.exists():
 +                continue
 +            if self._relative_html_target(root, resolved) is not None:
 +                continue
 +            if href not in outside_missing:
 +                outside_missing.append(href)
++
 +        if not outside_missing:
 +            return ValidationResult(valid=True)
++
 +        preview = ", ".join(outside_missing[:3])
 +        if len(outside_missing) > 3:
 +            preview += ", ..."
 +        return ValidationResult(
 +            valid=False,
 +            reason="HTML page links outside the current artifact root",
 +            suggestion=(
 +                "Keep local HTML href values inside the generated artifact root. "
 +                f"Missing out-of-scope href(s): {preview}. Remove the parent/outside "
 +                "link or replace it with an existing in-scope local target."
 +            ),
 +            severity="error",
 +        )
++
      def _validate_html_local_asset_links(
          self,
          file_path: str,

tests/test_permissions.pymodified

      assert "post-build audit loop" in blocked.message
 +@pytest.mark.asyncio
 +async def test_late_reference_drift_hook_requires_edit_during_active_repair_audit_loop(
 +    temp_dir: Path,
 +) -> None:
 +    registry = create_default_registry(temp_dir)
 +    policy = build_permission_policy(
 +        active_mode=PermissionMode.WORKSPACE_WRITE,
 +        workspace_root=temp_dir,
 +        tool_requirements=registry.get_tool_requirements(),
 +    )
 +    dod_store = DefinitionOfDoneStore(temp_dir)
 +    dod = create_definition_of_done("Create a multi-file guide from a reference")
 +    dod.status = "in_progress"
 +    guide_root = temp_dir / "guide"
 +    chapters = guide_root / "chapters"
 +    chapters.mkdir(parents=True, exist_ok=True)
 +    index_path = guide_root / "index.html"
 +    intro_path = chapters / "01-introduction.html"
 +    config_path = chapters / "03-basic-configuration.html"
 +    index_path.write_text("<h1>Nginx Guide</h1>\n")
 +    intro_path.write_text("<h1>Introduction</h1>\n")
 +    config_path.write_text("<h1>Configuration</h1>\n")
 +    plan_path = temp_dir / "implementation.md"
 +    plan_path.write_text(
 +        "\n".join(
 +            [
 +                "# Implementation Plan",
 +                "",
 +                "## File Changes",
 +                f"- `{index_path}`",
 +                f"- `{chapters}/`",
 +                "",
 +            ]
 +        )
 +    )
 +    dod.implementation_plan = str(plan_path)
 +    dod_path = dod_store.save(dod)
 +    session = FakeSession(
 +        active_dod_path=str(dod_path),
 +        messages=[
 +            Message(
 +                role=Role.USER,
 +                content=(
 +                    "Repair focus:\n"
 +                    f"- Improve `{index_path}`: insufficient structured content.\n"
 +                    f"- Improve `{intro_path}`: insufficient structured content.\n"
 +                    f"- Improve `{config_path}`: thin content.\n"
 +                    f"- Immediate next step: edit `{index_path}` with a substantial expansion.\n"
 +                ),
 +            )
 +        ],
 +    )
 +    hook = LateReferenceDriftHook(
 +        dod_store=dod_store,
 +        project_root=temp_dir,
 +        session=session,
 +    )
++
 +    def make_context(index: int) -> HookContext:
 +        return HookContext(
 +            tool_call=ToolCall(
 +                id=f"read-{index}",
 +                name="read",
 +                arguments={"file_path": str(index_path)},
 +            ),
 +            tool=registry.get("read"),
 +            registry=registry,
 +            permission_policy=policy,
 +            source="native",
 +        )
++
 +    for index in range(1, 5):
 +        context = make_context(index)
 +        result = await hook.pre_tool_use(context)
 +        assert result.decision == HookDecision.CONTINUE
 +        await hook.post_tool_use(context)
++
 +    blocked = await hook.pre_tool_use(make_context(5))
++
 +    assert blocked.decision == HookDecision.DENY
 +    assert blocked.message is not None
 +    assert "post-build audit loop" in blocked.message
 +    assert "make one concrete edit, patch, or write" in blocked.message
 +    assert "Do not finish with a final response" in blocked.message
 +    assert str(index_path.resolve(strict=False)) in blocked.message
++
++
  @pytest.mark.asyncio
  async def test_late_reference_drift_hook_allows_post_build_self_audits_during_verification(
      temp_dir: Path,

tests/test_safeguard_services.pymodified

      assert result.valid is True
 +def test_pre_action_validator_blocks_new_root_index_parent_html_link(
 +    tmp_path: Path,
 +) -> None:
 +    validator = PreActionValidator()
 +    guide = tmp_path / "guides" / "nginx"
 +    guide.mkdir(parents=True)
++
 +    result = validator.validate(
 +        "write",
 +        {
 +            "file_path": str(guide / "index.html"),
 +            "content": (
 +                '<html><body><a href="chapters/01-introduction.html">Intro</a>'
 +                '<p><a href="../index.html">Back to Main Index</a></p></body></html>'
 +            ),
 +        },
 +    )
++
 +    assert result.valid is False
 +    assert result.reason == "HTML page links outside the current artifact root"
 +    assert "../index.html" in result.suggestion
++
++
 +def test_pre_action_validator_allows_new_root_index_to_seed_child_html_links(
 +    tmp_path: Path,
 +) -> None:
 +    validator = PreActionValidator()
 +    guide = tmp_path / "guides" / "nginx"
 +    guide.mkdir(parents=True)
++
 +    result = validator.validate(
 +        "write",
 +        {
 +            "file_path": str(guide / "index.html"),
 +            "content": (
 +                '<html><body><a href="chapters/01-introduction.html">Intro</a>'
 +                '<a href="chapters/02-installation.html">Install</a></body></html>'
 +            ),
 +        },
 +    )
++
 +    assert result.valid is True
++
++
  def test_pre_action_validator_blocks_shell_text_rewrite_for_html_target() -> None:
      validator = PreActionValidator()