From 52971cc818fdd11e8b63960c8e674bd43ca16c6f Mon Sep 17 00:00:00 2001
From: Dong1017 <55723162+Dong1017@users.noreply.github.com>
Date: Sat, 31 Oct 2026 22:35:13 +0800
Subject: [PATCH 1/2] feat: make nonpaid SkillEval plans actionable for authors

Signed-off-by: Codex <codex@openai.com>
---
 docs/skill-eval-pr.md                     |  48 +++-
 tests/test_skill_eval_planned_guidance.py | 206 ++++++++++++++
 tests/test_skill_eval_pr.py               |   2 +-
 tests/test_skill_eval_pr_summary.py       |  26 +-
 tools/skill_eval_pr.py                    | 319 +++++++++++++++++++---
 5 files changed, 551 insertions(+), 50 deletions(-)
 create mode 100644 tests/test_skill_eval_planned_guidance.py

diff --git a/docs/skill-eval-pr.md b/docs/skill-eval-pr.md
index 147ac8cf4..09140a172 100644
--- a/docs/skill-eval-pr.md
+++ b/docs/skill-eval-pr.md
@@ -48,10 +48,56 @@ Plans and reports have one identifiable bot comment beginning with
 `<!-- inferrsi-skill-eval-pr:v1 -->`. A new head/base, trusted implementation,
 mapping, exam, model or budget produces a new plan. Earlier authorization and
 results are stale. The planner replaces the summary with the current plan and
-missing pairs. A publisher checks live revisions twice and refuses older writer
+explicit unexecuted status (not zero-valued pseudo-results). A publisher checks live revisions twice and refuses older writer
 runs, so delayed jobs cannot replace a newer summary. All plan/execute/publish
 runs for one PR share non-cancelling Actions concurrency.
 
+### Nonpaid author handoff
+
+A **PLANNED** comment is a work instruction, not a test result. Its front section
+identifies the current head, next action, unresolved blockers and required evidence.
+The collapsed **Author verification steps** contain the actual path-map trigger,
+existing task purpose/scope, required answer fields and concrete check instructions.
+Known fixed snapshot refusals remain precise; recognized dynamic errors expose only
+the fixed category, never arbitrary exception/YAML excerpts. Unknown errors receive
+an explicit generic preparation failure. The original plan/exception bytes are not
+rewritten by this public display projection. A mapped path does **not** establish
+that its task tests the changed claim. For example, a blocked-request diagnostic
+case is not a source-fidelity check merely because a skill metadata file changed.
+The author and independent reviewer must disposition that relevance explicitly.
+
+For canonical library or generated-index changes, the planner may show the existing
+`python tools/build_skill_index.py --source-revision <declared-commit> --check`
+with an **actual** immutable pin. It reads the known generated README as bounded
+Git data, requires one declared source commit, and checks that the entire canonical
+library has identical Git bytes/modes at that pin and the PR head. It does not
+execute the generator or establish that generated records are correct. At the
+identified PR checkout, with the reviewed tool and documented development/skills
+extras, the author can run that no-model check and retain its exit code plus full
+success/drift output. An absent, unavailable or mismatched pin yields an explicit
+source-selection action instead; HEAD is never silently substituted. A successful
+index check establishes projection consistency, not source-claim truth, behavior,
+hardware compatibility or skill benefit.
+
+For successfully prepared mappings, the displayed `python -m json.tool` commands
+inspect the retained tasks and schema from the downloaded `skill-eval-plan`
+artifact directory; they do not grade anything or call a model. Produce the required
+answer/artifact only after confirming applicability. Use the existing
+[comparison contract](skill-eval-comparison.md) or, for an explicitly selected
+engineering task, [local-author handoff](local-skill-evaluation.md). No paid
+execute command is a nonpaid fallback, and no task or mapping is selected on the
+author's behalf when the existing mapping supplies none.
+
+Return the current PR head, exact check/task and source pin, commands, environment,
+exit status, bounded input/output evidence and failures. Distinguish real author
+work from synthetic hand-authored/scripted controls. List claims still untested;
+an independent reviewer records verified/refuted/unverified dispositions. Path
+counts are grouped by canonical/generated/other **location**, never treated as
+claim counts or proof of a metadata-only change. Full paths, frozen task/grader
+identities, budget and execution controls remain in collapsed audit details and
+the retained plan. Older plans lacking task metadata say so instead of borrowing
+new metadata or rebinding old evidence. Unsupported snapshot safety is unchanged.
+
 ### Refresh a plan without execution
 
 Dispatch **Skill PR evaluation** on **main** with `action=plan` and the PR number
