Confirm restricted label placement failure and fresh baseline reading

2026-10-01 18:59:16 -07:00
parent 70cf350d23
commit 45bfb63b4f
18 changed files with 16647 additions and 3 deletions
@@ -2,3 +2,5 @@ native-reading/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
 *.json -text whitespace=cr-at-eol
 issue38-design-*.md -text whitespace=cr-at-eol
 launch-reading*.py -text whitespace=cr-at-eol
+label-candidates/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+first-exposure/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
@@ -55,13 +55,27 @@ because the available native tool exposes atomic completed drags.
 [Candidate comparison](issue38-design-candidates.md) evaluates ownership-aware
 automatic placement, selective unselected association cues and selection-only
 cues. The [fresh critic](issue38-design-critic.md) finds that the current candidate
-set has no collision-free placement in this witness, based on an explicitly
-unexecuted double-precision reconstruction. Confirm that finding in Rust before
-rejecting the bounded automatic-placement approach. Manual repair intersects both
+set has no collision-free placement in this witness; its initial report was an
+unexecuted double-precision reconstruction. The
+[restricted Rust confirmation](label-candidates/README.md) now passes all six
+probe tests, real CLI enumeration, strict example Clippy and byte/model checks.
+All 184 candidates are evaluated; all six best choices still cross the same
+foreign Allocation. The retained first test failure was a declared segment-index
+miscount corrected against the original geometry, with no other assertion changed.
+This rejects ownership tie-breaking within the fixed existing generator and best
+collision tuple for the declared nearest-box metric, rather than automatic
+placement generally. Manual repair intersects both
 own and foreign strokes and is not a fresh reading success or a validated distance
 metric. A short boundary-to-anchor cue remains an experiment with explicit noise,
 shared-anchor, export, cache and first-association rejection gates.

+A separate [fresh first-exposure screenshot review](first-exposure/review.md),
+without opening-view cues or model lookup, assigns the conversation label to the
+foreign technician-to-repair Allocation and its arrowhead. Request/report reading
+remains uncertain. This is one agent's static reading of the actual complete
+baseline Fit screenshot, not a human study or native interaction acceptance.
+It corroborates the misassociation independently of the earlier cued reading.
+
 No production routing or rendering change is accepted here. Direct new-exchange
 drawing, full shared-corridor readability, broad accessibility/DPI and complete
 OA/SA acceptance remain outstanding. Authoritative scope and ownership are in
