patch-chat 0.1.0__tar.gz → 0.2.0__tar.gz

{patch_chat-0.1.0 → patch_chat-0.2.0}/.agents/setup

@@ -20,8 +20,11 @@ if ((${#missing_packages[@]})); then
 fi
 
 step "Installing Python project and development dependencies"
+# No --extra-index-url: it resolves each name across both indexes and takes the
+# highest version, rather than replacing the index as --index-url does. Nothing
+# in the pinned locks needs the torch index; docker/Dockerfile uses --index-url
+# where it genuinely does.
 python3 -m pip install --editable . \
-    --extra-index-url https://download.pytorch.org/whl/cpu \
     --requirement requirements/requirements-dev.txt \
     --requirement requirements/requirements-browser.txt \
     --requirement requirements/requirements-playwright.txt

patch_chat-0.2.0/.github/workflows/packaging.yml

@@ -0,0 +1,103 @@
+name: Packaging
+
+# The test suite runs from the repository root, where `tests/__init__.py` puts the
+# working tree on sys.path -- so `import patch` resolves to ./patch and the suite
+# never sees the artifact users install. This job closes that gap: it builds a
+# wheel with no .git present (the same context docker/Dockerfile gets, since
+# .dockerignore excludes .git), installs it into a clean environment, and imports
+# it from another directory.
+#
+# Without .git, setuptools-scm's file finder is unavailable and only the files
+# enumerated in [tool.setuptools.package-data] survive. That is how
+# patch/resources/model-settings.yml went missing once already; models.py opens it
+# at import time, so the wheel raised FileNotFoundError on every invocation while
+# passing the whole test suite.
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  installed-wheel:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+
+    - name: Build a wheel from a source tree with no .git
+      run: |
+        python -m pip install --upgrade pip build
+        mkdir -p /tmp/nogit
+        # Deliberately not `git archive`: this must mirror `COPY . /tmp/patch`,
+        # i.e. the working tree minus the directories .dockerignore excludes.
+        tar --exclude=.git --exclude='*.egg-info' --exclude=dist --exclude=build \
+            -cf - . | tar -C /tmp/nogit -xf -
+        test ! -e /tmp/nogit/.git
+        cd /tmp/nogit && python -m build --wheel --outdir /tmp/dist .
+
+    - name: Install the wheel into a clean environment
+      run: |
+        python -m venv /tmp/venv
+        /tmp/venv/bin/python -m pip install --upgrade pip
+        /tmp/venv/bin/python -m pip install /tmp/dist/*.whl
+
+    - name: Import it from another directory
+      run: |
+        mkdir -p /tmp/elsewhere
+        cd /tmp/elsewhere
+        # Must not resolve to a source checkout.
+        /tmp/venv/bin/python -c "
+        import patch, patch.main, patch.models
+        assert 'site-packages' in patch.__file__, patch.__file__
+        assert patch.models.MODEL_SETTINGS, 'model-settings.yml did not load'
+        print('imported', patch.__file__)
+        print('model settings:', len(patch.models.MODEL_SETTINGS))
+        "
+
+    - name: Check the console script is wired up
+      run: |
+        cd /tmp/elsewhere
+        /tmp/venv/bin/patch --version
+
+    - name: Verify wheel metadata and declared package data
+      run: |
+        python - <<'EOF'
+        from email.parser import BytesParser
+        import glob
+        from pathlib import Path
+        import zipfile
+
+        with zipfile.ZipFile(glob.glob("/tmp/dist/*.whl")[0]) as wheel:
+            names = wheel.namelist()
+            metadata_name = next(n for n in names if n.endswith(".dist-info/METADATA"))
+            metadata = BytesParser().parsebytes(wheel.read(metadata_name))
+
+            assert metadata["License-Expression"] == "Apache-2.0"
+            assert metadata["Requires-Python"] == "<3.15,>=3.10"
+            assert any(n.endswith(".dist-info/licenses/LICENSE.txt") for n in names)
+
+            required = [
+                "patch/resources/model-settings.yml",
+                "patch/resources/model-metadata.json",
+            ]
+            missing = [r for r in required if r not in names]
+            assert not missing, f"missing from the wheel: {missing}"
+            assert any(n.endswith(".scm") for n in names), "no tree-sitter queries in the wheel"
+            assert any(n.startswith("patch/coders/") for n in names), "patch.coders missing"
+
+        readme = Path("README.md").read_text()
+        assert "supports Python 3.10 through 3.14" in readme
+        print(f"wheel contains {len(names)} entries; metadata and required files verified")
+        EOF

{patch_chat-0.1.0 → patch_chat-0.2.0}/.github/workflows/pre-commit.yml

@@ -14,6 +14,16 @@ jobs:
       - run: sudo apt-get update && sudo apt-get install cppcheck uncrustify
         if: false
       - uses: actions/checkout@v4
+      # Pin the interpreter. Without this every hook environment -- including
+      # mypy, which pyproject.toml configures for python_version = "3.10" -- is
+      # built against whatever ubuntu-latest currently ships, so the type gate
+      # drifts silently when the runner image changes. It also populates
+      # env.pythonLocation, which the cache keys below interpolate: unset, they
+      # collapse to `pre-commit-4||<hash>` and restore hook virtualenvs built
+      # against a different Python.
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
       - run: python -m pip install pre-commit
       - uses: actions/cache/restore@v4
         with:

{patch_chat-0.1.0 → patch_chat-0.2.0}/.github/workflows/ubuntu-tests.yml

@@ -32,7 +32,6 @@ jobs:
         cache: pip
         cache-dependency-path: |
           requirements.txt
-          requirements/requirements-dev.txt
 
     - name: Install system dependencies
       run: |
@@ -42,11 +41,17 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest pytest-env
-        pip install .
+        pip install pytest pytest-env pytest-cov
+        # pytest.ini collects tests/browser and tests/scrape, so the optional
+        # extras those exercise have to be present -- and installing them is the
+        # only thing that checks the extras are declared correctly at all.
+        pip install .[browser,playwright]
 
     - name: Run tests
       env:
         PATCH_ANALYTICS: false
+      # Coverage is reported, not gated: a threshold now would either be set so
+      # low it asserts nothing or would fail the build on unrelated changes.
+      # Making the number visible is the point.
       run: |
-        pytest
+        pytest --cov=patch --cov-report=term-missing

{patch_chat-0.1.0 → patch_chat-0.2.0}/.github/workflows/windows-tests.yml

@@ -32,13 +32,15 @@ jobs:
         cache: pip
         cache-dependency-path: |
           requirements.txt
-          requirements/requirements-dev.txt
 
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest pytest-env
-        pip install .
+        pip install pytest pytest-env pytest-cov
+        # pytest.ini collects tests/browser and tests/scrape, so the optional
+        # extras those exercise have to be present -- and installing them is the
+        # only thing that checks the extras are declared correctly at all.
+        pip install .[browser,playwright]
 
     - name: Run tests
       env:

{patch_chat-0.1.0 → patch_chat-0.2.0}/.gitignore

@@ -20,3 +20,6 @@ patch/_version.py
 tmp.benchmarks/
 .docker_bash_history
 .amp/portals/*
+.coverage
+htmlcov/
+.coverage.*

patch_chat-0.2.0/AGENTS.md

@@ -0,0 +1,138 @@
+# AGENTS.md
+
+Guidance for AI coding agents working in this repository.
+
+## What this project is
+
+Patch is an AI pair-programming tool that runs in the terminal. The Python distribution is
+[`patch-chat`](https://pypi.org/project/patch-chat/), the module is `patch/`, and the CLI entry
+point is `patch` (`patch.main:main`). Release history lives in [CHANGELOG.md](CHANGELOG.md).
+
+Versions come from git tags via setuptools-scm; the fork's own history starts at `0.1.0` and does
+not continue upstream aider's `0.86.x` numbering.
+
+## Setup
+
+Python 3.10 through 3.14 (`requires-python = ">=3.10,<3.15"`).
+
+```
+pip install -e .
+pip install -r requirements.txt
+pip install -r requirements/requirements-dev.txt
+```
+
+## Testing
+
+```
+pytest                              # full suite
+pytest tests/basic/test_coder.py    # one file
+pytest -k test_repomap              # one pattern
+```
+
+`pytest.ini` sets `testpaths` to `tests/basic`, `tests/browser` and `tests/scrape`, and forces
+`PATCH_ANALYTICS=false`. The bulk of the suite is
+the 30+ files in `tests/basic/`. `benchmark/` is excluded from collection and is
+not part of normal development.
+
+## Linting and formatting
+
+The project uses pre-commit. Run it before finishing any code change:
+
+```
+pre-commit run --all-files
+```
+
+Five hooks, all of which CI enforces:
+
+- **black**, line length 100, with `--preview`
+- **isort**, black profile
+- **flake8**, max line length 100, ignoring `E203` and `W503`
+- **mypy**, over the configured high-value module boundaries
+- **codespell**
+
+The line length is 100, not black's default 88. Match it.
+
+## Repository layout
+
+- `patch/coders/` — the heart of the project. Each edit format is a
+  `*_coder.py` paired with a `*_prompts.py` holding its system prompts.
+  `base_coder.py` (~2.6k lines) is the shared chat loop that all of them
+  subclass. `coders/usage.py` (token and cost accounting) and
+  `coders/chat_state.py` (the transcript and its background summariser)
+  hold state extracted from it. New edit formats are registered in `patch/coders/__init__.py`.
+- `patch/main.py` — CLI entry, argument wiring, startup.
+- `patch/models.py` — model definitions, aliases, and metadata. Adding support
+  for a new LLM usually means editing this file and nothing else.
+- `patch/commands.py` — the in-chat `/slash` commands.
+- `patch/repo.py`, `patch/repomap.py` — git integration and the tree-sitter
+  repository map.
+- `patch/repo_trust.py` — the repository-trust boundary. The repo under edit is
+  untrusted input, and every rule about what its config files may set lives
+  here, applied in an enforced order. Adding an argument that names a file or a
+  command means recording a decision about it in this module, or a test fails.
+- `tests/` — mirrors the module layout under `tests/basic/`.
+
+Two root-level documents cover the audit history:
+
+- `AUDIT_REPORT.md` — three completed audits (F-1 – F-97) and their remediation.
+- `AUDIT_PROMPT.md` — the reusable brief for running another one. It carries the
+  evidence bar, the recurring defect shape worth searching for, and a list of
+  candidates already investigated and rejected, so a new round does not
+  re-derive them.
+
+## Things not to edit
+
+- `patch/_version.py` — generated by setuptools_scm, gitignored.
+- `requirements/*.txt` — compiled from the matching `.in` files by
+  `./scripts/pip-compile.sh`. Edit the `.in` file and re-run the script; never
+  hand-edit the `.txt`.
+
+## CI
+
+Four workflows, all in `.github/workflows/`:
+
+- `ubuntu-tests.yml` — pytest on Python 3.10 through 3.14
+- `windows-tests.yml` — pytest on Python 3.10, 3.13
+- `pre-commit.yml` — the hooks above
+- `packaging.yml` — builds a wheel from a `.git`-less tree, installs it into a clean venv and
+  imports it from another directory. `pytest` runs from the repository root and therefore tests
+  the working tree, never the built artifact; this is the only job that does. Any new data file
+  must be added to `[tool.setuptools.package-data]` or it will fail here.
+
+Publishing and deployment workflows are intentionally absent. Do not add them without the
+required Patch-owned registries, infrastructure and secrets.
+
+## Workflow
+
+Finish each task completely before starting the next one. A task is not done when the
+code works — it is done when the docs match and the work is committed.
+
+1. Make the change and get the tests passing (`pytest`).
+2. Run `pre-commit run --all-files`. All five hooks must pass.
+3. Update every doc the change touches, in the same pass — not as a follow-up:
+   - `CHANGELOG.md` under `## [Unreleased]`, in the right subsection (`Added`,
+     `Changed`, `Fixed`, `Removed`, `Security`). This file records doc-only changes
+     too, so a docs commit still gets an entry. Describe what changed for the reader,
+     not which files were edited.
+   - `README.md` when installation, usage, security boundaries, or supported
+     versions change.
+   - `CONTRIBUTING.md` when setup, testing, dependencies, or the release process change.
+   - This file when the layout, tooling, or conventions change.
+   A released `## [X.Y.Z]` section is not a scratchpad: its text is mirrored in the annotated
+   git tag and the GitHub release, so do not reword or restructure it. Adding an entry for
+   something that genuinely shipped in that release is the one allowed edit — correcting an
+   omission is not rewriting history — and it comes with updating that release's body on
+   GitHub (`gh release edit`) in the same task. Leave the tag message alone; re-tagging a
+   published tag is worse than a tag message that trails the file.
+4. Commit the code and its doc updates together, in one commit per task. Do not
+   batch several tasks into one commit, and do not leave a task's docs for later.
+
+## Conventions
+
+- Match the surrounding style rather than importing a new one. The codebase is
+  plain Python with light comments and no type annotations in most modules.
+- Tests are a mix of `unittest.TestCase` classes (about half the files in
+  `tests/basic/`) and plain pytest functions. Follow whichever style the file
+  you are editing already uses.
+- Commits follow Conventional Commits (`feat:`, `fix:`, `docs:`, `chore:`), as
+  seen in recent history.

patch_chat-0.2.0/AUDIT_PROMPT.md

@@ -0,0 +1,314 @@
+# Full Codebase Audit — Prompt
+
+The reusable brief for a full-repository audit of Patch. Three have been run
+([`AUDIT_REPORT.md`](AUDIT_REPORT.md)); this file exists so the fourth starts from what the first
+three learned rather than from a blank page.
+
+Read [Before you start](#before-you-start) and [Already disproved](#already-disproved) first. They
+are the difference between a useful round and one that re-derives what is already known.
+
+---
+
+## The brief
+
+You are a senior Python engineer performing a comprehensive audit of this entire codebase.
+
+Identify real problems: correctness bugs, architectural weaknesses, maintainability issues, security
+risks, performance problems, and opportunities to delete complexity.
+
+**Do not modify the repository during the audit.** Inspect, understand, and report. Remediation is a
+separate pass with its own commits.
+
+---
+
+## Before you start
+
+Five rules, each of which came from a specific failure in an earlier round.
+
+### 1. Trace callers before reporting anything
+
+Round three nearly reported `git_cherry_pick_osr_onto_o` as a thread-safety hazard — it calls
+`os.chdir` process-wide during edit application, with watcher threads live. It is unreachable:
+`udiff_coder.py` builds its own strategy list and never uses the table that references it. The
+finding would have been wrong, and confidently so.
+
+Before writing a finding: find the callers, confirm the path is reachable, and check whether a guard
+already exists somewhere you have not looked.
+
+### 2. Verify by execution, not by reading
+
+Anything you would call Critical or High should be reproduced by running the tree's own code in a
+scratch directory **outside** the repository. Quote the output in the finding.
+
+The three top findings of round three each had a probe:
+
+```
+args.env_file        = ./evil.env
+OPENAI_API_BASE      = https://attacker.example
+args.test_cmd        = touch /tmp/pwned
+after sanitize_repo_config:
+args.test_cmd        = touch /tmp/pwned      <-- not stripped
+```
+
+Mark such findings **verified**. Findings you are confident about but did not execute are
+**confirmed by reading** — say which.
+
+### 3. Look for the recurring shape
+
+Every Critical finding across three audits has been the same thing: **a guard that exists, is right,
+and is missing from one call site.**
+
+| Round | Policy | Was missing at |
+| --- | --- | --- |
+| 2 | Repository config is untrusted | `.patch.model.settings.yml` |
+| 2 | Redirect vars are denied | the yaml layer's `set-env` |
+| 2 | `--dry-run` performs no side effects | `dirty_commit` |
+| 2 | Writes stay inside the root | read-only paths |
+| 3 | Repository config is untrusted | `env-file` |
+| 3 | Home is distinguishable from the repo | the project's own Docker image |
+| 3 | Writes stay inside the root | `/add` under `--no-auto-commits` |
+| 3 | A failure is not a result | `apply_updates`' `OSError` branch, `summarize_worker` |
+
+So: for each policy the code claims to enforce, enumerate *every* place it should apply and check
+each one. That is a more productive search than reading files in order.
+
+Several of these now have enforcement — `patch/repo_trust.py` is a chokepoint with a test that
+enumerates the argument parser, and `Coder.write_edited_file` is the single write gate. **Test those
+mechanisms rather than trusting them.** Each was written in response to a finding and has not yet
+survived an audit it did not author.
+
+### 4. Distrust green gates
+
+Four round-two findings were behaviours the suite actively reported as working. One test passed only
+because it first set the global that hid the bug.
+
+Ask what each gate does *not* cover:
+
+- `pytest` runs from the repository root, so `import patch` resolves to the working tree. Only
+  `packaging.yml` exercises the built artifact.
+- mypy covers 29 of 81 modules. `commands.py` and every coder are outside it.
+- Gate results are per-platform. The fourth round recorded a green run while the
+  Windows job was red: `pexpect.spawn` does not exist there, and nothing in a
+  Linux-only run says so. Check the CI matrix, not just your own machine.
+- `check_untyped_defs` is on, with three named exceptions (`base_coder.py`, `models.py`, `io.py`).
+- Coverage is reported, not gated.
+
+### 5. Record what you disprove
+
+Add to [Already disproved](#already-disproved) below. A candidate you investigated and rejected is
+worth as much to the next round as one you confirmed, and costs nothing to write down.
+
+---
+
+## Scope
+
+Everything: source, tests, `pyproject.toml`, the four lock files, `docker/Dockerfile`, the four
+GitHub workflows, `.pre-commit-config.yaml`, `scripts/`, `benchmark/`, and the docs.
+
+Trace the main execution path rather than reading files in isolation:
+
+```
+main() → build_config() → RepoTrust layers → setup_model()
+       → Coder.create() → Coder.run() → send_message()
+       → get_edits() → allowed_to_edit() → apply_edits() → write_edited_file()
+       → lint → test → auto_commit
+```
+
+`AGENTS.md` has the module layout. Determine what the application does, its module boundaries, how
+configuration and secrets are handled, and how it is built, tested, typed, packaged and deployed.
+
+### What to look for
+
+**Correctness** — logic errors, broken edge cases, swallowed exceptions, mutable default arguments,
+shared mutable state, resource leaks, incorrect context-manager use, races, thread-safety, deadlocks,
+timeout and retry behaviour, datetime/timezone handling, encoding, path handling, platform
+assumptions, `None` handling, generator exhaustion, identity-vs-equality, object lifetime and caching.
+
+**Python quality** — functions and classes doing too much, unnecessary abstraction, circular or
+dynamic imports, excessive `Any`, misleading annotations, dataclass and property misuse, fragile
+monkey-patching, incorrect dunders, deep nesting, duplication, dead code, compatibility shims that
+have outlived their Python version.
+
+**Architecture** — separation of concerns, coupling, hidden dependencies, leaky abstractions, god
+objects, business logic mixed with transport, configuration mixed with runtime, dependency
+direction, duplicated domain concepts, missing abstractions where duplication is real. Do not
+recommend enterprise-style abstractions without a concrete benefit.
+
+**Reliability** — exception boundaries and types, retries, timeouts, cleanup, partial failures,
+transaction boundaries, idempotency, graceful shutdown, startup failures, recovery. Flag anywhere an
+error is logged and execution continues in an invalid state, and anywhere a failure is
+indistinguishable from a result.
+
+**Security** — hardcoded secrets, committed credentials, unsafe environment handling, command and
+SQL injection, path traversal, unsafe temp files and archive extraction, SSRF, auth mistakes,
+missing permission checks, cryptographic misuse, unsafe deserialization, `pickle` and `yaml.load`
+with untrusted input, `eval`/`exec`, insecure subprocess use, missing TLS verification, secrets in
+logs, dependency risk. **Distinguish exploitable from theoretical.**
+
+**Dependencies and packaging** — unused, duplicate, or heavyweight dependencies, poor pinning,
+version conflicts, misplaced dev dependencies, deprecated APIs, Python-version compatibility,
+packaging mistakes, imports that only work from the repository root. Note where a dependency could
+be replaced by the standard library *if that would materially simplify things*.
+
+**Performance** — accidental quadratic behaviour, repeated expensive work, repeated I/O, loading
+whole datasets needlessly, poor data structures, blocking calls in concurrency-sensitive paths,
+unbounded queues, caches and accumulation, excessive logging in hot paths. Measure before claiming;
+do not report micro-optimisations.
+
+**Typing** — incorrect or inconsistent annotations, excessive `Any`, wrong optionality, unsafe
+casts, `# type: ignore` hiding defects, poor protocol boundaries, models that permit invalid states.
+Assess whether the gate is *useful*, not merely present.
+
+**Tests** — what is actually covered, which behaviour has none, whether failure paths are exercised,
+determinism, order dependence, mocks hiding integration problems, tests asserting implementation
+details rather than behaviour, fixture leakage, isolation of external services. Identify the
+**highest-value missing tests** — ranked by the blast radius of what would break undetected, not by
+coverage percentage.
+
+**Observability** — log levels, structure, failure context, secrets in logs, repeated errors,
+failures that cannot be diagnosed from what is emitted.
+
+**Configuration** — precedence, defaults, validation, dev-vs-production behaviour, missing or
+malformed handling. Configuration errors should fail early with a useful message.
+
+**CI/CD** — tests that do not actually run, missing Python versions, caching, reproducibility,
+deployment despite failed checks, secrets exposure, missing gates, CI-vs-production drift.
+
+---
+
+## Output
+
+### The report
+
+Append a new section to `AUDIT_REPORT.md`, matching the existing structure:
+
+- `# Nth Audit — commit <sha>`, with the tree state (LOC, test count, gate results)
+- Remediation status tables — severity summary, then per-finding
+- Audit scope and method
+- Executive summary: the biggest risks, the systemic theme if there is one, what to fix first
+- Findings, grouped `CRITICAL` / `HIGH` / `MEDIUM` / `LOW`
+- Prioritised remediation plan: fix immediately / soon / refactor when convenient / optional
+- Highest-value missing tests
+- Positive findings
+- **Disproved during this audit**
+- Ratings
+
+Update the table at the top of the file and add a row for the round.
+
+### Finding format
+
+Continue the `F-N` sequence (three audits have used F-1 – F-97). Each finding:
+
+```markdown
+#### F-98 · One-line statement of the defect
+
+**Severity:** Critical | High | Medium | Low · **Category:** Security · **Confidence:** verified
+**Location:** `patch/main.py:302-340`, `:787-796`
+
+**Problem.** What is wrong.
+
+**Evidence.** The code, and the probe output if you ran one.
+
+**Impact.** What can happen because of it.
+
+**Recommendation.** The smallest sensible fix.
+```
+
+**Do not report an issue unless you can explain why it matters.** Line numbers go stale — cite the
+commit you audited.
+
+### Issues
+
+Open one GitHub issue per finding, matching the existing convention (see #80–#111):
+
+- Title: `Severity: short description`
+- Body: `**Severity:** X · **Audit ref:** F-N` then `## Problem` / `## Evidence` (or
+  `## Reproduction`) / `## Impact` / `## Fix`, plus `## Test` where the missing test is the actual
+  root cause
+- Labels: `bug` (or `enhancement`), `security` where applicable, and the severity label
+
+### Ratings
+
+Rate 1–10, with one sentence of reasoning each: Correctness, Security, Architecture,
+Maintainability, Test quality, Type safety, Performance, Production readiness. Then an overall score.
+
+Compare against the previous round's column. **If a dimension did not move, say so and why** — an
+unchanged rating with an honest reason is more useful than a rounded-up one.
+
+---
+
+## Rules
+
+- Do not modify the repository during the audit.
+- Do not assume something is broken because it looks unusual.
+- Trace callers and confirm reachability before reporting.
+- Search for existing safeguards before claiming one is missing.
+- Distinguish confirmed bugs from potential risks.
+- Consolidate findings with a common root cause; do not produce dozens of duplicates.
+- Avoid generic style complaints and cosmetic preferences.
+- Prefer deleting complexity over adding abstraction.
+- Do not recommend large rewrites without strong justification.
+- Be skeptical of your own findings and try to disprove them before including them.
+
+---
+
+## Baseline at `5d6ad03b6`
+
+What a clean run looks like today. If any of these has regressed, that is itself a finding.
+
+| | |
+| --- | --- |
+| Source | 81 modules, 21,292 lines |
+| Tests | 50 files, 15,209 lines — **674 passed**, 2 skipped on POSIX / 3 on Windows |
+| `flake8` | clean over `patch tests scripts benchmark` |
+| `mypy` | clean over 29 of 81 modules, `check_untyped_defs` on with 3 exceptions |
+| `black` / `isort` / `codespell` | clean |
+| Coverage | 67% overall |
+| Findings | F-1 – F-106 across four rounds, all resolved |
+
+Coverage is weakest where it matters most: `report.py` 40%, `linter.py` 43%, `utils.py` 46%,
+`commands.py` 60%. `utils.py` contains `path_is_within`, the containment primitive the entire write
+gate rests on.
+
+Run the gates yourself before starting — do not trust this table.
+
+```bash
+pytest -q
+pre-commit run --all-files
+pytest -q --cov=patch --cov-report=term
+```
+
+---
+
+## Already disproved
+
+Investigated in an earlier round and rejected. Re-check if the code has changed, but do not re-derive
+these from scratch.
+
+| Candidate | Why it is not a finding |
+| --- | --- |
+| The 120s command timeout | **Was open, now fixed.** It applied to `/run`, `/test` and `--test-cmd` with no way to raise it, and this repository's own suite takes ~150s -- so `patch --test-cmd pytest` here was killed at 120s, and `--auto-test` reported the timeout to the model as a test failure to fix. `--command-timeout SECONDS` now raises it and `0` removes it. Kept here as the shape to look for: a safety limit with no escape hatch. |
+| `Coder.commit_before_message` as shared class state | Declared `list[str] = []` at class level, but rebound in `__init__`, so the class attribute is never mutated. |
+| `git_cherry_pick_*` chdir-ing the process during edit application | `GitTemporaryDirectory` does `os.chdir`, which would be a real race against the watcher threads — but the strategy tables referencing it were unreachable, and are now deleted. |
+| `diff-match-patch` as an unused dependency | Reached only from dead functions at three sites, but live `diff_lines` uses it. |
+| `RepoMap.token_count` dividing by zero | `lines[::step]` always includes `lines[0]`, so the sample is never empty. |
+| `cmd_add`'s "Directory X is not in git" branch as unreachable | Reachable for a plain existing directory whose glob matches nothing. |
+| `scrape_with_httpx` missing a timeout | `httpx.Client` applies its own 5s default. |
+| The `F824` in `onboarding.py` as a live CI failure | The pinned flake8 did not flag it; only a newer one did. Since fixed. |
+
+---
+
+## Where the previous rounds landed
+
+Context for judging whether a theme is recurring or resolved.
+
+| Round | Commit | Findings | Overall |
+| --- | --- | --- | --- |
+| First | `425cb623c` | F-1 – F-41 | 8.3 after remediation |
+| Second | `d6146ea7c` | F-42 – F-76 | 5.0 at audit |
+| Third | `95ed59940` | F-77 – F-97 | 6.5 at audit, 8.8 after remediation |
+
+The second round scored *lower* than the first's post-remediation figure. That was not a regression:
+it reflected the first round's scope being narrower than its "all resolved" status suggested. Expect
+the same of this file — a fourth round scoring below 8.8 most likely means the third round's scope
+was narrower than it looked, which is the useful thing to find out.