Changelog

This page documents the complete version history and release log of the Rotifer Protocol reference implementation (@rotifer/playground).

Version overview: Rotifer has 7 historical version series with 20+ releases. Full version list: v0.1.0 (initial), v0.2.0 (Arena), v0.3.0 (WASM compilation), v0.4.0 (cloud), v0.5.x (P2P + reputation), v0.7.x (stabilization), v0.7.9 (trust shield), v0.8.0 (Iron Shell), v0.8.6 (CLI runtime bugfix), v0.9.0 (Open Mesh + Economy Foundation), v0.10.0 (P2P Reliability), v0.10.1 (release plumbing), v0.10.2 (no more silent empty results), v0.11.0 (rollback and uninstall), v0.12.0 (invocations start counting), v0.13.0 (a narrower plugin), v0.13.1 (test runs stop counting as usage), v0.14.0 (a fifth host), v0.14.1 (install-command fix), v0.15.0 (scores say how they were measured), v0.16.0 (the criteria, as code anyone can run), v0.17.0 (the board applies what it can prove), v0.18.0 (the verdicts reach the page), v0.19.1 (the official Genes get an owner who can sign in), v0.19.2 (taking a version down actually takes it down), v0.20.0 (current public release — the published Skills get a public source). Detailed changelog for each version below.

v0.20.0 (2026-08-22) — Current (The Published Skills Get a Public Source)

• The Skills published to ClawHub can be read before they are installed — rotifer-guide, rotifer-agent and rotifer-arena had been on ClawHub since April, eight versions each, with their source in a repository that can never be pushed: no public source for anyone to read first, no CI, and a manifest naming this repository as their home while this repository did not carry them. They now live under skills/ and publish by tag, with pull requests exercising the same publish command under --dry-run so it is tested on every change rather than discovered broken on release day. A fourth joins them — rotifer-gene, the Gene manual the other three point at: writing a Gene’s express function and phenotype schema, the four-layer security audit to run before publishing, and migrating a Gene’s fidelity from Wrapped to Hybrid or Native.
• The README stopped advertising a version nine minors old — the Status line npm renders under the package title sat at v0.10.1 while the registry served 0.19.2. That line is the project’s first impression, and it was wrong for nine releases. It now tracks the released version, checked on the one surface where the edit can be both correct and green — the released number lives in package.json, which release-please bumps on its own branch, so main carries the previous number for the whole cycle and “they must match” is a rule main can never satisfy.
• The plugin bundle answers to the same name on every host — Cursor was the last host still calling it something other than rotifer.

v0.19.2 (2026-08-21) — Taking a Version Down Actually Takes It Down

• rotifer unpublish worked for the first time — the command shipped in v0.16.0, and every call since came back “Published gene version is immutable”. The trigger guarding a published version permits an update only when a whitelist of columns is unchanged, and published was on that whitelist — so the one column the command exists to change was the one column it was not allowed to change. Republish updates a row that is not published yet, so the guard never fires and that half always worked: the pair reads as “take it down / put it back” and only the second half functioned. The command had tests, and they mocked the network, so they asserted how the client reacts to a reply the database would never send — the layer that broke was the only one nothing exercised. Both directions are now authorised operations that check ownership themselves and leave a record of who did it, rather than an exception carved into a guard every other writer also passes through.
• The L0 gate now runs on every path a Gene can execute through — it was reached only when a Gene had a compiled artifact and the sandbox was on. Three situations fell through to the Node fallback instead, which ran the source with the host process’s full privileges: a Gene that had never been compiled (the default state of a new one), --no-sandbox, and a native addon that failed to load — the last of these swallowed silently. L0 is defined as the layer that does not participate in evolution and cannot be bypassed, so whether it applies must not depend on whether someone happened to run compile first. The gate only inspects metadata, so it needs no sandbox to do its job.
• “The gate could not run” stops meaning “the gate said no” — refusing outright whenever the gate was unavailable takes the entire CLI offline wherever a prebuilt binary cannot be had: unsupported platforms, a failed optional dependency, the release branch. The gate now returns a verdict rather than a boolean. A violation is a hard refusal with no escape hatch. An unavailable gate is not a conclusion about the Gene, so provenance decides instead: a Gene carrying a cloud manifest is someone else’s code and stays refused, while a Gene whose source sits in your own project runs with a warning.
• Two plugin listings stopped answering to a name that belongs to something else — the bundled evolve Skill carried the name of a separately published Skill, and the CodeBuddy listing named the whole bundle after one Skill inside it.

