From e2217ac8a043ee798e953bbe4a2e084df82683c0 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Thu, 22 Oct 2026 09:22:04 -0500 Subject: [PATCH 1/2] Prove retained-center port budget for every nonzero ambient quotient --- .../selective-quotient-port-budget/README.md | 120 +++++++++++++++ .../RESULT.json | 91 ++++++++++++ .../SOURCES.json | 24 +++ .../selective-quotient-port-budget/TASK.json | 85 +++++++++++ .../VERIFY.json | 21 +++ .../selective-quotient-port-budget/verify.py | 139 ++++++++++++++++++ 6 files changed, 480 insertions(+) create mode 100644 research/selective-quotient-port-budget/README.md create mode 100644 research/selective-quotient-port-budget/RESULT.json create mode 100644 research/selective-quotient-port-budget/SOURCES.json create mode 100644 research/selective-quotient-port-budget/TASK.json create mode 100644 research/selective-quotient-port-budget/VERIFY.json create mode 100644 research/selective-quotient-port-budget/verify.py diff --git a/research/selective-quotient-port-budget/README.md b/research/selective-quotient-port-budget/README.md new file mode 100644 index 0000000000..f20921446a --- /dev/null +++ b/research/selective-quotient-port-budget/README.md @@ -0,0 +1,120 @@ +# Every nonzero ambient quotient loses the retained local rank advantage + +**Scoped geometric proof and finite certificate; no new kappa.** Selecting only +the complex ports that survive a quotient cannot preserve the source's local +unpaid-rank advantage while retaining its eight center transports. This covers +every nonzero binary kernel, of every dimension, rather than just kernel 153 or +the 32 directions passing the earlier logical replay. It does not exclude +changed center words, nonquotient constructions, or all possible moment gains. + +The question arose while trying to repair DaysSky's #4629/#4633 quotient by +dropping incompatible ports and charging only surviving output contracts. +The preceding endpoint audits establish that keeping the old full-port invoice +is invalid. This package asks whether selecting a smaller valid port set saves +the quotient's local rank budget. The answer is no under the retained recipe. + +## Exact result + +Let V=F2^9. The source has 112 hyperplanes H_p complementary to its 112 +entrance lines P_p, and eight center hyperplanes C_i. The verifier extracts +their unique nonzero annihilators directly from the pinned canonical word. +Their disjoint union S is exactly the 120 vectors of Hamming weight 3 or 7. + +For any kernel K, a port retains a nonzero complementary entrance line after +quotienting exactly when K is contained in H_p. Write v(K) for the number of +such ports, and charge all eight retained center transports by their actual +image dimensions: + + c(K) = sum_i dim(image(C_i)). + +Then + + K = 0: v(K) - c(K) = 112 - 64 = 48; + every nonzero K: v(K) - c(K) <= 0. + +For one-dimensional kernels the complete balance distribution is 255 cases at +0, 255 at -8, and one at -64. Kernel 153 has 56 compatible ports, center charge +64 and balance -8. The seven directions with 64 compatible ports all retain +center charge 64. Re-padding unrelated helpers cannot alter this geometry. +Choosing fewer compatible ports can only lower the displayed balance. + +## Proof for every kernel dimension + +Let L=K-perp and r=dim L. A hyperplane with nonzero normal n contains K exactly +when n lies in L. Its image dimension is r-1 in that case and r otherwise. +Consequently + + v(K)-c(K) = |S intersect L| - 8r. + +It remains to bound |S intersect L| for r<=8. + +* For r=8 the exact 511-hyperplane census gives 255 intersections of size 64, + 255 of size 56 and one empty intersection. Thus the maximum is 8r. +* For r=7, L lies in exactly three hyperplanes. Each point of S inside L is + counted three times, and every point outside L once. Therefore + 120+2|S intersect L| <= 3*64, giving |S intersect L|<=36<56. +* For 1<=r<=6, S consists of odd-weight vectors. The parity functional on L + is either zero, giving an empty intersection, or takes value one on exactly + 2^(r-1) vectors. In this range 2^(r-1)<=8r. +* For r=0 both counts vanish. + +This is a dimension-uniform proof, not an assertion that enumerating line +kernels enumerates every higher-dimensional subspace. The coarse bounds for +r<=7 are not claimed sharp. [RESULT.json](RESULT.json) gives them explicitly. + +## Meaning for the controller + +The incumbent accounting lever is the number of unpaid central port directions +minus the center rank spend. Its value is 48 before quotienting. The repaired +selective-port version has a nonpositive value even before charging dropped-port +conversion, native normalizers, changed warps, boundary work and ordinary/outer +admission. Those costs are not assumed solved by this certificate. + +This rank statement is **not** a theorem that every concave target/paid moment +fails: a rank-mass comparison by itself is insufficient for that conclusion. +No full quotient program, scalar-field lift, replacement controller, new +ordinary supplier, or improved exponent is claimed. A changed circuit would +need its complete moment and physical contract checked separately. The result +identifies the center recipe as a premise that must change to recover a +positive local rank advantage, rather than declaring a universal barrier. + +## Reproduce + +From the repository root, standard-library CPython 3.12: + +```sh +python3.12 -B scripts/research_package.py --package research/selective-quotient-port-budget +python3.12 -I -O -B research/selective-quotient-port-budget/verify.py +``` + +The independent verifier authenticates the input, checks all 112 source splits, +extracts the 120 normals, computes all 511 line cases and verifies the numerical +bounds used in the written proof. Four geometry mutations are rejected; a +simultaneous change of frame bases preserves the complete result. It imports no +predecessor evaluator. Native circuit replay, phases, precision, compiler, +selected cold replay and human/formal review are outside its coverage. + +The optional current baseline command fails at this base with `KeyError: +'bit_lower'` because its expected certificate schema differs from the selected +record. It is not reported as a successful replay; this package uses the actual +selected record only as provenance and does not modify that unrelated helper. +The selected conditional saving is 0.00302015 at base +`b58ad9ef4d4e861b0eaa5dba41742bdc072dca51`. + +## Open next questions + +Can a changed center construction preserve valid native port maps while making +their count exceed its paid rank spend? First specify its exact center operator, +arbitrary-input restoration and a complete local invoice. The obstruction above +does not apply when that recipe changes. A larger kernel scan with the same +eight transports cannot reopen the rank question. See [TASK.json](TASK.json). + +## Credit + +Prepared by Cinna Davis with substantial OpenAI Codex assistance; Apache-2.0. +Credit DaysSky for the quotient experiments (#4596/#4629/#4633), Nick Petalas +for the kernel census (#4627), pinterbanget and Rohan Arun for endpoint checks, +and the preceding #4636 and local PR4633 repair audits. The source is zxv's +native construction with the retained E8/scalar/Clifford authors, Cinna Davis's +#4440/#4441/#4447/#4470 controller lineage, and Jacob Alan Sussman's mixed-target +recursion. No frozen source or selected-frontier file is changed. diff --git a/research/selective-quotient-port-budget/RESULT.json b/research/selective-quotient-port-budget/RESULT.json new file mode 100644 index 0000000000..6ade47d54c --- /dev/null +++ b/research/selective-quotient-port-budget/RESULT.json @@ -0,0 +1,91 @@ +{ + "all_kernel_dimension_bounds": [ + { + "dual_dimension": 0, + "kernel_dimension": 9, + "local_rank_balance_upper_bound": 0, + "port_and_center_normal_count_upper_bound": 0 + }, + { + "dual_dimension": 1, + "kernel_dimension": 8, + "local_rank_balance_upper_bound": -7, + "port_and_center_normal_count_upper_bound": 1 + }, + { + "dual_dimension": 2, + "kernel_dimension": 7, + "local_rank_balance_upper_bound": -14, + "port_and_center_normal_count_upper_bound": 2 + }, + { + "dual_dimension": 3, + "kernel_dimension": 6, + "local_rank_balance_upper_bound": -20, + "port_and_center_normal_count_upper_bound": 4 + }, + { + "dual_dimension": 4, + "kernel_dimension": 5, + "local_rank_balance_upper_bound": -24, + "port_and_center_normal_count_upper_bound": 8 + }, + { + "dual_dimension": 5, + "kernel_dimension": 4, + "local_rank_balance_upper_bound": -24, + "port_and_center_normal_count_upper_bound": 16 + }, + { + "dual_dimension": 6, + "kernel_dimension": 3, + "local_rank_balance_upper_bound": -16, + "port_and_center_normal_count_upper_bound": 32 + }, + { + "dual_dimension": 7, + "kernel_dimension": 2, + "local_rank_balance_upper_bound": -20, + "port_and_center_normal_count_upper_bound": 36 + }, + { + "dual_dimension": 8, + "kernel_dimension": 1, + "local_rank_balance_upper_bound": 0, + "port_and_center_normal_count_upper_bound": 64 + } + ], + "claim": "retained-center selective-port quotient rank budget only; no new kappa", + "controls": { + "basis_change_invariance": true, + "geometry_mutations_rejected": 4 + }, + "kernel_153": { + "compatible_ports": 56, + "kernel": 153, + "local_rank_balance": -8, + "retained_center_rank": 64 + }, + "line_balance_counts": { + "-64": 1, + "-8": 255, + "0": 255 + }, + "line_census_sha256": "865d17aa7a1eb1a965d2ff1fcf5d450e596799c708d15ddf67514efe95d2051c", + "line_compatible_port_counts": { + "0": 1, + "48": 7, + "52": 224, + "56": 48, + "60": 224, + "64": 7 + }, + "line_kernel_cases": 511, + "normal_weight_counts": { + "3": 84, + "7": 36 + }, + "source_centers": 8, + "source_ports": 112, + "unquotiented_local_rank_balance": 48 +} diff --git a/research/selective-quotient-port-budget/SOURCES.json b/research/selective-quotient-port-budget/SOURCES.json new file mode 100644 index 0000000000..1ab2e4b43b --- /dev/null +++ b/research/selective-quotient-port-budget/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "usage": "input", + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + } + ] +} diff --git a/research/selective-quotient-port-budget/TASK.json b/research/selective-quotient-port-budget/TASK.json new file mode 100644 index 0000000000..54c838cbb7 --- /dev/null +++ b/research/selective-quotient-port-budget/TASK.json @@ -0,0 +1,85 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. 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", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Prove the exact retained-center rank budget for selective native ports under every nonzero binary ambient quotient.", + "scope_change_reason": "User asks for a structural kappa breakthrough. After the preceding quotient endpoint audits, test the distinct repair of retaining only complementary ports and repricing all eight center images.", + "bottleneck_link": "Tests whether port selection can preserve the local unpaid rank advantage underlying the large quotient screen claims; it cannot under the retained center recipe.", + "budget_minutes": 60, + "stop_rule": "Finish the all-kernel proof and exact line census; do not infer a universal concave-moment obstruction from rank mass alone.", + "outcome": "completed", + "evidence": "README.md proof, RESULT.json and independently implemented verify.py", + "author": "Cinna Davis, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, implementation, verification and writing; no subagents.", + "open_questions": [ + { + "question": "Can a changed center recipe give a positive port-count minus center-rank balance with valid native endpoints?", + "why_it_matters": "Every nonzero quotient of the retained recipe has nonpositive balance, whereas the source has 48.", + "first_step": "Specify an exact center operator, arbitrary-input restoration and a fully charged local rank/moment profile before another kernel search.", + "blocked_by": "No changed center word and complete native invoice are supplied here." + } + ], + "overlap_coverage": { + "local": { + "head": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "records": 5860, + "head_records": 5860, + "complete_head_inventory": true, + "unsearched_head_paths": [] + }, + "open_prs": { + "fetched_at": "2026-10-22T14:06:57.031525+00:00", + "complete_pagination": true, + "records": 422 + }, + "discussions": { + "fetched_at": "2026-10-22T14:07:46.949234+00:00", + "complete_pagination": true, + "records": 3586 + } + } +} diff --git a/research/selective-quotient-port-budget/VERIFY.json b/research/selective-quotient-port-budget/VERIFY.json new file mode 100644 index 0000000000..73ace493a2 --- /dev/null +++ b/research/selective-quotient-port-budget/VERIFY.json @@ -0,0 +1,21 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "research/selective-quotient-port-budget/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "All source port splits, exact weight-three/seven normal set, all 511 line kernels, all kernel-dimension bounds, four rejecting geometry mutations and basis-change invariance." + } + ] +} diff --git a/research/selective-quotient-port-budget/verify.py b/research/selective-quotient-port-budget/verify.py new file mode 100644 index 0000000000..b219f3d12d --- /dev/null +++ b/research/selective-quotient-port-budget/verify.py @@ -0,0 +1,139 @@ +#!/usr/bin/env python3 +"""Exact selective-port quotient budget; Apache-2.0, Codex assistance.""" +from collections import Counter +from copy import deepcopy +import gzip +import hashlib +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCE = 'research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz' + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def span(basis): + values = {0} + for v in basis: + need(isinstance(v, int) and 0 <= v < 512, 'nine-bit vector') + values |= {x ^ v for x in values} + return values + + +def normal(basis): + need(len(basis) == 8 and len(span(basis)) == 256, 'hyperplane basis') + candidates = [n for n in range(1, 512) + if all((n & v).bit_count() % 2 == 0 for v in basis)] + need(len(candidates) == 1, 'unique nonzero normal') + return candidates[0] + + +def geometry(word): + frames, start, final = word['frames'], word['start'], word['final'] + need(word['v'] == 112 and len(start) == len(final) == 632, 'source inventory') + ports = [normal(frames[final[112 + i]]) for i in range(112)] + centers = [normal(frames[f]) for f in word['center_frames']] + need(len(centers) == 8, 'eight retained centers') + for i in range(112): + p, h = span(frames[start[i]]), span(frames[final[112 + i]]) + need(len(p) == 2 and p & h == {0}, 'source complementary port') + need(len(span(frames[final[i]])) == 512, 'full first main exit') + need(span(frames[start[112 + i]]) == {0}, 'ground second main entrance') + combined = ports + centers + expected = {n for n in range(1, 512) if n.bit_count() in (3, 7)} + need(len(set(combined)) == 120 and set(combined) == expected, + '112 ports plus eight centers are the weight-three/seven set') + return ports, centers + + +def census(ports, centers): + rows = [] + for k in range(1, 512): + v = sum((k & n).bit_count() % 2 == 0 for n in ports) + c = sum((k & n).bit_count() % 2 == 0 for n in centers) + rows.append({'kernel': k, 'compatible_ports': v, + 'retained_center_rank': 64 - c, 'local_rank_balance': v + c - 64}) + combined = Counter(r['compatible_ports'] + 64 - r['retained_center_rank'] for r in rows) + need(combined == {0: 1, 56: 255, 64: 255}, 'all 511 hyperplane counts') + need(max(r['local_rank_balance'] for r in rows) == 0, 'proper-line rank budget') + return rows + + +def verify(word): + ports, centers = geometry(word) + rows = census(ports, centers) + # A seven-space lies in three hyperplanes. Its points occur three times + # and the other points once: 120+2|S intersect L| <= 3*64. + seven_bound = (3 * 64 - 120) // 2 + need(seven_bound == 36 and seven_bound <= 8 * 7, 'codimension-two incidence bound') + bounds = [] + for r in range(9): + count = 0 if r == 0 else (64 if r == 8 else seven_bound if r == 7 else 2 ** (r - 1)) + need(count <= 8 * r, 'all proper dual subspace dimensions') + bounds.append({'dual_dimension': r, 'kernel_dimension': 9 - r, + 'port_and_center_normal_count_upper_bound': count, + 'local_rank_balance_upper_bound': count - 8 * r}) + return {'claim': 'retained-center selective-port quotient rank budget only; no new kappa', + 'source_ports': 112, 'source_centers': 8, 'normal_weight_counts': {'3': 84, '7': 36}, + 'unquotiented_local_rank_balance': 48, + 'line_kernel_cases': 511, + 'line_balance_counts': {str(k): v for k, v in sorted(Counter(r['local_rank_balance'] for r in rows).items())}, + 'line_compatible_port_counts': {str(k): v for k, v in sorted(Counter(r['compatible_ports'] for r in rows).items())}, + 'kernel_153': rows[152], + 'all_kernel_dimension_bounds': bounds, + 'line_census_sha256': hashlib.sha256(json.dumps(rows, sort_keys=True, separators=(',', ':')).encode()).hexdigest()} + + +def controls(word): + mutations = [] + bad = deepcopy(word) + bad['final'][112] = bad['start'][0] + mutations.append(bad) + bad = deepcopy(word) + bad['center_frames'][0] = bad['center_frames'][1] + mutations.append(bad) + bad = deepcopy(word) + bad['start'][0] = bad['final'][112] + mutations.append(bad) + bad = deepcopy(word) + frame = bad['final'][112] + bad['frames'][frame][-1] = bad['frames'][frame][0] + mutations.append(bad) + for bad in mutations: + try: + verify(bad) + except ValueError: + continue + raise ValueError('geometry mutation falsely accepted') + changed = deepcopy(word) + for b in changed['frames']: + if len(b) >= 2: + b[0] ^= b[1] + need(verify(changed) == verify(word), 'basis-change invariance') + return {'geometry_mutations_rejected': len(mutations), 'basis_change_invariance': True} + + +def main(): + pins = json.loads((HERE / 'SOURCES.json').read_text()) + pin = next(x for x in pins['files'] if x['path'] == SOURCE) + raw = (ROOT / SOURCE).read_bytes() + need(hashlib.sha256(raw).hexdigest() == pin['sha256'], 'source bytes') + word = json.loads(gzip.decompress(raw)) + result = verify(word) + result['controls'] = controls(word) + path = HERE / 'RESULT.json' + if '--write' in sys.argv: + path.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + else: + need(result == json.loads(path.read_text()), 'committed result equality') + print('PASS_SELECTIVE_QUOTIENT_PORT_BUDGET: 511 lines; all nonzero kernel dimensions; no new kappa') + + +if __name__ == '__main__': + main() From 9199dbfbd655237d977ddbba500628fd0b926e30 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Thu, 22 Oct 2026 09:23:19 -0500 Subject: [PATCH 2/2] Distinguish selective-port budget from concurrent mixed native interface --- research/selective-quotient-port-budget/README.md | 5 +++++ research/selective-quotient-port-budget/TASK.json | 13 +++++++------ 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/research/selective-quotient-port-budget/README.md b/research/selective-quotient-port-budget/README.md index f20921446a..a893a04791 100644 --- a/research/selective-quotient-port-budget/README.md +++ b/research/selective-quotient-port-budget/README.md @@ -78,6 +78,11 @@ need its complete moment and physical contract checked separately. The result identifies the center recipe as a premise that must change to recover a positive local rank advantage, rather than declaring a universal barrier. +Concurrent #4654 constructs an exact mixed type-A/type-B quotient interface. +Its type-B ports are not the retained complementary ports counted here. A +controller that consumes those changed interfaces escapes this selective-port +scope and remains a constructive next route; this result does not refute it. + ## Reproduce From the repository root, standard-library CPython 3.12: diff --git a/research/selective-quotient-port-budget/TASK.json b/research/selective-quotient-port-budget/TASK.json index 54c838cbb7..41af914230 100644 --- a/research/selective-quotient-port-budget/TASK.json +++ b/research/selective-quotient-port-budget/TASK.json @@ -66,20 +66,21 @@ "overlap_coverage": { "local": { "head": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", - "records": 5860, + "records": 5862, "head_records": 5860, "complete_head_inventory": true, "unsearched_head_paths": [] }, "open_prs": { - "fetched_at": "2026-10-22T14:06:57.031525+00:00", + "fetched_at": "2026-10-22T14:20:50.611470+00:00", "complete_pagination": true, - "records": 422 + "records": 425 }, "discussions": { - "fetched_at": "2026-10-22T14:07:46.949234+00:00", + "fetched_at": "2026-10-22T14:22:03.534515+00:00", "complete_pagination": true, - "records": 3586 + "records": 3588 } - } + }, + "concurrent_work": "PR4654 supplies a positive mixed A/B interface. This result counts only complementary retained ports, so it does not exclude a controller consuming the changed type-B interface." }