patch-cc 0.3.1__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.1 → patch_cc-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patch-cc
-Version: 0.3.1
+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.1 → patch_cc-0.3.3}/docs/CONDUCT.md

@@ -56,7 +56,7 @@ shape that already absorbs every case, found rather than bolted on.
   shape this build simply lacks — most patches carry several — not a regression.
   Keep "gone", "already applied", and "not on this build" as distinct signals;
   never collapse them into one number. Which one a sub-step's silence means is
-  not guesswork: declare it (`expect=True`) so a green tick cannot cover a dead
+  not guesswork: declare it (`Outcome.declare`) so a green tick cannot cover a dead
   feature. A step nobody declared is a step that cannot report its own death:
   `branding` carried none, so a name badge that stopped being a bold render was
   a green run, an unchanged banner, and a manifest asserting the new name. See

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

@@ -368,13 +368,13 @@ and why `prop-threading` resolves scope itself.
 
 Counting alone cannot tell "this build lacks that shape" from "the feature is
 dead": a patch whose optional shapes rewrite happily while a load-bearing one
-is gone still changes bytes, and would read as green. So each sub-step declares
-what its absence *means* (`Outcome.step(..., expect=...)`):
+is gone still changes bytes, and would read as green. So each sub-step is
+declared with what its absence *means* (`Outcome.declare`):
 
 | mark | meaning | absence is |
 |---|---|---|
-| *(default)* | a shape only some builds carry | informational |
-| `expect=True` | the patch does nothing useful without it | a regression |
+| `optional` | a shape only some builds carry | informational |
+| `required` | the patch does nothing useful without it | a regression |
 
 `Outcome.unmet()` turns a violation into a sentence (`required step
 group-routing found nothing`); `Outcome.failures()` adds any exception the
@@ -404,9 +404,15 @@ Three rules keep the net from having holes:
   feature are now checked by the markers their builders emit
   (`streaming._CORE_UPDATES`), which no amount of neighbouring churn can fake.
 - **Declare an expectation before the work, not inside it.** A step created only
-  by its own success cannot report its own absence. `_live_thinking` registers
-  the core updates up front; `agents.bypassed_agents` resolves the pinned agent
-  from the helper's durable head so a drifted body still has a step to fail.
+  by its own success cannot report its own absence. This is the API's shape,
+  not a discipline: `Outcome.declare` is the only way a step comes to exist
+  (up front, required and optional named apart), and `outcome.step(name)`
+  retrieves — an undeclared name raises, so a typo cannot mint a silently
+  optional step. Work that is owed conditionally declares under the same
+  condition it runs (`codex._register_context`), and a name resolved from the
+  bundle is declared the moment it resolves — `agents.bypassed_agents` has no
+  step to name until the helper's guard gives up the pinned agent, and a guard
+  that vanishes leaves the always-printed note, with no name left to declare.
 
 `apply` acts on the verdict: a broken patch is re-run out of the final pass, so
 its orphan edits never reach the binary, the manifest never claims it, and the
@@ -449,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
@@ -584,6 +594,20 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
   arm's head was baked in as the file's length, `newLines:String(t)`, counted
   and green.
 
+  **Alive by eye:** ask for a new file *via the Write tool* — the row reads
+  `Added N lines` over green `+` rows. Two things legitimately show no diff and
+  are not this patch failing: a file created through **Bash** (heredoc, `tee`,
+  a script) is Bash output and never enters this renderer; and upstream keeps
+  planting early returns *ahead of* the spliced render — plan-directory files
+  ("/plan to preview"), condensed contexts (subagent progress rows, session
+  summaries: "Wrote N lines to path"), and scratchpad/`.workshop.*` files in
+  non-verbose re-renders ("Wrote N lines ⧉"). The live conversation renders
+  the current message verbose, so the diff shows there today; those guards are
+  the patch's effective coverage narrowing upstream-side, which `doctor` —
+  counting matchers, not paths — cannot see. Measured on 2.1.234 (live,
+  resume, plain/workshop/scratchpad files): every reachable path drew the
+  diff.
+
 ### Thinking — `thinking.py`
 
 - **`thinking-summaries`** — stop echoing the account's server-side experiment