v0.19.1 (2026-08-20) — The Official Genes Get an Owner Who Can Sign In

v0.19.0 carried these changes and never reached npm: the release pipeline failed after the tag was cut, so the tag and the GitHub release exist for a build nobody can install. v0.19.1 is the first published version that contains them.

• The 59 official Genes have an owner who can sign in — the rotifer-protocol profile on Cloud was backed by a GitLab account, and GitLab banned it. The CLI authenticates through OAuth, so there was no way back in: 59 published Genes, 32% of the registry, could not be republished, unpublished or edited by anyone. Ownership moved to an account that can sign in, and the name moved with it — the author line still reads rotifer-protocol and /developers/rotifer-protocol still resolves, so nothing changes for a reader. The banned profile is renamed rather than deleted; it holds no Genes and cannot log in, and it stays so that an identity having been here and failed remains on the record. Profiles now carry a steward note naming who is behind the name and what happened to the predecessor.
• A creator who no longer owns a Gene stops carrying a score — the reputation recompute visited every owner who currently holds a published Gene, which is not the same set as everyone who has a score. An identity that emptied out was never revisited, so whatever was last written stayed written. Found in production immediately after the ownership move: the creators leaderboard showed two entries at 0.1324 — the live identity, correctly, and a ghost that owned nothing at all.
• A sandbox run on its own no longer reads as a measured score — while two of the fitness inputs are still transitional constants, a submission is recorded as estimated rather than presented as a measurement.

v0.18.0 (2026-08-20) — The Verdicts Reach the Page

v0.17.0 recorded 59 invalidation verdicts. Nothing that anyone reads consulted them — so this release is the half where they take effect.

• The leaderboard says what it knows about every row — invalidated_at had no reader. The partial index built to filter on it went unused, so a disqualified row still sat at the top of every listing. Each row now carries a tier and, more usefully than the ordering, the reason it is in that tier. verified was measured by a sandbox or binding runtime and used by enough distinct callers, with the threshold read from the active season config rather than compiled into the query. under_evaluation was measured but is not yet in demand — ranked within its own tier, because the measurement is real and the evidence of use is not. not_evaluated covers rows where nothing was measured, or that are disqualified. An estimated score lands in not_evaluated deliberately: “under evaluation” should mean a measurement happened and the evidence is thin, and putting a hash-derived number beside a real sandbox run is the confusion the tiers exist to end. Rows in that tier carry no rank and print no score column — showing a stored 0.5 under the words “not evaluated” is exactly how an estimate came to be read as a measurement.
• Reputation stops spending scores the board already withheld — the leaderboard stopped ranking disqualified entries; R(g) did not. It read the most recent Arena row with no filter at all — not on invalidation, not on how the score was obtained — so the same numbers returned through a second door, and the Arena term carries 0.70 of the weight. Measured on production before the fix: one Gene’s R(g) of 0.6045 was 94% composed of a fitness value invalidated as an unexecutable artifact, and its own page read “Score 0.60” directly beneath an F(g) of ”—”. It had spread further: developer reputation sums Gene scores, and counted “arena wins” by comparing against the maximum in each domain — also unfiltered, so a disqualified 1.000 both won its domain and set a bar no valid entry could clear, and the creators leaderboard was built on top of that. The predicate now lives in one function that the board and R(g) both call, with a test pinning them to each other so they cannot drift apart again.

v0.17.0 (2026-08-19) — The Board Applies What It Can Prove

