commitguardian 0.1.0__tar.gz → 0.1.2__tar.gz

{commitguardian-0.1.0 → commitguardian-0.1.2}/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
 [Semantic Versioning](https://semver.org/).
 
+## [Unreleased]
+
+## [0.1.2] - 2026-09-19
+
+### Fixed
+
+- `remediation.fix_on_push` did nothing for `git push origin HEAD` or
+  `git push origin HEAD:main`. For those forms Git reports the local ref as plain
+  `HEAD`, which the "only move local branches" guard did not recognise, so the
+  push was blocked instead of cleaned (safely - nothing was rewritten or sent).
+  `HEAD` is now resolved to the checked-out branch when that branch's tip is the
+  commit being pushed; a detached `HEAD` is still refused. Found by testing the
+  released 0.1.1 package on a real machine.
+
+## [0.1.1] - 2026-09-19
+
+### Added
+
+- **`remediation.fix_on_push`** (opt-in, off by default): the `pre-push` hook
+  removes AI, bot and agent attribution from *unpushed* commits that never
+  passed through `commit-msg` - made with `git commit --no-verify`,
+  `git cherry-pick`, `git rebase`, `git am`, or tools that skip hooks - then
+  stops that push so the next `git push` sends the cleaned commits (a hook
+  cannot change what a push in progress sends). Only the message changes: the
+  tree, author, committer and timestamps are copied byte for byte, and the
+  originals stay in the reflog. It refuses, and blocks as before, for any
+  commit a remote-tracking branch contains, tags, signed commits, identity
+  findings, a message that would be left empty, or an unfinished rebase, merge,
+  cherry-pick, revert or bisect; if any commit cannot be fixed, none are
+  rewritten; and nothing moves unless every rewritten commit re-analyses clean.
+  Branches move atomically with a compare-and-swap. `commitguard doctor` warns
+  while it is on, and a mandatory policy cannot enable it. Each of these guards
+  is covered by a test that fails when the guard is removed.
+
+### Changed
+
+- The blocked-push message no longer says "CommitGuard never modifies
+  commits", which is not true when `fix_on_push` is enabled. It now says the
+  commits were not changed and points to the setting.
+
 ## [0.1.0] - 2026-09-18
 
 ### Packaging

{commitguardian-0.1.0 → commitguardian-0.1.2}/CITATION.cff

@@ -22,5 +22,5 @@ keywords:
   - ai-attribution
   - software-supply-chain
 license: MIT
-version: 0.1.0.dev0
-date-released: "2026-09-17"
+version: 0.1.2
+date-released: "2026-09-19"

{commitguardian-0.1.0 → commitguardian-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: commitguardian
-Version: 0.1.0
+Version: 0.1.2
 Summary: Block AI, bot and agent attribution in Git commits, locally and on GitHub.
 Project-URL: Homepage, https://github.com/oyinlola-tech/commitguard
 Project-URL: Repository, https://github.com/oyinlola-tech/commitguard
@@ -325,8 +325,12 @@ result=BLOCK commits=1 block=1 warn=0 allow=0
 | `1` | blocked by policy (a finding or detector failure evaluated to `block`) |
 | `2` | error: invalid configuration/rules, Git error, bad arguments, unexpected failure (hooks block on errors) |
 
-CommitGuard never modifies commits or rewrites history; remediation is always
-left to the developer.
+By default CommitGuard never modifies commits or rewrites history; remediation
+is left to the developer. Two opt-in settings change that, locally only:
+`remediation.auto_remove` deletes AI attribution from a message before the
+commit is created, and `remediation.fix_on_push` rewrites *unpushed* commits
+that slipped past it (see [configuration](docs/configuration.md#remediation)).
+The GitHub Action and App never rewrite anything.
 
 ## Configuration
 

{commitguardian-0.1.0 → commitguardian-0.1.2}/README.md

@@ -285,8 +285,12 @@ result=BLOCK commits=1 block=1 warn=0 allow=0
 | `1` | blocked by policy (a finding or detector failure evaluated to `block`) |
 | `2` | error: invalid configuration/rules, Git error, bad arguments, unexpected failure (hooks block on errors) |
 
-CommitGuard never modifies commits or rewrites history; remediation is always
-left to the developer.
+By default CommitGuard never modifies commits or rewrites history; remediation
+is left to the developer. Two opt-in settings change that, locally only:
+`remediation.auto_remove` deletes AI attribution from a message before the
+commit is created, and `remediation.fix_on_push` rewrites *unpushed* commits
+that slipped past it (see [configuration](docs/configuration.md#remediation)).
+The GitHub Action and App never rewrite anything.
 
 ## Configuration
 

{commitguardian-0.1.0 → commitguardian-0.1.2}/config/default.yaml

@@ -33,7 +33,11 @@ enforcement:
 # What to do about a violation. By default CommitGuard blocks and leaves the
 # message to you. Set auto_remove: true and the commit-msg hook deletes the
 # offending lines instead, reports what it removed, and lets the commit through.
-# Attribution in the author or committer identity still blocks: no edit to the
-# message can fix that. `commitguard doctor` shows when this is on.
+# Set fix_on_push: true and pre-push also rewrites unpushed commits that skipped
+# commit-msg (--no-verify, cherry-pick, rebase), then asks you to push again; it
+# never touches a commit any remote already has. Attribution in the author or
+# committer identity always blocks: no edit to the message can fix that.
+# `commitguard doctor` shows when either is on.
 # remediation:
 #   auto_remove: true
+#   fix_on_push: true

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/api/README.md

@@ -5,7 +5,7 @@ dashboard is built on it. It exposes repositories, scans, violations, policies
 and their governance, exceptions, audit events, notifications and GitHub
 installations. The same process also receives GitHub webhooks.
 
-> **Stability.** CommitGuard is pre-alpha (`0.1.0`, "Development Status :: 2
+> **Stability.** CommitGuard is pre-alpha (`0.1.2`, "Development Status :: 2
 > - Pre-Alpha"). The API is versioned `v1` in its path, but no compatibility
 > promise exists yet. Endpoints, fields and error codes can change between
 > commits. There is no OpenAPI document; these pages, the view models in

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/cli/doctor.md

@@ -60,7 +60,7 @@ commitguard doctor --json
 
 ```json
 {
-  "commitguard_version": "0.1.0",
+  "commitguard_version": "0.1.2",
   "status": "HEALTHY",
   "enforcement": "LOCAL ENFORCEMENT ONLY",
   "counts": {"PASS": 14, "INFO": 1, "NOT CONFIGURED": 2, "WARNING": 0, "FAIL": 0},

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/configuration.md

@@ -73,7 +73,8 @@ never treated as a fully protected state.
 
 ```yaml
 remediation:
-  auto_remove: false   # default
+  auto_remove: false   # default: remove attribution before a commit is created
+  fix_on_push: false   # default: rewrite unpushed commits that slipped past it
 ```
 
 By default CommitGuard blocks a violating commit and leaves the message to you.
@@ -98,17 +99,68 @@ The stripped message is re-analysed before the commit is allowed. If it is still
 blocked, the original block stands: nothing is ever allowed on the assumption
 that the removal worked.
 
-Two deliberate constraints:
+A mandatory policy cannot set either option. A floor may only make enforcement
+stricter, and both turn a block into something that proceeds, so `remediation:`
+in a mandatory policy is a configuration error.
 
-* **`pre-push` is unaffected.** By then the commits exist, and correcting them
-  means rewriting history. CommitGuard never does that on its own; it blocks and
-  tells you which commits to amend or reword.
-* **A mandatory policy cannot set it.** A floor may only make enforcement
-  stricter, and `auto_remove` turns a block into a commit, so
-  `remediation:` in a mandatory policy is a configuration error.
+### `fix_on_push`: commits the commit-msg hook never saw
 
-`commitguard doctor` reports `! WARNING  remediation.auto_remove is on` whenever
-it is enabled, because it changes a block into a commit.
+`auto_remove` only sees commits made with `git commit`. These create commits
+without running `commit-msg`, so their attribution reaches `pre-push` intact:
+
+| How the commit was made | Cleaned by `auto_remove`? |
+|---|---|
+| `git commit`, `git commit --amend`, `git merge` | yes |
+| `git commit --no-verify` | no |
+| `git cherry-pick`, `git rebase`, `git am` | no |
+| tools that create commits without running hooks | no |
+
+With `fix_on_push: true`, the `pre-push` hook rewrites those commits' messages
+to remove the attribution. **It then stops that push.** Git decides which
+objects a push sends before the hook runs, so the push in progress would still
+carry the old commits; the next `git push` sends the cleaned ones:
+
+```
+$ git push
+CommitGuard
+! CLEANED 2 unpushed commits (AI attribution removed; history rewritten)
+
+  e70fd0f -> 23acf33  feat: two
+      removed: Co-Authored-By: Claude <noreply@anthropic.com>  [ai_coauthor]
+  d91e62b -> 06d7cc6  feat: three
+
+  Only commits that no remote has were changed; the old ones are in
+  `git reflog`. Branch updated: main.
+
+  This push was stopped (Git had already chosen what to send).
+  Run `git push` again to send the cleaned commits.
+
+$ git push
+CommitGuard: ✓ 3 outgoing commits checked, no policy violations
+```
+
+This rewrites history, so it is deliberately narrow. It does nothing - and the
+push is blocked as usual - unless every one of these holds:
+
+* **No remote has the commits.** A commit contained in *any* remote-tracking
+  branch, not only the one you are pushing to, has been shared and is never
+  rewritten.
+* **Only a local branch is being pushed.** Tags are never touched.
+* **Every blocking finding is a message line.** An AI author or committer still
+  blocks. If any commit cannot be fixed, *none* are rewritten.
+* **No commit is signed** (`gpgsig`, `mergetag`), since rewriting would silently
+  drop the signature, and none carries a header CommitGuard does not recognise.
+* **No rebase, merge, cherry-pick, revert or bisect is in progress.**
+* **Every rewritten commit re-analyses clean.** Nothing moves on assumption.
+
+Only the message changes. The tree, author, committer and both timestamps are
+copied byte for byte, so your working tree and index are untouched. Commits
+after a cleaned one get new IDs because their parent changed; commits before it
+keep theirs. Branches move atomically, and only if they still point where they
+did when the push began. The originals stay in `git reflog`.
+
+`commitguard doctor` reports a warning whenever either option is on, because
+each changes a block into something that proceeds.
 
 ## Validation (security-relevant)
 

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/deployment/README.md

@@ -1,6 +1,6 @@
 # Deploying CommitGuard
 
-CommitGuard 0.1.0 is pre-alpha software. This section describes the ways it
+CommitGuard 0.1.2 is pre-alpha software. This section describes the ways it
 can be deployed today, what each way protects against, and what it does not.
 Every mode runs the same detection engine and policy evaluator; they differ in
 where the check runs, who controls it, and whether it can prevent a merge.

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/deployment/local.md

@@ -25,7 +25,7 @@ and `commitguard-cli` on PyPI are unrelated projects.)
 
 ```bash
 pipx install commitguardian
-commitguard --version        # commitguard 0.1.0
+commitguard --version        # commitguard 0.1.2
 
 # or pinned to an exact commit:
 pipx install "git+https://github.com/oyinlola-tech/commitguard@<commit-sha>"

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/deployment/production.md

@@ -1,6 +1,6 @@
 # Running the App service in production
 
-> Status: **Experimental.** CommitGuard is pre-alpha (0.1.0).
+> Status: **Experimental.** CommitGuard is pre-alpha (0.1.2).
 > No external production deployments have been recorded yet.
 > The App service and organization governance have been validated only by this
 > repository's test suites, against an offline model of GitHub. There are no

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/deployment/troubleshooting.md

@@ -30,7 +30,7 @@ repository. Uninstall it and install from source, pinned to a commit:
 ```bash
 python -m pip uninstall commitguard
 pipx install "git+https://github.com/oyinlola-tech/commitguard@<commit-sha>"
-commitguard --version      # commitguard 0.1.0
+commitguard --version      # commitguard 0.1.2
 ```
 
 **`the GitHub App needs the optional dependencies: pip install 'commitguard[app]'`**

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/git-hooks.md

@@ -111,7 +111,7 @@ Allowed: 1
     Evidence: Claude <noreply@anthropic.com> (Co-authored-by trailer, line 3)
 ...
 How to fix:
-  CommitGuard never modifies commits. ...
+  CommitGuard did not change these commits. ...
 No changes were pushed to the remote repository.
 ```
 
@@ -266,8 +266,15 @@ CommitGuard
 ```
 
 It is off by default and never applies to identity-based findings, which cannot
-be fixed by editing text. `pre-push` never removes anything. See
-[configuration.md](configuration.md#remediation) for the full rules.
+be fixed by editing text. See [configuration.md](configuration.md#remediation)
+for the full rules.
+
+Commits made with `git commit --no-verify`, `git cherry-pick`, `git rebase` or
+`git am` skip `commit-msg`. `remediation.fix_on_push: true` makes `pre-push`
+rewrite those *unpushed* commits' messages and stop the push, so the next
+`git push` sends the cleaned commits. It never touches a commit any remote
+already has, tags, signed commits or identity findings; see
+[configuration.md](configuration.md#fix_on_push-commits-the-commit-msg-hook-never-saw).
 
 ## Doctor
 

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/maintainers/release-process.md

@@ -29,7 +29,7 @@ Artifacts are not signed, and no build provenance attestation is generated.
 | Runtime version (`commitguard --version`) | `src/commitguard/__init__.py`, `__version__` |
 | Dashboard package version | `web/package.json` (`"private": true`, not released separately; currently `0.1.0`, independent of the Python version) |
 
-Both Python locations must be changed together; today they both say `0.1.0`.
+Both Python locations must be changed together; today they both say `0.1.2`.
 `tests/integration/git/test_cli_commands.py` checks that `commitguard --version`
 prints `__version__`; no test compares it with `pyproject.toml`, so check both by
 hand. The name in `pyproject.toml` is pinned by
@@ -234,6 +234,40 @@ Marketplace shows the tag, so a release candidate must not be listed - which is
 why the workflow leaves an `rc` tag as a **draft prerelease** and only publishes
 a final tag.
 
+## When a release only half-finishes
+
+The first real tag, `v0.1.0`, exposed two faults at once. Both are fixed; this
+is what to do if a release stops partway.
+
+**Symptom:** the tag exists, the GitHub release exists, but PyPI has nothing.
+
+**Cause 1 - the build job imported the package it had just built.** It ran
+`python -c "import commitguard"` from inside `dist/`, where the package is
+neither installed nor on the path. The gate installs the package, so the gate
+passed and the build failed. The version now comes from the wheel filename.
+
+**Cause 2 - the release job assumed it was the one creating the release.**
+Listing an Action on the Marketplace *requires* a published release, and the
+web form creates the tag and the release together - which triggers this
+workflow, which then found the release already there. `gh release create`
+failed, so `publish` never ran. The job now creates **or updates**: it uploads
+the artifacts to the existing release with `--clobber`, and leaves hand-written
+notes alone.
+
+**To finish a stalled release, do not move or reuse the tag.** Run the workflow
+manually against it:
+
+> Actions -> Release -> Run workflow -> *Use workflow from:* `main`
+> -> *ref:* `v0.1.0`
+
+The workflow definition comes from `main` (so you get the fixes) while the code
+built comes from the tag (so you release what you tagged). The gate still
+checks that the tag matches `__version__`, the release job attaches the missing
+artifacts, and `publish` uploads to PyPI.
+
+Passing a commit SHA instead of a tag stays a dry run: it builds and tests, and
+skips both the release and the publish.
+
 ## Manual release checklist
 
 - [ ] CI, Security and CommitGuard workflows green on the tagged commit

{commitguardian-0.1.0 → commitguardian-0.1.2}/docs/security/threat-model.md

@@ -706,9 +706,15 @@ not file contents) of repositories while they are installed. See
 - Detectors receive data, not a repository handle; architecture tests forbid
   I/O imports in detection layers **[done]**.
 - Git reads use `GIT_OPTIONAL_LOCKS=0` **[done]**.
-- CommitGuard never rewrites commits or history; it never runs `git reset`,
-  `rebase`, `commit --amend`, `filter-branch` or `filter-repo`. Remediation
-  text explains the scope of any command it suggests **[by design]**.
+- CommitGuard never runs `git reset`, `rebase`, `commit --amend`,
+  `filter-branch` or `filter-repo`, and by default never rewrites commits or
+  history. The one exception is opt-in: with `remediation.fix_on_push`, the
+  `pre-push` hook rewrites the *message* of unpushed commits. It refuses any
+  commit a remote-tracking branch contains, tags, signed commits, identity
+  findings and in-progress rebases or merges; moves branches atomically with a
+  compare-and-swap; re-analyses every rewritten commit before moving anything;
+  and leaves the originals in the reflog. The server side (Action, App) never
+  rewrites anything **[by design; `tests/integration/hooks/test_pre_push.py`]**.
 - `init` never overwrites an existing file **[done]**.
 
 ## Maintaining this document

{commitguardian-0.1.0 → commitguardian-0.1.2}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "hatchling.build"
 # "commitguard-cli", belong to two unrelated projects (see docs/adr/009). The
 # import package and the console script stay `commitguard`.
 name = "commitguardian"
-version = "0.1.0"
+version = "0.1.2"
 description = "Block AI, bot and agent attribution in Git commits, locally and on GitHub."
 readme = "README.md"
 license = "MIT"

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/__init__.py

@@ -21,6 +21,6 @@ Package layout (dependency direction flows downwards only)::
     utils        -> subprocess / filesystem / platform helpers
 """
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 
 __all__ = ["__version__"]

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/cli/commands/doctor.py

@@ -182,7 +182,8 @@ def _hook_checks(repository: Repository, loaded: LoadedConfig | None) -> list[Ch
                     "set enforcement." + name.replace("-", "_") + ": true",
                 )
             )
-    if loaded is not None and build_remediation(*loaded.configs).auto_remove:
+    remediation = build_remediation(*loaded.configs) if loaded is not None else None
+    if remediation is not None and remediation.auto_remove:
         # This turns a blocked commit into a commit. It must never be invisible.
         checks.append(
             Check(
@@ -193,6 +194,17 @@ def _hook_checks(repository: Repository, loaded: LoadedConfig | None) -> list[Ch
                 "set remediation.auto_remove: false to block instead",
             )
         )
+    if remediation is not None and remediation.fix_on_push:
+        checks.append(
+            Check(
+                "Enforcement",
+                Status.WARN,
+                "remediation.fix_on_push is on: pre-push rewrites unpushed commits to remove "
+                "prohibited attribution, then asks you to push again (never commits a remote "
+                "already has; identity findings still block)",
+                "set remediation.fix_on_push: false to block instead",
+            )
+        )
     return checks
 
 

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/cli/commands/hook.py

@@ -28,6 +28,7 @@ from commitguard.services.hooks import (
     run_pre_commit,
     run_pre_push,
 )
+from commitguard.services.push_fix import PushFix
 
 MAX_PRE_PUSH_STDIN_BYTES = 8 * 1024 * 1024
 
@@ -86,6 +87,35 @@ def _removal_notice(run: HookRun) -> str:
     return "\n".join(lines)
 
 
+def _push_fix_notice(fixed: PushFix) -> str:
+    """What ``remediation.fix_on_push`` rewrote. Always shown in full: it
+    changed commits the developer made."""
+    count = len(fixed.commits)
+    lines = [
+        "CommitGuard",
+        f"! CLEANED {count} unpushed commit{'s' if count != 1 else ''} "
+        "(AI attribution removed; history rewritten)",
+        "",
+    ]
+    for commit in fixed.commits:
+        subject = sanitize_block(commit.subject, max_length=72)
+        lines.append(f"  {commit.old_sha[:7]} -> {commit.new_sha[:7]}  {subject}")
+        lines += [
+            f"      removed: {sanitize_block(r.text, max_length=200)}  [{r.rule_id}]"
+            for r in commit.removed
+        ]
+    branches = ", ".join(ref.removeprefix("refs/heads/") for ref in fixed.branches)
+    lines += [
+        "",
+        "  Only commits that no remote has were changed; the old ones are in",
+        f"  `git reflog`. Branch updated: {branches}.",
+        "",
+        "  This push was stopped (Git had already chosen what to send).",
+        "  Run `git push` again to send the cleaned commits.",
+    ]
+    return "\n".join(lines)
+
+
 def _finish(run: HookRun, text: str) -> None:
     if not run.enabled:
         _err(
@@ -95,6 +125,10 @@ def _finish(run: HookRun, text: str) -> None:
         return
     if run.removed:
         _err(_removal_notice(run))
+    if run.fixed is not None:
+        # The commits being pushed are the old ones: this push must not proceed.
+        _err(_push_fix_notice(run.fixed))
+        raise typer.Exit(code=int(ExitCode.BLOCKED))
     _err(text)
     if run.report is not None and run.report.action is Action.BLOCK:
         raise typer.Exit(code=int(ExitCode.BLOCKED))

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/cli/render.py

@@ -153,13 +153,15 @@ def render_check_text(report: ScanReport) -> str:
 # --------------------------------------------------------------------------- #
 _PUSH_REMEDIATION = [
     "How to fix:",
-    "  CommitGuard never modifies commits. Rewrite the blocked commits so they no",
-    "  longer carry the attribution, then push again:",
+    "  CommitGuard did not change these commits. Rewrite the blocked commits so",
+    "  they no longer carry the attribution, then push again:",
     "  - latest commit only:  git commit --amend",
     "      (replaces that one local commit with an edited copy)",
     "  - older commits:       git rebase -i <commit>^   and mark them 'reword'",
     "      (recreates the selected commits and every commit after them)",
     "  Only rewrite commits that have not already been shared with others.",
+    "  To have CommitGuard do this for unpushed commits, set",
+    "  remediation.fix_on_push: true (see docs/configuration.md).",
 ]
 
 

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/config/defaults.py

@@ -46,8 +46,12 @@ enforcement:
 # What to do about a violation. By default CommitGuard blocks and leaves the
 # message to you. Set auto_remove: true and the commit-msg hook deletes the
 # offending lines instead, reports what it removed, and lets the commit through.
-# Attribution in the author or committer identity still blocks: no edit to the
-# message can fix that. `commitguard doctor` shows when this is on.
+# Set fix_on_push: true and pre-push also rewrites unpushed commits that skipped
+# commit-msg (--no-verify, cherry-pick, rebase), then asks you to push again; it
+# never touches a commit any remote already has. Attribution in the author or
+# committer identity always blocks: no edit to the message can fix that.
+# `commitguard doctor` shows when either is on.
 # remediation:
 #   auto_remove: true
+#   fix_on_push: true
 """

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/config/enforcement.py

@@ -41,6 +41,7 @@ class Remediation(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     auto_remove: bool = False
+    fix_on_push: bool = False
 
 
 def build_remediation(*configs: CommitGuardConfig) -> Remediation:

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/config/schema.py

@@ -64,13 +64,21 @@ class RemediationOverride(BaseModel):
     it is then clean.
 
     It is off by default, because it edits what the developer wrote.
+
+    ``fix_on_push`` covers the commits ``commit-msg`` never saw (``--no-verify``,
+    cherry-pick, rebase, ``git am``). The ``pre-push`` hook rewrites the
+    *unpushed* commits on the branch to remove the same lines, then stops that
+    push: Git has already chosen which objects to send, so the corrected
+    commits go out on the next ``git push``. This rewrites history, so it is a
+    separate switch and also off by default.
     """
 
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     auto_remove: StrictBool | None = None
+    fix_on_push: StrictBool | None = None
 
-    @field_validator("auto_remove", mode="before")
+    @field_validator("auto_remove", "fix_on_push", mode="before")
     @classmethod
     def _reject_explicit_null(cls, value: object) -> object:
         if value is None:

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/detectors/identity.py

@@ -69,7 +69,7 @@ class IdentityDetector(Detector):
                     commit_sha=commit.sha,
                     remediation=(
                         "Recreate the commit under the responsible human contributor's identity "
-                        "before pushing. CommitGuard never rewrites commits itself."
+                        "before pushing. CommitGuard never changes who authored a commit."
                     ),
                 )
             )

{commitguardian-0.1.0 → commitguardian-0.1.2}/src/commitguard/git/repository.py

@@ -386,6 +386,85 @@ class Repository:
             raise UnsafeInputError(f"{path} at {commit[:12]} is larger than {max_bytes} bytes")
         return self._git(["cat-file", "blob", oid]).stdout
 
+    # ------------------------------------------------------------------ #
+    # Rewriting unpushed commits (remediation.fix_on_push)
+    # ------------------------------------------------------------------ #
+    #: State files that mean a rebase, merge, cherry-pick, revert or bisect is
+    #: in progress. Moving a branch underneath one of those corrupts it.
+    _IN_PROGRESS = (
+        "rebase-merge",
+        "rebase-apply",
+        "MERGE_HEAD",
+        "CHERRY_PICK_HEAD",
+        "REVERT_HEAD",
+        "BISECT_LOG",
+    )
+
+    def operation_in_progress(self) -> str | None:
+        """Name of an unfinished rebase/merge/cherry-pick/revert/bisect, if any."""
+        for name in self._IN_PROGRESS:
+            result = self._git(["rev-parse", "--git-path", name])
+            path = Path(result.stdout.decode("utf-8", errors="replace").strip())
+            if not path.is_absolute():
+                path = self.root / path
+            if path.exists():
+                return name
+        return None
+
+    def read_raw_commit(self, sha: str) -> bytes:
+        """The commit object exactly as stored (headers, blank line, message)."""
+        if not is_git_sha(sha):
+            raise UnsafeInputError("read_raw_commit requires a full commit id")
+        return self._git(["cat-file", "commit", sha]).stdout
+
+    def write_commit_object(self, data: bytes) -> str:
+        """Store a commit object and return its id. Nothing references it yet."""
+        result = self._git(["hash-object", "-t", "commit", "-w", "--stdin"], input_bytes=data)
+        sha = result.stdout.decode("ascii", errors="replace").strip()
+        if not is_git_sha(sha):
+            raise MalformedGitOutputError("git hash-object returned no object id")
+        return sha
+
+    def current_branch(self) -> str | None:
+        """``refs/heads/<name>`` that ``HEAD`` points at, or None when detached."""
+        result = self._git(["symbolic-ref", "--quiet", "HEAD"], check=False)
+        ref = result.stdout.decode("utf-8", errors="replace").strip()
+        return ref if result.ok and ref.startswith("refs/heads/") else None
+
+    def not_on_any_remote(self, shas: Sequence[str]) -> set[str]:
+        """The subset of ``shas`` not reachable from any remote-tracking branch.
+
+        A commit that some remote already has - even a different remote than the
+        one being pushed to - has been shared, and must never be rewritten.
+        """
+        for sha in shas:
+            if not is_git_sha(sha):
+                raise UnsafeInputError("not_on_any_remote requires full commit ids")
+        if not shas:
+            return set()
+        result = self._git(
+            ["rev-list", "--not", "--remotes", "--not", "--end-of-options", *shas, "--"]
+        )
+        reachable = set(result.stdout.decode("ascii", errors="replace").split())
+        return {sha for sha in shas if sha in reachable}
+
+    def move_branches(self, moves: Sequence[tuple[str, str, str]], reason: str) -> None:
+        """Atomically point each ``refs/heads/...`` at a new commit.
+
+        Each move is ``(ref, new, old)`` and applies only if the ref still points
+        at ``old``; either every ref moves or none does. Old commits stay in the
+        reflog.
+        """
+        lines = []
+        for ref, new, old in moves:
+            if not ref.startswith("refs/heads/") or any(ord(c) <= 0x20 for c in ref):
+                raise UnsafeInputError("move_branches only updates local branches")
+            if not (is_git_sha(new) and is_git_sha(old)):
+                raise UnsafeInputError("move_branches requires full commit ids")
+            lines.append(f"update {ref} {new} {old}\n")
+        payload = "start\n" + "".join(lines) + "prepare\ncommit\n"
+        self._git(["update-ref", "-m", reason, "--stdin"], input_bytes=payload.encode("ascii"))
+
     def config_get(self, key: str) -> str | None:
         """Return a Git configuration value, or None if it is unset."""
         validate_git_config_key(key)