diff --git a/tests/test_skill_eval_planned_guidance.py b/tests/test_skill_eval_planned_guidance.py
new file mode 100644
index 000000000..bd0a11144
--- /dev/null
+++ b/tests/test_skill_eval_planned_guidance.py
@@ -0,0 +1,206 @@
+"""Nonpaid planner guidance: raw Git/data inspection, never candidate/model execution."""
+
+import copy
+import json
+from unittest.mock import Mock
+
+import pytest
+
+from inferrsi.infra.artifacts import write_json
+from tests.fixtures.skill_eval_compare_support import git
+from tests.fixtures.skill_eval_pr_support import setup
+from tests.test_skill_eval_pr_summary import visible
+from tools import skill_eval_pr as pr
+
+
+def render(plan):
+    return pr.summary(plan, [], "https://example.invalid/plan", 100, 1)
+
+
+def test_prepared_task_purpose_trigger_and_needed_outputs_are_retained(tmp_path, monkeypatch):
+    repo, mapping, identity = setup(tmp_path, ids=("one",))
+    tasks = json.loads((tmp_path / "cases.json").read_text())
+    tasks[0].update(request="Audit every request against the fixed workload contract.")
+    assert "arbitrary_private_note" not in pr.task_context(
+        [{**tasks[0], "arbitrary_private_note": "DO-NOT-PROJECT"}])[0]
+    write_json(tmp_path / "cases.json", tasks)
+    never_execute = Mock(side_effect=AssertionError("No candidate or model execution"))
+    monkeypatch.setattr(pr.compare, "execute", never_execute)
+    plan = pr.prepare(repo, mapping, identity, tmp_path / "plan")
+    item = plan["comparisons"][0]
+    selection = item["selection"]
+    assert selection["basis"] == "trusted_path_mapping"
+    assert selection["matched_paths"] == [c["path"] for c in plan["coverage"]
+                                           if c["coverage"] == "covered"]
+    assert selection["tasks"][0]["request"] == tasks[0]["request"]
+    assert "arbitrary_private_note" not in selection["tasks"][0]
+    schema = json.loads((tmp_path / "plan/selected/plan/schema.json").read_text())
+    assert selection["required_answer_fields"] == schema["required"]
+    text, main = render(plan), visible(render(plan))
+    for expected in (tasks[0]["request"], "http&#95;fixed&#95;workload", "Required answer fields:",
+                     "python -m json.tool selected/plan/tasks.json", "**not grading**",
+                     "Independent check: frozen <code>audit</code>", "git rev-parse HEAD",
+                     "verified, refuted or unverified"):
+        assert expected in text
+    assert item["exam"]["grader"] in text and "DO-NOT-PROJECT" not in text
+    assert "Outcomes:" not in text and "--execute" not in main and "--stage-local" not in main
+    never_execute.assert_not_called()
+
+
+def test_unsupported_and_mapping_only_keep_task_purpose_without_fake_commands(tmp_path):
+    repo, mapping, identity = setup(tmp_path, ids=("one",))
+    git(repo, "update-index", "--chmod=+x", "library/selected/resource.txt")
+    git(repo, "commit", "--quiet", "-m", "Synthetic unsupported executable snapshot")
+    identity["head"] = git(repo, "rev-parse", "HEAD")
+    plan = pr.prepare(repo, mapping, identity, tmp_path / "unsupported")
+    main = visible(render(plan))
+    assert "Executable snapshot entries are not supported" in main
+    assert plan["comparisons"][0]["selection"]["tasks"]
+    assert "python -m json.tool selected" not in main
+    blocked = pr.prepare(repo, mapping, identity, tmp_path / "blocked",
+                         planning_blocked="unavailable configuration")
+    assert blocked["comparisons"][0]["selection"]["tasks"]
+    assert "Mapping-only scope; provider unavailable" in visible(render(blocked))
+    assert "No supported automatic comparison" in render(plan)
+
+
+def index_fixture(tmp_path):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    git(repo, "init", "--quiet")
+    canonical = repo / pr.LIBRARY_PATH / "skill-index.json"
+    canonical.parent.mkdir(parents=True)
+    canonical.write_text('{"fixture":"not an efficacy test"}\n')
+    git(repo, "add", ".")
+    git(repo, "commit", "--quiet", "-m", "Synthetic canonical source")
+    pin = git(repo, "rev-parse", "HEAD")
+    readme = repo / pr.PROJECTION_PATH / "README.md"
+    readme.parent.mkdir(parents=True)
+    readme.write_text(f"Source snapshot: [{pin}](https://github.com/example/fixture/tree/"
+                      f"{pin}/{pr.LIBRARY_PATH}).\n")
+    git(repo, "add", ".")
+    git(repo, "commit", "--quiet", "-m", "Synthetic declared projection pin")
+    identity = {"repository": "example/fixture", "base": pin,
+                "head": git(repo, "rev-parse", "HEAD")}
+    changes = pr.changed_files(repo, identity["base"], identity["head"])
+    return repo, readme, canonical, pin, identity, changes
+
+
+def test_index_pin_check_uses_declared_source_not_head_and_does_not_execute(tmp_path):
+    repo, _, _, pin, identity, changes = index_fixture(tmp_path)
+    check = pr.projection_check(repo, identity, changes)
+    assert check == {"status": "ready", "source_revision": pin,
+                     "declared_in": pr.PROJECTION_PATH + "/README.md"}
+    assert pin != identity["head"]
+    minimal = {**identity, "version": "d" * 40, "estimated_calls": 0, "projection_check": check,
+               "comparisons": [], "coverage": [{**c, "coverage": "uncovered"} for c in changes]}
+    text = "\n".join(pr.author_actions(minimal))
+    assert f"python tools/build_skill_index.py --source-revision {pin} --check" in text
+    assert "command has **not run**" in text and "not claim truth or skill efficacy" in text
+    assert "exit code and full drift/success output" in text
+    assert "Generated projection paths: 1" in text
+
+
+@pytest.mark.parametrize("mutation", ["missing", "malformed", "duplicate", "mismatch", "mode",
+                                      "symlink", "oversized", "unknown_commit", "missing_library"])
+def test_unusable_projection_pin_never_yields_a_concrete_check(tmp_path, mutation):
+    repo, readme, canonical, pin, identity, changes = index_fixture(tmp_path)
+    if mutation == "missing":
+        readme.unlink()
+    elif mutation == "malformed":
+        readme.write_text("Source snapshot: $(echo unsafe)\n")
+    elif mutation == "duplicate":
+        readme.write_text(readme.read_text() * 2)
+    elif mutation == "mismatch":
+        canonical.write_text("changed canonical input\n")
+    elif mutation == "mode":
+        readme.chmod(0o755)
+    elif mutation == "symlink":
+        readme.unlink()
+        readme.symlink_to(canonical)
+    elif mutation == "oversized":
+        readme.write_text(readme.read_text() + "x" * 65536)
+    elif mutation == "unknown_commit":
+        readme.write_text(readme.read_text().replace(pin, "f" * 40))
+    else:
+        canonical.unlink()
+    git(repo, "add", "-A")
+    git(repo, "commit", "--quiet", "-m", "Synthetic unavailable source")
+    identity["head"] = git(repo, "rev-parse", "HEAD")
+    check = pr.projection_check(repo, identity, changes)
+    assert check["status"] == "unavailable" and "source_revision" not in check
+    if mutation == "mismatch":
+        assert "differs from current canonical" in check["reason"]
+
+
+def test_hostile_metadata_is_escaped_and_raw_plan_is_not_mutated(tmp_path):
+    repo, mapping, identity = setup(tmp_path, ids=("one",))
+    plan = pr.prepare(repo, mapping, identity, tmp_path / "plan")
+    hostile = '</details><script>@all</script>\n```bash\n$(touch bad)'
+    item = plan["comparisons"][0]
+    item["selection"]["tasks"][0].update(request=hostile, provenance=hostile)
+    item["selection"]["matched_paths"] = [hostile]
+    item["selection"]["required_answer_fields"] = [hostile]
+    plan["coverage"].append({"path": hostile, "coverage": "uncovered"})
+    original = copy.deepcopy(plan)
+    text = render(plan)
+    assert text.count("</details>") == 3
+    assert "<script>" not in text and "@all" not in text and "\n$(touch bad)" not in text
+    assert plan == original
+    plan["comparisons"] = [{"skill": "selected", "unsupported": hostile}]
+    assert "<script>" not in render(plan) and "@all" not in render(plan)
+
+
+def test_grouping_is_location_only_and_preserves_every_gap(tmp_path):
+    repo, mapping, identity = setup(tmp_path, ids=("one",))
+    plan = pr.prepare(repo, mapping, identity, tmp_path / "plan")
+    plan.update(comparisons=[], estimated_calls=0)
+    paths = [f"{pr.LIBRARY_PATH}/owner-{i}.md" for i in range(7)] + [
+        f"{pr.PROJECTION_PATH}/record-{i}.json" for i in range(58)]
+    plan["coverage"] = [{"path": p, "coverage": "uncovered"} for p in paths]
+    text = render(plan)
+    main = visible(text)
+    assert "Canonical library paths: 7; Generated projection paths: 58; Other paths: 0" in main
+    assert "These are paths, not independent claims" in main
+    assert "no metadata-only conclusion is inferred" in text
+    assert "Outcomes:" not in text
+    assert all(path in text for path in paths)
+    assert len(main) < 4300
+    # This retained plan still has no automatic comparison; no new mapping was invented.
+    assert not plan["comparisons"] and "python -m json.tool" not in main
+
+
+@pytest.mark.parametrize("reason,category", [
+    ("Invalid skill YAML: /private/owner: SECRET-CANARY", "Invalid skill YAML"),
+    ("Missing declared skill document: /private/SECRET-CANARY", "Missing declared skill document"),
+    ("Unsafe bundle path: SECRET-CANARY", "Unsafe bundle path"),
+    ("arbitrary SECRET-CANARY exception", "unrecognized reason"),
+    ({"private": "SECRET-CANARY"}, "unrecognized reason"),
+])
+def test_public_failure_categories_do_not_echo_raw_suffix_or_unknown_text(
+        tmp_path, reason, category):
+    repo, mapping, identity = setup(tmp_path, ids=("one",))
+    plan = pr.prepare(repo, mapping, identity, tmp_path / "plan")
+    plan.update(comparisons=[{"skill": "selected", "unsupported": reason}], estimated_calls=0)
+    original = copy.deepcopy(plan)
+    text = render(plan)
+    assert category in visible(text) and category in text
+    assert "SECRET-CANARY" not in text and "/private/" not in text
+    assert plan == original
+
+
+def test_reachable_malformed_skill_yaml_retains_raw_reason_but_projects_only_category(tmp_path):
+    repo, mapping, identity = setup(tmp_path, ids=("one",))
+    skill = repo / "library/selected/SKILL.md"
+    skill.write_text("---\nname: selected\ndescription: [SECRET-CANARY\n---\n")
+    git(repo, "add", "library/selected/SKILL.md")
+    git(repo, "commit", "--quiet", "-m", "Synthetic malformed YAML public-display control")
+    identity["head"] = git(repo, "rev-parse", "HEAD")
+    output = tmp_path / "plan"
+    plan = pr.prepare(repo, mapping, identity, output)
+    original = (output / "pr-plan.json").read_bytes()
+    reason = plan["comparisons"][0]["unsupported"]
+    assert reason.startswith("Invalid skill YAML:") and "SECRET-CANARY" in reason
+    text = render(plan)
+    assert "Invalid skill YAML" in visible(text) and "SECRET-CANARY" not in text
+    assert (output / "pr-plan.json").read_bytes() == original
diff --git a/tests/test_skill_eval_pr.py b/tests/test_skill_eval_pr.py
index 71b46a4a8..e939470bb 100644
--- a/tests/test_skill_eval_pr.py
+++ b/tests/test_skill_eval_pr.py
@@ -105,7 +105,7 @@ def test_deleted_and_unmapped_skill_changes_are_visible_not_passed(tmp_path):
     assert plan["comparisons"] == [] and plan["estimated_calls"] == 0
     assert {c["coverage"] for c in plan["coverage"]} == {"uncovered", "unsupported"}
     body = integration.summary(plan, [], "https://github.com/example/fixture/actions/runs/1", 10, 1)
