Skip to content

WHOOP 5 MG: all three TOGGLE_LABRADOR (ECG) commands return SUCCESS and produce no data — six hypotheses, and which ones you can help rule out #891

Closed

Description

@vishk23

All three TOGGLE_LABRADOR_* commands return SUCCESS on a WHOOP 5 MG and produce no data. Posting the raw frames plus six hypotheses, because I can't distinguish them alone.

I want to be upfront that the headline here is a null result with an ambiguous cause, and that I am deliberately not leading with the interpretation my own tooling printed. More on that below.


What was run

Three commands sent to my WHOOP 5 MG (WS50_r03), one at a time, each followed by a 30-second listen on the realtime channels:

opcode name in the CommandNumber table result reply frame
139 TOGGLE_LABRADOR_FILTERED SUCCESS(1) aa010c000100271124148b2f01010000845a1705
125 TOGGLE_LABRADOR_RAW_SAVE SUCCESS(1) aa010c000100271124157d300101000067ab1b82
124 TOGGLE_LABRADOR_DATA_GENERATION SUCCESS(1) aa010c000100271124167c3101010000ef4bcf45

Zero ECG-shaped packets arrived in any of the three 30-second windows.

The opcode numbers come from Packages/WhoopProtocol/Sources/WhoopProtocol/Resources/whoop_protocol.json (CommandNumber) — already in the tree, credited by docs/PROTOCOL.md to the johnmiddleton12/my-whoop (4.0) and b-nnett/goose (5.0 puffin) community reverse-engineering efforts. I did not derive them.

The frames, aligned

139   aa 01 0c 00 01 00 27 11 24 14 8b 2f 01 01 00 00  84 5a 17 05
125   aa 01 0c 00 01 00 27 11 24 15 7d 30 01 01 00 00  67 ab 1b 82
124   aa 01 0c 00 01 00 27 11 24 16 7c 31 01 01 00 00  ef 4b cf 45
                                 ^^ ^^ ^^              ^^^^^^^^^^^
                                  9 10 11              trailing 4

CONFIRMED (directly observable, re-derivable from the hex above by anyone):

  • The three replies are byte-identical except for bytes 9, 10, 11 and the trailing four.
  • Byte 10 is the echoed opcode — 8b/7d/7c = 139/125/124.
  • Bytes 9 and 11 each increment by exactly 1 across the three replies, consistent with sequence counters.
  • Byte 8 is 0x24 = 36 = COMMAND_RESPONSE in the repo's own PacketType enum.
  • The probe's decoder read result = SUCCESS(1) from each reply.
  • No ECG-shaped traffic followed.

INFERRED, labelled as such: the trailing 01 bytes look like an echoed on-state. I have not verified that, and I would not build on it.


The interpretation I am not publishing as the conclusion

My tooling's verdict string said "Consistent with a device-flag block applied as a silent no-op."

That is one hypothesis, not the finding. It happens to be the one my code was written to print, which is exactly why it deserves the least trust here. This project has publicly retracted two overclaims already and I'd rather not add a third by promoting a verdict string to a conclusion. At least five other explanations fit the same evidence, and one of them is a free retest I simply did not perform.


Six hypotheses, presented neutrally

(a) The electrode circuit was never closed — and this retest is free

Single-lead ECG needs two electrodes on opposite sides of the heart. A wrist device supplies one; the wearer must hold a second contact with the opposite hand for the entire recording. If that didn't happen there is no circuit, no signal, and firmware would plausibly return SUCCESS to the enable command and then produce nothing at all.

I did not do this. Nobody held anything. This costs one repeat run and it is the first thing that should be ruled out before anyone reads anything into the null.

(b) It isn't a realtime stream

One of the three commands is literally named RAW_SAVE, which implies flash rather than a live channel. If ECG lands in the historical offload as a record type NOOP does not decode, a 30-second realtime listen sees nothing even on complete success.

→ Ask: has anyone seen a historical record type / packet type on a 5 MG that NOOP does not recognise? That single observation would move this a lot.

(c) The opcode mapping is itself a hypothesis

docs/PROTOCOL.md says so in as many words: the strap "exposes an ECG/HeartKey command family (ECG_MAIN_CONTROL, ECG_SEND_RAW, ECG_SAVE_RAW, ECG_SAVE_FILTERED, ECG_SELECT_WRIST; five consecutive codes around 0x7B–0x8B)" and then: "Exact codes for these are unconfirmed."

Three problems follow:

  • Five names, four codes. The table has 123 SELECT_WRIST, 124 TOGGLE_LABRADOR_DATA_GENERATION, 125 TOGGLE_LABRADOR_RAW_SAVE, 139 TOGGLE_LABRADOR_FILTERED. ECG_SEND_RAW is unaccounted for.
  • 139 is not contiguous with 123–125, despite the doc's "five consecutive codes".
  • The 5/MG demonstrably remaps opcodes. docs/PROTOCOL.md records that on MAVERICK the clock family answers in the high space — SET_CLOCK at 146, GET_CLOCK at 147, GET_HELLO at 145 — versus 10/11 on the 4.0.

So the strap may well have accepted three valid commands that mean something else on this firmware, and returned SUCCESS entirely honestly.

(d) Nothing was told to start

All three names are TOGGLE_* — they read as enables. ECG_MAIN_CONTROL and ECG_SEND_RAW are the two names in the doc's family that sound like session control, and neither has a code in the table. It is entirely possible the three toggles armed a subsystem correctly and no recording was ever initiated.

(e) A device-flag block applied as a silent no-op

The tooling's own verdict. Listed here as a peer of the others, not above them. It predicts the same SUCCESS-and-silence as (a) through (d), which is precisely why it can't be asserted from this evidence.

(f) An account / entitlement gate

WHOOP gates ECG to MG hardware plus a higher membership tier. My strap is subscription-free.

This is the same shape as the @82 result in #103: on my sub-free strap the v18 SpO2-adjacent byte is 0x00 on 100% of records including 103 deep-sleep ones, while a subscriber's strap carries values that track the app's nightly number at corr +0.99. If ECG generation is entitlement-gated strap-side, the strap could accept the toggle and simply never run the subsystem — which looks identical to (e) from outside.


What would falsify what

# hypothesis what kills it who can do it
a electrode circuit open rerun holding the opposite-hand contact for the whole window me, or any MG owner — free
b data goes to flash, not realtime run a full history offload after the toggles and look for an unrecognised record type any MG owner
c wrong opcodes a capture showing what the official app actually sends when an ECG reading is taken on an MG an MG owner with a subscription
d no start command sent same capture as (c); it would show the ordering and any missing verb same
e silent flag block can only be reached by eliminating a–d and f —
f entitlement gate an MG owner with an active subscription runs the exact same three toggles an MG subscriber

