codesuture 0.5.0__tar.gz → 0.6.0__tar.gz

codesuture-0.6.0/.gitignore

@@ -0,0 +1,33 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# CodeSuture specific
+.codesuture_cache/
+.codesuture_store/
+.codesuture_knowledge/
+.codesuture_fingerprints
+.models/
+
+# Exclude internal / dev scripts
+codesuture_verify*.py
+livepatch_verify*.py
+realbugg.py
+real.py
+*.zip
+.livepatch_*/
+v4test/
+
+# IDE / OS
+.vscode/
+.idea/
+.DS_Store

codesuture-0.6.0/CHANGELOG.md

@@ -0,0 +1,71 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.6.0] - 2026-05-12
+
+### Fixed
+- PEP 659: Force de-specialization after `__code__` swap via
+  `ctypes.pythonapi.PyFunction_SetCode` — prevents CPython 3.11+
+  adaptive bytecode cache from ignoring injected patches
+- Thread blindness: Install trace hook on all threads via
+  `threading.settrace` at startup, with `_install_trace_on_all_threads`
+  helper covering existing and future threads; added `threading.Lock`
+  for thread-safe patch store writes
+- Exception table corruption: Guard injection now detects try/except
+  scope via `TryBegin`/`TryEnd` markers and redirects to function
+  entry-point injection to avoid corrupting `co_exceptiontable` offsets
+  in CPython 3.11+
+
+## [0.5.1] - 2026-05-11
+
+### Fixed
+- propagate_patch: skip list/dict/set/generator comprehensions
+  instead of crashing with AttributeError on __code__
+- key_guard, subscript_guard, chain_subscript_guard: infer
+  correct default type from downstream bytecode usage
+  (string methods -> "" default, numeric ops -> 0 default)
+- KeyError on chained subscripts (e.g. request["headers"]["auth"].strip())
+  now produces a chain_subscript_guard instead of a simple key_guard,
+  preventing secondary TypeError from None subscript access
+
+## [0.5.0] - 2026-05-08
+
+### Added
+- Async/await support (CO_COROUTINE frame detection) — automatic `RESUME 0` preservation for coroutine bytecode patching.
+- Watch mode: `codesuture watch --max-restarts N` — subprocess loop with automatic crash-patch-restart cycle.
+- Explain command: `codesuture explain [func_name]` — detailed table of active patches with safety assessment (LIKELY/RISKY/UNKNOWN).
+- WSGI middleware: `CodeSutureMiddleware` — intercepts request handler exceptions, patches, and retries with `X-CodeSuture` response header.
+
+## [0.4.0] - 2026-05-07
+
+### Added
+- `codesuture rollback` command to selectively remove persisted patches (`codesuture rollback <func>`, `--all`, and `--dry-run`).
+- Three new guard types:
+  - `type_coercion_guard` for `TypeError` and `ValueError` during type conversions.
+  - `index_guard` for `IndexError` bounds checking.
+  - `key_guard` for safe dictionary `KeyError` fallbacks.
+- Enhanced `--dry-run` mode with confidence levels (HIGH/MEDIUM/LOW) based on fingerprint registry hits.
+- Full PyPI packaging structure (`pyproject.toml`, complete `README.md`, `CHANGELOG.md`).
+
+### Changed
+- Migrated legacy guards `list_bound_guard` to `index_guard` and `dict_get_guard` to `key_guard` for consistency.
+- Standardized CLI output format and improved error reporting.
+
+## [0.3.0] - 2026-05-06
+
+### Added
+- Dark Upgrade D1: Semantic diff safety gate to prevent runaway bytecode corruption.
+- Dark Upgrade D2: Caller-aware patch propagation to automatically fix closures and bound methods in-memory.
+- Dark Upgrade D3: Shadow execution mode (`--shadow`) to monitor and warn when sentinel defaults leak downstream.
+- Dark Upgrade D4: Patch expiry TTL warnings to nudge developers toward source-level fixes.
+- Dark Upgrade D5: Bytecode fingerprint registry for instant cache hits on known crash patterns.
+- Dark Upgrade D6: `codesuture audit` command for viewing all active patches in a formatted table.
+
+### Fixed
+- Addressed Windows `UnicodeDecodeError` and `cp1252` terminal limitations by enforcing `utf-8` encoding.
+- Resolved a race condition where patch persistence was executing after the code object swap, preventing correct caller identification.
+- Fixed namespace pollution during nested patching.

