#!/bin/bash
# Description: Verify GSRF repository exists and check its license
# Check if GSRF repo is accessible and extract license info
gh repo view nesl/GSRF --json licenseInfo,name,pushedAt | jq '.'
# Also check number of commits and recent activity
gh api repos/nesl/GSRF/commits --paginate | jq '. | length'

#!/bin/bash
set -euo pipefail
echo "== Repo identity (nesl/GSRF) =="
gh repo view nesl/GSRF --json nameWithOwner,licenseInfo,pushedAt,defaultBranchRef --jq '{nameWithOwner,licenseInfo, pushedAt, defaultBranchRef}'
echo
echo "== Recent commit timestamps (nesl/GSRF) =="
gh api repos/nesl/GSRF/commits --per_page=5 --jq 'map({sha: .sha[0:7], committedDate: .commit.author.date})'
echo
echo "== LICENSE file presence (nesl/GSRF) =="
# Use GitHub contents API; if LICENSE missing, try LICENSE.txt
( gh api repos/nesl/GSRF/contents/LICENSE --jq '{path: .path, name: .name, encoding: .encoding, sha: .sha}' ) \
 || ( gh api repos/nesl/GSRF/contents/LICENSE.txt --jq '{path: .path, name: .name, encoding: .encoding, sha: .sha}' )

#!/bin/bash
set -euo pipefail
echo "== Recent commit timestamps (nesl/GSRF, last 5) =="
gh api repos/nesl/GSRF/commits -F per_page=5 -q '.[].commit.author.date' | cat
echo
echo "== Count of commits returned by a paginated fetch (nesl/GSRF) =="
# Fetch first ~ pages but keep it bounded; compute count of all returned pages
gh api repos/nesl/GSRF/commits --paginate -F per_page=100 --jq '. | length' | python3 - <<'PY'
import sys, re
total=0
for line in sys.stdin:
 line=line.strip()
 if not line: continue
 total += int(line)
print(total)
PY
echo
echo "== LICENSE file (presence + small content check) =="
# Try LICENSE then LICENSE.txt
for p in LICENSE LICENSE.txt; do
 if gh api "repos/nesl/GSRF/contents/$p" --jq -e '.path' >/dev/null 2>&1; then
 echo "-- Found: $p"
 # Get decoded text (GitHub API returns base64 in `content`), then grep key BSD 3-Clause terms
 gh api "repos/nesl/GSRF/contents/$p" --jq '.content' | python3 - <<'PY'
import sys,base64
s=sys.stdin.read().strip()
if not s:
 sys.exit(0)
txt=base64.b64decode(s).decode('utf-8','replace')
needles=["BSD 3-Clause","Redistribution and use","THIS SOFTWARE","University","nor the names of"]
print("BSD_MATCHES:", sum(n in txt for n in needles), "/ 6")
# Print first couple lines for manual confirmation (short)
lines=txt.splitlines()
print("\n".join(lines[:6]))
PY
 exit 0
 fi
done
echo "-- No LICENSE or LICENSE.txt found via contents API"

#!/bin/bash
set -euo pipefail
candidates=("GSRF" "gsrf" "Gsrf" "gsRf" "GsrF")
for repo in "${candidates[@]}"; do
 echo "== gh repo view nesl/$repo =="
 gh repo view "nesl/$repo" --json nameWithOwner,licenseInfo,pushedAt,defaultBranchRef -q '.'
 echo
done
echo "== Confirm REST repo object for likely correct casing =="
# Try the original casing first
gh api "repos/nesl/GSRF" --jq '{full_name, default_branch, has_issues, license: .license, pushed_at}' || true
gh api "/repos/nesl/GSRF" --jq '{full_name, default_branch, has_issues, license: .license, pushed_at}' || true
echo
echo "== Commits endpoint test (nesl/GSRF) =="
gh api "repos/nesl/GSRF/commits" -F per_page=1 --jq '.[0].commit.author.date' || true
gh api "/repos/nesl/GSRF/commits" -F per_page=1 --jq '.[0].commit.author.date' || true
echo
echo "== LICENSE presence check (nesl/GSRF) =="
for p in LICENSE LICENSE.txt; do
 echo "-- Trying contents/$p"
 gh api "repos/nesl/GSRF/contents/$p" --jq '{path: .path, name: .name}' || true
