ACD

Latest release: v2026-10-04

ACD turns the changes you make in files into clean local Git history. You work normally. ACD captures the changes first, groups related work by intent, and creates semantic commits in the background.

The normal flow is simple:

1. You change files.
2. ACD captures those changes in a durable private checkpoint.
3. ACD groups related changes by intent.
4. ACD creates semantic local commits.
5. You get a clean, reviewable Git history.

If an AI-generated plan is invalid or unsafe, ACD rejects it. It retries or rebuilds the plan while the captured checkpoint stays protected. A provider outage, failed check, or Git operation can delay commits, but it does not undo a completed checkpoint.

ACD never pushes. You decide when and where to publish your commits.

Requirements

• macOS or Linux on arm64 or amd64
• Git installed and available on PATH
• A normal Git worktree on an attached branch
• A configured Git author name and email
• A working systemd user manager on Linux

Check your Git identity:

git config --global user.name
git config --global user.email

Set either value if it is missing:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

The released binary does not require Go, a Git remote, a GitHub account, or Full Disk Access on macOS. AI connections may need credentials; Local automatic commits work without them.

Install

Homebrew

brew install KristjanPikhof/tap/acd
acd --version

Verified release installer

curl -fsSL \
  https://raw.githubusercontent.com/KristjanPikhof/Auto-Commit-Daemon/main/scripts/install.sh |
  bash

The installer selects the correct macOS or Linux release, verifies its SHA-256 checksum, and installs acd in $HOME/.local/bin by default. If your shell cannot find it, add that directory to PATH:

export PATH="$HOME/.local/bin:$PATH"
acd --version

The installer needs Bash, curl, tar, install, and either shasum or sha256sum. jq is optional.

Set up once, then enable each repository

1. Set up ACD for your user account

acd setup

Setup recommends AI semantic commits with Everyday structural checks and bounded repair of recent private ACD commits. Related code, tests, and docs can become one meaningful commit. Choose an AI connection, or choose Local automatic commits for offline operation with more limited grouping and messages.

ACD shows one exact plan before changing anything. Once you approve it, setup installs the managed runtime, starts the background supervisor, and adds any integrations you selected.

Setup is user-wide. In a terminal it offers a separate confirmation to protect the current repository. Declining leaves installation complete; run acd on later. Setup verifies running versions and protection for enabled repositories before reporting completion. Existing settings and repository opt-ins are preserved.

To inspect the plan without making changes:

acd setup --dry-run

2. Enable one repository

cd /path/to/repository
acd on

acd on registers only that repository, starts its worker, and waits until the current eligible files have a verified checkpoint. You can run it again safely.

Run acd on once in every repository that you want ACD to protect.

3. Confirm protection

acd status

Look for:

Protection: on
Current changes saved: yes
Branch commits: 3 changes waiting for AI
Next: No action needed.

ACD bounds AI planning time and can publish safe groups with local messages during an outage. Large files stream into Git; binary contents stay out of AI requests. If a file cannot be read, ACD saves readable work in a partial checkpoint and reports incomplete protection while retrying. Recovery: N changes saved separately means that work is preserved outside ordinary branch history.

Use acd status --verbose for provider, queue, target, phase, and worker details.

Daily use

You do not need to run git add, git commit, or acd commit-all during normal work. Keep editing files and use these commands when you want to check what ACD is doing:

Command	What it tells you
acd or acd status	Full protection and publication state for the current repository
acd list	Live queue and phase across repositories
acd list --once --verbose	One detailed dashboard snapshot
acd history	Retained checkpoints and their local Git publication state
acd history activity	Recent capture and publication activity
acd doctor	The problem and the next safe command when action is required
acd off	Save a final checkpoint and stop protecting this repository
acd on	Start protection again

acd list works from any directory. It shows repositories active within the last hour and keeps unfinished work visible until it is resolved. Agent hooks, edits, commit-all requests, and applied history rewrites count as activity; worker heartbeats and maintenance checks do not. Rows stay in place as the terminal refreshes. Use --all to include idle repositories, including those with maintenance warnings.

The dashboard columns show protection and publication separately:

Column	Meaning
SAFE	The latest complete observation has a durable checkpoint
MODE	Intent or event commit mode
QUEUE	Protected changes still waiting for local Git publication
TARGET	Work left in a bounded drain or automatic recovery
LAST MOVE	Time since durable queue progress, not a heartbeat
PHASE	Grouping, provider call, verification, waiting, recovery, or publication
STATUS	Healthy, working, waiting, stalled, paused, or needs action

working, waiting, and stalled can all be safe states. If protection is yes and Action needed is no, leave ACD running. It will retry or repair the publication path itself. Use acd doctor only when status says that you need to act.

Publish the current work now

Normal Intent mode publishes automatically. When you explicitly want ACD to finish the currently protected work before you continue, preview a bounded drain:

acd commit-all --dry-run
acd commit-all --yes

This does not switch to deterministic commits and does not squash everything into one commit. It freezes the current target and lets the configured Intent or event strategy publish it normally. Later edits stay outside that target.

Do not use commit-all as a repair command. Check acd status, acd list, or acd doctor instead. ACD keeps retrying in the background if your terminal closes.

How ACD keeps work safe

Protection and Git publication are separate:

1. ACD observes the worktree through file events, an adaptive safety poll, and optional coding-tool hints.
2. It writes the complete eligible state to a private Git checkpoint ref.
3. Only completed checkpoints enter Intent planning.
4. ACD validates grouping, dependencies, materialization, verification, and the exact Git target before it publishes.
5. Successful groups become ordinary local Git commits.

An invalid or incomplete AI plan is not trusted. ACD can reject it, retry the provider, or rebuild the plan from the still-protected captures. If the provider remains unavailable, publication waits without losing the checkpoint.

Normal publication appends commits. Optional Intent repair can rewrite only a bounded recent suffix that ACD proves is private, unshared, and ACD-owned. It does not rewrite pushed or user-owned history.

Read the architecture overview and protection and publication for the full durability protocol.

Restore a checkpoint

Restore always previews first:

acd history
acd restore cp-...
acd restore cp-... --yes

ACD checkpoints the current state before applying a restore. It leaves HEAD and the Git index unchanged and returns the pre-restore checkpoint as the undo target.

See user workflows for restore, recovery, and support steps.

Privacy and providers

Fresh interactive setup recommends AI semantic grouping and messages. You choose the connection and approve source sharing before activation. Local automatic commits remain an explicit offline option. Unattended first setup requires an explicit --provider openai-compat or --provider deterministic.

Network diff egress is off until you approve it explicitly. Credentials never enter status, logs, diagnostics, traces, or plan fingerprints. Full provider payloads stay out of ordinary diagnostics. The advanced prompt-trace and raw reject-log options are explicit local opt-ins because their output can contain sensitive source text. Git-ignored files and configured sensitive paths remain outside the protected scope.

See AI providers for the provider and privacy contract.

Configuration

acd config                 # Edit global defaults; switch scope in the menu
acd config --repo .        # Edit this repository
acd config get             # Inspect saved values and their sources

Select the model, endpoint, or API key to change it, then choose Save changes. ACD reviews, tests, saves, and queues the settings in one flow. Repository fields can inherit global defaults or override individual values. API keys are masked and stored securely after testing. Advanced settings cover verification, capture, repair, and retention.

See settings and the generated configuration reference.

Upgrade and uninstall

Upgrade the CLI with the same method you used to install it, then apply the reviewed runtime plan:

brew upgrade acd        # Homebrew installation
acd setup --dry-run
acd setup

Uninstall keeps protected repository data by default:

acd uninstall --dry-run
acd uninstall

Detailed documentation

• Command reference
• User workflows
• Architecture overview
• Protection and publication
• Intent commit flow
• Settings
• AI providers
• Commit-message rewriting
• Changelog

Development

Building from source requires Go 1.26.6:

make build
make lint
make test

The local gate and each hosted workflow have a five-minute execution target. CI runs package race tests, repeated stability cases, and the tagged production integration suite in four measured shards on both Linux and macOS. The release-style integration child binary is not race-instrumented; package tests cover internal concurrency.

For one production shard or real checkpoint measurements:

scripts/dev/test.sh integration 4 0
scripts/dev/benchmark.sh

Set ACD_TEST_RESULTS_DIR to an output directory outside the checkout to retain JSON timings and complete shard manifests. Update measured weights with python3 scripts/dev/test-manifest.py timings <jsonl-files...> and review the result before replacing scripts/dev/test-timings.json. Tooling tests use python3 -B -m unittest discover -s scripts/dev -p '*_test.py'.

Repository contribution and verification requirements are in CLAUDE.md. ACD is MIT licensed.