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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patch-cc
-Version: 0.3.0
+Version: 0.3.2
 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.0 → patch_cc-0.3.2}/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.0 → patch_cc-0.3.2}/docs/PLAYBOOK.md

@@ -116,6 +116,18 @@ The tree removes the *mechanical* fragility. It does not decide these:
   that branch verbatim rather than constructing a flush call; `org-label` builds
   its line from upstream's own no-org string, so nothing here spells the
   separator. What you copy cannot drift from what you copied it from.
+- **Match an identity by the weakest claim that still proves it; hold a rewrite
+  to the exact node.** The two jobs pull in opposite directions.
+  `thinking-inline`'s null-guard neutralises only a `return` that answers
+  exactly `null`, because deleting a conditional answer would delete behaviour
+  — for a rewrite, doubt means stop. The codex resolvers' *identity* is the
+  opposite case: "rejects an unknown model" was once asked as "the default
+  returns exactly `null`", and 2.1.234 wrapping that same rejection in a dead
+  recognizer (`return vXu(e)?xVe(t):null`, the stub answering `!1` — behaviour
+  identical) read the resolver as gone with every anchor count standing.
+  Identity asks what the node *can* answer — membership among its possible
+  values, the same rule props and arrays already follow — and exactness there
+  is a break waiting on upstream's next harmless addition.
 - **Never anchor on a minified local** (`A_`, `mET`, `wg6`). Unchanged, and now
   structural: you capture the node, so there is never a reason to spell one.
 
@@ -356,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
@@ -392,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
@@ -572,6 +590,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
@@ -713,16 +745,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
@@ -770,7 +814,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
@@ -854,10 +908,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
@@ -883,14 +937,14 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
   |---|---|---|
   | `enum`\* | the Task tool's `model` enum, so a subagent can be pinned to a Codex id | `agents.model_enums` — the same arrays `discover_models` reads |
   | `validator`\* | the known-model array — it gates *resolution*, not just acceptance | the array whose strings *include* `sonnet`/`opus`/`haiku`/`opusplan` — membership, never their order |
-  | `resolver`\* | the override resolver (managed `availableModels` only) | the `"best"` arm whose `switch` answers `null` for an unknown model |
+  | `resolver`\* | the override resolver (managed `availableModels` only) | the `"best"` arm whose `switch` *can* answer `null` for an unknown model |
   | `general-resolver`\* | the resolver every ordinary request uses | the `"best"` arm whose `switch` has no answer of its own for one |
   | `redirect`\* | swaps the request origin to `127.0.0.1:<port>` | the `buildRequest` method that builds a URL (the others — two to four across the corpus — only delegate to `super`) |
   | `picker` | the `/model` list | the function every row list is handed to: it loops, adds, and returns its first parameter |
   | `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
@@ -994,15 +1048,26 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
   registered, with the manifest asserting the override. Now the dropped patch
   takes its pins down with it.
 
-  The two resolvers are told apart by **what they answer, never by their
-  minified names or by a statement form** — the override one rejects an unknown
-  model with `default:return null`, the general one has no answer for it and
-  falls through to handing the name back. That is a fact about what each
-  resolver is *for*. Braces around an arm are not: they were the discriminator
-  once, and putting a `let` in the general resolver's `case"best"` was enough to
-  make every family shortcut vanish with the patch still green and seven of
-  seven steps applied. The `buildRequest` methods and the
-  `models`-shaped objects are likewise separated by what they *do* and *carry*.
+  The two resolvers are told apart by **what each answers for an unknown
+  model, never by their minified names or by a statement form** — `null` is
+  among what the override one's default *can* answer, read off the grammar's
+  own value routing (a ternary answers with either branch, `||`/`??` with
+  their right side; 2.1.234 wrapped the same rejection in a dead recognizer,
+  `return vXu(e)?xVe(t):null` with the stub answering `!1`, and the exact
+  spelling read a behaviourally identical build as the resolver being gone),
+  while the general one has no answer of its own — nothing in its default
+  scoped to return or throw — and falls through to handing the name back.
+  Both identities are asked positively, of switches whose labels carry the
+  built-in models (the membership `validator` asks of its array, asked of the
+  labels — a throwaway `case"best":` elsewhere is nothing, not an arm to
+  classify), and an arm answering neither *raises* instead of swelling the
+  other side: under the complement this replaced, a reshaped override slid
+  silently into the general list, and only the required step's zero was left
+  to speak. Braces around an arm are no discriminator either: they were, once,
+  and a `let` in the general resolver's `case"best"` was enough to make every
+  family shortcut vanish with the patch still green and seven of seven steps
+  applied. The `buildRequest` methods and the `models`-shaped objects are
+  likewise separated by what they *do* and *carry*.
 
   **Two resolvers, and why both.** The **general** one turns `opus`
   into `claude-opus-4-8`, its return value *replaces* the model before the

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

@@ -20,7 +20,7 @@ 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 — 11 distinct binaries
+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`):
 
 | version | size | sha256 |
