fix(integrate_patch): end a patch set the tree already holds as already_present

[okorzh-amd]

• Description: what and why
  integrate_patch benchmarked candidates the framework tree already held. Both apply channels can already tell that a patch is fully present (a clean git apply -R --check, or patch -R --fuzz=0 --dry-run with no offset), but they reported that as an ordinary success. A patch set in which every patch was already present therefore went on to restart the server and run the benchmark, and an upstream PR that was already merged into the tree was graded as if it were new. On the git channel the check was also reached too late: a git apply -3 of a patch the tree already holds succeeds without changing anything, so a diff that carries blob ids never reached the reverse check at all. OUTCOME_ALREADY_PRESENT existed in the KB writeback, but nothing wrote it.

  Once "present" ends a candidate without a benchmark, a false "present" costs more than it did when it only benchmarked an unchanged tree. Two such cases are closed here:

  • The reverse probes tried every strip level. Undoing a deletion only needs the file to be absent, so a deletion-only patch whose target had drifted reverse-checked cleanly at a level where the stripped path names nothing (a/mod/x.py at -p0).
  • An empty checkout-head diff (merge-base..head) shows only that the PR head is in the live history. A PR that was merged and then reverted keeps its head in the history, while its change is gone from the tree.

  What changes:

  • The per-patch apply helpers return a named PatchApplyResult (ok, error, backups, feedback, present_by) in place of their 3- and 4-tuples. present_by names the check that found the patch present, as a PresenceCheck member. Every caller is migrated, including warm-patch replay, which now reads present_by instead of inferring "already present" from an empty backup list.
  • The git channel runs the reverse check before the -3 retry.
  • Both reverse probes accept a strip level only where some file the patch names resolves in the tree. When no level resolves any (a deletion that was already carried out), every level counts as before. The per-level path rule (path_resolves_at) is extracted from patch_targets_missing, which now uses it too, so the preflight and the probe resolve paths the same way.
  • The apply loop moves out of _stage_apply into apply_patch_set, which returns a PatchSetOutcome. It lives in the new _patch_set_apply.py, together with the git-channel apply helpers it calls, which moved out of integrate_patch.py. A satisfied no-op inside a set that changes the tree still lands with the set, as before.
  • When every patch is already present and the round changes nothing else (no server args, envs, artifacts, setup commands or acquired runtime), the executor returns status: already_present with the per-patch evidence and does not benchmark. It writes an already_present row through the existing framework-KB writeback.
  • An empty checkout-head diff is no longer proof on its own:
    • With a diff_url, the candidate falls back to it as before, and the apply's reverse check decides: a merged PR ends already_present, a reverted one is applied and benchmarked.
    • Without one, the candidate ends already_present only when the working tree matches the PR head on every path in its changed_files, each of which must exist at the head. Otherwise it reports fetch_failed as before.
  • Consumers that enumerate terminal statuses:
    • The Critic priors now include already_present.
    • The phase outcome summary counts it as tested, because it reached the apply stage.
    • The processed-candidate keys already cover every terminal row, so they are unchanged.
    • The semantic_status mapping in the empty-authoring recorder read a field that nothing has written since the per-candidate audit was retired. It is deleted, so that path stamps author_empty, which is the status it already produced in practice.
  • The comment claiming that discovery dedups on the KB ledger was false: the ledger's only reader is the config-lever accuracy check. The comment is corrected.
  • Operator docs are updated: SKILL.md, docs/conceptual/optimization-loop.md and the integrate_patch action playbook.

• Linked issue(s): none

• Tests: added and updated. (what to test; if a test was replaced, where its assertions live now)

  • New entry-point tests in orchestrator/actions/executors/tests/test_patch_already_applied_unit.py, each running the executor against a temporary git repo:
    • An all-no-op patch set, parametrized over the upstream_pr and specialist_authored lanes, ends already_present with per-patch evidence. The benchmark is never invoked, HEAD and the working tree are untouched, and exactly one KB row with outcome already_present is written under a temporary INFERENCE_OPTIMIZER_FA_KB_PATH.
    • The same all-no-op set with extra_server_args reaches the benchmark and writes no already_present row.
    • A PR head merged with a merge commit:
      • Without a diff_url, it ends already_present (pr_head_files_in_tree) without a fetch and writes the KB row.
      • With a diff_url, it falls back to the diff and ends already_present through the reverse check.
    • The same PR head after git revert -m 1 reaches the benchmark and writes no already_present row.
    • A set where the no-op rides with a real change still lands both patches.
  • Channel tests in the same file, parametrized over the git and patch channels:
    • apply_patch_set on a tree that holds every patch reports changed_nothing.
    • A deletion-only patch whose target drifted is a failure with feedback, not present.
    • A deletion-only patch whose file is already gone is present.
  • The git channel reports a committed patch present instead of three-way merging it, and apply_patch_set keeps one subset no-op in the set.
  • The existing subset-no-op tests in that file are kept and now also assert present_by.
  • test_patch_source_pr.py pins the checkout-head mapping through materialize_candidate_patches, on a repo whose PR head is merged with a merge commit:
    • A merged head whose changed_files match ends already_present.
    • A reverted head reports fetch_failed, not already_present.
    • A changed_files path that does not exist at the head proves nothing.
    • With a diff_url, an empty head diff falls back to the diff.
  • The scripted empty-diff test in test_framework_agent_selection_audit.py keeps its base assertion: an empty diff with nothing to confirm it is a failure.
  • Tuple-unpacking call sites in test_nogit_patch_unit.py, test_integrate_patch_executor.py, test_delivery_channels.py and test_integrate_patch_helpers_unit.py are migrated to the named result. The 4-tuple shape assertions are replaced by field assertions.
  • The two semantic_status tests become one test that carries the idempotency assertion over, with author_empty. Fixtures that only set semantic_status are dropped.
  • Each new test was checked against a mutation: it fails when the reverse probe tries every level again, when the already-carried-out deletion no longer falls back to every level, when an empty head diff is taken as proof on its own, or when the all-no-op rule ignores the round's other changes.
  • Commands run:
    • ruff check and ruff format --check on the changed files: pass.
    • lint-imports: 7 contracts kept.
    • python scripts/code_metrics.py --base-ref origin/main: PASSED (11 baseline entries lowered and 2 removed in this change).
    • pre-commit run --files <changed files>: codespell, reuse, gitleaks, import-linter and the CLI-reference hooks pass. The ruff (legacy alias) hook fails on any file on main (its config passes --force-exclude twice), and bandit reports the same Low findings per file as main.
    • pytest on the touched test modules (orchestrator/actions/executors/tests, orchestrator/delivery/tests, orchestrator/enablement/tests and the touched inference_optimizer/tests modules): 3 failures, which fail the same way on main (two need TraceLens, one is in test_setup_script.py).
    • pytest src/hyperloom/orchestrator src/hyperloom/inference_optimizer: the failures need TraceLens, rocprof-compute or multi-node tooling that is not installed locally, and they match main. The exception is test_aiperf_client_sh.py, a timing-sensitive suite that loads none of the changed modules. Its failing cases differ between runs on both trees: serially 3 on the branch and 1 on main, and a different set on each under -n 16.

• Size/complexity triggers crossed: split, or why the shape is right:

  • No new unit is over a limit. The largest new function has a cyclomatic complexity of 9; the new presence helpers are at 2 to 3.
  • IntegratePatchExecutor._stage_apply goes down from cyclomatic 55 to 47, cognitive 140 to 119, and 538 to 495 lines.
  • patch_targets_missing goes down from cyclomatic 9 to 3.
  • integrate_patch.py goes from 4915 to 4780 lines.
  • materialize_candidate_patches goes from 96 to 82 lines.
  • _stage_resolve_upstream_pr and _git_apply_collect_feedback drop under 80 lines.
  • patch_safety.py grows by 6 lines to 1091, over the 800-line warning and under the 1200-line limit, as it already was.