done

#!/bin/bash
set -euo pipefail
ADR="docs/adr/ADR-125-rf-gaussian-splatting-room-reconstruction.md"
echo "== ADR fenced code blocks (``` lines) =="
rg -n "^```" "$ADR" || true
echo
echo "== ADR snippets around fences =="
rg -n "^```" "$ADR" | cut -d: -f1 | head -n 20 | while read -r ln; do
 start=$((ln-2)); end=$((ln+4));
 sed -n "${start},${end}p" "$ADR" | nl -ba -w2 -s": " | sed "s/^/$ln:$ /" || true
done

echo
echo "== GSRF LICENSE presence + content check (nesl/GSRF) =="
LICENSE_CONTENT_B64=$(gh api "repos/nesl/GSRF/contents/LICENSE" --jq -r '.content')
python3 - <<'PY'
import os,base64,re,sys
b64=os.environ.get("LICENSE_CONTENT_B64","")
if not b64:
 print("No LICENSE content captured")
 sys.exit(0)
txt=base64.b64decode(b64).decode('utf-8','replace')
print("Contains 'BSD 3-Clause':", "BSD 3-Clause" in txt)
print("Contains 'Redistribution and use':", "Redistribution and use" in txt)
# Print a few representative lines
lines=txt.splitlines()
for i,line in enumerate(lines[:25],1):
 print(f"{i:02d}: {line}")
PY

echo
echo "== GSRF activity proxy (branches/main) =="
gh api "repos/nesl/GSRF/branches/main" --jq '{name:.name, commit_sha:.commit.sha, commit_date:.commit.committer.date}'

echo
echo "== GSRF last 3 commits via commit SHA (avoid list endpoint) =="
MAIN_SHA=$(gh api "repos/nesl/GSRF/branches/main" --jq -r '.commit.sha')
# Get commit details for HEAD (committer date)
gh api "repos/nesl/GSRF/commits/$MAIN_SHA" --jq '{sha:.sha[0:7], commit_date:.commit.committer.date, author_date:.commit.author.date}' || true

#!/bin/bash
set -euo pipefail
ADR="docs/adr/ADR-125-rf-gaussian-splatting-room-reconstruction.md"
echo "== ADR line count =="
wc -l "$ADR"
echo
echo "== ADR code fences (line numbers only) =="
rg -n "^```" "$ADR" || true

echo
echo "== ADR around start (lines 1-120) =="
sed -n '1,120p' "$ADR"

echo
echo "== GSRF LICENSE decode/check (nesl/GSRF) =="
b64="$(gh api "repos/nesl/GSRF/contents/LICENSE" --jq -r '.content')"
python3 - <<'PY'
import os,base64
b64=os.environ.get("B64","")
PY

#!/bin/bash
set -euo pipefail
ADR="docs/adr/ADR-125-rf-gaussian-splatting-room-reconstruction.md"
echo "== ADR total lines =="
wc -l "$ADR"
echo
echo "== ADR code fence lines (showing exact fence markers) =="
rg -n '^\`\`\`' "$ADR" | head -n 50
echo
echo "== ADR fences with no language (``` followed by optional whitespace only) =="
rg -n '^\`\`\`[[:space:]]*$' "$ADR" || true

echo
echo "== ADR context around line ~9 =="
sed -n '1,60p' "$ADR" | nl -ba -w2 -s": "

echo
echo "== ADR context around line ~95-110 =="
sed -n '90,130p' "$ADR" | nl -ba -w2 -s": "

echo
echo "== GSRF LICENSE decode/check (nesl/GSRF) =="
b64="$(gh api repos/nesl/GSRF/contents/LICENSE --jq -r '.content' 2>/dev/null || true)"
if [ -z "${b64}" ] || [ "${b64}" = "null" ]; then
 echo "LICENSE content missing/unavailable from API."
 exit 0
fi

python3 - <<'PY'
import os,base64
b64=os.environ.get("B64","")
PY

#!/bin/bash
set -euo pipefail
ADR="docs/adr/ADR-125-rf-gaussian-splatting-room-reconstruction.md"
echo "== ADR total lines =="
wc -l "$ADR"
echo
echo "== ADR code fence marker lines (exact) =="
rg -n '^```' "$ADR" || true
echo
echo "== ADR fences with no language (``` followed by only whitespace) =="
rg -n '^```[[:space:]]*$' "$ADR" || true

