`024377f`

Name concrete chapter outputs

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

SHA: 024377f917e545deda140d32f749dfb046c1d71d
Parents: f4fe116
Tree: baa4420

5 changed files

Status	File	+	-
M	`src/loader/runtime/repair.py`	52	0
M	`src/loader/runtime/tool_batches.py`	55	4
M	`src/loader/runtime/workflow.py`	20	0
M	`tests/test_repair.py`	71	0
M	`tests/test_tool_batches.py`	132	0

src/loader/runtime/repair.pymodified

      infer_pending_todo_output_target,
      preferred_pending_todo_item,
      reconcile_aggregate_completion_steps,
 +    todo_describes_aggregate_mutation,
 +    todo_describes_broad_setup_step,
      todo_file_candidates,
+ )
              if next_pending
              else None
+         )
 +        if (
 +            next_pending
 +            and inferred_pending_target is None
 +            and next_missing_artifact is not None
 +            and not next_missing_artifact[1]
 +            and todo_describes_aggregate_mutation(next_pending)
 +            and not todo_describes_broad_setup_step(next_pending)
 +        ):
 +            concrete_target = next_missing_artifact[0]
 +            outline_label = infer_output_outline_label(
 +                dod,
 +                concrete_target,
 +                project_root=self.context.project_root,
 +                todo_label=next_pending,
 +            )
 +            lines = [
 +                f"Resume with this exact next step: create `{concrete_target.name}`.",
 +                f"It is the next concrete output needed to continue `{next_pending}`.",
 +                f"Prefer one `write(content=...)` call for `{concrete_target}` before more research.",
 +                self._mutation_tool_scaffold(
 +                    concrete_target,
 +                    tool_name="write",
 +                ),
 +            ]
 +            if not concrete_target.parent.exists():
 +                lines.append(
 +                    "The `write` tool can create that file's parent directories "
 +                    "automatically, so do the write in one step instead of stopping "
 +                    "for a separate mkdir."
 +                )
 +            if outline_label:
 +                lines.append(
 +                    f"Use the existing outline label `{outline_label}` for that file so it matches the current guide structure."
 +                )
 +            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
          if next_pending and inferred_pending_target is not None:
              inferred_is_directory = not bool(inferred_pending_target.suffix)
              inferred_label = self._format_artifact_label(

src/loader/runtime/tool_batches.pymodified

      preferred_pending_todo_item,
      reconcile_aggregate_completion_steps,
      sync_todos_to_definition_of_done,
 +    todo_describes_aggregate_mutation,
 +    todo_describes_broad_setup_step,
+ )
  EventSink = Callable[[AgentEvent], Awaitable[None]]
              dod,
              project_root=self.context.project_root,
+         )
 -        next_pending_suffix = (
 -            f" Continue with the next pending item: `{next_pending}`."
 -            if next_pending
 -            else ""
 +        resume_target = _preferred_resume_target_path(
 +            dod,
 +            next_pending=next_pending,
 +            missing_artifact=missing_artifact,
 +            project_root=self.context.project_root,
 +            messages=session_messages,
 +        )
 +        pending_target = _preferred_pending_target_path(
 +            dod,
 +            next_pending=next_pending,
 +            project_root=self.context.project_root,
 +        )
 +        next_pending_suffix = _pending_item_handoff_prefix(
 +            next_pending,
 +            pending_target=pending_target,
 +            resume_target=resume_target,
+         )
          self.context.queue_steering_message(
              "Todo tracking is updated. A declared output artifact is still missing."
+     )
 +def _pending_item_handoff_prefix(
 +    next_pending: str | None,
 +    *,
 +    pending_target: Path | None,
 +    resume_target: Path | None,
 +) -> str:
 +    if not next_pending:
 +        return ""
 +    if (
 +        pending_target is None
 +        and resume_target is not None
 +        and resume_target.suffix
 +        and todo_describes_aggregate_mutation(next_pending)
 +        and not todo_describes_broad_setup_step(next_pending)
 +    ):
 +        return f" Continue with the next concrete output: `{resume_target.name}`."
 +    return f" Continue with the next pending item: `{next_pending}`."
++
++
 +def _preferred_pending_target_path(
 +    dod: DefinitionOfDone,
 +    *,
 +    next_pending: str | None,
 +    project_root: Path,
 +) -> Path | None:
 +    if not next_pending:
 +        return None
 +    pending_target = infer_pending_todo_output_target(
 +        dod,
 +        next_pending,
 +        project_root=project_root,
 +    )
 +    if pending_target is None:
 +        return None
 +    return pending_target.expanduser().resolve(strict=False)
++
++
  def _preferred_resume_target_path(
      dod: DefinitionOfDone,
      *,

src/loader/runtime/workflow.pymodified

      "preferred_pending_todo_item",
      "reconcile_aggregate_completion_steps",
      "sync_todos_to_definition_of_done",
 +    "todo_describes_aggregate_mutation",
 +    "todo_describes_broad_setup_step",
      "todo_file_candidates",
+ ]
+     )
 +def todo_describes_aggregate_mutation(item: str) -> bool:
 +    """Return True when a todo describes a broad multi-artifact mutation step."""
++
 +    text = item.strip().lower()
 +    if not text or item in _SPECIAL_TODO_ITEMS:
 +        return False
 +    return _todo_describes_aggregate_mutation(text)
++
++
 +def todo_describes_broad_setup_step(item: str) -> bool:
 +    """Return True when a todo is primarily about directory/setup scaffolding."""
