patch-cc 0.3.2__tar.gz → 0.3.3__tar.gz

patch_cc-0.3.3/.github/workflows/release-watch.yml

@@ -0,0 +1,164 @@
+name: Release watch
+
+# Fires the "patch-cc release watch" cloud routine the moment Anthropic ships a
+# new Claude Code build, instead of leaving it to the routine's own daily cron.
+#
+# The routine already knows how to decide whether anything moved -- it compares
+# the upstream version and the checkout HEAD against the ledger in issue #1 and
+# exits silently when neither did. Its schedule was never the interesting part;
+# it was just a poll, once a day, which meant a release that broke a patch could
+# sit unnoticed for up to 24 hours. This workflow moves the poll here, where a
+# tick is one curl instead of a cloud session, and only wakes the routine when
+# the version actually changes.
+#
+# The routine keeps its daily schedule as a backstop: if this workflow breaks or
+# GitHub skips the schedule, the watch degrades to its old once-a-day behaviour
+# rather than going silent. That is why a failed poll below is a warning and not
+# a red run -- a flaky fetch must not page anyone.
+#
+# SETUP (one time, by hand -- there is no API for token creation):
+#   claude.ai/code/routines -> "patch-cc release watch" -> pencil icon
+#   -> Add another trigger -> API -> Generate token (shown once)
+#   -> store it as the repo secret ROUTINE_FIRE_TOKEN.
+
+on:
+  schedule:
+    # Every 10 minutes. GitHub delays scheduled runs under load, so read this as
+    # "within ~10-25 min of a release", not as a guarantee.
+    - cron: "*/10 * * * *"
+  workflow_dispatch:
+
+concurrency:
+  group: release-watch
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  issues: read
+
+env:
+  # The channel file the Claude Code installer itself reads -- the same source
+  # the routine treats as authoritative, so the two never disagree about what
+  # "the current release" means.
+  CHANNEL_URL: https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/latest
+  # Not a secret: firing needs the bearer token, and that is one.
+  ROUTINE_ID: trig_01WrgxdCZahJEHD3NNYcetqS
+  LEDGER_ISSUE: "1"
+
+jobs:
+  watch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Read the release channel
+        id: upstream
+        run: |
+          set -uo pipefail
+          if ! v=$(curl -fsSL --max-time 30 --retry 3 --retry-delay 5 "$CHANNEL_URL"); then
+            echo "::warning::could not reach the release channel; skipping this tick"
+            echo "skip=1" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          v=$(printf '%s' "$v" | tr -d '[:space:]')
+          case "$v" in
+            [0-9]*.[0-9]*.[0-9]*) ;;
+            *)
+              echo "::warning::channel returned something that is not a version: '$v'"
+              echo "skip=1" >> "$GITHUB_OUTPUT"
+              exit 0
+              ;;
+          esac
+          echo "version=$v" >> "$GITHUB_OUTPUT"
+          echo "upstream: $v"
+
+      # First guard: did an earlier tick already fire for this version? The
+      # routine takes several minutes to run (it downloads a ~275 MB bundle), so
+      # without this every tick during that window would fire it again.
+      - name: Already fired for this version?
+        id: marker
+        if: steps.upstream.outputs.skip != '1'
+        uses: actions/cache/restore@v4
+        with:
+          path: .fired
+          key: fired-${{ steps.upstream.outputs.version }}
+          lookup-only: true
+
+      # Second guard, and the authoritative one: the ledger records the version
+      # the routine has actually finished processing. This is what catches the
+      # case where the cache entry was evicted but the work is long done.
+      - name: Read the ledger's last-version
+        id: ledger
+        if: steps.upstream.outputs.skip != '1' && steps.marker.outputs.cache-hit != 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -uo pipefail
+          if ! body=$(gh issue view "$LEDGER_ISSUE" --repo "$GITHUB_REPOSITORY" --json body -q .body); then
+            echo "::warning::could not read the ledger; skipping this tick rather than guessing"
+            echo "skip=1" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          last=$(printf '%s\n' "$body" | sed -n 's/^last-version:[[:space:]]*//p' | head -1 | tr -d '[:space:]')
+          echo "last=$last" >> "$GITHUB_OUTPUT"
+          echo "ledger: $last"
+
+      - name: Fire the routine
+        id: fire
+        if: >-
+          steps.upstream.outputs.skip != '1' &&
+          steps.marker.outputs.cache-hit != 'true' &&
+          steps.ledger.outputs.skip != '1' &&
+          steps.ledger.outputs.last != steps.upstream.outputs.version
+        env:
+          TOKEN: ${{ secrets.ROUTINE_FIRE_TOKEN }}
+          VERSION: ${{ steps.upstream.outputs.version }}
+          LAST: ${{ steps.ledger.outputs.last }}
+        run: |
+          set -uo pipefail
+          if [ -z "${TOKEN:-}" ]; then
+            echo "::error::ROUTINE_FIRE_TOKEN is not set -- see the setup note at the top of this file"
+            exit 1
+          fi
+          body=$(printf 'Claude Code %s is on the release channel; the ledger last recorded %s. This line is a hint for the run log only -- re-derive the version yourself from the channel, per your step 2.' "$VERSION" "${LAST:-(none)}")
+          payload=$(jq -nc --arg t "$body" '{text: $t}')
+          out=$(mktemp)
+          code=$(curl -sS -o "$out" -w '%{http_code}' -X POST \
+            "https://api.anthropic.com/v1/claude_code/routines/$ROUTINE_ID/fire" \
+            -H "Authorization: Bearer $TOKEN" \
+            -H "anthropic-version: 2023-06-01" \
+            -H "anthropic-beta: experimental-cc-routine-2026-04-01" \
+            -H "Content-Type: application/json" \
+            -d "$payload") || code=000
+          echo "HTTP $code"
+          cat "$out"
+          echo
+          if [ "$code" != "200" ]; then
+            # Deliberately not marking the version as fired, so the next tick
+            # retries. A 429 here just means the daily run cap was reached.
+            echo "::error::fire failed with HTTP $code"
+            exit 1
+          fi
+          echo "url=$(jq -r '.claude_code_session_url // empty' "$out")" >> "$GITHUB_OUTPUT"
+          : > .fired
+
+      # Only reached on a 200, so the marker never claims a fire that failed.
+      - name: Mark this version as fired
+        if: steps.fire.outcome == 'success'
+        uses: actions/cache/save@v4
+        with:
+          path: .fired
+          key: fired-${{ steps.upstream.outputs.version }}
+
+      - name: Summary
+        if: always()
+        run: |
+          {
+            echo "### Release watch"
+            echo
+            echo "- upstream: \`${{ steps.upstream.outputs.version || 'unreadable' }}\`"
+            echo "- ledger last-version: \`${{ steps.ledger.outputs.last || 'not read' }}\`"
+            if [ -n "${{ steps.fire.outputs.url }}" ]; then
+              echo "- **fired the routine** -> ${{ steps.fire.outputs.url }}"
+            else
+              echo "- no fire (nothing moved, or already fired for this version)"
+            fi
+          } >> "$GITHUB_STEP_SUMMARY"

