Skip to content

T21: pace the map and the pose by the belief commit - #164

Merged
superposition merged 4 commits into
mainfrom
ticket/T21
Sep 11, 2026
Merged

superposition merged 4 commits into
mainfrom
ticket/T21

Conversation

@superposition

Copy link
Copy Markdown
Owner
agent: ResumeT21
branch: ticket/T21
commit: fd5d1df
state: review
next: reviewer merges; #36 closes on merge
blocked_on: none
evidence: map 14 unit + 4 e2e and pose 25 unit + 3 e2e green on x86_64 and on Pinkie aarch64; live probe `qualia-pose: belief pace: stale, publishing pose at 1605 ms` at 1.31 s; python C:/tmp/gate.py -> provenance: OK

What this does

Step 21 of #7. qualia-map and qualia-pose now hold a publish back until the
belief layers have committed recently, so a map or pose update cannot outrun
the belief it is conditioned on. The window is QUALIA_BELIEF_PACE_MS
(default 250); a layer commits by flipping its slot's write index, so the
front buffer's timestamp_ns — already part of the shared ABI — is the newest
accepted tick. When every layer has been silent for pace * 8, the publisher
goes ahead anyway and says so:

qualia-map: belief pace: stale, publishing map at {lag} ms
qualia-pose: belief pace: stale, publishing pose at {lag} ms

Navigation degrades instead of stopping, which is the point of the gate.
QUALIA_BELIEF_PACE_MS=0 disables it and leaves both runners behaving exactly
as they did before.

Why the pose half is re-applied, not merged

#135 (25f2b6f) replaced runners/pose/src/main.rs wholesale with the
re-authored estimator. The branch was held back for exactly that reason, and
this PR merges origin/main with main's file as the resolution base and
re-applies only the pace gate on top of it:

  • DEFAULT_BELIEF_PACE_MS, BELIEF_PACE_STALE_WINDOWS, now_ns,
    newest_belief_tick_ns, and BeliefPaceGate with its
    fresh/lagging/stale classification;
  • the QUALIA_BELIEF_PACE_MS setting and the pre-publish wait in main,
    wired to main's Bootstrapped/Tracked outcomes so nothing publishes
    without passing the gate;
  • the pace unit tests and two end-to-end tests.

git diff origin/main is the four files below and nothing else; the pose
delta against main's file is the gate and its tests.

  • runners/map/src/main.rs, runners/map/tests/runtime.rs
  • runners/pose/src/main.rs, runners/pose/tests/smoke.rs

Verification

Host (x86_64, -j 4):

  • cargo build -p qualia-map -p qualia-pose clean.
  • cargo test -p qualia-map: 14 unit + 4 end-to-end pass, including
    publishes_when_belief_lag_exceeded and
    waits_while_belief_is_inside_the_stale_window.
  • cargo test -p qualia-pose: 25 unit + 3 end-to-end pass, including the five
    pace unit tests, both pace end-to-end tests, and the accumulator tests C25 pose: reauthor internals to clear the clean-room overlap gate #135
    added (observe_tracks_curved_motion_through_anchor_intervals).
  • Live probe of the real binary against a scratch region with a belief tick
    300 ms old under QUALIA_BELIEF_PACE_MS=200: the runner held the first pose
    for 1.31 s, then printed
    qualia-pose: belief pace: stale, publishing pose at 1605 ms and published —
    the 1.6 s stale window released it, as designed. The probe was a throwaway
    and is not part of the diff.
  • python C:/tmp/gate.py -> provenance: OK.

Board (Pinkie, jetson@192.168.55.1, aarch64, -j 2): the two packages build
(ELF 64-bit LSB pie executable, ARM aarch64) and both suites pass there —
map 14 unit + 4 end-to-end, pose 25 unit + 3 end-to-end. The board has no DNS,
so the tree was shipped as a tarball and built --offline against the cached
registry with the workspace members trimmed to crates/types, crates/shm,
runners/map, runners/pose; the board exercise is done, not pending.