echo
echo "== ADR context around line 9 =="
sed -n '1,25p' "$ADR" | nl -ba -w2 -s": "

echo
echo "== GSRF LICENSE decode/check (nesl/GSRF) =="
b64="$(gh api repos/nesl/GSRF/contents/LICENSE --jq -r '.content' 2>/dev/null || true)"
if [ -z "$b64" ] || [ "$b64" = "null" ]; then
 echo "LICENSE content missing/unavailable from API."
 exit 0
fi

python3 - <<PY
import os,base64
b64=os.environ.get("B64","")
txt=base64.b64decode(b64).decode("utf-8","replace")
print("Contains 'BSD 3-Clause':", "BSD 3-Clause" in txt)
print("Contains 'Redistribution and use':", "Redistribution and use" in txt)
print("First 20 lines:")
for i,line in enumerate(txt.splitlines()[:20],1):
 print(f"{i:02d}: {line}")
PY

#!/bin/bash
set -euo pipefail
ADR="docs/adr/ADR-125-rf-gaussian-splatting-room-reconstruction.md"
echo "== ADR lines 70-130 =="
nl -ba "$ADR" | sed -n '70,130p'
echo
echo "== All triple-backtick fence markers in ADR =="
rg -n '```' "$ADR"
echo
echo "== GSRF branch/main commit date (nesl/GSRF) =="
gh api repos/nesl/GSRF/branches/main --jq '{name:.name, commit_sha:.commit.sha, committed_date:.commit.committer.date}' || true
echo
echo "== GSRF LICENSE decode/check (nesl/GSRF) =="
b64="$(gh api repos/nesl/GSRF/contents/LICENSE --jq -r '.content' 2>/dev/null || true)"
python3 -c "import os,base64; b=os.environ.get('B64',''); assert b; t=base64.b64decode(b).decode('utf-8','replace'); 
print('Has BSD 3-Clause:', 'BSD 3-Clause' in t); 
print('Has Redistribution and use:', 'Redistribution and use' in t);
print('First 12 lines:');
print('\\n'.join(t.splitlines()[:12]));" 2>/dev/null

#!/bin/bash
set -euo pipefail
ADR="docs/adr/ADR-125-rf-gaussian-splatting-room-reconstruction.md"
echo "== ADR fences (all) =="
rg -n '```' "$ADR" || true
echo
echo "== ADR lines 70-130 (with original line numbers) =="
awk 'NR>=70 && NR<=130 {printf "%4d: %s\n", NR, 0ドル}' "$ADR"
echo
echo "== GSRF branches/main metadata (nesl/GSRF) =="
gh api repos/nesl/GSRF/branches/main --jq '{name:.name, commit_sha:.commit.sha, committer_date:.commit.committer.date, author_date:.commit.commit.author.date}' || true
echo
echo "== GSRF LICENSE decode/check (nesl/GSRF) =="
b64="$(gh api repos/nesl/GSRF/contents/LICENSE --jq -r '.content' 2>/dev/null || true)"
if [ -z "${b64}" ] || [ "${b64}" = "null" ]; then
 echo "LICENSE content missing/unavailable from API."
 exit 0
fi
export B64="$b64"
python3 - <<'PY'
import os,base64
b64=os.environ["B64"]
txt=base64.b64decode(b64).decode("utf-8","replace")
print("Contains 'BSD 3-Clause':", "BSD 3-Clause" in txt)
print("Contains 'Redistribution and use':", "Redistribution and use" in txt)
print("Contains 'THIS SOFTWARE IS PROVIDED':", "THIS SOFTWARE IS PROVIDED" in txt)
print("First 12 lines:")
for i,line in enumerate(txt.splitlines()[:12],1):
 print(f"{i:02d}: {line}")
PY