{patch_cc-0.3.2 → patch_cc-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patch-cc
-Version: 0.3.2
+Version: 0.3.3
 Summary: Interactive patcher for the Claude Code native binary
 Project-URL: Homepage, https://github.com/anfreire/patch-cc
 Project-URL: Repository, https://github.com/anfreire/patch-cc

{patch_cc-0.3.2 → patch_cc-0.3.3}/docs/PLAYBOOK.md

@@ -455,7 +455,11 @@ Each sub-step records its own `candidates`/`applied`:
   reducer whose setter threading applied while every arm had drifted once
   reported hits and streamed nothing.
 - **`final-summary`**, optional: redacted thinking in the closing summary is a
-  refinement, not the feature.
+  refinement, not the feature. Its guard is whichever enclosing `if` *tests the
+  block* — 2.1.236 nested an experiment gate between the test and the summary
+  it guards, and "the nearest `if`" read a shape that had merely moved as one
+  that was gone. The climb is bounded by the function that declares the block,
+  because a receiver's name is only a spelling until its scope is said.
 
 An *optional* sub-step that finds nothing is reported as absent, not broken —
 it is just a shape this build doesn't have. A sub-step that finds a shape but
@@ -788,6 +792,28 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
     *initialised* to is deliberately not asked: `useState(null)` is every
     build's spelling and `useState(void 0)` would be the same state, while the
     setter is the identity that matters.
+  - **The state has two homes, and the handed setter names both.** Through
+    2.1.235 the scope that hands `onStreamingThinking` declared the state
+    itself, and the state is the array pattern binding the handed setter —
+    `useState`'s pair. 2.1.236 moved it into an external stream store
+    (`subscribe`/`getSnapshot`/`_publish` — the `useSyncExternalStore` shape)
+    and hands `<store>.setStreamingThinking` instead; the same scope reads the
+    store back by destructuring the hook call it hands the store to
+    (`{streamingToolUses:…}=useX(<store>)`), so the state is that pattern's own
+    `streamingThinking` binding — upstream's the day it takes one, the goal
+    achieved, and until then ours, inserted at the front of the pattern. The
+    pattern is proven the snapshot read by the store expression itself: the
+    call's *only* argument is the very expression the setter was read off, one
+    answer or none (`js.only`). Sole argument is deliberate — a second is a
+    selector whose result is no longer the snapshot, and extending a pattern of
+    unknowable provenance binds `undefined` with every count green. The
+    insertion also pays for a witness the way `thinking-summaries` does: the
+    field it binds must still be named by the bundle's own objects (the store's
+    snapshot initialiser, its publish call), so a store that renames the field
+    reads as the step reporting the store rather than threading `undefined`.
+    Two things come free with the store: its setter takes functional updaters —
+    React's own contract, which the reducer splices already speak — and it
+    hides a finished block itself after 30 s, upstream's own linger.
 
   A render was once selected by *position* — the observation that the real sites
   fall after the state's `useState` declaration. That is worth recording as a