Closes #36

Add QUALIA_BELIEF_PACE_MS (default 250) to qualia-map and qualia-pose. Before
a scan is integrated or a pose is published, the runner waits until the newest
accepted belief commit, read from the layer slots' front-buffer timestamps, is
younger than the pace window. A belief silence past QUALIA_BELIEF_PACE_MS * 8
releases the publish anyway and logs the measured lag, so navigation degrades
instead of stopping. A pace of zero disables the gate.

Tests: pace classification, layer-tick selection, the disabled gate and the
stale release in both crates, plus two end-to-end qualia-map checks that the
binary publishes when belief lags past the stale window and holds while belief
is only lagging.
… pose rewrite

#135 (25f2b6f) replaced runners/pose/src/main.rs wholesale, so the conflict is
resolved by taking main's re-authored estimator as the base and re-applying
only the pace-gate change on top of it:

- DEFAULT_BELIEF_PACE_MS / BELIEF_PACE_STALE_WINDOWS, the BeliefPaceGate and
  its fresh/lagging/stale classification, and newest_belief_tick_ns;
- the QUALIA_BELIEF_PACE_MS setting and the pre-publish wait in main, wired to
  main's Bootstrapped/Tracked outcomes;
- the pace unit tests, plus end-to-end coverage of both the stale-release and
  the inside-the-window wait through the real binary.

The map half merges unchanged.
@superposition

Copy link
Copy Markdown
Owner Author
role: correctness
verdict: approve
notes: 0

Reviewed sha fd5d1dfaf8262733bb5ad329d7b13562454f873d — git rev-parse HEAD matches gh pr view 164 --json headRefOid. git merge-base origin/main HEAD = a4bf10b, and git diff --name-status a4bf10b..HEAD is exactly the four ticket files (runners/map/src/main.rs, runners/map/tests/runtime.rs, runners/pose/src/main.rs, runners/pose/tests/smoke.rs). #135's merge 25f2b6f is an ancestor of a4bf10b (git merge-base --is-ancestor → 0), so the pose half really is re-applied on the re-authored estimator. origin/main has since advanced to 19dcd68, but git log --oneline a4bf10b..origin/main -- runners/map runners/pose is empty, so the delta against current main is still these four files; the other paths in origin/main..HEAD are main-side rewrites this branch predates, not branch edits.

Build and suites (host, x86_64)

cargo build -p qualia-map -p qualia-pose -j 2 → clean.
cargo test -p qualia-map -j 2 (three consecutive runs):

test result: ok. 14 passed; 0 failed ... finished in 0.30s / 0.32s / 0.25s
test result: ok. 4 passed; 0 failed ... finished in 1.34s / 1.34s / 1.35s

cargo test -p qualia-pose -j 2 (three consecutive runs):

test result: ok. 25 passed; 0 failed ... finished in 0.09s / 0.07s / 0.09s
test result: ok. 3 passed; 0 failed ... finished in 1.34s / 1.33s / 1.34s

Matches the PR's numbers, stable across repeats. The e2e tests are behaviour tests: both spawn the real binary (CARGO_BIN_EXE_qualia-map / qualia-pose) and assert the emitted stale line, the lag parsed out of it, and the published state (map_grid().seq/log-odds, robot_pose.confidence).

Falsification: real binaries against scratch SHM

Throwaway probe under C:/tmp/Rev164Correct/probe (path-deps on the worktree crates, never placed in the worktree). It creates the region, commits layer ticks with LayerWriter exactly as a belief runner does, publishes a 200-point scan, spawns the real binary and times every stdout line. Selected output:

### pose-fresh [pose pace=250]           tick 100 ms old
  [+    5.8 ms] qualia-pose: starting lidar pose graph from shm=...
  [+    5.8 ms] qualia-pose: initialized pose from first scan points=200
  PUBLISHED at +7.8 ms          stale lines: 0