@@ -725,16 +749,28 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
 - **`live-thinking`** — the fourteen-step patch above.
 
   **`prop-threading`** inserts `streamingThinking:<state>,` before the
-  `agentDefinitions` property of every props bag that also carries
-  `conversationId` and `messages`. Three things do the work, and each replaced
-  something that had broken:
-
-  - **Identity is membership.** The props that make a render a conversation
-    render, asked of one object rather than of a span of text. Four matchers
-    once modelled this — a brace-free `createElement` call, an ordered prompt
-    renderer, and two regexes differing only in the order two call sites listed
-    the same props. 2.1.229 killed the ordered pair at once by inserting
-    `onRateLimitAutoQueueContinue:` between two of them.
+  `conversationId` property of every props bag *handed to a component* — an
+  argument — that also carries `messages`. Being an argument is part of the
+  identity: a module-level literal, a return-value payload, or a config object
+  may legitimately carry the pair, and none of them is a render. Three things
+  do the work, and each replaced something that had broken:
+
+  - **Identity is membership — of the essential props alone.** The props that
+    make a render a conversation render, asked of one object rather than of a
+    span of text. Four matchers once modelled this — a brace-free
+    `createElement` call, an ordered prompt renderer, and two regexes differing
+    only in the order two call sites listed the same props. 2.1.229 killed the
+    ordered pair at once by inserting `onRateLimitAutoQueueContinue:` between
+    two of them. The membership then carried `agentDefinitions` as a third
+    conjunct — witness and insertion point in one — and 2.1.235 retired that
+    prop from the bag: an identity resting on a *neighbour* read a build that
+    plainly drew four conversation renders as drawing none, with every anchor
+    count standing (`agentDefinitions` still occurs 97 times — as other
+    components' prop). The conversation pair is what the render *is*; the
+    neighbour was one more thing upstream had to keep, and upstream owes the
+    matcher nothing. Same class as the resolver default on 2.1.234: the
+    identity must be the weakest claim that still proves it, and every conjunct
+    past that is a break waiting on a harmless refactor.
   - **The insertion point is a prop boundary**, so nothing computes where a
     literal ends. Being an `object` and not an `object_pattern` is what
     separates a prop being *passed* from one being *received*; the regex spelled
@@ -756,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
@@ -782,7 +840,17 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
 
   **`transcript-signature` and `inline-extras`** are one hand-off and two
   steps: the first threads `streamingThinking` into every renderer whose
-  signature carries the transcript trio, the second rewrites that renderer's
+  signature carries `messages` and `streamingToolUses`, inserting before the
+  latter — an insertion point inside the identity, for `prop-threading`'s
+  reason. The signature was a trio until `showAllInTranscript` was measured to
+  discriminate nothing on any build in the corpus: a third conjunct that was
+  find-anchor, identity and insertion point in one, the exact triple role
+  `agentDefinitions` held when 2.1.235 retired it. Deriving the renderer from
+  its consumer instead — the scope that binds what the extras memo computes
+  over — was measured and rejected: the memo's receiver is a react-compiler
+  memoized *local* on every current build, with real dataflow between it and
+  the signature, and a dataflow pass is a tool this project deliberately does
+  not build. The second step rewrites that renderer's
   extras memo to draw the live block in order. What the memo reads is resolved
   in **its own scope** — the prop its enclosing function was handed — rather
   than carried over from whichever renderer the first step happened to see
@@ -866,10 +934,10 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
   `CLAUDE_CODE_DISABLE_EXPLORE_INHERIT_CAP` escape hatch in the middle, which
   silently cost every Explore override until the body matcher learned to skip
   intervening statements. The body is a node now, so there is nothing left to
-  skip. Resolving the agent from the guard alone is what makes a future body
-  reshape *loud*: we still know an override is at stake, so `bypass:<agent>` is
-  a required step that fails, instead of the agent's identity vanishing with the
-  match and the step never existing.
+  skip. Resolving the agent from the guard alone is why a future body reshape
+  costs nothing at all: the body is replaced whole, however upstream grows it,
+  and `bypass:<agent>` stands in the report as the record that an override was
+  at stake.
 
   If the **guard** goes too there is no step to fail — nothing left names the
   agent — and no way to tell "upstream stopped pinning" from "the guard
@@ -902,7 +970,7 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
   | `context` | the real context window | the function that *reads* `CLAUDE_CODE_MAX_CONTEXT_TOKENS` as a member and returns what it read, taking the model as a parameter; the table goes before its first statement |
   | `registry` | the binary's own model table — the status-line name, effort capabilities, `/advisor` eligibility | the object carrying both `models` and `aliases`, confirmed by its entries carrying `id`/`family`/`display_name` |
 
-  \* required (`expect=True`) — without any one of them the feature is dead.
+  \* required — without any one of them the feature is dead.
   `picker`, `context` and `registry` are refinements: absent, you can still
   type `/model <id>` and get the 200k default under the model's raw id.
   `context` has no step at all when no chosen model reports a window — there
@@ -1203,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.1 → 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,38 +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 — 12 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`), and a binary installed under a non-version name is
-saved as `claude.unknown-<hash>.orig`. Both of the extras present hash-match the
-`2.1.216` row above — same bytes, a different filename — which is why the count
-of *files* (14) and the count of *distinct binaries* (12) 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
@@ -71,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.1 → 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.1"
+__version__ = "0.3.3"

{patch_cc-0.3.1 → patch_cc-0.3.3}/src/patch_cc/patches/agents.py

@@ -100,7 +100,8 @@ def _subagent_prompt(source: Source, _options: Options, outcome: Outcome) -> Sou
     ``transcript && content && ...`` conjunction, which gates the agent's
     *output* and is not this patch's business.
     """
-    gate = outcome.step("gate", expect=True)
+    outcome.declare(required=("gate",))
+    gate = outcome.step("gate")
     edits: list[Edit] = []
     seen: set[int] = set()
 
@@ -346,7 +347,7 @@ def discover_models(source: Source) -> list[str]:
     by a guessed default. A hardcoded fallback (`haiku/sonnet/opus`) read a lost
     enum as those three: `doctor` printed a plausible list, every pin to one of
     them landed, and a pin to a name the real bundle accepts was refused -- the
-    same emptiness that `codex-models`' own `enum` step (`expect=True`) reports
+    same emptiness that `codex-models`' own required `enum` step reports
     as broken in the same run. With nothing to offer, the offer is empty:
     `discover_models` returns `[]`, `doctor` shows `models: inherit` alone, and a
     requested pin fails its required step rather than landing on a name nothing
@@ -481,13 +482,14 @@ def _subagent_models(source: Source, options: Options, outcome: Outcome) -> Sour
     found = {agent.name: agent for agent in agents}
     edits: list[Edit] = []
 
+    # Required: every override reaching a patch has already been validated
+    # against this bundle by its surface (CLI, --from-cache, or the menu), so
+    # one that cannot be written is not a shape this build lacks -- it is the
+    # asked-for change failing. Left optional, the patch stayed green, the
+    # binary shipped without the override, and the manifest claimed it.
+    outcome.declare(required=tuple(sorted(options.subagent_models)))
     for name, target in sorted(options.subagent_models.items()):
-        # Required: every override reaching a patch has already been validated
-        # against this bundle by its surface (CLI, --from-cache, or the menu),
-        # so one that cannot be written is not a shape this build lacks -- it is
-        # the asked-for change failing. Left optional, the patch stayed green,
-        # the binary shipped without the override, and the manifest claimed it.
-        step = outcome.step(name, expect=True)
+        step = outcome.step(name)
         if target not in offered:
             step.note(f"model {target!r} not offered by this bundle; skipped")
             continue
@@ -522,7 +524,11 @@ def _subagent_models(source: Source, options: Options, outcome: Outcome) -> Sour
     for bypass in bypasses:
         if bypass.agent not in options.subagent_models:
             continue
-        step = outcome.step(f"bypass:{bypass.agent}", expect=True)
+        # Declared the moment the guard resolves the agent's name -- the
+        # earliest this step *can* exist -- while a vanished guard stays the
+        # note above, with no name left to declare.
+        outcome.declare(required=(f"bypass:{bypass.agent}",))
+        step = outcome.step(f"bypass:{bypass.agent}")
         step.candidates += 1
         step.applied += 1
         edits.append(

{patch_cc-0.3.1 → patch_cc-0.3.3}/src/patch_cc/patches/base.py

@@ -109,7 +109,7 @@ class Outcome:
     notes: list[str] = field(default_factory=list)
     #: Named sub-steps, for patches built from several independent rewrites.
     steps: dict[str, Outcome] = field(default_factory=dict)
-    #: What this sub-step's absence means (set via :meth:`step`). ``False`` --
+    #: What this sub-step's absence means (set via :meth:`declare`). ``False`` --
     #: a shape some builds simply lack; ``True`` -- the patch is broken without
     #: it.
     expect: bool = False
@@ -167,18 +167,43 @@ class Outcome:
     def note(self, message: str) -> None:
         self.notes.append(message)
 
-    def step(self, name: str, expect: bool = False) -> Outcome:
-        """Get (or create) a named sub-outcome.
+    def declare(
+        self, required: tuple[str, ...] = (), optional: tuple[str, ...] = ()
+    ) -> None:
+        """Create sub-steps, before any of them does its work.
+
+        Declaring is the only way a step comes to exist (:meth:`step` only
+        retrieves), which makes "declare an expectation before the work" the
+        API's shape instead of each patch's discipline: a code path that never
+        runs leaves a required step at 0/0 with a verdict to fail, where a step
+        created by its own success could never report its own absence --
+        `branding`'s badge went unrenamed under exactly that silence, and the
+        lazily-created step was the hole the discipline papered over.
+        Conditional work declares under the same condition it runs (`context`),
+        and a name resolved from the bundle is declared the moment it resolves
+        (`bypass:<agent>`).
+        """
+        for name in required:
+            self.steps.setdefault(name, Outcome()).expect = True
+        for name in optional:
+            self.steps.setdefault(name, Outcome())
+
+    def step(self, name: str) -> Outcome:
+        """A declared sub-step, to record work against.
 
         A single scalar count cannot distinguish "all twelve rewrites landed"
         from "six landed and six silently drifted" -- which is exactly how
         upstream's live-thinking patch hides its own regressions. Recording each
         rewrite separately turns that into an actionable "reducer.message_stop
         missed".
+
+        Retrieval only: a name nobody declared is a programming error and
+        raises, which :meth:`Patch.run` reports as the patch broken -- loud,
+        never a silently-optional step minted by a typo.
         """
-        sub = self.steps.setdefault(name, Outcome())
-        sub.expect = sub.expect or expect
-        return sub
+        if name not in self.steps:
+            raise RuntimeError(f"step {name!r} was never declared")
+        return self.steps[name]
 
     def finalize(self) -> Outcome:
         """Roll sub-step totals up into this outcome."""

{patch_cc-0.3.1 → patch_cc-0.3.3}/src/patch_cc/patches/chrome.py

@@ -268,7 +268,8 @@ def _branding(source: Source, options: Options, outcome: Outcome) -> Source:
     # rather than a green tick over a binary that still says Claude Code. The
     # other two are sentences upstream may reword or drop, and their absence is
     # a build lacking a shape, not a dead feature.
-    badge = outcome.step("badge", expect=True)
+    outcome.declare(required=("badge",), optional=("styled", "welcome"))
+    badge = outcome.step("badge")
     styled = outcome.step("styled")
     welcome = outcome.step("welcome")