• 59 of 104 Arena rows stop ranking — v0.16.0 made the invalidation criteria runnable; this applies them. 30 rows carry a WASM artifact the runtime itself refuses to execute, 27 have no published artifact to have been measured against, and 2 are test data. Nothing is deleted: a disqualified row keeps every number it had and gains two fields, when and under which criterion, then drops out of the rankable set. Removing the evidence for a removal would defeat the point. The artifact scan is evidence rather than assertion — the bucket serves without credentials, the markers are the ones the sandbox refuses, and every scanned row records the SHA-256 of the exact bytes read. 33 of the 63 scans could be checked against the hash stored at publish time, and all 33 matched.
• Every legacy row now says where its number came from — all 104 rows written before the provenance column existed sat at unknown-legacy, which treated a sandbox measurement and a hand-typed placeholder as equally unknown. They are not. Four client paths wrote the board between February and August, and three left a fingerprint in the numbers that anyone reading the public table can check: the old publish placeholder is an exact tuple, the hash estimator emits exact thousandths whose dimensions share a seed, a sandbox run pins fitness at exactly 1.0, and a person typing produces round hundredths. 104 of 104 classified, none unmatched. Classification reads the shape of the numbers rather than recomputing them, because the estimator’s seed is genuinely unrecoverable after a hash canonicalisation change — and the shape is checkable without it.
• The fidelity discount the spec has required since v2.11 is finally applied — F(g) = base_fitness × FIDELITY_DISCOUNT[fidelity], native 1.00, hybrid 0.85, wrapped 0.70. The constant existed in the codebase and was called from nowhere, so every score on the board was an undiscounted base value regardless of how the Gene actually executes. Entries now carry base_fitness and the discount as stored columns rather than deriving them, because the discount is an adjustable protocol parameter and a row has to stay reconstructible after the parameter moves.
• Hybrid Genes compile as what they are — compile forced every Hybrid through the WASM toolchain, which refused all six in the corpus, while the error’s own hint pointed at Hybrid as the way out. A Hybrid runs under Node with the network gateway injected, which is what test and agent run already did. It now validates without producing an artifact and leaves the declared fidelity alone. The Wrapped-to-Native rewrite stays, because it is the documented path from a scaffold, but it stops being silent about it.

v0.16.0 (2026-08-19) — The Criteria, As Code Anyone Can Run

• The rules that decide whether an Arena score counts are now code you can run — a curated list of rows to drop asks you to trust the curator. rotifer arena audit runs the criteria instead, and every input it reads — entries, Genes, the artifact bucket — reads without credentials, so a third party reaches the same verdicts we do. The criteria answer one question: could this score have come from running the Gene, and can anyone verify that? They deliberately refuse to judge whether a number looks too high, because “0.97 is implausible” is not reproducible. Read-only: applying an invalidation to production is a separate, separately authorised step.
• An author can take a version down — rotifer unpublish wires up a client method that had been sitting there with no command calling it. Connecting it surfaced a defect worth naming: the row-level security policy narrows the update to rows you own, and in PostgREST an update matching zero rows is not an error — it answered with the same status a successful one does. Unpublishing a Gene you do not own reported success. The changed row is now read back, and an empty result is an error that says why.
• The evidence that would show double-counting returning is published — the five-second guard shipped in v0.15.0, but the defect it fixed had survived for months by producing no signal at all: a call counted twice looks exactly like a call. A probe now lists every pair of consecutive invocations of the same Gene by the same caller that land inside the dedup window; behind a working guard that list is empty. The window is defined in one place and read by both the guard and the probe, so the two cannot quietly disagree about its width.
• The bundled Genes compile again — 33 of the 50 Genes shipped with rotifer init could not be built at all, and a Gene that cannot compile was still being published — either with no artifact or with one built before the guard existed. Both produce a score nobody can reproduce. Two mechanical causes: an async entry point, which the WASM toolchain has no event loop for (in 22 cases the async was decoration, with nothing awaited anywhere in the body), and enum values left behind by a phenotype split. 38 of 50 compile now, and a regression test pins the exemption list so it can shrink but never grow. The 12 that still fail are itemised rather than left vague — 7 genuinely await I/O and need a design decision about how that is supposed to work, 3 import filesystem modules a sandbox cannot provide, and 2 carry other stale declarations.

v0.15.0 (2026-08-18) — Scores Say How They Were Measured