codesuture-0.6.0/MANIFEST.in

@@ -0,0 +1,14 @@
+include pyproject.toml
+include README.md
+include CHANGELOG.md
+include LICENSE
+include .gitignore
+
+recursive-include codesuture *.py
+recursive-include tests *.py
+
+exclude codesuture_verify*.py
+exclude livepatch_verify*.py
+exclude realbugg.py
+exclude real.py
+exclude *.zip

codesuture-0.6.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: codesuture
+Version: 0.6.0
+Summary: Runtime Python bytecode patcher with guard knowledge base, persistence, and self-healing re-execution
+License-Expression: MIT
+Project-URL: Source, https://github.com/codesuture-py/codesuture
+Keywords: bytecode,runtime,patching,self-healing,debugging,null-safety,resilience
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bytecode>=0.15.1
+Provides-Extra: autonomous
+Requires-Dist: llama-cpp-python; extra == "autonomous"
+Dynamic: license-file
+
+# CodeSuture
+
+> Runtime Python bytecode patcher. Catches crashes, synthesizes guards, rewrites functions in-memory, and persists fixes across runs.
+
+---
+
+## What it does
+
+CodeSuture sits between your Python program and its crashes. When an exception occurs, it intercepts the failing frame, disassembles the bytecode to identify the root cause, injects a deterministic guard directly into the function's code object, and retries execution — all without touching a single source file.
+
+The fix persists. On subsequent runs, CodeSuture loads the patched bytecode before the first function call. The crash is gone until you choose to remove the patch.
+
+It is a surgical tool for keeping programs running when structural failures — null access, missing keys, type mismatches, out-of-bounds reads — would otherwise bring them down.
+
+---
+
+## Installation
+
+```bash
+pip install codesuture
+```
+
+Python 3.11+ required.
+
+---
+
+## Quick start
+
+```bash
+codesuture run your_script.py
+```
+
+```
+[CodeSuture] Caught AttributeError: 'NoneType' object has no attribute 'bio'
+[CodeSuture] Applying null_guard on 'profile' ...
+[CodeSuture] Patch applied to get_bio().
+[CodeSuture] Re-executing after 1 patch(es)...
+
+Session summary:
+  Patches applied: 1
+```
+
+Run it again:
+
+```
+[CodeSuture] Already healed, skipping: loaded persistent patch for get_bio
+[CodeSuture] Session summary:
+  Patches applied: 0
+```
+
+---
+
+## How it works
+
+1. **Catch** — A `sys.settrace` callback intercepts exceptions at the exact frame and bytecode offset where they occur.
+2. **Analyze** — The pattern matcher disassembles the function's bytecode, walks the instruction chain, and identifies the failing variable or operation.
+3. **Patch** — The guard synthesizer injects new bytecode instructions into the function's code object in memory. A semantic diff gate rejects patches that would change too much of the function's logic.
+4. **Rewind** — Execution restarts from the patched function. The guard prevents the crash from recurring.
+5. **Persist** — The patched code object is serialized to `.codesuture_store/` with JSON metadata. On subsequent runs it loads before execution begins.
+
+No source files are modified at any point.
+
+---
+
+## Supported guard types
+
+| Guard type | Triggers on | Example |
+|---|---|---|
+| `null_guard` | `AttributeError` on `None` | `user.profile.bio` when `profile` is `None` |
+| `index_guard` | `IndexError` | `items[10]` when `len(items) == 2` |
+| `key_guard` | `KeyError` | `cfg["timeout"]` when key is missing |
+| `subscript_guard` | `TypeError` subscripting `None` | `data["key"]` when `data` is `None` |
+| `chain_subscript_guard` | Nested subscript on `None` | `data["user"]["name"]` |
+| `type_coercion_guard` | `TypeError` on conversion | `int("not_a_number")` |
+| `division_guard` | `ZeroDivisionError` | `x / count` when `count == 0` |
+| `str_coerce_guard` | `TypeError` on string concat | `"age: " + 25` |
+| `file_guard` | `FileNotFoundError` | `open(path)` when file is missing |
+| `callable_guard` | `TypeError` calling `None` | `func()` when `func` is `None` |
+
+---
+
+## CLI reference
+
+| Command | Flags | What it does |
+|---|---|---|
+| `codesuture run <script>` | | Run script with live patching enabled |
+| `codesuture run <script>` | `--verbose` | Show patch diffs and instruction deltas |
+| `codesuture run <script>` | `--shadow` | Warn when patched functions return sentinel values |
+| `codesuture run <script>` | `--dry-run` | Preview what would be patched without applying |
+| `codesuture run <script>` | `--ttl DAYS` | Set patch expiry in days (default: 7) |
+| `codesuture run <script>` | `--retries N` | Max re-execution attempts per crash (default: 3) |
+| `codesuture watch <script>` | `--max-restarts N` | Run continuously, restart after each patch |
+| `codesuture audit` | | Show all active patches in a formatted table |
+| `codesuture explain` | | Human-readable breakdown of what each patch changed |
+| `codesuture explain <name>` | | Explain one function's patch |
+| `codesuture rollback <name>` | | Remove one persisted patch |
+| `codesuture rollback` | `--all` | Remove all patches and the fingerprint registry |
+| `codesuture rollback` | `--dry-run` | Preview what would be removed |
+
+---
+
+## Runtime Intelligence
+
+Beyond basic patching, CodeSuture includes a set of higher-order behaviors that make it safe to use in real codebases:
+
+**Semantic diff gate** — Patches that would modify too many instructions relative to the guard type are automatically rejected. The engine will never corrupt a complex function to patch a simple crash.
+
+**Caller-aware propagation** — After patching a function, CodeSuture uses `gc.get_referrers` to find every live reference to the original code object — closures, bound methods, partials — and updates them all. No in-memory copy of the broken function survives.
+
+**Shadow execution mode** — `--shadow` monitors the return value of patched functions. If a sentinel default (`""`, `0`, `None`) leaks into downstream logic, CodeSuture logs a warning before it causes a second failure.
+
+**Patch expiry** — Every persisted patch carries a configurable TTL. When a patch ages past its limit, CodeSuture logs a reminder that the underlying bug should be addressed in source code. Patches are scaffolding, not permanent fixes.
+
+**Bytecode fingerprint registry** — Crash sites are hashed by their surrounding instruction window. When the same crash pattern appears again, CodeSuture applies the known guard directly without re-running analysis.
+
+**Audit trail** — `codesuture audit` displays every active patch: function name, guard type, target variable, default value, age, and rollback instructions. `codesuture explain` gives a plain-language breakdown of exactly what each patch changed and whether the default value is safe for downstream consumers.
+
+---
+
+## What CodeSuture is not
+
+**Not a logger.** It does not record exceptions and move on. It patches the function and retries.
+
+**Not a fuzzer or static analyzer.** It operates at runtime on live bytecode, not on source.
+
+**Not autonomous.** Patches should be reviewed via `codesuture audit` and `codesuture explain`. The goal is to keep your program running while you address the root cause — not to replace the fix.
+
+---
+
+## Limitations
+
+**Python 3.11+ only.** CodeSuture depends on bytecode structures introduced in CPython 3.11. Earlier versions are not supported.
+
+**List and dict comprehensions are not patchable.** Comprehensions are implemented as anonymous nested code objects in CPython. CodeSuture detects crashes inside them and logs a warning, but does not attempt to patch them. Refactor the comprehension into a named function to enable patching.
+
+**Semantic bugs are not patchable.** CodeSuture fixes structural crashes — null access, missing keys, type mismatches, bounds errors. It cannot fix logic errors where the code runs but produces wrong results.
+
+**Single-process scope.** Patches apply per-process. Multi-process applications need a CodeSuture instance per worker. The `.codesuture_store/` directory is shared on disk, so patches load correctly on restart.
+
+**Web server support requires Python 3.11+ with `threading.settrace` active.** Tested with `socketserver` and `threading.Thread`. ASGI frameworks (FastAPI, Starlette) require the ASGI middleware wrapper.
+
+---
+
+## License
+
+MIT. See [LICENSE](LICENSE) for details.