@@ -1245,10 +1271,10 @@ enumerated with their hashes in [corpus.md](corpus.md). Each removed matcher hit
 can still be running; each was carried as "kept for older builds", which is a
 claim the corpus disproves. The verbatim matchers were re-run from `HEAD` over
 the whole corpus after the move, and they are still zero everywhere. The
-measurements this section quotes were taken during the move across a wider span
-(2.1.210 → 2.1.233; 2.1.230 was never published), some of whose early builds
-predate the current backup set — `corpus.md` is the reproducible subset on disk
-now, and re-running `doctor` over it is one command (below).
+measurements this section quotes were taken during the move across
+2.1.210 → 2.1.233 (2.1.230 was never published) — a span the corpus has since
+grown to hold in full, so they are re-checkable rather than historical, and
+re-running `doctor` over it is one command (below).
 
 - **`live-thinking` / `reducer-legacy`** — the pre-2.1.138 reducer with
   positional parameters. Its removal collapsed the `reducer` variant *group*

{patch_cc-0.3.2 → patch_cc-0.3.3}/docs/corpus.md

@@ -11,7 +11,8 @@ Before the first patch of a version, patch-cc copies the pristine binary to
 `~/.local/share/patch-cc/backups/<version>.orig` ([INTERNALS.md](INTERNALS.md#safety)).
 The corpus is exactly those copies: not a fixture checked into the repo (each is
 ~300 MB), but a set that **accretes on its own** as Claude auto-updates and you
-re-patch. `doctor <path>` reads one; the sweep below reads all of them.
+re-patch — and that can be backfilled by saving any pristine native binary under
+the same name. `doctor <path>` reads one; the sweep below reads all of them.
 
 The binaries are the artifact, not this file — `doctor` recomputes every count
 from them, so nothing here can drift from what a matcher actually does. This
@@ -20,42 +21,52 @@ matches means the file changed under you, not that a number moved.
 
 ## On disk now
 
-The reproducible set on the machine this was written on — 13 distinct binaries
-by content (the SHA-256 is the whole file, `sha256sum <version>.orig`):
+The whole published span `2.1.210` → `2.1.236` — 2.1.230 was never published —
+one pristine binary per version, 26 in all. Two pairs share a byte count
+(`2.1.225`/`2.1.226`, `2.1.229`/`2.1.231`) and are still distinct binaries,
+which is why the identity column is the hash (of the whole file,
+`sha256sum <version>.orig`) and never the size:
 
 | version | size | sha256 |
 |---|---|---|
+| `2.1.210` | 261 MB | `e7d2ceb53ed4c2ced1fe7fc1c6331c98dc5f7b4c9b2722d9c5fa3dd5dff6f719` |
+| `2.1.211` | 262 MB | `8272c8a474ac9ea1bc35f19b9f7c7e7dc4dc4eb6d5ad3e484b19335ac72446b2` |
+| `2.1.212` | 264 MB | `044a88cf3a5180776617fd3da1238dcbf9141ddec449a39cf7d2af1ac78e684e` |
+| `2.1.213` | 265 MB | `7999631426e1b6e4444e4ecf9cd8a63a05a0411ccfe503927d4c9d57bc41bc64` |
+| `2.1.214` | 265 MB | `3c029136f7c81f54ed4a38e9d52e655aad536433dbbde50519c8c31bb646ad14` |
+| `2.1.215` | 265 MB | `c1efffaaf370aa187cb6a09dd93d4e511c646899b0078476f83791b664bde7fe` |
 | `2.1.216` | 267 MB | `74deca45220b8080ec75ab099bd5a5980e41a2b5879846a008fb115d436de085` |
 | `2.1.217` | 269 MB | `2630fc5dc6db61bc03f86b95daf47766e5ed5b61873f7bb7cfea764c5ac5a9ba` |
 | `2.1.218` | 273 MB | `e12071751a9336b8af1012c103358ff04ac18f9aaff4a738cff7ba5cdfaf63f2` |
 | `2.1.219` | 275 MB | `22cfd6f5b3061c0391ba84e9cf8c9deaa37783aac18b004d42ec061e98f00691` |
 | `2.1.220` | 275 MB | `674f61f20ff306f3100cf9200e4c36c4b70278b5bef2884549819b942a89c863` |
 | `2.1.221` | 289 MB | `60db8e88d42c24b5199c92cfd56ec88370c510c3789c6f364af748354f087ada` |
+| `2.1.222` | 289 MB | `10caae8f22b915c26bfff0e013a4d45608c4f1ae287583626569156f447730e5` |
 | `2.1.223` | 291 MB | `98226474f802e3094d6a86c5ade8883c16206d0fcb5c400b7401c800063e99d7` |
+| `2.1.224` | 296 MB | `a2b5add7dc4bcd8eaa029f4e8bdac4df7769b4073698db7989d206baf9419c2d` |
+| `2.1.225` | 298 MB | `0a3be8d18cb0f5357d38ce2d588601753a60b44cc9c622579ed8b8405dee231e` |
 | `2.1.226` | 298 MB | `4e9bec1177ce9690e8bd988b710ac24105e70da428dd094c5adcbbe786a55555` |
 | `2.1.227` | 304 MB | `6832dc3f1797b890b71116e5f2dbbf9a83fd3d0498c235b4b0f9cd0e6e499ad6` |
 | `2.1.228` | 309 MB | `d535985e6941a3eb00179ccd7f52ceb0c6623a0305a518ebc4e6514f84a94c99` |
+| `2.1.229` | 311 MB | `200338139a3df04a9ad22233837d1fb53fb6dffa21cd82e47559bfaa115acc1b` |
+| `2.1.231` | 311 MB | `47a01daebf794f6c86c13d1875ad6e5be0627029ad8600731161f24018ecde5b` |
+| `2.1.232` | 323 MB | `61d23f8749136907d586d5b11831ea8a5234d4c1dea40a5e55c33b52e204c6d1` |
 | `2.1.233` | 325 MB | `55d281096f57d411ebbdd94dbf5e9ff3accb7c05713e37348c2c11d4b83bf9d9` |
 | `2.1.234` | 328 MB | `3473601ea695d5bf769c5b202844d4cb4fbf723ae995450fcb6973204775c84a` |
 | `2.1.235` | 331 MB | `bfcf0ae2dbf94b2b6a106074aabf3938b9a10889c3b678e4cb5a00c03274d5d5` |
+| `2.1.236` | 335 MB | `6c8818fa22187aa555c242be4abbacc44d6b71a32ac9631ee7b2b5d12f51f752` |
 
-The backup directory holds a few more files than rows here, and that is not a
-discrepancy: a pre-0.2.0 backup doubled the version into its name
-(`2.1.216.2.1.216.orig`), a binary installed under a non-version name is
-saved as `claude.unknown-<hash>.orig`, and a binary patched under a
-non-canonical filename keeps that filename (`2.1.235` entered the corpus as a
-downloaded `claude-2.1.235`, so its backup is `claude-2.1.235.orig`). The two
-extra 2.1.216-era files hash-match the `2.1.216` row above — same bytes, a
-different filename — which is why the count of *files* (15) and the count of
-*distinct binaries* (13) differ.
+This set covers the span the playbook's tree-move measurements were taken over
+(`2.1.210` → `2.1.233`), so those numbers are re-checkable here rather than
+historical.
 
 ## Rebuild or extend it
 
-There is nothing to download and no fixture to restore: the corpus is whatever
-pristine backups you have accumulated, and it grows every time patch-cc touches
-a new build. To widen it, run patch-cc across Claude updates — each first patch
-of a version leaves its `.orig`. To read the JS a given binary carries without
-patching anything:
+The corpus grows every time patch-cc touches a new build — each first patch of
+a version leaves its `.orig` — and a version this machine never patched joins
+the same way: save its pristine native binary as
+`~/.local/share/patch-cc/backups/<version>.orig`. To read the JS a given binary
+carries without patching anything:
 
 ```bash
 patch-cc extract ~/.local/share/patch-cc/backups/2.1.233.orig > 2.1.233.js
@@ -75,12 +86,3 @@ sweep
 
 `doctor` is read-only — it runs the matchers and parses their output, and never
 writes a binary — so the sweep is safe to run against every backup at any time.
-
-## Provenance of the wider span
-
-Some measurements in the playbook were taken during "the move to the tree"
-across a wider set than is durably on disk now — the range `2.1.210` → `2.1.233`
-(2.1.230 was never published), whose earliest builds predate this backup set.
-Those numbers were real when taken; the set above is what reproduces today, and
-a claim that names a build not listed here is a historical one this file does
-not stand behind byte-for-byte.

{patch_cc-0.3.2 → patch_cc-0.3.3}/src/patch_cc/__init__.py

@@ -1,3 +1,3 @@
 """patch-cc: an interactive patcher for the Claude Code native binary."""
 
-__version__ = "0.3.2"
+__version__ = "0.3.3"

{patch_cc-0.3.2 → patch_cc-0.3.3}/src/patch_cc/patches/streaming.py

@@ -132,6 +132,9 @@ _SETTER = "onStreamingThinking"
 #: `prop-threading` when 2.1.235 retired it -- and discriminates nothing on any
 #: build in the corpus: the pair already names the same one renderer.
 _TRANSCRIPT_SIGNATURE = ("messages", "streamingToolUses")
+#: Our local for the threaded state, wherever one has to be minted: the
+#: renderer signatures `transcript-signature` extends, and the store-snapshot
+#: pattern `prop-threading` extends on builds that keep the state in a store.
 _INJECTED = "__cc_streamingThinking"
 
 
@@ -199,8 +202,10 @@ def _bound_in_scope(site: js.Node, prop: str) -> str | None:
     return None
 
 
-def _state_in_scope(site: js.Node) -> str | None:
-    """The live-thinking state variable visible at this render, if any.
+def _state_in_scope(site: js.Node) -> tuple[str, js.Node | None] | None:
+    """The live-thinking state at this render: the name to thread, and the
+    snapshot pattern to extend first when the state has to be read out of a
+    store rather than a binding upstream already made.
 
     Resolved from the site outwards, so what is threaded is a variable actually
     in scope where it is threaded -- the one thing the old matcher named as
@@ -211,34 +216,48 @@ def _state_in_scope(site: js.Node) -> str | None:
     gate could see it; it throws when that component renders.
 
     The state is identified by its setter: the scope that holds live thinking
-    is the scope that hands ``onStreamingThinking`` to the reducer.
-
-    Outwards is only half of lexical, and the half a subtree walk gets wrong:
-    the declaration has to be one this render can *see* (:func:`js.visible`),
-    which a nested function's is not and a block's own is not either. Threading
-    one anyway produced a binary that parsed and threw -- the same failure as
-    the bundle-wide answer this replaced, one door along -- and took the note
-    that says a render was skipped with it. The setter is the other question and
-    keeps the whole subtree: a scope may hand its setter to the reducer from
-    inside a callback, and that says nothing about where the state lives.
-
-    What the state is initialised to is not asked. ``useState(null)`` was the
-    spelling on every build in the corpus and ``useState(void 0)`` is the same
-    state, while the line below is the identity that matters: the pair whose
-    second name is the setter this scope hands the reducer *is* the live
-    thinking state, whatever produced it.
+    is the scope that hands ``onStreamingThinking`` to the reducer. The setter
+    is asked of the whole subtree on purpose -- a scope may hand it from inside
+    a callback, and that says nothing about where the state lives -- while the
+    binding threaded has to be one this render can *see* (:func:`js.visible`),
+    which a nested function's is not and a block's own is not either.
+
+    What the handed setter *is* has two upstream spellings, and each names the
+    state its own way:
+
+    - **A bare identifier** -- a ``useState`` setter, every build through
+      2.1.235. The state is the array pattern that binds it: the pair whose
+      second name is the setter this scope hands the reducer *is* the live
+      thinking state, whatever produced it (``useState(null)`` and
+      ``useState(void 0)`` are the same state, so the initialiser is never
+      asked).
+    - **A member read on a store** -- 2.1.236 moved the state into an external
+      stream store (``subscribe``/``getSnapshot``/``_publish``) and hands the
+      reducer ``<store>.setStreamingThinking``. The scope reads that store back
+      by destructuring the hook call it hands the same store to
+      (``{streamingToolUses:…}=useX(<store>)``), so the state is that pattern's
+      own ``streamingThinking`` binding: upstream's, the day it takes one --
+      the goal achieved, same as every other judged-on-achievement step -- and
+      until then ours, inserted into the pattern. The pattern is proven the
+      snapshot read by the store expression itself: the call's *only* argument
+      is the very expression the setter was read off, with one answer or none
+      (:func:`js.only`). Sole argument is deliberate -- a second argument is a
+      selector whose result is no longer the snapshot, and extending a pattern
+      of unknowable provenance binds ``undefined`` with every count green, so
+      that shape is refused loudly instead.
     """
     scope = js.climb(site, lambda n: n.type in js.FUNCTIONS)
     while scope is not None and not _outermost(scope):
-        setters = {
-            js.text(js.binding(value))
+        handed = [
+            value
             for node in js.every(
                 scope,
                 lambda n: n.type == "property_identifier" and js.text(n) == _SETTER,
             )
             if (pair := js.named(node)) is not None
             and (value := pair.child_by_field_name("value")) is not None
-        }
+        ]
+        setters = {js.text(js.binding(value)) for value in handed}
         for declarator in js.every(scope, js.of_type("variable_declarator")):
             name = declarator.child_by_field_name("name")
             if name is None or name.type != "array_pattern":
@@ -247,7 +266,33 @@ def _state_in_scope(site: js.Node) -> str | None:
                 continue
             bound = [js.text(child) for child in name.named_children]
             if len(bound) == 2 and bound[1] in setters:
-                return bound[0]
+                return bound[0], None
+        snapshots: dict[int, js.Node] = {}
+        for setter in (v for v in handed if v.type == "member_expression"):
+            store = js.text(js.receiver(setter))
+            for declarator in js.every(scope, js.of_type("variable_declarator")):
+                name = declarator.child_by_field_name("name")
+                value = declarator.child_by_field_name("value")
+                if name is None or name.type != "object_pattern":
+                    continue
+                if not js.children(name) or value is None:
+                    continue
+                if value.type != "call_expression":
+                    continue
+                taken = js.arguments(value)
+                if len(taken) != 1 or js.text(taken[0]) != store:
+                    continue
+                if not js.visible(declarator, site):
+                    continue
+                snapshots[declarator.start_byte] = name
+        pattern = js.only(
+            list(snapshots.values()), "snapshot reads of the live-thinking store"
+        )
+        if pattern is not None:
+            carried = js.props(pattern)
+            if _STREAMING in carried:
+                return js.text(js.binding(carried[_STREAMING])), None
+            return _INJECTED, pattern
         scope = js.climb(scope.parent, lambda n: n.type in js.FUNCTIONS)
     return None
 
@@ -257,22 +302,55 @@ def _step_prop_threading(source: Source, outcome: Outcome) -> Source:
     step = outcome.step("prop-threading")
     edits = []
     renders = _conversation_renders(source)
-    # Printed every run, green ones included: an early warning held back until
-    # something breaks arrives too late to be one.
-    step.note(f"{len(renders)} conversation render(s)")
-
+    # The durable witness behind a snapshot insertion: the field it binds is
+    # one the bundle's own objects still name (the store's snapshot initialiser
+    # and its publish call, on 2.1.236). Extending the pattern is a rewrite the
+    # matcher can only vouch for itself, and a store that renames the field
+    # would leave it threading `undefined` with every count green -- the same
+    # hole `thinking-summaries` pays a header-name count for.
+    field_named = any(
+        (pair := js.named(node)) is not None and pair.type == "pair"
+        for node in source.find(_STREAMING)
+    )
+    extended: set[int] = set()
+    unreached = 0
     for bag in renders:
-        state = _state_in_scope(bag)
-        if state is None:
-            step.note("a conversation render has no live-thinking state in scope")
+        resolved = _state_in_scope(bag)
+        if resolved is None:
+            # By design on every build we hold: the resume view, the transcript
+            # overlay and the message picker draw conversations too, in scopes
+            # where nothing ever streams. Counted rather than worth a sentence
+            # each -- the note below carries the number, and the number moving
+            # is the signal (a render newly skipped was the only sign of the
+            # 2.1.232 out-of-scope threading).
+            unreached += 1
+            continue
+        state, pattern = resolved
+        if pattern is not None and not field_named:
+            step.note(f"the stream store no longer names a {_STREAMING} field")
             continue
         step.candidates += 1
         step.applied += 1
-        edits.append(
-            Edit.before(
-                js.entry(js.props(bag)[_CONVERSATION[0]]), f"{_STREAMING}:{state},"
+        carried = js.props(bag)
+        if _STREAMING in carried:
+            # Upstream already threads it into this render; the goal achieved.
+            continue
+        if pattern is not None and pattern.start_byte not in extended:
+            # Two renders in one scope read one snapshot: the pattern gains the
+            # field once, at the front, which is valid whatever it ends with.
+            extended.add(pattern.start_byte)
+            edits.append(
+                Edit.before(pattern.named_children[0], f"{_STREAMING}:{state},")
             )
+        edits.append(
+            Edit.before(js.entry(carried[_CONVERSATION[0]]), f"{_STREAMING}:{state},")
         )
+    # Printed every run, green ones included: an early warning held back until
+    # something breaks arrives too late to be one.
+    step.note(
+        f"{len(renders)} conversation render(s)"
+        + (f", {unreached} with no live-thinking state in scope" if unreached else "")
+    )
     return source.apply(edits)
 
 
@@ -473,19 +551,34 @@ def _step_final_summary(source: Source, outcome: Outcome) -> Source:
         if not js.reads(thinking, _SUMMARY_PROPS[0]):
             continue
         block = js.text(js.receiver(thinking))
-        guard = js.up(summary, "if_statement")
-        if guard is None:
-            continue
-        condition = guard.child_by_field_name("condition")
-        scope = js.climb(guard, lambda n: n.type in js.FUNCTIONS)
-        if condition is None or scope is None:
+        # The block's home is the function that produced it -- the one holding
+        # the `.find` whose predicate selects thinking -- resolved from the
+        # summary outwards, since the summary itself sits inside the callback
+        # that hands it over.
+        scope = js.climb(summary, lambda n: n.type in js.FUNCTIONS)
+        predicate = None
+        while scope is not None and not _outermost(scope):
+            if (predicate := _selects_thinking(scope, block)) is not None:
+                break
+            scope = js.climb(scope.parent, lambda n: n.type in js.FUNCTIONS)
+        if predicate is None or scope is None:
             continue
-        # The two tests that reject a redacted block: the one inside the `.find`
-        # that produced it, and the one this summary is guarded by. Each is a
-        # node; none of the code between them is.
-        predicate = _selects_thinking(scope, block)
-        test = _tests_thinking(condition, block)
-        if predicate is None or test is None:
+        # Which `if` guards the summary is answered by what its condition
+        # tests, never by being the nearest: 2.1.236 nested an unrelated gate
+        # between the thinking test and the summary it guards, and the nearest
+        # `if` read a shape that had merely moved as one that was gone. The
+        # climb stays inside the block's own home, because its name is only a
+        # spelling until the scope it belongs to is said.
+        guard = js.up(summary, "if_statement")
+        test = None
+        while (
+            guard is not None
+            and guard.start_byte >= scope.start_byte
+            and (test := _tests_thinking(guard.child_by_field_name("condition"), block))
+            is None
+        ):
+            guard = js.up(guard.parent, "if_statement")
+        if test is None:
             continue
         step.candidates += 1
         step.applied += 1