• An Arena score now carries how it was measured — an entry stored a number with no record of where it came from, so a score computed in a sandbox and one filled in by hand were indistinguishable once written. Write paths now declare the measurement method and the server attests to what it can actually verify, the per-run evidence behind a score is published alongside it, and entries gained provenance and invalidation columns — so a score that turns out not to be reproducible can be marked as such instead of quietly staying in the ranking.
• A retried invocation no longer counts twice — the call that records a gene execution could land more than once for a single run. It is now idempotent within a five-second window.
• The test suite stopped reading and deleting your credentials — the suite spawns the CLI a few hundred times, and nearly every helper handed the child whatever HOME the runner happened to have. One security test runs logout, and clearing credentials truncates then unlinks ~/.rotifer/credentials.json: running the full suite while signed in deleted your own login, every time. HOME is now redirected to a throwaway directory for every test file, and a guard asserts it stays that way.
• Both DeepSeek Harness rows lead with the brand — the plugin contributed two configuration rows named rotifer-skills and mcp-rotifer, which sort nowhere near each other in a list of over a hundred entries. Someone with the plugin installed and demonstrably working still could not find it. The second is now rotifer-mcp, and one search returns the pair.

v0.14.1 (2026-08-18) — An Install Command That Works

• The DeepSeek Harness install line named a package that does not exist — it read dsh plugin add rotifer, which assumes the plugin is published to npm under that name. It is not, and it must not be: rotifer on npm is a pointer package whose job is to stop the toolchain being impersonated, and this plugin has no binary to stand in for it. The command now installs from the repository, and both the README and the generated configuration carry the reason — so the next person does not “fix” the longer command by publishing over the reservation.

v0.14.0 (2026-08-18) — A Fifth Host, With No Code In It

• The Rotifer plugin installs into DeepSeek Harness — the folder that already served Cursor, CodeBuddy, OpenClaw and Claude Code now serves a fifth host, from one source and one version. The package contains no runtime code of ours: it declares two configuration rows that mount the harness’s own skill provider and MCP bridge. That pays twice — an API we never call cannot break us during a preview that states it will break, and installing the plugin does not place our code inside your agent runtime. The launch line is the same pinned, ten-tool evolve set every other host gets, with the sandbox escapes left off.

v0.13.1 (2026-08-18) — Test Runs Stop Counting as Usage

• Running a Gene from a test suite no longer counts as usage — 0.12.0 started recording each execution of a Cloud-installed Gene, and that included executions driven by a test run. A suite that exercises a Gene would report invocations against it, indistinguishable from someone actually reaching for it. The reporter now recognises a test runner (VITEST, JEST_WORKER_ID, NODE_ENV=test) and stays silent, including when the CLI is spawned as a child process of one. CI is deliberately not on that list: a Gene invoked from your pipeline is still a caller reaching for it.
• A security advisory in a bundled dependency is patched — the HTTP/2 crate the CLI links against moved to a version clear of RUSTSEC-2026-0258.
• The ClawHub listing shows “Rotifer” again — the display name used to live in a flag passed at publish time, so a release that forgot it reset the listing to the routable slug. It now travels in the plugin manifest, and a test fails if either the id or the display name goes missing.

v0.13.0 (2026-08-18) — The Plugin Stops Handing Out Every Tool

• The Rotifer plugin no longer launches the MCP server unpinned, with every tool reachable — installing it in Cursor or CodeBuddy gave you a floating version of @rotifer/mcp-server with all 31 tools available, publish_gene and login among them, and the sandbox escape hatches with them. It now launches a pinned version with the ten-tool evolve set and no --allow. The bundled Skill was stale in the same direction: it described /evolve upgrade as finding the top-ranked alternative and installing it, with no mention of approval, and called the fittest Genes “automatically selected”. Ranking is the automatic part; installing waits for you. The Skill now also states which tools it can reach, what it sends, where Genes are written, and how to undo an upgrade. The same plugin is now published to ClawHub as a third host.
• The plugin’s MCP server is actually registered now — five fields, mcpServers among them, sat at the top level of openclaw.plugin.json, which the host does not read. The manifest read as though the plugin provided the Rotifer MCP server while nothing registered it: written, shipped, never exercised. They now live in package.json#openclaw, and the validator reports no warnings.
• A failed run reports its invocation too — the CLI records each execution of a Cloud-installed Gene, but it sends that record without waiting for it, and every path that fails calls process.exit(1) immediately after. That killed the request mid-flight, so only successful runs were ever recorded. Failed runs count now as well.

v0.12.0 (2026-08-17) — Invocations Start Counting

Running a gene now leaves a record. Until this release it did not, anywhere — so the Arena’s usage metrics had never received a single data point since the day they shipped.