ADR="docs/adr/ADR-125-rf-gaussian-splatting-room-reconstruction.md"
awk 'NR>=140 && NR<=160 {printf "%4d: %s\n", NR, 0ドル}' "$ADR"

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@docs/adr/ADR-125-rf-gaussian-splatting-room-reconstruction.md` at line 9,
Update ADR-125 to correct the GSRF reference by replacing or appending the
precise arXiv identifier "arXiv:2502.01826" and its full title ("GSRF:
Complex-Valued 3D Gaussian Splatting for Efficient Radio-Frequency Data
Synthesis") wherever GSRF is described (e.g., the Foundation line), verify the
stated license by reading the repository's LICENSE file and keep the
"BSD-3-Clause" only if it matches, remove or substantiate the claim in the ADR
that says "release stub (~8 commits, no active dev)" for GSRF (or replace it
with an accurate activity summary referencing recent commits/dates from the
repo), and fix the untyped markdown code fence by adding an appropriate language
tag (for example ```text) or reformatting the block in the ADR document.

- n_antennas = max(1, data[5])
- (n_subcarriers,) = struct.unpack_from("<H", data, 6)
+ n_antennas = int(data[5])
+ (n_subcarriers,) = struct.unpack_from("<H", data, 6)
+ if n_antennas < 1 or n_antennas > 4:
+ return None
+ if n_subcarriers < 1 or n_subcarriers > 256:
+ return None

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@python/wifi_densepose/rfgs/dataset.py` around lines 83 - 94, The parsing code
currently reads n_antennas and n_subcarriers from the header and then computes
iq_len/unpacks without bounds; add defensive checks before any unpacking:
validate n_subcarriers > 0, clamp/limit n_antennas and n_subcarriers to sensible
protocol maxima (e.g., MAX_ANTENNAS, MAX_SUBCARRIERS constants) and return None
when out of range, and only compute iq_len and call struct.unpack_from when
len(data) >= CSI_HEADER_SIZE + iq_len; update all uses of n_antennas,
n_subcarriers, CSI_HEADER_SIZE, and iq_len accordingly so malformed frames
cannot trigger huge allocations or expensive unpack operations.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@python/wifi_densepose/rfgs/dataset.py` around lines 85 - 89, The header
parsing uses hardcoded byte indices that don't match ADR-018; update the
channel/rssi/noise_floor/timestamp_us reads to use the ADR-018 wire offsets
(replace the literals in the struct.unpack_from calls and the direct data index
for channel with the correct offsets per ADR-018) and centralize those offsets
as named constants (e.g., ADR018_CHANNEL_OFFSET, ADR018_RSSI_OFFSET,
ADR018_NOISE_OFFSET, ADR018_TIMESTAMP_OFFSET) so the lines that set channel,
rssi, noise_floor, and timestamp_us use struct.unpack_from with those constants
instead of the current numeric indices.

- rx_ids = room.rx_node_ids()
- rx_id = rx_ids[0] if rx_ids else room.tx_node_id
- node = room.nodes[rx_id]
 out: list[CsiMeasurement] = []
 for fp in files:
 for line in fp.read_text().splitlines():
@@
 rec = json.loads(line)
+ rx_id = int(rec.get("node_id", room.tx_node_id))
+ if rx_id == room.tx_node_id:
+ continue
+ node = room.nodes.get(rx_id)
+ if node is None:
+ log.warning("jsonl row from unknown node_id=%s; skipping", rx_id)
+ continue
 amp = rec.get("subcarriers") or []

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@python/wifi_densepose/rfgs/dataset.py` around lines 283 - 313, The code
currently picks a single rx_id before iterating files and lines, causing every
JSONL record to be assigned that same receiver; instead, for each parsed record
(rec) determine the correct receiver id (e.g., check rec.get("node_id") or
rec.get("rx_id") and fall back to the previous rx_ids logic if absent), validate
it exists in room.nodes, then use that per-record rx_id when computing node =
room.nodes[rx_id] and freqs = room.freqs_for_node(rx_id, n_sub) and when
constructing the CsiMeasurement; if the record lacks an rx id keep the original
fallback behavior.

 def split(self, holdout: float = 0.1) -> tuple[list[int], list[int]]:
 """Deterministic train/held-out index split (last ``holdout`` fraction)."""
 n = len(self.measurements)
- k = max(1, int(n * holdout))
+ if not (0.0 <= holdout < 1.0):
+ raise ValueError("holdout must be in [0.0, 1.0)")
+ k = int(n * holdout)
 idx = list(range(n))
 return idx[: n - k], idx[n - k :]

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@python/wifi_densepose/rfgs/dataset.py` around lines 320 - 325, The split
method currently forces at least one held-out sample and doesn't validate the
holdout fraction; update split(self, holdout: float = 0.1) to validate that 0 <=
holdout < 1 (raise ValueError otherwise), allow holdout==0, compute k = int(n *
holdout) (no max(1,...)) and ensure k is at most n, handle n==0 by returning two
empty lists if needed, and return idx[: n - k], idx[n - k :] using the existing
variables (function split, variables n, k, idx).

 `@torch.no_grad`()
 def prune(self, min_opacity: float = 0.005) -> int:
 """Drop near-transparent Gaussians; returns the number removed."""