### pose-stale [pose pace=250]           tick 10 s old
  [+    3.9 ms] qualia-pose: belief pace: stale, publishing pose at 10003 ms
  PUBLISHED at +5.7 ms          stale lines: 1

### pose-pr-claim-pace200-tick300 [pose pace=200]   (reproduces the PR's probe)
  [+ 1308.3 ms] qualia-pose: belief pace: stale, publishing pose at 1608 ms
  PUBLISHED at +1309.7 ms       stale lines: 1
### map-pr-claim-pace200-tick300 [map pace=200]
  [+ 1308.8 ms] qualia-map: belief pace: stale, publishing map at 1608 ms
  PUBLISHED at +1311.8 ms       stale lines: 1

### pose-just-under [pace=250]           tick held committed at 240 ms old
  PUBLISHED at +4.2 ms          stale lines: 0
### pose-just-over  [pace=250]           tick held committed at 260 ms old
  (held; committer stopped at +1.2 s)
  [+ 2951.1 ms] qualia-pose: belief pace: stale, publishing pose at 2010 ms
  PUBLISHED at +2952.5 ms       stale lines: 1
### map-just-over   [pace=250]
  [+ 2944.3 ms] qualia-map: belief pace: stale, publishing map at 2006 ms
  PUBLISHED at +2947.7 ms       stale lines: 1

### pose-lag-then-fresh [pace=250]       tick 300 ms old, refreshed fresh at +800 ms
  [+  808.7 ms] qualia-pose: initialized pose from first scan points=200
  PUBLISHED at +809.1 ms        stale lines: 0
### map-lag-then-fresh
  PUBLISHED at +804.2 ms        stale lines: 0

### pose-absent-pace0 / map-absent-pace0  (no belief layer, QUALIA_BELIEF_PACE_MS=0)
  PUBLISHED at +3.6 / +5.5 ms   stale lines: 0

What this establishes on both runners, through the real binaries: a lag inside the pace window releases at once; a lag outside it holds (240 ms vs 260 ms brackets the 250 ms default); the release happens once the silence passes pace*8 and reports the measured lag (2010/2006 ms against a 2000 ms threshold); a fresh commit during the hold releases within one poll (≈9 ms with POLL_MS=10); QUALIA_BELIEF_PACE_MS=0 disables the gate; and the stale line reports an integer millisecond lag. The PR's quoted 1.31 s / 1605 ms probe reproduced at 1.308 s / 1608 ms.

What I could not falsify, and the edge I did find

  • Exactly at the threshold. classify is lag_ms < pace_ms → Fresh, lag_ms <= pace_ms*8 → Lagging, else Stale, so lag == pace holds and lag == pace*8 still waits — the strict reading of the ticket ("younger than", "longer than"). Equality is not reachable through the binary (lag is recomputed from the wall clock) and no unit test pins it (they use 100 vs 1000 ms at pace 250, and 50 vs 90 ms at pace 10). Semantics match the ticket by inspection; the boundary itself is untested.
  • Belief layer absent entirely. With no layer committed at all the gate measures lag from its own creation, so a publication attempted in the first pace_ms of run time is released unpaced and silently (pose-absent, map-absent: PUBLISHED at +6.1/+6.3 ms, 0 stale lines), while one attempted later holds to pace*8 and then logs (pose-absent-scan-at-1s → held to +2010 ms, ...at-2.5s → +2507 ms, lag 2005/2502 ms). The branch's own unit test deliberately blesses this (cold_layers_wait_out_the_stale_window_then_publish asserts classify(None, start) == Fresh), the doc comment on lag_ms states it, and the impact is bounded to the first update at boot, so I am not calling it a defect — but it is the one place the gate lets a publication out with no belief commit behind it, and the test's name does not describe what its assertions check. Worth a follow-up line in the ticket, not a change request.
  • A persistently silent belief layer logs the stale line on every publish (the gate has no rate limit; the map already rate-limits its skip warning to one per 2 s). Ticket does not require rate limiting, so noted only.
  • newest_belief_tick_ns reads the front buffer of an 8-slot double buffer whose writer only ever fills the back buffer and publishes with a Release store read back with an Acquire load, so a tick it sees is a completed commit; BeliefSlot::timestamp_ns is wall-clock UNIX ns (crates/shm::now_ns), the same clock the runners' now_ns uses, so the lag arithmetic is not cross-clock. Could not falsify.