@@ -36,13 +36,18 @@ by content (the SHA-256 is the whole file, `sha256sum <version>.orig`):
 | `2.1.227` | 304 MB | `6832dc3f1797b890b71116e5f2dbbf9a83fd3d0498c235b4b0f9cd0e6e499ad6` |
 | `2.1.228` | 309 MB | `d535985e6941a3eb00179ccd7f52ceb0c6623a0305a518ebc4e6514f84a94c99` |
 | `2.1.233` | 325 MB | `55d281096f57d411ebbdd94dbf5e9ff3accb7c05713e37348c2c11d4b83bf9d9` |
+| `2.1.234` | 328 MB | `3473601ea695d5bf769c5b202844d4cb4fbf723ae995450fcb6973204775c84a` |
+| `2.1.235` | 331 MB | `bfcf0ae2dbf94b2b6a106074aabf3938b9a10889c3b678e4cb5a00c03274d5d5` |
 
 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* (13) and the count of *distinct binaries* (11) differ.
+(`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.
 
 ## Rebuild or extend it
 

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

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

{patch_cc-0.3.0 → patch_cc-0.3.2}/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.0 → patch_cc-0.3.2}/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.0 → patch_cc-0.3.2}/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")
 

{patch_cc-0.3.0 → patch_cc-0.3.2}/src/patch_cc/patches/codex.py

@@ -29,7 +29,7 @@ and the subagent pins: the ids to register, and the port to route them to.
 Nothing here reads a store of its own, which is what makes the binary's manifest
 the one record of what a patched Claude Code answers to.
 
-Required steps (``expect=True``): without any one, the feature is dead --
+Required steps: without any one, the feature is dead --
 ``enum`` (subagent use), ``validator`` and ``resolver`` (the model is accepted
 and resolves -- an id to itself, a shortcut to the newest id in its family),
 ``redirect`` (requests actually reach the gateway). ``general-resolver`` is
@@ -165,52 +165,153 @@ def claimed_model_names(source: Source) -> set[str]:
 # ----------------------------------------------------------------- resolvers
 #
 # The binary has TWO model resolvers and a shortcut needs an arm in both. They
-# are told apart by what they *answer*, never by their minified names or by a
-# statement form: the override resolver (reached only when managed
-# `availableModels` are active) rejects an unknown name with `null`; the general
-# resolver -- the one every ordinary request uses, which turns `opus` into
-# `claude-opus-4-8` -- has no answer of its own for one and falls through to
-# passing it straight back.
+# are told apart by what each *answers* for an unknown model, never by their
+# minified names or by a statement form: the override resolver (reached only
+# when managed `availableModels` are active) has a closed list and rejects --
+# null is among what its default can answer -- while the general resolver (the
+# one every ordinary request uses, which turns `opus` into `claude-opus-4-8`)
+# has no answer of its own and falls through to passing the name straight back.
+# Both identities are asked positively, of every model resolver, and an arm
+# answering neither raises instead of swelling the other side: a complement
+# cannot report its own absence.
 
 
 def _best_arms(source: Source) -> list[js.Node]:
-    """Every arm labelled ``"best"``, which is where new model arms are spliced.
+    """Every model resolver's ``"best"`` arm -- where new model arms are spliced.
 
     The label is the name and the arm is the node; ``case"best":`` written out
-    is the two of them with the minifier's spacing in between.
+    is the two of them with the minifier's spacing in between. The switch also
+    has to *be* a model resolver -- its labels carry the built-in models, the
+    same membership `_validators` asks of its array -- because everything here
+    applies to every arm of the kind: a throwaway ``case"best":`` in unrelated
+    code must be nothing to a registration that would splice into it and to a
+    classifier that would be asked what it is (`_resolvers`).
     """
     found = []
     for node in source.find(_BEST):
         arm = js.up(node, "switch_case")
-        if arm is not None and arm.child_by_field_name("value") == node:
+        if (
+            arm is not None
+            and arm.child_by_field_name("value") == node
+            and set(_BUILT_IN_MODELS) <= _labels(arm)
+        ):
             found.append(arm)
     return found
 
 
-def _rejects_unknown(arm: js.Node) -> bool:
-    """Does this arm's ``switch`` answer ``null`` when nothing matched?
+def _labels(arm: js.Node) -> set[str]:
+    """The string labels of this arm's whole ``switch``, as their values.
 
-    The two resolvers differ in what an unknown model means to them, which is a
-    fact about what each is *for*: the override resolver has a closed list and
-    rejects, the general one passes the name through for something downstream to
-    judge. Whether either spells an arm as ``case"best":return f()`` or
-    ``case"best":{return f()}`` is the minifier's business -- and telling them
+    A set: which names the switch dispatches on is the question, and neither
+    their order nor what sits between them is part of it.
+    """
+    return {
+        js.text(value)[1:-1]
+        for case in js.children(arm.parent)
+        if case.type == "switch_case"
+        for value in [case.child_by_field_name("value")]
+        if value is not None and value.type == "string"
+    }
+
+
+def _answer(statement: js.Node) -> js.Node | None:
+    """The expression a ``return`` answers with -- nothing for a bare ``return;``."""
+    parts = [child for child in js.children(statement) if child.type != "comment"]
+    return parts[0] if parts else None
+
+
+def _may_answer_null(expr: js.Node | None) -> bool:
+    """Can this expression's value be ``null``?
+
+    Asked of the grammar's own value routing, so the rejection keeps counting
+    however much recognition upstream composes in front of it: a ternary
+    answers with either branch, parentheses and a sequence with their last
+    expression, ``||`` and ``??`` with their right side (a null on their left
+    is exactly what both exist to pass over), ``&&`` with either side (null is
+    falsy), an assignment with the value it assigns. Everything else -- a call,
+    an identifier, an ``await`` -- is opaque: it may well evaluate to null, but
+    the grammar does not say so, and a rejection hidden behind one is a new
+    shape to be told about (`_resolvers` raises), never one to absorb.
+
+    2.1.234 is why this is a question about *possible* answers and not the
+    answer's spelling: the override default became ``return vXu(e)?xVe(t):null``
+    with ``vXu`` a stub returning ``!1`` -- behaviour identical to ``return
+    null`` -- and "exactly a bare null" read that build's rejection as gone.
+    """
+    if expr is None:
+        return False
+    if expr.type == "null":
+        return True
+    if expr.type == "ternary_expression":
+        return any(
+            _may_answer_null(expr.child_by_field_name(field))
+            for field in ("consequence", "alternative")
+        )
+    if expr.type in ("parenthesized_expression", "sequence_expression"):
+        parts = [child for child in js.children(expr) if child.type != "comment"]
+        return bool(parts) and _may_answer_null(parts[-1])
+    if expr.type == "assignment_expression":
+        return _may_answer_null(expr.child_by_field_name("right"))
+    if expr.type == "binary_expression":
+        operator = expr.child_by_field_name("operator")
+        sides = {"&&": ("left", "right"), "||": ("right",), "??": ("right",)}
+        return any(
+            _may_answer_null(expr.child_by_field_name(field))
+            for field in sides.get("" if operator is None else operator.type, ())
+        )
+    return False
+
+
+def _resolvers(source: Source) -> tuple[list[js.Node], list[js.Node]]:
+    """Every model resolver, classified: (override, general).
+
+    Each identity is asked positively of the arm's own ``switch``: the override
+    resolver's default *can answer null* (`_may_answer_null`, over the
+    default's scoped returns -- a callback's ``return`` answers for the
+    callback); the general resolver's default has no answer of its own --
+    absent, or with nothing scoped to return or throw -- so an unknown model
+    falls out of the switch and back to the caller's passthrough. Whether
+    either spells an arm as ``case"best":return f()`` or
+    ``case"best":{return f()}`` is the minifier's business -- telling them
     apart by that was a silent failure waiting: brace the general resolver (a
     `let` in the arm is enough) and every family shortcut disappeared with the
     patch still green.
+
+    The identities exclude each other by construction, and an arm holding
+    neither -- a default that answers something, never null -- raises, which
+    `Patch.run` turns into one broken patch naming the new shape (the promise
+    `js.only` keeps for cardinality, kept here for classification). Under the
+    complement this replaced, such an arm slid silently into the general list,
+    and only a required step's zero was left to say anything at all.
     """
-    default = next(
-        (
-            sibling
-            for sibling in js.children(arm.parent)
-            if sibling.type == "switch_default"
-        ),
-        None,
-    )
-    if default is None:
-        return False
-    answer = js.first(default, js.of_type("return_statement"))
-    return answer is not None and [c.type for c in answer.named_children] == ["null"]
+    override: list[js.Node] = []
+    general: list[js.Node] = []
+    for arm in _best_arms(source):
+        default = next(
+            (
+                sibling
+                for sibling in js.children(arm.parent)
+                if sibling.type == "switch_default"
+            ),
+            None,
+        )
+        answers = js.every(default, js.of_type("return_statement"), scoped=True)
+        refusals = js.every(default, js.of_type("throw_statement"), scoped=True)
+        if not answers and not refusals:
+            general.append(arm)
+        elif any(_may_answer_null(_answer(statement)) for statement in answers):
+            override.append(arm)
+        else:
+            answered = [_answer(statement) for statement in answers]
+            kinds = sorted(
+                {"nothing" if value is None else value.type for value in answered}
+                | ({"a throw"} if refusals else set())
+            )
+            raise ValueError(
+                "a model resolver neither rejects an unknown model nor passes "
+                f"it through: its default answers {', '.join(kinds)}"
+            )
+    return override, general
 
 
 def _existing_arms(arm: js.Node) -> set[str]:
@@ -241,12 +342,12 @@ def _arms(resolution: dict[str, str]) -> str:
 
 def _override_resolvers(source: Source) -> list[js.Node]:
     """Every resolver reached only when managed ``availableModels`` are active."""
-    return [arm for arm in _best_arms(source) if _rejects_unknown(arm)]
+    return _resolvers(source)[0]
 
 
 def _general_resolvers(source: Source) -> list[js.Node]:
     """Every resolver an ordinary request goes through."""
-    return [arm for arm in _best_arms(source) if not _rejects_unknown(arm)]
+    return _resolvers(source)[1]
 
 
 def _register_arms(
@@ -562,8 +663,8 @@ def _register_context(source: Source, models, outcome: Outcome) -> Source:
     # place to bake it -- a drifted window resolver then reads as this step
     # finding nothing, not as no step at all. Created *after* the search, a
     # renamed CLAUDE_CODE_MAX_CONTEXT_TOKENS produced seven steps, no note and no
-    # absent-step line, the exact silence PLAYBOOK's "declare an expectation
-    # before the work" rule (and `_live_thinking`) exists to break.
+    # absent-step line, the exact silence `Outcome.declare` now exists to break.
+    outcome.declare(optional=("context",))
     step = outcome.step("context")
     resolver = _window_resolver(source)
     body = js.body(resolver) if resolver is not None else None
@@ -760,6 +861,11 @@ def _codex_models(source: Source, options: Options, outcome: Outcome) -> Source:
         return source
 
     model_ids = [m.id for m in options.codex_models]
+    # Classified once here for the gate and the note; the registrations below
+    # re-derive from the source each hands the next, since every batch of edits
+    # is a new parse. A count that moves on a green run is the early warning.
+    override, general = _resolvers(source)
+    outcome.note(f"resolvers: {len(override)} override, {len(general)} general")
     # Family shortcuts (`sol` -> the newest `gpt-<ver>-sol`) resolve to an id
     # before the request is built, so they ride only the surfaces that accept,
     # resolve, and show a model -- validator, both resolvers, picker. They need no
@@ -770,33 +876,43 @@ def _codex_models(source: Source, options: Options, outcome: Outcome) -> Source:
     # so absent it, no shortcut is registered anywhere and the ids (which need none
     # of this) carry on untouched.
     shorts = family_aliases(options.codex_models)
-    if shorts and not _general_resolvers(source):
+    if shorts and not general:
         outcome.note("general model resolver anchor drifted; shortcuts skipped")
         shorts = {}
 
-    source = _register(
-        source, model_enums(source), model_ids, outcome.step("enum", expect=True)
+    # `general-resolver` is owed exactly when a shortcut is; `context` declares
+    # itself where its own work is owed (see _register_context).
+    outcome.declare(
+        required=(
+            "enum",
+            "validator",
+            "resolver",
+            *(("general-resolver",) if shorts else ()),
+            "redirect",
+        ),
+        optional=("picker", "registry"),
     )
+    source = _register(source, model_enums(source), model_ids, outcome.step("enum"))
     source = _register(
         source,
         _validators(source),
         model_ids + list(shorts),
-        outcome.step("validator", expect=True),
+        outcome.step("validator"),
     )
     source = _register_arms(
         source,
         _override_resolvers(source),
         {i: i for i in model_ids} | shorts,
-        outcome.step("resolver", expect=True),
+        outcome.step("resolver"),
     )
     if shorts:
         source = _register_arms(
             source,
             _general_resolvers(source),
             shorts,
-            outcome.step("general-resolver", expect=True),
+            outcome.step("general-resolver"),
         )
-    source = _redirect(source, options, outcome.step("redirect", expect=True))
+    source = _redirect(source, options, outcome.step("redirect"))
     source = _register_picker(
         source, options.codex_models, shorts, outcome.step("picker")
     )

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

@@ -116,13 +116,22 @@ def _delta(event: str, setter: str, helper: str) -> str:
 #: props freely and inserts new ones between them, and neither is a fact about a
 #: set. Two regexes once differed only in the order two call sites listed the
 #: same props, and 2.1.229 killed both at once by inserting
-#: `onRateLimitAutoQueueContinue:` between two of them.
+#: `onRateLimitAutoQueueContinue:` between two of them. The pair is also the
+#: *whole* identity: it once had `agentDefinitions` beside it as witness and
+#: insertion point, and 2.1.235 retired that prop from the bag -- an identity
+#: resting on a neighbour reported no conversation renders on a build that
+#: plainly drew four. The conversation is what the render is *for*; the props
+#: that name it are the weakest claim that still proves it.
 _CONVERSATION = ("conversationId", "messages")
-
-_AGENT_DEFINITIONS = "agentDefinitions"
 _STREAMING = "streamingThinking"
 _SETTER = "onStreamingThinking"
-_TRANSCRIPT_SIGNATURE = ("messages", "streamingToolUses", "showAllInTranscript")
+#: What the transcript renderer's signature *is*: the conversation it draws and
+#: the streaming tool-uses the extras memo computes over. A third conjunct
+#: (`showAllInTranscript`) stood here as find-anchor, identity and insertion
+#: point in one -- the exact triple role `agentDefinitions` held in
+#: `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")
 _INJECTED = "__cc_streamingThinking"
 
 
@@ -140,26 +149,34 @@ def _outermost(scope: js.Node) -> bool:
 def _conversation_renders(source: Source) -> list[js.Node]:
     """Every props bag that is a conversation render, as the object it is.
 
-    ``agentDefinitions`` is both a witness and the insertion point -- a new
-    property immediately before an existing one is valid in any object literal
-    -- so nothing here computes where the bag *ends*. That question used to be
-    the whole difficulty: delimiting an object literal in minified JS means
-    telling a regex literal from division, and a hand-rolled scanner that
-    guesses returns a `}` that is merely wrong.
+    The identity is one of the identity's own props -- a new property
+    immediately before an existing one is valid in any object literal -- so
+    nothing here computes where the bag *ends*, and the insertion point cannot
+    be absent from a bag the identity admitted. Ending the literal used to be
+    the whole difficulty: delimiting one in minified JS means telling a regex
+    literal from division, and a hand-rolled scanner that guesses returns a
+    `}` that is merely wrong.
 
     Being an ``object`` and not an ``object_pattern`` is what separates a prop
     being *passed* from one being *received*; inserting into the latter would
     rebind a local. The regex spelled that as a call-opening it had to match.
+    A render bag is also *handed to* a component -- an argument -- which is
+    what keeps a module-level literal, a return-value payload, or a config
+    object that happens to carry the pair from being read as a render: those
+    are the decoys the pair alone admits, and being an argument is a fact
+    about what a render *is*, not about how this build spells one.
     """
     found = []
-    for node in source.find(_AGENT_DEFINITIONS):
+    for node in source.find(_CONVERSATION[0]):
         pair = js.named(node)
         if pair is None:
             continue
         bag = js.owner(pair)
         if bag is None or bag.type != "object":
             continue
-        if js.carries(bag, *_CONVERSATION):
+        if bag.parent is None or bag.parent.type != "arguments":
+            continue
+        if js.carries(bag, *_CONVERSATION[1:]):
             found.append(bag)
     return found
 
@@ -237,7 +254,7 @@ def _state_in_scope(site: js.Node) -> str | None:
 
 def _step_prop_threading(source: Source, outcome: Outcome) -> Source:
     """Pass the live-thinking state into the renderers that need it."""
-    step = outcome.step("prop-threading", expect=True)
+    step = outcome.step("prop-threading")
     edits = []
     renders = _conversation_renders(source)
     # Printed every run, green ones included: an early warning held back until
@@ -253,7 +270,7 @@ def _step_prop_threading(source: Source, outcome: Outcome) -> Source:
         step.applied += 1
         edits.append(
             Edit.before(
-                js.entry(js.props(bag)[_AGENT_DEFINITIONS]), f"{_STREAMING}:{state},"
+                js.entry(js.props(bag)[_CONVERSATION[0]]), f"{_STREAMING}:{state},"
             )
         )
     return source.apply(edits)
@@ -327,7 +344,7 @@ def _step_display_mode(source: Source, outcome: Outcome) -> Source:
     gains a default. Whatever guards reach it, and in whatever order the
     declaration lists them, is untouched because it is never matched.
     """
-    step = outcome.step("display-mode", expect=True)
+    step = outcome.step("display-mode")
     edits = []
     seen: set[int] = set()
 
@@ -487,11 +504,24 @@ def _step_final_summary(source: Source, outcome: Outcome) -> Source:
 
 
 def _step_transcript_signature(source: Source, outcome: Outcome) -> Source:
-    """Make sure the transcript renderer actually receives the live state."""
-    step = outcome.step("transcript-signature", expect=True)
+    """Make sure the transcript renderer actually receives the live state.
+
+    The insertion point is one of the identity's own names, so it cannot be
+    absent from a pattern the identity admitted -- the guarantee
+    ``prop-threading`` moved to after 2.1.235 retired its third conjunct.
+
+    Deriving the renderer from its consumer instead -- the scope that binds
+    what the streaming-extras memo computes over -- was measured and rejected:
+    on every current build the memo's receiver is a react-compiler memoized
+    *local* (``Te=useMemo(...)``), with real dataflow between it and the
+    signature, and a dataflow pass is a tool this project deliberately does
+    not build. Membership of the pair is the weakest claim the grammar can
+    still prove.
+    """
+    step = outcome.step("transcript-signature")
     edits = []
 
-    for node in source.find(_TRANSCRIPT_SIGNATURE[2]):
+    for node in source.find(_TRANSCRIPT_SIGNATURE[1]):
         pattern = js.owner(node)
         # A destructured parameter list, not a props bag being passed: this is
         # the renderer's own signature, and the same property names appear on
@@ -509,7 +539,7 @@ def _step_transcript_signature(source: Source, outcome: Outcome) -> Source:
             continue
         edits.append(
             Edit.before(
-                js.entry(carried[_TRANSCRIPT_SIGNATURE[2]]),
+                js.entry(carried[_TRANSCRIPT_SIGNATURE[1]]),
                 f"{_STREAMING}:{_INJECTED},",
             )
         )
@@ -593,7 +623,7 @@ def _flatmap_extras(source: Source) -> tuple[js.Node, js.Node] | None:
 
 def _step_inline_extras(source: Source, found: Discovery, outcome: Outcome) -> Source:
     """Render live thinking inline, ordered with streaming tool-use blocks."""
-    step = outcome.step("inline-extras", expect=True)
+    step = outcome.step("inline-extras")
     computed = _flatmap_extras(source)
     if computed is None:
         step.note("no streaming-extras memo in this build")
@@ -891,7 +921,7 @@ def _step_reducer(source: Source, found: Discovery, outcome: Outcome) -> Source:
     away reads as that point's absence by name rather than as a bare count drop
     inside an aggregate.
     """
-    step = outcome.step("reducer", expect=True)
+    step = outcome.step("reducer")
     helper = found.create_message_helper
     handler = _reducer(source)
     if handler is None or helper is None:
@@ -937,27 +967,27 @@ def _step_reducer(source: Source, found: Discovery, outcome: Outcome) -> Source:
         handler,
         (_REQUEST_START,),
         f"{setter}?.(null)",
-        outcome.step("request-start", expect=True),
+        outcome.step("request-start"),
     )
     edits += _dispatch(
         handler,
         (_MESSAGE_STOP,),
         ended,
-        outcome.step("message-stop", expect=True),
+        outcome.step("message-stop"),
         on="event",
     )
     edits += _dispatch(
         handler,
         ("text",),
         cleared,
-        outcome.step("text-clear", expect=True),
+        outcome.step("text-clear"),
         on="content_block",
     )
     edits += _dispatch(
         handler,
         ("message_delta",),
         cleared,
-        outcome.step("message-delta-clear", expect=True),
+        outcome.step("message-delta-clear"),
         on="event",
     )
     edits += _dispatch(
@@ -982,11 +1012,26 @@ def _step_reducer(source: Source, found: Discovery, outcome: Outcome) -> Source:
 
 def _live_thinking(source: Source, _options: Options, outcome: Outcome) -> Source:
     found = Discovery()
-    # Declared before anything runs: an expectation that only comes into
-    # existence once its own rewrite succeeds can never report that rewrite
-    # missing -- which is exactly the silence being designed out here.
-    for name, _marker in _CORE_UPDATES:
-        outcome.step(name, expect=True)
+    # Every step this patch can take, declared before anything runs: an
+    # expectation that only comes into existence once its own rewrite succeeds
+    # can never report that rewrite missing. The dispatch points are declared
+    # here too, so a build whose reducer is gone fails *them* by name as well,
+    # instead of them never having existed.
+    outcome.declare(
+        required=(
+            "prop-threading",
+            "display-mode",
+            "transcript-signature",
+            "inline-extras",
+            "reducer",
+            "request-start",
+            "message-stop",
+            "text-clear",
+            "message-delta-clear",
+            *(name for name, _marker in _CORE_UPDATES),
+        ),
+        optional=("final-summary", "thinking-start", "thinking-append"),
+    )
 
     source = _step_prop_threading(source, outcome)
     source = _step_display_mode(source, outcome)
@@ -999,7 +1044,7 @@ def _live_thinking(source: Source, _options: Options, outcome: Outcome) -> Sourc
     # updates *are* the feature, and every other step can land without them.
     for name, marker in _CORE_UPDATES:
         if source.count(marker):
-            step = outcome.step(name, expect=True)
+            step = outcome.step(name)
             step.candidates += 1
             step.applied += 1
     return source
@@ -1018,7 +1063,7 @@ PATCHES = [
             f'case"{_THINKING_DELTA}"',
             f'"{_REQUEST_START}"',
             _CONTENT_BLOCK_START,
-            _AGENT_DEFINITIONS,
+            _CONVERSATION[0],
         ),
     ),
 ]

