From ae18b8db189f777bef159530d5395ebfe024f7b1 Mon Sep 17 00:00:00 2001 From: Wentao Li Date: Sun, 18 Oct 2026 01:49:36 +0000 Subject: [PATCH 1/3] Research: present-head flag 9 hosts basis head only after source drop MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pin matched P104 flag 9 (X4→Y23, head 196) on the published channel: the source drops the head at event 500 and the matched target hosts it only at the terminal transport after-frame at event 3489, so chronological dirty restoration cannot use co-hosted basis-head geometry. No new kappa. Prepared by Wentao Li with substantial AI assistance. --- .../CERTIFICATE.json | 143 +++++++++ .../MASTER-HANDOFF.md | 69 +++++ .../p104-present-head-flag9-audit/NOTICE.md | 8 + .../p104-present-head-flag9-audit/PROOF.md | 57 ++++ .../p104-present-head-flag9-audit/README.md | 46 +++ .../SOURCES.json | 36 +++ .../p104-present-head-flag9-audit/TASK.json | 90 ++++++ .../p104-present-head-flag9-audit/VERIFY.json | 28 ++ .../independent.py | 289 ++++++++++++++++++ .../test_package.py | 143 +++++++++ .../p104-present-head-flag9-audit/verify.py | 280 +++++++++++++++++ 11 files changed, 1189 insertions(+) create mode 100644 research/p104-present-head-flag9-audit/CERTIFICATE.json create mode 100644 research/p104-present-head-flag9-audit/MASTER-HANDOFF.md create mode 100644 research/p104-present-head-flag9-audit/NOTICE.md create mode 100644 research/p104-present-head-flag9-audit/PROOF.md create mode 100644 research/p104-present-head-flag9-audit/README.md create mode 100644 research/p104-present-head-flag9-audit/SOURCES.json create mode 100644 research/p104-present-head-flag9-audit/TASK.json create mode 100644 research/p104-present-head-flag9-audit/VERIFY.json create mode 100644 research/p104-present-head-flag9-audit/independent.py create mode 100644 research/p104-present-head-flag9-audit/test_package.py create mode 100644 research/p104-present-head-flag9-audit/verify.py diff --git a/research/p104-present-head-flag9-audit/CERTIFICATE.json b/research/p104-present-head-flag9-audit/CERTIFICATE.json new file mode 100644 index 0000000000..e41c2ea6a4 --- /dev/null +++ b/research/p104-present-head-flag9-audit/CERTIFICATE.json @@ -0,0 +1,143 @@ +{ + "schema_version": 1, + "claim_id": "p104-present-head-flag9-audit", + "pinned_main": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "flag_index": 9, + "source": 4, + "target": 23, + "basis_head": 196, + "departure_choice": 1, + "arrival_choice": 1, + "basis": [ + 196, + 8, + 3, + 4, + 16, + 96, + 256, + 1, + 32 + ], + "source_register": "X4", + "target_register": "Y23", + "source_initial": [ + 196 + ], + "source_final": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "target_initial": [], + "target_final": [ + 467, + 27, + 196, + 12, + 124, + 3, + 7, + 1 + ], + "source_initial_is_basis_head": true, + "target_final_contains_basis_head": true, + "source_frame_restored": false, + "target_frame_restored": false, + "source_first_event": 500, + "source_last_event": 4009, + "target_first_event": 74, + "target_last_event": 3489, + "source_event_count": 21, + "target_event_count": 13, + "joint_source_target_events": 0, + "basis_head_drop_event": 500, + "basis_head_drop_before": [ + 196 + ], + "basis_head_drop_after": [ + 8, + 64, + 132, + 260 + ], + "basis_head_arrive_event": 3489, + "basis_head_arrive_before": [ + 127, + 192, + 447 + ], + "basis_head_arrive_after": [ + 1, + 3, + 7, + 12, + 27, + 124, + 196, + 467 + ], + "hosting_gap_events": 2989, + "source_annotations_containing_basis_head": 1, + "target_annotations_containing_basis_head": 1, + "target_preterminal_annotations_containing_basis_head": 0, + "source_head_annotations": [ + { + "event": 500, + "opcode": "transport", + "role": "before", + "frame": [ + 196 + ] + } + ], + "target_head_annotations": [ + { + "event": 3489, + "opcode": "transport", + "role": "after", + "frame": [ + 1, + 3, + 7, + 12, + 27, + 124, + 196, + 467 + ] + } + ], + "target_annotated_vectors": [ + 1, + 3, + 7, + 12, + 27, + 124, + 127, + 192, + 196, + 447, + 467 + ], + "basis_head_in_any_target_annotation": true, + "basis_head_in_source_after_drop": false, + "targets_whose_final_contains_basis_head_among_all": 7, + "hit_flags_from_census": [ + 0, + 1, + 9, + 43 + ], + "flag_is_present_head_case": true, + "obstruction": "published_channel_hosts_basis_head_on_matched_target_only_at_terminal_transport_after_source_drop", + "no_new_kappa": true, + "selected_kappa": "0.001672660197076918" +} diff --git a/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md b/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md new file mode 100644 index 0000000000..9065eb3f71 --- /dev/null +++ b/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md @@ -0,0 +1,69 @@ +# Master handoff — `research/p104-present-head-flag9-audit/` + +## Candidate + +- Branch: `cursor/p104-present-head-flag9-60b9` +- Package: `research/p104-present-head-flag9-audit/` +- Base: `6f100d4bb5083f8c35d96fd95a539811c62f245c` +- Card: `p104-side-correction` (refined), priority revision 6 +- κ: unchanged `0.001672660197076918` + +## Claim + +On published matched flag 9 (`X4`→`Y23`, basis head `196`), the channel drops +the head from the source at event 500 and introduces it on the matched target +only at the terminal transport after-frame at event 3489 (gap 2989), with zero +preterminal target hosting, zero joint endpoint events, and unrestored frames — +so chronological dirty restoration cannot use co-hosted basis-head geometry. + +## Closest priors + +- #3349 `p104-channel-touch-restoration-audit` — full restoration census; names + present-head class `(0,1,9,43)`; leaves coefficient/dirty restoration open. +- #3392 `p104-absent-head-flag2-audit` — complementary absent-head obstruction + on flag 2 (leave alone). +- #3363/#3365/#3371/#3372 — algebraic coefficient delivery (flag-0 cascade); + soft-overlap checked; different obligation. +- #3242 — chronology receipt for worked pair X0/Y34. + +## New checkable fact + +Present-head flag 9 has `preterminal_hosting=0`, `drop_event=500`, +`arrive_event=3489`, `hosting_gap_events=2989`. A maintainer can replay without +reopening #3349's census or #3392's absent-head path. + +## Evidence commands + +```sh +python3.12 -I -B research/p104-present-head-flag9-audit/verify.py +python3.12 -I -O -Werror -B research/p104-present-head-flag9-audit/verify.py +python3.12 -I -O -Werror -B research/p104-present-head-flag9-audit/independent.py +python3.12 -I -O -Werror -B research/p104-present-head-flag9-audit/test_package.py +python3.12 -B scripts/research_package.py --package research/p104-present-head-flag9-audit +``` + +Expected markers: + +```text +PASS_P104_PRESENT_HEAD_FLAG9 flag=9 head=196 preterminal_hosting=0 drop_event=500 arrive_event=3489 no_new_kappa +PASS_P104_PRESENT_HEAD_FLAG9_INDEPENDENT flag=9 head=196 preterminal_hosting=0 drop_event=500 arrive_event=3489 no_new_kappa +PASS_P104_PRESENT_HEAD_FLAG9_TESTS groups=6 +PASS_REGISTERED_RESEARCH_PACKAGE research/p104-present-head-flag9-audit outcome=completed +``` + +## Soft-overlap risks + +- Flag-0 cascade (#3363–#3412) stays clear: this package pins flag 9 / Y23 / X4. +- Do not extend to flags 0/1/43 in the same PR without a new fact. +- Do not reopen #3349 restoration census or #3392 flag-2 path. +- Coefficient delivery is deliberately not claimed (already open elsewhere). + +## Open questions + +Can a changed schedule co-host 196 on X4 and Y23 long enough to dirty-restore, +and at what cost? + +## Disposition note for master + +Worker produces fork branch + package only. Do **not** open a CrocSwap PR from +this worker. Master decides publish/defer after independent skeptical review. diff --git a/research/p104-present-head-flag9-audit/NOTICE.md b/research/p104-present-head-flag9-audit/NOTICE.md new file mode 100644 index 0000000000..6ecea2ac48 --- /dev/null +++ b/research/p104-present-head-flag9-audit/NOTICE.md @@ -0,0 +1,8 @@ +# Notice + +This package is a finite annotated-frame audit of one published P104 matched +flag. It does not modify frozen upstream sources. + +Prepared by Wentao Li with substantial AI assistance. +Apache-2.0; predecessor notices and exact source pins are retained in +`SOURCES.json`. diff --git a/research/p104-present-head-flag9-audit/PROOF.md b/research/p104-present-head-flag9-audit/PROOF.md new file mode 100644 index 0000000000..7786b2143f --- /dev/null +++ b/research/p104-present-head-flag9-audit/PROOF.md @@ -0,0 +1,57 @@ +# Proof: present-head flag 9 late-only target hosting + +## Setup + +Pin CrocSwap main `6f100d4bb5083f8c35d96fd95a539811c62f245c`, the #2981 +208-flag matching (`research/p104-joint-unit-flags/CERTIFICATE.json`), and the +reviewed #1991 channel witness +(`research/p104-native-channel/inputs/LOWRANK-WITNESS.json`, 4,058 events). + +A register annotation is a transport before/after frame or an add frame naming +that register. The basis head of a matched flag is the first vector of its +basis. Open #3349 records that the target final contains that head for exactly +the flag indices `(0, 1, 9, 43)`. This note audits index 9. + +## Statement + +Let flag 9 have source `X4`, target `Y23`, and basis head `196`. On the published +word: + +1. `X4` begins at `[196]` and first transports at event 500 from `[196]` to + `[8, 64, 132, 260]`, dropping the head. +2. No later `X4` annotation contains `196`. +3. No `Y23` annotation with event index strictly less than 3489 contains `196`. +4. Event 3489 is the last `Y23` event. It is a transport whose before-frame + excludes `196` and whose after-frame equals the target final and contains + `196`. +5. No event names both `X4` and `Y23`. +6. Neither endpoint frame returns to its initial frame. + +Therefore the published channel hosts the basis head on the matched target only +at the terminal transport after-frame, 2,989 events after the source drop. It +never co-hosts that head on a live source frame and the matched target at the +same chronological cut. Logical dirty restoration of the source singleton line +into `Y23` along co-hosted basis-head geometry is unavailable on this word. + +## Checking method + +Two independent scanners read the same pinned inputs. The primary scanner walks +annotated frames in program order. The second accumulates frozensets per +register. Both reject duplicate JSON keys, enforce source SHA-256 pins, and +admit through `need()` under `python -O`. Their receipts are byte-compared to +the committed certificate. + +## Soft overlap + +Open #3363/#3365/#3371/#3372 record algebraic coefficient delivery for the +channel/relay/Gram/tail path and concentrate worked examples on flag 0. Open +#3392 proves the complementary absent-head obstruction on flag 2. Open #3349 +counts the present-head class but does not pin late-only hosting on flag 9. +This package does not recompute those coefficient identities or re-audit flag 2. + +## Limits + +This is a statement about the published annotated frames of one matched flag. +It does not price a repair, construct a changed schedule, or claim a new κ. +A schedule that co-hosts `196` on `X4` and `Y23` before the source drop is +outside this certificate. diff --git a/research/p104-present-head-flag9-audit/README.md b/research/p104-present-head-flag9-audit/README.md new file mode 100644 index 0000000000..0f216f0e94 --- /dev/null +++ b/research/p104-present-head-flag9-audit/README.md @@ -0,0 +1,46 @@ +# Present-head flag 9: published channel hosts basis head only after source drop + +**Scoped obstruction. No new exponent.** + +Open [#3349](https://github.com/CrocSwap/integer-mult-bounds/pull/3349) shows the +basis head meets the target final on only four of 208 matched flags. Open +[#3392](https://github.com/CrocSwap/integer-mult-bounds/pull/3392) pins one of +the other 204 (absent-head flag 2). This package pins one of those four: +flag 9 (`X4` → `Y23`, basis head `196`). + +On the published 4,058-event word, `X4` starts at `[196]` and drops `196` at +transport event 500. Every annotated `Y23` frame before the terminal transport +avoids `196`. The head appears on `Y23` only in the after-frame of event 3489 — +2,989 events after the source drop. No event names both endpoints, and neither +frame is restored. The published channel therefore cannot chronologically +dirty-restore that source line into the matched target along co-hosted +basis-head geometry, even though the target final contains the head. + +Selected κ stays 0.001672660197076918. Details and limits are in +[PROOF.md](PROOF.md). + +## Reproduce + +```sh +python3.12 -I -B research/p104-present-head-flag9-audit/verify.py +python3.12 -I -O -Werror -B research/p104-present-head-flag9-audit/verify.py +python3.12 -I -O -Werror -B research/p104-present-head-flag9-audit/independent.py +python3.12 -I -O -Werror -B research/p104-present-head-flag9-audit/test_package.py +python3.12 -B scripts/research_package.py --package research/p104-present-head-flag9-audit +``` + +`verify.py` is read-only. Admission goes through `need()` and still fires under +`-O`. + +## Credit + +Credit Nick Petalas / #2981, jwr404 / #3242, #3349 for the 4/208 present-head +census, and #3392 for the complementary absent-head obstruction. Prepared by +Wentao Li with substantial AI assistance. + +## Open next questions + +Can a changed schedule co-host basis head 196 on `X4` and `Y23` long enough to +dirty-restore the source line, and what does that cost against the channel bill? +This package only shows the published annotated word introduces that head on the +matched target after the source has already abandoned it. diff --git a/research/p104-present-head-flag9-audit/SOURCES.json b/research/p104-present-head-flag9-audit/SOURCES.json new file mode 100644 index 0000000000..33cf7b857d --- /dev/null +++ b/research/p104-present-head-flag9-audit/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "upstream": "CrocSwap/integer-mult-bounds", + "files": [ + { + "path": "research/p104-joint-unit-flags/CERTIFICATE.json", + "usage": "input", + "git_blob": "0fa7d2d40566e92f3ea1539723abf438ba65adb8", + "sha256": "a98126428a8da6eae91c50afcc42e014a284c82b554ef77e5b3a34fc6d228128", + "credit": "Nick Petalas, PR #2981" + }, + { + "path": "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "usage": "input", + "git_blob": "86beaf424e9f0f800ae3a62797d94ec9386b7706", + "sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e", + "credit": "Reviewed #1991 native channel witness" + }, + { + "path": "research/p104-endpoint-geometric-budget/geometry.py", + "usage": "input", + "git_blob": "f49752bcfc321a6129186d4daa774b2c3fdb84f1", + "sha256": "1a2792189beaf15aa8180136ca007cd2301992a62e77ba72edea99b298e4148f", + "credit": "X/Y naming lines for the 104 sources and 104 targets" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "pin": "base_commit:docs/research/agent-task-catalog.json", + "credit": "Priority revision 6 task catalogue at the pinned base" + } + ] +} diff --git a/research/p104-present-head-flag9-audit/TASK.json b/research/p104-present-head-flag9-audit/TASK.json new file mode 100644 index 0000000000..071e0b414a --- /dev/null +++ b/research/p104-present-head-flag9-audit/TASK.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 6, + "selected_kappa": "0.001672660197076918", + "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "original_card": { + "id": "p104-side-correction", + "question": "Can the proposed P104 joint endpoint flags be realized by a chronological correction program with coefficients, dirty restoration and an affordable complete bill?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md", + "research/p104-joint-unit-flags/README.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the revision-6 family record and #2981 static joint flags, alongside the reviewed #1991 channel. #2981 is an author-checked source archive, not an independently validated executable correction or a refutation of program-level lifetime floors.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "After checking live handoffs, pin one named collection from #2981 and attach acquisition/delivery times, source dependencies and coefficient requirements. Test legal access and arbitrary dirty restoration; price any completion against the full channel/endpoint/hosting allowance. Stop with the exact missing implication or a scoped counterexample rather than expanding the static cover census.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier.", + "Repeating a correction or physical conversion already supplied by a pending follow-up without adding independent coverage or a different unresolved obligation.", + "Repeating the 208-flag static matching or calling a static nested cover a chronological correction program. Independent audit of that certificate is distinct and remains useful." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991", + "2586", + "endpoint transport", + "physical dual", + "relay composition", + "2981", + "joint unit flags", + "acquisition delivery", + "static nesting" + ], + "existing_checks": [ + { + "scope": "PR #2981 reports static joint endpoint flags and a matching of 208 departure and arrival flags; archival intake is not independent verification.", + "evidence": "research/p104-joint-unit-flags/README.md", + "remaining": "Independent flag check and a chronological coefficient program with dirty restoration and a complete cost.", + "status": "author-checked", + "source_commit": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Pin matched present-head flag 9 from the #2981 certificate and prove that the published #1991 channel hosts its basis head on the matched target only at the terminal transport after-frame, 2989 events after the source drops that head, so chronological dirty restoration cannot use co-hosted basis-head geometry.", + "scope_change_reason": "Open #3349 already registers the full 208-flag frame-restoration census (restored=0; basis head in target final on flags 0,1,9,43 only). Open #3392 pins the complementary absent-head obstruction on flag 2. Open #3363/#3365/#3371/#3372 cover algebraic coefficient delivery for the channel/relay/Gram/tail path, concentrated on flag 0. This package takes the still-open dirty-restoration gap on a present-head flag outside that flag-0 cascade.", + "bottleneck_link": "A present-head final does not by itself host the basis-head direction when the source still carries the singleton line. Flag 9 shows the published channel only introduces that head on the matched target after the source has already abandoned it.", + "budget_minutes": 60, + "stop_rule": "Stop after one present-head flag's late-only hosting obstruction is pinned and dual-scanned. Do not build a correction word, recompute algebraic relays, or survey the other three present-head flags.", + "outcome": "completed", + "evidence": "Flag 9 is source 4, target 23, basis head 196. X4 starts at [196] and drops 196 at transport event 500. Y23's annotated frames never contain 196 until the terminal transport after-frame at event 3489 (gap 2989). No joint X4/Y23 event exists. Neither endpoint frame is restored. Selected kappa is unchanged.", + "author": "Wentao Li", + "ai_assistance": "Substantial AI assistance for derivation, implementation, checking and writing.", + "no_new_kappa": true, + "open_questions": [ + { + "question": "Can a changed schedule co-host basis head 196 on X4 and Y23 long enough to dirty-restore the source line, and what does that cost against the channel bill?", + "why_it_matters": "The published word only places 196 into Y23 after X4 has already dropped it. A repair must name new events or a different frame contract and pay for them.", + "first_step": "Exhibit one finite program fragment that places 196 into Y23 while X4 still carries the source-line value, or prove a stronger model-level barrier across all four present-head flags.", + "blocked_by": "This package only reads the published annotated frames for flag 9. It does not construct a repair or price the other three present-head flags." + } + ] +} diff --git a/research/p104-present-head-flag9-audit/VERIFY.json b/research/p104-present-head-flag9-audit/VERIFY.json new file mode 100644 index 0000000000..7446f17f8d --- /dev/null +++ b/research/p104-present-head-flag9-audit/VERIFY.json @@ -0,0 +1,28 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-joint-unit-flags/CERTIFICATE.json", + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "research/p104-endpoint-geometric-budget/geometry.py" + ], + "commands": [ + { + "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/verify.py"], + "timeout_seconds": 60, + "checks": "Annotated-frame scan of flag 9 present-head late hosting on X4 and Y23" + }, + { + "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/independent.py"], + "timeout_seconds": 60, + "checks": "Set-accumulation scan of the same flag-9 late-hosting obstruction" + }, + { + "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/test_package.py"], + "timeout_seconds": 90, + "checks": "Duplicate JSON keys, temp-copy certificate corruption, optimized admission, scanner agreement" + } + ] +} diff --git a/research/p104-present-head-flag9-audit/independent.py b/research/p104-present-head-flag9-audit/independent.py new file mode 100644 index 0000000000..be721cb41e --- /dev/null +++ b/research/p104-present-head-flag9-audit/independent.py @@ -0,0 +1,289 @@ +#!/usr/bin/env python3 +"""Second flag-9 present-head scanner. It does not import verify.py. + +Frames are accumulated as frozensets per register. Drop and late-arrive +detection use transport before/after sets. Admission uses need() under -O. +""" + +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +MARKER = ( + "PASS_P104_PRESENT_HEAD_FLAG9_INDEPENDENT flag=9 head=196 " + "preterminal_hosting=0 drop_event=500 arrive_event=3489 no_new_kappa" +) +INPUTS = ( + "research/p104-joint-unit-flags/CERTIFICATE.json", + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "research/p104-endpoint-geometric-budget/geometry.py", +) +SOURCE_LINE = "sources = [paths[f'X{s}'] for s in range(104)]" +TARGET_LINE = "targets = [paths[f'Y{t}'] for t in range(104)]" +FLAG_INDEX = 9 +HIT_FLAGS = (0, 1, 9, 43) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def pairs_unique(pairs): + value = {} + for key, item in pairs: + need(key not in value, "duplicate JSON key") + value[key] = item + return value + + +def read_json(path): + raw = Path(path).read_bytes() + need(len(raw) <= 2_000_000, "input exceeds 2 MB") + return json.loads(raw, object_pairs_hook=pairs_unique) + + +def register_name(item): + if type(item) is not str or len(item) < 2 or item[0] not in "XY": + return None + if not item[1:].isdigit() or int(item[1:]) > 103: + return None + return item + + +def frame_set(frame): + need(type(frame) is list, "frame") + values = [] + for entry in frame: + need(type(entry) is int, "frame entry") + values.append(entry) + folded = frozenset(values) + need(len(folded) == len(values), "duplicate frame vector") + return folded + + +def pin_sources(): + manifest = read_json(HERE / "SOURCES.json") + rows = [row for row in manifest["files"] if row["usage"] == "input"] + need(tuple(row["path"] for row in rows) == INPUTS, "input inventory") + pinned = {} + for row in rows: + raw = (ROOT / row["path"]).read_bytes() + need(hashlib.sha256(raw).hexdigest() == row["sha256"], "source hash: " + row["path"]) + pinned[row["path"]] = raw + return pinned + + +def evaluate(): + pinned = pin_sources() + geometry = pinned[ + "research/p104-endpoint-geometric-budget/geometry.py" + ].decode("utf-8") + need(SOURCE_LINE in geometry and TARGET_LINE in geometry, "geometry naming") + helpers = json.loads( + pinned["research/p104-joint-unit-flags/CERTIFICATE.json"], + object_pairs_hook=pairs_unique, + )["helpers"] + witness = json.loads( + pinned["research/p104-native-channel/inputs/LOWRANK-WITNESS.json"], + object_pairs_hook=pairs_unique, + ) + need(len(helpers) == 208 and len(witness["program"]) == 4058, "sizes") + hits = [] + for index, row in enumerate(helpers): + if row["basis"][0] in witness["final_frames"][f"Y{row['target']}"]: + hits.append(index) + need(hits == list(HIT_FLAGS), "hit-flag census drift") + need(FLAG_INDEX in hits, "flag 9 left the present-head class") + helper = helpers[FLAG_INDEX] + head = helper["basis"][0] + source = f"X{helper['source']}" + target = f"Y{helper['target']}" + source_hits = [] + target_hits = [] + source_indices = [] + target_indices = [] + target_pool = set() + joint = 0 + drop = None + drop_before = None + drop_after = None + arrive_before = None + arrive_after = None + for index, event in enumerate(witness["program"]): + names = [register_name(item) for item in event] + names = [name for name in names if name is not None] + if source in names and target in names: + joint += 1 + if source in names: + source_indices.append(index) + if event[0] == "transport" and event[1] == source: + before = frame_set(event[2]) + after = frame_set(event[3]) + if drop is None: + drop = index + drop_before = sorted(before) + drop_after = sorted(after) + if head in before: + source_hits.append( + { + "event": index, + "opcode": "transport", + "role": "before", + "frame": sorted(before), + } + ) + if head in after: + source_hits.append( + { + "event": index, + "opcode": "transport", + "role": "after", + "frame": sorted(after), + } + ) + elif event[0] == "add" and source in (event[1], event[2]): + present = frame_set(event[-1]) + if head in present: + source_hits.append( + { + "event": index, + "opcode": "add", + "role": "add", + "frame": sorted(present), + } + ) + if target in names: + target_indices.append(index) + if event[0] == "transport" and event[1] == target: + before = frame_set(event[2]) + after = frame_set(event[3]) + target_pool.update(before) + target_pool.update(after) + if head in before: + target_hits.append( + { + "event": index, + "opcode": "transport", + "role": "before", + "frame": sorted(before), + } + ) + if head in after: + target_hits.append( + { + "event": index, + "opcode": "transport", + "role": "after", + "frame": sorted(after), + } + ) + elif event[0] == "add" and target in (event[1], event[2]): + present = frame_set(event[-1]) + target_pool.update(present) + if head in present: + target_hits.append( + { + "event": index, + "opcode": "add", + "role": "add", + "frame": sorted(present), + } + ) + need(drop is not None, "missing drop") + need(drop_before == [head], "drop before") + need(head not in drop_after, "drop after") + need(len(target_hits) == 1, "unexpected target head hosting count") + arrive = target_hits[0] + need(arrive["opcode"] == "transport" and arrive["role"] == "after", "arrive shape") + need(arrive["event"] == target_indices[-1], "arrive not terminal") + arrive_event = witness["program"][arrive["event"]] + arrive_before = sorted(frame_set(arrive_event[2])) + arrive_after = sorted(frame_set(arrive_event[3])) + need(head not in arrive_before, "arrive before hosts head") + need(head in arrive_after, "arrive after missing head") + preterminal = [row for row in target_hits if row["event"] < arrive["event"]] + need(preterminal == [], "preterminal target hosting") + after_drop = any( + row["event"] > drop or (row["event"] == drop and row["role"] == "after") + for row in source_hits + ) + hosting_gap = arrive["event"] - drop + source_initial = witness["initial_frames"][source] + source_final = witness["final_frames"][source] + target_initial = witness["initial_frames"][target] + target_final = witness["final_frames"][target] + finals_with_head = sum( + 1 for index in range(104) if head in witness["final_frames"][f"Y{index}"] + ) + receipt = { + "schema_version": 1, + "claim_id": "p104-present-head-flag9-audit", + "pinned_main": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "flag_index": FLAG_INDEX, + "source": helper["source"], + "target": helper["target"], + "basis_head": head, + "departure_choice": helper["departure_choice"], + "arrival_choice": helper["arrival_choice"], + "basis": helper["basis"], + "source_register": source, + "target_register": target, + "source_initial": source_initial, + "source_final": source_final, + "target_initial": target_initial, + "target_final": target_final, + "source_initial_is_basis_head": source_initial == [head], + "target_final_contains_basis_head": head in target_final, + "source_frame_restored": sorted(source_initial) == sorted(source_final), + "target_frame_restored": sorted(target_initial) == sorted(target_final), + "source_first_event": source_indices[0], + "source_last_event": source_indices[-1], + "target_first_event": target_indices[0], + "target_last_event": target_indices[-1], + "source_event_count": len(source_indices), + "target_event_count": len(target_indices), + "joint_source_target_events": joint, + "basis_head_drop_event": drop, + "basis_head_drop_before": drop_before, + "basis_head_drop_after": drop_after, + "basis_head_arrive_event": arrive["event"], + "basis_head_arrive_before": arrive_before, + "basis_head_arrive_after": arrive_after, + "hosting_gap_events": hosting_gap, + "source_annotations_containing_basis_head": len(source_hits), + "target_annotations_containing_basis_head": len(target_hits), + "target_preterminal_annotations_containing_basis_head": len(preterminal), + "source_head_annotations": source_hits, + "target_head_annotations": target_hits, + "target_annotated_vectors": sorted(target_pool), + "basis_head_in_any_target_annotation": head in target_pool, + "basis_head_in_source_after_drop": after_drop, + "targets_whose_final_contains_basis_head_among_all": finals_with_head, + "hit_flags_from_census": list(HIT_FLAGS), + "flag_is_present_head_case": True, + "obstruction": ( + "published_channel_hosts_basis_head_on_matched_target_only_at_" + "terminal_transport_after_source_drop" + ), + "no_new_kappa": True, + "selected_kappa": "0.001672660197076918", + } + need(receipt["target_final_contains_basis_head"] is True, "left present-head class") + need(receipt["target_preterminal_annotations_containing_basis_head"] == 0, "preterminal") + need(receipt["basis_head_in_source_after_drop"] is False, "source retained head") + need(receipt["joint_source_target_events"] == 0, "joint endpoint event") + return receipt + + +def main(): + observed = evaluate() + expected = read_json(HERE / "CERTIFICATE.json") + need(observed == expected, "certificate mismatch") + print(MARKER) + + +if __name__ == "__main__": + main() diff --git a/research/p104-present-head-flag9-audit/test_package.py b/research/p104-present-head-flag9-audit/test_package.py new file mode 100644 index 0000000000..d3d0ffbccc --- /dev/null +++ b/research/p104-present-head-flag9-audit/test_package.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python3 +"""Admission, corruption, and scanner-agreement checks. No assert statements.""" + +import hashlib +import json +import subprocess +import sys +import tempfile +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import independent +import verify + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def test_duplicate_key(): + with tempfile.TemporaryDirectory() as tmp: + path = Path(tmp) / "dup.json" + path.write_text('{"a": 1, "a": 2}\n', encoding="utf-8") + try: + verify.read_json(path) + except ValueError as exc: + need(str(exc) == "duplicate JSON key", "duplicate message") + else: + need(False, "duplicate key accepted") + + +def test_corrupt_certificate(): + observed = verify.evaluate() + with tempfile.TemporaryDirectory() as tmp: + path = Path(tmp) / "CERTIFICATE.json" + blob = json.loads((HERE / "CERTIFICATE.json").read_text(encoding="utf-8")) + blob["basis_head_drop_event"] = 0 + path.write_text(json.dumps(blob), encoding="utf-8") + bad = verify.read_json(path) + try: + verify.admit(observed, bad) + except ValueError as exc: + need(str(exc) == "certificate mismatch", "corruption message") + else: + need(False, "corrupt certificate accepted") + live = verify.read_json(HERE / "CERTIFICATE.json") + need(live["basis_head_drop_event"] == 500, "on-disk certificate mutated") + need(live["basis_head_arrive_event"] == 3489, "arrive field mutated") + + +def test_optimized_admission(): + script = ( + "import sys\n" + "from pathlib import Path\n" + f"sys.path.insert(0, {str(HERE)!r})\n" + "import verify\n" + "verify.need(__debug__ is False, 'optimization off')\n" + "try:\n" + " verify.need(False, 'admission')\n" + "except ValueError as exc:\n" + " if str(exc) != 'admission':\n" + " raise SystemExit('wrong admission')\n" + "else:\n" + " raise SystemExit('admission skipped')\n" + "print('PASS_OPTIMIZED_ADMISSION')\n" + ) + done = subprocess.run( + [sys.executable, "-O", "-I", "-B", "-c", script], + check=False, + capture_output=True, + text=True, + ) + need(done.returncode == 0, "optimized admission failed: " + done.stderr) + need("PASS_OPTIMIZED_ADMISSION" in done.stdout, "optimized marker") + + +def test_sample_drop_and_arrive(): + drop = ["transport", "X4", [196], [8, 64, 132, 260], 2] + frames = verify.annotated_frames(drop, "X4") + need(frames[0] == ("before", [196]), "sample before") + need(frames[1] == ("after", [8, 64, 132, 260]), "sample after") + need(196 not in frames[1][1], "sample drop") + arrive = [ + "transport", + "Y23", + [447, 127, 192], + [467, 27, 196, 12, 124, 3, 7, 1], + 2, + ] + arrive_frames = verify.annotated_frames(arrive, "Y23") + need(196 not in arrive_frames[0][1], "sample arrive before") + need(196 in arrive_frames[1][1], "sample arrive after") + folded = independent.frame_set([8, 64, 132, 260]) + need(196 not in folded and folded == frozenset((8, 64, 132, 260)), "sample set") + + +def test_hash_rejection(): + with tempfile.TemporaryDirectory() as tmp: + path = Path(tmp) / "blob.txt" + path.write_bytes(b"nope") + try: + verify.need( + hashlib.sha256(path.read_bytes()).hexdigest() == "0" * 64, + "source hash: temp", + ) + except ValueError as exc: + need("source hash" in str(exc), "hash message") + else: + need(False, "bad hash accepted") + + +def test_scanners_agree(): + before = { + path.name: hashlib.sha256(path.read_bytes()).hexdigest() + for path in HERE.iterdir() + if path.is_file() + } + left = verify.evaluate() + right = independent.evaluate() + need(left == right, "scanner disagreement") + verify.admit(left, verify.read_json(HERE / "CERTIFICATE.json")) + after = { + path.name: hashlib.sha256(path.read_bytes()).hexdigest() + for path in HERE.iterdir() + if path.is_file() + } + need(before == after, "package files mutated") + + +def main(): + test_duplicate_key() + test_corrupt_certificate() + test_optimized_admission() + test_sample_drop_and_arrive() + test_hash_rejection() + test_scanners_agree() + print("PASS_P104_PRESENT_HEAD_FLAG9_TESTS groups=6") + + +if __name__ == "__main__": + main() diff --git a/research/p104-present-head-flag9-audit/verify.py b/research/p104-present-head-flag9-audit/verify.py new file mode 100644 index 0000000000..d19277457b --- /dev/null +++ b/research/p104-present-head-flag9-audit/verify.py @@ -0,0 +1,280 @@ +#!/usr/bin/env python3 +"""Read-only present-head dirty-restoration audit for matched flag 9. + +Flag 9 is one of the four published flags whose target final contains the +basis head. Admission uses need() and remains active under python -O. This +module does not import independent.py or any predecessor verifier. +""" + +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +MARKER = ( + "PASS_P104_PRESENT_HEAD_FLAG9 flag=9 head=196 " + "preterminal_hosting=0 drop_event=500 arrive_event=3489 no_new_kappa" +) +INPUTS = ( + "research/p104-joint-unit-flags/CERTIFICATE.json", + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "research/p104-endpoint-geometric-budget/geometry.py", +) +SOURCE_LINE = "sources = [paths[f'X{s}'] for s in range(104)]" +TARGET_LINE = "targets = [paths[f'Y{t}'] for t in range(104)]" +FLAG_INDEX = 9 +HIT_FLAGS = (0, 1, 9, 43) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def pairs_unique(pairs): + value = {} + for key, item in pairs: + need(key not in value, "duplicate JSON key") + value[key] = item + return value + + +def read_json(path): + raw = Path(path).read_bytes() + need(len(raw) <= 2_000_000, "input exceeds 2 MB") + return json.loads(raw, object_pairs_hook=pairs_unique) + + +def register_name(item): + if type(item) is not str or len(item) < 2 or item[0] not in "XY": + return None + if not item[1:].isdigit() or int(item[1:]) > 103: + return None + return item + + +def annotated_frames(event, name): + frames = [] + if event[0] == "transport" and event[1] == name: + need(type(event[2]) is list and type(event[3]) is list, "transport frames") + frames.append(("before", list(event[2]))) + frames.append(("after", list(event[3]))) + elif event[0] == "add" and name in (event[1], event[2]): + need(type(event[-1]) is list, "add frame") + frames.append(("add", list(event[-1]))) + return frames + + +def pin_sources(): + manifest = read_json(HERE / "SOURCES.json") + rows = manifest["files"] + inputs = [row for row in rows if row["usage"] == "input"] + need(tuple(row["path"] for row in inputs) == INPUTS, "input inventory") + pinned = {} + for row in inputs: + path = ROOT / row["path"] + raw = path.read_bytes() + need(len(raw) <= 2_000_000, "source size") + digest = hashlib.sha256(raw).hexdigest() + need(digest == row["sha256"], "source hash: " + row["path"]) + pinned[row["path"]] = raw + return pinned + + +def hit_flag_indices(helpers, witness): + hits = [] + for index, row in enumerate(helpers): + head = row["basis"][0] + target = f"Y{row['target']}" + if head in witness["final_frames"][target]: + hits.append(index) + return hits + + +def build_receipt(witness, helpers): + need(len(helpers) == 208, "flag count") + need(len(witness["program"]) == 4058, "word length") + hits = hit_flag_indices(helpers, witness) + need(hits == list(HIT_FLAGS), "hit-flag census drift") + need(FLAG_INDEX in hits, "flag 9 left the present-head class") + helper = helpers[FLAG_INDEX] + head = helper["basis"][0] + source = f"X{helper['source']}" + target = f"Y{helper['target']}" + program = witness["program"] + source_events = [] + target_events = [] + joint = 0 + source_head = [] + target_head = [] + target_vectors = set() + for index, event in enumerate(program): + need(type(event) is list and 1 <= len(event) <= 8, "event shape") + names = [] + for item in event: + name = register_name(item) + if name is not None: + names.append(name) + kinds = {name[0] for name in names} + if "X" in kinds and "Y" in kinds and (source in names or target in names): + if source in names and target in names: + joint += 1 + if source in names: + source_events.append(index) + for role, frame in annotated_frames(event, source): + if head in frame: + source_head.append( + { + "event": index, + "opcode": event[0], + "role": role, + "frame": sorted(frame), + } + ) + if target in names: + target_events.append(index) + for role, frame in annotated_frames(event, target): + target_vectors.update(frame) + if head in frame: + target_head.append( + { + "event": index, + "opcode": event[0], + "role": role, + "frame": sorted(frame), + } + ) + need(source_events and target_events, "endpoint silence") + drop = source_events[0] + drop_event = program[drop] + need(drop_event[0] == "transport" and drop_event[1] == source, "first source op") + need(drop_event[2] == [head], "drop before-frame") + need(head not in drop_event[3], "drop after-frame still hosts head") + after_drop = False + for row in source_head: + if row["event"] > drop: + after_drop = True + if row["event"] == drop and row["role"] == "after": + after_drop = True + need(len(target_head) == 1, "unexpected target head hosting count") + arrive = target_head[0] + need(arrive["opcode"] == "transport", "arrive opcode") + need(arrive["role"] == "after", "arrive role") + need(arrive["event"] == target_events[-1], "arrive is not terminal target event") + preterminal = [ + row for row in target_head if row["event"] < arrive["event"] + ] + need(preterminal == [], "preterminal target hosting") + # Also: no before-frame at the arrive event hosts the head. + arrive_event = program[arrive["event"]] + need(arrive_event[0] == "transport" and arrive_event[1] == target, "arrive transport") + need(head not in arrive_event[2], "arrive before-frame already hosts head") + need(head in arrive_event[3], "arrive after-frame missing head") + hosting_gap = arrive["event"] - drop + need(hosting_gap > 0, "arrive precedes drop") + finals_with_head = sum( + 1 for index in range(104) if head in witness["final_frames"][f"Y{index}"] + ) + source_initial = witness["initial_frames"][source] + source_final = witness["final_frames"][source] + target_initial = witness["initial_frames"][target] + target_final = witness["final_frames"][target] + return { + "schema_version": 1, + "claim_id": "p104-present-head-flag9-audit", + "pinned_main": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "flag_index": FLAG_INDEX, + "source": helper["source"], + "target": helper["target"], + "basis_head": head, + "departure_choice": helper["departure_choice"], + "arrival_choice": helper["arrival_choice"], + "basis": helper["basis"], + "source_register": source, + "target_register": target, + "source_initial": source_initial, + "source_final": source_final, + "target_initial": target_initial, + "target_final": target_final, + "source_initial_is_basis_head": source_initial == [head], + "target_final_contains_basis_head": head in target_final, + "source_frame_restored": sorted(source_initial) == sorted(source_final), + "target_frame_restored": sorted(target_initial) == sorted(target_final), + "source_first_event": source_events[0], + "source_last_event": source_events[-1], + "target_first_event": target_events[0], + "target_last_event": target_events[-1], + "source_event_count": len(source_events), + "target_event_count": len(target_events), + "joint_source_target_events": joint, + "basis_head_drop_event": drop, + "basis_head_drop_before": sorted(drop_event[2]), + "basis_head_drop_after": sorted(drop_event[3]), + "basis_head_arrive_event": arrive["event"], + "basis_head_arrive_before": sorted(arrive_event[2]), + "basis_head_arrive_after": sorted(arrive_event[3]), + "hosting_gap_events": hosting_gap, + "source_annotations_containing_basis_head": len(source_head), + "target_annotations_containing_basis_head": len(target_head), + "target_preterminal_annotations_containing_basis_head": len(preterminal), + "source_head_annotations": source_head, + "target_head_annotations": target_head, + "target_annotated_vectors": sorted(target_vectors), + "basis_head_in_any_target_annotation": head in target_vectors, + "basis_head_in_source_after_drop": after_drop, + "targets_whose_final_contains_basis_head_among_all": finals_with_head, + "hit_flags_from_census": list(HIT_FLAGS), + "flag_is_present_head_case": True, + "obstruction": ( + "published_channel_hosts_basis_head_on_matched_target_only_at_" + "terminal_transport_after_source_drop" + ), + "no_new_kappa": True, + "selected_kappa": "0.001672660197076918", + } + + +def evaluate(): + pinned = pin_sources() + geometry = pinned[ + "research/p104-endpoint-geometric-budget/geometry.py" + ].decode("utf-8") + need(SOURCE_LINE in geometry, "source naming left the geometry") + need(TARGET_LINE in geometry, "target naming left the geometry") + certificate = json.loads( + pinned["research/p104-joint-unit-flags/CERTIFICATE.json"], + object_pairs_hook=pairs_unique, + ) + witness = json.loads( + pinned["research/p104-native-channel/inputs/LOWRANK-WITNESS.json"], + object_pairs_hook=pairs_unique, + ) + receipt = build_receipt(witness, certificate["helpers"]) + need(receipt["target_final_contains_basis_head"] is True, "left present-head class") + need(receipt["target_preterminal_annotations_containing_basis_head"] == 0, "preterminal") + need(receipt["target_annotations_containing_basis_head"] == 1, "target hosting count") + need(receipt["basis_head_drop_event"] == 500, "drop event drift") + need(receipt["basis_head_arrive_event"] == 3489, "arrive event drift") + need(receipt["hosting_gap_events"] == 2989, "gap drift") + need(receipt["basis_head_in_source_after_drop"] is False, "source retained head") + need(receipt["joint_source_target_events"] == 0, "joint endpoint event") + need(receipt["source_frame_restored"] is False, "source restored") + need(receipt["target_frame_restored"] is False, "target restored") + need(receipt["no_new_kappa"] is True, "kappa claim crept in") + return receipt + + +def admit(observed, expected): + need(observed == expected, "certificate mismatch") + + +def main(): + observed = evaluate() + expected = read_json(HERE / "CERTIFICATE.json") + admit(observed, expected) + print(MARKER) + + +if __name__ == "__main__": + main() From d9004e446a48bab303c17bae47ddec36f145edb9 Mon Sep 17 00:00:00 2001 From: Wentao Li Date: Sun, 18 Oct 2026 01:49:48 +0000 Subject: [PATCH 2/3] Record verified tip SHA in present-head flag 9 handoff Prepared by Wentao Li with substantial AI assistance. --- research/p104-present-head-flag9-audit/MASTER-HANDOFF.md | 1 + 1 file changed, 1 insertion(+) diff --git a/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md b/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md index 9065eb3f71..ce5a5e9fab 100644 --- a/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md +++ b/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md @@ -3,6 +3,7 @@ ## Candidate - Branch: `cursor/p104-present-head-flag9-60b9` +- Tip: `ae18b8db189f777bef159530d5395ebfe024f7b1` - Package: `research/p104-present-head-flag9-audit/` - Base: `6f100d4bb5083f8c35d96fd95a539811c62f245c` - Card: `p104-side-correction` (refined), priority revision 6 From acc2fa45374ce34c2d6293b862c3dcafb853ffa6 Mon Sep 17 00:00:00 2001 From: Wentao Li Date: Sun, 18 Oct 2026 01:50:01 +0000 Subject: [PATCH 3/3] Clarify content tip versus packaging tip in flag 9 handoff Prepared by Wentao Li with substantial AI assistance. --- research/p104-present-head-flag9-audit/MASTER-HANDOFF.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md b/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md index ce5a5e9fab..6100f1167e 100644 --- a/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md +++ b/research/p104-present-head-flag9-audit/MASTER-HANDOFF.md @@ -3,7 +3,7 @@ ## Candidate - Branch: `cursor/p104-present-head-flag9-60b9` -- Tip: `ae18b8db189f777bef159530d5395ebfe024f7b1` +- Content tip: `ae18b8db189f777bef159530d5395ebfe024f7b1` (scientific package commit) - Package: `research/p104-present-head-flag9-audit/` - Base: `6f100d4bb5083f8c35d96fd95a539811c62f245c` - Card: `p104-side-correction` (refined), priority revision 6