Clean-room

cd C:/Users/ericm/wt/T21 && python C:/tmp/gate.py →
provenance: compared 120 authored file(s) (1 generated skipped); 0 byte-identical, 6 code runs over 20, 0 prose runs over 2 / provenance: OK. Also re-ran on an LF tree (git clone --shared, git -c core.autocrlf=false checkout fd5d1df, verified CR bytes: 0) → identical summary, so the CRLF checkout is not masking anything. The six over-threshold runs are all in files the diff does not touch — crates/types/src/lib.rs 40, kernels/evidence_layout.cu 31, crates/sync-types/src/lib.rs 30, runners/agent/Cargo.toml 24, crates/jepa-dataset/src/lib.rs 23, crates/sync-types/src/spatial.rs 21 — i.e. inherited. At --max-run 6 neither changed src/main.rs is listed, so the longest identical run between the two changed runners and their reference counterparts is ≤ 6 lines. The pace gate and its log strings do not exist anywhere under C:/qualia (grep for BELIEF_PACE|belief pace|BeliefPace → no matches), so nothing here is copied from the reference.

Contract

Only new interface name is QUALIA_BELIEF_PACE_MS (default 250, both runners); git grep finds it in exactly the two runners and their tests, and it is absent from the reference, so there is no reference string it must match. The emitted line qualia-map: belief pace: stale, publishing map at {lag} ms contains the ticket's required belief pace: stale, publishing map at {lag} ms verbatim, and pose mirrors it with publishing pose. No new dependency (LayerReader, ShmRegion, NUM_LAYERS are existing qualia-shm exports), no SHM/JSON field, exit code or manifest change, and no ROS-graph write.

Not verified here

The aarch64/Pinkie claim. This host had no aarch64 target; I added aarch64-unknown-linux-gnu and cargo check -p qualia-map -p qualia-pose --target aarch64-unknown-linux-gnu -j 2 finished clean, which is a type-check only (no aarch64 linker here). ssh jetson@192.168.55.1 answered but rejected this workstation (Permission denied (publickey,password)), so the board build and the on-board suite runs in the PR body are taken on the author's word.

agent: Rev164Correct
branch: none (review only)
commit: fd5d1dfaf8262733bb5ad329d7b13562454f873d
state: review
next: merge #164; its delta against current main (19dcd68) is still only the four ticket files
blocked_on: none
evidence: real-binary probe at pace 250: tick 240 ms old -> published +4.2 ms, 0 stale lines; tick 260 ms old -> held, then `qualia-pose: belief pace: stale, publishing pose at 2010 ms` at +2951.1 ms; PR's own probe (pace 200, tick 300 ms) reproduced at +1308.3 ms / `at 1608 ms` on pose and map

@superposition

Copy link
Copy Markdown
Owner Author
role: clean-room
verdict: approve
notes: 0

Reviewed sha fd5d1dfaf8262733bb5ad329d7b13562454f873d — git rev-parse HEAD == gh pr view 164 --json headRefOid; git merge-base origin/main HEAD = a4bf10b, and git diff --name-status a4bf10b..HEAD is exactly the four ticket files (runners/map/src/main.rs, runners/map/tests/runtime.rs, runners/pose/src/main.rs, runners/pose/tests/smoke.rs).

Measured trees: worktree C:/Users/ericm/wt/T21 @ fd5d1df (LF, core.autocrlf=false inherited from the main checkout) vs reference C:/qualia @ 733329d (CRLF, its own core.autocrlf=true). The EOL mismatch is the caveat in the reverse direction from the ticket note: the raw gate reads the reference's CRLF working tree, so it can only report false negatives, and I re-measured on LF-normalised content.