codesuture-0.6.0/README.md

@@ -0,0 +1,146 @@
+# CodeSuture
+
+> Runtime Python bytecode patcher. Catches crashes, synthesizes guards, rewrites functions in-memory, and persists fixes across runs.
+
+---
+
+## What it does
+
+CodeSuture sits between your Python program and its crashes. When an exception occurs, it intercepts the failing frame, disassembles the bytecode to identify the root cause, injects a deterministic guard directly into the function's code object, and retries execution — all without touching a single source file.
+
+The fix persists. On subsequent runs, CodeSuture loads the patched bytecode before the first function call. The crash is gone until you choose to remove the patch.
+
+It is a surgical tool for keeping programs running when structural failures — null access, missing keys, type mismatches, out-of-bounds reads — would otherwise bring them down.
+
+---
+
+## Installation
+
+```bash
+pip install codesuture
+```
+
+Python 3.11+ required.
+
+---
+
+## Quick start
+
+```bash
+codesuture run your_script.py
+```
+
+```
+[CodeSuture] Caught AttributeError: 'NoneType' object has no attribute 'bio'
+[CodeSuture] Applying null_guard on 'profile' ...
+[CodeSuture] Patch applied to get_bio().
+[CodeSuture] Re-executing after 1 patch(es)...
+
+Session summary:
+  Patches applied: 1
+```
+
+Run it again:
+
+```
+[CodeSuture] Already healed, skipping: loaded persistent patch for get_bio
+[CodeSuture] Session summary:
+  Patches applied: 0
+```
+
+---
+
+## How it works
+
+1. **Catch** — A `sys.settrace` callback intercepts exceptions at the exact frame and bytecode offset where they occur.
+2. **Analyze** — The pattern matcher disassembles the function's bytecode, walks the instruction chain, and identifies the failing variable or operation.
+3. **Patch** — The guard synthesizer injects new bytecode instructions into the function's code object in memory. A semantic diff gate rejects patches that would change too much of the function's logic.
+4. **Rewind** — Execution restarts from the patched function. The guard prevents the crash from recurring.
+5. **Persist** — The patched code object is serialized to `.codesuture_store/` with JSON metadata. On subsequent runs it loads before execution begins.
+
+No source files are modified at any point.
+
+---
+
+## Supported guard types
+
+| Guard type | Triggers on | Example |
+|---|---|---|
+| `null_guard` | `AttributeError` on `None` | `user.profile.bio` when `profile` is `None` |
+| `index_guard` | `IndexError` | `items[10]` when `len(items) == 2` |
+| `key_guard` | `KeyError` | `cfg["timeout"]` when key is missing |
+| `subscript_guard` | `TypeError` subscripting `None` | `data["key"]` when `data` is `None` |
+| `chain_subscript_guard` | Nested subscript on `None` | `data["user"]["name"]` |
+| `type_coercion_guard` | `TypeError` on conversion | `int("not_a_number")` |
+| `division_guard` | `ZeroDivisionError` | `x / count` when `count == 0` |
+| `str_coerce_guard` | `TypeError` on string concat | `"age: " + 25` |
+| `file_guard` | `FileNotFoundError` | `open(path)` when file is missing |
+| `callable_guard` | `TypeError` calling `None` | `func()` when `func` is `None` |
+
+---
+
+## CLI reference
+
+| Command | Flags | What it does |
+|---|---|---|
+| `codesuture run <script>` | | Run script with live patching enabled |
+| `codesuture run <script>` | `--verbose` | Show patch diffs and instruction deltas |
+| `codesuture run <script>` | `--shadow` | Warn when patched functions return sentinel values |
+| `codesuture run <script>` | `--dry-run` | Preview what would be patched without applying |
+| `codesuture run <script>` | `--ttl DAYS` | Set patch expiry in days (default: 7) |
+| `codesuture run <script>` | `--retries N` | Max re-execution attempts per crash (default: 3) |
+| `codesuture watch <script>` | `--max-restarts N` | Run continuously, restart after each patch |
+| `codesuture audit` | | Show all active patches in a formatted table |
+| `codesuture explain` | | Human-readable breakdown of what each patch changed |
+| `codesuture explain <name>` | | Explain one function's patch |
+| `codesuture rollback <name>` | | Remove one persisted patch |
+| `codesuture rollback` | `--all` | Remove all patches and the fingerprint registry |
+| `codesuture rollback` | `--dry-run` | Preview what would be removed |
+
+---
+
+## Runtime Intelligence
+
+Beyond basic patching, CodeSuture includes a set of higher-order behaviors that make it safe to use in real codebases:
+
+**Semantic diff gate** — Patches that would modify too many instructions relative to the guard type are automatically rejected. The engine will never corrupt a complex function to patch a simple crash.
+
+**Caller-aware propagation** — After patching a function, CodeSuture uses `gc.get_referrers` to find every live reference to the original code object — closures, bound methods, partials — and updates them all. No in-memory copy of the broken function survives.
+
+**Shadow execution mode** — `--shadow` monitors the return value of patched functions. If a sentinel default (`""`, `0`, `None`) leaks into downstream logic, CodeSuture logs a warning before it causes a second failure.
+
+**Patch expiry** — Every persisted patch carries a configurable TTL. When a patch ages past its limit, CodeSuture logs a reminder that the underlying bug should be addressed in source code. Patches are scaffolding, not permanent fixes.
+
+**Bytecode fingerprint registry** — Crash sites are hashed by their surrounding instruction window. When the same crash pattern appears again, CodeSuture applies the known guard directly without re-running analysis.
+
+**Audit trail** — `codesuture audit` displays every active patch: function name, guard type, target variable, default value, age, and rollback instructions. `codesuture explain` gives a plain-language breakdown of exactly what each patch changed and whether the default value is safe for downstream consumers.
+
+---
+
+## What CodeSuture is not
+
+**Not a logger.** It does not record exceptions and move on. It patches the function and retries.
+
+**Not a fuzzer or static analyzer.** It operates at runtime on live bytecode, not on source.
+
+**Not autonomous.** Patches should be reviewed via `codesuture audit` and `codesuture explain`. The goal is to keep your program running while you address the root cause — not to replace the fix.
+
+---
+
+## Limitations
+
+**Python 3.11+ only.** CodeSuture depends on bytecode structures introduced in CPython 3.11. Earlier versions are not supported.
+
+**List and dict comprehensions are not patchable.** Comprehensions are implemented as anonymous nested code objects in CPython. CodeSuture detects crashes inside them and logs a warning, but does not attempt to patch them. Refactor the comprehension into a named function to enable patching.
+
+**Semantic bugs are not patchable.** CodeSuture fixes structural crashes — null access, missing keys, type mismatches, bounds errors. It cannot fix logic errors where the code runs but produces wrong results.
+
+**Single-process scope.** Patches apply per-process. Multi-process applications need a CodeSuture instance per worker. The `.codesuture_store/` directory is shared on disk, so patches load correctly on restart.
+
+**Web server support requires Python 3.11+ with `threading.settrace` active.** Tested with `socketserver` and `threading.Thread`. ASGI frameworks (FastAPI, Starlette) require the ASGI middleware wrapper.
+
+---
+
+## License
+
+MIT. See [LICENSE](LICENSE) for details.