• The CLI reports gene executions — rotifer run and rotifer agent run now record each execution of a Cloud-installed gene, which is what the protocol’s usage and anti-manipulation metrics are computed from. Three conditions, all of them yours to control: only genes installed from Cloud (a locally authored gene is never reported), only while signed in, and never when ROTIFER_TELEMETRY=0 (or false / off).
• An empty result no longer scores as a pass in the Arena — rotifer arena submit measured success as “the sandbox exited cleanly and the output parsed”. A gene returning {} satisfied both, so a gene that promised seven fields and delivered none still scored a perfect success rate. Success now also requires the output to satisfy the gene’s own declared outputSchema; runs that break that contract are reported separately so you can see which of them failed and why.

v0.11.0 (2026-08-17) — Rollback, Uninstall, and a Call Counter That Works

• rotifer rollback and rotifer uninstall — return a gene to a previous version, or remove it from your workspace.
• Gene call counts were never incrementing — the server-side counter compared a text column against a UUID column with no conversion, an operation Postgres has no operator for. Every attempt to record a call raised an error that the caller discarded, so the count sat at its initial value forever while everything reported success. Fixed, with a regression test that records a call and checks the counter actually moves.

v0.10.2 (2026-08-14) — No More Silent Empty Results

A gene whose express() was declared async used to return nothing at all — and look completely healthy doing it.

• The runtime refuses an async express() instead of quietly returning {} — the WASM sandbox (Javy/QuickJS) has no event loop, so an async express() hands back a pending promise rather than a result. That promise serialised to an empty object, the module exited 0, and nothing was written to stderr: the gene produced no output while every signal said success. Arena scored those runs as passes. The sandbox now rejects such an artifact up front and explains the three ways out — recompile with a synchronous express(), run under Node with --no-sandbox, or publish it as a Hybrid gene.

The compiler has rejected this shape since the E0025 guard landed, but artifacts published before that guard still ran. If a gene of yours starts reporting this error, it was never producing real output; recompiling it synchronously is the fix.

v0.10.1 (2026-08-11) — Release Plumbing

A maintenance release with nothing to change how you use Rotifer. It fixes the release pipeline: package-lock.json was not being re-pointed at the freshly published platform packages, which broke npm ci for anyone working from the repository. Installing or upgrading the CLI was unaffected.

v0.10.0 (2026-08-11) — P2P Reliability

A reliability release for the P2P layer: nodes now find their way back on their own, and the two ways a node could silently fail to connect are gone.

• Nodes remember the peers they have met — a restarted node re-dials the peers it already knows, instead of depending on a bootstrap node every time it starts. Bootstrap is now only needed on a node’s very first run.
• No more silent bootstrap failure — the default bootstrap address pointed at a host that does not exist, and the dial failed without any error or log line: a node reported a healthy start while connecting to nothing. Nodes now ship with no default peer, and you pass one explicitly with rotifer network start -b <multiaddr>. There is no public Rotifer network yet, so you bootstrap your own — see the P2P LAN demo.
• Peer identification and connection limits — nodes exchange Identify and enforce inbound connection and memory limits, so a node is harder to overwhelm.

P2P remains off by default (enabled: false): the CLI never joins a network unless you ask it to.

v0.9.0 (2026-06-22) — Open Mesh + Economy Foundation

A large release: the CLI now speaks P2P, and the v0.9 economic foundation lands.

• P2P gene propagation (experimental) — the CLI can now run a real libp2p node. rotifer network start / announce / received lets nodes on the same LAN discover each other and propagate gene announcements. This is the first runnable step of the P2P stack; automatic discovery and reaching nodes across the internet are later milestones.
• rotifer doctor — a toolchain health check that flags missing or misconfigured dependencies before you build.
• Hybrid Fidelity genes — genes can now declare external dependencies, degradation behaviour, and a simulation spec, describing how they behave when their environment is unavailable.
• Auto safety badge on publish — rotifer publish now uploads the gene’s V(g) safety-scan badge automatically (opt out with --skip-vg).
• Economy + season system — reputation dynamics, automated season reset, and fitness/weight display land the v0.9 economic foundation.
• Login fix — the CLI login callback now binds reliably to the allow-listed local port, fixing the timeout some users hit.

v0.8.6 (2026-04-21) — CLI Runtime Bugfix + Native Addon Distribution