• If this simplifies or refactors: which mechanism was removed, which contract was preserved, and the tests that show it:

  • Removed:
    • The positional tuple results of _apply_patch_no_git, _git_apply_collect_feedback and _materialize_pr_diff_from_head.
    • The empty-backups heuristic for "already present" in warm-patch replay.
    • The dead semantic_status branch.
    • The integrate_patch re-export of _apply_patch_no_git, which no longer has a consumer there.
    • The inline per-level path loop in patch_targets_missing, now path_resolves_at.
  • Preserved, as shown by test_patch_already_applied_unit.py, test_nogit_patch_unit.py, test_integrate_patch_executor.py and test_specialist_patch_safety_unit.py:
    • The apply-failure result shape and its retry_feedback.
    • The vetting of unvetted patches before any apply.
    • Subset-no-op tolerance inside a set, including a deletion that an earlier patch in the set already made.
    • Which patch targets the preflight reports missing.

• Observable effect: what an operator will now see, and what the old behaviour cost them (if none, why the change is unobservable):

  • A candidate whose every patch is already in the framework tree now ends integrate_patch with status: already_present. The result carries an already_present list of {patch, check} rows, or one {diff_range, check} row for a merged PR head confirmed against its changed files. The FRAMEWORK progress row has status already_present, and the framework KB lessons.jsonl gets a row with outcome: already_present.
  • No server restart or benchmark runs for such a candidate. Before, each one cost a full boot and benchmark and came back as a misleading kept or reverted verdict.
  • A PR whose head is in the live history but whose change was reverted is still applied and benchmarked when it has a diff_url, and still reports fetch_failed without one, as before. It is never recorded as already_present.
  • A deletion-only patch whose target file has changed now fails to apply, with feedback, instead of passing as a no-op.
  • A patch set that only partly overlaps the tree, or that carries other changes such as args, envs, artifacts or setup, is benchmarked as before.
  • On a git checkout, a fully present patch no longer goes through git apply -3, so the index is no longer touched in that case.
  • In warm-patch replay on a non-git tree, the already_present status now comes from the reverse check. Before, it came from an empty backup list; the two differ only for a patch that touches no file.

• Breaking changes: no. The changed signatures are private helpers whose in-repo callers are all migrated. already_present is a new status value and was already an allowed KB outcome.

• PR addresses single concern: yes. Three things ride with it:

  • The git-channel apply helpers moved with the apply loop, so that integrate_patch.py shrinks; it is over the module-length limit and may only go down.
  • Three misspellings ("applyable", "unparseable") on existing lines of the touched files are fixed, so that the codespell hook passes.
  • In _nogit_patch.py, the existing errors="replace" literal is named as a module constant, because the new read made it a repeated literal under the metrics gate.

• Root cause is upstream (Magpie/TraceLens/GEAK/IntelliKit/AgentKernelArena), ticket filed: no, the cause is in this repo.

[chaojhou]

Thanks @okorzh-amd. No blockers:

• A set ends already_present only when every patch is fully present and nothing errored.
• Both channels' reverse checks fail closed.
• The extracted apply_patch_set matches the old loop.

Two must-fix items:

1. The merged-PR-head exit skips the "round changes nothing else" check.

   • integrate_patch.py:2042-2043 ends the attempt as already_present in _stage_resolve. That is before _stage_apply reads config_changes, extra_server_args, extra_envs, artifacts or the enablement setup. changes_beyond_patches (:2419, :2704) guards only the patch-set exit.
   • Example: an upstream_pr task for a merged PR with no diff_url, which also carries extra_server_args to turn on the PR's opt-in switch. It ends already_present and writes the KB row, and the arg change is never measured. The same candidate with a diff_url is benchmarked.
   • That contradicts SKILL.md ("ends the same way") and the description.
   • Please take this exit only when the params carry no other change, and otherwise return the checkout-head failure as before.