codesuture-0.6.0/codesuture/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.6.0"
+

{codesuture-0.5.0 → codesuture-0.6.0}/codesuture/cli.py

@@ -1,11 +1,11 @@
 import sys
 import argparse
-from codesuture.tracer import install, uninstall
+from codesuture.tracer import install, uninstall, _install_trace_on_all_threads
 
 def main():
     parser = argparse.ArgumentParser(prog='codesuture',
                                      description='Runtime Python bytecode patcher with self-healing re-execution')
-    parser.add_argument('--version', action='version', version='codesuture 0.5.0')
+    parser.add_argument('--version', action='version', version='codesuture 0.6.0')
     sub = parser.add_subparsers(dest='command', required=True)
 
     run_parser = sub.add_parser('run', help='Run a script with live patching')
@@ -102,7 +102,7 @@ def main():
                 patched_before = tracer.stats['patched']
                 tracer._handled_exc_ids.clear()
                 try:
-                    sys.settrace(tracer)
+                    _install_trace_on_all_threads(tracer)
                     globs = make_persisted_patch_globals(
                         "__main__",
                         {'__name__': '__main__', '__file__': args.script},

{codesuture-0.5.0 → codesuture-0.6.0}/codesuture/guard_synthesizer.py

@@ -1,9 +1,30 @@
-"""
+"""
 Synthesises guard + original bytecode for all deterministic strategies.
 """
+import ctypes
 from bytecode import Bytecode, Instr, Label, Compare
 from codesuture.pattern_matcher import PatchSpec
 
+def _force_despecialize(func):
+    """
+    Force CPython 3.11+ to abandon its adaptive
+    instruction cache for this function.
+    After __code__ replacement, the interpreter must
+    re-read the new bytecode from scratch.
+    """
+    try:
+        # PyFunction_SetCode forces de-specialization
+        # by going through the official C API path
+        # rather than the Python attribute setter.
+        ctypes.pythonapi.PyFunction_SetCode(
+            ctypes.py_object(func),
+            ctypes.py_object(func.__code__)
+        )
+    except Exception:
+        pass  # Non-fatal: patch still applied, may not
+              # take effect until next function cold-start
+
+
 class PatchValidationError(Exception):
     pass
 
@@ -25,6 +46,22 @@ def validate_patch(original_code, patched_code):
 
 def propagate_patch(original_func, patched_code) -> int:
     import gc
+    import logging
+    if original_func is None:
+        return 0
+    if not hasattr(original_func, '__code__'):
+        return 0
+    name = getattr(original_func, '__qualname__', '') or \
+           getattr(original_func, '__name__', '')
+    if '<listcomp>' in name or '<genexpr>' in name or \
+       '<dictcomp>' in name or '<setcomp>' in name:
+        import logging
+        logging.getLogger(__name__).debug(
+            "[CodeSuture] Skipping %s — "
+            "comprehensions are not patchable via __code__", name
+        )
+        return 0
+
     original_code = original_func.__code__
     propagated = 0
 
@@ -35,21 +72,91 @@ def propagate_patch(original_func, patched_code) -> int:
         if hasattr(ref, '__func__') and hasattr(ref.__func__, '__code__'):
             if ref.__func__.__code__ is original_code:
                 ref.__func__.__code__ = patched_code
+                _force_despecialize(ref.__func__)
                 propagated += 1
 
         elif hasattr(ref, '__code__') and ref.__code__ is original_code:
             ref.__code__ = patched_code
+            _force_despecialize(ref)
             propagated += 1
 
     original_func.__code__ = patched_code
+    _force_despecialize(original_func)
 
     if propagated > 0:
         print(f"[CodeSuture] Propagated patch to {propagated} additional "
               f"live reference(s) of {original_func.__qualname__}.")
     return propagated
 
+def _is_inside_try_block(code):
+    """Return True if any BINARY_SUBSCR or crash-relevant opcode
+       falls inside an exception handler range (TryBegin/TryEnd).
+       Uses the bytecode library's TryBegin/TryEnd markers."""
+    import sys
+    if sys.version_info < (3, 11):
+        return False
+    try:
+        from bytecode import TryBegin, TryEnd
+        bc = Bytecode.from_code(code)
+        depth = 0
+        has_subscr_in_try = False
+        for item in bc:
+            if isinstance(item, TryBegin):
+                depth += 1
+            elif isinstance(item, TryEnd):
+                depth = max(0, depth - 1)
+            elif depth > 0 and isinstance(item, Instr):
+                if item.name in ('BINARY_SUBSCR', 'LOAD_ATTR', 'LOAD_METHOD',
+                                 'BINARY_OP', 'BINARY_TRUE_DIVIDE'):
+                    has_subscr_in_try = True
+                    break
+        return has_subscr_in_try
+    except Exception:
+        return False
+
+def _build_entry_point_null_guard(original_code, var_name, default):
+    """Build a guard injected at the function entry point (after RESUME).
+       Checks if var_name is None and replaces it with default.
+       Safe for use when the crash site is inside a try block."""
+    bc = Bytecode.from_code(original_code)
+    skip = Label()
+    patch = [
+        Instr('LOAD_FAST', var_name),
+        Instr('LOAD_CONST', None),
+        Instr('IS_OP', 0),
+        Instr('POP_JUMP_FORWARD_IF_FALSE', skip),
+        Instr('LOAD_CONST', default),
+        Instr('RETURN_VALUE'),
+        skip
+    ]
+    idx = 0
+    for i, instr in enumerate(bc):
+        if isinstance(instr, Instr) and instr.name == 'RESUME':
+            idx = i + 1
+            break
+    for instr in reversed(patch):
+        bc.insert(idx, instr)
+    return bc
+
+# Strategies that inject inline at the crash site (replace BINARY_SUBSCR etc.)
+# These are the ones that can corrupt exception tables when inside try blocks.
+_INLINE_STRATEGIES = frozenset({
+    'subscript_guard', 'key_guard', 'dict_get_guard',
+    'chain_subscript_guard', 'division_guard',
+})
+
 def synthesize_guarded_code(original_code, spec: PatchSpec) -> Bytecode:
-    if spec.strategy in ('subscript_guard', 'key_guard', 'dict_get_guard'):
+    # Bug 3 fix: If the crash site is inside a try/except block and we
+    # would normally inject inline, redirect to an entry-point guard
+    # to avoid corrupting co_exceptiontable offsets on CPython 3.11+.
+    if spec.strategy in _INLINE_STRATEGIES and _is_inside_try_block(original_code):
+        import logging
+        logging.getLogger(__name__).debug(
+            "[CodeSuture] Crash inside try block — redirecting %s to entry-point guard",
+            spec.strategy
+        )
+        res = _build_entry_point_null_guard(original_code, spec.var_name, spec.default_value)
+    elif spec.strategy in ('subscript_guard', 'key_guard', 'dict_get_guard'):
         res = _build_subscript_guarded_code(original_code, spec.var_name, spec.key_name, spec.default_value)
     elif spec.strategy == 'chain_subscript_guard':
         res = _build_chain_subscript_guarded_code(original_code, spec.var_name, spec.key_name, spec.default_value)