@ikon85/agent-workflow-kit 0.36.4 → 0.37.0

package/scripts/test_board_sync_create_idempotency.py

@@ -34,6 +34,7 @@ PROFILE = {
 
 
 def load_board_sync():
+    previous_profile = os.environ.get("BOARD_SYNC_PROFILE")
     with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as profile:
         profile.write("<!-- board-sync:profile -->\n```json\n")
         json.dump(PROFILE, profile)
@@ -45,11 +46,18 @@ def load_board_sync():
     )
     module = importlib.util.module_from_spec(spec)
     assert spec.loader is not None
-    spec.loader.exec_module(module)
-    Path(profile_path).unlink()
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        Path(profile_path).unlink()
+        if previous_profile is None:
+            os.environ.pop("BOARD_SYNC_PROFILE", None)
+        else:
+            os.environ["BOARD_SYNC_PROFILE"] = previous_profile
     return module
 
 
+PROFILE_BEFORE_LOAD = os.environ.get("BOARD_SYNC_PROFILE")
 bs = load_board_sync()
 
 
@@ -80,6 +88,11 @@ class FakeGh:
         return ""
 
 
+class BoardSyncImportIsolationTest(unittest.TestCase):
+    def test_loading_board_sync_restores_the_caller_profile(self):
+        self.assertEqual(os.environ.get("BOARD_SYNC_PROFILE"), PROFILE_BEFORE_LOAD)
+
+
 class MarkerAwareCreateTest(unittest.TestCase):
     def test_identical_program_leaf_retry_reuses_existing_issue(self):
         marker = "<!-- program-leaf-source: program-x/1a -->"

package/scripts/test_board_sync_wave_title.py

@@ -37,6 +37,7 @@ BASE_PROFILE = {
 
 
 def load_board_sync(profile_dict: dict, module_name: str):
+    previous_profile = os.environ.get("BOARD_SYNC_PROFILE")
     with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as profile:
         profile.write("<!-- board-sync:profile -->\n```json\n")
         json.dump(profile_dict, profile)
@@ -48,8 +49,14 @@ def load_board_sync(profile_dict: dict, module_name: str):
     )
     module = importlib.util.module_from_spec(spec)
     assert spec.loader is not None
-    spec.loader.exec_module(module)
-    Path(profile_path).unlink()
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        Path(profile_path).unlink()
+        if previous_profile is None:
+            os.environ.pop("BOARD_SYNC_PROFILE", None)
+        else:
+            os.environ["BOARD_SYNC_PROFILE"] = previous_profile
     return module
 
 
@@ -75,6 +82,11 @@ class WaveTitleDefaultPrefix(unittest.TestCase):
             "Welle 29 — Auth hardening",
         )
 
+    def test_loading_board_sync_restores_the_caller_profile(self):
+        before = os.environ.get("BOARD_SYNC_PROFILE")
+        load_board_sync(copy.deepcopy(BASE_PROFILE), "board_sync_wave_isolation")
+        self.assertEqual(os.environ.get("BOARD_SYNC_PROFILE"), before)
+
 
 class WaveTitleProfilePrefix(unittest.TestCase):
     """A profile with `titles.wavePrefix` drives the anchor title language."""

package/scripts/test_census_backstop.py

@@ -40,6 +40,39 @@ class CensusBackstopTest(unittest.TestCase):
             "overrides": overrides or [],
         }) + "\n", encoding="utf-8")
 
+    def test_execute_ready_missing_profile_failure_is_captured_and_exact(self):
+        missing_profile = ROOT / "missing-board-profile.md"
+        environment = os.environ.copy()
+        environment["BOARD_SYNC_PROFILE"] = str(missing_profile)
+
+        completed = subprocess.run(
+            [
+                sys.executable,
+                str(ROOT / "scripts" / "execute-ready-check.py"),
+                "--issue",
+                "52",
+                "--mode",
+                "handoff",
+            ],
+            cwd=ROOT,
+            env=environment,
+            capture_output=True,
+            text=True,
+        )
+
+        expected_stderr = (
+            "[FAIL] execute-ready-check: Board-Profil nicht verfügbar — "
+            f"board profile not found at {missing_profile} — run /setup-workflow "
+            "to seed docs/agents/board-sync.md.\n"
+        )
+        diagnostics = (
+            f"stdout:\n{completed.stdout}\n"
+            f"stderr:\n{completed.stderr}"
+        )
+        self.assertEqual(completed.returncode, 1, diagnostics)
+        self.assertEqual(completed.stdout, "", diagnostics)
+        self.assertEqual(completed.stderr, expected_stderr, diagnostics)
+
     def activate_current(self, root):
         fresh = DRIFT_GUARD.scan_census_status(root)["fresh"]
         (root / ".census" / "active.json").write_text(

package/scripts/test_orchestrate_wave_contract.py

@@ -210,6 +210,41 @@ class OrchestrateWaveContract(unittest.TestCase):
         ):
             self.assertIn(fragment, done)
 
