patch-cc 0.2.3__tar.gz → 0.2.4__tar.gz

{patch_cc-0.2.3 → patch_cc-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: patch-cc
-Version: 0.2.3
+Version: 0.2.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

{patch_cc-0.2.3 → patch_cc-0.2.4}/docs/PLAYBOOK.md

@@ -116,10 +116,18 @@ can finish.
 Every patched bundle ends with one comment line recording what was applied; its
 shape lives in [INTERNALS.md](INTERNALS.md#the-manifest). What matters here is
 that it makes `status` a parse instead of a guess — several patches are value
-flips (`verbose:!0`) that leave no other fingerprint — and that `is_patched`
-also still recognises the legacy fingerprints (`__cc_` identifiers, the old
-`--version` marker), so binaries patched by pre-manifest versions are not
-mistaken for clean.
+flips (`verbose:!0`) that leave no other fingerprint — and that it is the
+**only** evidence `is_patched` accepts. Authorship is declared, never inferred:
+`is_patched` once also took side effects of our edits as proof — the `__cc_`
+identifier prefix, the old `--version` marker — until 2.1.227 shipped
+`__cc_name`/`__cc_line`/`__cc_set` shell variables of its own and every
+pristine install read as patched, hard-blocking `apply`. A prefix tracks
+upstream's naming fashion, never authorship (the same lesson as the `.enum(`
+callee above), and once upstream ships it, it fires on every later build, so no
+narrowing rescues an inferred fingerprint — `__cc_line` was already both our
+arrow-param and their shell variable. Binaries patched by pre-manifest versions
+therefore read as clean, which costs nothing now that Claude's daily
+auto-update has long since replaced that population.
 
 ## How resilience is detected
 

{patch_cc-0.2.3 → patch_cc-0.2.4}/pyproject.toml

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

{patch_cc-0.2.3 → patch_cc-0.2.4}/src/patch_cc/__init__.py

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

{patch_cc-0.2.3 → patch_cc-0.2.4}/src/patch_cc/cli.py

@@ -525,11 +525,6 @@ def cmd_status(args) -> int:
             if isinstance(codex.get("port"), int):
                 style, note = gateway_note(codex["port"])
                 console.print(f"  gateway:   [{style}]{note}[/{style}]")
-    elif st.patched:
-        console.print(
-            "  [dim]patched by an older patch-cc (no manifest); "
-            "re-apply to record one[/dim]"
-        )
     console.print(
         f"  bytecode:  "
         f"{'stripped' if st.bytecode_stripped else f'{st.bytecode_size / 1e6:.0f} MB present'}"

{patch_cc-0.2.3 → patch_cc-0.2.4}/src/patch_cc/doctor.py

@@ -3,8 +3,8 @@
 Two different questions, deliberately kept apart:
 
 * **status** -- is the *installed* binary patched right now? Answered by the
-  manifest comment every patched bundle ends with (plus legacy fingerprints),
-  and the bytecode-stripped invariant.
+  manifest comment every patched bundle ends with, and the bytecode-stripped
+  invariant.
 * **dryrun** -- would our patches still apply to *this* bundle? Answered by
   running every patch and reporting per-step hits, so a silently drifted
   matcher shows up as a concrete "reducer.message_stop missed" instead of a
@@ -21,20 +21,23 @@ from dataclasses import dataclass, field
 
 from .bun import Bundle
 from .codex.models import CodexModel
-from .patcher import is_patched, read_manifest
+from .patcher import read_manifest
 from .patches import ALL_PATCHES, Options, Outcome, Patch
 from .patches.agents import INHERIT, BuiltinAgent, discover_agents, discover_models
 
 
 @dataclass(slots=True)
 class Status:
-    patched: bool
     bytecode_stripped: bool
     bytecode_size: int
     #: Parsed manifest for binaries patched by this tool; ``None`` when the
-    #: binary is pristine or predates the manifest.
+    #: binary is pristine.
     manifest: dict | None
 
+    @property
+    def patched(self) -> bool:
+        return self.manifest is not None
+
     @property
     def patch_ids(self) -> list[str]:
         if not self.manifest:
@@ -48,12 +51,10 @@ class Status:
 
 
 def status(bundle: Bundle) -> Status:
-    source = bundle.source
     return Status(
-        patched=is_patched(source),
         bytecode_stripped=bundle.bytecode_size == 0,
         bytecode_size=bundle.bytecode_size,
-        manifest=read_manifest(source),
+        manifest=read_manifest(bundle.source),
     )
 
 

{patch_cc-0.2.3 → patch_cc-0.2.4}/src/patch_cc/patcher.py

@@ -11,7 +11,7 @@ from pathlib import Path
 
 from . import __version__, locate
 from .bun import Bundle, container
-from .patches import ALL_PATCHES, DEFAULT_SUFFIX, SENTINEL, Options, Outcome, Patch
+from .patches import ALL_PATCHES, DEFAULT_SUFFIX, Options, Outcome, Patch
 
 #: Every patched bundle ends with one comment line recording exactly what was
 #: applied. Comments cannot collide with code, survive re-extraction, and make
@@ -19,9 +19,6 @@ from .patches import ALL_PATCHES, DEFAULT_SUFFIX, SENTINEL, Options, Outcome, Pa
 #: fingerprint.
 MANIFEST_PREFIX = "//patch-cc "
 
-#: Fingerprints of binaries patched by versions before the manifest existed.
-_LEGACY_MARKER = "(Claude Code)\\n" + DEFAULT_SUFFIX
-
 
 class AlreadyPatchedError(RuntimeError):
     """The only source available is already patched; patching it would stack.
@@ -132,11 +129,16 @@ def read_manifest(source: str) -> dict | None:
 
 
 def is_patched(source: str) -> bool:
-    return (
-        ("\n" + MANIFEST_PREFIX) in source
-        or SENTINEL in source
-        or _LEGACY_MARKER in source
-    )
+    """Whether the bundle carries our manifest -- the one mark of our work.
+
+    Authorship is declared, never inferred. This used to also sniff side
+    effects of our edits (the ``__cc_`` identifier prefix, the old
+    ``--version`` marker), until 2.1.227 shipped ``__cc_``-prefixed shell
+    variables of its own and every pristine install read as patched. An
+    inferred fingerprint is a bet that upstream's vocabulary never overlaps
+    ours, and once upstream ships it, it fires on every build after, forever.
+    """
+    return read_manifest(source) is not None
 
 
 def selected_patches(ids: list[str]) -> list[Patch]:

{patch_cc-0.2.3 → patch_cc-0.2.4}/src/patch_cc/patches/__init__.py

@@ -22,7 +22,6 @@ from .base import (
     GROUP_CHROME,
     GROUP_MODELS,
     GROUP_OUTPUT,
-    SENTINEL,
     Options,
     Outcome,
     Patch,
@@ -61,7 +60,6 @@ __all__ = [
     "DEFAULT_BRAND",
     "DEFAULT_SUFFIX",
     "GROUP_ORDER",
-    "SENTINEL",
     "Options",
     "Outcome",
     "Patch",

{patch_cc-0.2.3 → patch_cc-0.2.4}/src/patch_cc/patches/base.py

@@ -32,11 +32,6 @@ from ..codex import DEFAULT_PORT
 if TYPE_CHECKING:
     from ..codex.models import CodexModel
 
-#: Prefix for every identifier we inject. These are the only reliable
-#: fingerprints of our work -- value flips like ``verbose:!0`` are
-#: indistinguishable from the 11 that upstream already ships.
-SENTINEL = "__cc_"
-
 # Groups, in display order: what renders, what runs (and how hard), how it is
 # dressed. Generic on purpose -- a group named after a feature (Thinking,
 # Subagents, Codex) fits exactly that feature, and the next patch that is

{patch_cc-0.2.3 → patch_cc-0.2.4}/uv.lock

@@ -320,7 +320,7 @@ wheels = [
 
 [[package]]
 name = "patch-cc"
-version = "0.2.3"
+version = "0.2.4"
 source = { editable = "." }
 dependencies = [
     { name = "blessed" },