`107ddd4`

Resume concrete file todos

Authored by

espadonne 2 weeks ago

SHA: 107ddd4458d81afee9439dece19971d9545a229a
Parents: 33957e2
Tree: 872c78f

3 changed files

Status	File	+	-
M	`src/loader/runtime/repair.py`	121	5
M	`src/loader/runtime/workflow.py`	20	0
M	`tests/test_repair.py`	74	5

src/loader/runtime/repair.pymodified

      planned_artifact_target_satisfied,
+ )
  from .parsing import parse_tool_calls
 -from .workflow import preferred_pending_todo_item, reconcile_aggregate_completion_steps
 +from .workflow import (
 +    preferred_pending_todo_item,
 +    reconcile_aggregate_completion_steps,
 +    todo_file_candidates,
 +)
  _SPECIAL_DOD_ITEMS = {
      "Complete the requested work",
                      "Confirmed completed work: " + "; ".join(completed[-2:])
+                 )
 -            next_pending = preferred_pending_todo_item(
 +            next_pending = self._preferred_resume_pending_item(
                  dod,
 -                project_root=self.context.project_root,
                  missing_artifact=next(
+                     (
                          artifact
              ),
              None,
+         )
 -        next_pending = preferred_pending_todo_item(
 +        next_pending = self._preferred_resume_pending_item(
              dod,
 -            project_root=self.context.project_root,
              missing_artifact=next_missing_artifact,
+         )
          if (
                  lines.append(
                      "Do not restart from scratch unless one specific missing fact blocks "
                      "that discovery step."
 +            )
 +            return lines
++
 +        inferred_pending_target = (
 +            self._infer_pending_item_output_target(dod, next_pending)
 +            if next_pending
 +            else None
 +        )
 +        if next_pending and inferred_pending_target is not None:
 +            inferred_label = self._format_artifact_label(
 +                inferred_pending_target,
 +                expect_directory=False,
 +            )
 +            lines = [
 +                "Resume with this exact next step: continue "
 +                f"`{next_pending}` by creating {inferred_label}."
 +            ]
 +            lines.append(
 +                f"Prefer one `write(content=...)` call for `{inferred_pending_target}` before more research."
 +            )
 +            if completed_artifacts >= 2:
 +                lines.append(
 +                    "Follow the same one-file-at-a-time mutation pattern that already "
 +                    "created the confirmed output files."
 +                )
 +            if retry_number >= 2:
 +                lines.append(
 +                    "Do not return another working note or empty response; emit the "
 +                    "concrete mutation tool call now."
 +                )
 +            else:
 +                lines.append(
 +                    "Do not restart discovery unless one specific missing fact blocks "
 +                    "that file write."
+                 )
              return lines
              return lines
          return []
 +    def _infer_pending_item_output_target(
 +        self,
 +        dod: DefinitionOfDone,
 +        item: str,
 +    ) -> Path | None:
 +        candidates = todo_file_candidates(item)
 +        if not candidates:
 +            return None
++
 +        planned_targets = collect_planned_artifact_targets(
 +            dod,
 +            project_root=self.context.project_root,
 +            max_paths=12,
 +        )
 +        planned_files = {
 +            target.name.lower(): target
 +            for target, expect_directory in planned_targets
 +            if not expect_directory
 +        }
 +        planned_directories = [
 +            target
 +            for target, expect_directory in planned_targets
 +            if expect_directory
 +        ]
 +        touched_paths = [
 +            Path(path)
 +            for path in dod.touched_files
 +            if str(path).strip()
 +        ]
++
 +        for candidate in candidates:
 +            candidate_str = str(candidate)
 +            if candidate.is_absolute() or candidate_str.startswith("~"):
 +                return Path(candidate_str).expanduser()
++
 +            planned_match = planned_files.get(candidate.name.lower())
 +            if planned_match is not None:
 +                return planned_match
++
 +            for touched in reversed(touched_paths):
 +                if touched.name.lower() == candidate.name.lower():
 +                    continue
 +                if candidate.suffix and touched.suffix.lower() != candidate.suffix.lower():
 +                    continue
 +                return touched.parent / candidate.name
++
 +            for directory in planned_directories:
 +                return directory / candidate.name
++
 +        return None
++
 +    def _preferred_resume_pending_item(
 +        self,
 +        dod: DefinitionOfDone,
 +        *,
 +        missing_artifact: tuple[Path, bool] | None,
 +    ) -> str | None:
 +        preferred = preferred_pending_todo_item(
 +            dod,
 +            project_root=self.context.project_root,
 +            missing_artifact=missing_artifact,
 +        )
 +        if preferred:
 +            return preferred
++
 +        explicit_file_items = [
 +            item
 +            for item in dod.pending_items
 +            if item not in _SPECIAL_DOD_ITEMS
 +            and _todo_is_mutation_step(item)
 +            and todo_file_candidates(item)
 +        ]
 +        if explicit_file_items:
 +            return explicit_file_items[0]
++
 +        return next(
 +            (item for item in dod.pending_items if item not in _SPECIAL_DOD_ITEMS),
 +            None,
 +        )
++
      @staticmethod
      def _format_artifact_label(path: Path, *, expect_directory: bool) -> str:
          label = path.name or str(path)

src/loader/runtime/workflow.pymodified

      "preferred_pending_todo_item",
      "reconcile_aggregate_completion_steps",
      "sync_todos_to_definition_of_done",
 +    "todo_file_candidates",
+ ]
  VERIFICATION_SEPARATOR = "<<<VERIFICATION>>>"
      return pending_items[0]
 +def todo_file_candidates(item: str) -> list[Path]:
 +    """Extract explicit file references from a todo item in source order."""
++
 +    if item in _SPECIAL_TODO_ITEMS:
 +        return []
 +    seen: set[str] = set()
 +    candidates: list[Path] = []
 +    for match in _TODO_FILE_CANDIDATE_PATTERN.findall(item.strip()):
 +        normalized = match.strip()
 +        if not normalized:
 +            continue
 +        key = normalized.lower()
 +        if key in seen:
 +            continue
 +        seen.add(key)
 +        candidates.append(Path(normalized))
 +    return candidates
++
++
  def preserve_task_grounded_acceptance_criteria(
      task_statement: str,
      *,

tests/test_repair.pymodified

      assert decision.should_continue is True
      assert decision.retry_message is not None
 -    assert "Resume with this exact next step: create `index.html`." in decision.retry_message
      assert (
 -        "The `write` tool can create that file's parent directories automatically"
 +        "Resume with this exact next step: continue `Write main index.html for nginx guide` "
 +        "by creating `index.html`."
          in decision.retry_message
+     )
      assert (
 -        "Shape the next response as one concrete `write(file_path=..., content=...)` "
 -        "tool call for that exact path."
 +        f"Prefer one `write(content=...)` call for `{index_path}` before more research."
 +        in decision.retry_message
 +    )
 +    assert (
 +        "Do not restart discovery unless one specific missing fact blocks that file write."
          in decision.retry_message
+     )
          "Resume with this exact next step: continue `Develop the main index.html file with proper structure`"
          in decision.retry_message
+     )
 -    assert "Prefer one concrete `write` call" in decision.retry_message
 +    assert "Prefer one `write(content=...)` call" in decision.retry_message
      assert "Make the next response one concrete evidence-gathering tool call" not in decision.retry_message
      assert "introduction.html` before more research." in decision.retry_message
 +def test_empty_response_retry_infers_concrete_file_from_pending_todo_after_broad_artifacts_exist(
 +    temp_dir: Path,
 +) -> None:
 +    context = build_context(
 +        temp_dir=temp_dir,
 +        use_react=False,
 +    )
 +    repairer = ResponseRepairer(context)
++
 +    guide_root = temp_dir / "guides" / "nginx"
 +    chapters = guide_root / "chapters"
 +    chapters.mkdir(parents=True)
 +    index_path = guide_root / "index.html"
 +    chapter_one = chapters / "01-introduction.html"
 +    index_path.write_text("<html></html>\n")
 +    chapter_one.write_text("<html></html>\n")
++
 +    implementation_plan = temp_dir / "implementation.md"
 +    implementation_plan.write_text(
 +        "\n".join(
 +            [
 +                "# Implementation Plan",
 +                "",
 +                "## File Changes",
 +                f"- `{guide_root}/`",
 +                f"- `{chapters}/`",
 +                f"- `{index_path}`",
 +                "",
 +            ]
 +        )
 +    )
++
 +    dod = create_definition_of_done("Create a multi-file nginx guide.")
 +    dod.implementation_plan = str(implementation_plan)
 +    dod.touched_files.extend([str(index_path), str(chapter_one)])
 +    dod.completed_items.extend(
 +        [
 +            "Create index.html for nginx guide",
 +            "Create first chapter file (01-introduction.html)",
 +        ]
 +    )
 +    dod.pending_items.append("Create second chapter file (02-installation.html)")
++
 +    decision = repairer.handle_empty_response(
 +        task="Create a multi-file nginx guide.",
 +        original_task=None,
 +        empty_retry_count=2,
 +        max_empty_retries=2,
 +        dod=dod,
 +    )
++
 +    assert decision.should_continue is True
 +    assert decision.retry_message is not None
 +    assert (
 +        "Resume with this exact next step: continue `Create second chapter file "
 +        "(02-installation.html)` by creating `02-installation.html`."
 +        in decision.retry_message
 +    )
 +    assert (
 +        f"Prefer one `write(content=...)` call for `{chapters / '02-installation.html'}` "
 +        "before more research."
 +        in decision.retry_message
 +    )
 +    assert "Do not return another working note or empty response" in decision.retry_message
++
++
  def test_empty_response_retry_fails_after_extended_late_stage_budget_is_exhausted(
      temp_dir: Path,
  ) -> None: