`aa4c3b0`

Persist first file handoff

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 weeks ago

SHA: aa4c3b0ed21070560eebca04bbde26570d8f62fd
Parents: 3842320
Tree: ec346af

2 changed files

Status	File	+	-
M	`src/loader/runtime/tool_batches.py`	95	14
M	`tests/test_tool_batches.py`	116	0

src/loader/runtime/tool_batches.pymodified

              dod,
              project_root=self.context.project_root,
+         )
 +        resume_suffix = _pending_item_resume_suffix(
 +            dod,
 +            next_pending=next_pending,
 +            missing_artifact=missing_artifact,
 +            project_root=self.context.project_root,
 +            messages=list(getattr(self.context.session, "messages", []) or []),
 +        )
          queue_message = (
              self.context.queue_steering_message
 -            if not has_file_artifact_progress
 +            if _should_use_persistent_missing_artifact_handoff(
 +                dod,
 +                project_root=self.context.project_root,
 +            )
              else self.context.queue_ephemeral_steering_message
+         )
          todo_refresh = _todo_refresh_guidance(
          ):
              queue_message(
                  f"Confirmed progress: {current_label} is now recorded."
 -                + _missing_artifact_resume_suffix(
 -                    missing_artifact,
 -                    project_root=self.context.project_root,
 -                    messages=list(getattr(self.context.session, "messages", []) or []),
 -                )
 +                + resume_suffix
                  + " No TodoWrite, no verification, no rereads until that artifact exists."
+             )
              return
          queue_message(
              f"Confirmed progress: {current_label} is now recorded."
              " One declared output artifact is still missing."
 -            + _missing_artifact_resume_suffix(
 -                missing_artifact,
 -                project_root=self.context.project_root,
 -                messages=list(getattr(self.context.session, "messages", []) or []),
 -            )
 +            + resume_suffix
              + todo_refresh
              + " Do not move to verification, final confirmation, or TodoWrite-only "
              "bookkeeping until that artifact exists."
      *,
      project_root: Path,
  ) -> bool:
 +    return _confirmed_file_artifact_count(dod, project_root=project_root) > 0
++
++
 +def _confirmed_file_artifact_count(
 +    dod: DefinitionOfDone,
 +    *,
 +    project_root: Path,
 +) -> int:
 +    count = 0
      for target, expect_directory in collect_planned_artifact_targets(
          dod,
          project_root=project_root,
              expect_directory=False,
              project_root=project_root,
          ):
 -            return True
 -    return any(
 -        Path(path).expanduser().resolve(strict=False).suffix
 +            count += 1
 +    if count:
 +        return count
 +    return sum(
 +        1
          for path in dod.touched_files
          if str(path).strip()
 +        and Path(path).expanduser().resolve(strict=False).suffix
+     )
 +def _should_use_persistent_missing_artifact_handoff(
 +    dod: DefinitionOfDone,
 +    *,
 +    project_root: Path,
 +) -> bool:
 +    return _confirmed_file_artifact_count(
 +        dod,
 +        project_root=project_root,
 +    ) < 2
++
++
 +def _next_missing_planned_file_within_directory(
 +    dod: DefinitionOfDone,
 +    *,
 +    target: Path,
 +    project_root: Path,
 +) -> Path | None:
 +    normalized_target = target.expanduser().resolve(strict=False)
 +    if normalized_target.suffix:
 +        return None
++
 +    for planned_target, expect_directory in collect_planned_artifact_targets(
 +        dod,
 +        project_root=project_root,
 +        max_paths=12,
 +    ):
 +        if expect_directory:
 +            continue
 +        normalized_planned = planned_target.expanduser().resolve(strict=False)
 +        try:
 +            normalized_planned.relative_to(normalized_target)
 +        except ValueError:
 +            continue
 +        if planned_artifact_target_satisfied(
 +            dod,
 +            target=normalized_planned,
 +            expect_directory=False,
 +            project_root=project_root,
 +        ):
 +            continue
 +        return normalized_planned
 +    return None
++
++
  def _missing_artifact_resume_suffix(
      missing_artifact: tuple[Path, bool] | None,
      *,
                  messages=messages,
                  allow_inferred_child=False,
+             )
 +    if missing_artifact is not None and missing_artifact[1]:
 +        next_planned_file = _next_missing_planned_file_within_directory(
 +            dod,
 +            target=missing_artifact[0],
 +            project_root=project_root,
 +        )
 +        if next_planned_file is not None:
 +            parent_label = missing_artifact[0].name or str(missing_artifact[0])
 +            return (
 +                f" Resume by creating `{next_planned_file.name}` now."
 +                f" It is the next missing declared output under `{parent_label}/`."
 +                f" Prefer one `write` call for `{next_planned_file}` instead of more rereads."
 +                " Make your next response the concrete mutation tool call itself, not another"
 +                " bookkeeping-only turn."
 +            )
      return _missing_artifact_resume_suffix(
          missing_artifact,
          project_root=project_root,
      if not expect_directory:
          return normalized_target
 +    next_planned_file = _next_missing_planned_file_within_directory(
 +        dod,
 +        target=normalized_target,
 +        project_root=project_root,
 +    )
 +    if next_planned_file is not None:
 +        return next_planned_file.expanduser().resolve(strict=False)
++
      next_output_file, _ = infer_next_output_file(
          target=normalized_target,
          project_root=project_root,

tests/test_tool_batches.pymodified

      assert ephemeral_messages == []
 +@pytest.mark.asyncio
 +async def test_tool_batch_runner_first_file_handoff_stays_persistent(
 +    temp_dir: Path,
 +) -> None:
 +    async def assess_confidence(
 +        tool_name: str,
 +        tool_args: dict,
 +        context: str,
 +    ) -> ConfidenceAssessment:
 +        raise AssertionError("Confidence scoring should be disabled in this scenario")
++
 +    async def verify_action(
 +        tool_name: str,
 +        tool_args: dict,
 +        result: str,
 +        expected: str = "",
 +    ) -> ActionVerification:
 +        raise AssertionError("Verification should not run for this scenario")
++
 +    nginx_root = temp_dir / "guides" / "nginx"
 +    chapters = nginx_root / "chapters"
 +    chapters.mkdir(parents=True)
 +    index_path = nginx_root / "index.html"
++
 +    implementation_plan = temp_dir / "implementation.md"
 +    implementation_plan.write_text(
 +        "\n".join(
 +            [
 +                "# Implementation Plan",
 +                "",
 +                "## File Changes",
 +                f"- `{chapters}/`",
 +                f"- `{index_path}`",
 +                f"- `{chapters / '01-introduction.html'}`",
 +                "",
 +            ]
 +        )
 +    )
++
 +    context = build_context(
 +        temp_dir=temp_dir,
 +        messages=[],
 +        safeguards=FakeSafeguards(),
 +        assess_confidence=assess_confidence,
 +        verify_action=verify_action,
 +        auto_recover=False,
 +    )
 +    persistent_messages: list[str] = []
 +    ephemeral_messages: list[str] = []
 +    context.queue_steering_message_callback = persistent_messages.append
 +    context.queue_ephemeral_steering_message_callback = ephemeral_messages.append
 +    runner = ToolBatchRunner(context, DefinitionOfDoneStore(temp_dir))
 +    dod = create_definition_of_done("Create a multi-file nginx guide.")
 +    dod.implementation_plan = str(implementation_plan)
 +    sync_todos_to_definition_of_done(
 +        dod,
 +        [
 +            {
 +                "content": "Create the main index.html file with proper structure",
 +                "active_form": "Creating the main index.html file with proper structure",
 +                "status": "pending",
 +            },
 +            {
 +                "content": "Create each chapter file with appropriate content",
 +                "active_form": "Creating each chapter file with appropriate content",
 +                "status": "pending",
 +            },
 +        ],
 +    )
++
 +    tool_call = ToolCall(
 +        id="write-index",
 +        name="write",
 +        arguments={
 +            "file_path": str(index_path),
 +            "content": "<html></html>\n",
 +        },
 +    )
 +    executor = FakeExecutor(
 +        [
 +            tool_outcome(
 +                tool_call=tool_call,
 +                output=f"Successfully wrote 14 bytes to {index_path}",
 +                is_error=False,
 +            )
 +        ]
 +    )
++
 +    summary = TurnSummary(final_response="")
 +    await runner.execute_batch(
 +        tool_calls=[tool_call],
 +        tool_source="assistant",
 +        pending_tool_calls_seen=set(),
 +        emit=_noop_emit,
 +        summary=summary,
 +        dod=dod,
 +        executor=executor,  # type: ignore[arg-type]
 +        on_confirmation=None,
 +        on_user_question=None,
 +        emit_confirmation=None,
 +        consecutive_errors=0,
 +    )
++
 +    assert persistent_messages
 +    message = persistent_messages[-1]
 +    assert "Confirmed progress:" in message
 +    assert "Resume by creating `01-introduction.html` now." in message
 +    assert (
 +        f"Prefer one `write` call for `{(chapters / '01-introduction.html').resolve(strict=False)}` "
 +        "instead of more rereads."
 +        in message
 +    )
 +    assert "Do not move to verification, final confirmation, or TodoWrite-only bookkeeping" in message
 +    assert ephemeral_messages == []
++
++
  @pytest.mark.asyncio
  async def test_duplicate_observation_nudge_prioritizes_missing_artifact_over_review(
      temp_dir: Path,