-    assert "uncovered" in body and "unsupported" in body and '"fix":0' in body
+    assert "uncovered" in body and "unsupported" in body and "Outcomes:" not in body
     with pytest.raises(ValueError, match="No supported comparisons"):
         approval(plan)
 
diff --git a/tests/test_skill_eval_pr_summary.py b/tests/test_skill_eval_pr_summary.py
index ff70ba75f..eaf07e4ec 100644
--- a/tests/test_skill_eval_pr_summary.py
+++ b/tests/test_skill_eval_pr_summary.py
@@ -45,13 +45,13 @@ def outcome(**values):
 def assert_boundaries(text):
     main = visible(text)
     assert text.startswith(integration.MARKER + "\n")
-    assert text.count("<details>") == text.count("</details>") == 2
+    assert text.count("<details>") == text.count("</details>") == (3 if "**PLANNED:" in text else 2)
     assert "<details open" not in text
     for statement in ("Applicable only while", "trusted label authorization",
                       "cumulative PR reservation", "Unknown accounting blocks new paid calls",
                       "Retention: 30 days", "Unix time", "Expired evidence is unverified.",
                       "offline fixed outputs do not establish skill efficacy"):
-        assert statement in main
+        assert statement in text
     assert "[Evidence and logs](https://example.invalid/evidence)" in main
 
 
