Skip to main content
skill CX Codex

re0-squash — Claude Code skill: GitHub history cleanup and install

The re0-squash Claude Code skill condenses a GitHub repository into one signed commit, then recreates its remote. It runs on an explicit request to replace a repository’s history.

MIT 123 installs ★ 1,470 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add LilMGenius/paperthin --skill re0-squash -a claude-code
Open on GitHub

What re0-squash does

The skill replaces a repository’s commit history with one signed commit while keeping the same file tree, then deletes and recreates the GitHub repository with recorded settings. An audit lists local state, remote items and settings before deletion; a human must accept each listed loss. Deletion cannot be undone.

A bundled script, scripts/squash.mjs, handles the audit, squash and republish as separate commands. It requires git with commit signing configured and an authenticated gh with the delete_repo scope. The old history is saved in a verified bundle. Secrets, variables, webhooks, rulesets, deploy keys and collaborators are not restored, while forks and other clones retain old commits.

What it helps with

  • condense a repository’s history into one signed commit
  • remove old commits from a remote GitHub repository
  • save the former history in a bundle before deletion
  • recreate a repository with its recorded settings

Example prompts for the agent

  • Run re0-squash to condense this repository’s history into one commit and recreate its remote.
  • Audit owner/name and show me every loss before deleting the repository.
  • Squash this repository’s history and recreate its GitHub remote after I confirm.

How to install re0-squash

1Skills CLI (Vercel)

npx skills add LilMGenius/paperthin --skill re0-squash -a claude-code

2Manually: put the files in place

~/.claude/skills/re0-squash/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/re0-squash/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about re0-squash

How do I install re0-squash in Claude Code?

Run npx skills add LilMGenius/paperthin --skill re0-squash -a claude-code. The skill file is installed at ~/.claude/skills/re0-squash/SKILL.md.

What does re0-squash do?

It replaces a repository’s history with one signed commit that keeps the same file tree, then deletes and recreates the GitHub repository. A human reviews and accepts the listed losses before deletion.

What does re0-squash need to run?

It needs git with commit signing configured and an authenticated gh with the delete_repo scope. Squashing requires a clean checkout on the default branch, and deletion requires explicit human confirmation.

Source text

SKILL.md · MIT
---
name: re0-squash
description: "Republish a GitHub repository as one signed commit: squash its whole history into one commit with the same tree, then delete the remote and recreate it under the same name and settings, because a force push leaves the old commits reachable by hash, in forks and in pull requests. User-invoked, and the deletion cannot be undone."
disable-model-invocation: true
---

Squash one repository's history into one signed commit with the same tree, then delete its GitHub remote, recreate it with the settings the script records (step 4) and push that one commit.

## Goal

A force push does not clean a GitHub history. GitHub's guide on removing sensitive data says rewritten commits can stay reachable in clones and forks, by hash in cached views, and through pull requests that reference them. Deleting the repository is what drops those objects from it, so this skill squashes every commit into one, deletes the remote, recreates it with the settings it can restore, and pushes the one commit. The tree stays byte-identical; only the record changes.

This is not a restart: nothing is rebuilt and no archive branch keeps the old line on the remote. A restart from v0 is `re0-work`.

It is **user-invoked**: it deletes a remote repository, which cannot be undone, and its trigger is a deliberate human act; a model with it in reach could reach for a delete on its own. Run it when the human names this skill, or asks to squash a repository's history and recreate its remote.

## Workflow

Prerequisites: git with commit signing configured, and gh authenticated with the delete_repo scope. --repo overrides the owner/name read from origin.

The inputs are a clean checkout on the default branch, the commit message the human approves, and the human's acceptance of each loss the audit lists. One bundled script does the work in three subcommands, run from the repository root (the root of the repository being republished; `scripts/squash.mjs` below means the script in this skill's folder, called by its absolute path):

    node scripts/squash.mjs audit [--repo <owner/name>]
    node scripts/squash.mjs squash --message-file <file> [--bundle <path>]
    node scripts/squash.mjs republish --confirm <owner/name> [--accept-loss] [--repo <owner/name>]

Each prints one JSON object. Exit codes: 0 done (audit: no blockers; republish: pushed head matches and no setting drifted); 1 refused or failed (dirty tree, detached HEAD, wrong --confirm, unaccepted blockers, more than one commit, a git or gh call that failed, a pushed head that differs, or a restored setting that drifted); 2 usage; 3 audit found blockers.