Gate. cd C:/Users/ericm/wt/T21 && python C:/tmp/gate.py:

provenance: compared 120 authored file(s) (1 generated skipped); 0 byte-identical, 6 code runs over 20, 0 prose runs over 2
provenance: highest identical-code-line share 1.000 (.cargo/config.toml)
CODE RUN 40: crates/types/src/lib.rs
CODE RUN 31: kernels/evidence_layout.cu
CODE RUN 30: crates/sync-types/src/lib.rs
CODE RUN 24: runners/agent/Cargo.toml
CODE RUN 23: crates/jepa-dataset/src/lib.rs
CODE RUN 21: crates/sync-types/src/spatial.rs
provenance: OK

None of the six reported runs is in the diff; all six files are untouched by this PR (inherited on the merged base).

No byte-identical file. LF-normalised re-scan of all 121 shared paths (my own script using the gate's code_line/prose_line/longest_run): 42 files byte-identical after normalisation — every one is a manifest/build-contract file (runners/*/Cargo.toml, crates/*/Cargo.toml, .cargo/config.toml, Cross.toml, config/stack-manifest.zero-motion.json), i.e. the legitimate class the ticket note names. None of the four changed files is among them. Per changed file, normalised:

file code run prose run identical-code-line share normalised byte-identical
runners/map/src/main.rs 6 0 0.241 (142/590) no
runners/pose/src/main.rs 2 0 0.046 (42/907) no
runners/map/tests/runtime.rs no reference counterpart – – –
runners/pose/tests/smoke.rs no reference counterpart – – –

Longest runs, quoted; all inherited, none authored here. The three 6-line runs in runners/map/src/main.rs are all outside the PR's hunk ranges (git diff -U0 adds only new-file lines 11-13, 18, 59-62, 76, 94, 106-190, 205, 247-250, 543, 833-921), so they are context carried from main's map runner:

  • new-file 372-377 vs ref 192-197: let binary = shm.binary_map_mut(); / binary.width = MAP_GRID_W as u32; / binary.height = MAP_GRID_H as u32; / binary.resolution_m = MAP_RESOLUTION_M; / binary.origin_x_m = map.origin_x_m; / binary.origin_y_m = map.origin_y_m; — ABI field list on the shared BinaryMapGrid.
  • new-file 314-319 vs ref 149-154: binary.last_update_ns = 0; / binary.occupied_cells = 0; / binary.free_cells = 0; / binary.unknown_cells = MAP_GRID_CELLS as u32; / binary.cells.fill(0); / binary.seq.store(1, Ordering::Release); — ABI field resets + constant.
  • new-file 286-291 vs ref 123-128: fn init_map_grid(shm: &ShmRegion, reset_on_start: bool) { … — public-signature + MAP_GRID_W/MAP_GRID_H/seq geometry checks.

Contract-forced, not copied: the map file's 119 distinct shared code lines are constants (LOG_ODDS_*, OCCUPIED_THRESHOLD, MIN/MAX_INTEGRATION_RANGE_M, MAP_RESOLUTION_M, the DEFAULT_*), ABI field names, public fn signatures, and the two emitted format strings "qualia-map: skip integration pose_conf=… " / "qualia-map: map_seq=… last_update_ns={}" (D-008 operator strings). pose/src/main.rs shares at most 2 consecutive code lines and 42/907 lines total, all of the same classes.

The new gate code is authored here. Whole-reference git grep over C:/qualia returns zero hits for every identifier the PR introduces: BeliefPaceGate 0, BeliefPace 0, newest_belief_tick_ns 0, await_pace 0, lag_ms 0, belief pace 0, BELIEF_PACE 0, and git grep -rn "belief pace" . | wc -l → 0. The emitters qualia-map: belief pace: stale, publishing map at {lag_ms} ms and qualia-pose: belief pace: stale, publishing pose at {lag_ms} ms are absent from the reference (reference map/pose print only starting …, the skip line, and map_seq=/pose status lines). The reference map's now_ns uses .map(|d| …) whereas the branch uses .map(|elapsed| …), so even the helper clears the threshold (longest shared run 3).

No shared prose. Normalised prose runs: 0 in all four files; the only comment lines that appear verbatim in the reference set are #[cfg(test)], #[test], #[derive(Clone, Copy, Debug, PartialEq, Eq)] and bare //!//// markers. Every added doc sentence is unique to the PR, verified individually (Publishing is paced by the belief layers, Holds a publisher back until the belief layers, Newest accepted belief tick across the layer slots, Publish a belief tick the way a belief runner commits one, How far the newest belief commit lags, What the belief pace gate decided about one publish → 0 reference hits each).

No mirrored test body. runners/map/tests/ and runners/pose/tests/ do not exist in the reference tree, so there is no counterpart to mirror; and a cross-path scan of each of the four changed files against every reference file found zero runs >12 code lines or >2 prose lines. The new e2e tests assert observable output (belief pace: stale, publishing map/pose at, parsed {lag} ms, published map_grid().seq == 2, pose confidence > 0), not reference text.

agent: Rev164Clean
branch: none (review only)
commit: fd5d1df
state: review
next: merge #164; no clean-room findings
blocked_on: none
evidence: LF-normalised scan of the four changed files vs C:/qualia -> longest code run 6 (map) / 2 (pose), prose run 0, no normalised byte-identity, and 0 reference hits for every new gate identifier; raw gate from C:/Users/ericm/wt/T21 prints "provenance: OK"

@superposition

Copy link
Copy Markdown
Owner Author
role: contract
verdict: approve
notes: 0

Reviewed sha fd5d1dfaf8262733bb5ad329d7b13562454f873d — gh pr view 164 --json headRefOid and git ls-remote origin refs/heads/ticket/T21 both give fd5d1dfa…. Reviewed from a scratch copy (git archive HEAD | tar -x), never inside the ticket worktree.

Scope

git merge-base origin/main fd5d1dfa → a4bf10b87defbc1324fa5db5b1c905fd83af8d10; git diff --name-status a4bf10b..fd5d1dfa:

M	runners/map/src/main.rs
M	runners/map/tests/runtime.rs
M	runners/pose/src/main.rs
M	runners/pose/tests/smoke.rs

Exactly the two packages the ticket names, source and tests, nothing else. git log --oneline a4bf10b..origin/main -- runners/map runners/pose is empty, so although origin/main has since advanced to a28736f, the delta against current main is still these four files.

Interface

  • Package / binary names unchanged: runners/map/Cargo.toml name/[[bin]] = qualia-map, pose = qualia-pose; neither manifest is in the diff, there are no feature flags or dependency changes, and the e2e tests still spawn CARGO_BIN_EXE_qualia-map / CARGO_BIN_EXE_qualia-pose.
  • Public types, signatures, constants: the diff adds no pub item. BeliefPace, BeliefPaceGate::{new, lag_ms, classify, await_pace}, newest_belief_tick_ns, pose's now_ns, and the constants DEFAULT_BELIEF_PACE_MS = 250 / BELIEF_PACE_STALE_WINDOWS = 8 are all file-private, and 250 / × 8 are the ticket's numbers. Map reuses its pre-existing now_ns; pose adds one, as drive and explore already do. The stale boundary is the ticket's strict reading: lag <= pace*8 keeps waiting, so release needs a silence longer than pace*8.
  • SHM / ABI: read-only, nothing added or reworded. LayerReader::new(shm.layer_slot(layer)).read().timestamp_ns over 0..NUM_LAYERS is the access pattern runners/health, runners/watch and crates/cuda already use, and LayerReader / LayerWriter / NUM_LAYERS / layer_slot are existing qualia-shm exports. No field, offset, size or JSON/wire name changes; no exit code or stderr diagnostic changes. The only removed line in the whole diff is the QUALIA_POSE_POLL_MS var read, refactored into poll_ms.
  • The field the gate reads is the one the ticket points at ("the belief layers' existing tick timestamps"): BeliefSlot.timestamp_ns is stamped wall-clock UNIX ns at commit time (crates/cuda, now_ns() = SystemTime/UNIX_EPOCH), and both runners compare it against a wall-clock now_ns, so there is no cross-clock arithmetic. The region is zero-filled at creation, so an uncommitted front buffer reads timestamp_ns == 0 and the != 0 filter cannot mistake "never" for a tick. The ABI is consumed as-is at an existing #[repr(C)] field.

Emitted lines (the question against the ticket text)

The diff adds exactly two print* calls and no other emitted string:

qualia-map: belief pace: stale, publishing map at {lag_ms} ms
qualia-pose: belief pace: stale, publishing pose at {lag_ms} ms
  • Ticket authorisation / reference duty. Ticket T21 Belief-paced map/pose #36 Step 21 names one line: belief pace: stale, publishing map at {lag} ms. The map line is that string verbatim — checked mechanically: strip the qualia-map: prefix and normalise {lag_ms} → {lag}, and the equality holds. The qualia-<runner>: prefix is the repo's operator-log convention rather than new vocabulary (all eight runners use it; D-008's own examples are qualia-pose: / qualia-lidar:). The reference tree contains no belief pace, no BELIEF_PACE / QUALIA_BELIEF_PACE_MS, and no publishing map / publishing pose, so D-008's byte-identity rule does not bind either line and D-009's "no re-wording of an emitted value" has no reference value to re-word. The ticket is the authority here, and it authorises this line.
  • The pose wording is the ticket's only coherent reading, approved as such. Step 21's sentence states the rule for both runners — "Add QUALIA_BELIEF_PACE_MS … to runners/map and runners/pose: before publishing a new Map or pose update into SHM … publish anyway and log …" — so the literal map in the log string is the map instance of a rule stated for both. A pose publisher printing publishing map would be a false diagnostic to operators, which is the failure D-009 exists to prevent; pose names the artefact this runner actually publishes. This is the one string in the PR not verbatim in the ticket, and I am recording the interpretation as the decision so no later pass has to re-litigate it: ticket intent, not a deviation.
  • New config naming. QUALIA_BELIEF_PACE_MS, default 250, in both runners: byte-identical to the ticket and consistent with the repo's convention (shared variables unprefixed like QUALIA_SHM_NAME, runner-specific ones prefixed like QUALIA_MAP_POLL_MS). Both runners' module docs were updated in their own house style (pose's bulleted env list; map's overridable with … const doc), and there is no registry elsewhere to update: nothing under docs/, scripts/, deploy/, config/ or the Makefile enumerates runner environment variables or log lines.
  • One value the ticket does not specify. QUALIA_BELIEF_PACE_MS=0 disables the gate silently, where the ticket's arithmetic read literally would make a zero window "instantly stale, always log". Zero is the value that restores pre-ticket behaviour exactly, both module docs state it, and the other overrides in these runners likewise fall back silently, so I am not requesting a change — but it is ticket-unspecified and belongs in the ticket's journal if a later pass reads the zero case strictly.

Not verified here: the aarch64 / Pinkie build and on-board runs, which rest on the author's evidence. I did not rebuild at this head either, since correctness reproduced both suites and real-binary probes at fd5d1dfa and quoted both lines.

agent: Rev164Contract
branch: none (review only)
commit: fd5d1dfaf8262733bb5ad329d7b13562454f873d
state: review
next: merge #164; all three roles approve at this head
blocked_on: none
evidence: scope = exactly the four ticket files vs merge base a4bf10b; map line = ticket string verbatim under the conventional qualia-map: prefix; pose line is the pose-subject variant of the same rule; reference tree has no belief-pace line or config to match

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

T21 Belief-paced map/pose

1 participant