@@ -0,0 +1,6 @@
+{
+  "review.md": {
+    "bytes": 6334,
+    "sha256": "e3f083690868f6d4514de4baa8b6b5dd4930a34c8b4270df640bd4dbf1d532ab"
+  }
+}
@@ -0,0 +1,31 @@
+# First-exposure static screenshot reading
+
+I inspected only `C:/ar-diagram-01a0d717/.local/native-reading/fit-52.png` using `view_image` with `detail: original`. The screenshot is 1442 by 932 pixels. It shows the native Arcadia Studio Architecture page, the view titled “Issue 38 representative eight-card mixed view”, and 52% zoom. I read the working agreement in AGENTS.md but did not inspect source code, model data, answer keys, other reports, comparison images, or external research. The interpretations below are my first readings, recorded before receiving any correctness feedback.
+
+## Request field repair
+
+My initial candidate is a directed relation from “Assess pressure alarm” to “Repair valve in the field”, but I cannot confidently establish the first endpoint from this view. Endpoint confidence is low. The label appears just above the horizontal stroke at about y = 611. That stroke runs left to a vertical near x = 430 and right to the closely spaced vertical strokes just left of the repair card. A small open green triangle at the repair card's upper left edge, near y = 591, appears to point toward the card. This suggests a directed arrival at the repair function, with moderate confidence in that local reading.
+
+The difficult part is establishing which path actually belongs to the label. Following the left vertical upward brings me into the rectangular route above and around “Pressure coordination service”, while other strokes meet or cross near the right edge of “Assess pressure alarm”. Following the right vertical upward brings me toward “Assess an alarm procedure” and the line running toward the actor. I cannot tell reliably whether these are connected branches, crossings, or overlapping independent routes. “Assess an alarm procedure” is therefore a plausible alternative first endpoint; a route involving “Pressure coordination service” is also visually easy to infer. My initial assess-to-repair candidate partly uses the nearby card positions and the label's meaning. It is not a confidently traced endpoint pair.
+
+## Report repair result
+
+My initial candidate is a directed relation from “Repair valve in the field” to “Confirm safe pressure”. Endpoint confidence is low to moderate. The label appears above the horizontal stroke at about y = 646. That stroke runs between the repair card's lower left corner and a vertical near x = 521. Following that vertical downward brings me toward the horizontal stroke at y = 797 and an open green triangle pointing into the right edge of “Confirm safe pressure”. This supports the candidate direction toward confirmation.
+
+However, the small open green triangle at the repair end of the labeled horizontal stroke appears to point left, away from the repair card, and is difficult to distinguish from the other open green card markers. I would tentatively read this as a directional relation, not confidently as an unoriented relation, but the marker convention is not self-explanatory in the screenshot. The same left vertical passes the small arrow at “Reset valve remotely” and intersects the horizontal near y = 568. A reader could therefore follow it to “Reset valve remotely”, or continue upward toward the assessment/service row. I cannot exclude those alternatives from geometry alone. The label meaning makes repair-to-confirmation seem reasonable, but it does not resolve the line ownership.
+
+## Technician service conversation
+
+My first reading is a directed relation from “Field technician” to “Repair valve in the field”. Confidence is high relative to the other two readings, and moderate to high overall. A vertical stroke leaves the bottom of the technician card near x = 933, turns left below the label, and then turns down into a small filled arrowhead at the top of the repair card near x = 883. That is a short, locally traceable path. I do not need the label meaning to infer the endpoint pair or downward direction.
+
+The word “conversation” might suggest an unoriented or two-way relationship in ordinary language, but the visible route has a downward arrowhead. I would follow the visible marker rather than infer two-way semantics from the name. The technician card also has a separate square marker and route at its left edge; I would not assign that route to this label on my first reading.
+
+## Reading effort and visual ambiguity
+
+The complete eight-card layout is visible, but the card titles, type captions, and relation labels are very small at 52%. I can decipher the requested labels with concentrated inspection; they are not comfortable scanning text. Several card type captions are substantially harder to read than the card names. Thin grey strokes and very small arrowheads make a route's terminal direction harder to identify than the card structure.
+
+The largest effort is tracking line identity across the middle of the view. The assessment/service row contains intersections and a route surrounding the service card. Near the repair card, several closely spaced verticals and horizontal turns compete for attention. Near the reset/confirmation cards, one apparent vertical can be followed toward several endpoints. I do not see an unmistakable junction-versus-crossing convention that resolves these alternatives in this image. The first two labels require repeated tracing and still leave uncertainty.
+
+The blue and purple hollow squares at card boundaries, the green open triangles, and the small filled grey arrowheads appear to be different marker families. Without a visible legend, I cannot confidently separate semantic relation markers from ports or editing affordances. The screenshot says “0 selected”, which argues against treating every coloured boundary marker as a selection handle. The large pointer over Fit and its pale blue highlight look like cursor/UI markings rather than diagram semantics. The dotted canvas and tool buttons also look nonsemantic.
+
+This is one agent's first-exposure reading of one static screenshot. It is not a human user study, a correctness determination against the underlying model, or acceptance evidence for native gestures, interaction, accessibility, or alternative zoom levels. It establishes only the interpretations and uncertainties observable to this evaluator in this archived Fit view.
@@ -0,0 +1,49 @@
+# Restricted existing-candidate feasibility confirmation
+
+Executed source `70cf350d23ed3a47ca843754220e4f45fa51aa47`: formatting, all six
+probe tests, real CLI enumeration and strict example Clippy pass on Windows
+gnullvm. The first five-pass/one-fail run at `05b1b1d` is retained. Its declared
+segment index was independently reconciled against the original saved geometry;
+the entire successor code change is `[2]` to `[1]` in that expectation. No scoring,
+other expected values or production implementation changed.
+
+Actual f32 enumeration confirms 184 candidates, zero node-clear/stroke-clear
+choices, and six best `(0,0,1)` choices. Every best box is 18 world units from its
+own route and intersects the same foreign ordinary allocation at segment index1.
+The parent reconciled the complete CLI Project/input bytes and all six owner-tagged
+winner rows. A second CLI call against its already-existing output fails with
+AlreadyExists; both input and prior output remain byte-exact. Raw output, gate
+logs, initial failure, author reconciliation, independent source/arithmetic review,
+source manifest and parent result remain in this packet.
+
+This rejects candidate A only as specified: ownership-aware tie-breaking inside
+the existing generator, preserving the best collision tuple and fixed routes,
+cannot repair the declared nearest-box ownership metric for this reconstructed
+view. It does not reject new candidate generators/objectives or automatic layout
+generally, and does not establish that alternate heights cannot aid perception.
+The exhaustive probe omits production budgets/early exit; no chooser latency or
+winner simulation is claimed. Restrictions include flat nodes, an automatic
+unsuspended nonempty target label, no association-end/earlier nonempty labels,
+and finite orthogonal paths. The representative view is not recovered user source.
+Native reading of candidate B remains separate.
+
+The parent's first direct guard harness omitted the DLL search path and failed
+its expected-error assertion before capturing a result. A separately retained
+repeat returns Windows `0xc0000135` with empty streams; this is a startup failure,
+not a create-new guard pass. The corrected harness explicitly supplies the pinned
+libunwind directory and system PATH. That actual repeat reaches AlreadyExists.
+
+From this checkout with Rust configured:
+
+```powershell
+cargo fmt --all -- --check
+cargo test --locked -p oa-core --example diagram_readability_probe
+cargo clippy --locked -p oa-core --example diagram_readability_probe -- -D warnings
+cargo run --locked -p oa-core --example diagram_readability_probe -- label-candidates harness/experiments/diagram-readability-20261001/native-reading/working/eight-card.json examples/release1/expected-diagnostics.json 00000000-0038-4000-8000-000000000001 63009b5f-539e-5914-b630-ec6b7fefb4d5 NEW_OUTPUT_JSON
+```
+
+Choose a nonexistent output path. The collector retains historical absolute paths
+and performs a deliberate existing-output guard attempt; it is provenance, not a
+portable replay script. Inventory hashes cover all subpacket files except the
+inventory itself. Runtime provenance requires the external manifest/source gates;
+the JSON's embedded experiment description alone is not a build identity.
@@ -0,0 +1,109 @@
+from pathlib import Path
+import hashlib, json, os, shutil, subprocess
+
+root = Path(__file__).resolve().parents[1]
+source = '70cf350d23ed3a47ca843754220e4f45fa51aa47'
+assert subprocess.check_output(['git','rev-parse','HEAD'],cwd=root,text=True).strip()==source
+sha = lambda b: hashlib.sha256(b).hexdigest()
+load = lambda p: json.loads(p.read_text(encoding='utf-8'))
+inp = root/'.local/native-reading/working/eight-card.json'
+output = root/'.local/label-candidates-corrected.json'
+raw_input = inp.read_bytes(); raw_output = output.read_bytes(); value = load(output)
+assert sha(raw_input)=='9db1015369f450d5810c96a01fddb8a009d57f6aafbda5182703f15ded23d9c8'
+assert value['project']==json.loads(raw_input) and value['original_input_utf8']==raw_input.decode('utf-8')
+assert value['project_conserved'] and value['input_bytes_conserved']
+assert (value['fraction_count'],value['offset_count'],value['candidate_count'],value['distinct_stroke_count'])==(23,8,184,37)
+assert value['zero_node_zero_stroke_count']==0 and value['best_collision_tuple']==[0,0,1]
+winners=[value['candidates'][i] for i in value['best_candidate_indices']]
+assert len(winners)==6
+for candidate in winners:
+    assert candidate['own_clearance']==18 and candidate['foreign_clearance']==0
+    assert candidate['own_intersections']==[]
+    assert candidate['foreign_intersections']==[{'edge':'725f2e1b-aa2c-5615-9b1f-28da178168fa','relation_alias':'sa_repair_allocation','segments':[1]}]
+exe=Path('C:/Users/User/Documents/Git/ARCADIA-Studio/.local/target-gnullvm/debug/examples/diagram_readability_probe.exe')
+command=[str(exe),'label-candidates',str(inp),str(root/'examples/release1/expected-diagnostics.json'),
+         '00000000-0038-4000-8000-000000000001','63009b5f-539e-5914-b630-ec6b7fefb4d5',str(output)]
+runtime=Path('C:/ar-compact-01a0d717/.local/package39/bin/libunwind.dll')
+assert sha(runtime.read_bytes())=='f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4'
+env=os.environ.copy(); system=os.environ['SystemRoot']
+env['PATH']=str(runtime.parent)+';'+str(Path(system)/'System32')+';'+system
+guard=subprocess.run(command,cwd=root,env=env,capture_output=True)
+assert guard.returncode!=0 and b'AlreadyExists' in guard.stderr
+assert inp.read_bytes()==raw_input and output.read_bytes()==raw_output
+packet=root/'harness/experiments/diagram-readability-20261001/label-candidates'
+packet.mkdir(exist_ok=False)
+for name in ['label-candidates-first-failed.log','label-candidates-corrected-format.log',
+             'label-candidates-corrected-tests.log','label-candidates-corrected-cli.log',
+             'label-candidates-corrected-clippy.log','label-candidates-corrected.json',
+             'label-candidates-summary.md','label-candidates-independent-review.md',
+             'label-candidates-guard-without-runtime-repeated.json']:
+    shutil.copyfile(root/'.local'/name,packet/name)
+shutil.copyfile(Path(__file__),packet/'collect-label-candidates.py')
+source_files=['crates/oa-core/examples/diagram_readability_probe.rs','crates/oa-core/src/routing.rs',
+              'examples/release1/model.json','examples/release1/expected-diagnostics.json',
+              'harness/experiments/diagram-readability-20260929/eight-card-view.json','Cargo.lock']
+manifest={'source':source,'input_sha256':sha(raw_input),'output_sha256':sha(raw_output),
+          'binary_sha256':sha(exe.read_bytes()),'runtime_sha256':sha(runtime.read_bytes()),'files':{}}
+for name in source_files:
+    b=subprocess.check_output(['git','show',source+':'+name],cwd=root)
+    manifest['files'][name]={'bytes':len(b),'sha256':sha(b)}
+(packet/'source-manifest.json').write_text(json.dumps(manifest,indent=2)+'\n',encoding='utf-8')
+receipt={'status':'PASS','source':source,'candidate_count':184,'best_candidates':winners,
+         'input_bytes_and_complete_project_conserved':True,'existing_output_guard':{
+           'command':command,'exit_code':guard.returncode,'stdout':guard.stdout.decode('utf-8'),
+           'stderr':guard.stderr.decode('utf-8'),'path':env['PATH'],'runtime_sha256':sha(runtime.read_bytes()),'input_unchanged':True,'output_unchanged':True}}
+(packet/'result.json').write_text(json.dumps(receipt,indent=2)+'\n',encoding='utf-8')
+(packet/'README.md').write_text('''# Restricted existing-candidate feasibility confirmation
+
+Executed source `70cf350d23ed3a47ca843754220e4f45fa51aa47`: formatting, all six
+probe tests, real CLI enumeration and strict example Clippy pass on Windows
+gnullvm. The first five-pass/one-fail run at `05b1b1d` is retained. Its declared
+segment index was independently reconciled against the original saved geometry;
+the entire successor code change is `[2]` to `[1]` in that expectation. No scoring,
+other expected values or production implementation changed.
+
+Actual f32 enumeration confirms 184 candidates, zero node-clear/stroke-clear
+choices, and six best `(0,0,1)` choices. Every best box is 18 world units from its
+own route and intersects the same foreign ordinary allocation at segment index1.
+The parent reconciled the complete CLI Project/input bytes and all six owner-tagged
+winner rows. A second CLI call against its already-existing output fails with
+AlreadyExists; both input and prior output remain byte-exact. Raw output, gate
+logs, initial failure, author reconciliation, independent source/arithmetic review,
+source manifest and parent result remain in this packet.
+
+This rejects candidate A only as specified: ownership-aware tie-breaking inside
+the existing generator, preserving the best collision tuple and fixed routes,
+cannot repair the declared nearest-box ownership metric for this reconstructed
+view. It does not reject new candidate generators/objectives or automatic layout
+generally, and does not establish that alternate heights cannot aid perception.
+The exhaustive probe omits production budgets/early exit; no chooser latency or
+winner simulation is claimed. Restrictions include flat nodes, an automatic
+unsuspended nonempty target label, no association-end/earlier nonempty labels,
+and finite orthogonal paths. The representative view is not recovered user source.
+Native reading of candidate B remains separate.
+
+The parent's first direct guard harness omitted the DLL search path and failed
+its expected-error assertion before capturing a result. A separately retained
+repeat returns Windows `0xc0000135` with empty streams; this is a startup failure,
+not a create-new guard pass. The corrected harness explicitly supplies the pinned
+libunwind directory and system PATH. That actual repeat reaches AlreadyExists.
+
+From this checkout with Rust configured:
+
+```powershell
+cargo fmt --all -- --check
+cargo test --locked -p oa-core --example diagram_readability_probe
+cargo clippy --locked -p oa-core --example diagram_readability_probe -- -D warnings
+cargo run --locked -p oa-core --example diagram_readability_probe -- label-candidates harness/experiments/diagram-readability-20261001/native-reading/working/eight-card.json examples/release1/expected-diagnostics.json 00000000-0038-4000-8000-000000000001 63009b5f-539e-5914-b630-ec6b7fefb4d5 NEW_OUTPUT_JSON
+```
+
+Choose a nonexistent output path. The collector retains historical absolute paths
+and performs a deliberate existing-output guard attempt; it is provenance, not a
+portable replay script. Inventory hashes cover all subpacket files except the
+inventory itself. Runtime provenance requires the external manifest/source gates;
+the JSON's embedded experiment description alone is not a build identity.
+''',encoding='utf-8')
+inventory={p.relative_to(packet).as_posix():{'bytes':p.stat().st_size,'sha256':sha(p.read_bytes())}
+           for p in packet.rglob('*') if p.is_file()}
+(packet/'evidence-files.json').write_text(json.dumps(inventory,indent=2)+'\n',encoding='utf-8')
+print(json.dumps({'status':'PASS','captured_files':len(inventory),'source':source,'output_sha256':sha(raw_output)},indent=2))
@@ -0,0 +1,54 @@
+{
+  "collect-label-candidates.py": {
+    "bytes": 7879,
+    "sha256": "60530ad52007e2cc3b64b376784c902fcf1592a2263cf92357bd999f1e5dd746"
+  },
+  "label-candidates-corrected-cli.log": {
+    "bytes": 476,
+    "sha256": "a0b823c42c4e4bd82cf369c3dcae78505fa926c5859747836245c7b6f56000b2"
+  },
+  "label-candidates-corrected-clippy.log": {
+    "bytes": 131,
+    "sha256": "be3db997064a64f0decf6e32a939325d880930b52570cb1e38e71937ee71ed70"
+  },
+  "label-candidates-corrected-format.log": {
+    "bytes": 0,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+  },
+  "label-candidates-corrected-tests.log": {
+    "bytes": 923,
+    "sha256": "e992552c7a5ebc47978a8d076fe36025bde7eb96680176b71077fbd13a2e3ab9"
+  },
+  "label-candidates-corrected.json": {
+    "bytes": 546617,
+    "sha256": "3cc6a058fd7b16e1082b0aa38fa322147c129612fa3d27d30e54f7f75e63470b"
+  },
+  "label-candidates-first-failed.log": {
+    "bytes": 1543,
+    "sha256": "75e4759570bf1acc0d0b4eebaa6409d25d068d0877ff9700f7080f6569b92842"
+  },
+  "label-candidates-guard-without-runtime-repeated.json": {
+    "bytes": 90,
+    "sha256": "86e177b1b1018f67cb3554456e8981d664a134528cedbe80fd36a3e6f2030717"
+  },
+  "label-candidates-independent-review.md": {
+    "bytes": 6763,
+    "sha256": "5c5b81a13577b94de6abb18afecede2354103a7d4e1e12def84f6ead4068950b"
+  },
+  "label-candidates-summary.md": {
+    "bytes": 4097,
+    "sha256": "c28c4ea7e90f0abb9898f228234523e30236e8975ae7851dee88aeb37a53dcbc"
+  },
+  "README.md": {
+    "bytes": 3304,
+    "sha256": "fa6a397d948651be55cce7a5d9eefff653ceb1b4f6411863b3d8c3b45a9eea65"
+  },
+  "result.json": {
+    "bytes": 6398,
+    "sha256": "7d86a5ba5d1ef94d9c2703949d230ed6ae91c17b5f5c5a831538a1a24d6d44fe"
+  },
+  "source-manifest.json": {
+    "bytes": 1419,
+    "sha256": "da54db7e47c7b1bd0ace2fb2a86565ac4b6bcde4f65ad1e7f4cca8c4596ac6c1"
+  }
+}
@@ -0,0 +1,3 @@
+   Compiling oa-core v0.2.0 (C:\ar-diagram-01a0d717\crates\oa-core)
+    Finished `dev` profile [unoptimized] target(s) in 1.75s
+     Running `C:\Users\User\Documents\Git\ARCADIA-Studio\.local\target-gnullvm\debug\examples\diagram_readability_probe.exe label-candidates .local/native-reading/working/eight-card.json examples/release1/expected-diagnostics.json 00000000-0038-4000-8000-000000000001 63009b5f-539e-5914-b630-ec6b7fefb4d5 .local/label-candidates-corrected.json`
@@ -0,0 +1,2 @@
+    Checking oa-core v0.2.0 (C:\ar-diagram-01a0d717\crates\oa-core)
+    Finished `dev` profile [unoptimized] target(s) in 17.18s
@@ -0,0 +1,14 @@
+   Compiling oa-core v0.2.0 (C:\ar-diagram-01a0d717\crates\oa-core)
+    Finished `test` profile [unoptimized] target(s) in 33.45s
+     Running unittests examples\diagram_readability_probe.rs (C:\Users\User\Documents\Git\ARCADIA-Studio\.local\target-gnullvm\debug\examples\diagram_readability_probe-6772f474561e0ccd.exe)
+
+running 6 tests
+test tests::analytical_query_controls_distinguish_edges_segments_and_labels ... ok
+test tests::complete_scene_preserves_semantics_sentinel_and_authored_route ... ok
+test tests::square_port_corner_is_occluded_even_outside_ten_unit_circle ... ok
+test tests::unexpected_diagnostics_and_invalid_source_fail_closed ... ok
+test tests::conversation_existing_candidates_cannot_avoid_foreign_allocation ... ok
+test tests::representative_preserves_every_original_record_and_view ... ok
+
+test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.20s
+
@@ -0,0 +1,29 @@
+   Compiling oa-core v0.2.0 (C:\ar-diagram-01a0d717\crates\oa-core)
+    Finished `test` profile [unoptimized] target(s) in 1m 26s
+     Running unittests examples\diagram_readability_probe.rs (C:\Users\User\Documents\Git\ARCADIA-Studio\.local\target-gnullvm\debug\examples\diagram_readability_probe-6772f474561e0ccd.exe)
+
+running 6 tests
+test tests::analytical_query_controls_distinguish_edges_segments_and_labels ... ok
+test tests::complete_scene_preserves_semantics_sentinel_and_authored_route ... ok
+test tests::square_port_corner_is_occluded_even_outside_ten_unit_circle ... ok
+test tests::conversation_existing_candidates_cannot_avoid_foreign_allocation ... FAILED
+test tests::unexpected_diagnostics_and_invalid_source_fail_closed ... ok
+test tests::representative_preserves_every_original_record_and_view ... ok
+
+failures:
+
+---- tests::conversation_existing_candidates_cannot_avoid_foreign_allocation stdout ----
+
+thread 'tests::conversation_existing_candidates_cannot_avoid_foreign_allocation' (7848) panicked at crates\oa-core\examples\diagram_readability_probe.rs:731:13:
+assertion `left == right` failed
+  left: Array [Number(1)]
+ right: Array [Number(2)]
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+
+failures:
+    tests::conversation_existing_candidates_cannot_avoid_foreign_allocation
+
+test result: FAILED. 5 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.72s
+
+error: test failed, to rerun pass `-p oa-core --example diagram_readability_probe`
@@ -0,0 +1,6 @@
+{
+  "returncode": 3221225781,
+  "hex": "0xc0000135",
+  "stdout": "",
+  "stderr": ""
+}
@@ -0,0 +1,41 @@
+# Independent review: restricted label candidate enumeration
+
+No material source or conceptual defect found in the bounded enumeration. The helper is suitable to test the predeclared geometric feasibility claim. Corrected Rust execution remains a separate parent gate; no passing result is inferred from the earlier five-pass/one-fail run. This review does not accept a production label algorithm or general usability improvement.
+
+## Exact scope
+
+Read applicable AGENTS.md, design critic, original production routing implementation, added helper/CLI/test, initial failure and the one-line correction. Source addition: `05b1b1d804c4cd47d9c8ff464644e365d8ede5b2`; corrected assertion commit: `70cf350d23ed3a47ca843754220e4f45fa51aa47`. Current working tree was clean during review.
+
+Working-file SHA256: `crates/oa-core/examples/diagram_readability_probe.rs` = `cbc6713a4974c77b1c8b44f12cb9e0a2271096bbbdbc883aae0c5ba9703ba483`; `crates/oa-core/src/routing.rs` = `b377fe80cece3892d64f62ba5e1578d8974eeefc2a317620f343a86f2f257fbd`.
+
+Probe exact SHA256: `cbc6713a4974c77b1c8b44f12cb9e0a2271096bbbdbc883aae0c5ba9703ba483`.
+
+No compiler, GUI, Gitea, commit or production edit. Read-only Python arithmetic independently reconstructed candidate geometry over previously captured baseline paths. This report is the only new artifact.
+
+## Production correspondence
+
+`LabelProbeRect` matches production rectangle construction, inflation, strict overlap and strict segment-intersection inequalities including EPSILON 0.001. Under the required exact orthogonality, its interval-separation/hypot clearance is the segment-to-uninflated-box distance, not a perceptual or glyph distance.
+
+The flat-node guard makes all production traversable-ancestor sets empty, so full node rectangles inflated by 12 reproduce edge_obstacles. No association-end labels and no earlier nonempty ordinary labels imply the production prior-label collision component is exactly zero. Authored target labels and suspended custom routes are rejected. Unknown diagram/edge, empty label, too-short path, nonfinite or nonorthogonal paths and changed label dimensions are rejected rather than silently approximated.
+
+Fraction generation matches production f32 length accumulation, segment midpoints, 1/20 increments, sorting by distance from 0.5 then numeric order, exact deduplication and truncation at 32. Eight offsets and label width/height reconstruction match. Anchor interpolation calls the actual production point_along_polyline helper. Final candidate bounds use the same f32 expression order.
+
+Distinct nonzero strokes are deduplicated only by exact undirected endpoint equality, matching record_segments. Production label collision score counts each stored segment once and does not multiply by its multiplicity. The probe does the same; it separately walks original edge-tagged segment windows to retain every semantic owner and zero-based segment index. It therefore does not collapse coincident foreign ownership into the target's identity. Partially overlapping segments stay distinct in both paths.
+
+The helper intentionally computes full tuples without the 8192 budget, early pruning or early successful exit. It enumerates the complete generator set, a superset of candidates actually examined by the production chooser. This is appropriate for proving absence within that set; it does not reproduce the actual chooser's work count, budget exhaustion, winner or latency. The report states that boundary.
+
+## Independent witness reconciliation
+
+Independent read-only arithmetic over the original geometry-before.json, with explicit f32 rounding of candidate/interpolation operations, reproduces 23 fractions, 184 candidates, 37 distinct strokes, minimum tuple (0,0,1), and precisely the declared six best fractions: 0.5, approximately 0.45/0.55/0.6/0.65/0.67610836. All use offset (134.5,0), center x1296.5 and the predeclared center y values within f32 tolerance. Their boxes remain 18 units from the own path and intersect the foreign allocation. This is independent arithmetic confirmation, not Rust test execution.
+
+The first failed Rust log is preserved with SHA256 `75e4759570bf1acc0d0b4eebaa6409d25d068d0877ff9700f7080f6569b92842`. Its failed assertion was declared segment [2] versus actual [1]. The original captured allocation points are (1312.5,161), (1312.5,179), (1312.5,325), (1216,325), (1216,343). The offending vertical is therefore windows(2) index 1; index 2 is horizontal. Independent geometry supports correcting only [2] to [1]. Git confirms that is the entire successor change. The failed run stopped in the first winner row, so it does not establish successful completion of all six rows.
+
+## Preservation and limits
+
+The CLI uses existing exact-diagnostics admission, rejects model errors or changed warning sets, reads input bytes, retains original UTF-8 text in output, compares input bytes again after analysis, and writes through create_new. Existing outputs or output equal to input fail without replacement. Project is immutable to the helper and explicitly compared to its clone. These are read-only/single-writer experiment checks, not a filesystem lock or atomic cross-process promise. Create-new output can remain partial on a later write failure; failed attempts should stay identifiable.
+
+The new test checks independently declared full-model preservation, candidate/stroke counts, absence of a zero-node/zero-stroke option, exact optimum tuple, all six expected best placements, ownership/alias/segment and clearance values. Unsupported-context rejection and create-new behavior are not newly exercised by this test. Source inspection supports them; do not turn this into a generic nested/association/earlier-label scorer without separate work.
+
+The defensible conclusion after corrected execution is narrow: on these fixed representative paths, no existing generator candidate can improve the declared own-versus-foreign nearest-box relationship while preserving the best collision tuple. All six best candidates still intersect the same allocation. This does not prove every change in height is perceptually useless, all automatic placement strategies are impossible, a different candidate generator is unnecessary, or that the manual control/B cue improves fresh reading. Those require separately declared metrics and native evidence. The representative view remains a reconstruction, not recovered user source.
+
+No material finding requires production changes. Before recording A's restricted metric formulation as rejected, retain the corrected Rust result/output, complete input/source identity and this explicit scope. Production budgets/performance and B native acceptance remain outside this review.
@@ -0,0 +1,39 @@
+# Label candidate confirmation: initial scope
+
+Bounded issue 38 experiment, delegated by root. Modify only `crates/oa-core/examples/diagram_readability_probe.rs`; parent is sole compiler and integration owner. No production router/renderer changes, GUI, Gitea, commit, or build/test execution by this agent.
+
+Add read-only `label-candidates INPUT EXPECTED_DIAGNOSTICS DIAGRAM_UUID EDGE_UUID NEW_OUTPUT_JSON` with create-new output. Reconstruct current candidate geometry and full f32 collision scores for flat nodes and simple label context; reject unsupported nested nodes, association-end labels, and earlier nonempty labels. Preserve Project and source bytes. Enumerate an unbudgeted exhaustive superset; do not claim to simulate the production comparison budget or winner.
+
+Expected falsification witness: 23 fractions times 8 offsets; no node-clear/stroke-clear candidate; six optimum (0,0,1) candidates, all intersecting ordinary `sa_repair_allocation`, own/foreign box clearances 18/0. One fixture test will assert the independently declared expected table with f32 tolerance. Parent will compile and verify actual output before treating findings as confirmed.
+
+## Implementation ready for parent verification
+
+Implemented the bounded command in the existing probe and added one representative-fixture falsification test. The report includes each candidate's f32 geometry, full collision tuple, owner-preserving semantic stroke intersections, and uninflated own/foreign box clearances. The command rejects unsupported geometry/label contexts and uses existing diagnostics admission and create-new writing. Existing generate/probe commands and tests remain in place.
+
+Static review and `git diff --check` completed; no build, formatter, or tests run by this agent. Parent should format the touched Rust file, run the probe's six tests, and execute the new command against the immutable representative input with release1 diagnostics. Expected values are predeclared in the new test; actual Rust output is not yet confirmed.
+
+Suggested invocation arguments (after the parent's normal build setup):
+
+```text
+label-candidates .local/native-reading/working/eight-card.json examples/release1/expected-diagnostics.json 00000000-0038-4000-8000-000000000001 63009b5f-539e-5914-b630-ec6b7fefb4d5 NEW_OUTPUT_JSON
+```
+
+Source reviewed by author; parent independently owns code/result review. This is not a fresh second critic's implementation review.
+
+## First Rust run: declared segment-index transcription correction
+
+Parent's first six-test run at frozen source `05b1b1d804c4cd47d9c8ff464644e365d8ede5b2` failed: five tests passed and the new fixture test stopped at its first-row segment-index assertion (actual `[1]`, declared `[2]`). Preserve `.local/label-candidates-tests.log` as failure evidence. Counts, optimum tuple, and first-row geometry/ownership assertions had passed before that point; the complete six-row finding remains pending the corrected run.
+
+Independently reopened the original saved baseline `.local/native-reading/manual/geometry-before.json`, not the new Rust output. Ordinary allocation `725f2e1b-aa2c-5615-9b1f-28da178168fa` has these consecutive points:
+
+```text
+0: (1312.5,161)
+1: (1312.5,179)
+2: (1312.5,325)
+3: (1216,325)
+4: (1216,343)
+```
+
+Thus the vertical segment at x1312.5, y179..325 is zero-based window index **1**; index 2 is the horizontal segment at y325. The probe reports `edge.points.windows(2).enumerate()` indices, with no segment merging in its semantic owner lists. Production `record_segments` deduplication affects the independent collision tuple only, not these semantic indices. The candidate baseline box y262.5..286.5 intersects index 1 and cannot intersect horizontal index 2 even after its 3-unit inflation.
+
+The `[2]` assertion was my declared index miscount, contradicted by the pre-existing geometry; it was not evidence of changed routing. Corrected only `[2]` to `[1]` in that assertion. No other expected value, tolerance, geometry rule, or assumption changed. No compile, test execution, GUI, commit, or Gitea action by this agent.
@@ -0,0 +1,278 @@
+{
+  "status": "PASS",
+  "source": "70cf350d23ed3a47ca843754220e4f45fa51aa47",
+  "candidate_count": 184,
+  "best_candidates": [
+    {
+      "anchor": {
+        "x": 1162.0,
+        "y": 274.5
+      },
+      "bounds": {
+        "position": {
+          "x": 1180.0,
+          "y": 262.5
+        },
+        "size": {
+          "height": 24.0,
+          "width": 233.0
+        }
+      },
+      "center": {
+        "x": 1296.5,
+        "y": 274.5
+      },
+      "collision_tuple": [
+        0,
+        0,
+        1
+      ],
+      "foreign_clearance": 0.0,
+      "foreign_intersections": [
+        {
+          "edge": "725f2e1b-aa2c-5615-9b1f-28da178168fa",
+          "relation_alias": "sa_repair_allocation",
+          "segments": [
+            1
+          ]
+        }
+      ],
+      "fraction": 0.5,
+      "offset": {
+        "x": 134.5,
+        "y": 0.0
+      },
+      "own_clearance": 18.0,
+      "own_intersections": []
+    },
+    {
+      "anchor": {
+        "x": 1162.0,
+        "y": 294.79998779296875
+      },
+      "bounds": {
+        "position": {
+          "x": 1180.0,
+          "y": 282.79998779296875
+        },
+        "size": {
+          "height": 24.0,
+          "width": 233.0
+        }
+      },
+      "center": {
+        "x": 1296.5,
+        "y": 294.79998779296875
+      },
+      "collision_tuple": [
+        0,
+        0,
+        1
+      ],
+      "foreign_clearance": 0.0,
+      "foreign_intersections": [
+        {
+          "edge": "725f2e1b-aa2c-5615-9b1f-28da178168fa",
+          "relation_alias": "sa_repair_allocation",
+          "segments": [
+            1
+          ]
+        }
+      ],
+      "fraction": 0.44999998807907104,
+      "offset": {
+        "x": 134.5,
+        "y": 0.0
+      },
+      "own_clearance": 18.0,
+      "own_intersections": []
+    },
+    {
+      "anchor": {
+        "x": 1162.0,
+        "y": 254.1999969482422
+      },
+      "bounds": {
+        "position": {
+          "x": 1180.0,
+          "y": 242.1999969482422
+        },
+        "size": {
+          "height": 24.0,
+          "width": 233.0
+        }
+      },
+      "center": {
+        "x": 1296.5,
+        "y": 254.1999969482422
+      },
+      "collision_tuple": [
+        0,
+        0,
+        1
+      ],
+      "foreign_clearance": 0.0,
+      "foreign_intersections": [
+        {
+          "edge": "725f2e1b-aa2c-5615-9b1f-28da178168fa",
+          "relation_alias": "sa_repair_allocation",
+          "segments": [
+            1
+          ]
+        }
+      ],
+      "fraction": 0.550000011920929,
+      "offset": {
+        "x": 134.5,
+        "y": 0.0
+      },
+      "own_clearance": 18.0,
+      "own_intersections": []
+    },
+    {
+      "anchor": {
+        "x": 1162.0,
+        "y": 233.89999389648438
+      },
+      "bounds": {
+        "position": {
+          "x": 1180.0,
+          "y": 221.89999389648438
+        },
+        "size": {
+          "height": 24.0,
+          "width": 233.0
+        }
+      },
+      "center": {
+        "x": 1296.5,
+        "y": 233.89999389648438
+      },
+      "collision_tuple": [
+        0,
+        0,
+        1
+      ],
+      "foreign_clearance": 0.0,
+      "foreign_intersections": [
+        {
+          "edge": "725f2e1b-aa2c-5615-9b1f-28da178168fa",
+          "relation_alias": "sa_repair_allocation",
+          "segments": [
+            1
+          ]
+        }
+      ],
+      "fraction": 0.6000000238418579,
+      "offset": {
+        "x": 134.5,
+        "y": 0.0
+      },
+      "own_clearance": 18.0,
+      "own_intersections": []
+    },
+    {
+      "anchor": {
+        "x": 1162.0,
+        "y": 213.60000610351562
+      },
+      "bounds": {
+        "position": {
+          "x": 1180.0,
+          "y": 201.60000610351562
+        },
+        "size": {
+          "height": 24.0,
+          "width": 233.0
+        }
+      },
+      "center": {
+        "x": 1296.5,
+        "y": 213.60000610351562
+      },
+      "collision_tuple": [
+        0,
+        0,
+        1
+      ],
+      "foreign_clearance": 0.0,
+      "foreign_intersections": [
+        {
+          "edge": "725f2e1b-aa2c-5615-9b1f-28da178168fa",
+          "relation_alias": "sa_repair_allocation",
+          "segments": [
+            1
+          ]
+        }
+      ],
+      "fraction": 0.6499999761581421,
+      "offset": {
+        "x": 134.5,
+        "y": 0.0
+      },
+      "own_clearance": 18.0,
+      "own_intersections": []
+    },
+    {
+      "anchor": {
+        "x": 1162.0,
+        "y": 203.0
+      },
+      "bounds": {
+        "position": {
+          "x": 1180.0,
+          "y": 191.0
+        },
+        "size": {
+          "height": 24.0,
+          "width": 233.0
+        }
+      },
+      "center": {
+        "x": 1296.5,
+        "y": 203.0
+      },
+      "collision_tuple": [
+        0,
+        0,
+        1
+      ],
+      "foreign_clearance": 0.0,
+      "foreign_intersections": [
+        {
+          "edge": "725f2e1b-aa2c-5615-9b1f-28da178168fa",
+          "relation_alias": "sa_repair_allocation",
+          "segments": [
+            1
+          ]
+        }
+      ],
+      "fraction": 0.6761083602905273,
+      "offset": {
+        "x": 134.5,
+        "y": 0.0
+      },
+      "own_clearance": 18.0,
+      "own_intersections": []
+    }
+  ],
+  "input_bytes_and_complete_project_conserved": true,
+  "existing_output_guard": {
+    "command": [
+      "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\target-gnullvm\\debug\\examples\\diagram_readability_probe.exe",
+      "label-candidates",
+      "C:\\ar-diagram-01a0d717\\.local\\native-reading\\working\\eight-card.json",
+      "C:\\ar-diagram-01a0d717\\examples\\release1\\expected-diagnostics.json",
+      "00000000-0038-4000-8000-000000000001",
+      "63009b5f-539e-5914-b630-ec6b7fefb4d5",
+      "C:\\ar-diagram-01a0d717\\.local\\label-candidates-corrected.json"
+    ],
+    "exit_code": 1,
+    "stdout": "",
+    "stderr": "Error: Os { code: 80, kind: AlreadyExists, message: \"The file exists.\" }\n",
+    "path": "C:\\ar-compact-01a0d717\\.local\\package39\\bin;C:\\Windows\\System32;C:\\Windows",
+    "runtime_sha256": "f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4",
+    "input_unchanged": true,
+    "output_unchanged": true
+  }
+}
@@ -0,0 +1,33 @@
+{
+  "source": "70cf350d23ed3a47ca843754220e4f45fa51aa47",
+  "input_sha256": "9db1015369f450d5810c96a01fddb8a009d57f6aafbda5182703f15ded23d9c8",
+  "output_sha256": "3cc6a058fd7b16e1082b0aa38fa322147c129612fa3d27d30e54f7f75e63470b",
+  "binary_sha256": "9e07a8cf703c1c3247d2b6f9bc63468fd4ad902f49f0a13b290104177db5230a",
+  "runtime_sha256": "f45604a12e8bcd839fd86f667c1be1cc7c4f9da2b3c69ff381ac708f0e1ae7d4",
+  "files": {
+    "crates/oa-core/examples/diagram_readability_probe.rs": {
+      "bytes": 36267,
+      "sha256": "cbc6713a4974c77b1c8b44f12cb9e0a2271096bbbdbc883aae0c5ba9703ba483"
+    },
+    "crates/oa-core/src/routing.rs": {
+      "bytes": 53958,
+      "sha256": "b377fe80cece3892d64f62ba5e1578d8974eeefc2a317620f343a86f2f257fbd"
+    },
+    "examples/release1/model.json": {
+      "bytes": 134520,
+      "sha256": "ef0ef4006c3e09d5db6e1b621256b3f7d6642f3a7b09cc34607cfbcca830c727"
+    },
+    "examples/release1/expected-diagnostics.json": {
+      "bytes": 288,
+      "sha256": "3700393d76b940cfc076bf52861bd7b1f43370f8eabce3594531bd0bf1fc851e"
+    },
+    "harness/experiments/diagram-readability-20260929/eight-card-view.json": {
+      "bytes": 3641,
+      "sha256": "f851e7e96fc6f5b1edb328b94eb991aa8e94b14cc1bcd07b2c42d32310c4527b"
+    },
+    "Cargo.lock": {
+      "bytes": 119855,
+      "sha256": "2aa80d113c5112b31c0767b874845d60f555e4e8ae7eb3ecd0b4b91954b55378"
+    }
+  }
+}