{patch_cc-0.3.0 → patch_cc-0.3.2}/src/patch_cc/patches/thinking.py

@@ -145,7 +145,7 @@ def _ungrouped(arm: js.Node) -> js.Node | None:
 
 def _reroute_grouping(source: Source, outcome: Outcome) -> Source:
     """Send finished thinking messages to the visible list, not the group."""
-    step = outcome.step("group-routing", expect=True)
+    step = outcome.step("group-routing")
     edits: list[Edit] = []
     seen: set[int] = set()
 
@@ -255,8 +255,9 @@ def _thinking_inline(source: Source, _options: Options, outcome: Outcome) -> Sou
     the value forced to ``!0`` here and the name the early return is keyed on
     there, so neither rewrite is looking for a gate the other cannot see.
     """
-    guard = outcome.step("null-guard", expect=True)
-    props = outcome.step("renderer-props", expect=True)
+    outcome.declare(required=("group-routing", "null-guard", "renderer-props"))
+    guard = outcome.step("null-guard")
+    props = outcome.step("renderer-props")
     source = _reroute_grouping(source, outcome)
     edits: list[Edit] = []
 
@@ -439,8 +440,9 @@ def _whitelist(node: js.Node) -> js.Node | None:
 
 def _max_effort(source: Source, _options: Options, outcome: Outcome) -> Source:
     """Let ``/effort max`` save as the default for new sessions."""
-    gate = outcome.step("gate", expect=True)
-    schema = outcome.step("schema", expect=True)
+    outcome.declare(required=("gate", "schema"))
+    gate = outcome.step("gate")
+    schema = outcome.step("schema")
     edits: list[Edit] = []
     seen: set[int] = set()