The verified story behind every change.

{
  "format": "parc",
  "format_version": "0.2.0",
  "arc_id": "arc_8f2c1d4a9b",
  "repository": {
    "default_branch": "main",
    "head_before": "a1b2c3d…",
    "head_after": "f9e8d7c…"
  },
  "files": [
    { "path": "evidence/summary/review.json",
      "size": 4120, "sha256": "9f1c2e…", "kind": "summary" }
  ],
  "totals": { "files": 9, "bytes": 48213, "commits": 4 },
  "trust": { "offline_verifiable": true, "redaction_applied": false }
}

$ patcharc inspect .patcharc/capsules/arc_8f2c1d4a9b.parc
  Capsule:        arc_8f2c1d4a9b
  Format:         0.2.0
  Files:          9 (48213 bytes)
✓ Signature:      true
✓ Manifest:       true
✓ Path traversal: true
✓ Zip-bomb safe:  true
$ patcharc verify .patcharc/capsules/arc_8f2c1d4a9b.parc
✓ arc_8f2c1d4a9b is valid (9 files, 48213 bytes, signed by 3f9a1c7e2b5d…)
$ echo $?
  0

Worked example from a sealed Arc. Fields match evidence/summary/review.json and manifest.json in 0.2.0.

signature on every capsule manifest

Ed25519

signature on every capsule manifest

hash on every file, checked on verify

SHA-256

hash on every file, checked on verify

workspace detectors for monorepo scopes

10

workspace detectors for monorepo scopes

review sections, computed without AI

6

review sections, computed without AI

random ArcLink slugs, 30-day default expiry

96-bit

random ArcLink slugs, 30-day default expiry

accounts needed for the local loop

0

accounts needed for the local loop

$ patcharc init
✓ Initialised PatchArc in ~/src/your-repo
$ patcharc start --detach "Rework sessions"
✓ Arc arc_8f2c1d started on main @ a1b2c3d
# commits, notes, decisions, risks
$ patcharc stop
✓ Arc sealed: .patcharc/capsules/arc_8f2c1d.parc
$ patcharc verify .patcharc/capsules/arc_8f2c1d.parc
✓ arc_8f2c1d is valid (9 files, signed by 3f9a1c7e…)
$ patcharc share --visibility public
✓ Uploaded arc_8f2c1d.parc (48213 bytes)
  ArcLink: https://link.patcharc.dev/a/X9kQ2mN4vR7s

Monorepo-native

Ten workspace detectors (pnpm, npm and yarn workspaces, Nx, Rush, Bazel, go.work, Cargo, Maven, Gradle, .NET) map a change to the packages it touched, or you declare scopes in config.yaml and they win.

Links you can revoke

ArcLink slugs carry at least 96 bits of entropy and expire in 30 days by default. Revoke one and it returns 410; rotate one and the old slug stops resolving immediately. Every share and revoke is an audit event.

Device-flow sign-in

patcharc login opens the approval page, you sign in with GitHub or Google, and the CLI receives its token. Credentials live in ~/.patcharc/credentials.json (0600), separate from the repo. Refresh tokens are hashed at rest and rotated on every use.

Your keys stay sealedlater

Provider keys registered for BYOK are envelope-encrypted: a per-connection AES-256-GCM key wrapped by a versioned master key, decrypted only inside an isolated key service with no public endpoint. No API ever returns a key. AI summaries that use them are not produced yet.

Redaction engine

Thirteen detectors (AWS, GitHub, Slack, Stripe, OpenAI, Anthropic, Google keys, PEM blocks, JWTs, connection strings), env-file rules, and entropy scanning run over every diff when the capsule is sealed. The signed redaction report records what was removed; inspect a capsule before you share it all the same.

Tests become evidence

patcharc run wraps any command: go test, pytest, vitest, jest, playwright, and cargo results are parsed into the review's Verification section, JUnit XML imports with --junit, and the exit code passes through so CI pipelines wrap it safely. An Arc with no recorded tests says so, rather than showing zeros as a clean run.

Knows who wrote what

Commits carrying agent trailers or agent committer identities are attributed automatically: each commit reads agent, assisted, or human in the sealed review, derived from Git evidence rather than anyone's say-so. The counts and the agents involved appear in every capsule and every shared link.

Any agent, one integration

patcharc mcp serves the recorder over the open agent-tool protocol: Claude Code, Codex, Cursor, and anything else that speaks it can start and seal Arcs, record decisions and risks, and file test results as it works. No per-agent adapter required; commits alone are enough even without it.

Ambient capture, opt-in

patcharc hooks install adds append-only git hooks that reconcile commits the moment they land and record rebases and amends as rewrite evidence; with init --auto, a commit made with no Arc active opens one by itself. Every hook line is designed so PatchArc can never fail a commit.

Attestations for provenance pipelines

patcharc attest re-expresses a verified capsule as a signed in-toto statement, binding the resulting commit and the capsule digest to the recorded process evidence. Standard provenance tooling can consume the story of a change without learning a new format.

No telemetry, hooks only by choice

The observer reads Git plumbing on a 1.5 s poll and the local loop makes no network calls. Git hooks are installed only when you ask, via patcharc hooks install or init --auto, are append-only, and can never fail a commit. Delete .patcharc/ and nothing of yours remains anywhere we operate.

• ADR tools compared, and decisions captured in the flow

  adr-tools, Log4brains, dotnet-adr, and the Backstage ADR plugin for architecture decision records, next to recording decisions with patcharc decision while the change is being made.

• CodeRabbit vs Greptile

  A neutral head to head on how each reviews a pull request, what each stores, what each costs, and what neither of them records.

• PatchArc vs Entire

  The two closest tools for recording what an AI coding agent did: Entire stores full transcripts on a Git branch; PatchArc seals a signed, deterministic review capsule. Where each fits and where both can run together.

• PatchArc vs Lore

  Two ways to hand off an AI coding session: Lore shares the raw transcript with a fork prompt; PatchArc shares a sealed, verifiable review. Pricing, privacy, and which to pick.

01

Do I need an account?

No. Everything except share runs with no account and no network. You sign in only when you publish a link.

02

When does my code leave my machine?

Only when you run patcharc share. What uploads is the sealed capsule, and the service re-verifies it before a link exists.

03

Does the review need AI?

No. The six sections are computed from recorded evidence. AI summaries are planned on top; none are generated yet.

04

Who can open an ArcLink?

Only you, by default: share reads share.default from your repo config, which starts as private. Public links are an explicit choice, expire after 30 days, and you can revoke or rotate one at any time.

05

Can I read a capsule without PatchArc?

Yes. It is a ZIP with a documented manifest: unzip it and read the review and every patch with any text tool.

06

What about monorepos?

Ten workspace detectors map a change to the packages it touched, so the review is organised by scope rather than by file path.

07

Does it work with Claude Code, Codex, or Cursor?

Yes. An agent's commits are recorded the same way yours are, agent trailers and identities are attributed automatically, and patcharc mcp gives any MCP-capable agent tools to record decisions and test results itself. Transcript capture is planned, not built.

08

Are secrets redacted?

Yes, at seal time. Every diff passes through the redaction engine when stop seals the capsule, and the signed redaction report records what was removed. It is a guardrail, not a guarantee: read a capsule with patcharc inspect before you share it.