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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patch-cc
-Version: 0.3.1
+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.1 → 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.1 → patch_cc-0.3.2}/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
@@ -584,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
@@ -725,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
@@ -782,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
@@ -866,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
@@ -902,7 +944,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

{patch_cc-0.3.1 → 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 — 12 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 |
@@ -37,13 +37,17 @@ by content (the SHA-256 is the whole file, `sha256sum <version>.orig`):
 | `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* (14) and the count of *distinct binaries* (12) 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.1 → 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.1"
+__version__ = "0.3.2"

{patch_cc-0.3.1 → 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.1 → 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.1 → 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.1 → 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
@@ -663,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
@@ -880,29 +880,39 @@ def _codex_models(source: Source, options: Options, outcome: Outcome) -> Source:
         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.1 → 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.1 → 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()