(f) is the cheapest decisive one and needs no capture tooling at all — if a subscribed MG produces data from the same three commands that produced silence on my unsubscribed one, that's the answer, and it's a ten-second run.

What "it worked" would look like: a packet type NOOP doesn't recognise, or a REALTIME_RAW_DATA variant carrying a high-rate single-channel int16 waveform (ECG is one channel, unlike the 3-axis IMU and unlike the optical blocks). If you have ever seen an unexplained high-rate single-channel stream on an MG, please say so here.


Scope and safety, stated explicitly

  • These are writes, not reads. Unlike the Ask the strap which feature flags it knows: a read-only enumeration probe (#761) #872 / Ask the strap what a config key's VALUE is: a read-only device-config read probe (#103) #890 probes, TOGGLE_* commands change strap state. I sent them deliberately as a one-off experiment on my own strap. Nothing in any shipped NOOP code path forms these bytes, and I am not proposing that it should — the 5/MG send() allowlist rejects them today.
  • None of 124/125/139 is on the destructive list in docs/PROTOCOL.md (25 FORCE_TRIM, 32 POWER_CYCLE_STRAP, 36/37/38 firmware, 45 ENTER_BLE_DFU).
  • Caution if you reproduce this: they are toggles, and the replies carry a trailing 01. Whether they persist across reconnect or reboot is UNKNOWN — I did not verify a clean off state afterwards. Assume they might stick.
  • This is a protocol/decode question, not a product proposal. NOOP's rhythm surfaces are deliberately non-diagnostic ("not an ECG", "not a diagnosis", "cannot detect any heart condition") and NOOP is not a medical device. Whether anything ECG-shaped belongs in the product at all is a separate open question in Decide whether possible-arrhythmia notifications are out of scope #752, and nothing here is an argument for changing that answer. Even a fully working waveform would be a research artifact first.
  • Interoperation with hardware the user owns, from observed wire behaviour and names already in this repo's own tables.

The ask

I have one MG, no subscription, and one negative result. Any of these helps:

  1. An MG owner reruns the three toggles while holding the opposite-hand contact. Kills or confirms (a) for free.
  2. An MG owner with an active subscription reruns them unchanged. Kills or confirms (f).
  3. Anyone who has seen an unrecognised record type or packet type in a 5 MG offload — say so, even vaguely. That's (b).
  4. An HCI/PacketLogger capture of an MG taking an ECG reading in the official app. That settles (c) and (d) outright and is the single most valuable artifact. Same privacy guidance as WHOOP 5.0 raw HCI capture — where to submit? (docs reference #174, which doesn't exist) #103: filter to the WHOOP peripheral, and no account identifiers, tokens or HTTPS bodies — only the app→strap command frames matter.

Happy to be wrong about any of this. Posting the raw frames precisely so someone can tell me which hypothesis I've mis-weighted.

(Related: #103 for the @82 / entitlement-gate parallel and the capture guidance, #761 for the 5/MG deep-data roadmap, #872 / #890 for the read-only probes, #752 for the scope boundary.)

Activity

  1. ryanbr commented on Jul 27, 2026

    @ryanbr
    Owner

    Checked the three frames against the repo's own decoder rather than taking the table on faith. They hold up.

    Verified

    All three pass every structural check: declared length u16@[2..4] = 12, total = declLen + 8 = 20 ✓; CRC16-Modbus header over frame[0..6) = 0x1127 ✓; CRC32 tail over the inner record ✓. Run through decodeCommandResponseWhoop5 they decode exactly as reported — type@8 = 36 COMMAND_RESPONSE, resp_cmd@10 = 139 / 125 / 124, result@12 = 1 = SUCCESS. The names at 124/125/139 are in whoop_protocol.json's CommandNumber table as quoted. These are genuine, well-formed replies; nothing here is a misparse.

    One byte reading to correct

    Bytes 9 and 11 aren't two strap counters. Byte 11 is resp_seq, strap-side. Byte 9 is the envelope seq, which is host-assigned — puffinCommandFrame(cmd:seq:) takes it from the caller and BLEManager holds private var seq: UInt8 that it increments per send. The strap echoes it. So 0x14→0x16 describes the sending tool's counter, not the strap's. The repo's real battery fixture shows the split clearly: seq 147 alongside resp_seq 2. Doesn't change the result; it does mean byte 9 carries no information about strap state.

    The part worth more weight than it got

    The replies are not bare SUCCESS. Bytes 12–15 are 01 01 00 00 — byte 12 is the result, and byte 13 = 0x01, identical across all three. Byte 13 is the response-value slot: it is exactly where GET_BATTERY_LEVEL returns its number (the real fixture has 0x2f = 47 there, and the decoder reads battery_pct from @13). Filing that only under the persistence caution undersells it. It is the one piece of positive evidence in the capture that a flag took a value, though it could equally be an echo of the requested value rather than a read-back of state — which is the point.

    That makes (e) falsifiable without a second person. If these toggles are backed by device-config or feature-flag storage, GET_DEVICE_CONFIG_VALUE (121) and GET_FF_VALUE (128) are read-only, already on the send allowlist behind the Test Centre gate, and already have probe infrastructure — DeviceConfigReadProbe, and the flag-name enumeration probe from #761. Read before, toggle, read after:

    Solo, read-only, no subscription, no capture tooling. That is cheaper than (f), which needs another owner — worth doing before either. It also answers the open persistence question directly, which is currently listed as UNKNOWN.

    On (a)

    Worth running first because it is free, but it is a complete explanation only under an assumption worth stating: an open electrode circuit explains a flat or garbage waveform, and explains zero packets only if the firmware suppresses transmission on lead-off detect. Common in single-lead designs, not guaranteed. If the retest is run and still yields nothing, that gap is where the reasoning has to be careful — silence with leads closed rules out more than silence with leads open.

    On (c) — correct, and the doc is internally inconsistent regardless of which codes are right. docs/PROTOCOL.md:413 says "five consecutive codes around 0x7B–0x8B", while the table has 123/124/125 and then a gap to 139. Five names, four codes, non-contiguous. That line should be corrected to match the table and keep the "unconfirmed" caveat, independent of how this resolves.

    Scope — the safety framing checks out. There is no Labrador case in WhoopCommand at all, and the 5/MG path is an explicit allowlist that falls through to "no WHOOP 5/MG framing for this command yet", so nothing shipped can form these bytes. None of the three is on the destructive list.

    Declining to promote the tooling's verdict string to a conclusion is the right call and is what #194 asks for. The null result is worth having on the record either way.

  2. ryanbr commented on Jul 27, 2026

    @ryanbr
    Owner

    Opened #893 for the one thing here that was resolvable without hardware.

    Android labelled command responses from its curated sender enum rather than the shared schema, so these three replies rendered as 0x8B(139) / 0x7D(125) / 0x7C(124) on Android and named on Apple — from identical bytes. Anyone answering the ask above from an Android phone would have posted hex. 46 opcodes were affected; three more printed a different name on each platform.

    Fixed as a read-only label table, not by growing the sender enum — that would have made FORCE_TRIM and the firmware-load family constructible. The three frames are pinned as decode fixtures on both platforms, and byte 13 is deliberately left undecoded.

    Also corrected the docs/PROTOCOL.md line behind hypothesis (c).

    The ECG question itself is untouched — it still needs the retest, a subscribed MG, or a capture.

  3. vishk23 commented on Jul 27, 2026

    @vishk23
    Author

    Three more runs on the same WHOOP 5 MG (WS50_r03, build 215), tonight. One of them answers the byte-13 question @ryanbr raised, on hardware, and it does not answer it the way I expected.

    Fingers were on the clasp electrodes for the full 30 seconds in every run this time — thumb and index on the two indents, the posture WHOOP's own Heart Screener instructions call for. That was the free retest hypothesis (a) asked for, and I should have done it the first time.

    Also: one of these runs is not a test at all, and my tooling said it was. That is at the bottom, with the fix.


    Verification first

    All five frames below (the four new ones plus the earlier run-1 reply) were re-decoded with this repo's own whoop-decode against Packages/WhoopProtocol at current main, not by hand. All five: CRC16-Modbus over frame[0..6) = 0x1127 OK, CRC32 over the inner record OK, packet_type@8 = 36 COMMAND_RESPONSE. Post-#899 the Apple decoder now names resp_seq and result itself, so the field reading is the decoder's, not mine:

    resp_cmd       = SELECT_WRIST(123)  (7b)
    resp_seq       = 129                (81)
    result         = SUCCESS(1)         (01)
    

    Opcodes as before, from whoop_protocol.json's CommandNumber table already in the tree — I derived none of them.

    Using @ryanbr's corrected reading of the envelope (byte 9 = host-assigned seq, byte 11 = strap-side resp_seq):

    run command arg sent seq@9 resp_cmd@10 resp_seq@11 result@12 byte 13
    1 SELECT_WRIST 1 (left) 215 123 129 SUCCESS(1) 1
    2 TOGGLE_LABRADOR_FILTERED 1 241 139 155 SUCCESS(1) 1
    2 TOGGLE_LABRADOR_RAW_SAVE 1 242 125 156 SUCCESS(1) 1
    2 TOGGLE_LABRADOR_DATA_GENERATION 1 (start) 243 124 157 SUCCESS(1) 1
    3 SELECT_WRIST 0 (right) 33 123 204 FAILURE(0) 1
    run 1  aa010c000100271124d77b81010100007ce76722
    run 2  aa010c000100271124f18b9b01010000e07dc8b1
           aa010c000100271124f27d9c010100006941cbf1
           aa010c000100271124f37c9d01010000c8b080a1
    run 3  aa010c000100271124217bcc000100000213163d
    

    resp_seq runs 129 → 155 → 156 → 157 → 204, which independently confirms the runs are in that order — a useful side effect of byte 11 being strap-side rather than ours.

    Zero ECG-shaped packets in every 30-second window.


    1. Byte 13 is a read-back of stored state, not an echo of the request

    @ryanbr identified byte 13 as the response-value slot — the same slot GET_BATTERY_LEVEL returns its number in (Interpreter.swift reads battery_pct from pay[2], i.e. frame offset 13, with the 47%-confirmed fixture) — and named exactly the right caveat: it "could equally be an echo of the requested value rather than a read-back of state — which is the point."

    Every observation up to now was confounded: argument sent = 1, byte 13 back = 1, four times.

    Run 3 breaks the confound. I sent argument 0 and byte 13 came back 1.

    An echo would have returned 0. It returned the value stored by run 1's successful write. So on this reply byte 13 carries strap state, not the request. That is @ryanbr's question, answered on hardware, in his favour — and it means byte 13 is worth the weight he put on it rather than the weight I gave it.

    One residual caveat I would rather name than have pointed out: this is demonstrated on a FAILURE reply. A firmware that echoed the request on success and reported current state on refusal would also fit every frame here. The single-mechanism reading — byte 13 is the stored value throughout — is much the simpler one, but the four SUCCESS replies remain individually confounded because for them the requested and stored values are both 1.

    It also corrects my own guess in the opening post. I wrote that the trailing 01 "look[s] like an echoed on-state". Echo is the reading that just failed.

    2. FAILURE(0), not UNSUPPORTED(3) — and the same opcode succeeded minutes earlier

    The strap knows opcode 123 — it ran it successfully earlier in the same session and refused it later. The only thing that changed is the argument:

    SELECT_WRIST arg=1 (left)  — equals the already-stored value  → SUCCESS(1), byte13=1
    SELECT_WRIST arg=0 (right) — would be a real change           → FAILURE(0), byte13=1
    

    Two readings fit, and I cannot separate them with two data points:

    • (i) A write that changes nothing is accepted; a write that would actually mutate state is refused. This is my leading reading, stated as a hypothesis and nothing more.
    • (ii) 0 is simply not a valid argument on this firmware. docs/PROTOCOL.md has always flagged right=0/left=1 as inferred from the client enum's order, not attested. If the real encoding is something else, run 3 sent a bad argument and got the correct answer to it.

    Worth being precise about what a cheap follow-up buys: re-sending left (arg=1) and getting SUCCESS again would confirm the asymmetry is stable rather than a one-off, but it does not separate (i) from (ii) — both predict SUCCESS. Nor does an out-of-range argument; both predict FAILURE. Separating them properly needs a strap whose stored wrist is the other one. I will run the consistency check regardless, because "it was a transient" is worth eliminating for free.

    Loose end this creates, flagged rather than resolved: the stored wrist value is currently left, and whether that matches the wrist the strap is actually worn on is not observable from the wire — the one command that would change it is being refused.

    3. What this does and does not say about the three toggles

    Reasoning chain, with its assumption named, not a conclusion:

    • Observed: all three toggle replies carry byte 13 = 1.
    • Assumption: byte 13 is stored state for opcodes 124/125/139 too. This is proven only for 123. It is the natural generalisation of a single response-value slot, and it is still an assumption.
    • If that holds: the strap is reporting the ECG flags as ON while emitting nothing. That pushes away from "the write never took" and toward (b) it isn't a realtime stream or a suppression sitting below the flag layer.
    • Double-conditional, flagged as such: if hypothesis (i) above also holds, then the toggles returning SUCCESS means those writes changed nothing either — i.e. the flags were already 1 before run 2 was sent. I am not asserting that; two stacked assumptions is exactly where this thread has gone wrong before. But it is the implication, and I would rather name it than have it found later.

    On (b) specifically, @digitalerdude's full-history capture in #103 remains the strongest evidence against — every historical record a 124 B v18 or 88 B v26 frame, frames >200B = 0 across ~30k contiguous records — with the caveat from the opening post that it was a 5.0 rather than an MG, with Labrador presumably never enabled.

    4. Electrode contact is weakened as an explanation for run 2

    Run 2 had fingers on the clasp electrodes for the entire 30 seconds and still produced nothing. That weakens hypothesis (a) as the explanation for that run.

    Weakens, not eliminates. Nothing on the wire reports whether skin contact was electrically adequate — the heartKeyLeadsAreOn bit lives in the ECG status header, and no ECG packet arrived to carry one. "I held it correctly" is a claim about my hands, not a measurement. And as @ryanbr noted, an open circuit explains zero packets only if the firmware suppresses transmission on lead-off detect; that assumption is untouched by this run.


    5. Run 1 is not a test, and my tooling said it was — twice

    Run 1 sent only SELECT_WRIST(123). No toggle, no data-generation command, nothing that could cause the strap to produce ECG data. Zero packets is the correct and expected outcome, and the run says nothing whatsoever about whether ECG is blocked.

    My probe rendered:

    Verdict: Accepted but SILENT — every command returned SUCCESS yet no ECG packet arrived in 30s. Consistent with a device-flag block applied as a silent no-op.

    That is wrong. And run 3 — also wrist-only — tripped the other verdict:

    Verdict: LIKELY blockedByDeviceFlags

    Both are the same defect: the classifier read "zero ECG-shaped packets" and "a FAILURE arrived" as evidence about the block question without checking whether the run had asked the ECG data path for anything at all. It manufactured support for hypothesis (e) — the one I said in the opening post deserved the least trust precisely because it was the string my code was written to print — out of two runs that could not speak to it. If I had pasted either verdict here unqualified it would have corrupted the thread.

    Fix in flight (#896, pushed): the two verdicts that read silence or refusal as evidence about the feature are now unreachable unless the run sent a command that could actually produce realtime ECG data and the strap acknowledged it. That predicate is decided from the opcode and the argument in the shared protocol layer, mirrored in Kotlin, tested on both platforms — SELECT_WRIST starts nothing on either argument, the OFF sequence asks for the silence it gets, and RAW_SAVE names flash rather than a live channel. A wrist-only run now reports that it sent no data-generation command and cannot speak to the block question; a FAILURE on a configuration write reports as a refusal of that write. Regression tests pin both of tonight's misreadings by their real frames.

    The general rule, since it is not specific to ECG: a probe verdict must not assert a conclusion the run's own inputs could not support. I have audited the other three probes against it and there are hits — I will file those separately rather than bury them here.


    Where that leaves the six hypotheses

    • (a) open electrode circuit — weakened for run 2, not eliminated.
    • (b) not a realtime stream — strengthened, if byte 13 generalises. Best remaining lead.
    • (c) wrong opcode mapping — untouched. Still wants a capture.
    • (d) nothing told to start — untouched.
    • (e) silent flag block — no better supported than before, and two of the three data points that appeared to support it were my own tool's error.
    • (f) entitlement gate — untouched. Still the cheapest decisive one, and still needs a subscribed MG owner: the same three toggles, ten seconds, unchanged.

    The asks from the opening post all stand. Added to them: if anyone with an MG can send SELECT_WRIST with the wrist they are not currently set to, I would like to know whether they also get FAILURE — that separates "this strap refuses mutations" from "something about my strap".

  4. vishk23 commented on Jul 27, 2026

    @vishk23
    Author

    A device-config key named enable_raw_data_w_ecg, and it is '0'

    Cross-referencing rather than restating — the full result is in
    #103, and it bears directly on
    hypothesis (e) here.

    The device-config namespace enumerates on this strap. START_DEVICE_CONFIG_KEY_EXCHANGE(115) →
    SEND_NEXT_DEVICE_CONFIG(116) returned revision=1, count=7 and walked to a clean terminator. One of
    the seven keys is:

    enable_raw_data_w_ecg = '0'
    

    Same strap as the runs above (WS50_r03, build 215), read-only, no writes on that path.

    I want to be careful with this. It is the cleanest explanation anyone has for "three toggles ack
    SUCCESS with the electrodes properly held and zero packets arrive" — but it is a leading
    hypothesis, not a cause
    . What is established is only that a device-config key with that name exists
    on this strap and is set to '0'. Nothing yet connects it to the Labrador data path by observation;
    the name is suggestive and that is all it is. (b) flash-not-realtime, (c) a wrong opcode mapping, the
    missing-start-verb reading, and the entitlement gate are all still live, and the byte-13 result above
    does not pick between them either.

    What it does change is that the flag-block branch is now cheap to test instead of hypothetical:
    the key has a name, SET_DEVICE_CONFIG_VALUE(119) is the write verb for that namespace (confirmed
    separate from SET_FF_VALUE(120) in both directions — see #103), and #103 also establishes on this
    strap that NOOP's config writes actually persist and read back rather than being silently dropped.
    So this is a one-round-trip experiment now, not a research project.

    Two caveats before anyone tries it, both mine to own:

    1. That would be a write, and every probe in this thread so far has been read-only. It needs its
      own gate and its own before/after read, not a bolt-on to the existing probe.
    2. Enumeration only lists keys that have a stored value. The oracle cannot tell "no such key" from
      "key exists, nothing stored" — both return FAILURE — so the list is what is currently set on this
      strap, not the firmware's key space.
  5. ryanbr commented on Jul 27, 2026

    @ryanbr
    Owner

    Re-decoded all five frames independently. Every one verifies — CRC16-Modbus header 0x1127, CRC32 over the inner record, packet_type@8 = 36 — and every field in your table reproduces exactly, including resp_seq 129 → 155 → 156 → 157 → 204 and the FAILURE(0) on run 3. Nothing in the report needs qualifying on the decode.

    Run 3 is a good experiment and §5 is a better one. Two things below: one where I think the conclusion outruns the data by a single step, and one convergence that makes an ask you already have worth more than it looks.

    Byte 13: echo is refuted, read-back is not established

    Sending arg=0 and getting byte 13 = 1 back kills the echo reading outright. That is a real result and it is the right experiment.

    It does not get to read-back yet, though. Across every MG COMMAND_RESPONSE on record — the three in the opening post plus tonight's five — byte 13 has taken exactly one value:

    frames commands results distinct byte-13 values
    8 123, 124, 125, 139 7× SUCCESS, 1× FAILURE {1}

    A constant fits all eight observations as well as stored-state does, and is the simpler of the two. What run 3 established is the narrower claim: byte 13 is not the request. Between "carries state" and "is 1 on this reply family" the data is silent, because the stored value has been 1 in every frame anyone has captured.

    That matters specifically for §3. The chain there — byte 13 = 1 on the toggles → the strap reports the ECG flags ON while emitting nothing → strengthens (b) — needs read-back to be true. Under the constant reading the premise carries no information about flag state and (b) is not strengthened at all. You flagged the generalisation from 123 to 124/125/139 as the assumption; the load-bearing one is a step earlier than that.

    The residual caveat you named — that read-back is demonstrated only on a FAILURE reply, so a firmware that echoes on success and reports state on refusal fits too — is the same gap seen from a different angle, and you were right to name it.

    The convergence: your §2 ask settles byte 13 as well

    You asked for an MG owner to send SELECT_WRIST with the wrist they are not currently set to, to separate "refuses mutations" from "something about my strap".

    That is the same run that separates constant from read-back. A strap whose stored wrist is right replies with a stored value of 0, and byte 13 either follows it or does not. One run, three questions: the (i)/(ii) split, the constant/read-back split, and whether the asymmetry is stable. Worth saying so in the ask — it is currently framed as buying only the first.

    GET_DEVICE_CONFIG_VALUE(121) will not substitute, incidentally: that reply carries its value after the 32-byte echoed name field, not at 13, so it reads a different slot and says nothing about this one.

    The two comments in tension, usefully

    If byte 13 does generalise, the strap reports Labrador flags ON while enable_raw_data_w_ecg reads '0'. Different namespaces, so both can hold — but it is worth noticing that the flag which is observably off is the config one, and the flags that are inferred on are the toggles. If anything that points at the config key being the gate and the toggles being downstream of it, which is a cleaner story than either comment tells alone. Not a claim, and both readings survive it.

    Your caution on the key is right, and the second caveat is the sharper one: enumeration lists keys with a stored value, so count=7 is what is set on that strap, not the firmware's key space. A key absent from the list is not a key that does not exist.

    §5

    The right call, and the fix is the right shape — a verdict that cannot be reached unless the run sent something that could produce the data it is drawing conclusions about. Deciding the predicate from opcode and argument in the shared layer is what makes it hold on both platforms rather than in the UI that happened to launch it.

    Worth stating plainly since it is easy to lose: two of the three data points that appeared to support (e) were produced by a tool printing its own verdict string, and you found that yourself and said so before anyone else read it. That is the failure mode #194 exists for, caught one level up from where it usually is.

    Auditing the other three probes against the same rule is the right follow-up. If it helps scope it: the rule generalises past probes — any report that turns absence of evidence into a named conclusion needs the run's inputs to license the conclusion, and FeatureFlagProbe's "strap names no oxygen flag" line in #103 is the same shape.

  6. added a commit that references this issue on Jul 27, 2026
  7. vishk23 commented on Jul 28, 2026

    @vishk23
    Author

    You are right on both counts. The second one is load-bearing in a way I did not see, and it takes down a chain I wrote.

    Byte 13: I walked one step past the result

    Conceded, without qualification. A constant fits all eight frames as well as read-back does and is the simpler of the two, and I had no business preferring the other one. What run 3 bought is exactly the narrow claim and nothing beyond it: byte 13 is not the request. Echo is refuted. That is where the evidence stops.

    The reason the data cannot go further is worth stating plainly, because it is the whole of it: the stored value has been 1 in every frame anyone has captured, so "carries state" and "is 1 on this reply family" make identical predictions on all eight. Four opcodes, seven SUCCESS and one FAILURE, one distinct value. There is no observation on record that the two readings disagree about.

    The consequence, which is mine to own rather than leave sitting in your comment. §3 of my last post ran:

    byte 13 = 1 on the toggles → the strap reports the ECG flags ON while emitting nothing → strengthens (b)

    That chain needs read-back at step one. Under the constant reading the premise carries no information at all — not weaker information, none — so there is nothing for a generalisation to generalise, and (b) is not strengthened. I flagged 123 → 124/125/139 as the assumption in that section and was pointing at the wrong step: the load-bearing one is earlier, and it is the one I had just told myself was proven. (b) goes back to standing on @digitalerdude's #103 capture and nothing else.

    Thank you for pinning the FAILURE frame in #906 with byte 13 deliberately left undecoded. That is the right call and it is the one I would now have to argue for rather than against.

    The ask, rewritten — it buys three things, not one

    You are right that I under-sold it. Restating it in full, since the earlier framing is what is in the thread and it asks for less than the run actually gives.

    If you own a WHOOP 5 MG: send SELECT_WRIST(123) with the argument for the wrist your strap is not currently set to. One command, no subscription, no capture tooling, ten seconds. Then paste the raw response frame, not just the verdict — the frame is what answers the third question, and a SUCCESS/FAILURE report alone does not.

    One run separates three things that are currently tangled:

    1. Refuses-mutations vs something-about-my-strap. My MG accepted arg=1 (the value already stored) and refused arg=0 minutes later. Whether that is a firmware that refuses real mutations, or an invalid argument, or a quirk of this unit, is unresolved on two data points.
    2. Constant vs read-back — the question above. A strap whose stored wrist is the other one has a stored value of 0. Byte 13 either follows it or it does not. That is the first observation on record where the two readings predict different bytes, and it settles the slot outright in whichever direction it lands.
    3. Whether the asymmetry is stable at all, rather than a transient in one session.

    GET_DEVICE_CONFIG_VALUE(121) will not substitute, and I want that recorded rather than rediscovered: its reply carries the value after the 32-byte echoed name field, not at byte 13. It reads a different slot and says nothing about this one.

    What is actually left standing on ECG

    With the byte-13 premise removed, the honest inventory on this strap (WS50_r03, build 215, n=1 device) is:

    • CONFIRMED. All three TOGGLE_LABRADOR commands are acknowledged SUCCESS(1), and zero ECG-shaped packets arrive in a 30-second realtime listen with fingers on both clasp electrodes for the full window (run 2).
    • CONFIRMED. A device-config key named enable_raw_data_w_ecg exists on this strap and reads '0' (read-only 115/116 enumeration, revision=1 count=7, clean terminator).
    • INFERRED, and now unsupported by byte 13: anything about what state those three flags are actually in. The acks are acks.

    That is less than I claimed last night and it is the correct amount. It does not pick between (b), (c), (d), (e) or (f).

    Why #907 survives this

    Worth saying explicitly, because it is the reason the experiment is still worth running in the shape it is already in: #907 does not depend on byte 13 meaning anything. It writes enable_raw_data_w_ecg and then re-reads the key with GET_DEVICE_CONFIG_VALUE(121) — a different slot, past the echoed name field — and reports only the value that comes back. The write's own COMMAND_RESPONSE is recorded and explicitly not believed; a SUCCESS ack whose read-back did not move is reported as unchanged, not as success.

    That design came out of your earlier point that an ack is not evidence of a state change, and it is what makes it immune to this critique rather than a casualty of it. A confirmed '1' with still no packets removes the leading hypothesis and is exactly as publishable as a positive.

    §5

    Noted on FeatureFlagProbe's "strap names no oxygen flag" line in #103 being the same shape — you are right, and the enumeration caveat makes it sharper than I wrote it: a key absent from the list is a key with no stored value, not a key the firmware does not know. I will fix that one in the same sweep and file the rest against the general rule rather than one-off.

  8. ryanbr commented on Jul 28, 2026

    @ryanbr
    Owner

    Agreed on all of it, and the §3 retraction is the right call — under the constant reading that premise carries no information rather than weaker information, so there is nothing left to generalise. (b) is back to standing on the #103 capture alone.

    One datum to add, because it narrows the question rather than settling it, and neither of us has put it in the thread.

    Byte 13 is not fixed across commands — the slot demonstrably carries data

    Across every real 5/MG COMMAND_RESPONSE in the tree:

    fixture command result byte 13
    battery, 47% GET_BATTERY_LEVEL SUCCESS 47
    data-range GET_DATA_RANGE SUCCESS 1
    wrist, accepted SELECT_WRIST SUCCESS 1
    wrist, refused SELECT_WRIST FAILURE 1
    ECG toggle TOGGLE_LABRADOR_FILTERED SUCCESS 1

    GET_BATTERY_LEVEL puts 47 there — the decoder has read battery_pct from that offset since the port, hardware-confirmed against the app. So the slot is not a fixed field with a fixed value; it is the first byte of the per-command response body, and its meaning is whatever that command's handler writes.

    That does not settle constant-vs-read-back, and I do not want to overstate it the way I would be inviting you to. What it does is narrow the question from "is byte 13 a constant" to "what does the wrist/toggle handler put in a slot that other handlers use for real values". A handler writing a literal 1 into that position is possible; it is just less natural than one writing the state it was asked about. That is a shift in prior, not evidence, and the eight frames still make identical predictions under both readings.

    It also means the opposite-wrist run settles it cleanly in either direction rather than only confirming one: a stored 0 coming back as 0 proves read-back, and coming back as 1 proves the handler writes a literal — both are results, neither is a null.

    On the ask

    The rewritten version is right, and the instruction to paste the raw frame rather than the verdict is the part that matters most — a SUCCESS/FAILURE report genuinely cannot answer question 2, and that is not obvious from outside.

    Recording the GET_DEVICE_CONFIG_VALUE(121) non-substitution was worth doing. Its value sits after the 32-byte echoed name field, so it reads a different slot entirely; anyone reaching for it as a shortcut would get an answer to a different question and not notice.

    #907

    Your reading is right and it is worth being precise about why, since it is the difference between the experiment surviving this and not: #907 never reads byte 13. It writes the key, re-reads it through 121 past the name field, and reports only what comes back — with a SUCCESS ack whose value did not move reported as unchanged. Nothing in that path touches the slot under discussion, so removing the byte-13 premise costs it nothing.

    The review comments on it stand as posted: the six strings.xml conflicts, no CI runs on the branch, and the flash-retention asymmetry in the copy — the flag is reversible in one tap and history trimmed while it was on is not.

    The inventory

    Adopting your three-line version as the state of this issue. It is less than was claimed two comments ago and it is the correct amount, which is the only way this thread stays worth reading.

  9. 57 remaining items

  10. vishk23 commented on Oct 13, 2026

    @vishk23
    Author

    @meta1971 Thanks for both fixtures. I checked mg_fixture_trimmed.zip independently today with a small Python parser (not your verification script): all four R16 records and three R17 frames pass header CRC16-Modbus and inner-record CRC32; frame lengths, declared counts, the listed status fields, and every expected signed sample match. That checks the wire/decode expectations, not the voltage scale or the reported cross-stream correlation.

    The terminal frame at rebased second 1013 also matches the raw fields you listed: state 2, progress 100, flags 0x0c, result 2, reasons 0x02, live HR 62 and HRV 0xffff. Keeping it as integer wire counts makes this directly useful for Swift/Kotlin parity tests.

    @ryanbr Current main (3a0b74b2d) now has the 60 s capture window, terminal-frame retention and 10 s terminal grace. Meta1971’s newer 16-run timing means that grace should be described as an evidence window, not a guarantee that HRV will become valid: the reported delays include +17 s, +113/+120 s and runs with no value before stopping. An unset field at the end remains unavailable, not zero or a failed completed reading.

    The new 139/125 isolation runs are also useful: on that tested unit, live R17 works with raw-save off, while R16 banks with live off. I would keep that provenance with the fixture rather than generalize it to every firmware. The TX/RX pair is a good literal regression fixture too: request seq 0x03 appears at response byte 11, not byte 9; byte 13=1 should stay uninterpreted given the off-command observations.

    @DX23876 Please do push the source branch and reproducible QTDB harness you offered, with the tested commit and exact command. That would let contributors inspect the alignment/resampling and rate-dependent thresholds without needing your personal recordings. I have no new r03 hardware result yet, so I can’t supply the requested reference pair. Your fork’s readings and meta1971’s fixture are attributed evidence, not a retest on my device.

  11. ryanbr commented on Oct 24, 2026

    @ryanbr
    Owner

    Answered. The cause, what landed, and what stays open

    Closing this with a summary, because the question in the title has a measured answer and the thread is long enough that nobody arriving now should have to read 26 comments to find it.

    The honest headline: the three commands were correct, the strap was never gating anything, and the argument to one of them was wrong. Three separate findings, none of them any of the mechanisms the opening post suspected.

    1. Opcode 124's second byte is an operation, not a flag

    1 is STOP. 2 is START. 0 is refused.

    @Zebsi235 measured that on an MG (WS50_r00, fw 50.39.1.0) and reported it in #1727. Every run in the opening post, and every run in the first month of this thread, sent 124=1 believing it meant "on". So the strap armed the analog front end and was then told to stop generating. The SUCCESS(1) replies were entirely honest answers to the question actually asked.

    That mapping is corrected on both platforms in f2476f95d, and the trap is pinned by a test rather than left in a comment, because a caller sending 1 meaning "on" stops the session it just armed.

    2. The output has two independent gates, and 124 is neither of them

    139 gates the live stream. 125 gates the flash-banked record. 124 only runs generation.

    @Zebsi235 found the first half of this and corrected their own earlier claim while doing it: the strap narrates MAX86176: Set ECG ON in CONSOLE_LOGS once per 124=2 whether or not 139 is open, correlated against the strap's own uptime rather than a phone clock, eight sends to eight console lines within 0.2 s. So a closed 139 does not stop the ECG. It stops the data leaving the strap.

    @meta1971 then ran the switches one at a time and separated them outright:

    Sequence live R17 stored R16
    139=1, 125=1, 124=2 yes 282
    139=0, 125=1, 124=2 0 frames 190
    139=1, 125=0, 124=2 184 frames 0

    3. For a client that is not NOOP, an unaligned command frame gets no reply at all

    @meta1971's earlier result in this thread was NoReplies: not accepted-but-silent, but zero COMMAND_RESPONSE frames for any of the four opcodes across a 40-attempt matrix that had already eliminated contact, bond, timing and repetition. They then traced it to their own frame builder: the strap silently discards any command frame whose inner record is not padded to a multiple of 4 bytes. Checked retrospectively against roughly 10,000 logged frames over ~50 opcodes, every aligned frame got a reply and every unaligned one got silence, TOGGLE_REALTIME_HR included, so it is a general framing requirement and nothing to do with ECG.

    NOOP's puffinCommandFrame has padded to 4 since #48. That is why NOOP always got acks where an independent client got nothing, and why two correct reports in this thread looked for weeks like they contradicted each other.

    So "SUCCESS and no data" had two different causes depending on who was asking, and the data was never missing. It was banking to flash the whole time whenever 125 was on, and streaming live whenever 139 was on at a frame shape NOOP's own plausibility test could not recognise.


    The six hypotheses, settled

    # hypothesis outcome
    (a) electrode circuit never closed Ruled out empirically. @vishk23 re-ran with thumb and index on the clasp indents for the full 30 s, three separate runs, same silence. The free retest was spent and bought a real negative.
    (b) not a realtime stream, banked to flash Correct, and incomplete. R16 (type 47, version 16, 1584 B, 500 samples/s) is real and carries the waveform, found by @ayiskakov. But live R17 (type 43, 240 B, 100 samples/s) exists at the same time, so the answer was not "flash instead of live", it was "both, through separate gates".
    (c) wrong opcode mapping Opcodes right, argument wrong. @meta1971 confirmed all four opcodes independently against the official client's own frame builders, cross-checked against two already-known-correct opcodes before trusting the third.
    (d) nothing was told to start This is the answer, in its sharpest form. Something was told to stop.
    (e) silent device-flag block Falsified twice on hardware. @vishk23 wrote enable_raw_data_w_ecg to '1' and still got silence; @ayiskakov repeated it with a frame-attested GET_DEVICE_CONFIG_VALUE(121) read-back on a different unit and firmware. The mechanism the verdict string named was also never on the wire: blockedByDeviceFlags was a client-side construct with no opcode behind it, which @vishk23 identified in their own tooling and removed.
    (f) subscription / entitlement gate Dead. Every strap in this thread that produced a waveform has no membership: @Zebsi235, @ayiskakov, @meta1971 and @DX23876 all state so explicitly.

    A note on (e) that is worth keeping: two of the three data points that originally appeared to support it were produced by a probe printing its own verdict string, and @vishk23 found that in their own code and said so before anyone else read it. That is the #194 failure mode caught one level above where it usually gets caught.

    What landed in NOOP because of this thread

    Protocol and decode:

    • #893 Android named command responses from its sender enum, so these three replies rendered as raw hex on Android and by name on Apple from identical bytes. Replaced with a read-only label table covering 46 affected opcodes, which does not make anything constructible.
    • #915 documented the COMMAND_RESPONSE body, with byte 13 deliberately left undecoded.
    • #914 stopped the config-read probe reporting silence as a firmware verdict.
    • #927 made a history offload count the packet types it drops instead of discarding them silently. Until that landed, the honest answer to the (b) ask was that nobody could have known either way.
    • #2183 (@bhelm) wrote docs/PROTOCOL_ECG.md, which specified the R16 frame correctly before anyone in this thread had decoded one. @ayiskakov's R16 correction defers to it by name.
    • #2594 corrected the R17 layout, the wrist argument values and the START list from @ayiskakov's hardware findings.
    • #2838 stopped the realtime decoder reading the record's alignment word as a 101st sample.
    • #2839 added the R16 decoder: 500 three-byte slots at constant offsets, signed 18-bit samples big-endian within the slot, the two sample flags, the lead-off halfwords, and both CRCs, pinned on both platforms against byte-level fixtures.

    Probe behaviour:

    • #896 decoded the Labrador packets and shipped the gated, default-off turn-on probe, so reproducing this stopped requiring anyone to hand-craft three writes.
    • #1166 made the (e) hypothesis testable rather than hypothetical: an opt-in enable_raw_data_w_ecg write with a mandatory read-back that reports an unmoved value as unchanged, never as success.
    • #1941 and eb45622ad gave the allow-list, the research modules and the Android probe, so both platforms drive the same sequence through one send chokepoint.
    • b1c76595e took the capture window from 30 s to 60 s, retains any terminal frame regardless of the candidate cap, and keeps listening past it. @meta1971's timing is what found both defects: the terminal frame lands 36 to 39 s after first contact, so a 30 s window could not reach a completed reading on any strap or firmware, and the 12-line cap was retaining seconds 1 to 12 while result, average HR and the reason mask only populate on the terminal frame.
    • cd9235dd2 keeps a capture's frames when a person stops it, instead of discarding the evidence they were waiting for.

    A correction to my own first comment in this thread

    I wrote that response byte 9 is the host-assigned envelope seq and byte 11 is a strap-side resp_seq. @meta1971's TX/RX pair shows that is reversed: the sequence number the host sent appears at response byte 11 (53 of 53 replies), while response byte 9 counts up on its own and never matches. @vishk23 and @DX23876 both independently agree on byte 11.

    Structurally that is also the more natural reading, since the sender's own seq sits at inner offset 1 in both directions, so response byte 9 is the strap's counter in the same slot our byte 9 holds ours. The earlier frames could not distinguish the two because both counters were incrementing together at a near-constant offset. Our decoder still labels offset 11 resp_seq, which now reads backwards. That naming is on the open list below rather than changed in this comment.

    Byte 13 stays uninterpreted, and @meta1971's 53-reply series is why: it reads 1 in all 53, including four replies to a request of 0 against a flag that was already off. So it is neither the requested value nor the stored state, and the project decodes it as nothing.

    What stays open

    None of these belong in this issue any more, so I am naming them rather than leaving them implied:

    1. The raw-IMU fail-safe fires into live ECG sessions. stopUnexpectedRealtimeImu keys on frame[8] == 43 with no ECG exemption, so during a capture it sent stopRawData and toggleIMUMode off every 30 s: @ayiskakov measured 49 unrequested writes in one 25-minute session. The recording survived it, but the app should not be sending those commands into a session it started. This needs its own issue, and the exemption has to stay narrow so genuinely orphaned IMU streams keep being recovered.
    2. R16 records are decoded but not stored. They still evict at 64 per layout version, and @DX23876 measured the reject archive filling with R20 and R21 so an ECG reading is gone within a couple of hours. A versioned migration, a retention policy and somewhere to put a waveform are all required, and mapping version 16 without storage first would be worse than the status quo: it would stop the raw archiving while the trim-ack frees the strap's copy.
    3. The terminalGrace doc figure is stale. It cites the 2 to 9 s variability-field delay from the original five sessions. @meta1971's later 16-run series reports minus 3 to plus 17 s in nine runs, plus 113 and plus 120 s in two, and no value at all before the recording ended in five. The 10 s window is an evidence window, not a guarantee, and the comment should say so.
    4. The resp_seq label at offset 11, per the correction above.
    5. Research questions this project does not have the hardware to answer, all of them well documented above and none of them a defect: where the roughly 1.5 Hz high-pass lives (@DX23876 measured it against a calibrated Apple Watch and @meta1971 measured no high-pass in R16, which is a genuine open tension), the microvolt scale beyond about 10 percent, the classifier result codes past 1, 2, 5 and 6, the reason masks, and the fields of the free-running 0x1D message that @meta1971 showed fits one 600.62 s period across 48.9 h.

    The scope line from earlier in the thread stands unchanged: an analysis layer is in scope as research instrumentation, with no rhythm classification of ours, no alerts and no clinical wording. Nothing NOOP decodes here is a diagnosis, and the strap is not a medical device in this project's hands.

    Credit

    This thread is the best piece of collaborative reverse engineering this repository has hosted, and every step of it came from someone else's hardware.

    • @vishk23 opened it with a null result, refused to promote their own tooling's verdict string to a conclusion, ran the free retest they had skipped, broke their own byte-13 confound with a deliberate argument-0 run, conceded the over-reading twice when the data did not support it, found and removed the blockedByDeviceFlags phrase in their own code, withdrew the vestigial-layout reading of ECG negative result: the 1584-byte flash record is layout v16, and it is empty with the circuit closed #1100 once the argument mapping was known, and independently verified @meta1971's fixtures with a parser they wrote from scratch rather than the one shipped with it.
    • @Zebsi235 found the actual cause. The inverted 124 argument mapping is the answer to the title, and the MAX86176: Set ECG ON correlation that showed 139 gates the transport rather than the front end came with it. They also corrected their own master-gate claim a week later, unprompted, and built the allow-list and research modules the probe stands on.
    • @ayiskakov found the flash-banked R16 record sitting in NOOP's own reject archive, proved it carried the ECG with an empty-versus-populated pair of the same layout from the same offload, validated the rhythm against the Widget (iOS): throttle the live-HR republish to 60s (#114 follow-up) #194 record-period artifact before anyone asked, retracted their own "zero-fill" and "no live stream" claims with the same care they made them, and located two defects in NOOP's probe along the way.
    • @meta1971 contributed the unaligned-frame root cause, the switch-isolation matrix, the verdict timing that invalidated the 30 s window, the HRV-field behaviour, the byte-82 burst cadence, the R20 and R21 layouts, the front-end measurements, and two sanitised CRC-valid fixtures with a verification script, counters rebased and nothing identifying the strap. Much of what NOOP now decodes past ECG came out of that work.
    • @DX23876 brought the calibrated reference nobody else had: an Apple Watch on the same wrist, three back-to-back pairs, the microvolt scale to within about 10 percent, the high-pass measurement, interval accuracy checked against the cardiologist annotations of the PhysioNet QT Database before trusting it against the strap, and a detection bug in their own code found by running it on someone else's noisy fixture. They also flagged the reject-archive eviction that is now item 2 above.
    • @bhelm wrote the ECG protocol chapter that turned out to be right about R16 before anyone had decoded one.
    • @digitalerdude, whose full-history capture in WHOOP 5.0 raw HCI capture — where to submit? (docs reference #174, which doesn't exist) #103 was the strongest evidence against hypothesis (b) for two months and is what made the eventual R16 result interesting rather than expected.
    • And the OpenStrap project, whose ECG flow @DX23876 ported and credited, and the johnmiddleton12/my-whoop and b-nnett/goose reverse-engineering efforts that the opcode table came from in the first place.

    Thank you, all of you. The discipline in this thread is the reason it converged: labelled OBSERVED and INFERRED, retractions posted by the people who had the most invested in the claim, and raw frames pasted instead of verdicts.

  12. ryanbr commented on Oct 24, 2026

    @ryanbr
    Owner

    Items 1 and 2 of the open list above now have their own issues, so they are tracked somewhere live rather than only here:

    Items 3 and 4 (the stale terminalGrace figure, and the resp_seq label at response offset 11) are small enough to ride along with the next ECG change rather than carry an issue each.

  13. meta1971 commented on Oct 24, 2026

    @meta1971

    Data for the terminalGrace item. 128 recordings on one MG (fw 50.40.1.0) reached progress 100. The first record to the progress-100 record took a median 37 s (90th percentile 40, range 36 to 111), and 115 of the 128 landed at 35 to 40 s. The HRV field (bytes 29 to 30) was valid at some point in 123 of 128. Relative to the progress-100 record, its first valid value was a median +6 s (90th percentile +106, maximum +238), and it was already valid on or before that record in 26. So a 10 s window after it catches 57% of recordings, 20 s catches 69%, and 60 s catches 84%. Five never got a value.

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

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions