Releases

Release notes for the Entire CLI and git-sync.

  1. Added

    • redaction.drop_images setting (opt-in, off by default) keeps images out of checkpoints. Each image in a stored transcript is replaced with a 1x1 placeholder of the same type, on every storing path, including and . It covers Claude Code (including images read with the Read tool), Codex (including generated images and data URIs inside longer strings), Pi and OpenCode. Cursor's images are not captured. It is on when either settings file sets it, and it overrides externalize_images. Existing checkpoints are not changed. Note: older CLI versions reject a settings file that contains drop_images and write no checkpoints, so commit the setting only after the whole team has upgraded

    Changed

    • : if --timeout expires while the initial clone is still processing, the row reads still syncing, the command points to and exits 0, like --no-wait. A keyring or token failure at the deadline still fails and is not reported as still syncing

    Fixed

    • The pre-push hook no longer panics on every push in a repository that has extensions.worktreeConfig and a config.worktree file. This was a regression in 0.13.3. Opening a bare repository with a config.worktree no longer panics either

    Thanks

    Thanks to @MuskanPaliwal for the opt-in redaction.drop_images setting that keeps images out of checkpoints, and for fixing the pre-push panic in repositories with a config.worktree!

  2. Added

    • and run a project's review agents on your own machine. setup, run as a project admin, binds a service account (existing, or created with --name) to the project's self-hosted environment and grants it read access to the current repository; it never creates secrets. serve, run with that account's secret in ENTIRE_TOKEN, polls for jobs and runs Claude Code reviews in the foreground (--once, --poll-interval). A Core outage or throttling during the token exchange is retried, while a refused secret stops serve

    • Codex tool results in checkpoint transcripts carry exitCode for commands, declined for commands and file changes the user declined (their status stays "error"), and cwd for commands and file changes

    Changed

    • Checkpoints blank selected injected request text: Claude Code's recorded request logs, system prompt, loaded instruction files and memory notes; Codex's recorded base instructions and loaded user/repository instructions; and Pi's project_context section. Each record and the line count are kept. Pi's other system-message sections and Codex's built-in model-switch instructions remain stored. Claude Code attachments are blanked too, including session_context, which carried the developer's email, except queued prompts, shared files and IDE context

    • On Windows, hook commands find entire on PATH only, not in the working directory. Run in each repository to update installed hooks

    • offers to commit only the configuration files this run changed. Files that already had uncommitted changes are listed for review and never committed, and --local only lists

    • Plugins and signals: the signal Entire receives is forwarded as is (SIGTERM stays SIGTERM), SIGHUP is handled so closing the terminal winds a plugin down, and a second Ctrl-C gives a plugin up to 5s to finish before it is killed. A plugin that exits 0 after Ctrl-C keeps exit 0, and a signal ignored at startup stays ignored, so nohup entire <plugin> works. Plugin authors: see docs/architecture/external-commands.md

    Fixed

    • Plugins on Windows: works while the plugin is running instead of failing with Access is denied, and Ctrl-C no longer fails with exec: canceling Cmd: not supported by windows. On every platform, a failed install rolls back to the previous version instead of recording the new one, and concurrent installs, upgrades and removals of one plugin wait for each other

    • Entire works in a checkout whose .git directory shares another repository's objects and refs through a commondir file without being registered under worktrees/, as container launchers create them. Session start, and the commit hooks failed there with validate linked-worktree registration, and commits got no Entire-Checkpoint trailer. Note: files a session started in another checkout changes in such a checkout are not recorded; its tokens are. A turn spanning several worktrees also counts its step correctly when the first worktree recorded no files

    • A checkpoint whose ref sits under the other-case spelling of its shard directory, which a case-insensitive filesystem can produce, is found after git gc packs refs ( failed), extended instead of forked by later writes, listed once, and fetched from a remote that only has that spelling

    • Images pasted into Codex are kept intact in checkpoints instead of being corrupted by redaction. They are stored unredacted, as images from other agents already are

    • When Entire backs up an existing git hook by copying (filesystems without hard links, or taking a hook back from pre-commit or another hook manager), the copy keeps the hook's permissions, so a hook switched off with chmod -x stays off and a 0600 hook stays private

    • Pi sessions keep being captured after /reload, /new and /resume, and a hook that exits before reading its input no longer crashes Pi. A committed .pi/extensions/entire/index.ts needs regenerating; reports it as outdated

    Housekeeping

    • Go 1.27.4 and dependency updates, including betterleaks v1.10.0

    • Core API: project trails resolve through /project-resolver, repository-scoped trail requests use the repository-ID Change routes, and legacy Buildkite routes are dropped from the vendored Core spec

    • Tests and cleanup: bundle redaction of custom rules in settings JSON, the OpenCode 2 E2E seed test, and a repo default-branch constructor rename

    Thanks

    Thanks to @Beehtrix for keeping hook permissions on copied backups, for reporting how Windows hook commands looked up programs, adding exit codes, declined markers and working directories to Codex tool results, and keeping Pi capture alive across /reload, /new and /resume!

  3. Added

    • , list and delete manage a service account's secrets. create prints only the secret on stdout so it redirects cleanly into a file or secret store; --expires-in-days takes 1 to 365 and otherwise Core's 90-day default applies. An ENTIRE_TOKEN starting with ent_svc_ is exchanged for the service account's short-lived token, cached and renewed near expiry, including in git-remote-entire

    • Each release also ships git-remote-entire on its own as a git-remote-entire-<os>-<arch> archive. The entire_* archive, Homebrew and Scoop still ship both binaries

    • offers to install the entire-rsl plugin when it is missing, like , and

    Changed

    • Session and checkpoint tokens are counted from each agent's own running total instead of by slicing transcripts, for sessions started by this version with Claude Code, Codex, Copilot CLI, OpenCode, Pi, Factory Droid or Antigravity. Turns without file changes are no longer missed, and a repeated Stop, a commit in the middle of a turn or Copilot's cache no longer count twice. Checkpoint metadata adds session_token_usage, the session's total at that checkpoint

    • Repository-scoped and are removed; assignees and editable descriptions live on project trails, whose create and update are unchanged. Repository-scoped trail output and --json no longer include assignees or the aggregate comment and unresolved counts

    • OpenCode checkpoints: a tool still pending or running is no longer written as failed, an assistant message with only usage writes "content":null instead of "content":[], and a raw OpenCode 2 export converts in full. Live OpenCode views hide messages you undid, as OpenCode does

    Fixed

    • Antigravity IDE and Antigravity 2.0 app sessions are captured: transcripts under ~/.gemini/antigravity/brain and ~/.gemini/antigravity-ide/brain are accepted, so a turn end no longer fails with transcript file not found and finds those conversations

    • fills {repo_id} with the repository's processing placement and routes --to cell requests whose path contains {repo_id} to that placement's cell, except for /me paths or when --jurisdiction or a direct cell override selects the cell. 's repository scope uses the same lookup

    • install.sh verifies the archive against its exact line in checksums.txt instead of a suffix match that could pick the wrong archive

  4. Added

    • Checkpoint push policy: each clone can keep checkpoints local until you send them. automatic, the default, keeps today's behavior. Under manual, git push uploads no checkpoints and pre-push prints how many are waiting; or --all uploads them. On the first terminal push with checkpoints waiting, Entire asks once whether to push automatically, manually, or decide later (it waits 60s and backs off for 7 days on timeout). A policy that can't be read uploads nothing. manual is not supported on the git-branch backend

    • OpenCode 2 support, with the same coverage as OpenCode 1, which keeps working. The plugin moves to .opencode/plugin/entire.ts

    • New trail commands for a single change: (--undo returns it to draft) and ; (or --agent <id> to run one project agent), and ; and the read-only , and

    • , edit-reply and delete-reply manage the replies on a finding's thread, and prints them with their message IDs. The dashboard shows each project agent's latest reading, trend and run status

    • lists the trails you authored or are assigned across every project and region

    • , list and remove manage the images in a project trail's description. add prints the ![image](attachment:<id>) line to paste, and a failed upload leaves nothing behind

    • prints each open change's merge gates and check runs again (changes[].mergeability in --json), the trail's phase and last activity, and the base branch of each change. gains a PHASE column

    • , show, cancel and retry manage the runs of a project's review agents

    • (alias sa) manages project-owned service accounts: create, list, get, delete, repository and project grants, and GitHub Actions OIDC bindings

    • changes an Entire repository's default branch. GitHub mirrors follow GitHub's default branch and are refused

    • picks the processing cell instead of the region's default, and the success line shows the region and cell

    • After a plugin runs, Entire tells you when that plugin has a newer release and how to upgrade it, checked at most once a day per plugin

    Changed

    • Trail runners are replaced by project agents, stored in Entire per project instead of in .entire/runners/*.json. (including runner setup) is removed; shows a project's agents and adds preset reviewers for the current repository

    • On a color terminal, and finding list show open findings as cards like results, most severe first, with resolved and dismissed findings collapsed under Done. finding show prints the body as written and patches flush-left so they still apply. Plain output, pipes and --json stay stable

    • without --base no longer sends a guessed main. It uses origin/HEAD, then origin's HEAD from the remote, and otherwise lets the server use the repository's default branch

    • checks the repository's Trails setting before pushing the branch and stops with how to turn Trails on. A create the server rejects now says no trail was created

    • reached through a change (no selector, --branch or <repo>/<n>) says on stderr that it edits the parent project trail. A bare number run from a clone sends the checked-out branch so the server can refuse an update that would overwrite an unrelated trail. trail list and trail timeline accept -n for --limit

    • Only Entire-Checkpoint: lines in a commit message's last paragraph link a commit to a checkpoint. A trailer pasted into the body, or reused from a teammate's commit with git commit -C, no longer links or rewrites that checkpoint

    • The pre-push hook passes git's list of pushed refs to Entire and replays it to hooks that run after it, so Entire sees what the push sends

    • An invalid config.json is reported before a command runs instead of surfacing later as "not logged in". Only the token_store key is accepted. is exempt, and ENTIRE_TOKEN skips the check

    • root, and any process without $HOME, finds its home folder from the password database, as ssh does. Under sudo -E root no longer writes into the invoking user's ~/.config/entire, and root can use a file token store set in its own config.json

    • Codex transcripts from current Codex versions map commands, file changes, MCP calls, web searches and sub-agent spawns from the recorded items, the same way a live Codex stream does

    • Pi checkpoints are folded through the same streaming adapter as live Pi views. Pi lines that carry only usage now print "content":null instead of "content":[]

    • git push and read waiting checkpoints and their tips from one ref listing

    • Nix-installed binaries (under /nix/store/) skip the update check

    Fixed

    • A checkpoint_remote with no URL the CLI can build no longer falls back to the code repository's push remote, which could be public. Checkpoints stay queued locally and every push says why until the setting is fixed. A push to a raw URL no longer reports origin as a fallback, and the URL is redacted from the debug log

    • On the git-refs backend, pre-push pushes each checkpoint ref at the exact version that was queued, so a newer version written during the push stays queued instead of waiting for the next write

    • Queued checkpoint refs are pushed in chunks of 200 under one time budget. On Windows the batch push failed past about 340 refs, and a large backlog never caught up

    • Foreground checkpoint fetches (explain, resume, enable, checkpoint delete) are no longer killed after 2 minutes and restarted from zero; they run under one 30-minute budget

    • Legacy (v1) checkpoints are copied into their refs from whichever copy changed them last, after asking the remote, so a teammate's newer sessions are no longer hidden. When both copies changed, post-commit, attach and explain point at , which keeps the newer copy or asks which to keep. The doctor scan is much faster on clones with many legacy checkpoints

    • Checkpoint push recovery no longer replays over history that a shallow clone hides; it deep-fetches the ref and retries once, and otherwise says how to unblock it

    • A turn-end checkpoint write that fails is reported as degraded capture in and retried on the next Stop in the same turn, instead of being dropped silently

    • Token totals include Claude Code subagents launched by other subagents

    • A Claude Code foreground subagent that commits its own work now gets its task record and transcript stored in that commit's checkpoint

    • Agent hooks warn when entire is on PATH but fails to run (for example a mise shim with no version selected), instead of silently capturing nothing

    • re-signs the rewritten commits that you signed, instead of dropping every signature

    • On Windows, background workers no longer open visible terminal windows for their git subprocesses

    • Objects that git maintenance packed into loose-<hash>.pack files are found again, so read-only turns no longer list every file under those trees as touched

    • git-remote-entire holds a pushed pack in memory once instead of about four times, bounds its replica cache, and relays fetch negotiation rounds the way git upload-pack does, fixing "bad pack header" and "bad band" fetch failures

    • accepts --checkout and --add-assignee again, and prints the git switch command when the trail's branch isn't checked out

    • Trail commands explain a project that does not exist or is not visible to your login, instead of printing a raw API error

    • Review findings quote only files in the reviewed change, read from the worktree; anchors outside the change post at file level

    • The stale ended sessions warning reaches the terminal; the post-commit hook used to discard it

    • The Windows installer skips invalid or quoted PATH entries with a warning instead of failing

    Housekeeping

    • CI fails a PR on functions over cognitive complexity 30 that are new or worse than at the merge base

    • The README is rewritten around Entire as a Git forge, with reference detail moved to docs.entire.com

    • Checkpoint push and reconcile share one replay implementation

    • Faster -race tests for redact and transcript, a sharded Windows canary, and fixes for two flaky tests

    • Dependency updates, including brotli and klauspost/compress past GO-2026-6888 and GO-2026-6865

    Thanks

    Thanks to @dhanushk-offl for keeping Windows background workers headless (#2972), and to @lcv-leo for the diagnosis and patch it was based on (#2926)!

    Thanks also to everyone who reported the issues fixed in this release: @postusername, @SamPlaysKeys and @0x7CFE (OpenCode 2), @VytlaDinesh (hooks failing silently and subagent task records), @rennf93 (session attach dropping signatures), @marcosnils (git-remote-entire push memory) and @AndreaBozzo (Windows checkpoint ref push)!

  5. Added

    • ends by listing the Entire configuration that still needs committing (.entire/settings.json, .entire/.gitignore, and each agent's hook config and skill files), since other worktrees and clones only get the setup once it is committed. In an interactive terminal it offers to commit exactly those files and leaves anything else you had staged alone. The default answer is Yes when setup created a file and No when every listed file was already tracked. With --yes, without a TTY, or during a merge or rebase it only prints the list, and only lists. Nothing is pushed

    • transcript.jsonl assistant lines carry per-call usage for Claude Code, Codex and Pi: the call's model, fresh input_tokens, output_tokens, cache_read_tokens, cache_write_tokens (with the 5m/1h split when the agent reports it) and reasoning_tokens. Codex writes one assistant line per model call. Older lines stay readable and the format version is still 1

    • With redaction.externalize_images on, Pi images move to assets/ like Claude Code and Codex images. Pi user turns that hold only an image are no longer dropped from transcript.jsonl

    Changed

    • The first-turn context Entire injects into agent sessions now goes out in every session, not only where trails are enabled. It points agents at ; the trail guidance is added only when trails are enabled, on a later turn if that is learned after the session starts. Agents may create checkpoints manually when the user asks, and are told to ask before running setup or destructive commands

    • write commands (add, reply, edit, delete, resolve, unresolve) refuse when run from an agent session and point at instead, since trail comments are for people. list and show still work for agents. agent-help and the injected context say the same

    • is listed in under a new "Trails:" group

    Fixed

    • A commit no longer gets an Entire-Checkpoint trailer for an idle session whose new work is only in its live transcript without that checkpoint being written. Such sessions are now condensed at commit, and in stacked worktrees that touch the same files only the session's own worktree picks up its work

    Housekeeping

    • The transcript library's Pi JSONL parser moved to an internal package, and the unused Claude Code and Codex native-reader API was removed

  6. Added

    • On the git-refs backend, shows which checkpoints the next git push will upload (ID, age, agent, first prompt and files touched) and where they go, reading only local state. The count in now matches that list and no longer includes queued refs that were deleted locally. --outgoing is not supported on the git-branch backend

    • ends with a checkpoint privacy notice: where checkpoints will be uploaded, that they contain agent transcripts readable by anyone if the destination is public, that secret redaction is best effort, and how to stop uploads or use a separate private repo

    • shows a Sync: section when GitHub blocks the owner's installation (for example an org IP allow list), including the fix and the resync command. The new queues a resync for every placement once the block is cleared. --json adds syncBlock and syncStatus

    • PII redaction has a new ip category ([REDACTED_IP]), on by default when redaction.pii.enabled is true. It redacts private and link-local addresses, and public ones only when they appear in a network context, so version numbers and user agents are kept

    • Redaction catches *_CLIENT_SECRET, *_API_KEY and *_TOKEN assignments in text and JSONL fields, and low-entropy secrets piped into credential commands (printf 'value' | examplectl secret put EXAMPLE_API_KEY). Identifier-shaped values (*_id, *_account) and placeholders are left alone

    • Checkpoints record how many values redaction replaced, per layer, and shows them. Only counts and layer names are stored

    • strategy_options.checkpoint_ref_list_timeout_seconds sets how long waits for each remote (default 5s, capped at 2 minutes), for remotes that are too slow to list their checkpoint refs in time

    • Factory AI Droid sessions record token usage, read from the session's settings file, because Droid writes none to its transcript. Before this, every Droid session recorded 0 tokens

    • offers to install the entire-brain plugin when it is missing, like graph and investigate do, instead of failing with "unknown command"

    Changed

    • no longer accepts --title, --body, --type, --priority or --assignee; those are trail-level fields, so set them with . A linked change's title is always its branch name, and --status is validated the same way as in create. still sets all of them on the project trail

    • links the change a project trail was reached through. In --json, each changes[] entry gains a url and the current change is marked current: true. The text view is aligned and colored like the other show commands

    • no longer reports the enabled repository to entire.io

    • posts at most 50 findings, highest severity first, and shortens finding bodies over 16,384 characters. It reports how many it left out or shortened. Judge prompts fence each reviewer report with a per-prompt token, so a report can no longer close its own fence

    Fixed

    • OpenCode child sessions and Factory AI Droid Workers count toward the parent session's tokens in status, sessions, attach and checkpoint metadata, each counted exactly once. The header total includes subagents

    • A commit from a linked worktree by an agent that started in the main checkout (for example after Claude Code's EnterWorktree) no longer pulls the main checkout's unrelated mid-turn sessions into its checkpoint

    • The background session sweep and write a salvaged checkpoint on the session's recorded branch instead of the sweeping worktree's branch. If the session's original worktree is unusable, they fall back to the current repository instead of failing. Existing misattributed checkpoints are not rewritten

    • git-remote-entire honors protocol.version from git config, so fetches over entire:// with protocol v0 or v1 no longer exit 1 without a message

    • OPF PII redaction no longer withholds a checkpoint when the transcript contains CRLF or bare carriage returns

    Housekeeping

    • Experimental commands are shown or hidden in help based on the build version alone: stable X.Y.Z releases hide them, while dev, nightly and commit-stamped builds show them

    • The transcript package exports its JSONL records adapter for live streams

    • ci is removed from the official plugin telemetry list

    • Test isolation: unset the legacy GIT_CONFIG variable, keep the developer's git config out of the Antigravity tests, and make the attach tests pass on git 2.56

    Thanks

    Thanks to @jaysomani for fixing OPF batch redaction on CRLF transcripts!

  7. Breaking changes and migrations

    • Project trails are the default: always uses project-scoped trails, and ENTIRE_PROJECT_TRAILS is no longer read. now works on project trails too. It merges one open change and lists the candidates when there are several (narrow with --repo / --branch), and its hints name the change ()

    • Project trail --status accepts only open and closed; draft is rejected

    Changed

    • Browser links (trail, review and experts links) point at entire.com, where the web app now lives; API calls stay on entire.io. ENTIRE_WEB_BASE_URL overrides the web origin, accepts entire.com trail URLs as well as entire.io ones, and help text that refers to the website names entire.com

    • git-remote-entire errors print one readable line (repository not found, no access, login rejected, server error, no reachable server) instead of the whole protocol error chain, and credentials in invalid URLs are masked. The full chain is still in the ENTIRE_DEBUG trace

    • The Windows installer reads releases from install.entire.com first, with GitHub as the fallback, matching the Unix installer. It also accepts a -Version pin and honors ENTIRE_INSTALL_BASE_URL, and a checksum mismatch aborts instead of falling back to another origin

    • Project trail --add-assignee / --remove-assignee resolve GitHub logins to accounts before updating, so an unknown login aborts the update instead of applying part of it. A retried with the same --client-id reuses the same finding instead of duplicating it

    Fixed

    • Redaction catches Authorization and Proxy-Authorization header credentials whatever their entropy (UUIDs, hex tokens, short base62 tokens), in raw requests, header maps and common language idioms, and leaves the header name and scheme visible

    • Redaction no longer lets git@company.com-style mailboxes or base64 secrets that follow punctuation (token_<secret>, -p<secret>, user@<secret>) through; the git@ exemption now applies only to git remotes

    • Headless agents (claude -p, codex exec, droid exec) no longer lose earlier turns' tokens, or store them twice, after a turn that changes no files: an ended session's state is kept while it holds uncommitted tokens or transcript offsets

    • OpenCode: a commit made while a background subagent is still running links to the parent session, because the subagent's edits so far count toward co-authorship. The check shares a 10s budget, so a hung export cannot hold up the commit

    • OpenCode summaries and work with OpenCode 2, where they failed with Unrecognized flag: --dir. Generation now runs standalone so it no longer attaches to a running OpenCode service or leaves one behind. Note: OpenCode 2's plugin API and opencode export changes are not yet supported

    Housekeeping

    • Bump aws-actions/configure-aws-credentials to 6.3.0

  8. Security

    • Bumped the Go toolchain to 1.27.3 (go.mod toolchain and the mise pin), clearing GO-2026-6809: crypto/x509 now distrusts compromised intermediate certificates. It is reachable through TLS verification on every HTTPS remote.

    • Bumped the Go toolchain to 1.27.2 (go.mod toolchain and the mise pin), clearing ten standard-library advisories reachable from the HTTP transport and the convert-sha256 filesystem paths — among them HTTP/1 client desynchronization after a CONNECT rejection (GO-2026-6605), a memory-limit bypass parsing MIME headers in net/textproto (GO-2026-6608), malformed ECH outer extension references accepted by crypto/tls (GO-2026-6607), and HTTP/2 transport accepting malformed framing headers (GO-2026-6610). Released binaries are built from the go.mod toolchain; govulncheck ./... goes from 10 called vulnerabilities to 0. The go directive stays at 1.26, so the minimum Go version for library consumers is unchanged. golangci-lint moves to v2.15.0, since releases before v2.13.0 refuse to lint a module targeting Go 1.27.

    • Bumped golang.org/x/crypto to v0.58.0 and golang.org/x/net to v0.61.0 (raised as indirect dependencies; golang.org/x/sys follows to v0.49.0), clearing three SSH advisories in packages git-sync imports (GO-2026-6303, GO-2026-6354, GO-2026-6355) and five HTTP/2 advisories in golang.org/x/net. None was reachable from git-sync's call graph. The remaining module-level finding, GO-2026-5932 (golang.org/x/crypto/openpgp is unmaintained), has no fix and git-sync does not import that package.

    Added

    • RefScope.IncludeRefPrefixes narrows a request to one or more namespaces. With any prefix set, a ref outside all of them is neither pushed nor pruned, in every kind — the filter is the single predicate the desired set, TargetScope.Manages and the prune set all ask, so push scope and prune scope cannot disagree. Exclusions still apply within an included prefix, and explicit Mappings bypass both as before. Every entry must start with refs/: a blank or refs/-less prefix scopes a request to nothing, which under a prune policy is a zero-plan success that repeats forever, so it is rejected at the request edge instead. git-sync's own refs/gitsync/ scaffolding is the exception to the narrowing: a run manages only the bootstrap markers of branches it manages, minus any it excludes by name, so two syncs with different scopes sharing one target cannot delete each other's live resume state, and other scaffolding answers to the exclusions alone because prune is the only cleaner a stale marker has. Callers whose target refuses writes outside the included prefixes must exclude refs/gitsync/ explicitly; the markers of branches a run manages stay prunable. The source ref listing is not narrowed: ref-prefix stays refs/ under AllRefs, so an empty in-scope set stays distinguishable from a source that advertised nothing.

    • SyncPolicy.AllowEmptyScope lets an empty in-scope desired set prune instead of failing. Without it, a replicate whose scope matched no source ref fails with the historical "no source refs matched", so a caller replicating a namespace could never propagate the deletion of its last ref. With it, a source that advertised at least one ref proceeds with an empty desired set and the target's in-scope refs are pruned; a source that advertised nothing at all still fails, now with ErrSourceEmptyUnverified, because a withheld listing is indistinguishable from an empty one. Replicate-only (only replicate's empty-set branch consults the policy; elsewhere the run returns the historical error and keeps the refs the caller meant to prune), and requires Prune (without it the policy plans nothing and reports a green pass over the refs it was set to reap), AllRefs (a narrowed listing cannot tell an empty namespace from one it never asked about) and IncludeRefPrefixes. Mutually exclusive with AllowEmptySource, which needs the unscoped listing its own claim rests on. Every one of these is rejected at the request edge rather than discarded.

    • The CLI flag --bootstrap-fallback-max-pack-bytes and unstable.AdvancedOptions.BootstrapFallbackMaxPackBytes enable the fallback for bootstrap, sync, replicate, and plan. unstable.Options.BootstrapLogger supplies structured diagnostics to bootstrap and sync paths.

    • Options.BootstrapFallbackMaxPackBytes provides an opt-in local byte ceiling for indivisible bootstrap checkpoints when no target limit is known. These uploads bypass projection and the batching margin, while preserving source limits, deadlines, and observed server cutoffs. Exceeding the fallback remains retryable, not ErrCheckpointExceedsTargetLimit. Diagnostics identify the configured_fallback budget separately from a target-announced limit.

    • Options.BootstrapLogger emits one structured event per bootstrap checkpoint upload without verbose protocol logging. Events include the checkpoint, split eligibility, effective budget and its source, read/object counters, size projection, and local abort reason. Abort counters are captured at the decision; they do not assert target receipt or acceptance. Upload limits and retry behavior are unchanged.

    • ErrCheckpointExceedsTargetLimit identifies a permanent, target-verified bootstrap size failure. Sync and Replicate, plus unstable.Client.Bootstrap, wrap this sentinel only after the target refuses a one-commit checkpoint that cannot be subdivided further, so embedders can terminate futile redelivery with errors.Is while continuing to retry transport failures and deadline expiry

    Changed

    • A failed bootstrap now returns its route alongside the error. Plan, Sync, and Replicate, plus their unstable counterparts and Bootstrap, preserve the selected operation and transfer modes, relay fallback reason, attempted ref plan, and completed batch progress when a bootstrap fails, so a failed or partially completed bootstrap can be told apart from a pre-execution failure without reconstructing the route from the error text. This covers the bootstrap route only: a failed incremental or materialized relay still reports an empty transfer mode, and most other error paths still return a zero result. Outcome counts are unpopulated on every one of these paths and must not be used to infer how much landed

    • A target that refuses the batched bootstrap temp ref now fails the run, including under --best-effort. Every other per-ref refusal stays a warning there, but this one is the batching state machine: the run previously advanced its checkpoint position against a ref the target had not moved, then failed later and more confusingly, or deleted a marker at a hash the target never accepted. A run against a target that blocks writes to refs/gitsync/* used to exit 0 with warnings and now exits non-zero — worth knowing if you alert on exit codes

    Fixed

    • Interrupted bootstraps can resume when their markers remain on the target. Replicate recognizes a live bootstrap marker and selects bootstrap when all desired target refs are absent and the source supports batching. Sync and replicate pruning preserve live resume markers, and source discovery ignores refs/gitsync/* scaffolding.

    • A private GitHub repository over 1.5 GiB now bootstraps in batches. The GitHub size lookup that selects batched bootstrap sent no credentials, so every private repository got a 404 and was sent silently as one pack. The lookup now carries the source credentials, scoped to api.github.com, and retries once anonymously if the API refuses them. Each lookup's outcome is logged through Options.BootstrapLogger, and a failed lookup prints a notice.

    • Preserve source-read errors when closing bootstrap observation, including io.ErrUnexpectedEOF; a truncated source is reported as observer_failed, not expected observer_interrupted. Intentional partial closure is unchanged.

    • At source EOF, bootstrap upload guards enforce actual bytes without projection or the batching safety margin. Final bytes returned together with EOF remain subject to the byte limit, and diagnostic counters retain their observed values.

    • Bootstrap upload diagnostics distinguish expected scanner interruption on a partially consumed upload (observer_interrupted) from malformed input or scanner failure (observer_failed). Closing a partial valid pack no longer reports instrumentation failure; malformed data and source truncation remain visible.

    • An indivisible one-commit bootstrap checkpoint is now tested against the target's announced pack limit before the run gives up. The batching budget is intentionally smaller than that limit, so treating a pack that crossed the budget as permanently too large made every retry fail locally even when the target would have accepted it. Once subdivision bottoms out at one commit, git-sync now attempts that pack and only reports a permanent failure when the target itself refuses it. A deadline retains its original classification instead of being converted into a size verdict

    • A batched bootstrap no longer discards its resume position when the target refuses the branch create. The cutover push carries two commands — advance the refs/gitsync/bootstrap/heads/<branch> temp ref to the final checkpoint, and create the real branch there — and the temp ref was deleted on the strength of that push returning no error. Under --best-effort (implied by --all-refs) a per-ref ng reaches a callback and the push still returns nil, so a target that refuses the create — a protected branch, a pre-receive policy — ended the run with neither the branch nor the marker and reported success. With nothing on the target referencing the objects already delivered, the next run had no fetch have to negotiate against and re-transferred the entire history, on precisely the large repositories batching exists for. Whether the branch landed is now settled against the target's own refs, not inferred from the push, and the marker survives anything short of the branch being present at the hash the run pushed

  9. Breaking changes and migrations

    • is removed; invoking it reports that it was removed. approve and approvals remain

    • is deprecated and has no effect; it prints a deprecation warning and will be removed

    Added

    • Review profiles can give each reviewer its own agent config (, or --configure <profile> --set-config <reviewer>=<config.json|isolated|none>). That reviewer then runs with the profile's hooks, MCP servers and extensions instead of the branch's, for Claude Code, Codex and Pi. Configs are honored only from developer-owned layers (clone-local preferences or an untracked .entire/settings.local.json), and tools a headless reviewer was denied are reported after the run

    • reports what happens to the trail's branch, and --delete-branch / --no-delete-branch override the repo's delete-branch-on-merge setting for one merge

    • OpenCode subagents are tracked as subagents of their parent session instead of as separate top-level sessions

    • A session's edits in another worktree of the repository (by absolute path, or after resuming there) are recorded against that worktree, so a commit there links the session's work

    • Install and update read releases from Entire's own release mirror first, with GitHub as the fallback, so a GitHub outage no longer blocks installing an already-published release

    • exposes repoId and apiUrl for the repository's cell

    • Antigravity: Entire installs agy's SessionStart hook (agy 1.1.1+)

    Changed

    • Project trails: repository writers can create trails with branch-backed changes, branch-level trail commands pick a project trail's change across repositories, and prints the trail's URL

    • and warn Claude Code users when required Entire hooks are missing after an upgrade, and the remaining hook remedies point at the right fix

    • , list and remove discover external agents (entire-agent-* on $PATH)

    • backs off and retries with jitter when the search service sheds load with a 429

    • Prompts are passed on stdin instead of argv, so other local users cannot read them from the process table: Pi and Antigravity summary generation, and Claude Code and Pi reviewers

    • External agents' checkpoint transcripts are compacted with the agent's own compactor instead of the built-in one, which wrote empty entries for formats it didn't know

    • Turn-end checkpoint finalization has an overall deadline, so a slow but responsive remote can no longer outlast the agent's hook timeout

    Fixed

    • Redaction catches more secrets: betterleaks multi-part rules (such as a bare AWS access key ID without its secret) and keyword-gated tokens, base64 secrets containing /, JSON values scanned together with their keys and under skip keys, and other missed credential shapes

    • Redaction no longer over-redacts env output, placeholder URLs and git remotes, and skips custom rules that can match the empty string instead of corrupting every transcript

    • Redaction settings are honored everywhere: subcommands (including doctor bundle) load custom rules, the background session sweep and summary writes load repo settings first, and the transcript prefix cache no longer reuses a prefix redacted under different rules

    • Redone commits (after git reset or amend) inherit the replaced commit's checkpoint instead of minting a fresh one, and redo detection compares content in the index the commit is actually made from (git commit -a, path-limited commits)

    • Token counts: a turn that changes no files keeps its tokens for every agent, session attach counts a crashed session's last turn, Claude Code subagents named only in the structured tool result (foreground Explore and Plan) are counted, and a Claude fork's copy of its launch message is counted once

    • Entire takes back git hooks that another hook manager moved aside and wrapped

    • A detached background process no longer inherits the parent's output pipes, so it does not die once a short-lived parent such as a git hook exits

    • resolves the default branch by full ref name, so a tag or local branch named main cannot stand in for it; a Pi review whose stream ends without agent_end is reported as finished; and a clean approval is no longer posted to the trail as an "Unspecified finding"

    • git-remote-entire C-unquotes --force-with-lease and push-option values, so leases and options with quotes, backslashes or non-ASCII bytes work, and reuses the entry connection between auth discovery and the cold-start probe

    • sends the commit token on readiness polls, avoiding spurious 403s from a regional authz follower that hasn't seen the grant

    • Cloud dispatch stops polling when a redirect is refused by the HTTP policy instead of treating it as a dropped connection

    Housekeeping

    • Transcript library: native converters and Pi JSONL parsing moved into the shared transcript package, with a typed Entire Transcript Format reader and spec, and JSONL conversion split into a records adapter and an agent-agnostic fold (groundwork for live session streaming)

    • Go 1.27.3 and golangci-lint 2.15.0

    • govulncheck runs on PRs, main and daily

    • --force-with-lease through the remote helper is pinned by integration tests

    • Test flake fixes: hook exec retries on ETXTBSY, and three intermittent tests

    • Dependency updates, including go-git v6 and go-billy v6 beta.1

    Thanks

    Thanks to @teej-mny for reporting that bare AWS access key IDs were not redacted, and to @wernerkasselman-au for the review that found dispatch polling retried refused redirects!

  10. Breaking changes and migrations

    • Agent turns no longer write shadow branches (entire/<commit>-<worktree>): pending work is tracked in session state, and checkpoints are written only when you commit. Branches left by older versions are not removed automatically. and report them, and or deletes the entire/<commit>-<worktree> form without touching session state. The oldest bare entire/<commit> form is only listed, since a branch of your own named after a short SHA looks the same; removes it behind a confirmation. Do not use plain for this, because it also clears pending session state. Deleting the branches frees no space by itself: a later git gc reclaims it once their objects are two weeks old. Downgrading after this release discards pending (uncommitted) agent work, because older versions delete ended session state whose shadow branch is missing

    • Line attribution is removed: reports whether each line's commit is linked to a checkpoint instead of AI/Human/Mixed labels, and reports a per-line status (checkpoint, commit, uncommitted) instead of authorship and tag. Checkpoint metadata no longer carries initial_attribution or combined_attribution

    • takes only a /et/<project>/<repo> path; --project and bare-name lookup are gone, and output says "mirrors" and names repos by path instead of ULID

    Added

    • removes a checkpoint locally and from every checkpoint remote that holds it, on both backends, with a plan shown first, --dry-run, and confirmation (or --force). Deleted ids are remembered so a later commit or push does not bring them back

    • merges a trail's branch into its base after checking mergeability and gates; --dry-run only reports, and --force bypasses gates where the repo's bypass policy allows it

    • Project-scoped trails (opt in with ENTIRE_PROJECT_TRAILS=1): one trail captures intent across repositories and branches, with project-level intent, discussion and link/unlink commands. Repository-scoped trails stay the default

    • Interactive wizards for and when the command line doesn't name everything needed; full flag forms still create directly without prompts, and partial flag forms or non-terminal runs are refused before any request

    • converts a sole-placement /gh/ mirror into a native /et/<project>/<repo> repo, with a server dry-run plan, --dry-run, --yes and --json

    • deletes a native repo together with its mirrors on other clusters, waiting for completion unless --no-wait is passed

    • resolves a commit to its linked checkpoint across repositories, so a commit hit from can be drilled into directly

    • Sessions remember which agent home (CLAUDE_CONFIG_DIR, CODEX_HOME, COPILOT_HOME, FACTORY_HOME_OVERRIDE, PI_CODING_AGENT_DIR) holds their transcript, so and find sessions started under a different home than the current one, including archived Codex rollouts

    • Agents launched by Claude Code's Workflow tool and by skills with context: fork are recorded in checkpoints with task records, transcripts and subagent tokens. Existing installs need to re-run for the new SubagentStart hook

    • git-remote-entire honours GIT_HTTP_USER_AGENT for its HTTP User-Agent, matching git

    Changed

    • decides how to link from whether the commit already has a checkpoint and whether it is pushed: it adds to an existing checkpoint, records a link for a pushed commit without rewriting it, or adds a trailer to an unpushed one. --commit <rev> links any commit. It shows what it will do and asks first; without a terminal it changes nothing unless --force is passed

    • loads the reviewed checkout's full agent configuration again (reverting the 0.11.4 isolation, which made reviews worse), and instead asks before reviewing someone else's code. --show-config lists what the branch would run, --trust-target <sha> skips the prompt, and every reviewer is told that repository content cannot change its task

    • Same-repository remotes (for example a GitHub remote and an entire:// mirror of it) can both carry checkpoints past the single-remote sync gate

    • (cloud mode) generates on the entire-api cell, and the dispatch wizard and search --repo completion discover repositories from the control plane, replacing removed BFF routes

    • and talk only to the home entire-api cell; the BFF fallback is removed, so errors surface directly instead of as a later 401

    • Each Entire Claude Code hook has a timeout, so Claude Code cancels a stalled entire launch instead of waiting. Existing installs get them from or , and flags configs without them

    • The auth token refresh lock moves into Entire's cache directory (macOS: ~/Library/Caches/auth-go to ~/.cache/entire/auth-locks)

    • says an existing git hook still runs after Entire's, and reports restoring it

    • shows external agents by name instead of "Unknown"

    • Connection setup (DNS, TCP, proxy CONNECT and TLS) is bounded by ENTIRE_CONNECT_TIMEOUT_SECONDS, which previously covered only DNS and TCP; a node that stalls the TLS handshake no longer blocks failover

    • The OpenAI Privacy Filter (OPF) is deprecated and its documentation removed; existing configurations keep working until the code is removed in a later release

    Fixed

    • Windows: git commit -m from a desktop agent (Claude Code, Codex) no longer hangs in prepare-commit-msg on an unanswerable linking prompt. The prompt now gives up after 15s and links on every platform, windowless consoles count as non-interactive, and Antigravity's shell is treated as an agent

    • Credential-bearing HTTP clients (remote helper, API, control plane, cloud dispatch, cell catalog) no longer follow HTTPS-to-HTTP downgrades

    • HTTP_PROXY, HTTPS_PROXY and NO_PROXY are honored by the shared HTTP transport, so control-plane commands work on networks that require a proxy

    • Summary generation runs agents with no tools, from an empty working directory and (for Antigravity) an isolated home, and external agent plugins run generate-text outside the repository, so instructions in a transcript cannot act on files or config

    • Commits link to sessions whose agent changed a file only through a shell command: edits to already-untracked files and files created by a background subagent after the parent's turn ended

    • Each checkpoint's tokens are counted once: partial commits, session attach, session adopt and mid-turn commits no longer double count or drop tokens

    • A subagent's task record counts API calls written to its transcript after SubagentStop fired

    • A git hook is never lost when a .pre-entire backup already exists, and Entire's hook keeps working after pre-commit install

    • only imports sessions that belong to this repository, for agents whose per-project directories can be shared by different repo paths

    • Bare sk- keys with short bodies (such as LiteLLM virtual keys) are redacted

    • A blocked keychain or network inside an agent sandbox is reported as such instead of "Not logged in"

    • reports why a Pi reviewer failed, and no longer fails a Claude Code reviewer on non-assistant stream events

    • of a released /gh/ address names the clone command for the repo's new /et/ path

    • no longer suggests --repos, which local mode refuses

    • Activity "today" and "yesterday" labels are correct across DST changes

    Housekeeping

    • Agent capabilities all resolve through As* helpers, guarded against drift from the DeclaredCaps list

    • Removed about 2,400 lines of dead and test-only code

    • Per-commit git-remote-entire builds stamp their commit into the version

    • E2E decides prompting from real agent signals, and the Vogon canary runs on Windows

    • CI uses the official Codex and Copilot installers on Unix

    • Test fixes: OpenCode dependency cache rebuilds, Antigravity generation test isolation, time-relative pending-preview fixtures

    • Trail-review runner reports every issue in one pass

    • Agent instructions clarify the trail findings check

    • Dependency updates

    Thanks

    Thanks to @mvanhorn for making the shared HTTP transport honor proxy environment variables, to @wernerkasselman-au for responsibly reporting the HTTPS-to-HTTP downgrade paths, and to @ChetanReddyC for privately reporting that summary generation passed transcript content to a tool-enabled agent!

  11. Breaking changes and migrations

    • is removed; is now the one repository view for both forges, listing name, visibility and every cluster holding a copy with its role, clone URL and status. It takes /et/<project>/<repo>, /gh/<owner>/<repo> or an entire:// clone URL; the repo ULID and bare name with --project are no longer accepted. The CLUSTER column now prints the public host that --cluster accepts, and primary and mirror rows share one status vocabulary (ready, processing)

    • A trailing .git is never part of a repo name: every ref parser drops it, so /et/p/foo and /et/p/foo.git address one repository, and refuses names ending in .git in any letter case. This reverts the 0.11.2 rule that treated the suffix as part of a native repo name

    Added

    • exposes subagent task records and the full session token breakdown (subagent_tokens, subagent_tokens_complete, api_call_count)

    • Hidden writes a checkpoint from a session that changed no files (research, planning, review), which previously never produced one

    • delegates to an installed entire-<plugin> command's own agent-help

    • creates a trail through the API alone, without a local clone; --title, --base and --branch (or --no-branch) are required and the branch must already exist on the repo

    • Project and repo grant lists show account display names, as org member lists already did

    • also suggests the command to repoint an existing checkout at the new mirror

    • A committed checkpoint_remote rejected by the ownership check is now reported to the user, with an offer to claim it when the store is theirs, instead of only a warning in .entire/logs

    Changed

    • Org names resolve against the caller's own org list instead of the server's global name lookup; when several of your orgs share a name, the CLI lists them and asks for the ULID

    • Google handles printed as google:<id> by are now accepted as grantees, and org member names are shown in grant output

    • now fails with a pointer to , since the server no longer allows deleting trails. The command is hidden but stays registered so existing scripts get the guidance

    Fixed

    • no longer loads execution-capable agent config from the reviewed checkout: Claude Code ignores project settings, hooks, MCP servers, commands and skills; pi ignores project-local extensions; Codex runs --target reviews with the checkout marked untrusted

    • Claude Code turns that end on an API error (StopFailure: rate limit, overload, auth or billing failure, max output tokens) now end the turn, instead of leaving the session ACTIVE until the next prompt. Existing installs need to re-run to add the new hook; until then reports the Claude Code hook config as outdated

    • Session resume, attach and transcript lookup honor each agent's home relocation variable (CLAUDE_CONFIG_DIR, CODEX_HOME, COPILOT_HOME, FACTORY_HOME_OVERRIDE, pi's dirs), including a CLAUDE_CONFIG_DIR set in Claude's own settings. Relative values are refused and reported by

    • Subagent capture: Claude Code background subagents now reach checkpoints, task records carry token usage, files and Codex completion before commit, Codex child transcripts resolve when the parent commits before its own Stop, and an aborted Codex turn counts as ended

    • Read-only review sessions are no longer condensed into another session's mid-turn commit

    • Commits redone after a git reset keep the dropped commits' Entire-Checkpoint trailers, so the session stays on the trail

    • OPF redaction splits entities that span two batched leaves instead of dropping them, which previously left both unredacted under Entire-OPF-Applied: true

    • review_prompt and investigate_topic in checkpoint metadata.json are redacted like prompts

    • Redaction no longer replaces Claude Code tool-use ids or Codex agent_message ciphertext with REDACTED

    • Checkpoint ref push fallback is bounded to two minutes or five consecutive failures, unpushed refs stay queued and rotate so later refs get a turn, and fetch errors keep their underlying cause

    • Protocol v2 pushes through git-remote-entire declare their size, so an oversized push is refused up front with a clear 413 message instead of uploading fully and failing with the remote end hung up unexpectedly

    • Missing-checkpoint errors name the refs where the checkpoint can actually live under the configured backend, instead of always suggesting a fetch of entire/checkpoints/v1

    • derives ULID checkpoint IDs under the git-refs backend

    • On Windows, and no longer report approved Codex hooks as needing approval

    • and work from an Entire-native clone instead of failing with "remote is not a GitHub repository": the default scope comes from the origin's forge (et/… or gh/…), so a native repo and a same-named GitHub mirror stay distinct. with --repo, repo: or --all-repos no longer requires a readable origin, and the wizard now discovers native checkouts

    • validates declared subagent transcript paths against the agent's session directory and clears paths it cannot verify, instead of copying them unchecked into checkpoints

    Housekeeping

    • Local commit and reference reads use go-git

    • Cluster discovery drops the unused jurisdiction audience fields and requirement

    • Command-layer tests pin refusal of off-manifest 421 redirects

    • Control-plane E2E login handles the new sign-in provider picker

  12. Breaking changes and migrations

    • Gemini CLI support is removed: , Gemini hook capture, the Gemini review runner and summary provider, session import and resume, and Gemini skill setup are gone. Entire hooks already installed in .gemini/settings.json now exit silently without recording anything; and remove them. Checkpoints recorded from earlier Gemini CLI sessions remain readable by and summaries. Antigravity CLI (below) is its successor

    • has one verb: repo remote use becomes repo remote add <remote-name> [repo], which refuses an occupied remote name unless --override is passed (re-adding the same URL is a no-op). repo remote url and --upstream are removed; lists clone URLs per cluster. No compatibility aliases

    • is removed. now answers for both forges: /et/ refs show the repo's grants and /gh/ refs show the mirror's GitHub collaborators. repo grant add|remove refuse /gh/ refs and point to GitHub

    • is deprecated and now fails with a migration hint. The plain output is accepted directly at every entire-api cell, so drop the flag; the jurisdiction token exchange is removed from the CLI

    Added

    • Antigravity CLI (agy) agent integration (preview): lifecycle hooks, transcript decoding, native token counts via a title tee, review-skill discovery and resume tracking. Note: agy writes its transcript after Stop, so first-turn mid-turn commits can produce a files/prompt-only checkpoint and mid-turn commits record zero tokens until the next condensation; tracking is silent inside agy, use

    • invites an email address to an organization, reaching people who have never signed in. The invitee accepts through the emailed link

    • measures latency to each available cluster and picks the fastest, without --cluster or a terminal

    • offer an interactive multi-select of grantees when the grantee is omitted on a terminal, with a role per grantee for add

    • surfaces the backend's mergeability snapshot in text and --json

    • Windows entire.exe and git-remote-entire.exe embed PE version metadata, so Explorer and Get-Command report the real version instead of 0.0.0.0

    Changed

    • is condensed to a verdict line and a few rows, with humanized timestamps and user shown as the provider-qualified handle usable in grant commands. --sessions prints the full session table with the current CLI session marked, and --json is supported

    • Non-interactive cluster selection for repo clone and repo remote add defaults to the repo's primary cluster instead of failing when a repo has several placements

    Fixed

    • Commits squashed locally with git merge --squash and a custom message keep the squashed commits' Entire-Checkpoint trailers. Inherited trailers are treated as links and never condensed into, and post-commit no longer writes pending work into an older checkpoint when a commit carries several trailers

    • Hooks no longer delete live idle sessions. Previously a hook in any worktree could remove a healthy IDLE session after a linked commit, re-initializing it from scratch and leaving a commit in the gap with no session

    • Condensation no longer resets the session-wide token totals shown by and to the per-checkpoint usage

    • Checkpoint sync remote election ignores remotes that only have a pushurl and no fetch URL, since Entire cannot read checkpoint history from them

    • Remotes written as git+ssh:// or ssh+git:// are recognized as SSH, so checkpoint URL derivation and token handling work for them

    • Git subprocesses that target a specific repository strip an inherited GIT_COMMON_DIR, which could otherwise make them read another repository's shared git data

    • Adding an external agent through the interactive flow writes only to the settings file being edited, instead of copying merged project and local settings across scopes

    • A symbolic-ref rejection from ref compare-and-swap is no longer misreported as a retryable lock error

    Housekeeping

    • Literal branch names are validated with go-git instead of git check-ref-format, with characterization tests pinning native Git behavior ahead of further go-git migration

    • Removed Pi's unused active-session cache file

    • E2E fixes: Codex runs without its app-server daemon (0.157+) and waits on the composer rather than the startup dialog, pinned to gpt-6-luna; agent installs retry and the Antigravity leg is authenticated; the control-plane suite is fixed and now runs on PRs

    • Bumped posthog-go to 1.25.3

    • Added the v0.11.2 changelog

    Thanks

    Thanks to @MuskanPaliwal for fixing session token totals reset by condensation, pushurl-only checkpoint remote election, GIT_COMMON_DIR leaking into targeted git commands, settings-scope leaks when adding external agents, symbolic-ref error classification, and removing Pi's unused session cache! Thanks to @jaysomani for embedding Windows version metadata in the binaries!

  13. Changed

    • Trail, review, thread and watch requests follow the RFD-026 cell contract (snake_case payloads, bracket filters, cursor pagination, dotted watch event names). --json output keeps its existing keys. replaces --offset with --cursor and returns next_cursor alongside has_more when another page exists

    Fixed

    • A trailing .git in a native repository reference is now part of the repo name instead of being stripped. Previously could delete a sibling repo named foo, and repo-scoped commands inside a clone of foo.git targeted foo. Confirmation lines now show the repository the server resolved, repo create accepts .git names as the API does, and dot-only owner or repo names are rejected

    • ENTIRE_CHECKPOINT_TOKEN is only attached when the checkpoint remote uses a direct git transport. entire:// and file:// remotes are used as configured and are never rewritten into credentialed HTTPS URLs

    • Session IDs containing surrounding whitespace, trailing periods, ASCII control characters or Windows reserved device names are rejected on every OS. Unsafe checkpoint metadata is refused before session files are resolved or restored, and external-agent session references are checked against the repository session store before write-session runs

    Housekeeping

    • Removed filtered_fetches from this repository's .entire/settings.json

    Thanks

    Thanks to @wernerkasselman-au for responsibly reporting the session ID path validation issue!

  14. Breaking changes and migrations

    • Control-plane commands are renamed without compatibility aliases. auth use is now auth switch, repo get is repo view, repo visibility set is repo edit --visibility, repo list <project> takes --project, repo mirror create|use become repo mirror add and repo remote use, and repo mirror collaborators list becomes repo access list; positional cluster arguments become --cluster. becomes . Update scripts using the old spellings

    • processes every saved login and revokes CLI sessions on other machines too. Older servers fall back to revoking only the current session. Browser and web sessions remain active unless --everywhere is passed. --all-contexts is removed, explicit --context is rejected, and Ctrl-C stops the sweep

    • initializes repositories locally without creating or pushing a GitHub remote. --repo-name, --repo-owner, --repo-visibility, --no-github and --push are removed; publish separately. Git initialization, identity setup and the optional initial commit are unchanged

    • Mirror creation always uses the asynchronous workflow. Remove the retired async_mirror_requests key from settings files; strict decoding rejects it

    • moves to the entire-investigate plugin. Install with or accept the install prompt; existing flags are unchanged. Copy the old investigate settings object into .entire/investigate.local.json; legacy settings blocks are ignored

    Added

    • Native repository references (/et/<project>/<repo>) are supported by repo view, delete, visibility, protection, grant and checkpoint explain --repo. Ambiguous bare owner/repo references are rejected with forge-qualified suggestions. also accepts native repos and sends forge-qualified slugs

    • supports native repositories. repo clone and repo remote url offer an interactive choice of the home cluster and ready native mirrors. Non-interactive runs use the primary cluster unless --cluster <host> is supplied; GitHub mirrors use the same selection flow

    • shows regions, cluster slugs and validated hosts for use with commands such as org create --region and repo clone --cluster

    • prints a repository's git remote URL and nothing else, so an existing local checkout can be connected with git remote add entire "$(entire repo remote url /et/project/repo)". It works outside a git checkout and keeps placement prompts on stderr

    • manages branch protection rules. Empty results distinguish unprotected native repositories from GitHub mirrors whose rules are managed upstream

    • without an argument offers a saved-context picker. It and auth contexts consistently mark the active context

    • Subagent tracking for Codex and Copilot CLI. Codex reports child token totals only with exact coverage. Copilot supports modern agent IDs and unambiguous name matching on 1.0.63; task records explain when child transcripts are unavailable

    • asks which git remote should receive checkpoints, and --checkpoint-push-remote <name> selects one non-interactively. The override is written to .entire/settings.local.json only, leaving automatic election in place when you keep the current destination

    • accepts gitlab:<owner>/<repo>. Mirror push-through, the trails API, issue linking and entire.io checkpoint discovery remain GitHub-only

    • OpenCode can generate summaries and tailor runners: works for checkpoint explain --generate and runner setup. The adapter runs in a temporary directory with a dedicated tool-denying agent and sharing disabled

    • offers to install the Graph plugin on demand, with confirmation and progress on stderr. Non-interactive runs print an hint; stdout remains reserved for plugin output

    • waits up to 10 minutes for provisioning by default. --no-wait skips waiting; --wait-timeout changes the limit. If readiness cannot be confirmed, the command prints the created repository and recovery instructions and exits nonzero. repo view reads registry details by default; pass --authoritative to check provisioning status

    • fills missing repo-local git identity fields from the verified Entire profile without overwriting configured values. It signs in when needed, or provides ENTIRE_TOKEN guidance in detected automation

    • automatically uses device-code authentication on Linux and BSD without a graphical display, including headless sessions not detected as SSH. WSL and an explicit BROWSER are excluded

    • Nightly smoke tests install published artifacts on Linux, macOS and Windows and verify agent checkpointing. A stable-install job also tests the documented Homebrew command

    • A control-plane E2E suite covers device-flow login and organization, project and repository lifecycle operations without a coding agent, using isolated credentials and automatic resource cleanup

    Changed

    • Data-API commands and links follow ENTIRE_TOKEN or the selected login's environment rather than defaulting to production. and -j <jurisdiction> use that login's cluster catalog. Commands acting as a saved login announce the context on stderr when multiple logins exist

    • propagates to child processes through ENTIRE_CONTEXT, fixing inconsistent login selection in repo clone, resume, explain and trail create. Unknown context names are rejected before spawning children

    • reports one entry per session, with session_id, worktree_path and branch, instead of collapsing sessions for the same agent

    • The hidden command and its enforcement are removed. Its policy ref used a server-reserved namespace and could block repository mirroring

    • Redaction and transcript reads use less memory and avoid repeated searches for duplicate findings. Redaction output and fingerprints are unchanged

    • Agents no longer display a Preview suffix during setup. Agent.IsPreview and the external-agent info field is_preview are removed; external agents still emitting the field remain compatible

    • Removed an unreachable wrong-cluster hint from git-remote-entire and outdated semantic-search rollout wording

    Fixed

    • Imported checkpoints, including onboarding imports, carry a validated anchor commit to prevent hydration failures. The anchor must be a full hex commit ID; validation also applies to --dry-run. Existing imports are not repaired

    • Fixed missing factoryai-droid checkpoints on Windows by installing native cmd.exe hook wrappers, including on hosts with Git Bash

    • Managed plugin executables work on Windows without symlinks. Fixed the hardlink fallback on all platforms

    • Interactive prompts use native Windows console handles. Plugin confirmations no longer require an extra keypress to close the prompt

    • Commands run through Cursor's or OpenCode's shell tools no longer show unattended interactive prompts

    • Already-committed files are no longer checkpointed again at turn-end. Comparisons against HEAD respect autocrlf, .gitattributes and Git LFS without refreshing the index

    • respects a valid checkpoint push remote, and status correctly reports disabled session pushing. Checkpoint fetches retain the selected read remote, fixing missing metadata and transcripts in clones with inherited checkpoint-remote settings

    • Rejected checkpoint pushes preserve the remote's explanation, including secret-scanning and repository-rule failures. Confirmed policy and hook rejections no longer trigger speculative fetch/replay or get mislabeled as divergence

    • uses agent session IDs and process ancestry instead of selecting the most recently active session, avoiding misidentification across worktrees and nested agents. Ambiguous matches are reported explicitly. session adopt does not yet enforce caller identification

    • no longer deletes stale records or finalizes exited sessions while reading them. Cleanup remains with doctor and the session sweeper

    • Mid-turn commits record subagent tokens even when no shadow branch is resolved. Totals remain checkpoint-scoped rather than repeating cumulative usage

    • Checkpoints remain visible in checkpoint list and explain when a case-insensitive filesystem changes the casing of a shard directory

    • Native repositories shared by a direct pull grant resolve by /et/ path without requiring project-level access. This fixes cloning and name resolution for repository management and cell-routing commands; each operation still requires its own permissions

    • Unsupported summary providers produce an actionable error listing supported agents. also detects invalid provider settings

    • and auth status no longer count null or nameless entries in contexts.json as saved logins

    • Shell completion installation and E2E transcript writes report file-close errors instead of silently accepting potentially incomplete writes

    • Optimized the duplicate-key scan added in for large JSON objects while preserving unconditional detection

    Security

    • Restored the cross-host redirect guard on cross-jurisdiction token exchanges after a regression between and . This prevents redirects from forwarding login tokens to another host or accepting substituted tokens. Exchange URL validation remains in place

    • Git hook installation uses confined filesystem operations, rejects symlinked hook directories and preserves foreign symlinked hooks. doctor reports unsafe hook directories. External summary-provider discovery requires the external_agents grant, and branch-name validation is strengthened

    • JSONL redaction verifies replacements even when strings use alternate JSON encodings, falling back to structural rewriting or failing closed. Custom investigate and review prompts also require trusted settings before being passed to agents with approvals disabled

    • GitHub Actions jobs declare explicit least-privilege token permissions. CodeQL scanning is limited to languages used in this repository

    Housekeeping

    • Repository instructions are split into a compact CLAUDE.md and task-specific development references, with tests enforcing the root-file size budget and local documentation links. AGENTS.md remains a symlink

    • Homebrew installation uses a single fully qualified cask command compatible with Homebrew 6's tap trust. The copyable command no longer includes a comment that fails in default interactive zsh. Requires Homebrew 6.0.10+

    • Updated Go from 1.26.6 to 1.27.1 and golangci-lint from 2.11.3 to 2.13.2, resolving findings from the updated linters

    • Dependency bumps: gofrs/flock, mattn/go-runewidth, posthog/posthog-go, golang.org/x/crypto, golang.org/x/mod, golang.org/x/sync, golang.org/x/sys, and aws-actions/configure-aws-credentials

    • All E2E agent runners honor E2E_TIMEOUT and per-test prompt timeouts. Malformed timeout values produce an error

    • Consolidated E2E workflows with agent and test-regex selection. Nightly smoke failures now mark the individual agent's step as failed

    • Codex E2E tests no longer use the retired gpt-5.4-mini. Multi-session prompts allow hook-added checkpoint trailers

    • Fixed a terminal-test race, macOS path comparisons and ENTIRE_TOKEN test isolation. Redaction fixtures no longer embed a complete AWS-key-shaped value that triggers push protection

    • Removed .opencode/package-lock.json from version control and tracked .opencode/.gitignore so fresh clones inherit its rules. Removed the repo-local trail-summary runner to prevent self-triggered trail-body updates

    Thanks

    Thanks to @KC1706 for fixing checkpoints silently disappearing from list and explain when a case-insensitive filesystem folds a shard directory's case!

  15. Added

    • A Windows PowerShell installer, scripts/install.ps1, works under both Windows PowerShell 5.1 and PowerShell 7: irm https://entire.io/install.ps1 | iex. It resolves stable and nightly releases, verifies SHA-256 checksums, installs entire.exe and git-remote-entire.exe, and delegates to Scoop for stable installs when Scoop is on PATH. Update nudges now print that one-liner — naming the directory the running binary lives in, so the installer replaces it in place — instead of sending you to the GitHub releases page. Install detection is per-OS (brew and mise on unix, Scoop and mise on Windows) and honours relocated install roots

    Changed

    • Reworked flags and interaction flow. Interactive setup now asks whether to tailor runners or create generic defaults; -y selects tailoring, replacing the deprecated --run. --print-prompt preserves the previous default behavior, --defaults-only creates generic runners, and --dry-run previews tailoring without writing files. --agent <name> skips provider selection for this run without changing saved settings. Non-interactive use requires an explicit mode

    Fixed

    • now runs pre-push hooks when pushing the trail branch, allowing existing checkpoints to sync through the normal push path. Hook output and prompts are streamed instead of buffered, so checkpoint sync failures and OPF prompts remain visible

    • commands work against Entire-native repos. Trail resolution discarded the forge and looked up <owner>/<repo>, so a native /et/<project>/<repo> remote with a same-named legacy GitHub mirror — entirehq/marvin — returned the /gh/ repo's trails. The et namespace is now preserved through resolution, native repos are addressed by repository ULID against their home cell, and list, show, update, delete and runner trail gathering all follow

    • A named pipe where Entire expects a config file no longer hangs the process. mkfifo .claude/settings.json made block in openat until SIGINT, because open(2) on a FIFO with no writer waits for one. Every no-follow read now refuses a non-regular leaf before opening it, which covers all nine agents, the plugin manifest, doctor's log readers and the settings loader

    • no longer silently drops Vercel deployment blocking in a repo whose vercel.json is an absolute symlink into a monorepo's shared config. os.Root refuses an absolute link target unconditionally, even one landing inside the root, and the refusal is not "file not found" — so the check reported path escapes from parent and returned false

    • A concurrent checkpoint write can no longer silently discard an OPF rewrite. The OPF paths used go-git's compare-and-swap, which does not take native Git's reference lock, so a native transaction landing afterwards overwrote the rewrite while both reported success. Ref updates now go through a native git update-ref --stdin transaction that holds the lock across the symbolic-ref check, with a bounded retry for transient lock contention and a terminal error for a genuine stale value

    • Session and checkpoint file locks revalidate the locked file's inode after acquiring, and retry against the current file if the name has since been replaced

    • reports a regular file, FIFO, socket or device node where an agent directory belongs. It tested for a symlink and nothing else, so those came back clean while every hook install and os.Root open failed on them; a regular file at .claude was additionally reported as NOT READABLE with a permissions remedy that could not fix it. .claude/agents/, .codex/agents and .gemini/agents are also scanned now, and a worktree root that will not open is reported rather than passing silently

    • The repo docs embedded into the tailoring prompt sends to the model are truncated on a rune boundary. The cap is a byte budget applied to text described in characters, so a doc whose 6000th byte landed inside a multi-byte rune put invalid UTF-8 into the prompt. A file that is not UTF-8 to begin with keeps its own bytes rather than being reduced to a truncation marker

    Security

    • The migration command's opt-in "Push N migrated checkpoint ref(s) now?" applies the OpenAI Privacy Filter. With redaction.openai_privacy_filter.enabled set, answering yes sent 8-layer content to the remote untagged — the skip outcome without the decision ever being resolved or surfaced, and the opposite safety to answering no, which left the refs queued for the next git push, where OPF does run

    • external_agents joins openai_privacy_filter.command behind the settings trust gate: it is honored only from a verified-untracked .entire/settings.local.json, because it grants execution of every entire-agent-* binary on $PATH and a committed one-line JSON diff does not read as executable to a reviewer. Rejection is a downgrade with the reason surfaced by , not a hard error. Every $PATH scanner now returns only absolute entries, and the external-agent runner refuses a non-absolute binary path before spawning — Go's own ErrDot protection does not reach a scanner that resolves by glob, and the scanner executes what it finds

    • Pi's .pi/extensions/entire/ is created, read, written and removed through the worktree anchor like the other eight agents, so a repository shipping a symlinked .pi no longer has install through it — and uninstall RemoveAll through it — without the user ever naming pi, which matters because pi is auto-detected. The uninstall guard is stated positively as "a directory Entire named" rather than as a blocklist, so an agent whose config sits one level below its root cannot reach RemoveAll on the user's own config

    Housekeeping

    • Physical git worktree metadata — git dir, common dir, worktree id — has one owner, gitrepo.ResolveWorktreeMetadata, resolved once per open and passed into repository storage, alternates inspection and reftable inspection. The checkpoint package's duplicate traversal, its git rev-parse --git-common-dir subprocess, and the mutex and cache compensating for it are deleted; inspection errors now reach the caller instead of reading as "feature absent"

    • The e2e-tests (opencode) leg is green again and runs in 469s rather than timing out at 1266s. opencode forks a background 27-package plugin install for every .opencode directory it finds and then blocks on all of them with no timeout and no output, so each of the ~40 fresh test repos paid it — in-process via @npmcli/arborist, measured at 5m00.9s against npm install's 3s for the identical tree. The tree is now built once and seeded into each repo, and opencode's own logs are collected into the artifacts, which is what made the diagnosis possible

    • Test fixes for failures that named the wrong cause: a leaked goroutine in the reentrant-clear test panicked the whole strategy package run from a t.Errorf after completion; TestRootBasesAreTrusted accused its own detection pattern of going stale when git was configured to colorize into a pipe; the versioncheck probe tests read the host's mise and Scoop roots, and three unix-only tests were untagged. Brew-before-mise probe precedence is now pinned, since it decides whether a user with both installs is told to run brew upgrade

    Thanks

    Thanks to @MuskanPaliwal for serializing OPF ref updates against native git's reference lock, and for splitting git metadata resolution onto a single canonical owner!

    Thanks to @Rohitkanithi for the flock inode revalidation!

  16. Changed

    • Mirror creation goes through the control plane's async request routes by default, reporting queued, placing, and cloning progress instead of holding one request open for the whole placement; the async_mirror_requests setting it shipped behind in 0.10.4 now defaults on. Opt out with "async_mirror_requests": false. In async mode --wait-timeout is one deadline across submission, placement, and clone readiness, not clone readiness alone

    • Entire no longer installs a Read(./.entire/metadata/**) deny rule into Claude Code's or Factory Droid's permission config, so agents in auto mode stop prompting for permission on ordinary commands. A deny rule is a hard block auto mode's classifier cannot get past, and it matched on the path being named rather than on anything being read, so a recursive grep from the repo root needed hand approval. clears one an older CLI left behind and repairs it

    • takes the repo id from the placement lookup that already chose its cell, and now tells "not onboarded" apart from "processing placement failed or suspended" instead of guessing at three causes

    Fixed

    • A session's full.jsonl is released from .entire/metadata once its content has been condensed into a checkpoint. Nothing ever emptied that staging buffer, so transcripts accumulated in the worktree forever after being committed and pushed — 460 MB across 392 session directories in one checkout. Existing files are not reclaimed automatically

    • git clone entire://<cluster>/… works again when your active login is on a different federation and exactly one saved login can authenticate that cluster; the CLI uses it and names it on stderr. --context and $ENTIRE_CONTEXT are unchanged

    • says it is waiting for a session lock instead of stalling with no output

    Security

    • A cluster's /.well-known/entire-cluster.json can no longer advertise login servers outside its own registrable domain. That document decides which saved login's JWT is sent to the host as a bearer, so a hostile cluster naming foo.auth.entire.io in core_urls was handed a real entire.io token — through --context, the active context, and ENTIRE_TOKEN alike. Choosing a login for you is additionally limited to Entire's own sites

    • verifies a cell's response is for the repo and checkpoint that were requested before caching or rendering it, and labels the result with the server's own checkpoint ID. A wrong-repo or wrong-checkpoint response would otherwise have rendered as belonging to the repo you asked about

    • Clearing a session's state file takes the same per-session gate every other write to that file takes. A concurrent, properly locked write landing between the "safe to clear" decision and the delete was destroyed silently

    • docs/security-and-privacy.md discloses what happens to a pasted image: no redaction pass reads image content, there is no OCR or vision scan, and the outcome is per-agent — unredacted inline base64 on Claude Code, destroyed by the entropy layer on Codex, not stored at all on Cursor

    Housekeeping

    • The cross-jurisdiction HTTP transport (421 follow plus RFC 8693 token exchange) moves to entireio/auth-go's crossjuris package, shared with entiredb and entire-ci

  17. Security

    • Bumped golang.org/x/crypto to v0.54.0, closing 13 Dependabot alerts (7 critical, 3 high, 3 medium), all of them in its SSH implementation. Raised as an indirect dependency via minimal version selection, since go-git still asks for v0.51.0; lifts golang.org/x/net to v0.56.0 and golang.org/x/sys to v0.47.0

    • Bumped go-git to v6.0.0-alpha.5, clearing two advisories govulncheck reported as reachable from git-sync's own call graph: GO-2026-6214, path traversal via crafted reference names, reached where convert-sha256 writes advertised refs to disk; and GO-2026-6213, worktree operations following symlinks. Pulls go-billy to v6.0.0-alpha.2 transitively

    • Bumped the Go toolchain to 1.26.6 (go.mod toolchain and the mise pin), clearing ten standard-library advisories reachable from the HTTP transport and the convert-sha256 filesystem paths — among them quadratic complexity in net/url resolvePath, an os root escape via symlink plus trailing slash, and an HTTP/2 infinite loop on a bad SETTINGS_MAX_FRAME_SIZE. Released binaries are built from the go.mod toolchain, so they carried these until now; govulncheck ./... goes from 12 called vulnerabilities to 0

    • Explicitly supplied credentials are now bound to the host you named. Under --source-follow-info-refs-redirect / --target-follow-info-refs-redirect, git-sync addresses the host /info/refs redirected to directly for the follow-up RPCs, and re-attached the configured token to those requests after Go's http.Client had deliberately stripped the Authorization header on the cross-host hop — so any redirect an attacker could cause (an open redirect on the real host, a hostile mirror, a man-in-the-middle on a plain-http source) collected a token that on the target side typically carries write access. A token now goes only to the host named on the command line and its subdomains, on the same port and without a scheme downgrade, and anything else falls through to the credential helper with a warning naming the withheld host. Credentials resolved from the helper are unaffected — those were always looked up keyed on the host being challenged

    • Ref names from a remote are validated before git-sync acts on them. Unchecked names reached two places where a malformed one matters: convert-sha256 writes them to disk, where refs/heads/../../config escapes refs/heads (go-billy clamps the traversal at the repository root, so the reachable damage is overwriting config, HEAD, or packed-refs); and ref-update commands embed them in the receive-pack request, where a NUL lets the source inject a capability list into the push git-sync sends to the target. Advertised names now go through plumbing.ReferenceName.Validate — git's own check_refname_format, so nothing git accepts is affected — at both decode boundaries, on the source and target side. A failing name is skipped with a quoted warning rather than failing the run; names supplied through --map are rejected outright at startup

    • A packfile object header can no longer request an unbounded allocation. ExtractCommitParents sized its per-object buffer from the size the pack header declares, which go-git validates only for varint overflow — so the value is remote-controlled up to int64, and a 48-byte pack declaring a 128 TiB object produced fatal error: out of memory, a Go runtime fatal an embedding process cannot contain with recover(). Declared sizes above 64 MiB are now rejected (this path reads tree:0-filtered packs, whose objects are commits and tags measured in kilobytes) and the initial buffer is capped at 64 KiB, so the allocation tracks bytes actually received. Reachable from ordinary planning, via FetchCommitParents during ancestry checks

    • SSH repository paths are now shell-quoted in full. shellQuotePath exempted the segment before the first slash when the path began with ~, leaving it for the remote login shell to expand — and a SCP-style URL puts attacker-influenceable text in exactly that position: git@host:~a;id/repo.git produced the remote command git-upload-pack ~a;id/'repo.git', executing id on the remote host as the authenticated SSH user. This matters wherever only part of the URL is caller-controlled, such as a repository path templated into a fixed host or one arriving from a webhook. Quoting the whole path costs nothing, because git-upload-pack resolves it through enter_repo(), which interpolates a leading ~ itself

    • Credentials embedded in a remote URL are no longer echoed. probe and fetch carried Source.URL/Target.URL verbatim into their results, which are printed to stdout and serialized into --json — so https://user:token@host/repo.git, the standard CI form, put the token in output that automation collects; the URL-parse failure path leaked it too, since url.Parse embeds the raw URL in its error. All of these now redact the whole userinfo component via the new internal/redact package, which also replaces url.URL.Redacted() in HTTP error messages: Redacted() masks only the password, leaving a token in the username position — how GitHub App and PAT URLs are normally written — in the clear

    • The materialized object limit is enforced while the pack streams, not after. FetchToStore filled the in-memory store with no cap, and --materialized-max-objects (default 500,000) was checked against the object closure only once the fetch had finished — by which point the objects were resident and the process may already have died, so the guard reported an overrun it exists to prevent. The store now enforces the count as objects are decoded, failing the write that would exceed the limit, with an ErrObjectLimit sentinel and an ObjectLimitError carrying the limit. The cap applies per fetch rather than cumulatively, because a store outlives one fetch and the materialized tag refill legitimately resends objects already present, so worst-case residency is the limit times the number of fetches — two on the sync path. The unstable Fetch path now actually threads MaterializedMaxObjects through, having previously accepted and dropped it

    • Advertisement reads are bounded on every transport. The HTTP path capped /info/refs at 64 MiB, but the SSH transport read the advertisement with a bare io.ReadAll and the remote-helper transport accumulated pkt-lines until a flush that a remote need never send — either grows until the process dies. All three now share one MaxAdvertisementBytes ceiling, and hitting it tears the producer down rather than leaving a subprocess blocked on a full pipe and hanging Wait forever

    • The commit-graph pack spill to disk is bounded. ExtractCommitParents copies a non-seekable pack into a temp file to give the parser a seekable source, with no limit on the copy, so a source could fill the disk during what is only a planning round trip. Capped at 4 GiB

    • Server-authored text is stripped of terminal control characters. Sideband progress, up to 64 KiB of HTTP error body, receive-pack ng rejection reasons, diagnostic response headers, and ssh's relayed remote: output all reached terminals, log files and --json results unfiltered, so a hostile remote could redraw the line its message was printed on — making a rejected push read as a successful one — or smuggle control characters into whatever ingests the JSON. All five paths now go through internal/sanitize, which drops everything below 0x20 plus DEL. Carriage return survives only in streamed progress, where git's in-place updates depend on it; one-shot messages lose it, because a bare CR rewrites the line on its own (rejected\rok refs/heads/main reads as a success with no escape sequence involved). Rejection classification still runs on the raw status, so filtering cannot change whether a rejection is treated as a concurrent move

    • Whether TLS verification is disabled is now derived from the transport. HTTPConn.InsecureSkipTLSVerify was a field callers had to set to match the client they passed in, and the cross-host credential guard depends on it — so a caller who disabled verification on their transport but forgot the field silently lost that protection, which is the wrong direction for a security check to fail. The transport is now inspected directly, following Unwrap through wrappers so an instrumentation layer cannot hide the setting; the explicit field still forces the guard on for transports that cannot be inspected

    • Release artifacts now carry signed build provenance. checksums.txt was the only integrity signal and was itself unsigned, so someone downloading a Linux archive plus its checksum had no way to establish that either came from this repository — macOS binaries were signed and notarized, but nothing else was. The release workflow now attests the archives and the checksum file via actions/attest-build-provenance, verifiable with gh attestation verify <file> --repo entireio/git-sync. README documents the check

    • Added permissions: contents: read to the Tests and License Check workflows, which previously inherited the repository default while running PR-controlled code. lint.yml already declared it. Defence in depth — GitHub already restricts the token for fork PRs — but same-repo branches are not restricted

    Added

    • SyncPolicy.AllowEmptySource — an empty source can now be an outcome instead of an error, when a source of truth says so. Replicate previously failed any run whose planning produced no desired refs, with one message (no source refs matched) covering unrelated conditions: the source has no refs, the source has refs the requested scope excluded, and the source has refs this reader was never shown. A caller could not tell them apart, and the first is not always a failure — a mirror of a repository that has never been pushed to is trivially up to date. With the policy set, Replicate reports them separately: ErrNoRefsSelected when the source does advertise refs, ErrSourceEmptyUnverified / ErrTargetEmptyUnverified when either side's emptiness could not be established, ErrSourceEmptyTargetPopulated when the source is empty while the target still holds refs (a real divergence — refused rather than converged, since converging means deleting them), and a zero-plan success with ExecutionSummary.Converged when source and target are both empty and therefore already agree.

      git-sync does not decide that a repository is empty, and will not guess. It cannot: ref hiding is designed to be invisible to the client, so a hidden ref and an absent one are the same observation. An unborn HEAD does not close the gap either — git emits that line for any dangling HEAD, so a repository holding refs/heads/other with HEAD pointed at a never-created refs/heads/main reports unborn, and hiding that branch reduces its entire advertisement to the unborn line alone (verified against git 2.53). The assertion is therefore an input: SyncPolicy.SourceAssertedEmpty, which the caller supplies from a repository-state query that sees past hiding.

      The target needs the same treatment, via SourceAssertedEmpty's counterpart TargetAssertedEmpty, and for a sharper reason: receive.hideRefs omits matching refs from receive-pack's advertisement, so a populated target can advertise nothing but the bare capabilities^{} sentinel — and because receive.hideRefs and uploadpack.hideRefs are separate settings, a ref hidden from the push side is still served to fetchers, so a target wrongly judged empty is one whose readers see refs the source does not have.

      What git-sync contributes is a consistency check on those claims, and it only ever refuses. Before reporting convergence it independently requires an empty advertisement on each side, an unborn HEAD on the source (now requested via protocol v2's ls-refs=unborn where the server advertises it, and surfaced as RefService.HeadUnborn), no advertised ref name dropped as invalid on either side, and no visible target ref within the request's scope (an excluded namespace the run would neither push nor prune is not divergence). None of those can promote an absent assertion into a success, so a caller cannot get a false converge out of a compliant server, and a caller that supplies no assertion gets ErrSourceEmptyUnverified or ErrTargetEmptyUnverified no matter what the wire says. The unborn line's symref-target is deliberately not surfaced as SourceHEAD, which consumers read as a branch that exists.

      Off by default: without the opt-in an empty source still fails with the historical message, and the new sentinels deliberately do not carry that text so a caller still matching on it cannot mistake a divergence for the old benign no-op. The policy is replicate-only and requires RefScope.AllRefs — under a narrower scope the source ref listing is itself narrowed, so an empty result says nothing about the repository as a whole — and both requirements are now rejected at the request edge rather than accepted and silently discarded. Convergence also requires protocol v2 on the source leg, since the unborn cross-check has no v1 equivalent: ProtocolV1 is rejected at the request edge, and an auto source that falls back to v1 mid-run reports that the protocol cannot carry the signal rather than implying the server withheld refs.

      One thing does change for every v2 caller, opt-in or not: unborn is appended to each ls-refs request whose server advertises support for it (see docs/protocol.md). It adds no round trip and a source with commits answers exactly as before, but the request bytes differ, so a test asserting on the exact ls-refs body will need updating. Only the reader of the resulting flag is gated on the policy

    • A Vulnerability Scan workflow running govulncheck ./... on pull requests, pushes to main, and a weekly schedule. The existing lint suite cannot see this class of issue, and the weekly run matters because advisories are published against versions already in go.mod — without it, a newly disclosed vulnerability goes unreported until someone happens to open a PR

  18. What's Changed

    • Stop credential tokens leaking into usage output by @Soph in

    • Enforcing stricter input validation for SSH destinations by @Soph in

    • Fix nil-pointer panic in checkpoint parent-load error path by @Soph in

    • Consume positional source/target left-to-right across commands by @Soph in

    • Include the port in the git-credential host field by @Soph in

    • Carry Scope.Mappings into the fetch config by @Soph in

    • gitproto: classify create-side CAS races (already exists) as ErrTargetRefMoved by @nodo in

    • Keep a pack-observer Scanner error from aborting the upload by @Soph in

    • Treat a pack-less v2 fetch response as an error, not success by @Soph in

    • Release session resources on partial-setup and error paths by @Soph in

    • Move internalbridge under internal/ so it is truly unimportable by @Soph in

    • go.mod and test hygiene by @Soph in

    • Don't mutate the caller's managed map in BuildPlans by @Soph in

    • git-sync-bench: exit non-zero on failed runs, drop -1 sentinels by @Soph in

    • Make the token-store file lock compile and work on Windows by @Soph in

    • Batch ref-update commands to stay under receive-pack cap by @Soph in

    • Remove the Entire DB credential-store integration by @Soph in

    • Support git remote-helper schemes (entire://) as a transport by @Soph in

    • refscope: add ExcludeRefs for exact ref-name exclusion by @nodo in

    • Simplify: remove pass-through layers, dead code, and copy-pasted helpers by @Soph in

    • adding runners config, used "entire runner setup" by @Soph in

    • enable ref backend for git-sync by @Soph in

    • Bump golang.org/x/net to v0.55.0 (CVE-2026-25680) by @Soph in

    • Add SetIdentity for embedder User-Agent attribution; derive default version from build info by @toothbrush in

    • Cut 0.8.0 release section in the changelog by @toothbrush in

    New Contributors

    • @toothbrush made their first contribution in

    Full Changelog: https://github.com/entireio/git-sync/compare/v0.7.0...v0.8.0

  19. Added

    • Typed push-rejection errors on the public API. Sync/Replicate now report a *RefRejectedError (carrying the rejected Ref and the raw server Reason) for per-ref receive-pack ng statuses, reachable with errors.As. Rejections that are unambiguous concurrent target-ref moves — entire-server's compare-and-swap rejection (remote ref has changed) and git's --force-with-lease lease miss (stale info) — additionally satisfy errors.Is(err, ErrTargetRefMoved). This lets embedders distinguish a benign racing concurrent push (retryable) from a genuine push failure without substring-matching the free-form error message. Ambiguous markers (non-fast-forward / fetch first) are deliberately excluded from the move classification so a real "needs --force" rejection is not masked. The ForceWithLease lease-failure escalation (raised even under BestEffort) also satisfies errors.Is(err, ErrTargetRefMoved), though it is not itself a *RefRejectedError — prefer errors.Is over errors.As when you only need the cause. The error message and the underlying value-typed packp.CommandStatusErr are preserved unchanged (reach it with a value errors.As target), so existing checks keep working

    Fixed

    • Concurrent target-ref rejections are now actually classified — errors.Is(err, ErrTargetRefMoved) and errors.As(err, *RefRejectedError) match on the real push path. go-git returns packp.CommandStatusErr by value from ReportStatus.Error(), but asRefRejectedError / annotateLeaseFailure used a *packp.CommandStatusErr (pointer) errors.As target, which never matches a value in the chain — so every live receive-pack ng status passed through unclassified and ErrTargetRefMoved was never reported. Both now use a value target, and a regression test drives a real ReportStatus.Error() end to end so a pointer-vs-value relapse fails CI. (Bug in the typed-rejection feature above — never shipped in a tagged release.)

    • Batched bootstrap no longer dies when finalizing a subsumed branch against a receive-pack that requires a pack for every non-delete command. The pack-less ref-create sent only command pkt-lines, which strict servers rejected with unpack error: ... read packfile header: EOF (observed mid-run mirroring to entiredb prod, leaving the target half-populated); git-sync now sends a valid empty pack with such creates

    • Large or slow bootstrap relays that outlast the target's git-receive-pack deadline (GitHub HTTP 408, or gateway 504) now fall back to batched bootstrap with checkpoint subdivision instead of hard-failing. Previously only 413 body-limit rejections triggered batching, so relaying a large repo over a slow source link — where the upstream read rate throttles the downstream write past GitHub's receive-pack window — failed with a bare http 408 and no remediation. Timeouts are classified distinctly from size rejections, the auto-batch notice names the cause, and a one-shot failure with no batched fallback (source lacking protocol-v2 fetch-filter support) now carries actionable guidance

  20. Added

    • git-sync convert-sha256: one-off conversion that fetches a pack over smart HTTP from a SHA1 source, walks every reachable object via a two-pass topological DFS, and writes a fresh SHA256 bare repository with every tree/commit/tag reference re-encoded — including abbreviated SHA1 prefixes in commit messages. All branches and tags are always converted to avoid stranding cross-branch references; sharp edges and operational characteristics are documented in docs/convert-sha256.md

    Changed

    • HTTP auth now matches git's own flow: try anonymous first and only consult the credential helper after a 401, instead of proactively running git credential fill for every endpoint. This stops git-sync from dropping into an interactive Username:/Password: prompt on unauthenticated hosts and from leaking tokens to public repos. Expired credentials (401, or 403 from token services like Cloudflare) trigger a helper reject so the next run starts clean; the helper runs with GIT_TERMINAL_PROMPT=0 to fail fast rather than block on a tty

    • Outbound requests now identify git-sync in the User-Agent instead of advertising only go-git's default. Git wire-protocol traffic (smart-HTTP info-refs, upload-pack/receive-pack, and the protocol v2 agent= capability) sends git-sync/<version> go-git/<v> to preserve go-git attribution; non-git HTTP (the GitHub repo metadata call during bootstrap) sends just git-sync/<version>. A new internal/useragent package centralises the format, wired from versioninfo.Version at startup so --version and the User-Agent agree, and overridable by SDK consumers

    • Bootstrap planning streams the commit-graph fetch instead of materializing the full commit set: a new ExtractCommitParents path parses the tree:0 pack incrementally, extracting only (commit -> parent hashes) tuples with a bounded LRU for delta resolution. On torvalds/linux this cut peak Go heap from 5.42 GiB to 1.47 GiB (-73%), peak RSS from 5.69 GiB to 1.63 GiB (-71%), and wall time from 32m to 19m (-40%)

    Fixed

    • Materialized push against CDN-fronted HTTP targets (e.g. Cloudflare) no longer fails mid-upload with use of closed network connection. Two independent causes: a stale keep-alive pool entry expiring on the CDN edge during the gap between info-refs and receive-pack (fixed by disabling keep-alives on the default transport), and a mid-stream stall while go-git ran delta selection synchronously inside Encode() (fixed via packfile.WithObjectSelector to run selection up front and stream the write phase through io.Pipe). Adds GITSYNC_HTTP_TRACE=1 for per-request lifecycle tracing with redacted auth, plus in-place verbose progress for the materialized encode/write phases

    Housekeeping

    • Bump go-git to v6.0.0-alpha.4

  21. Added

    • SSH transport: ssh://, SCP-style git@host:path.git, and git+ssh:// remotes via the local ssh binary, with one process per logical RPC so v2 and batched flows work correctly. SSH config-driven user/key behavior is honored, and a clear error is raised when ssh is not on PATH

    • --all-refs for mirroring arbitrary refs/* namespaces (notes, pulls, custom) beyond refs/heads/* and refs/tags/*. For sync and bootstrap it bundles a best-effort failure mode that downgrades per-ref receive-pack rejections to warnings (surfaced via Result.Warned and JSON warned), so mirroring into hosts with hidden refs like GitHub refs/pull/* works. replicate keeps strict semantics. Library exposes RefScope.AllRefs, SyncPolicy.BestEffort, RefKindOther, and ActionWarn

    • Bootstrap pushes the source HEAD's branch first, so hosts that pick the default branch from the first push on a fresh repo (GitHub, GitLab) end up with the right default automatically. The source HEAD symref is also surfaced on Result and ProbeResult (execution.sourceHead / sourceHead in JSON)

    Changed

    • --force is replaced by two explicit flags: --force-with-lease (previous lease-protected behavior) and --force-blind (zero expected-old, overwrite regardless — matches git push --force). The flags are mutually exclusive; legacy --force errors out with a migration hint. bootstrap and replicate continue to reject force flags entirely. SyncPolicy.Force splits into ForceWithLease and ForceBlind. Lease-failure ng responses from receive-pack are annotated with a rerun-or---force-blind hint

    • replicate failure messages no longer suggest "use sync instead" for errors that aren't relay-capability problems (network, cancellation, etc.)

    Fixed

    • v1 target pushes against repos with annotated tags no longer fail with HTTP 400 invalid reference name: refs/tags/<X>^{}. AdvRefsToSlice now drops peeled ^{} entries that go-git v6 alpha.3 preserves inline; affected replicate always and sync --prune

    Housekeeping

    • Bump go-git to v6.0.0-alpha.3

  22. Added

    • --bootstrap-strategy=topo for merge-heavy repos: walks every reachable commit in deterministic topological order so batched bootstrap can place sub-pack boundaries inside side-branch ancestry

    • --progress for live per-side throughput across sync, replicate, bootstrap, and fetch, with rolling-window rate, hostname-aware labels, inline pack subdivision, and an end-of-run summary under --stats

    • Per-subcommand --help after the CLI moved to cobra; bare git-sync lists subcommands on stdout instead of printing the full usage block as an error

    • README cover image and embedded demo videos for git-sync plan and git-sync sync

    Changed

    • Batched bootstrap stream-parses the pack and aborts doomed pushes ~5% in instead of waiting for the body-limit rejection; subdivision converges in 1–2 rounds instead of 6+ on blob-heavy repos

    • Post-rejection subdivision sizes splits from observed pack bytes (4× when the server cut us off mid-stream, 2× otherwise) and ratchets the bytes-per-object estimate up after each 413

    • Batched bootstrap recombines upcoming checkpoints when consecutive packs underuse the target limit, recovering pack granularity after heavy regions; already-pushed checkpoints are also passed as fetch haves on later rounds

    • Relay-only syncs skip the upfront FetchToStore; the materialized fallback lazy-fetches the source closure only when force, prune, or divergent refs require it

    Fixed

    • Sync into targets that share reachability with the source: tolerate pruned objects in the materialized walker, accept branch creates and no-thin targets in incremental relay, and surface diagnostic headers (Cf-Ray, Server, X-Request-Id) on opaque 5xx

  23. First public release. git-sync mirrors refs from a source remote to a target remote without a local checkout, streaming source packs directly into target receive-pack whenever possible. The release covers the CLI, the library API, and the protocol plumbing they share.

    Added

    • git-sync sync — relay-based mirror that streams source upload-pack output into target receive-pack without materializing the object graph locally. Falls back to an in-memory go-git store, bounded by --materialized-max-objects, when relay is not eligible (force, prune, deletes, tag retargets).

    • git-sync replicate and git-sync plan --mode replicate for source-authoritative, relay-only replication. Divergent branches and tags are retargeted against the source; --prune deletes orphan managed refs. Relay-only by design: no materialized fallback.

    • git-sync plan — preview the actions a sync or replicate would take, with structured JSON output suitable for automation.

    • git-sync bootstrap — initial-seed path for empty targets, with adaptive batching, trunk-first planning to cut per-branch graph fetches, and resume-from-stale-temp-refs recovery.

    • git-sync version subcommand with build metadata.

    • Reusable Go library at entire.io/entire/git-sync. The stable surface (Probe, Plan, Sync, Replicate, typed results, auth and HTTP injection) lives at the module root; advanced controls (Bootstrap, Fetch, batching knobs, heap measurement) live in entire.io/entire/git-sync/unstable.

    • Git protocol v2 source-side support: ls-refs, fetch with v2 acknowledgments and response-end handling, capability negotiation, and graceful fallback when the source does not advertise v2.

    • Smart HTTP transport: pkt-line primitives, sideband demultiplexing, info/refs advertisement validation, smart endpoint path normalization, oversized packet rejection, empty pkt-line acceptance, and v2 fetch remote ERR packet handling.

    • Optional info/refs redirect following on the source endpoint, exposed through the public gitsync API.

    • Git credential helper fallback and --source-token / --target-token flags for HTTPS auth.

    • JSON output mode with a stable schema and camelCase keys across all commands.

    • Adaptive bootstrap batching: auto-subdivide on target body-size rejection, pre-check PACK header object count before pushing oversized batches, and shared --max-pack-bytes / --target-max-pack-bytes flags across sync, replicate, plan, and bootstrap.

    • Sideband progress streamed to stderr when -v is set.

    • Homebrew tap install via brew tap entireio/tap && brew install --cask git-sync.

    • GoReleaser-based release pipeline for cross-platform binaries.

    • Identical source and target endpoints are rejected before any network round-trips.

    • Documentation set: docs/usage.md, docs/architecture.md, docs/protocol.md, docs/testing.md, plus README installation, quick-start, and FAQ.