Repository navigation
Releases
causet v0.31.0
-
Experimental: import writes the fact log, and
cst provenanceand
cst receiptsread it (#419, ADR-0047 decisions 5–8). In a native
repository:- Import reads the history of
refs/notes/causetinto the fact log's
shared chain, with one entry per notes commit (store type09). Each
entry adds the facts its notes tree gives that are not current at its
parents, and retires those it no longer gives. Its actor and time come
from the notes commit's committer line. - A fact (store type
08) is a record import can take, in canonical
JSON. Its object IDs are the native IDs of what they name, at the fields
its family's published schema marks. - Parked facts. A note import cannot read, a record it cannot take
and a repeated copy are kept as parked facts, which no reader is
handed. Records it cannot take include those of an unknown version,
invalid ones, and those naming objects the store lacks or holding a
fraction, as every reconciliation's timings do. - Roots. The commits records name, such as a landing's absorbed
commits, get native commits too. cst fsckchecks every fact and entry: a fact's record is
canonical, and its names are its object IDs and its subject. An entry
keeps the log's rules of parents, scope, adds and retires.cst provenance [<revision>] [--all]andcst receipts, with and
without--json, answer as they answer in the Git-backed original, IDs
translated, and start no Git process.cst provenance declareis
refused.
Recording a fact changes no native commit's ID. Until the operation log
holds them (#423), a chain's heads are the entries no other names as a
parent. The local chain of disputed copies and dispositions, the legacy
refs/notes/vcs-labname, andcst metadata statusandvalidateare
#420's.docs/native-history/facts.mdis the contract, and
native/modelnow lists each note-record family's object-ID fields, held
to the published schemas by a test. Like every native command, all of this
needsCAUSET_EXPERIMENTAL=nativeand is not a contract. - Import reads the history of
causet v0.30.0
-
Experimental:
cst branchandcst taglist a native repository's
names (#418, ADR-0047 decisions 9 and 12). Import's ref snapshot now
becomes names:refs/heads/*become branches,refs/tags/*tags andrefs/remotes/*
read-only remote-tracking names;- a symbolic ref names a name when its target is in one of those three
namespaces, asorigin/HEADnamesorigin/main; - cst's records (
refs/notes/causet,refs/causet/*,refs/vcs-lab/*)
and every other ref,refs/stashandrefs/replace/*among them, stay in
the snapshot for the bridge and are never shown as names.
In a native repository,
cst branchlists the branches,-rthe
remote-tracking names and-aboth, andcst tagthe tags.-land
--listtake patterns matched as Git'sref-filtermatches them,*
crossing/.--formatprints byte for byte whatgit branch --formatand
git tag --formatprint on the Git-backed original, IDs translated, for
every fieldcst for-each-refimplements.%(HEAD)is refused, since a
native repository'sHEADis no name.- Without
--formatboth print cst's own listing, a name a line and a
symbolic one asalias -> main. With--jsonthey print the new
causet.names/v1document. - Refused: creating, moving, copying or deleting a branch or tag, which
the operation log and native writes bring (#423, #426); Git's other
options, such as-v,--sortand--contains;-ror-agiven a
name. Each has a registered code, and under--jsonis the failure
envelope.
Neither command starts a Git process.
docs/native-history/operations.md
§2.3 is their contract, including where Git cannot be matched: a detached
HEAD's line, and a symbolic ref to a ref that is no name.cst log's
decorations (%d,%D,%S,%(decorate),%(describe)) stay refused;
#455 tracks them. Like every native command, all of this needs
CAUSET_EXPERIMENTAL=nativeand is not a contract.
causet v0.29.0
-
Experimental:
cst logandcst showread native history the way Git
reads it (#417, ADR-0046 decision 2, ADR-0047 decision 12). In a native
repository:-
--formatprints byte for byte whatgit log --formatandgit show -s --formatprint on the Git-backed original, IDs translated. That holds
for every placeholder a native commit's own fields answer:- every author and committer form,
%adin each implemented--date
mode; %B %f %e %x,%m, and%(trailers)with all its options;- the
%+,%-and space prefixes, padding, truncation and%w()
wrapping; %Ccolours, printed as Git prints them off a terminal: as nothing.
Non-UTF-8 and malformed commits print exactly. A placeholder whose source
native history does not hold yet is refused before anything prints: - every author and committer form,
-
cst logwalks as Git's revision walk does, newest first. It takes
<rev>,^<rev>and<a>..<b>, a range marked as Git'slimit_list
marks it, and-n,--skip,--reverse,--first-parent,--merges,
--no-mergesand--date. -
cst showprints commits and annotated tags, a tag of a tag down to
its commit, each commit once. -
Without
--formatboth print cst's own human output, with each
commit's change identity, lineage and actors. With--jsonthey print the
newcauset.log/v1andcauset.show/v1documents. -
Refused:
show --formatwithout-s, since Git would follow it with a patch;- a patch, paths,
a...b, and Git's named formats such as--oneline; - every other option.
Each is refused with a registered code, and under
--jsonas the failure
envelope.
Import now also writes a native tag, store type
07, straight after each
annotated tag a name reaches, and a later import adds the ones a store from
an earlier build lacks.cst fsckre-derives each imported tag. Every
native command names an annotated tag by its native tag, as it names a
commit by its native commit.docs/native-history/reading.mdis the new
contract for both commands, including the few places Git itself cannot be
matched. Like every native command, all of this needs
CAUSET_EXPERIMENTAL=nativeand is not a contract. -
causet v0.28.1
- cst's records are read through one record source (#415).
cst provenance,cst receipts,cst graphandcst metadata statusand
validatenow take their records from a single source. In a Git-backed
repository that source is the notes, as before. This prepares a native
repository to answer the same commands from its fact log (#419, #420;
ADR-0047), without any reader's parsing, validation or output changing.
Nothing changes forcst: every suite mode, the conformance fixtures and
the frozen oracle answers pass unchanged.
causet v0.28.0
- Provenance says whether an actor is a human or an agent, and whom an
agent acts for (#414, ADR-0047 decision 3). Acauset.provenance/v1
actor takes two optional members:kind,humanoragent, andfor,
the human or organisation an agent acts for, present only with kind
agent.cst provenance declare <commit> --kind agent --for <actor>
states them, and--kind humanstates the other kind. A kind describes
one actor, so the declaration must name exactly one,CAUSET_AGENT
included. Otherwise it is refused withusage-conflicting-options, as is
--forwith--kind human. An unknown kind or an empty--foris
usage-invalid-option-value, and--forwithout--kindis
usage-missing-argument.cst commitdoes not take them.cst provenance
shows them after the actor as(human),(agent)or(agent for <actor>),
and its JSON reports them inactors. A record without them validates and
reads exactly as before, and an absent kind means the kind is unstated.
The record model refuses any other kind, and anyforthat is not a
non-empty string with kindagent. The published schema records the
addition, and so doesdocs/schemas/compatibility.md, in a new section on
members added inside a version. Provenance carried through a hard squash,
cherry-pick, reconcile or rebase keeps both. Where the carried sources
disagree about one actor's kind or principal, the carried actor leaves that
member out, whatever order the sources come in. A build older than this one
drops both members when it carries provenance. The record it carried from
keeps them.cst --helplists the new flags.
causet v0.27.2
- npm is published by hand with
scripts/publish-npm.ps1(#448). While
npm/cli#9969 keeps automatic npm publishing off (#139), a maintainer runs
pwsh -File scripts/publish-npm.ps1 -Version <x.y.z>afternpm login. It
publishes the release's own tarballs from its GitHub release, never a
checkout. It refuses a tarball whose digest is not the oneSHA256SUMS
lists, and a main package that does not pin both platform packages at the
version. A main package published from a checkout would install without
cst. It publishes the platform packages first, then the main package,
skips any version npm already has (so a rerun is safe), and takes
-DryRun. It needs PowerShell 7. Nothing changes forcstor its
packages.
causet v0.27.1
- ADR-0048 is accepted (#440). Every landing releases a version of its
own, and one dispatch ofpromote.ymlmakes a version the stable release.
The owner accepted it after v0.26.0, v0.26.1 and v0.27.0 released
themselves on landing and v0.27.0 became the stable release that way. This
documents a decision and changes no behavior.
causet v0.27.0
- Node.js 24 is the new floor (#445). Node 20 reached end of life on
2026-04-30. The npm package now declaresengines.node>=24, so
installingcstthrough npm, running its launcher when install scripts did
not run, and developing from a checkout all need Node.js 24 or newer. The
installedcststill needs no Node.js, andinstall.shandinstall.ps1
are unchanged. CI runs every suite on Node 26, the active LTS, and a full
qualification also runs the default and session-on modes on Node 24, the
floor. The suites' store reader dropped its fallback for a Node that cannot
read zstd. That fallback mistranslated a commit a later import adds, and it
failed the 0.26.1 promotion on Node 20.
causet v0.26.1
/what-nextputs an active handoff first. Whenhandoff_map.json
names one for this repository, the report leads with it and recommends
/lets-go, and one whose document has not reached this machine is shown
as pending. It still changes nothing, and a machine without the handoffs
config skips the check.
causet v0.26.0
Every landing is a version, and native repositories arrive. This is the
first version a landing released by itself (ADR-0048); a later one becomes
the stable release by one dispatch. Since 0.25.1, experimental native
repositories have come in: cst import copies a Git repository's whole
history into N1's content store (ADR-0045), losslessly, verifiably,
deterministically and incrementally; a native repository answers Git's
inspection commands itself; and it has a history of its own that cst log
reads (N2, ADR-0047). The suites gained reftable, SHA-256 and native-kind
modes, and corpora of generated histories and real repositories.
-
Every landing is a version, and one dispatch makes a version stable
(#440, ADR-0048). Whenci.ymlpasses on a push tomain,release.yml
tags the landing with the version its newest changelog section names,
builds and installs that version, and publishes it as a GitHub prerelease.
The install scripts keep installing the stable release, and
install.sh --version <x.y.z>reaches any landing's build.
gh workflow run promote.yml -f version=<x.y.z>runs the whole release
gate on that version's tag and, when every gate passes, makes its GitHub
release the latest. npm takes part in both, undernextand then
latest, once the repository variableNPM_PUBLISHistrue; while
npm/cli#9969 blocks publishing from CI (#139), npm is published by hand. A pull request's newest
changelog section must now name the version its merge will mint, which a
newchangelogjob checks, andpackage.jsononmainnames the release
line: a release build writes its own version into it. The hand release
procedure, its preparation branch and its draft releases are gone. -
N1's storage gate counts N1's objects, and native history's bytes are
reported beside it (#437). Since #416, import has written a native
commit for each commit a name reaches. Native commits are N2's objects, but
they counted against N1's storage gate (ADR-0044 item 2, release gate 11),
and git/git's store, 126,093,364 bytes, failed against Git's 113,030,000.
ADR-0044 is amended: a phase's storage gate counts its own objects and its
predecessors', and a later phase's objects are reported, never gated,
until that phase exits. What native history may cost against Git is
decided at N2's exit. The real-repository check now gates an import
written without native history, through a test-only hook,
CAUSET_TEST_IMPORT_WITHOUT_HISTORY=1, and each job's summary gains a row
for the bytes native history adds, never checked.corpora.ymlalso runs
for a pull request that touches the native import, store or history
crates, since only the corpora measure what a store holds. No behavior of
cstchanges. -
Experimental: a native repository names each commit by its native
commit, in every command (#435).cst rev-parse,cat-file,ls-tree,
for-each-refand import'sHEAD is atline now print a commit's native
commit ID wherever import derived one, ascst logdoes, and take that
ID, a unique prefix of it, or the commit's Git ID.cat-fileshows a
native commit as Git shows the commit:-tprintscommit,-sand
--batchgive its Git bytes, and-pnames its tree and parents by their
native IDs. The preserved Git commit a native commit derives from is no
longer an object to any command: its ID and its prefixes name nothing. A
commit with no native commit keeps its preserved ID: a carrier such as a
notes commit, a commit onlyrefs/stashor a similar ref reaches, and
every commit of a store imported before #416.cst log's%hand a
prefix are unique among the same objects, so every%hresolves in every
command. A new option,cst rev-parse --git-id, prints the Git ID of what
each revision names. A command that prints a commit ID now reads the
store's every index once, about 60 ms on an import of this repository,
and also reads every native commit once when it meets a commit that has
none, such as a notes or stash commit.docs/native-history/commits.md§6 records the rules.
Like every native command, all of this needsCAUSET_EXPERIMENTAL=native
and is not a contract. -
Experimental: a native repository has history, and
cst logreads it
(#416), the first slice of N2 (ADR-0047). Import now also writes a native
commit, store type06ofdocs/native-history/commits.md, straight after
each Git commit that a branch, a tag or a remote-tracking ref reaches:- its tree and parents, as native objects;
- its author and committer;
- its message's encoding, and the message byte for byte;
- an
authoredactor from its author line; - its
Change-Id,Derived-FromandOrigin-Commit, lifted as
Git-backed cst lifts them.
A carrier commit, such as a notes commit, gets none. A later import gives
one to a commit a name reaches only by then. In a native repository,
cst log [<revision>] --format=<format>prints a revision's history in
Git's order, byte for byte withgit log --formaton the original, with
native commit IDs, and runs no Git. Its placeholders are
%H %h %T %t %P %p %an %ae %ad %cn %ce %cd %s %b %n %%. Every other
option and placeholder, paths, and a message in an encoding other than
UTF-8 or ISO-8859-1 are refused.cst fsckalso checks each native commit,
re-deriving an imported one from the Git commit it came from. A store
imported before this change has no native commits, andcst logasks for
it to be imported again. Like every native command, all of this needs
CAUSET_EXPERIMENTAL=nativeand is not a contract. -
The generated-history corpus runs weekly on a new seed, without
blocking anything (#336).corpora.ymlchecks only the seed
causet-n1, kept fixed so release gate 11 fails the same way twice, and a
fixed seed finds nothing new once it passes. A new workflow,
rotating-corpus.yml, checks 1,000 histories of the ISO week's seed
(weekly-<year>-W<week>) on Ubuntu and Windows every Thursday, and on
manual dispatch with an optional seed. It gates nothing, andcorpora.yml,
its seed and gate 11 are unchanged. A failure turns the run red, and its
last job, the only one allowed to write issues, opens oneneeds-triage
issue per seed. The issue lists each failing host and history with its
problems, the command that reproduces it, and the run's link. A later
failure of that seed comments on the seed's issue instead, reopening it if
it was closed. To file it, the corpus test writes a JSON report when
CAUSET_GENERATED_REPORTnames a file. No behavior ofcstchanges. -
Experimental: import holds the commits, tags and trees it reads on disk,
not in memory (#405). Since #347, git/git's import peaked at 3.1 GB,
most of it the Git bytes of every commit, tag and tree import reads before
it encodes them. Import now writes each object's bytes to a file named
import.objectsas it reads them, keeps only where each one sits, and
reads them back from that file, never from Git again. The file follows
import.metadata: it sits in.cst-import/for a new store and beside
import.lockfor an existing one, and is removed before the store is put
in place and on every failure. The next import replaces one a killed import
left, and no command reads it. An import therefore needs more temporary
disk while it runs: on git/git about 2.6 GB more, about 4.2 GB with the
held metadata. The store it writes is byte-identical to before, and the
format is unchanged. The import report (CAUSET_TEST_IMPORT_REPORT) gains
heldObjects, the file's peak size, and each real repository's job summary
incorpora.ymlgains a column for it. Both are reported, never checked. -
The incremental import check compares every delta both imports store
(#338). The import checks hold an incremental import to what a full import
of the same history holds, and since ADR-0045's amendment of 2026-10-26
they let a large version be a delta in one and a chunk list in the other.
When both stored a version as a delta, nothing compared the two records.
Now the check requires the same record in both, byte for byte. Its base is
fixed by history, the same path in the introducing commit's first parent
(storage.md §5.1), and its data by the contract's parameters and the pinned
zstd (§7). A delta is alone in a stored frame, so the check reads both
records with no decompression, on every Node the suites support, and never
skips. It fails on a delta in any other frame, and on a difference, naming
the version and both bases, or its base and the first byte where the
records differ. The generated-history corpus and each real repository's
job summary say how many deltas it compared: 223 across the 1,000
generated histories. No behavior ofcstchanges. -
Experimental: importing git/git peaks at half the memory, and each real
repository's job summary says what its imports cost (#347). A full
import of git/git on Linux peaked at 6.3 GB, nearly all of it while import
read every commit, tag and tree: it held one name for every tree entry Git
follows, across a whole round, before it dropped the duplicates, and most
entries name objects already read. Import now drops each duplicate as it
reads it, so the peak is 3.1 GB, set now by the trees' and commits' bytes
held until they are encoded. Import asks Git for the same objects in the
same order as before, and the store it writes is byte-identical. Set
CAUSET_TEST_IMPORT_REPORTto a file andcst importwrites there what
it cost, as JSON:- seconds in all and for each of its seven phases;
- the process's peak memory in all and as each phase ends, on Linux only,
andnullelsewhere, since every crate forbids unsafe code; - the peak size of the held metadata it spills to disk while it writes.
The variable is a test hook, ine...