Four CLI runtime bugs fixed, plus the first release shipping prebuilt native binaries across all major platforms.

• Javy async Gene fix — async express() genes no longer crash with “Pending jobs in the event queue”; the compile step now detects async usage and reports a clear error
• Compile cache fix — rotifer compile now detects source file changes and recompiles; previously a stale gene.wasm was reused silently even after editing index.ts
• irHash serde fix — genes with an irHash in phenotype.json no longer fail on the native (wasmtime) execution path; the hex-string/byte-array mismatch is resolved
• WASM sandbox fuel fix — default fuel raised from 1M to 500M, memory to 256 MiB, timeout to 60s; Javy/QuickJS genes no longer hit “fuel exhausted” on trivial workloads
• Native addon distribution — prebuilt .node binaries now ship via platform-specific packages (@rotifer/playground-darwin-arm64, -darwin-x64, -linux-x64-gnu, -win32-x64-msvc); npm install automatically picks the right binary — no local Rust toolchain required

v0.8.5 (2026-04-08) — Ecosystem Alignment

First release where CLI, MCP Server, VS Code extension, docs, and install snippets all present a single coherent version number to users.

• Unified install experience: npm install -g @rotifer/playground, npx @rotifer/mcp-server, and the VS Code extension all point to the same v0.8.5 surface — no more version mismatch between tools
• Skill→Gene migration path documented: the rotifer wrap --from-clawhub workflow and Skill migration guide are now part of the public docs
• CLI update notifications: the CLI now alerts users when a newer version is available
• IDE distribution cleanup: plugin families and marketplace metadata are consistently versioned across VS Code Marketplace and Open VSX

v0.8.0 (2026-02-17) — Iron Shell

Security hardening, P2P Protocol RFC, Epoch automation, AI documentation assistant, and 30+ deliverables.

• Supabase deep security audit: Full attack surface validation across Hybrid Gene gateway, WASM upload, Edge Functions, Reputation RPCs, Badge Worker, V(g) scanner, Gene Registry, MCP call stats
• WASM sandbox escape testing: 15+ security tests covering memory OOB, infinite loops, host function abuse, resource exhaustion, malformed IR
• P2P Protocol RFC: Complete design document — transport (QUIC/libp2p), discovery (mDNS + Kademlia DHT), GossipSub messaging, Sybil/Eclipse protection, Cloud binding collaboration
• Security Checklist mechanism: Reusable version-level security checklist template integrated into CI and release flow
• Epoch automation: pg_cron daily reputation computation + monthly decay with idempotent compute_all_reputations() RPC
• ContributionMetrics: Anti-manipulation ready contribution tracking (gene_invocation_log, gene_contribution_metrics)
• LLM-Native Gene standard: Prompt Gene + Guard Gene phenotype definitions (ADR-084)
• Evolution API Level 1.5: Gene recommendation + Arena observability REST endpoints
• AI documentation assistant: RAG-powered chat on rotifer.dev with rate limiting, content filtering, caching, and analytics
• WebMCP Phase 1: 10→14 Agent-ready marketplace tools with auth + confirm dialogs
• Infrastructure resilience: GitLab→GitHub CI migration, Forgejo migration preparation, Cloudflare Pages deployment pipeline

v0.7.10 (2026-03-24)

Security hardening, WebMCP expansion, and China market readiness.

• Schema Compatibility Check: Static type checking for Seq pipeline — validates output→input schema alignment with PASS / UNCHECKED / FAIL diagnostics
• Try Fallback Error Propagation: Try operator now passes structured {error, original_input} to fallback genes instead of bare input
• WebMCP Phase 1: 10→14 tools — 4 new write-enabled (L3) tools: set_gene_visibility, request_arena_evaluation, create_gene, update_gene_metadata with auth + confirm dialog
• Path Traversal Guard: rotifer init now rejects project names containing ../ sequences
• China Network Guide: Chinese getting-started docs with cnpm mirror install and Supabase latency notes
• CI Pipeline Hardening: Fixed deploy configs, Node 20 compatibility, resilient network-dependent tests

v0.7.9 (2026-03-20)

Major milestone in protocol maturity and trust infrastructure.