+    def test_phase_one_orders_producers_before_surface_measurers(self):
+        prose = " ".join(self.skill.split())
+        phase_one = prose.split("## Phase 1", 1)[1].split("## Phase 2", 1)[0]
+        for fragment in (
+            "Producer/measurer coupling",
+            "semantic dependency",
+            "measurer strictly after the producer",
+            "baseline reconciliation",
+            "drop producer-resolved entries",
+        ):
+            self.assertIn(fragment, phase_one)
+
+        done = phase_one.split("**Done when:**", 1)[1]
+        for fragment in (
+            "producer/measurer pair",
+            "explicit edge/order",
+            "reconciliation owner",
+        ):
+            self.assertIn(fragment, done)
+
+    def test_phase_four_centrally_runs_builder_browser_specs_before_ci(self):
+        prose = " ".join(self.skill.split())
+        phase_four = prose.split("## Phase 4", 1)[1].split("## Phase 5", 1)[0]
+        browser_contract = "builders authored or changed browser specs"
+        central_gate = "Re-run your project's full CI/verify gate CENTRALLY yourself"
+        for fragment in (
+            browser_contract,
+            "unverified artifact",
+            "ONE central green run",
+            "if `§Verify Recipe` names a local e2e runner",
+            "Never invent a command under generic fallback",
+        ):
+            self.assertIn(fragment, phase_four)
+        self.assertLess(phase_four.index(browser_contract), phase_four.index(central_gate))
+
     def test_phase_two_keeps_per_slice_routing_decisions(self):
         prose = " ".join(self.skill.split())
         self.assertIn("(a) inline vs delegate", prose)

package/scripts/test_retro_wrapup_contract.py

@@ -88,7 +88,7 @@ class WrapupChainingContract(unittest.TestCase):
         required = (
             "invoke the `retro` skill immediately in this run",
             "land nothing in this run",
-            "fresh explicit `/wrapup` invocation",
+            "fresh explicit `$wrapup` or `/wrapup` invocation",
         )
         for surface in SURFACES:
             with self.subTest(surface=surface):
@@ -120,10 +120,27 @@ class WrapupChainingContract(unittest.TestCase):
             with self.subTest(surface=surface):
                 text = skill(surface, "wrapup")
                 self.assertIn("disable-model-invocation: true", text)
-                self.assertIn("user's `/wrapup` input IS the explicit", text)
+                self.assertIn(
+                    "user's direct `$wrapup` or `/wrapup` input IS the explicit",
+                    text,
+                )
                 self.assertIn("program-sync", text)
                 self.assertIn("Phasen-Gates", text)
 
+    def test_wrapup_accepts_only_direct_user_dollar_or_slash_invocations(self):
+        required = (
+            "direct `$wrapup` or `/wrapup`",
+            "Natural-language requests",
+            "indirect skill chaining",
+            "autonomous invocation",
+            "fresh explicit `$wrapup` or `/wrapup` invocation",
+        )
+        for surface in SURFACES:
+            with self.subTest(surface=surface):
+                text = contract_text(surface, "wrapup")
+                for phrase in required:
+                    self.assertIn(phrase, text)
+
     def test_new_contract_is_reference_free(self):
         for surface in SURFACES:
             with self.subTest(surface=surface):

package/scripts/test_wrapup_land.py