2. The description predates the rebase onto #1858.

   • Main no longer has a git apply -3 retry; #1858 removed it. So three statements describe nothing this PR changes: "runs the reverse check before the -3 retry", "reports a committed patch present instead of three-way merging it" and "no longer goes through git apply -3".
   • The complexity numbers are pre-rebase. At head:
     • _stage_apply is cyclomatic 53→45, cognitive 131→110, and 513→470 lines;
     • integrate_patch.py is 4804→4703 lines;
     • the baseline edits lower 9 entries and remove 1.
   • Please drop the -3 statements and refresh the numbers.

CI has not run yet; the fork workflows are awaiting approval. In a local run, ruff, import-linter and the code-metrics checks pass, and pr-hygiene will warn at 825 production lines.

[github-actions]

Gate job conclusion: success (run) on 510fdddb4b4407670b03b54b2003d080b2fec566, as reported by GitHub.

The report below was uploaded by that run; the conclusion above is the result.

---

Code metrics gate: PASSED

Judged: the 22 files this change touches. Files it does not touch never fail it; anything found there is listed under Outside this change for information.

Dimension	Limit	New	Worse	Baseline out of date	Baseline entries	vs base
Cyclomatic complexity	fails > 20	0	0	0	120	+0
Cognitive complexity	fails > 30	0	0	0	320	+0
Function length (lines)	fails > 80	0	0	0	469	-1
Nested block depth	fails > 5	0	0	0	29	+0
Module length (lines)	warns > 800, fails > 1200	0	0	0	53	+0
Duplicated lines per file	fails > 0	0	0	0	120	+0
Dead code (vulture)	fails > 0	0	0	0	2	+0

Check	Findings	Effect
Comments	0
English only	0
Production code imports test code	0
Repeated literals	0
A1 Private name of another package	0
A8 Flag argument	0
A9 Tuple return	0
A10 Raw vocabulary comparison	0
A11 Hidden global write	0
A12 Pure forwarder	0
A12 Single-implementation abstraction	0

Module length warning: over 800 lines, within the 1200-line failure limit (not failing): 1

Module	Lines	Limit
src/hyperloom/orchestrator/specialists/patch_safety.py	1091	warns > 800