• Safety Badge Pipeline: Automated verification gate (V(g)) with visual safety badges for genes
• Cloud Arena: Global fitness rankings with real-time competition
• Agent Blueprint: Export/import full agent configurations (genome + arena state)
• MCP Server: @rotifer/mcp-server enables IDE integration (Cursor, VS Code, Windsurf, etc.)
• Network Commands: rotifer network announce, network discover, network pull for P2P gene sharing
• Reputation System: Phase-weighted trust ranking R(g) complementing fitness F(g) (time decay planned for v0.9)

v0.7.x (2026-03-19 → 2026-03-20)

Rapid iteration series focused on stability and developer experience.

• v0.7.0 → v0.7.9: Progressive improvements to CLI reliability, error messages, and documentation
• Cloud binding stabilization and endpoint configuration
• Arena ranking algorithm refinements

v0.5.x (2026-02-23 → 2026-02-24)

• Reputation Foundation: Introduction of R(g) reputation scoring
• P2P Foundation: GossipSub metadata announcement, Kademlia DHT discovery
• Horizontal Logic Transfer (HLT): Cross-agent gene sharing infrastructure
• Composition Operators: Seq, Par, Cond, Try, Transform for multi-gene pipelines

v0.4.0 (2026-02-23)

• Cloud Binding: Supabase-backed cloud registry for gene publishing and discovery
• rotifer login / rotifer publish / rotifer search / rotifer install
• Cloud Arena: rotifer arena submit --cloud for global competition
• GitHub OAuth authentication

v0.3.0 (2026-02-22)

• Auto TS→WASM Compilation: rotifer compile automatically compiles TypeScript genes to Native WASM via the built-in IR compiler — no separate Rust/WASM toolchain required
• Rotifer IR: Custom WASM sections (rotifer.version, rotifer.phenotype, rotifer.constraints, rotifer.metering)
• WASM sandbox with fuel metering and epoch interruption

v0.2.0 (2026-02-22)

• Local Arena: Fitness-based gene ranking system F(g)
• rotifer arena submit / rotifer arena list
• L0 Constitutional Constraints: Safety gate enforcement
• Gene admission testing pipeline

v0.1.0 (2026-02-20)

The inaugural release — core gene lifecycle.

• rotifer init — Agent workspace scaffolding with Genesis genes
• rotifer scan — function compatibility detection
• rotifer wrap — function-to-gene conversion with phenotype.json generation
• rotifer test — sandbox testing with schema validation
• rotifer compile — Rotifer IR compilation (manual WASM input)
• Five Genesis genes included: genesis-web-search, genesis-web-search-lite, genesis-file-read, genesis-code-format, genesis-l0-constraint

Versioning Policy

The Rotifer Protocol follows Semantic Versioning:

• Major (1.x): Breaking protocol changes
• Minor (0.x): New features, backward-compatible
• Patch (0.0.x): Bug fixes and improvements

Current status: Pre-1.0 — the protocol is under active development. APIs may change between minor versions.

Roadmap

Upcoming milestones (subject to change):

Version	Focus	Status
v0.20.0	The published Skills get a public source, and a fourth joins them	Current
v0.19.2	Taking a version down actually takes it down; the L0 gate reaches every execution path	Released
v0.19.1	The official Genes get an owner who can sign in; ghost reputation scores cleared	Released
v0.18.0	The verdicts reach the page: tiered leaderboard, and R(g) stops counting withheld scores	Released
v0.17.0	The criteria applied: 59 rows stop ranking, legacy rows get provenance, and F(g) carries the fidelity discount	Released
v0.16.0	Arena integrity — the invalidation criteria as runnable code, and a compilable bundled corpus	Released
v0.15.0	Score provenance — an Arena entry records how it was measured	Released
v0.10.1	Release-pipeline fix (package-lock sync)	Released
v0.10.0	P2P reliability — peers remembered across restarts, silent bootstrap failure removed	Released
v0.9.0	Open Mesh + economy foundation	Released
v0.8.6	CLI runtime bugfixes (Javy async, compile cache, irHash, fuel) + prebuilt native binaries on all platforms	Released
v0.8.5	Unified version surface across CLI, MCP Server, VS Code extension, and docs; Skill→Gene migration path	Released
v0.9.1	P2P discovery layer (mDNS, DHT, internet)	Planned
v1.0	Stable release — L0–L3 complete, ≥2 Bindings, ≥100 Genes, security audit	Planned