@@ -0,0 +1,428 @@
+#!/usr/bin/env python3
+"""Focused contracts for wrapup's bounded PR-check merge gate."""
+
+import importlib.util
+import io
+import json
+import subprocess
+import unittest
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent
+WRAPUP = REPO / "scripts/wrapup-land.py"
+
+
+def load_wrapup():
+    spec = importlib.util.spec_from_file_location("wrapup_land_check_gate", WRAPUP)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def completed(payload, returncode=0, stderr=""):
+    return subprocess.CompletedProcess([], returncode, json.dumps(payload), stderr)
+
+
+def pr_snapshot(**overrides):
+    snapshot = {
+        "state": "OPEN",
+        "mergeable": "MERGEABLE",
+        "mergeStateStatus": "CLEAN",
+        "statusCheckRollup": [],
+        "baseRefName": "main",
+    }
+    snapshot.update(overrides)
+    return snapshot
+
+
+def gate_runner(snapshots, required_checks):
+    snapshots = iter(snapshots)
+    required_checks = iter(required_checks)
+
+    def runner(cmd, **_kwargs):
+        if cmd[:3] == ["gh", "pr", "view"]:
+            return completed(next(snapshots))
+        if cmd[:3] == ["gh", "pr", "checks"]:
+            checks = next(required_checks)
+            return completed(checks, returncode=1 if any(
+                check.get("state") == "FAILURE" for check in checks
+            ) else 0)
+        raise AssertionError(f"unexpected command: {cmd}")
+
+    return runner
+
+
+class FakeClock:
+    def __init__(self):
+        self.now = 0.0
+
+    def monotonic(self):
+        return self.now
+
+    def sleep(self, seconds):
+        self.now += seconds
+
+
+class WrapupCheckGateContract(unittest.TestCase):
+    def setUp(self):
+        self.wrapup = load_wrapup()
+
+    def test_required_check_names_come_from_active_base_branch_rules(self):
+        commands = []
+
+        def runner(cmd, **_kwargs):
+            commands.append(cmd)
+            if cmd[:3] == ["gh", "repo", "view"]:
+                return completed({"nameWithOwner": "acme/repo"})
+            if cmd[:2] == ["gh", "api"]:
+                return completed([
+                    {"type": "pull_request"},
+                    {
+                        "type": "required_status_checks",
+                        "parameters": {
+                            "required_status_checks": [
+                                {"context": "test", "integration_id": 1},
+                                {"context": "lint", "integration_id": 1},
+                            ],
+                        },
+                    },
+                ])
+            raise AssertionError(f"unexpected command: {cmd}")
+
+        self.assertEqual(
+            self.wrapup._configured_required_check_names(
+                pr_snapshot(baseRefName="release/next"), runner
+            ),
+            {"test", "lint"},
+        )
+        self.assertIn(
+            ["gh", "api", "repos/acme/repo/rules/branches/release%2Fnext"],
+            commands,
+        )
+
+    def test_pending_checks_are_visible_then_green_checks_proceed(self):
+        snapshots = iter([
+            pr_snapshot(mergeable="UNKNOWN", mergeStateStatus="BLOCKED"),
+            pr_snapshot(),
+        ])
+        checks = iter([
+            [{"name": "test", "state": "PENDING", "link": "https://example.test"}],
+            [{"name": "test", "state": "SUCCESS", "link": "https://example.test"}],
+        ])
+        calls = []
+
+        def runner(cmd, **_kwargs):
+            calls.append(cmd)
+            if cmd[:3] == ["gh", "pr", "view"]:
+                return completed(next(snapshots))
+            if cmd[:3] == ["gh", "pr", "checks"]:
+                return completed(next(checks))
+            raise AssertionError(f"unexpected command: {cmd}")
+
+        clock = FakeClock()
+        progress = io.StringIO()
+        already_merged = self.wrapup.wait_for_merge_gate(
+            "42",
+            timeout_seconds=30,
+            poll_interval=5,
+            command_runner=runner,
+            clock=clock.monotonic,
+            sleeper=clock.sleep,
+            progress_stream=progress,
+            configured_required_names={"test"},
+        )
+
+        self.assertFalse(already_merged)
+        self.assertEqual(len(calls), 4)
+        self.assertIn("waiting for PR #42 checks", progress.getvalue())
+        self.assertIn("test", progress.getvalue())
+
+    def test_explicit_null_conclusion_waits_even_with_green_legacy_state(self):
+        checks = [{
+            "name": "test",
+            "status": "COMPLETED",
+            "conclusion": None,
+            "state": "SUCCESS",
+        }]
+
+        self.assertEqual(self.wrapup.pending_checks(checks), checks)
+
+    def test_terminal_red_check_stops_before_merge_and_names_check(self):
+        snapshot = pr_snapshot(mergeStateStatus="BLOCKED")
+        checks = [[{
+            "name": "test",
+            "state": "FAILURE",
+            "link": "https://example.test",
+        }]]
+
+        with self.assertRaises(self.wrapup.Stop) as stopped:
+            self.wrapup.wait_for_merge_gate(
+                "42",
+                command_runner=gate_runner([snapshot], checks),
+                configured_required_names={"test"},
+            )
+
+        self.assertEqual(stopped.exception.step, "0c merge-gate")
+        self.assertIn("test", stopped.exception.detail)
+        self.assertNotIn("infrastructure failure", stopped.exception.detail)
+
+    def test_timeout_names_pending_checks_and_elapsed_time(self):
+        snapshot = pr_snapshot(mergeable="UNKNOWN", mergeStateStatus="BLOCKED")
+        checks = [
+            {"name": "test", "state": "QUEUED"},
+            {"name": "lint", "state": "PENDING"},
+        ]
+        clock = FakeClock()
+
+        with self.assertRaises(self.wrapup.Stop) as stopped:
+            self.wrapup.wait_for_merge_gate(
+                "42",
+                timeout_seconds=10,
+                poll_interval=5,
+                command_runner=gate_runner(
+                    [snapshot, snapshot, snapshot],
+                    [checks, checks, checks],
+                ),
+                clock=clock.monotonic,
+                sleeper=clock.sleep,
+                progress_stream=io.StringIO(),
+                configured_required_names={"test", "lint"},
+            )
+
+        self.assertIn("wait budget exceeded", stopped.exception.reason)
+        self.assertIn("elapsed=10.0s", stopped.exception.detail)
+        self.assertIn("test", stopped.exception.detail)
+        self.assertIn("lint", stopped.exception.detail)
+
+    def test_already_merged_pr_bypasses_check_wait(self):
+        snapshot = pr_snapshot(
+            state="MERGED", mergeable="UNKNOWN", mergeStateStatus="UNKNOWN"
+        )
+        clock = FakeClock()
+        commands = []
+
+        def runner(cmd, **_kwargs):
+            commands.append(cmd)
+            return completed(snapshot)
+
+        already_merged = self.wrapup.wait_for_merge_gate(
+            "42",
+            command_runner=runner,
+            clock=clock.monotonic,
+            sleeper=clock.sleep,
+            progress_stream=io.StringIO(),
+            configured_required_names={"test"},
+        )
+
+        self.assertTrue(already_merged)
+        self.assertEqual(clock.now, 0)
+        self.assertEqual(len(commands), 1)
+
+    def test_optional_red_check_does_not_block_when_required_check_is_green(self):
+        snapshot = pr_snapshot(
+            mergeStateStatus="BLOCKED",
+            statusCheckRollup=[{
+                "name": "advisory-browser",
+                "status": "COMPLETED",
+                "conclusion": "FAILURE",
+            }],
+        )
+        runner = gate_runner([snapshot], [[{
+            "name": "test",
+            "state": "SUCCESS",
+            "link": "https://example.test",
+        }]])
+
+        self.assertFalse(self.wrapup.wait_for_merge_gate(
+            "42", command_runner=runner, configured_required_names={"test"}
+        ))
+
+    def test_fresh_pr_waits_until_required_checks_become_visible(self):
+        snapshots = [
+            pr_snapshot(mergeable="UNKNOWN", mergeStateStatus="BLOCKED"),
+            pr_snapshot(mergeable="UNKNOWN", mergeStateStatus="BLOCKED"),
+            pr_snapshot(),
+        ]
+        required = [
+            [],
+            [{"name": "test", "state": "PENDING"}],
+            [{"name": "test", "state": "SUCCESS"}],
+        ]
+        clock = FakeClock()
+        progress = io.StringIO()
+
+        self.assertFalse(self.wrapup.wait_for_merge_gate(
+            "42",
+            timeout_seconds=30,
+            poll_interval=5,
+            command_runner=gate_runner(snapshots, required),
+            clock=clock.monotonic,
+            sleeper=clock.sleep,
+            progress_stream=progress,
+            configured_required_names={"test"},
+        ))
+        self.assertIn("test (awaiting discovery)", progress.getvalue())
+        self.assertIn("test", progress.getvalue())
+
+    def test_visible_optional_check_cannot_mask_required_discovery(self):
+        snapshot = pr_snapshot(
+            mergeStateStatus="BLOCKED",
+            statusCheckRollup=[{
+                "name": "advisory-browser",
+                "status": "COMPLETED",
+                "conclusion": "FAILURE",
+            }],
+        )
+
+        clock = FakeClock()
+        with self.assertRaises(self.wrapup.Stop) as stopped:
+            self.wrapup.wait_for_merge_gate(
+                "42",
+                timeout_seconds=0,
+                command_runner=gate_runner([snapshot], [[]]),
+                clock=clock.monotonic,
+                sleeper=clock.sleep,
+                progress_stream=io.StringIO(),
+                configured_required_names={"test"},
+            )
+        self.assertIn("test (awaiting discovery)", stopped.exception.detail)
+
+    def test_zero_step_failed_job_is_named_as_infrastructure_failure(self):
+        snapshot = pr_snapshot(mergeStateStatus="BLOCKED")
+        check = {
+            "name": "test",
+            "state": "FAILURE",
+            "link": "https://github.com/acme/repo/actions/runs/123/job/456",
+        }
+        commands = []
+
+        def runner(cmd, **_kwargs):
+            commands.append(cmd)
+            if cmd[:3] == ["gh", "pr", "view"]:
+                return completed(snapshot)
+            if cmd[:3] == ["gh", "pr", "checks"]:
+                return completed([check], returncode=1)
+            if "--json" in cmd:
+                return completed({
+                    "jobs": [{
+                        "databaseId": 456,
+                        "name": "test",
+                        "conclusion": "failure",
+                        "steps": [],
+                    }],
+                })
+            return subprocess.CompletedProcess(
+                cmd, 1, "", "log unavailable"
+            )
+
+        with self.assertRaises(self.wrapup.Stop) as stopped:
+            self.wrapup.wait_for_merge_gate(
+                "42", command_runner=runner, configured_required_names={"test"}
+            )
+
+        self.assertIn("test", stopped.exception.detail)
+        self.assertIn("infrastructure failure", stopped.exception.detail)
+        self.assertIn(["gh", "run", "view", "123", "--json", "jobs"], commands)
+        self.assertEqual(
+            [cmd[:3] for cmd in commands].count(["gh", "run", "view"]), 1
+        )
+
+    def test_billing_annotation_is_sanitized_and_bounded(self):
+        noisy = (
+            "The job was not started because recent account payments have failed. "
+            + "TOKEN=secret "
+            + "x" * 1000
+        )
+        check = {
+            "name": "test",
+            "state": "FAILURE",
+            "link": "https://github.com/acme/repo/actions/runs/123/job/456",
+        }
+
+        def runner(cmd, **_kwargs):
+            if "--json" in cmd:
+                return completed({"jobs": [{
+                    "databaseId": 456,
+                    "name": "test",
+                    "conclusion": "failure",
+                    "steps": [{"name": "x"}],
+                }]})
+            self.assertIn("--job", cmd)
+            self.assertIn("456", cmd)
+            return subprocess.CompletedProcess(cmd, 0, noisy, "")
+
+        diagnosis = self.wrapup.infrastructure_failure_diagnosis(
+            check, command_runner=runner
+        )
+
+        self.assertIn("infrastructure failure", diagnosis)
+        self.assertLessEqual(len(diagnosis), self.wrapup.MAX_EXTERNAL_DETAIL)
+        self.assertNotIn("\n", diagnosis)
+
+    def test_mixed_run_does_not_misclassify_real_test_failure_as_infra(self):
+        check = {
+            "name": "test",
+            "state": "FAILURE",
+            "link": "https://github.com/acme/repo/actions/runs/123/job/456",
+        }
+        commands = []
+
+        def runner(cmd, **_kwargs):
+            commands.append(cmd)
+            if "--json" in cmd:
+                return completed({"jobs": [
+                    {
+                        "databaseId": 111,
+                        "name": "setup",
+                        "conclusion": "startup_failure",
+                        "steps": [],
+                    },
+                    {
+                        "databaseId": 456,
+                        "name": "test",
+                        "conclusion": "failure",
+                        "steps": [{"name": "Run tests", "conclusion": "failure"}],
+                    },
+                ]})
+            return subprocess.CompletedProcess(
+                cmd, 0, "AssertionError: expected green", ""
+            )
+
+        diagnosis = self.wrapup.infrastructure_failure_diagnosis(
+            check, command_runner=runner
+        )
+
+        self.assertEqual(diagnosis, "")
+        self.assertIn(
+            ["gh", "run", "view", "123", "--job", "456", "--log-failed"],
+            commands,
+        )
+
+    def test_check_without_unique_job_match_is_not_classified_from_run_logs(self):
+        check = {
+            "name": "test",
+            "state": "FAILURE",
+            "link": "https://github.com/acme/repo/actions/runs/123",
+        }
+        commands = []
+
+        def runner(cmd, **_kwargs):
+            commands.append(cmd)
+            if "--json" in cmd:
+                return completed({"jobs": [
+                    {"name": "test", "conclusion": "failure", "steps": []},
+                    {"name": "test", "conclusion": "failure", "steps": []},
+                ]})
+            raise AssertionError("aggregate run logs must not be inspected")
+
+        self.assertEqual(
+            self.wrapup.infrastructure_failure_diagnosis(
+                check, command_runner=runner
+            ),
+            "",
+        )
+        self.assertEqual(len(commands), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/scripts/workflow-advisories/core.py

@@ -261,11 +261,47 @@ def convention_freshness_decision(profile: dict, root: Path) -> Decision:
     )
 
 