@@ -59,9 +59,10 @@ def test_planned_summary_keeps_visible_status_and_folds_full_approval_fields(pla
     text = render(plan)
     assert_boundaries(text)
     main = visible(text)
-    binding, gaps = details(text)
+    author, binding, gaps = details(text)
+    assert "git rev-parse HEAD" in author
     assert "**PLANNED:" in main
-    assert '"missing_pair":1' in main
+    assert "Outcomes:" not in main and "no task outcomes yet" in main
     assert "Selected comparisons: **1**" in main
     assert "Estimated task calls: **2**" in main
     assert "Uncovered/unsupported changes: **0**" in main
@@ -69,7 +70,10 @@ def test_planned_summary_keeps_visible_status_and_folds_full_approval_fields(pla
                   integration.canonical(plan["model"]),
                   integration.canonical(integration.budget(plan)),
                   integration.canonical(plan["comparisons"][0]["exam"]), "one (holdout)"):
-        assert value in binding and value not in main
+        assert value in binding
+        # The author sees the head to bind the checkout and pinned implementation doc links.
+        if value != plan["head"]:
+            assert value not in main
     assert "(none)" in gaps
 
 
@@ -106,8 +110,8 @@ def test_zero_comparisons_and_zero_gaps_remain_truthful_and_closed(plan):
     main = visible(text)
     assert "Selected comparisons: **0**" in main
     assert "Estimated task calls: **0**" in main
-    assert '"missing_pair":0' in main
-    assert "(none)" in details(text)[1]
+    assert "Outcomes:" not in main and "no supported automatic comparison" in main
+    assert "(none)" in details(text)[-1]
 
 
 def test_seventy_gaps_are_complete_but_visible_summary_is_bounded(plan):
@@ -117,11 +121,11 @@ def test_seventy_gaps_are_complete_but_visible_summary_is_bounded(plan):
     assert_boundaries(text)
     main = visible(text)
     assert "Uncovered/unsupported changes: **70**" in main
-    assert len(main) < 1800 and len(main.splitlines()) < 28
+    assert len(main) < 4300 and len(main.splitlines()) < 40
     assert "uncovered-00.md" not in main
     for gap in plan["coverage"]:
         escaped = html.escape(integration.canonical(gap["path"])).replace("@", "&#64;")
-        assert escaped in details(text)[1]
+        assert escaped in details(text)[-1]
 
 
 @pytest.mark.parametrize("path", [
@@ -138,7 +142,7 @@ def test_hostile_gap_paths_cannot_close_details_or_escape_as_markdown(plan, path
     text = render(plan)
     assert_boundaries(text)
     expected = html.escape(integration.canonical(path)).replace("@", "&#64;")
-    assert expected in details(text)[1]
+    assert expected in details(text)[-1]
     assert "<script>" not in text and "<img " not in text
     assert "@someone" not in text and "@org/team" not in text and "@all" not in text
     assert "\n# forged heading\n" not in text
@@ -149,7 +153,7 @@ def test_unsupported_comparison_has_zero_calls_without_hiding_gap(plan):
                 estimated_calls=0, coverage=[{"path": "missing.md", "coverage": "unsupported"}])
     text = render(plan)
     assert_boundaries(text)
-    assert "unsupported snapshot" in details(text)[0]
+    assert "unsupported snapshot" in details(text)[-2]
     assert "Selected comparisons: **0**" in visible(text)
     assert "Uncovered/unsupported changes: **1**" in visible(text)
 
diff --git a/tools/skill_eval_pr.py b/tools/skill_eval_pr.py
index 107473d0a..87d475767 100644
--- a/tools/skill_eval_pr.py
+++ b/tools/skill_eval_pr.py
@@ -35,6 +35,8 @@
 RETENTION_DAYS = 30
 MAX_ARCHIVE = 100 * 1024 * 1024
 SHA = r"[0-9a-f]{40}"
+LIBRARY_PATH = "src/inferrsi/data/skill_library"
+PROJECTION_PATH = "src/inferrsi/data/repo_packs/inferrsi/knowledge"
 
 
 def canonical(value):
@@ -59,6 +61,52 @@ def blob_exists(repo, revision, path):
     return bool(git(repo, "ls-tree", revision, "--", path).strip())
 
 
+def matches_path(path, prefixes):
+    return any(path == prefix or path.startswith(prefix.rstrip("/") + "/")
+               for prefix in prefixes)
+
+
+def task_context(tasks):
+    # Public descriptive metadata only, not inputs, oracle answers or arbitrary fields.
+    if not isinstance(tasks, list):
+        return []
+    return [{key: task[key] for key in ("id", "split", "request", "evidence_scope", "provenance")
+             if isinstance(task.get(key), str)} for task in tasks if isinstance(task, dict)]
+
+
+def projection_check(repo, identity, changes):
+    """Identify an applicable existing check from raw Git data, without running it."""
+    if not any(matches_path(c["path"], (LIBRARY_PATH, PROJECTION_PATH)) for c in changes):
+        return None
+    unavailable = {"status": "unavailable", "reason": "No usable declared projection source pin"}
+    readme = PROJECTION_PATH + "/README.md"
+    try:
+        # Do not follow a symlink or read executable/oversized PR metadata.
+        entry = git(repo, "ls-tree", identity["head"], "--", readme).decode().split()
+        if len(entry) != 4 or entry[:2] != ["100644", "blob"]:
+            return unavailable
+        if int(git(repo, "cat-file", "-s", entry[2])) > 65536:
+            return unavailable
+        text = git(repo, "cat-file", "blob", entry[2]).decode("utf-8")
+        pattern = (r"^Source snapshot: \[(" + SHA + r")\]\(https://github\.com/"
+                   + re.escape(identity["repository"]) + r"/tree/\1/"
+                   + re.escape(LIBRARY_PATH) + r"\)\.$")
+        pins = re.findall(pattern, text, flags=re.M)
+        if len(pins) != 1 or git(repo, "cat-file", "-t", pins[0]).strip() != b"commit":
+            return unavailable
+        library = git(repo, "ls-tree", identity["head"], "--", LIBRARY_PATH).decode().split()
+        if len(library) != 4 or library[:2] != ["040000", "tree"]:
+            return unavailable
+        changed = git(repo, "diff", "--no-ext-diff", "--no-textconv", "--no-renames",
+                      "--name-only", pins[0], identity["head"], "--", LIBRARY_PATH)
+        if changed.strip():
+            return {"status": "unavailable", "reason":
+                    "Declared projection source differs from current canonical library bytes"}
+        return {"status": "ready", "source_revision": pins[0], "declared_in": readme}
+    except (subprocess.CalledProcessError, UnicodeError, ValueError):
+        return unavailable
+
+
 def prepare(repo, mapping_path, identity, output, *, provider=None, planning_blocked=None):
     # Read only trusted configuration and raw Git objects, never PR Python or graders.
     for key in ("base", "head", "version"):
@@ -84,9 +132,8 @@ def prepare(repo, mapping_path, identity, output, *, provider=None, planning_blo
     output.mkdir(parents=True, exist_ok=False)
     coverage, selected = [], set()
     for change in changes:
-        matches = [item for item in mapping["skills"] if any(
-            change["path"] == path or change["path"].startswith(path.rstrip("/") + "/")
-            for path in item["paths"])]
+        matches = [item for item in mapping["skills"]
+                   if matches_path(change["path"], item["paths"])]
         status = "uncovered"
         if matches:
             status = "unsupported" if change["status"] not in ("A", "M") else "covered"
@@ -101,12 +148,22 @@ def prepare(repo, mapping_path, identity, output, *, provider=None, planning_blo
         # safe-ID rule here, before building any output path from it.
         if not re.fullmatch(r"[a-z0-9][a-z0-9._-]*", item["skill"]):
             raise ValueError("Unsafe skill ID in the PR case mapping")
+        selection = {"basis": "trusted_path_mapping", "adapter": item.get("adapter", "audit"),
+                     "matched_paths": [c["path"] for c in changes
+                                       if matches_path(c["path"], item["paths"])]}
+        try:
+            selection["tasks"] = task_context(
+                compare.read_json(mapping_path.parent / item["cases"]))
+        except (OSError, ValueError):
+            selection["tasks"] = []
+        selected_item = {"skill": item["skill"], "selection": selection}
         if planning_blocked is not None:
-            comparisons.append({"skill": item["skill"],
+            comparisons.append({**selected_item,
                                 "unsupported": "Mapping-only scope; provider unavailable"})
             continue
         entrypoint = mapping["skill_root"] + "/" + item["entrypoint"]
         if not blob_exists(repo, identity["head"], entrypoint):
+            comparisons.append({**selected_item, "unsupported": "Mapped entrypoint is missing"})
             for entry in coverage:
                 if any(entry["path"].startswith(p.rstrip("/") + "/")
                        or entry["path"] == p for p in item["paths"]):
@@ -131,7 +188,7 @@ def prepare(repo, mapping_path, identity, output, *, provider=None, planning_blo
             digest = compare.prepare(config_path, repo, destination)
         except ValueError as error:
             # Unsupported snapshots remain visible; they are never task passes.
-            comparisons.append({"skill": item["skill"], "unsupported": str(error)})
+            comparisons.append({**selected_item, "unsupported": str(error)})
             for entry in coverage:
                 if any(entry["path"] == p or entry["path"].startswith(p.rstrip("/") + "/")
                        for p in item["paths"]):
@@ -140,7 +197,10 @@ def prepare(repo, mapping_path, identity, output, *, provider=None, planning_blo
         finally:
             config_path.unlink()
         plan = compare.load_plan(destination)
-        comparisons.append({"skill": item["skill"], "mode": plan["mode"],
+        selection["tasks"] = task_context(compare.read_json(destination / "plan/tasks.json"))
+        selection["required_answer_fields"] = compare.read_json(
+            destination / "plan/schema.json").get("required", [])
+        comparisons.append({**selected_item, "mode": plan["mode"],
                             "plan_sha256": digest, "cases": [
                                 {"id": t["id"], "split": t["split"]}
                                 for t in compare.read_json(destination / "plan/tasks.json")],
@@ -150,6 +210,9 @@ def prepare(repo, mapping_path, identity, output, *, provider=None, planning_blo
             "comparisons": comparisons, "model": mapping["model"], "limits": mapping["limits"],
             "estimated_calls": sum(c.get("calls", 0) for c in comparisons),
             "retention_days": RETENTION_DAYS}
+    check = projection_check(repo, identity, changes)
+    if check is not None:
+        plan["projection_check"] = check
     if planning_blocked is not None:
         plan["execution_blocked"] = planning_blocked
         plan["model"] = {"name": "unconfigured", "effort": "not_applicable"}
@@ -481,6 +544,173 @@ def review_guidance(plan, results, *, evidence_state):
             "evidence_state": evidence_state, "plan_sha256": fingerprint(plan)}
 
 
+def public_preparation_reason(reason):
+    """Project known refusal categories, never arbitrary exception/YAML excerpts."""
+    fixed = {
+        "Executable snapshot entries are not supported",
+        "Snapshot symlinks and submodules are not supported",
+        "Snapshot revision must identify a Git commit",
+        "Snapshot skill_root contains no files",
+        "Mapping-only scope; provider unavailable",
+        "Mapped entrypoint is missing",
+        "Unknown configuration field",
+        "Unknown experiment adapter",
+        "Unknown case split",
+        "cases must be nonempty with unique IDs",
+        "case IDs must be safe path components",
+        "schedule exceeds max_task_calls",
+        "Diagnostic comparisons require paired old/new bundles (update mode)",
+        "Selected adapter owns its frozen schema and verifier",
+        "Unsupported execution mode for selected adapter",
+    }
+    if isinstance(reason, str):
+        if reason in fixed:
+            return reason
+        for prefix in ("Invalid skill YAML: ", "Missing declared skill document: ",
+                       "Missing local snapshot blob: ", "Unsafe bundle path: ",
+                       "Symlink resource is not supported: ",
+                       "Resource escapes the skills root: ",
+                       "Resource cycle inside the skills root: ",
+                       "Unsupported input fields at ", "Missing required case fields: "):
+            if reason.startswith(prefix):
+                return prefix.rstrip(": ") + " (detail omitted)"
+        if reason.startswith(
+                "Snapshot preparation requires Git >= 2.45 for --no-lazy-fetch; found "):
+            return "Snapshot preparation requires Git >= 2.45 for --no-lazy-fetch"
+    return "Snapshot/task preparation failed (unrecognized reason; raw detail not projected)"
+
+
+def path_groups(paths):
+    groups = {"Canonical library paths": [], "Generated projection paths": [], "Other paths": []}
+    for path in paths:
+        key = ("Canonical library paths" if matches_path(path, (LIBRARY_PATH,)) else
+               "Generated projection paths" if matches_path(path, (PROJECTION_PATH,)) else
+               "Other paths")
+        groups[key].append(path)
+    return groups
+
+
+def author_actions(plan):
+    """Nonpaid next actions; never synthesize an execution or approval command."""
+    lines = ["**PLANNED: not executed; there are no task outcomes yet.**",
+             "### Author actions (no model calls)",
+             "1. **Bind the checkout.** Run `git rev-parse HEAD`; it must equal "
+             + code(plan["head"]) + ". If it differs, obtain a current plan; "
+             "do not reuse old results."]
+    check = plan.get("projection_check")
+    if isinstance(check, dict):
+        revision = check.get("source_revision")
+        if (check.get("status") == "ready" and isinstance(revision, str)
+                and re.fullmatch(SHA, revision)):
+            lines += ["2. **Check source/index consistency.** At that PR checkout, using the "
+                      "reviewed repository tool and its documented development dependencies, run:",
+                      "```bash", "python tools/build_skill_index.py --source-revision "
+                      + revision + " --check", "```",
+                      "The declared source pin matches this head's canonical library bytes. "
+                      "The command has **not run**: retain its exit code and full "
+                      "drift/success output. "
+                      "It checks the generated projection, not claim truth or skill efficacy."]
+        else:
+            lines += ["2. **Resolve the index source pin before checking.** "
+                      + safe_text(check.get("reason")) + ". Identify the committed source matching "
+                      "the canonical inputs and record why it applies; do not substitute HEAD "
+                      "or label the projection verified."]
+    else:
+        lines += ["2. **Choose an applicable check.** Match each changed behavior to the task "
+                  "below or a source/content check; a path match alone does not establish "
+                  "relevance."]
+    supported = [c for c in plan["comparisons"] if "plan_sha256" in c]
+    if not supported:
+        lines += ["**No supported automatic comparison is selected.** Review the canonical changes "
+                  "and explain which claims need evidence, are unaffected, or remain unverified; "
+                  "do not treat generated records as separate behavioral claims."]
+    for item in plan["comparisons"][:3]:
+        lines += ["- **" + code(item["skill"]) + "**"]
+        selection = item.get("selection", {})
+        matched = selection.get("matched_paths", [])
+        if matched:
+            lines += ["  Selected by the trusted path mapping: "
+                      + "; ".join(code(p) if len(p) <= 128 else safe_text(p, 180)
+                                  for p in matched[:2])
+                      + (f" (+{len(matched) - 2} more in the plan)." if len(matched) > 2 else ".")]
+        tasks = selection.get("tasks", [])
+        for task in tasks[:2] if "unsupported" not in item else []:
+            lines += ["  Task " + code(task.get("id")) + ": "
+                      + safe_text(task.get("request"), 300)]
+            scope = [safe_text(task[key], 200) for key in ("evidence_scope", "provenance")
+                     if key in task]
+            if scope:
+                lines += ["  Scope: " + "; ".join(scope)]
+        if not tasks:
+            lines += ["  Task metadata was not retained; inspect frozen tasks before "
+                      "deciding relevance."]
+        if "unsupported" in item:
+            lines += ["  **Unsupported:** "
+                      + safe_text(public_preparation_reason(item["unsupported"]), 240)
+                      + ". No snapshot prepared; task metadata is in details. "
+                      "Do not relax snapshot safety."]
+        else:
+            fields = selection.get("required_answer_fields", [])
+            if fields:
+                lines += ["  Required answer fields: "
+                          + ", ".join(code(field) for field in fields[:12]) + "."]
+            lines += ["  Independent check: frozen " + code(selection.get("adapter", "unspecified"))
+                      + " grader/schema bound in details. Confirm it tests the changed claim, "
+                      "not merely the touched path."]
+    if len(plan["comparisons"]) > 3:
+        lines += ["Additional mappings and all task metadata are retained in the plan details."]
+    # Only successful preparation and safe IDs yield concrete read-only inspection commands.
+    safe = [c for c in supported if re.fullmatch(r"[a-z0-9][a-z0-9._-]*", c["skill"])]
+    if safe:
+        skill = safe[0]["skill"]
+        lines += ["From the downloaded **skill-eval-plan** artifact directory, inspect the first "
+                  "prepared task and its required answer schema (read-only; **not grading**):",
+                  "```bash", f"python -m json.tool {skill}/plan/tasks.json",
+                  f"python -m json.tool {skill}/plan/schema.json", "```"]
+    groups = path_groups([c["path"] for c in plan["coverage"] if c["coverage"] != "covered"])
+    lines += ["Uncovered scope by location: " + "; ".join(
+        f"{name}: {len(paths)}" for name, paths in groups.items())
+        + ". Path counts are not claim counts; no metadata-only conclusion is inferred.",
+        "3. **Return evidence for independent review:** head, check/task/source pin, command, "
+        "environment, exit status, outputs/failures and untested claims. Label scripted controls. "
+        "Request each claim's disposition: verified, refuted or unverified; this plan proves "
+        "neither model provenance nor benefit."]
+    repository, version = plan.get("repository", ""), plan.get("version", "")
+    if (re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", repository)
+            and re.fullmatch(SHA, version)):
+        base = f"https://github.com/{repository}/blob/{version}/docs/"
+        lines += ["[Check recipes and evidence limits](" + base
+                  + "skill-eval-pr.md#nonpaid-author-handoff)"]
+    steps = lines[2:]
+    prepared = len(supported)
+    gaps = [c for c in plan["coverage"] if c["coverage"] != "covered"]
+    intro = [lines[0], "No approval, model efficacy or current-head test result is implied.",
+             "- **Next:** " + ("run the pinned source/index `--check` below at head "
+                 if isinstance(check, dict) and check.get("status") == "ready" else
+                 "resolve check applicability at head ") + code(plan["head"]) + "."]
+    blockers = [safe_text(public_preparation_reason(c["unsupported"]), 160)
+                for c in plan["comparisons"] if "unsupported" in c]
+    if isinstance(check, dict) and check.get("status") != "ready":
+        blockers.append(safe_text(check.get("reason"), 160))
+    if blockers:
+        intro += ["- **Blockers:** " + "; ".join(dict.fromkeys(blockers[:3]))
+                  + ". No unsafe fallback; details below."]
+    else:
+        intro += ["- **Task selection:** " + ("confirm the prepared task tests the changed claim."
+                  if prepared else "no supported automatic comparison; choose a relevant source/"
+                  "content check and disposition uncovered claims.")]
+    intro += [f"- Selected comparisons: **{prepared}** · Estimated task calls: "
+              f"**{plan['estimated_calls']}**. Uncovered/unsupported changes: **{len(gaps)}**; "
+              + "; ".join(f"{name}: {len(paths)}" for name, paths in groups.items())
+              + ". These are paths, not independent claims.",
+              "- **Return:** command, input/source pin, exit status, outputs/failures and "
+              "untested claims for independent verified/refuted/unverified disposition.",
+              "", "<details>",
+              "<summary>Author verification steps (nonpaid; not yet run)</summary>",
+              "", *steps, "", "</details>", ""]
+    return intro
+
+
 def summary(plan, results, evidence_url, expires_at, now, *, evidence_state=None,
             execution_control=None):
     expired = now >= expires_at
@@ -489,17 +719,19 @@ def summary(plan, results, evidence_url, expires_at, now, *, evidence_state=None
     guidance = review_guidance(plan, results, evidence_state=evidence_state)
     lines = [MARKER, "## Skill evaluation"]
     lines += comparison_lines(plan, results, evidence_state)
-    if plan.get("execution_blocked"):
+    planned = evidence_state == "planned / unexecuted" and not results
+    if planned:
+        lines += author_actions(plan)
+    if plan.get("execution_blocked") and not planned:
         lines += ["", "Paid execution blocked: " + safe_text(plan["execution_blocked"]) + ". "
                   "New execution only: this does not invalidate available retained results; "
                   "no alternate provider/model is selected."]
-    if execution_control is not None:
-        lines += ["", "Automatic execution / cumulative PR budget: `"
-                  + canonical(execution_control) + "`", ""]
-    lines += ["### Advisory: " + guidance["disposition"],
-              "Retained evidence availability: **" + evidence_state + "**. "
-              "No approval or merge authorization is issued."]
-    lines.extend("- " + safe_text(reason) for reason in guidance["reasons"][:6])
+    advisory = ["### Advisory: " + guidance["disposition"],
+                "Retained evidence availability: **" + evidence_state + "**. "
+                "No approval or merge authorization is issued."]
+    if not planned:
+        lines += advisory
+    lines.extend("- " + safe_text(reason) for reason in guidance["reasons"][:6] if not planned)
     if len(guidance["reasons"]) > 6:
         lines += [f"- {len(guidance['reasons']) - 6} additional reasons in details below."]
     lines += [""]
@@ -515,39 +747,41 @@ def summary(plan, results, evidence_url, expires_at, now, *, evidence_state=None
                 counts[key] += result["counts"][key]
         lines += ["**RETAINED RESULTS**", "", "Outcomes: `" + canonical(counts) + "`",
                   "Discovery is reported separately in retained evidence."]
-    else:
-        counts["missing_pair"] = sum(
-            sum(c["split"] != "discovery" for c in item["cases"]) * plan["limits"]["repeats"]
-            for item in plan["comparisons"] if "plan_sha256" in item)
-        lines += ["**PLANNED: execution is not authorized by knowing this hash.**",
-                  "Outcomes: `" + canonical(counts) + "`",
-                  "Earlier revision results are stale for this plan."]
     gaps = [c for c in plan["coverage"] if c["coverage"] != "covered"]
     selected = sum("plan_sha256" in item for item in plan["comparisons"])
-    lines += ["", f"Selected comparisons: **{selected}** · Estimated task calls: "
-              f"**{plan['estimated_calls']}**.",
-              f"Uncovered/unsupported changes: **{len(gaps)}**. Gaps never count as passes.", "",
-              "Applicable only while these revisions and inputs match the current PR.",
+    limits = ["Applicable only while these revisions and inputs match the current PR.",
               "Paid execution requires trusted label authorization and cumulative PR reservation. "
               "Unknown accounting blocks new paid calls; planning is not execution.",
-              "Pipeline evidence only; offline fixed outputs do not establish skill efficacy.",
-              f"[Evidence and logs]({evidence_url}) · Retention: {RETENTION_DAYS} days.",
-              f"Outcomes are historical; verifiable only before Unix time `{int(expires_at)}` "
+              "Pipeline evidence only; offline fixed outputs do not establish skill efficacy."]
+    if not planned:
+        lines += ["", f"Selected comparisons: **{selected}** · Estimated task calls: "
+                  f"**{plan['estimated_calls']}**.",
+                  f"Uncovered/unsupported changes: **{len(gaps)}**. Gaps never count as passes.",
+                  "", *limits]
+    lines += [f"[Evidence and logs]({evidence_url}) · Retention: {RETENTION_DAYS} days.",
+              f"Retained artifacts are verifiable only before Unix time `{int(expires_at)}` "
               "while the linked artifact is available. Expired evidence is unverified.", "",
               "<details>",
               "<summary>Plan bindings, budget, frozen exam and advisory details</summary>", "",
+              *(advisory + limits if planned else []),
+              *(["Paid execution blocked: " + safe_text(plan["execution_blocked"]) + ". "
+                  "New execution only: this does not invalidate available retained results; "
+                  "no alternate provider/model is selected."]
+                 if planned and plan.get("execution_blocked") else []),
               "Unchanged-correct is valid neutral evidence, not incremental benefit.",
               "Content/source review and authorship admission remain separate.",
               "Trusted regrading checks retained answers, not model/hardware provenance or "
               "a hostile executor; this is not an efficacy certification.",
-              *["- " + safe_text(reason) for reason in guidance["reasons"][6:26]],
-              "", "Per-case outcomes (discovery excluded; regressions and gaps first):",
-              "```json", json_for_code(sorted(guidance["observations"], key=lambda item:
-                  (item["outcome"] not in ("regression", "inconclusive", "missing_pair",
-                                           "unchanged_incorrect"), item["skill"]))[:20]), "```",
-              f"Showing at most 20 of {len(guidance['observations'])} pairs; "
-              "the evidence link contains all outcomes, including omitted regressions/gaps.",
-              "",
+              *["- " + safe_text(reason) for reason in
+                (guidance["reasons"][:26] if planned else guidance["reasons"][6:26])],
+              *([] if planned else [
+                  "", "Per-case outcomes (discovery excluded; regressions and gaps first):",
+                  "```json", json_for_code(sorted(guidance["observations"], key=lambda item:
+                      (item["outcome"] not in ("regression", "inconclusive", "missing_pair",
+                                               "unchanged_incorrect"), item["skill"]))[:20]), "```",
+                  f"Showing at most 20 of {len(guidance['observations'])} pairs; "
+                  "The evidence link contains all outcomes, including omitted regressions/gaps.",
+                  ""]),
               *[line for line in evidence_binding_lines(plan, results, evidence_state)],
               f"Plan SHA-256: `{fingerprint(plan)}`",
               f"Base: `{plan['base']}` · Head: `{plan['head']}`",
@@ -564,7 +798,18 @@ def summary(plan, results, evidence_url, expires_at, now, *, evidence_state=None
                          f"{item['calls']} |")
             lines.append("\nFrozen exam hashes: `" + canonical(item["exam"]) + "`\n")
         else:
-            lines.append(f"| {code(item['skill'])} | unsupported snapshot | — | 0 |")
+            lines.append(f"| {code(item['skill'])} | unsupported snapshot: "
+                         + safe_text(public_preparation_reason(item.get("unsupported")))
+                         + " | — | 0 |")
+        if "selection" in item:
+            lines += ["", "Selection/task metadata (not a relevance verdict):", "```json",
+                      json_for_code(item["selection"]), "```"]
+    if execution_control is not None:
+        lines += ["", "Automatic execution / cumulative PR budget:", "```json",
+                  json_for_code(execution_control), "```"]
+    if "projection_check" in plan:
+        lines += ["", "Projection check selection (not an executed result):", "```json",
+                  json_for_code(plan["projection_check"]), "```"]
     if "provider_config" in plan:
         lines += ["", "Provider/settings: `" + canonical(plan["provider_config"]) + "`"]
     lines += ["", "</details>", "", "<details>",

From 297835b34d22add47a1a458cdb883f0d67f2c939 Mon Sep 17 00:00:00 2001
From: Dong1017 <55723162+Dong1017@users.noreply.github.com>
Date: Sat, 31 Oct 2026 22:49:28 +0800
Subject: [PATCH 2/2] fix: stabilize PR planning source-pin metadata across
 jobs

Align plan and publish history and restrict automatic source-pin selection to the frozen head ancestor closure. Preserve evidence and execution gates.

Signed-off-by: Codex <codex@openai.com>
---
 .github/workflows/skill-eval-pr.yml       |  2 +
 docs/skill-eval-pr.md                     | 15 ++--
 tests/test_skill_eval_planned_guidance.py | 86 +++++++++++++++++++++++
 tests/test_skill_eval_pr.py               |  5 ++
 tools/skill_eval_pr.py                    | 14 +++-
 5 files changed, 116 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/skill-eval-pr.yml b/.github/workflows/skill-eval-pr.yml
index 85141f066..7eaef43da 100644
--- a/.github/workflows/skill-eval-pr.yml
+++ b/.github/workflows/skill-eval-pr.yml
@@ -72,6 +72,8 @@ jobs:
       - uses: actions/checkout@v4
         with:
           ref: ${{ github.workflow_sha }}
+          # Match publish: declared source pins can predate the PR base.
+          fetch-depth: 0
           persist-credentials: false
       - uses: actions/setup-python@v5
         with:
diff --git a/docs/skill-eval-pr.md b/docs/skill-eval-pr.md
index 09140a172..c331a189e 100644
--- a/docs/skill-eval-pr.md
+++ b/docs/skill-eval-pr.md
@@ -69,13 +69,20 @@ The author and independent reviewer must disposition that relevance explicitly.
 For canonical library or generated-index changes, the planner may show the existing
 `python tools/build_skill_index.py --source-revision <declared-commit> --check`
 with an **actual** immutable pin. It reads the known generated README as bounded
-Git data, requires one declared source commit, and checks that the entire canonical
-library has identical Git bytes/modes at that pin and the PR head. It does not
-execute the generator or establish that generated records are correct. At the
+Git data, requires one declared source commit in the frozen head's ancestor closure,
+and checks that the entire canonical library has identical Git bytes/modes at that
+pin and the PR head. It does not
+execute the generator or establish that generated records are correct. Plan and
+publish both fetch full history before preparing the same fingerprint; a shallow
+boundary must not make a declared ancestor disappear in only one job. At the
 identified PR checkout, with the reviewed tool and documented development/skills
 extras, the author can run that no-model check and retain its exit code plus full
 success/drift output. An absent, unavailable or mismatched pin yields an explicit
-source-selection action instead; HEAD is never silently substituted. A successful
+source-selection action instead; HEAD is never silently substituted. Non-ancestor
+pins are also withheld from this automatic command selection, whether locally cached
+or missing. This is an advisory availability limit, not a failed check, invalid
+source claim or change to the indexer's accepted inputs; authors can explicitly
+review an independently chosen source pin. A successful
 index check establishes projection consistency, not source-claim truth, behavior,
 hardware compatibility or skill benefit.
 
diff --git a/tests/test_skill_eval_planned_guidance.py b/tests/test_skill_eval_planned_guidance.py
index bd0a11144..72529290c 100644
--- a/tests/test_skill_eval_planned_guidance.py
+++ b/tests/test_skill_eval_planned_guidance.py
@@ -2,6 +2,7 @@
 
 import copy
 import json
+import subprocess
 from unittest.mock import Mock
 
 import pytest
@@ -204,3 +205,88 @@ def test_reachable_malformed_skill_yaml_retains_raw_reason_but_projects_only_cat
     text = render(plan)
     assert "Invalid skill YAML" in visible(text) and "SECRET-CANARY" not in text
     assert (output / "pr-plan.json").read_bytes() == original
+
+
+
+def test_plan_and_publisher_full_history_keep_projection_fingerprint_identical(tmp_path):
+    # Actual local Git transport, not a stubbed metadata/availability response.
+    # No candidate checkout/import, model invocation, external network or credentials.
+    repo, readme, _, pin, _, _ = index_fixture(tmp_path)
+    base = git(repo, "rev-parse", "HEAD")
+    readme.write_text(readme.read_text() + "\nSynthetic PR projection change.\n")
+    git(repo, "add", ".")
+    git(repo, "commit", "--quiet", "-m", "Synthetic PR head after shallow base")
+    head = git(repo, "rev-parse", "HEAD")
+    remote = tmp_path / "remote.git"
+    git(tmp_path, "clone", "--quiet", "--bare", str(repo), str(remote))
+    git(remote, "update-ref", "refs/heads/main", base)
+    git(remote, "update-ref", "refs/pull/7/head", head)
+    git(remote, "symbolic-ref", "HEAD", "refs/heads/main")
+    shallow, publisher = tmp_path / "shallow", tmp_path / "publisher"
+    for destination, depth in ((shallow, ["--depth", "1"]), (publisher, [])):
+        git(tmp_path, "clone", "--quiet", "--no-checkout", "--branch", "main", *depth,
+            remote.as_uri(), str(destination))
+        # Same explicit base + PR ref fetch as the existing workflow entrypoint.
+        git(destination, "fetch", "--no-tags", "--no-recurse-submodules", remote.as_uri(),
+            base, "refs/pull/7/head")
+    assert git(shallow, "rev-parse", "--is-shallow-repository") == "true"
+    assert git(publisher, "rev-parse", "--is-shallow-repository") == "false"
+    mapping = tmp_path / "mapping.json"
+    write_json(mapping, {"skills": [], "skill_root": pr.LIBRARY_PATH,
+                        "model": {"name": "offline-fixture", "effort": "test"},
+                        "limits": {"repeats": 1, "max_task_calls": 2, "timeout_seconds": 60,
+                                   "campaign_seconds": 600, "token_stop_new_trials": 1000}})
+    identity = {"repository": "example/fixture", "pr": 7, "base": base,
+                "head": head, "version": base}
+    old = pr.prepare(shallow, mapping, identity, tmp_path / "old-shallow-plan")
+    published = pr.prepare(publisher, mapping, identity, tmp_path / "full-publisher-plan")
+    assert old["projection_check"]["status"] == "unavailable"
+    assert published["projection_check"] == {"status": "ready", "source_revision": pin,
+                                            "declared_in": pr.PROJECTION_PATH + "/README.md"}
+    assert pr.fingerprint(old) != pr.fingerprint(published)  # Reproduces the native finding.
+    git(shallow, "fetch", "--unshallow", "--no-tags", "--no-recurse-submodules", remote.as_uri())
+    repaired = pr.prepare(shallow, mapping, identity, tmp_path / "full-plan")
+    assert repaired == published and pr.fingerprint(repaired) == pr.fingerprint(published)
+    assert not repaired["comparisons"] and repaired["estimated_calls"] == 0
+
+
+
+def test_unrelated_source_ref_presence_cannot_change_full_history_plan(tmp_path):
+    repo, readme, _, _, _, _ = index_fixture(tmp_path)
+    tree = git(repo, "rev-parse", "HEAD^{tree}")
+    unrelated = git(repo, "commit-tree", tree, "-m", "Synthetic unrelated source with same library")
+    readme.write_text(f"Source snapshot: [{unrelated}](https://github.com/example/fixture/tree/"
+                      f"{unrelated}/{pr.LIBRARY_PATH}).\n")
+    git(repo, "add", ".")
+    git(repo, "commit", "--quiet", "-m", "Synthetic nonancestor declaration")
+    head = git(repo, "rev-parse", "HEAD")
+    remote = tmp_path / "remote.git"
+    git(tmp_path, "clone", "--quiet", "--bare", str(repo), str(remote))
+    # The orphan object is not copied merely by naming its SHA in README.
+    git(repo, "update-ref", "refs/heads/source-only", unrelated)
+    git(remote, "fetch", str(repo), "refs/heads/source-only:refs/heads/source-only")
+    git(remote, "update-ref", "refs/heads/main", head)
+    git(remote, "symbolic-ref", "HEAD", "refs/heads/main")
+    cached, absent = tmp_path / "cached", tmp_path / "absent"
+    git(tmp_path, "clone", "--quiet", "--no-checkout", remote.as_uri(), str(cached))
+    git(remote, "update-ref", "-d", "refs/heads/source-only")
+    git(tmp_path, "clone", "--quiet", "--no-checkout", remote.as_uri(), str(absent))
+    assert git(cached, "cat-file", "-t", unrelated) == "commit"
+    missing = subprocess.run(["git", "cat-file", "-e", unrelated], cwd=absent,
+                             capture_output=True, check=False)
+    assert missing.returncode != 0
+    mapping = tmp_path / "mapping.json"
+    write_json(mapping, {"skills": [], "skill_root": pr.LIBRARY_PATH,
+                        "model": {"name": "offline-fixture", "effort": "test"},
+                        "limits": {"repeats": 1, "max_task_calls": 2, "timeout_seconds": 60,
+                                   "campaign_seconds": 600, "token_stop_new_trials": 1000}})
+    identity = {"repository": "example/fixture", "pr": 7, "base": git(repo, "rev-parse", "HEAD^"),
+                "head": head, "version": head}
+    plans = []
+    for index, clone in enumerate((cached, absent)):
+        assert git(clone, "rev-parse", "--is-shallow-repository") == "false"
+        plans.append(pr.prepare(clone, mapping, identity, tmp_path / f"plan-{index}"))
+    assert plans[0] == plans[1] and pr.fingerprint(plans[0]) == pr.fingerprint(plans[1])
+    assert plans[0]["projection_check"]["status"] == "unavailable"
+    assert "source_revision" not in plans[0]["projection_check"]
+    assert "automatic command selection" in plans[0]["projection_check"]["reason"]
diff --git a/tests/test_skill_eval_pr.py b/tests/test_skill_eval_pr.py
index e939470bb..d6cd20509 100644
--- a/tests/test_skill_eval_pr.py
+++ b/tests/test_skill_eval_pr.py
@@ -483,6 +483,11 @@ def test_workflow_separates_execution_and_publication_credentials():
         checkout = next(step for step in job["steps"] if step.get("uses") == "actions/checkout@v4")
         assert checkout["with"]["persist-credentials"] is False
         assert checkout["with"]["ref"] == "${{ github.workflow_sha }}"
+    # Plan identities must not depend on a source ancestor missing only in one job.
+    for name in ("plan", "publish"):
+        checkout = next(s for s in workflow["jobs"][name]["steps"]
+                        if s.get("uses") == "actions/checkout@v4")
+        assert checkout["with"]["fetch-depth"] == 0
     step = next(s for s in executor["steps"] if "control --output" in s.get("run", ""))
     assert set(step["env"]) == {"GITHUB_TOKEN", "SKILL_EVAL_YIBUAPI_KEY"}
 
diff --git a/tools/skill_eval_pr.py b/tools/skill_eval_pr.py
index 87d475767..5ebe4ef62 100644
--- a/tools/skill_eval_pr.py
+++ b/tools/skill_eval_pr.py
@@ -78,7 +78,8 @@ def projection_check(repo, identity, changes):
     """Identify an applicable existing check from raw Git data, without running it."""
     if not any(matches_path(c["path"], (LIBRARY_PATH, PROJECTION_PATH)) for c in changes):
         return None
-    unavailable = {"status": "unavailable", "reason": "No usable declared projection source pin"}
+    unavailable = {"status": "unavailable", "reason":
+                   "No verified ancestor source pin for automatic command selection"}
     readme = PROJECTION_PATH + "/README.md"
     try:
         # Do not follow a symlink or read executable/oversized PR metadata.
@@ -92,7 +93,16 @@ def projection_check(repo, identity, changes):
                    + re.escape(identity["repository"]) + r"/tree/\1/"
                    + re.escape(LIBRARY_PATH) + r"\)\.$")
         pins = re.findall(pattern, text, flags=re.M)
-        if len(pins) != 1 or git(repo, "cat-file", "-t", pins[0]).strip() != b"commit":
+        if len(pins) != 1:
+            return unavailable
+        # Only the frozen head's full ancestor closure is stable across jobs.
+        # An unrelated locally cached object must not change the plan fingerprint.
+        ancestor = subprocess.run(
+            [*compare.GIT_READ, "merge-base", "--is-ancestor", pins[0], identity["head"]],
+            cwd=repo, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
+        if ancestor.returncode != 0:
+            return unavailable
+        if git(repo, "cat-file", "-t", pins[0]).strip() != b"commit":
             return unavailable
         library = git(repo, "ls-tree", identity["head"], "--", LIBRARY_PATH).decode().split()
         if len(library) != 4 or library[:2] != ["040000", "tree"]: