tenseleyflow/loader / d4b1624

+        next_missing_target = _next_missing_repair_path(

+            repair,

+            changed_path=changed_path,

+        )

+        if next_missing_target:

+            self.context.queue_steering_message(

+                "The active verification repair target was updated, but the "

+                "declared artifact set is still incomplete. Continue directly with "

+                f"the next missing declared artifact `{next_missing_target}` using "

+                "one concrete `write(file_path=..., content=...)` call. Do not "

+                "run verification, call TodoWrite, reread unrelated references, or "

+                "finish with a summary yet.\n\n"

+                "Repair focus:\n"

+                f"- Continue the declared output set by creating missing planned artifact `{next_missing_target}`.\n"

+                f"- Immediate next step: write `{next_missing_target}`.\n"

+                "- Use the current generated guide files as source of truth; do not "

+                "rewrite existing aggregate files to match the partial artifact set."

+            )

+            return

+

+def _next_missing_repair_path(repair: Any, *, changed_path: str) -> str:

+    """Return the next concrete missing repair file after one support artifact exists."""

+

+    try:

+        normalized_changed = str(Path(changed_path).expanduser().resolve(strict=False))

+    except (OSError, RuntimeError, ValueError):

+        normalized_changed = str(Path(changed_path).expanduser())

+

+    for raw_path in getattr(repair, "allowed_paths", ()) or ():

+        path_text = str(raw_path or "").strip()

+        if not path_text:

+            continue

+        try:

+            normalized = str(Path(path_text).expanduser().resolve(strict=False))

+        except (OSError, RuntimeError, ValueError):

+            normalized = str(Path(path_text).expanduser())

+        if normalized == normalized_changed:

+            continue

+        try:

+            if not Path(normalized).exists():

+                return normalized

+        except (OSError, RuntimeError, ValueError):

+            continue

+    return ""

+

+

+@pytest.mark.asyncio

+async def test_tool_batch_runner_continues_missing_declared_repairs_before_verify(

+    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 in this scenario")

+

+    guide_root = temp_dir / "guide"

+    chapters = guide_root / "chapters"

+    index = guide_root / "index.html"

+    first_missing = chapters / "02-installation.html"

+    second_missing = chapters / "03-configuration.html"

+    chapters.mkdir(parents=True)

+    index.write_text(

+        '<a href="chapters/02-installation.html">Install</a>\n'

+        '<a href="chapters/03-configuration.html">Configure</a>\n'

+    )

+    context = build_context(

+        temp_dir=temp_dir,

+        messages=[

+            Message(

+                role=Role.USER,

+                content=(

+                    "Repair focus:\n"

+                    f"- Continue the declared output set by creating missing planned artifact `{first_missing}`.\n"

+                    f"- Continue the declared output set by creating missing planned artifact `{second_missing}`.\n"

+                    f"- Existing file `{index}` already references `chapters/02-installation.html` -> `{first_missing}`.\n"

+                    f"- Immediate next step: write `{first_missing}`.\n"

+                    "- Continue one missing declared output at a time until the declared set exists.\n"

+                ),

+            )

+        ],

+        safeguards=FakeSafeguards(),

+        assess_confidence=assess_confidence,

+        verify_action=verify_action,

+    )

+    queued: list[str] = []

+    context.queue_steering_message_callback = queued.append

+    runner = ToolBatchRunner(context, DefinitionOfDoneStore(temp_dir))

+    dod = create_definition_of_done("Create a multi-file guide.")

+    tool_call = ToolCall(

+        id="write-install",

+        name="write",

+        arguments={

+            "file_path": str(first_missing),

+            "content": "<html><body><h1>Install</h1></body></html>",

+        },

+    )

+

+    await runner.execute_batch(

+        tool_calls=[tool_call],

+        tool_source="assistant",

+        pending_tool_calls_seen=set(),

+        emit=_noop_emit,

+        summary=TurnSummary(final_response=""),

+        dod=dod,

+        executor=FakeExecutor(

+            [

+                tool_outcome(

+                    tool_call=tool_call,

+                    output=f"Successfully wrote {first_missing}",

+                    is_error=False,

+                )

+            ]

+        ),  # type: ignore[arg-type]

+        on_confirmation=None,

+        on_user_question=None,

+        emit_confirmation=None,

+        consecutive_errors=0,

+    )

+

+    assert queued

+    handoff = queued[-1]

+    assert "declared artifact set is still incomplete" in handoff

+    assert str(second_missing.resolve(strict=False)) in handoff

+    assert f"Immediate next step: write `{second_missing.resolve(strict=False)}`" in handoff

+    assert "Do not run verification" in handoff

+    assert "Finish with a final response now" not in handoff

+

+