Keep baseline runtimes independent of temporary source and candidate launchers

Signed-off-by: tzhouam <tzhouam@connect.ust.hk>

Author: tzhouam

doc/architecture/SPEC/engine/steps/rebase_v3.md

@@ -132,7 +132,9 @@ harness 会话通过 MCP tool bridge 拿到同一套工具面，plan gate 在派
   `upstream_commit` 重新确保 scratch。
 - baseline venv（`ensure_baseline_venv`）：硬链接克隆 campaign venv 并换入
   baseline commit 的 wheel，让"omni main 对上次对齐的 wheel 是否也失败"可问；
-  任何失败返回 None，保留保守的回归判定。
+  使用发布 wheel（若配置 URL）或非 editable 安装，删除临时源码后再验证导入；
+  克隆的 console/activation 脚本通过原子替换改为 baseline 路径，不能写穿硬链接
+  修改 campaign。缓存复用也必须通过导入检查。任何失败返回 None，保留保守的回归判定。
 
 ## 操作者重跑与本地超时预算（2026-10-29）
 

src/infermatrix_copilot/rebase_engine/wheel.py

@@ -749,6 +749,31 @@ def import_ok() -> bool:
 
 # -- baseline runtime ----------------------------------------------------------
 
+def _relocate_venv_scripts(src: Path, dst: Path) -> None:
+    """Point cloned launchers/activation scripts at the clone, without writing
+    through hardlinks into the campaign runtime."""
+    import stat
+
+    source = os.fsencode(str(src))
+    destination = os.fsencode(str(dst))
+    # The baseline directory name starts with the campaign name. Match the
+    # complete path so a healthy cloned launcher is not relocated twice.
+    source_path = re.compile(re.escape(source) + rb"(?=[/\x22\x27\s]|$)")
+    for script in (dst / "bin").iterdir():
+        if script.is_symlink() or not script.is_file():
+            continue
+        data = script.read_bytes()
+        if b"\0" in data or not source_path.search(data):
+            continue
+        replacement = script.with_name(f".{script.name}.relocate-{os.getpid()}")
+        try:
+            replacement.write_bytes(source_path.sub(lambda _: destination, data))
+            replacement.chmod(stat.S_IMODE(script.stat().st_mode))
+            os.replace(replacement, script)
+        finally:
+            replacement.unlink(missing_ok=True)
+
+
 def _clone_tree_hardlinked(src: Path, dst: Path) -> bool:
     """Hardlink clone (near-zero disk, same filesystem). uv replaces files
     by rename, which breaks the links — the campaign venv is never modified
@@ -757,6 +782,7 @@ def _clone_tree_hardlinked(src: Path, dst: Path) -> bool:
     if rc != 0:
         _log(f"baseline-venv clone failed: {err.strip()}")
         return False
+    _relocate_venv_scripts(src, dst)
     return True
 
 
@@ -778,7 +804,8 @@ def ensure_baseline_venv(
     against the wheel main was LAST aligned to"; this builds exactly that
     runtime: hardlink-clone the campaign venv (identical deps), swap in
     the baseline wheel from a throwaway worktree of the upstream at the
-    baseline commit. Returns None on any failure — a missing baseline
+    baseline commit. Installs are non-editable so cleanup cannot remove code
+    the runtime needs; console scripts are relocated to the clone. Returns None on any failure — a missing baseline
     runtime keeps the loop's regression-preserving default and must never
     read as pre-existing."""
     import shutil
@@ -791,9 +818,16 @@ def ensure_baseline_venv(
     python = str(bv / "bin" / "python")
     if (bv / "pyvenv.cfg").is_file():
         installed = read_installed_version(spec, python=python, run=run)
-        if installed and version_matches_commit(installed, baseline_commit):
-            log(f"baseline venv already healthy at {bv}")
-            return bv
+        matches = (installed_wheel_matches(
+            spec, baseline_commit, installed, python=python, run=run)
+            if spec.install_url_template else
+            bool(installed and version_matches_commit(installed, baseline_commit)))
+        if matches:
+            rc, _, _ = run([python, "-c", build_import_check_snippet(spec)], cwd=bv)
+            if rc == 0:
+                _relocate_venv_scripts(target_venv, bv)
+                log(f"baseline venv already healthy at {bv}")
+                return bv
     if not (Path(upstream) / ".git").exists():
         log(f"baseline venv: upstream {upstream} is not a git checkout")
         return None
@@ -817,8 +851,14 @@ def ensure_baseline_venv(
         env.update({key: value.replace("{commit}", baseline_commit)
                           .replace("{variant}", spec.variant)
                     for key, value in spec.install_env.items()})
+        # The worktree is deleted below. An editable install would retain a
+        # finder pointing into that deleted tree and pass only the import check
+        # run from inside it. Prefer the frozen published wheel when available.
+        requirement = (spec.install_url_template.format(
+            commit=baseline_commit, variant=spec.variant, arch=spec.arch,
+            package=spec.package) if spec.install_url_template else ".")
         rc, _, err = run([uv, "pip", "install", "--python", python,
-                          "-e", "."], cwd=wt, env=env, timeout=3600)
+                          requirement], cwd=wt, env=env, timeout=3600)
         if rc != 0:
             log(f"baseline wheel install failed: {err.strip()[-300:]}")
             shutil.rmtree(bv, ignore_errors=True)