-def migration_reminder_decision(profile: dict, payload: dict) -> Decision:
+def _migration_session_marker(profile: dict, payload: dict, root: Path) -> Path | None:
+    session_id = payload.get("session_id")
+    if not isinstance(session_id, str) or not session_id:
+        return None
+    state_dir = root / profile.get("baseline", {}).get(
+        "stateDir", ".claude/logs/advisory-state",
+    )
+    safe_session = re.sub(r"[^A-Za-z0-9._-]", "-", session_id)
+    return state_dir / f"{safe_session}.migration.hinted"
+
+
+def _unquoted_shell_text(command: str) -> str:
+    visible: list[str] = []
+    quote: str | None = None
+    escaped = False
+    for character in command:
+        if escaped:
+            visible.append(" " if quote else character)
+            escaped = False
+        elif character == "\\" and quote != "'":
+            visible.append(" ")
+            escaped = True
+        elif quote:
+            visible.append(" ")
+            if character == quote:
+                quote = None
+        elif character in {"'", '"', "`"}:
+            visible.append(" ")
+            quote = character
+        else:
+            visible.append(character)
+    return "".join(visible)
+
+
+def migration_reminder_decision(
+    profile: dict, payload: dict, root: Path,
+) -> Decision:
     config = profile.get("migration", {})
     if payload.get("tool_name") != "Bash":
         return Decision(None, "PostToolUse")
-    command = payload.get("tool_input", {}).get("command", "")
+    command = _unquoted_shell_text(payload.get("tool_input", {}).get("command", ""))
     if not any(
         re.search(pattern, command)
         for pattern in config.get("commandMatchers", [])
@@ -275,6 +311,12 @@ def migration_reminder_decision(profile: dict, payload: dict) -> Decision:
     refresh = config.get("refreshCommand", [])
     if not artifact or not refresh:
         return Decision(None, "PostToolUse")
+    marker = _migration_session_marker(profile, payload, root)
+    if marker and marker.exists():
+        return Decision(None, "PostToolUse")
+    if marker:
+        marker.parent.mkdir(parents=True, exist_ok=True)
+        marker.write_text(f"{payload['session_id']}\n", encoding="utf-8")
     message = (
         f"Migration advisory: refresh {artifact} with `{' '.join(refresh)}` "
         "before treating the migration result as complete."