Already over at the base (backlog, not this change's): 3

Unit	Dimension	Base	Now
src/hyperloom/orchestrator/actions/executors/baseline.py:2307 BenchmarkRunExecutor._run_once	Function length (lines)	683	683
src/hyperloom/orchestrator/actions/executors/baseline.py:3369 BenchmarkRunExecutor._run_single_benchmark	Function length (lines)	580	580
src/hyperloom/orchestrator/actions/executors/baseline.py:1	Module length (lines)	4292	4290

50 findings in files this change does not touch

Outside this change (informational): 50

Unit	Dimension	Baseline	Now
src/hyperloom/orchestrator/enablement/recipe/projections.py project_launch_evidence	Cognitive complexity	absent	36
src/hyperloom/orchestrator/state/shared_state.py resolve_graded_comparison	Cognitive complexity	absent	34
src/hyperloom_kb/collect/mapping.py _experience	Cognitive complexity	absent	31
src/hyperloom_kb/schema.py FieldDeclaration.__post_init__	Cognitive complexity	absent	32
src/hyperloom_kb/tests/test_cli.py	Duplicated lines per file	absent	18
src/hyperloom_kb/tests/test_global_identity_and_pull.py	Duplicated lines per file	absent	13
src/hyperloom_kb/tests/test_local_state.py	Duplicated lines per file	absent	18
src/hyperloom_kb/http_service.py RequestHandler._dispatch	Function length (lines)	absent	91
src/hyperloom_kb/sync.py GlobalSync.pull	Function length (lines)	absent	86
src/hyperloom_kb/http_service.py	Module length (lines)	absent	1539
src/kernelforge/cli/forge_loop_command.py	Module length (lines)	absent	1725
src/hyperloom/common/launch_log_evidence.py _server_args_from_log	Cognitive complexity	48	49
src/hyperloom/orchestrator/actions/executors/_geak_sweep.py sweep_via_geak	Cognitive complexity	67	70
src/hyperloom/orchestrator/actions/executors/_grid_runner.py run_grid	Cognitive complexity	222	228
src/hyperloom/orchestrator/actions/executors/explore.py ExploreExecutor.__call__	Cognitive complexity	369	372
src/hyperloom/orchestrator/loop/dispatcher.py DispatcherCollaborator._spawn_fitting_queued	Cognitive complexity	110	111
src/hyperloom/orchestrator/state/_shared_state/render.py _RenderMixin._format_variant_line	Cognitive complexity	36	40
src/hyperloom/common/launch_log_evidence.py _server_args_from_log	Cyclomatic complexity	22	23
src/hyperloom/orchestrator/actions/executors/_workload_envs.py materialize_config_with_envs	Cyclomatic complexity	110	111
src/hyperloom/inference_optimizer/cli/bootstrap.py _seed_shared_state	Function length (lines)	155	157
src/hyperloom/orchestrator/actions/executors/_geak_sweep.py sweep_via_geak	Function length (lines)	217	235
src/hyperloom/orchestrator/actions/executors/_grid_runner.py run_grid	Function length (lines)	1073	1076
src/hyperloom/orchestrator/actions/executors/_workload_envs.py build_agentx_workload_spec	Function length (lines)	113	118
src/hyperloom/orchestrator/actions/executors/_workload_envs.py materialize_config_with_envs	Function length (lines)	922	928
src/hyperloom/orchestrator/actions/executors/explore.py ExploreExecutor.__call__	Function length (lines)	1124	1132

...and 25 more; the job log lists every row.

Verdict computed by the gate scripts in /home/runner/work/_temp/code-metrics-gate, not by this tree's copy.

_{Thresholds and sources: [tool.hyperloom.code_metrics] in pyproject.toml. Tools: complexipy 8.0.1, jscpd 5.4.1, ruff 0.16.2, vulture 2.16.}

[chaojhou]

PR #1845 -- fix(integrate_patch): end a patch set the tree already holds as already_present

What it does: integrate_patch used to restart the server and benchmark candidates whose every patch the framework tree already held, because both apply channels reported "already present" as an ordinary success. The apply helpers now return a named PatchApplyResult carrying which reverse check found the patch present, the apply loop moves into _patch_set_apply.apply_patch_set, and an attempt whose patches are all present (or whose merged PR head matches the tree on its changed files) and that changes nothing else ends already_present with a KB row and no benchmark.

Blocking issues: 1

1. [X2] The PR description still describes a git apply -3 path that exists at neither base nor head, and its complexity numbers are stale [verified]
   Problem: The body says "The git channel runs the reverse check before the -3 retry", that it "reports a committed patch present instead of three-way merging it", and that "a fully present patch no longer goes through git apply -3". The git channel, _git_apply_collect_feedback, has no -3 path at base 1a444f6 or at head. The body also gives _stage_apply cyclomatic 55 to 47 and the largest new function at 9; c901.py measures 53 to 41 and 7 at head. src/hyperloom/orchestrator/actions/executors/_patch_set_apply.py:95
   Impact: Reviewers read an index-safety change and complexity figures that this PR does not have.
   Action: Drop the -3 statements, including the one in the opening paragraph, and refresh every figure in the size and complexity list against the current head.

Checked: integrate_patch.py _stage_apply, _materialize_upstream_pr, _RoundProposal.changes_beyond_patches, _end_already_present; _patch_set_apply.py apply_patch_set, _git_apply_collect_feedback; _nogit_patch.py _reverse_probe_levels; _patch_source_pr.py _empty_head_diff, _tree_has_head_files; patch_safety.py path_resolves_at; baseline.py _apply_warm_patches; consumers of already_present in framework/artifacts.py, phases/framework.py, loop/writeback.py; ci.txt | Ran: python ..\pr_tools\hl_fetch.py 1845; git grep for -3/3way at base and head; python ..\pr_tools\c901.py 1a444f6 510fddd on the changed src files; git log/diff --stat fcbcb4a..510fddd; gh run list --commit 510fddd after approving the fork runs (9 workflows success, the 2 label-gated E2E skipped) | Base: 1a444f6 | Head: 510fddd

[chaojhou]

PR #1845 -- fix(integrate_patch): end a patch set the tree already holds as already_present

What it does: integrate_patch restarted the server and benchmarked candidates whose every patch the framework tree already held, because both apply channels reported "already present" as an ordinary success. The apply helpers now return a named PatchApplyResult with present_by, the apply loop moves into _patch_set_apply.apply_patch_set, and an attempt whose patches are all present (or whose merged PR head matches the tree on its changed files) and that changes nothing else ends already_present with a KB row and no benchmark.

Blocking issues: 2

1. [S4] A drifted deletion-only patch in mail format still reads as present, so the round ends already_present while the file is untouched [verified]
   Problem: _reverse_probe_levels falls back to every -p level when parse_patch_manifest raises ValueError. A git format-patch deletion (mail header before the diff) raises there, while the preflight parser reads it (patch_file_targets gives [('a/mod/alpha.py', '/dev/null')], nothing missing). At a level where the stripped path is absent, the reverse check of the deletion passes. src/hyperloom/orchestrator/actions/executors/_nogit_patch.py:112
   Impact: on a scratch repo whose mod/alpha.py drifted from the patch's pre-image, _git_apply_collect_feedback returns ok=True, present_by=GIT_REVERSE_APPLY and the file is left as it was, so apply_patch_set reports changed_nothing and the round writes an already_present KB row for a change the tree does not have. This is the false positive the anchoring in this PR closes, reopened for mail-format input; the description says such a patch "now fails to apply".
   Action: take the probe's paths from the parser the preflight already uses (patch_file_targets) and delete the ValueError branch; add a mail-format case to the drifted-deletion test.

2. [X2] The description still describes code this PR does not contain, and its figures are stale [verified]
   Problem: unchanged since the last round at this head. It still says "a git apply -3 of a patch the tree already holds ...", "The git channel runs the reverse check before the -3 retry", "reports a committed patch present instead of three-way merging it" and "no longer goes through git apply -3", though neither base nor head has a -3 path; and it still gives _stage_apply "55 to 47, cognitive 140 to 119, 538 to 495", "4915 to 4780" and a largest new function of 9. src/hyperloom/orchestrator/actions/executors/_patch_set_apply.py:111
   Impact: reviewers and the release notes read an index-safety change and figures this PR does not have.
   Action: remove every -3 statement, refresh the figures from the head, and drop "the preflight and the probe resolve paths the same way" (they use different parsers, item 1).

---

Design review (requested by the maintainer; beyond the blocking bar)

The aim of this section is a smaller PR, not more guards: each point says what to delete or merge.

Purpose, route, files. Purpose and route as above. Production: _apply_feedback.py (result types), _nogit_patch.py (anchored probe), the new _patch_set_apply.py (git channel and set loop moved out of integrate_patch.py), integrate_patch.py (_RoundProposal, two exits, _end_already_present), _patch_source_pr.py (head-diff result type, _tree_has_head_files), patch_safety.py (path_resolves_at), baseline.py (warm replay reads present_by), status consumers in artifacts.py and framework.py. Tests: test_patch_already_applied_unit.py, test_patch_source_pr.py, tuple-to-dataclass migrations. Docs: SKILL.md, the integrate_patch playbook, optimization-loop.md.

1. Completeness. The core exit agrees with its consumers: writeback journals already_present as no_promote and the enablement lane counts it as a stall; the description states neither. Apart from item 1, a set whose deletion upstream already made never reaches the probe, because the preflight ends it apply_failed/patch_target_missing; that is fine, say so.

2. Simpler / smaller. The merged-PR-head exit buys nothing at runtime. At base an empty merge-base..head diff without a diff_url already ended fetch_failed with no boot (base _patch_source_pr.py:288, :301); with a diff_url, base and head both fall back to the diff and apply_patch_set now decides. Its only effect is relabelling fetch_failed as already_present, and for that the PR adds PresenceCheck.PR_HEAD_FILES, _tree_has_head_files (which trusts discovery's changed_files and fails once any of them is touched after the merge), _empty_head_diff, PrMaterialization.already_present riding on failure, _materialize_upstream_pr, _RoundProposal, an async _stage_resolve_upstream_pr, and a second "changes beyond patches" decision. My first-round must-fix asked for that guard; dropping the exit is the better fix. Ride-alongs that belong in their own PR: the semantic_status cleanup and its test edits, the comment and codespell fixes.

3. Redundancy and silent failure. "Changes beyond patches" is decided twice from different inputs: integrate_patch.py:2122-2123 uses params["enablement"] as a stand-in for setup and runtime, :2462-2465 uses the measured setup_commands_applied and the attempt runtime. PrMaterialization encodes three states in two fields. _end_already_present writes patches_reverted: [] and also clears attempt.applied; one is enough. The ValueError fallback is item 1; git errors otherwise fail closed.

4. Docs and comments. Besides item 2: _patch_source_pr.py:211-212 says the caller returns the failure as is, but integrate_patch.py:2118-2124 may return already_present instead; SKILL.md, optimization-loop.md and _apply_feedback.py:26 say "every file the PR changes", while the code checks the candidate's changed_files.

5. Tests. Keep: the all-present exit (test_patch_already_applied_unit.py:426), all-present plus server args benchmarks (:609), a no-op riding with a real change (:625), merged PR via diff_url (:559), reverted PR (:593), the drifted deletion (:290), the present_by assertions and the mechanical migrations. Redundant or freezing the current shape: :213 (the -3 story, repeats :178), :230 (duplicates :625 one layer down), :273 (fold into :426 as a non-git parameter), :574 (same decision as :609), :328 (pins the fail-open fallback of item 1), and the PR-head-exit tests :500, :531 and test_patch_source_pr.py:139-200.

Starting from zero. The mechanism is worth having in its core form: the channels already prove presence with a reverse check; surface it as a field, end an all-present round that changes nothing else, write the KB row. That is PatchApplyResult, apply_patch_set (needed for the metrics gate and the import cycle), a probe anchored on the preflight parser, one exit in _stage_apply and _end_already_present -- roughly half of today's production diff, with _patch_source_pr.py and _stage_resolve_upstream_pr left as at base.

Change list, in order of impact:

1. Fix the probe (item 1) and add the mail-format test; delete :328.
2. Delete the merged-PR-head exit: revert _patch_source_pr.py and _stage_resolve_upstream_pr to base, drop PR_HEAD_FILES, _materialize_upstream_pr and _RoundProposal, and name the existing predicate once inside _stage_apply; delete its tests and doc sentences.
3. Trim the tests listed in point 5.
4. Keep one encoding of "nothing applied" in _end_already_present.
5. Move the semantic_status cleanup to its own PR.
6. Rewrite the description (item 2), and state the no_promote journalling, the enablement stall, and that a deletion already made upstream ends patch_target_missing.

Checked: _nogit_patch._reverse_probe_levels, _patch_set_apply._git_apply_collect_feedback / apply_patch_set, patch_safety.patch_file_targets / path_resolves_at, integrate_patch._materialize_upstream_pr / _stage_apply / _end_already_present and both changes_beyond_patches calls, _patch_source_pr at base and head, the tests named above, the description against the head | Ran: _git_apply_collect_feedback on a scratch git repo with a drifted mod/alpha.py and a git format-patch deletion (present_by=GIT_REVERSE_APPLY, file unchanged); no test suite | Base: 1a444f6 | Head: 510fddd