Git → prikk: a vocabulary map, not a feature map
If you know Git, prikk’s commands will look familiar and several of them mean something different.
commit does not publish. There is no HEAD and no staging area, though there is a current branch
that branch switch moves. seal has no
Git counterpart at all. Reading prikk’s words as Git’s words will make you wrong about several things
at once, and you will not notice, because nothing will error — the commands will simply do something
other than what you expected.
This page is a vocabulary map for a human, not a migration tool. It does not import Git history and does not promise to; the closest active work on that is RFC 113, which is a design for the import contract, and nothing implements it yet.
Command correspondence
| Git | prikk | What differs |
|---|---|---|
git init | prikk init | Same idea: create the repository layout. |
git clone | — | Missing. prikk bundle import reads a bundle file into an untrusted, unmerged remotes/<ref> pointer — it does not create a worktree or a local branch. There is no network transport at all: bundles and sync artifacts are files you move yourself. |
git fetch | prikk sync have <ref> (you) → prikk sync build (them) → prikk sync accept <file> (you), or prikk bundle import | File-based, and never merged. What arrives is an untrusted remotes/<name> pointer. No sockets: you move the file yourself. |
git pull | Fetch as above, then prikk sync seal <ref> --claim <id>, or prikk merge-evidence → prikk merge-plan → prikk merge | No single verb, by design. sync seal when the received patches extend your ref; the three merge steps when the histories diverged. |
git push | — | No counterpart. You produce the artifact (prikk sync build, prikk bundle export) and the other side accepts it; prikk never writes into another repository. |
git add (staging) | — | Missing, deliberately. There is no index and no staging area. prikk commit --from-worktree always considers the whole worktree (governed by .prikkignore, which is a flat list of literal path prefixes — no globbing, no negation, unlike .gitignore; see Ignoring Worktree Paths). You cannot stage part of a change. |
git mv | prikk mv <old> <new> | A declaration, authored into the next commit. Moves the file and records the rename for the next commit; if <old> is already moved on disk (a shell mv), it records the declaration alone and touches no bytes. |
git commit | prikk commit --from-worktree -m <message> | Two-phase, not one. commit only queues a signed Patch into a local WAL; nothing is published yet. See Commit versus seal below. The message is stored as signed evidence since 0.32.0 — see Messages are stored. |
| — | prikk seal --allow-no-audit | No Git counterpart. Publishes the queued WAL as a signed Block, moving the branch ref. Nothing is visible to log or a peer before this runs. |
git status | prikk status + prikk worktree-status | Split in two: status reports the repository/WAL/queue state; worktree-status reports the worktree’s own drift against the replay baseline commit would author against. Neither is git status’s single combined view. |
git log | prikk log | Block and ref metadata only — target Block ID, RefState ID, kind, parent/Patch counts, rollback classification. No commit message, author, or date is shown, because none is stored yet (see below). |
git show | prikk show <block-id|patch-id> | One block or patch, as its operations. Prints each operation with the content it carries — a created file’s text, an edit’s old and new span — rather than a unified diff. Content comes from the patch itself; a block id additionally resolves edited nodes to their paths by one replay, which a bare patch id cannot. |
git ls-tree -r | prikk tree [--ref <ref|block-id>] [--prefix <p>] | Files only, no directory entries. Lists every file present at a ref or a bare block id, with mode, exact size, and whether it is text or binary; a binary file also shows its blob id. --prefix matches whole path components. --format json is tree-listing-v1. |
git show <rev>:<path> | prikk cat --path <p> [--ref <ref|block-id>] | Bytes, bounded. Writes the file’s content at a point to stdout or --output; --max-bytes refuses anything larger, writing nothing. Binary content refuses a terminal and names --output. --format json (path-content-v1) reports the metadata with no bytes. |
git archive <rev> | tar -x -C <dir> | prikk extract --ref <ref|block-id> <dir> | Only a new directory that does not exist yet — refuses an existing target rather than overwriting it, and never writes history or worktree state into it. Anchors only where a writer would (the same rule checkout uses for a worktree write), never cat/tree’s own weaker anchoring, since this is what a CI job or a forge download trusts; --allow-full-replay reads past the trusted distance bound when no admitted snapshot is in reach. |
git diff A B | prikk diff --from <ref|block-id> --to <ref|block-id> | Compares the state at any two refs or block ids and prints unified hunks (3 lines of context) for each text change; a rename is shown only when history declares one (prikk mv), never guessed from similarity; a binary file shows ids and sizes, and prikk cat reads either side. --format json is diff-report-v1. |
git diff (worktree against HEAD) | prikk diff | What commit would author, with content. Bare prikk diff compares the current branch’s tip (and any queued commits) with the worktree; prikk diff --from <point> compares that point. There is no index, so a new file is an added entry with its content — there is no “untracked” list — and ignored paths never appear. commit then diff is empty again. |
git branch | prikk branch list / branch create heads/<name> | List and create work the same way in spirit. |
git branch -d | prikk branch close heads/<name> | Diverged. Closing marks the branch (a schema-2 closed RefState); nothing is deleted or reclaimed, and there is no reopen verb. |
git checkout <branch> / git switch | prikk branch switch heads/<name> | Stricter. Refuses a dirty worktree and unsealed work for another branch rather than carrying changes across; untracked files are never touched. See A current branch, no HEAD below. |
git checkout -- <path> / git restore | prikk checkout --patch-materialize (and the sibling --snapshot-*/--patch-* flags) | Materializes files for one --ref, plan-first (--plan-only, --snapshot-plan, --patch-plan). No pathspec — it is whole-ref, not a partial restore. |
git tag | prikk tag create tags/<name> --target <ref|block> [-m <message>] | The tag message is persisted — unlike a commit message, TagPayload already carries one. |
git merge | prikk merge-evidence → prikk merge-plan → prikk merge --allow-no-audit | Three explicit steps, not one. merge executes only a merge already proven confluent by evidence; a merge that is not refuses with a witness rather than producing a conflicted worktree. |
git rebase / git cherry-pick | — | Missing. The closest thing to cherry-pick is prikk sync seal --claim <id>, which seals one already-received patch — it cannot take an arbitrary patch from your own history. |
git revert | prikk rollback-preview → prikk rollback-draft --append-inverse -m <message> → prikk rollback-draft-verify → prikk seal | Four explicit steps producing a preimage-exact inverse Patch, rather than one command that also commits. prikk inverse-plan shows the unsigned inverse without writing anything. None of them inverts a prikk mv rename yet: a history containing one is refused. |
git stash / git submodule / git worktree (multiple) | — | Missing. One worktree per repository; nothing analogous to any of the three exists. |
git gc | prikk compact --pointer-index|--received-index|--trust-policy|--all | Diverged, not equivalent. prikk’s object model never deletes an object — compact reclaims stale index and policy records only. There is no object pruning of any kind. |
git branch -d -r / git update-ref -d refs/remotes/<name> | prikk received remove <remotes/…> [--plan-only] | Diverged. Removes only the received pointer; the objects it reached stay, reported by prikk verify as unreached objects. --plan-only previews without writing; a real run is restorable by run id through prikk doctor --recovery-restore as long as nothing has since written to the same slot. |
git fsck | prikk verify [--format json] [--stop-on-first-error] | Broader: object/WAL/ref integrity plus three-valued publication-trust classification in one pass. |
git reflog | — | No user-facing verb. Every ref update is a signed, append-only RefUpdate log entry internally, but nothing surfaces it to a command today. |
git config | prikk config get|set|unset|list | Far narrower. One repository-scoped key exists today, incoming.max-object-bytes (RFC 158 Stage A), at .prikk/config — never global, never per-user. Signing keys are still read from a per-user key directory by default, with PRIKK_*_SEED_FILE / PRIKK_*_KEY_ID environment variables overriding it — see Security and Signing Setup. |
| N/A — no counterpart | prikk key generate/prikk key public/prikk key status | Draws a fresh Ed25519 seed from the OS CSPRNG, derives a public key from a seed already held, or reports whether this machine can sign and with which key, signing nothing. Git has no equivalent — an SSH key or GPG key is generated with a separate tool entirely. |
| N/A — no counterpart | prikk setup | Composes init, key generation for both roles, trust maintainer add, and the export lines into one command. Nothing in Git bootstraps signing identity this way — git init alone reaches a usable repository because Git commits are unsigned by default. |
git blame / git bisect / git grep | — | Missing. None exists in any form. |
.gitignore | .prikkignore | Diverged, and narrower on purpose. Literal repository-relative path prefixes only — no globbing, no negation, no per-directory files, and it binds only at commit’s worktree walk and worktree-status’s scan, never at replay or verification. |
git remote add / remote tracking | — | Missing. No remote registry or URLs of any kind — see File-based distribution below. |
| N/A — no counterpart | prikk doctor | Health diagnostics with two real repairs (--repair-wal-tail, --repair-index); --repair-main-ref is recognized and always refused — there is no implemented repair behind it. |
| N/A — no counterpart | prikk format upgrade | Moves a format-6 repository to format 7 in place, after the same verification prikk verify runs. Git’s own extensions.* config changes are the nearest idea, but prikk’s upgrade is one explicit verb, verified first, with no downgrade. |
| N/A — no counterpart | prikk unlock | Lists or clears a held file lock. Nothing in Git needs this because Git has no equivalent lock. |
| N/A — no counterpart | prikk trust maintainer add/remove | Manages the local MAINTAINER trust set. Git has no signer-trust concept at this layer; the closest analogue is a GPG keyring, and it is not the same model. |
| N/A — no counterpart | prikk ref complete <ref> | Finishes an interrupted branch create/tag create/sync adopt-tag/merge/seal publication that is a completable lead (RFC 165 R4), by any adopted maintainer key, not only the one that started it. --plan-only previews without writing. Git has no equivalent: a crashed Git write is repaired by its own reflog/fsck machinery, not a per-ref completion verb. |
Commit versus seal, a two-phase model
Git’s commit does one thing: it creates a commit object and moves the branch pointer in the same
step. prikk splits that into two commands with nothing in between them optional:
prikk commit --from-worktree -m "message" # queues a signed Patch to the local WAL
prikk seal --allow-no-audit # publishes the queue as a Block, moves the ref
A queued-but-unsealed commit is genuinely not part of history yet — it does not appear in log, and
a peer reading your repository cannot see it. You can queue several commits before sealing them
together. There is no Git operation that maps onto commit alone; it is closer to git add plus
git commit --no-verify into a holding area that Git does not have, and seal is the step that
actually behaves like git commit’s publishing half.
A current branch, no HEAD
There is no HEAD and no detached state, but there is a current branch: .prikk/current-branch
names one local branch (heads/main in a new repository), and every command that takes --ref
defaults to it. prikk branch switch heads/<name> moves the worktree and the pointer together. Unlike
git switch, it never carries uncommitted changes across: a dirty worktree, or unsealed work queued
for another branch, is refused, and you commit or seal first. --ref given explicitly still works on
every command without switching.
Messages are stored; authors and dates are not
prikk commit -m <message> requires a non-empty message and stores it — since 0.32.0 it is a
signed, identity-bearing field on the Patch itself (Patch schema 4), and prikk log prints it
under its block, one line per patch. Changing a message changes the patch id, exactly as changing an
operation does: it is evidence, not an annotation
(RFC 123).
A patch written before 0.32.0 carries no message and shows no message line — absence, not a
placeholder. Those patches stay readable forever; the message was never recorded and cannot be
attached retroactively.
An author display name and a commit date are still not stored, and the date never will be.
created_at is pinned to zero at every signing site so object ids stay reproducible across machines,
which CI proves by mutating a repository on Windows and Linux and diffing the resulting id lists. A
timestamp inside the identity surface would destroy that property. The display name is a separate,
deferred question (RFC 123 §5). A tag’s message is persisted too — the two commands are now
symmetric in this respect.
File-based distribution instead of remotes
There is no remote registry, no URLs, and no network transport of any kind in the binary. Moving history between repositories is always a file you produce and hand to the other side yourself:
prikk bundle export/import/verify— a complete, self-contained history bundle in one file.prikk archive export/verify— a whole repository, every ref and every object, verbatim, in one file (RFC 155).archive importis not built yet.prikk sync’ssummary/compare/have/build/accept/pending/sealsubcommands — an incremental, gap-closing exchange, still file-based, still no sockets.
Either way, what you receive lands as an untrusted remotes/<name> pointer — readable by log,
merge-evidence, and merge, but not automatically merged or trusted the way a Git remote-tracking
branch is once fetched.
Claim-to-Source Anchors
| Claim | Source anchors |
|---|---|
commit only queues a signed Patch to the local WAL; seal publishes it as a Block and moves the branch ref. | node_authoring.rs, seal.rs |
There is no HEAD; --ref defaults to the branch .prikk/current-branch names, and branch switch refuses a dirty worktree or unsealed work for another branch. | current_branch.rs, branch_switch.rs, branch.rs, commands.rs |
commit -m’s message is stored as an identity-bearing Patch field since 0.32.0; tag create -m’s message is persisted too. | main.rs, payload/tag.rs, RFC 123 |
There is no staging area; commit --from-worktree always considers the whole worktree, filtered only by .prikkignore. | worktree_files.rs, ignore.rs |
No remote registry or network transport exists; distribution is bundle export/import/verify or sync, both file-based, landing as an untrusted remotes/<name> pointer. | bundle.rs, sync.rs, received.rs |
| Every command named on this page is a real registered command, and every registered command is named on this page. | commands.rs (COMMANDS), checked mechanically by rules (A) and (C) |
Provenance
Seeded from the external architecture audit’s 2026-08-31 feature-completeness matrix
(audit-2026-08-31-task-1a-design-functionality.md §4), re-verified against main at the time of
writing rather than copied — several rows in that matrix are now stale (worktree-status was broken
then and is fixed; .prikkignore did not exist then and does now). RFC
128
§5 requested this page. It does not cover RFC 113 (history import) or any importer tool — neither
exists yet.