++
 +    text = item.strip().lower()
 +    if not text or item in _SPECIAL_TODO_ITEMS:
 +        return False
 +    return _contains_any(text, _BROAD_SETUP_HINTS)
++
++
  def _todo_requires_complete_artifact_set(text: str) -> bool:
      return (
          _contains_any(text, _AGGREGATE_TODO_HINTS)

tests/test_repair.pymodified

+     )
 +def test_empty_response_retry_uses_concrete_file_language_for_aggregate_chapter_step(
 +    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"
 +    index_path.write_text(
 +        "\n".join(
 +            [
 +                "<html>",
 +                '<a href="chapters/01-introduction.html">Chapter 1: Introduction to Nginx</a>',
 +                '<a href="chapters/02-installation.html">Chapter 2: Installation and Setup</a>',
 +                "</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.append(str(index_path))
 +    dod.completed_items.append("Develop the main index.html file with proper structure")
 +    dod.pending_items.append("Create chapter files with content and structure")
++
 +    decision = repairer.handle_empty_response(
 +        task="Create a multi-file nginx guide.",
 +        original_task=None,
 +        empty_retry_count=3,
 +        max_empty_retries=4,
 +        dod=dod,
 +    )
++
 +    assert decision.should_continue is True
 +    assert decision.retry_message is not None
 +    assert "Next missing planned artifact: `01-introduction.html`" in decision.retry_message
 +    assert (
 +        "Resume with this exact next step: create `01-introduction.html`."
 +        in decision.retry_message
 +    )
 +    assert (
 +        "It is the next concrete output needed to continue `Create chapter files with content and structure`."
 +        in decision.retry_message
 +    )
 +    assert (
 +        "continue `Create chapter files with content and structure` by creating `01-introduction.html`."
 +        not in decision.retry_message
 +    )
++
++
  def test_empty_response_retry_prefers_output_index_over_reference_index_with_same_name(
      temp_dir: Path,
  ) -> None:

tests/test_tool_batches.pymodified

      assert "Resume by creating `01-introduction.html` now." in message
 +@pytest.mark.asyncio
 +async def test_tool_batch_runner_todowrite_uses_concrete_output_language_for_aggregate_chapter_step(
 +    temp_dir: Path,
 +) -> None:
 +    async def assess_confidence(
 +        tool_name: str,
 +        tool_args: dict,
 +        context: str,
 +    ) -> ConfidenceAssessment:
 +        raise AssertionError("Confidence scoring should not run in this scenario")
++
 +    async def verify_action(
 +        tool_name: str,
 +        tool_args: dict,
 +        result: str,
 +        expected: str = "",
 +    ) -> ActionVerification:
 +        raise AssertionError("Verification should not run in this scenario")
++
 +    guide_root = temp_dir / "guides" / "nginx"
 +    chapters = guide_root / "chapters"
 +    chapters.mkdir(parents=True)
 +    index_path = guide_root / "index.html"
 +    index_path.write_text(
 +        "\n".join(
 +            [
 +                "<html>",
 +                '<a href="chapters/01-introduction.html">Chapter 1: Introduction to Nginx</a>',
 +                '<a href="chapters/02-installation.html">Chapter 2: Installation and Setup</a>',
 +                "</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}`",
 +                "",
 +            ]
 +        )
 +    )
++
 +    context = build_context(
 +        temp_dir=temp_dir,
 +        messages=[],
 +        safeguards=FakeSafeguards(),
 +        assess_confidence=assess_confidence,
 +        verify_action=verify_action,
 +    )
 +    queued_messages: list[str] = []
 +    context.queue_steering_message_callback = queued_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)
 +    dod.touched_files.append(str(index_path))
 +    sync_todos_to_definition_of_done(
 +        dod,
 +        [
 +            {
 +                "content": "Develop the main index.html file with proper structure",
 +                "active_form": "Developing the main index.html file with proper structure",
 +                "status": "completed",
 +            },
 +            {
 +                "content": "Create chapter files with content and structure",
 +                "active_form": "Creating chapter files with content and structure",
 +                "status": "pending",
 +            },
 +        ],
 +    )
++
 +    todos = [
 +        {
 +            "content": "Develop the main index.html file with proper structure",
 +            "active_form": "Developing the main index.html file with proper structure",
 +            "status": "completed",
 +        },
 +        {
 +            "content": "Create chapter files with content and structure",
 +            "active_form": "Creating chapter files with content and structure",
 +            "status": "pending",
 +        },
 +    ]
 +    tool_call = ToolCall(
 +        id="todo-aggregate",
 +        name="TodoWrite",
 +        arguments={"todos": todos},
 +    )
 +    executor = FakeExecutor(
 +        [
 +            tool_outcome(
 +                tool_call=tool_call,
 +                output="Todos updated",
 +                is_error=False,
 +                metadata={"new_todos": todos},
 +            )
 +        ]
 +    )
++
 +    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 queued_messages
 +    message = queued_messages[-1]
 +    assert "Continue with the next concrete output: `01-introduction.html`." in message
 +    assert "Resume by creating `01-introduction.html` now." in message
 +    assert (
 +        "Continue with the next pending item: `Create chapter files with content and structure`."
 +        not in message
 +    )
++
++
  @pytest.mark.asyncio
  async def test_duplicate_observation_nudge_prioritizes_missing_artifact_over_review(
      temp_dir: Path,