+ if self.num_gaussians == 0:
+ return 0
 keep = self.opacities() > min_opacity
+ if not keep.any():
+ keep[self.opacity_logit.argmax()] = True
 if keep.all():
 return 0
 removed = int((~keep).sum().item())
 self._reindex(keep.nonzero(as_tuple=True)[0])
 return removed

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@python/wifi_densepose/rfgs/model.py` around lines 129 - 136, The prune method
can drop all Gaussians if every opacity is ≤ min_opacity; update prune (and its
use of opacities(), keep, and _reindex) to ensure at least one Gaussian remains:
if keep.any() is False, choose the index of the maximum opacity (e.g., via
opacities().argmax()) and set keep for that index to True before calling
_reindex; preserve the removed count semantics (i.e., count everything except
the one forced-kept Gaussian).

- to_rx = mu - rx
+ to_rx = rx - mu
 d_rx = to_rx.norm(dim=-1).clamp_min(1e-3) # [N]
 dirs = to_rx / d_rx.unsqueeze(-1) # [N,3] g->rx direction

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@python/wifi_densepose/rfgs/render.py` around lines 66 - 68, The vector from
Gaussian to receiver is currently computed as to_rx = mu - rx (used to compute
dirs and passed to directional_basis and the antenna steering term), which
inverts the documented g->rx direction; change the sign to compute to_rx = rx -
mu (and recompute d_rx and dirs from that) and apply the same sign flip to any
repeated computations around the antenna steering code (references: to_rx, mu,
rx, dirs, directional_basis, and the antenna steering/phase calculation) so the
directional_basis input and per-antenna phase pattern use the correct g->rx
direction.

 tracer = ReferenceTorchTracer()
 train_idx, hold_idx = dataset.split(holdout)
+ if not train_idx:
+ raise ValueError(
+ "training split is empty; reduce holdout or provide more measurements"
+ )
 opt = torch.optim.Adam(field.parameters(), lr=lr)

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@python/wifi_densepose/rfgs/train.py` around lines 130 - 156, After calling
dataset.split(holdout) save and check train_idx before training: if train_idx is
empty, avoid calling batch_loss(..., grad=True) and loss.backward(); instead log
or raise and skip the training loop. Concretely, after train_idx, hold_idx =
dataset.split(holdout) add an explicit guard (e.g., if len(train_idx) == 0:)
that either logs an error/warning and returns/raises (so the subsequent
opt.zero_grad(), batch_loss(..., grad=True), and loss.backward() are never
executed) or falls back to a safe behavior; reference the batch_loss, train_idx,
loss.backward, and opt.zero_grad symbols so the check is inserted in the same
scope.

 if densify_every and step > 0 and step % densify_every == 0:
- removed = field.prune(min_opacity=0.005)
- added = field.densify_clone(grad_norm, threshold=grad_norm.mean().item() * 2)
+ added = field.densify_clone(
+ grad_norm, threshold=grad_norm.mean().item() * 2
+ )
+ removed = field.prune(min_opacity=0.005)
 if removed or added:
 opt = torch.optim.Adam(field.parameters(), lr=lr) # params changed
 log.info("step %d densify: +%d/-%d -> %d Gaussians",
 step, added, removed, field.num_gaussians)

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@python/wifi_densepose/rfgs/train.py` around lines 162 - 165, The code
computes grad_norm then prunes before densifying, so pruning shifts Gaussian
indices and makes densify_clone(grad_norm, ...) act on stale indices; to fix,
call field.densify_clone(grad_norm, threshold=grad_norm.mean().item() * 2)
before field.prune(min_opacity=0.005) (i.e., swap the two calls inside the
densify_every block) and then compute/inspect the boolean results
(added/removed) from those calls in the new order so densify operates on the
original index mapping.