@@ -832,6 +872,13 @@ def ensure_baseline_venv(
     finally:
         run(["git", "-C", str(upstream), "worktree", "remove",
              "--force", str(wt)], timeout=600)
+    # Probe after removal, away from both source trees: cwd must not rescue a
+    # broken install. This also protects baseline classification on later reuse.
+    rc, _, err = run([python, "-c", build_import_check_snippet(spec)], cwd=bv)
+    if rc != 0:
+        log(f"baseline venv import failed after source cleanup: {err.strip()[-200:]}")
+        shutil.rmtree(bv, ignore_errors=True)
+        return None
     log(f"baseline venv ready at {bv} (wheel {baseline_commit[:12]})")
     return bv
 

test/test_rebase_release_target.py

@@ -437,3 +437,92 @@ def clone(src, dst):
                                run=run, clone=clone)
     assert out == tmp_path / ("venv-baseline-" + "a" * 12)
     assert any("worktree" in c and "remove" in c for c in calls)
+
+
+def test_hardlinked_baseline_launchers_use_clone_without_modifying_target(tmp_path):
+    import venv
+
+    from infermatrix_copilot.rebase_engine.wheel import _clone_tree_hardlinked, _relocate_venv_scripts
+
+    target, baseline = tmp_path / "venv", tmp_path / "venv-baseline"
+    venv.EnvBuilder(with_pip=False).create(target)
+    launcher = target / "bin" / "runtime-probe"
+    original = f"#!{target}/bin/python\nimport sys\nprint(sys.prefix)\n"
+    launcher.write_text(original)
+    launcher.chmod(0o755)
+    assert _clone_tree_hardlinked(target, baseline)
+    _relocate_venv_scripts(target, baseline)  # Cached reuse must be idempotent.
+    result = subprocess.run([str(baseline / "bin" / launcher.name)],
+                            capture_output=True, text=True, check=True)
+    assert result.stdout.strip() == str(baseline)
+    assert launcher.read_text() == original
+    assert str(target) in (target / "bin" / "activate").read_text()
+    assert str(baseline) in (baseline / "bin" / "activate").read_text()
+
+
+def test_baseline_package_survives_temporary_source_removal(tmp_path):
+    import shutil
+    import venv
+
+    from infermatrix_copilot.rebase_engine import wheel
+
+    target = tmp_path / "target"
+    venv.EnvBuilder(with_pip=False).create(target)
+    (tmp_path / ".git").mkdir()
+
+    def run(cmd, *, cwd=None, env=None, timeout=600):
+        if cmd[0] == "git":
+            source = tmp_path / ("target-baseline-" + "a" * 12 + "-src")
+            if "add" in cmd:
+                (source / "fixture").mkdir(parents=True)
+                (source / "fixture" / "__init__.py").write_text("VALUE = 'baseline'\n")
+            else:
+                shutil.rmtree(source)
+            return 0, "", ""
+        if cmd[:3] == ["fixture-uv", "pip", "uninstall"]:
+            return 0, "", ""
+        if cmd[:3] == ["fixture-uv", "pip", "install"]:
+            python = cmd[cmd.index("--python") + 1]
+            site = subprocess.check_output(
+                [python, "-c", "import sysconfig; print(sysconfig.get_path('purelib'))"],
+                text=True).strip()
+            # Simulate editable/non-editable installation without network or a
+            # build backend. The former becomes unimportable after git cleanup.
+            from pathlib import Path
+            if "-e" in cmd:
+                (Path(site) / "fixture.pth").write_text(str(cwd) + "\n")
+            else:
+                shutil.copytree(cwd / "fixture", Path(site) / "fixture")
+            return 0, "", ""
+        return wheel._run(cmd, cwd=cwd, env=env, timeout=timeout)
+
+    spec = WheelSpec(package="fixture", variant="cpu", arch="x86_64",
+                     index_url_template="https://example.invalid/{commit}")
+    baseline = wheel.ensure_baseline_venv(target, spec, tmp_path, "a" * 40,
+                                           uv="fixture-uv", run=run)
+    assert baseline is not None
+    assert not (tmp_path / (baseline.name + "-src")).exists()
+    result = subprocess.run([str(baseline / "bin/python"), "-c",
+                             "import fixture; print(fixture.VALUE)"],
+                            cwd=tmp_path, capture_output=True, text=True, check=True)
+    assert result.stdout.strip() == "baseline"
+
+
+def test_cached_baseline_with_matching_metadata_but_missing_code_is_rejected(tmp_path):
+    from infermatrix_copilot.rebase_engine import wheel
+
+    target = tmp_path / "target"
+    baseline = tmp_path / ("target-baseline-" + "a" * 12)
+    baseline.mkdir()
+    (baseline / "pyvenv.cfg").write_text("home=/usr\n")
+    (tmp_path / ".git").mkdir()
+
+    def run(cmd, **kwargs):
+        if len(cmd) > 3 and cmd[-1] == "fixture":
+            return 0, "1.0+gaaaaaaaaa\n", ""
+        return 1, "", "missing fixture source"
+
+    result = wheel.ensure_baseline_venv(target, _install_spec(), tmp_path,
+                                       "a" * 40, run=run,
+                                       clone=lambda src, dst: False)
+    assert result is None