patch-cc 0.1.3__tar.gz → 0.1.4__tar.gz

{patch_cc-0.1.3 → patch_cc-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patch-cc
-Version: 0.1.3
+Version: 0.1.4
 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
@@ -76,9 +76,9 @@ patch-cc                       # then just run it
 |---|---|---|
 | Output & diffs | Detailed tool calls | Show full read/search calls, not collapsed summaries |
 | | Colour new files as diffs | Created files render with `+` lines and green |
-| Thinking | Opt out of server-side experiments | Some accounts land in one that empties every thinking block |
+| Thinking | Fix blank thinking blocks | Opt out of the server-side experiment that can empty every thinking block |
 | | Always show thinking | Thinking blocks stay inline — no `ctrl+o` |
-| Live thinking | Stream thinking live | See reasoning as it is generated, inline and in order |
+| | Stream thinking live | See reasoning as it is generated, inline and in order |
 | Subagents | Show subagent prompts | Prompt blocks visible during normal use |
 | | Override subagent models | Pick the model per built-in agent (discovered from your binary) |
 | Chrome | Disable spinner tips | No rotating tips on the spinner |
@@ -97,10 +97,11 @@ uvx patch-cc apply --brand                    # + branding as <username>'s Code
 uvx patch-cc apply --brand "Ada's Code"       # + branding, explicit name
 uvx patch-cc apply --model Explore=haiku --model general-purpose=opus
 uvx patch-cc apply --suffix "(mine)"          # custom --version marker
+uvx patch-cc apply --from-cache               # replay your last remembered selection
 uvx patch-cc status                           # exactly what is applied
 uvx patch-cc doctor                           # do all patches match this build?
 uvx patch-cc doctor path/to/claude            # ...or match some other binary
-uvx patch-cc list                             # patches + your binary's agents/models
+uvx patch-cc list                             # every patch, described
 uvx patch-cc restore                          # put the original back
 ```
 
@@ -110,8 +111,9 @@ against what your installed binary actually ships.
 ## After a Claude update
 
 Claude auto-updates roughly daily and replaces the binary, which reverts the
-patch. Re-run `patch-cc` — the menu remembers your last selection — or re-apply
-your set explicitly:
+patch. Re-run `patch-cc` — the menu remembers your last selection — replay it
+without the menu via `patch-cc apply --from-cache`, or re-apply your set
+explicitly:
 
 ```bash
 uvx patch-cc apply --brand --model Explore=haiku

{patch_cc-0.1.3 → patch_cc-0.1.4}/README.md

@@ -48,9 +48,9 @@ patch-cc                       # then just run it
 |---|---|---|
 | Output & diffs | Detailed tool calls | Show full read/search calls, not collapsed summaries |
 | | Colour new files as diffs | Created files render with `+` lines and green |
-| Thinking | Opt out of server-side experiments | Some accounts land in one that empties every thinking block |
+| Thinking | Fix blank thinking blocks | Opt out of the server-side experiment that can empty every thinking block |
 | | Always show thinking | Thinking blocks stay inline — no `ctrl+o` |
-| Live thinking | Stream thinking live | See reasoning as it is generated, inline and in order |
+| | Stream thinking live | See reasoning as it is generated, inline and in order |
 | Subagents | Show subagent prompts | Prompt blocks visible during normal use |
 | | Override subagent models | Pick the model per built-in agent (discovered from your binary) |
 | Chrome | Disable spinner tips | No rotating tips on the spinner |
@@ -69,10 +69,11 @@ uvx patch-cc apply --brand                    # + branding as <username>'s Code
 uvx patch-cc apply --brand "Ada's Code"       # + branding, explicit name
 uvx patch-cc apply --model Explore=haiku --model general-purpose=opus
 uvx patch-cc apply --suffix "(mine)"          # custom --version marker
+uvx patch-cc apply --from-cache               # replay your last remembered selection
 uvx patch-cc status                           # exactly what is applied
 uvx patch-cc doctor                           # do all patches match this build?
 uvx patch-cc doctor path/to/claude            # ...or match some other binary
-uvx patch-cc list                             # patches + your binary's agents/models
+uvx patch-cc list                             # every patch, described
 uvx patch-cc restore                          # put the original back
 ```
 
@@ -82,8 +83,9 @@ against what your installed binary actually ships.
 ## After a Claude update
 
 Claude auto-updates roughly daily and replaces the binary, which reverts the
-patch. Re-run `patch-cc` — the menu remembers your last selection — or re-apply
-your set explicitly:
+patch. Re-run `patch-cc` — the menu remembers your last selection — replay it
+without the menu via `patch-cc apply --from-cache`, or re-apply your set
+explicitly:
 
 ```bash
 uvx patch-cc apply --brand --model Explore=haiku

{patch_cc-0.1.3 → patch_cc-0.1.4}/docs/CONDUCT.md

@@ -29,9 +29,11 @@ shape that already absorbs every case, found rather than bolted on.
   brick.
 
 - **Explicit invocations are hermetic.** A non-interactive command's arguments
-  are its whole input; no saved state may silently change what it does, so the
-  same command always yields the same result. Persisted choices belong to the
-  interactive UI alone — they pre-fill a prompt, never trigger an action.
+  are its whole input; no saved state may *silently* change what it does.
+  Persisted choices pre-fill the interactive UI and never act on their own — the
+  lone exception is `apply --from-cache`, which takes the cache as its *named*
+  input, so the state it reads is declared in the arguments, not hidden behind a
+  default. Absent that flag, the same command still always yields the same result.
 
 - **Anchor matchers on meaning.** String literals, `case` labels, prop names,
   control-flow shape — never a minified local that changes every build. A new

{patch_cc-0.1.3 → patch_cc-0.1.4}/docs/PLAYBOOK.md

@@ -223,8 +223,9 @@ that broke a patch along with every note.
 
 ## Patch reference
 
-Grouped as in `patch-cc list`. Each entry: what it changes, the stable anchor,
-and where it lives.
+Grouped by source module — the UI folds `live-thinking` into the Thinking group,
+but it still lives in `streaming.py`. Each entry: what it changes, the stable
+anchor, and where it lives.
 
 ### Output & diffs — `output.py`
 

{patch_cc-0.1.3 → patch_cc-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "patch-cc"
-version = "0.1.3"
+version = "0.1.4"
 description = "Interactive patcher for the Claude Code native binary"
 readme = "README.md"
 requires-python = ">=3.11"

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/__init__.py

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

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/cache.py

@@ -1,10 +1,12 @@
 """Remembered interactive selection.
 
-The menu's only memory: the patches and customisations picked last time, so the
-next interactive run comes up pre-filled even after a Claude auto-update wiped
-the patched binary (and its manifest) away. It is never read by the ``apply``
-args path and never applies anything on its own -- deleting the file simply
-resets the menu to defaults.
+The last selection made, so the next interactive run comes up pre-filled even
+after a Claude auto-update wiped the patched binary (and its manifest) away.
+Written by the interactive menu and by any ``apply`` given an explicit selection
+-- a bare ``apply`` (the default set) leaves it untouched, so it never clobbers a
+remembered custom pick. ``apply --from-cache`` is the non-interactive reader,
+replaying that selection when explicitly asked. Deleting the file resets the
+menu to defaults and leaves ``--from-cache`` with nothing to replay.
 """
 
 from __future__ import annotations

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/cli.py

@@ -25,16 +25,64 @@ from pathlib import Path
 
 from rich.markup import escape
 
-from . import locate, patcher
+from . import cache, locate, patcher
 from .bun import BunError, Bundle
-from .patches import Options, Outcome, by_group, default_ids, derived_brand, ids
+from .patches import (
+    DEFAULT_SUFFIX,
+    GROUP_ORDER,
+    Options,
+    Outcome,
+    Patch,
+    by_group,
+    default_ids,
+    derived_brand,
+    ids,
+)
 from .patches.agents import INHERIT, discover_agents, discover_models
-from .ui import MARKS, console, err, findings, heading, ok, warn
+from .ui import MARKS, applied_value, console, err, findings, heading, ok, warn
 
 #: ``--brand`` with no value: derive the name from the system username.
 _DERIVE = ""
 
 
+def _enable_hint(patch: Patch) -> str:
+    """How a patch is turned on: blank for the default set, else how to opt in.
+
+    Reads the patch's own ``option``, so a non-default patch says exactly how it
+    is enabled -- ``subagent-models`` needs ``--model``, ``spinner-tips`` is just
+    named -- instead of the old blanket ``(via --model)`` that mislabelled every
+    off-by-default patch.
+    """
+    if patch.default:
+        return ""
+    if patch.option:
+        return f"(off by default; enable with {patch.option})"
+    return "(off by default; name it to apply)"
+
+
+def _list_hint(patch: Patch, cached: cache.Selection) -> str:
+    """Simple, binary-free hints for `list`: how to enable a patch, its default
+    configurable value, and the value your last interactive run cached where
+    that is meaningful. The dynamic agent/model catalog lives in `apply --help`.
+    """
+    parts: list[str] = []
+    if enable := _enable_hint(patch):
+        parts.append(enable.strip("()"))
+    opts = cached.options
+    if patch.id == "branding":
+        parts.append(f"default {derived_brand()!r}")
+        if opts.rebrands and "branding" in cached.patches:
+            parts.append(f"cached {opts.brand!r}")
+    elif patch.id == "version-marker":
+        parts.append(f"default {DEFAULT_SUFFIX!r}")
+        if opts.version_suffix != DEFAULT_SUFFIX:
+            parts.append(f"cached {opts.version_suffix!r}")
+    elif patch.id == "subagent-models" and opts.subagent_models:
+        picks = ", ".join(f"{a}={m}" for a, m in opts.subagent_models.items())
+        parts.append(f"cached {picks}")
+    return "  ·  ".join(parts)
+
+
 def _parse_models(specs: list[str], source: str) -> dict[str, str]:
     """Validate ``AGENT=MODEL`` pairs against what this bundle offers."""
     agents = {a.name: a for a in discover_agents(source)}
@@ -96,17 +144,86 @@ def _requested(args, source: str) -> tuple[list[str], Options]:
     return selected, options
 
 
+def _has_selection_args(args) -> bool:
+    """Did the user pass an explicit selection (vs. bare `apply` = the defaults)?
+
+    Only an explicit pick is worth remembering: caching the default set would
+    clobber a previously remembered custom selection with nothing meaningful.
+    """
+    return bool(args.patches or args.brand is not None or args.model or args.suffix)
+
+
+def _valid_models(
+    models: dict[str, str], source: str
+) -> tuple[dict[str, str], list[str]]:
+    """Split cached overrides into those this binary still accepts and the rest.
+
+    A build can drop an agent or retire a model between the interactive apply
+    that cached the choice and a later ``--from-cache`` replay; those are skipped
+    with a warning rather than written blind, mirroring the menu's own check.
+    """
+    known_agents = {a.name for a in discover_agents(source)}
+    known_models = {INHERIT, *discover_models(source)}
+    valid: dict[str, str] = {}
+    dropped: list[str] = []
+    for agent, model in models.items():
+        if agent in known_agents and model in known_models:
+            valid[agent] = model
+        else:
+            dropped.append(f"{agent}={model}")
+    return valid, dropped
+
+
+def _from_cache(args, source: str) -> tuple[list[str], Options]:
+    """Rebuild the last interactive selection for a non-interactive apply.
+
+    The single place a persisted choice drives an action rather than pre-filling
+    the menu -- entered explicitly via ``--from-cache``, so the cache is a named
+    argument, not hidden state (see docs/CONDUCT.md). Model overrides are
+    re-validated against the binary in hand.
+    """
+    if args.patches or args.brand is not None or args.model or args.suffix:
+        err(
+            "--from-cache replays your last interactive selection; do not combine "
+            "it with patch ids or --brand / --model / --suffix."
+        )
+        raise SystemExit(2)
+    if not cache.cache_path().exists():
+        err(
+            "No cached selection yet. Apply once from the interactive menu "
+            "(run `patch-cc`), then `--from-cache` replays it."
+        )
+        raise SystemExit(2)
+
+    selection = cache.load()
+    options = selection.options
+    selected = list(selection.patches)
+    if options.subagent_models:
+        valid, dropped = _valid_models(options.subagent_models, source)
+        options.subagent_models = valid
+        if dropped:
+            warn(
+                "cached model override(s) not valid for this build, skipped: "
+                + ", ".join(dropped)
+            )
+        if not valid and "subagent-models" in selected:
+            selected.remove("subagent-models")
+    return selected, options
+
+
 def _print_findings(outcome: Outcome) -> None:
     """The detail under a patch line -- worded in :func:`ui.findings`."""
     for style, text in findings(outcome):
         console.print(f"      [{style}]· {text}[/{style}]")
 
 
-def _print_report(report: patcher.PatchReport) -> None:
+def _print_report(report: patcher.PatchReport, options: Options) -> None:
     heading("Patch results")
     for patch, outcome in report.results:
         mark, colour = MARKS[outcome.health]
         detail = f"  applied {outcome.applied}" if outcome.applied else ""
+        if outcome.applied and (value := applied_value(patch, options)):
+            detail += f"  [dim]→ {escape(value)}[/dim]"
         console.print(f"  [{colour}]{mark}[/{colour}] {patch.title:28s}{detail}")
         _print_findings(outcome)
 
@@ -139,9 +256,15 @@ def _print_report(report: patcher.PatchReport) -> None:
 def cmd_apply(args) -> int:
     install = locate.find_or_raise()
     bundle = patcher.read_pristine(install)
-    selected, options = _requested(args, bundle.source)
-
-    heading(f"Patching Claude {install.version or '?'} ({install.binary.name})")
+    if args.from_cache:
+        selected, options = _from_cache(args, bundle.source)
+    else:
+        selected, options = _requested(args, bundle.source)
+
+    version = install.version or "?"
+    name = install.binary.name
+    where = version if name == version else f"{version} ({name})"
+    heading(f"Patching Claude {where}")
     try:
         report = patcher.patch_installation(install, selected, options, bundle=bundle)
     except patcher.AlreadyPatchedError as exc:
@@ -151,8 +274,14 @@ def cmd_apply(args) -> int:
         err(str(exc))
         return 1
 
-    _print_report(report)
+    _print_report(report, options)
     if report.output is not None:
+        # Remember an explicit pick so `apply --from-cache` and the menu can
+        # replay it -- but never a bare `apply`, which would overwrite a
+        # remembered selection with the defaults. `--from-cache` never reaches
+        # here with selection args, so a replay does not re-cache itself.
+        if _has_selection_args(args):
+            cache.save(cache.Selection(patches=selected, options=options))
         console.print("\n[dim]Restart Claude Code for changes to take effect.[/dim]")
     return 0 if report.ok else 1
 
@@ -279,32 +408,25 @@ def cmd_doctor(args) -> int:
 
 
 def cmd_list(args) -> int:
+    """The quick catalog: id, description, simple hints. Registry + cache only --
+
+    no binary read, so it is fast and works anywhere. The dynamic agent/model
+    catalog and full usage live in `apply --help`.
+    """
     heading("Available patches")
+    console.print(
+        "  [dim]apply with `patch-cc apply <id>`; "
+        "see `apply --help` for flags, examples & your binary's agents/models[/dim]"
+    )
+    cached = cache.load()
     for group, patches in by_group().items():
         if not patches:
             continue
         console.print(f"\n[bold]{group}[/bold]")
         for patch in patches:
-            tag = "[dim](via --model)[/dim]" if not patch.default else ""
-            console.print(f"  [cyan]{patch.id:18s}[/cyan] {patch.summary} {tag}")
-
-    install = locate.find()
-    if install is None:
-        return 0
-    try:
-        source = patcher.read_pristine(install).source
-    except (BunError, OSError):
-        return 0
-    agents = discover_agents(source)
-    if agents:
-        console.print(f"\n[bold]Subagents in Claude {install.version or '?'}[/bold]")
-        for agent in agents:
-            console.print(
-                f"  [cyan]{agent.name:18s}[/cyan] default model: {agent.effective_model}"
-            )
-        console.print(
-            f"  [dim]models: {', '.join([INHERIT, *discover_models(source)])}[/dim]"
-        )
+            console.print(f"  [cyan]{patch.id:18s}[/cyan] {patch.summary}")
+            if hint := _list_hint(patch, cached):
+                console.print(f"  [dim]{'':18s} {hint}[/dim]")
     return 0
 
 
@@ -335,36 +457,182 @@ def cmd_menu(args) -> int:
     return run_menu()
 
 
+_MAIN_EPILOG = """\
+Run with no arguments to open the interactive menu.
+
+common tasks:
+  patch-cc apply          apply the default patch set to the installed binary
+  patch-cc apply --help   every patch id, the flags, and worked examples
+  patch-cc status         show exactly what is applied right now
+  patch-cc doctor         check every patch still matches this build
+  patch-cc list           describe every patch: ids, descriptions, hints
+  patch-cc restore        put the original binary back from backup
+"""
+
+
+def _discover_binary() -> tuple[str | None, str | None]:
+    """The installed binary's JS source and version, or ``(None, version?)``.
+
+    Best-effort: ``apply --help`` reads the real binary so its agent/model list
+    matches what ``--model`` accepts, but a missing or unreadable install just
+    drops the dynamic block instead of failing the help.
+    """
+    install = locate.find()
+    if install is None:
+        return None, None
+    try:
+        return patcher.read_pristine(install).source, install.version
+    except (BunError, OSError):
+        return None, install.version
+
+
+def _example_model(models: list[str], offset: int = 0) -> str:
+    """A concrete (non-inherit) model alias for a ``--model`` example."""
+    concrete = [m for m in models if m != INHERIT]
+    return concrete[offset % len(concrete)] if concrete else INHERIT
+
+
+def _apply_epilog() -> str:
+    """Build ``apply --help`` from the registry *and* the installed binary.
+
+    Nothing is hardcoded: the patch list and default markers come from the
+    registry, the subagent agents and models from the real binary. The binary
+    read is deferred to the help action, so only ``apply --help`` pays for it and
+    a missing install degrades to the static parts.
+    """
+    source, version = _discover_binary()
+    agents = discover_agents(source) if source else []
+    models = [INHERIT, *discover_models(source)] if source else []
+    grouped = by_group()
+
+    lines = ["patches  (name them to apply exactly those; * = the default set):", ""]
+    for group in GROUP_ORDER:
+        group_patches = grouped.get(group, [])
+        if not group_patches:
+            continue
+        lines.append(f"  {group}")
+        for patch in group_patches:
+            mark = "*" if patch.default else " "
+            hint = _enable_hint(patch)
+            row = f"    {mark} {patch.id:20s}{patch.title}"
+            lines.append(f"{row}   {hint}" if hint else row)
+        lines.append("")
+
+    lines += [
+        "naming ids replaces the default set with exactly what you name; the",
+        "flags below always add their own patch on top of whatever you named.",
+        "",
+        "configuring patches:",
+        f"  --brand [NAME]       selects branding  ·  no value -> {derived_brand()!r}",
+        f"  --suffix TEXT        selects version-marker  ·  default {DEFAULT_SUFFIX!r}",
+        "  --model AGENT=MODEL  selects subagent-models  ·  repeatable, one per agent",
+    ]
+    if agents:
+        lines += [
+            f"      agents (Claude {version or '?'}):  "
+            + "  ".join(a.name for a in agents),
+            "      models:  " + "  ".join(models),
+        ]
+    elif source is None:
+        lines.append(
+            "      (the agents/models list shows when a Claude install is present)"
+        )
+
+    ex_one = f"{agents[0].name}={_example_model(models)}" if agents else "Explore=haiku"
+    ex_two = f"{agents[1].name}={_example_model(models, 1)}" if len(agents) > 1 else ""
+
+    lines += [
+        "",
+        "examples:",
+        "  patch-cc apply",
+        "      the default set (the * patches above)",
+        "  patch-cc apply tool-calls live-thinking",
+        "      only these two; the default set is replaced",
+        "  patch-cc apply --brand",
+        f"      the default set, branded {derived_brand()!r}",
+        '  patch-cc apply --brand "Ada\'s Code" --suffix "(ada)"',
+        "      default set with an explicit startup name and version marker",
+        f"  patch-cc apply --model {ex_one}" + (f" --model {ex_two}" if ex_two else ""),
+        "      default set plus subagent model override" + ("s" if ex_two else ""),
+        "  patch-cc apply --from-cache",
+        "      re-apply your last interactive menu selection (saved by `patch-cc`)",
+    ]
+    return "\n".join(lines)
+
+
+class _ApplyHelpAction(argparse.Action):
+    """``apply -h/--help``: assemble the dynamic epilog, then print help.
+
+    Deferred here rather than at parser-build time so only ``apply --help`` reads
+    the binary -- every other ``patch-cc`` invocation stays fast and needs no
+    install.
+    """
+
+    def __init__(self, option_strings, dest, **kwargs):
+        super().__init__(
+            option_strings, dest, nargs=0, default=argparse.SUPPRESS, **kwargs
+        )
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser.epilog = _apply_epilog()
+        parser.print_help()
+        parser.exit()
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="patch-cc",
         description="Interactive patcher for the Claude Code native binary.",
+        epilog=_MAIN_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.set_defaults(func=cmd_menu)
     sub = parser.add_subparsers(dest="command")
 
-    p_apply = sub.add_parser("apply", help="apply patches to the installed binary")
+    p_apply = sub.add_parser(
+        "apply",
+        help="apply patches to the installed binary",
+        description="Apply patches to the installed Claude binary. Always starts "
+        "from a pristine copy, so re-applying replaces the previous set rather "
+        "than stacking on it.",
+        add_help=False,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p_apply.add_argument(
+        "-h",
+        "--help",
+        action=_ApplyHelpAction,
+        help="show this help (reads the installed binary for its agents/models)",
+    )
     p_apply.add_argument(
         "patches",
         nargs="*",
         metavar="PATCH",
-        help="patch ids to apply (default: the default set)",
+        help="patch ids to apply (default: the default set; all ids listed below)",
+    )
+    p_apply.add_argument(
+        "--from-cache",
+        action="store_true",
+        help="re-apply your last interactive menu selection (ignores other args)",
     )
     p_apply.add_argument(
         "--brand",
         nargs="?",
         const=_DERIVE,
         metavar="NAME",
-        help="custom startup name (no value: <username>'s Code)",
+        help="startup name; selects `branding` (no value: <username>'s Code)",
     )
     p_apply.add_argument(
         "--model",
         action="append",
         metavar="AGENT=MODEL",
-        help="override a subagent's default model (repeatable)",
+        help="set a subagent's model; selects `subagent-models` (repeatable)",
     )
     p_apply.add_argument(
-        "--suffix", metavar="TEXT", help="--version marker text (default: (patched))"
+        "--suffix",
+        metavar="TEXT",
+        help="`claude --version` marker text; selects `version-marker` "
+        "(default: (patched))",
     )
     p_apply.set_defaults(func=cmd_apply)
 
@@ -381,7 +649,11 @@ def build_parser() -> argparse.ArgumentParser:
     )
     p_doctor.set_defaults(func=cmd_doctor)
     sub.add_parser(
-        "list", help="list patches, and the agents/models in your binary"
+        "list",
+        help="describe every patch + the subagent models your binary offers",
+        description="Describe every patch (what it does, whether it is on by "
+        "default, and how to enable it) plus the subagent models discovered in "
+        "your installed binary. For apply syntax and examples, see `apply --help`.",
     ).set_defaults(func=cmd_list)
     sub.add_parser(
         "restore", help="restore the original binary from backup"

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/menu.py

@@ -49,7 +49,7 @@ from .patches import (
     derived_brand,
 )
 from .patches.agents import INHERIT, BuiltinAgent, discover_agents, discover_models
-from .ui import MARKS, console, err, findings
+from .ui import MARKS, applied_value, console, err, findings
 
 if TYPE_CHECKING:
     from .doctor import DryRun, Status
@@ -1028,12 +1028,15 @@ class MenuApp:
         report = self.report
         if report is None:
             return lines, None
+        options = self.model.selection().options
         for patch, outcome in report.results:
             mark, style = MARKS[outcome.health]
             line = Text()
             line.append(f"  {mark} ", style=style)
             line.append(f"{patch.title:<32}")
             line.append(f"{outcome.applied or '':>3}", style="dim")
+            if outcome.applied and (value := applied_value(patch, options)):
+                line.append(f"  → {value}", style="dim")
             lines.append(line)
             lines += _findings(outcome)
 
@@ -1063,6 +1066,12 @@ class MenuApp:
             )
             lines.append(line)
             lines.append(Text("    Restart Claude Code to see it.", style="dim"))
+            lines.append(
+                Text(
+                    "    Reapply this selection anytime:  patch-cc apply --from-cache",
+                    style="dim",
+                )
+            )
         return lines, None
 
     def _body_doctor(self, panel_width: int) -> tuple[list[Text], int | None]:

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/patches/__init__.py

@@ -13,7 +13,6 @@ from .base import (
     DEFAULT_SUFFIX,
     GROUP_AGENTS,
     GROUP_CHROME,
-    GROUP_LIVE,
     GROUP_OUTPUT,
     GROUP_THINKING,
     SENTINEL,
@@ -31,7 +30,7 @@ ALL_PATCHES: list[Patch] = [
     *chrome.PATCHES,
 ]
 
-GROUP_ORDER = [GROUP_OUTPUT, GROUP_THINKING, GROUP_LIVE, GROUP_AGENTS, GROUP_CHROME]
+GROUP_ORDER = [GROUP_OUTPUT, GROUP_THINKING, GROUP_AGENTS, GROUP_CHROME]
 
 _BY_ID = {patch.id: patch for patch in ALL_PATCHES}
 

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/patches/agents.py

@@ -341,6 +341,7 @@ PATCHES = [
         group=GROUP_AGENTS,
         fn=_subagent_models,
         default=False,
+        option="--model",
         anchors=('agentType:"', "Optional model override"),
     ),
 ]

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/patches/base.py

@@ -33,7 +33,6 @@ SENTINEL = "__cc_"
 # Groups, in display order.
 GROUP_OUTPUT = "Output & diffs"
 GROUP_THINKING = "Thinking"
-GROUP_LIVE = "Live thinking (streaming)"
 GROUP_AGENTS = "Subagents"
 GROUP_CHROME = "Chrome & branding"
 
@@ -218,6 +217,11 @@ class Patch:
     group: str
     fn: PatchFn
     default: bool = True
+    #: The CLI flag that configures and auto-selects this patch (``--brand``,
+    #: ``--model``, ``--suffix``); ``None`` for patches selected only by id. The
+    #: single home for the patch<->flag coupling, so ``list`` and ``apply
+    #: --help`` can say how an opt-in patch is turned on rather than inferring it.
+    option: str | None = None
     #: Anchors to report on when this patch stops matching.
     anchors: tuple[str, ...] = ()
 

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/patches/chrome.py

@@ -184,6 +184,7 @@ PATCHES = [
         summary="Append a marker line to `claude --version` (custom text via --suffix).",
         group=GROUP_CHROME,
         fn=_version_output,
+        option="--suffix",
         anchors=("}.VERSION} (Claude Code)",),
     ),
     Patch(
@@ -192,6 +193,7 @@ PATCHES = [
         summary="Rename the startup/help branding (default: your username's Code).",
         group=GROUP_CHROME,
         fn=_branding,
+        option="--brand",
         anchors=('"Welcome to Claude Code"', '{bold:!0},"Claude Code"'),
     ),
 ]

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/patches/streaming.py

@@ -23,7 +23,7 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass
 
-from .base import GROUP_LIVE, IDENT, Options, Outcome, Patch, compile_js, splice
+from .base import GROUP_THINKING, IDENT, Options, Outcome, Patch, compile_js, splice
 
 #: The mutually-exclusive reducer variants. On any one build one of them lands;
 #: none landing means upstream shipped a fourth shape and live thinking is dead.
@@ -974,7 +974,7 @@ PATCHES = [
         title="Stream thinking live",
         summary="Show thinking as it is generated, inline and in order, instead of "
         "only after the turn finishes.",
-        group=GROUP_LIVE,
+        group=GROUP_THINKING,
         fn=_live_thinking,
         anchors=(
             "onStreamingThinking:",

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/patches/thinking.py

@@ -192,8 +192,8 @@ def _thinking_summaries(content: str, _options: Options, outcome: Outcome) -> st
 PATCHES = [
     Patch(
         id="thinking-summaries",
-        title="Opt out of server-side experiments",
-        summary="Stop sending the account's experiment-bucket header, which can empty every thinking block.",
+        title="Fix blank thinking blocks",
+        summary="Opt out of the server-side experiment bucket that can return empty thinking blocks on some accounts. Drops all experiment enrollment, not just this one.",
         group=GROUP_THINKING,
         fn=_thinking_summaries,
         anchors=(_BUCKET_HEADER, "?.atis"),

{patch_cc-0.1.3 → patch_cc-0.1.4}/src/patch_cc/ui.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from rich.console import Console
 
-from .patches.base import Outcome
+from .patches.base import Options, Outcome, Patch
 
 console = Console()
 
@@ -37,6 +37,22 @@ def findings(outcome: Outcome) -> list[tuple[str, str]]:
     return lines + [("dim", note) for note in notes]
 
 
+def applied_value(patch: Patch, options: Options) -> str | None:
+    """The value a configurable patch actually wrote, for the report line.
+
+    Branding, the version marker, and model overrides each carry a chosen value;
+    a plain toggle patch carries none. One source so the CLI and the menu report
+    the same thing after an apply.
+    """
+    if patch.id == "branding":
+        return options.brand
+    if patch.id == "version-marker":
+        return options.version_suffix
+    if patch.id == "subagent-models" and options.subagent_models:
+        return ", ".join(f"{a}={m}" for a, m in options.subagent_models.items())
+    return None
+
+
 def heading(text: str) -> None:
     console.print(f"\n[bold]{text}[/bold]")
 

{patch_cc-0.1.3 → patch_cc-0.1.4}/uv.lock

@@ -256,7 +256,7 @@ wheels = [
 
 [[package]]
 name = "patch-cc"
-version = "0.1.3"
+version = "0.1.4"
 source = { editable = "." }
 dependencies = [
     { name = "blessed" },