1. **Audit.** Run `node scripts/squash.mjs audit [--repo <owner/name>]` on the checkout. Its JSON lists the local state (`local`), every remote item the delete takes (`remote`), the settings republish will restore (`settings`), `blockers` and `notes`. Read every blocker; a remote list gh cannot read is one, since its loss cannot be ruled out. A public fork keeps the old commits after the delete and is out of this skill's reach. **Stop: the human decides.** Brief the human on each blocker, and they accept or decline each loss; one declined loss ends the run here, with nothing squashed. A request to squash is not acceptance of a loss nobody has seen.
2. **Write the message.** When the human wants the squash message to follow the repository's commit standard from an existing message, tell the human to run `/re0-git` before this step; it is user-invoked, so this skill never calls it. Read the repository's documented commit convention and its log first. Write one subject naming what the repository is, a blank line, then one `-` bullet per durable capability on a single unwrapped line saying what it does now. Leave out process history, reverts and renames, which the squash is meant to drop, and any co-author trailer. **Stop: the human decides.** Show the human the message before squashing, and squash only once they approve it; then save the approved message to a file.
3. **Squash.** Run `node scripts/squash.mjs squash --message-file <file> [--bundle <path>]` on the clean checkout. It writes the old history to a verified bundle (in the home folder unless --bundle names a path), the only copy you hold once the remote is gone, and replaces the branch with one commit of the same tree, signed and dated now; its JSON gives the old tip (`old`), the new commit (`new`), `commits`, `signature` and `bundle`. Stop unless `commits` is 1 and `signature` is `G`: the script does not check the signature, and an unsigned or multi-commit result must not be republished.
4. **Republish. This step deletes the GitHub repository, and the deletion cannot be undone.** Every remote item the audit listed goes with it, and from here the bundle from step 3 is the only copy of the old history you hold; forks and other clones still carry it, outside this skill's reach. **Stop: the human decides.** Delete only on an explicit request from the human naming this repository's owner/name in this conversation. To confirm the human's reading of which repository and which losses before the delete, call the Skill tool with "readback" on the owner/name and the list of accepted losses, and delete only once the human confirms that restatement. Run `node scripts/squash.mjs audit` once more and compare its blockers with the ones the human accepted, since republish re-audits but with --accept-loss lets a new blocker pass unreported; a new one goes back to the human. Then run `node scripts/squash.mjs republish --confirm <owner/name> [--accept-loss] [--repo <owner/name>]`, with --confirm repeating owner/name exactly and --accept-loss only when the human accepted every blocker. It audits again, deletes and recreates the repository, restores the recorded settings and pushes the one commit as the default branch; its JSON gives the pushed head (`pushed`), `matchesLocal`, the settings that drifted (`settingsDrift`), what was not restored (`notRestored`) and `ok`.
5. **Close.** Watch the first CI run; if it fails or never starts, report that with its log and treat the republish as incomplete. Tell the human where the bundle is, that it is the only copy of the old history they hold and that it stays until they delete it; that secrets, variables, webhooks, rulesets, deploy keys and collaborators were not restored and must be recreated by hand if kept; and that every other clone must `git fetch` and `git reset --hard origin/<branch>` before it can push again.

When the audit shows blockers the human does not accept, or the human declines at any stop, nothing is squashed or deleted: report the audit and stop. That is a successful run.

## Rules

- Never delete the remote without an explicit request naming this repository in this conversation. --confirm must repeat owner/name exactly.
- Accept no loss on the human's behalf. --accept-loss is passed only after the human accepted every listed blocker in this conversation.
- One branch is republished. Other local branches and tags keep the old commits and are not pushed.
- The squash commit is dated now and signed; it records when the republish happened. Content never changes: `git diff` between the old tip and the new commit is empty.
- A step that fails stops the run. A pushed head that differs or a drifted setting is reported as a failure, never as done.

## Verification

1. The audit ran, and every blocker was briefed to the human and accepted before republish.
2. `git diff <old> <new>` between the old tip and the new commit is empty, the branch holds one commit, and the signature status is `G`.
3. The bundle exists and verifies (`git bundle verify <bundle>`).
4. The republish output shows `matchesLocal` true, `settingsDrift` empty, `ok` true, and the first CI run passed.
5. The human was told the bundle path, what was not restored, and how other clones recover.

© LilMGenius · MIT · LilMGenius/paperthin

Similar skills

All skills for Git and GitHub →

From the same set48

The whole set →
re0-readme re0-readme is a Claude Code skill that audits and aligns a repository's README, AGENTS.md, and manifests. It runs when updating or reviewing documentation. CX Codex +1 126installs demock demock — a Claude Code skill that finds mocks and hidden failures on live code paths. It runs when reviewing changes, integrations, or error handling. CX Codex +1 125installs whychk whychk — a skill for Claude Code and Codex that challenges freshly made choices. An isolated sub-session identifies unstated assumptions, demanding explanations one gap at a time. CX Codex +1 123installs re0-decide re0-decide — a skill for Claude Code that turns proposal materials into a traceable decision instrument without recommending outcomes. CX Codex +1 123installs scopechk scopechk is a Claude Code skill that checks whether an item falls within a target repository scope. Run it before adding or moving a module into a repository. CX Codex +1 123installs re0-import re0-import — a Claude Code skill routes handed-over material into documents in an existing knowledge base. It follows that base’s own routing rules for notes, links, and corrections. CX Codex +1 123installs crossthink crossthink — a skill for Claude Code that borrows operational mechanisms from distant fields when technical options get stuck on a single blocker. CX Codex +1 121installs deid This Claude Code skill finds one person’s or organization’s data in a shared artifact and replaces matches with roles or placeholders. It runs before publication or when a repository needs de-identification. CX Codex +1 121installs

Project sponsors

Companies that keep this analytics open