the ship log
Changelog.
A workflow language earns trust by moving, and by not breaking what you wrote. Every public milestone, dated and tagged: the spec opened, the verbs locked, the permits: boundary (what a plan is allowed to touch), the tool library and the playground landed.
- 23releasesshipped
- 52milestoneslogged
- 8registerstags
- 08·05latestrelease
v0.108.0 · the access layer
The access layer arrives, and the check stops trusting what it cannot read. From this tag, model: picks the intelligence and access picks the path: the admission-time resolver is a pure function with a strict sovereign order (local · mock · harness · oauth · api), enumeration order can never change the outcome, and every dropped candidate carries its witness: the dimension, the layer, the teaching line. --access pins the path at the launch gates, before a token is spent: unsatisfied refuses, never substitutes. The ACP harness class lands with its mock agent in a quarantined workspace, proving the wire with no vendor in the loop. And the security fix that taught the train its lesson: a shell-string exec with no permits passed check green. The verifiable argv door refused while the unverifiable shell door stood open, the exact inversion of a security gate. The exec capability is now required whatever the spelling, and the runtime deferral owns dynamic values, never the door itself.
release notes on GitHubv0.107.2 · the adversarial pass
An adversary was set on 0.107.1’s six boundaries with one instruction, break it. Three of six claims fell, and hunting what the first repairs still let through found four more · every fix proven on the binary before the code was touched, each carrying the mutation that makes it fail. Two doors were open: a permit could name a system root by shouting it (/ROOT/x* passed where /root/./x* refused: macOS folds case, so the comparison does now, and the Linux side can only ever refuse a path that does not exist), and a secret redacted in the trace was printed on stdout (outputs: rides RunOutcome past the event lane · the map is scrubbed at any depth now). Three guards judged less than they claimed: the dangerous-environment floor is proven entry by entry (forty names, both halves pinned), a tainted nika:notify target is judged whatever channel carries it, and the run guard speaks only about runs (an unreadable payload no longer blocks ls). And one law had two implementations: the MCP spawn now composes its child environment through the same function as the exec runner · the copy was equivalent, and equivalence was exactly what nothing guaranteed.
release notes on GitHubv0.107.1 · the composition wave
The 0.107 train shipped the trust objects; an outside checkpoint then measured what a stranger actually meets and found the composition missing. Three synthetic personas (novice FR · senior dev · privacy-first) walked the binary end to end, and every fix carries the transcript line that found it. One door catalog, one ratchet: DoorId{Discover,Create,Project} is the single source behind every taught first-contact command: the five workspace states, the chat-only JSON mirror and the kit’s allowed-tools all derive from it, and a test replays EVERY command welcome can teach against the live clap tree. The dead nika examples the concierge kept teaching is gone from text, JSON, kit and docs, and hygiene vector 45 sweeps three rendered surfaces so the class cannot return. nika try opens on three jobs, not thirty-nine: one contrasted trade each (support · meetings · release), every row a taught try <slug>, while a pipe still gets the full parsable shelf byte-for-byte.
release notes on GitHubv0.107.0 · the trust release
An outside audit measured the experience instead of the feature list · five waves, seventy-two receipts, twenty-two P0s · and the arc closed every one: welcome gates its run CTA on the exact file’s verdict, a non-affirmative consent fires zero effects (NIKA-SEC-014, minted spec-first with its conformance fixtures), the hooks’ judge moved into the binary (nika guard, fail-visible, bypass matrix in test), autonomy is graded before it is colored, the data journey names sources, destinations and secrets before the run, and redaction works by provenance. The teaching grammar collapsed to three doors: nika try is the showroom (a slug runs the mock rehearsal offline by default), nika new takes one positional gesture (slug, plain words BM25-routed, or a filename that gets the wizard), nika init founds · the examples verb tree died and evidence/receipt moved under the run’s dossier. Around the core, one client matrix asserts the coverage of thirty-one hosts, nika wire previews and never rewrites unasked, and the host plane descended to nika-cli-host at the 15k wall (ADR-110). The catalog the site vendors grew its energy rows · sixteen, each carrying its ml.energy/arXiv provenance inline.
release notes on GitHubv0.106.1 · the checker reaches the browser
The browser release: the parse + conformance half of nika check compiled to WebAssembly and admitted through the full 12-gate ceremony (ADR-107), including a three-leg adversarial review that found a real engine bug before any browser saw it (a jq nesting bomb that killed the checking instance for good; the guard now refuses at depth 128 on every surface). The artifact debuts on npm as @supernovae-st/nika-check-wasm, packed by the release train itself: manifest projected from cargo metadata, host paths remapped out of the bytes, the tarball attached to the release and attested whether or not a registry credential exists. The registry copy carries npm provenance, byte-verified against the attested asset by the train’s own gate. In-band honesty rides every verdict (wasm: true and a closed legs: list), so the browser half can never be mistaken for the full binary. Around it the ladder tightens: when:/for_each: stop admitting the loop locals, and the audited card stops calling a ceiling a floor. This site’s /play runs the exact attested artifact. Embed it from npm and it judges your files the same way.
release notes on GitHubv0.106.0 · the values split, the authority speaks
The authority release: two flag-days in one window, and both change what an existing file MEANS. The value forms split into the four authorities. vars: and env: are dead (NIKA-VALUES-001 · NIKA-VALUES-002); inputs: · config: · const: · secrets: are the whole family, and the law is classify-not-rename: every entry moves to the authority its ROLE commands, never to one bulk destination (--var keeps its spelling; its target is inputs: now). And permits: stops being optional: absent is the EMPTY boundary, not the unconfined floor. A body carrying any effect with no block refuses NIKA-AUTH-006 before a token is spent; nika check --infer-permits prints the tightest block, and the round-trip law holds (the inferred block re-checks clean). Around them the attestation lane arrives whole: a run declares its entropy and its clock, boots from a manifest, seals what it covered, signs, anchors to a public transparency log, and exports a pack an auditor reads without trusting us. nika check --fix applies the mechanical half of the migration and stops untouched rather than guess at the rest. The site re-baked the same day: every served workflow speaks the four authorities natively, the hello declares its touch, the /learn radar opens on a blocking human gate (NIKA-SEC-009 · the lethal-trifecta judge), and the w1-to-w2 serving door retired. What you copy runs on YOUR installed binary.
release notes on GitHubv0.105.0 · the map comes home
The refonte reaches users: the file becomes a map. workflow: is an object (id + description), tasks: is a map keyed by id, and precedence reads the way you think: the binding IS the edge (with: declares the data edge) while control-only ordering is after: {producer: succeeded} against a closed predicate set. The old forms die loudly (a scalar workflow: is NIKA-PARSE-020, depends_on: is NIKA-PARSE-024) and nika check --fix machine-migrates the provable cases. The proof layer opens: semantic hash, nika.lock, receipt_format: 1, workflow composition (invoke: workflow:), and nika:decide, the deterministic decision kernel. One security seat ships in the tag: the lethal-trifecta judge (NIKA-SEC-009) refuses private-read plus untrusted-ingress plus external-egress with no blocking human gate on the path. The LSP learns the map end to end: server-side rename, per-block keysets, semantic_document_format: 1. Every surface you copy from re-baked the same day; what you copy runs on YOUR installed binary.
release notes on GitHubv0.104.0 · kimi takes a priced seat
Moonshot joins the canonical catalog: model: moonshot/kimi-k3 runs first-class (1M context, MOONSHOT_API_KEY), and the pricing snapshot makes --max-cost-usd a hard ceiling on kimi spend (the promotion run metered real cents against a printed worst case). K3 is a thinking model, and the honesty ships with it: reasoning spends output tokens, so budget max_tokens generously; starved, the answer comes back empty and the engine says why. The release branch cut from v0.103.0 on purpose: main is mid-refonte and users never ship a transitional grammar. Also in the wave: the lsp, graph and mcp fixtures that shipped red at the previous tag now speak the argv form, banked as a CI-coverage finding.
release notes on GitHubnika.sh v4.18 · the site speaks the shipped grammar
The 0.104 release flipped the language: the envelope became a scalar (workflow: my-job), tasks became a sequence (- id: …), and every edge is declared (depends_on: an undeclared tasks.X read now dies at check as NIKA-DAG-003; after: died with it). The public spec still teaches the old form, so the site now runs on TWO spec surfaces and says so out loud: /spec/v1 stays the ratified pin, /spec/shipped vendors what the released binary itself embeds (nika spec --schema and --canon, refreshed deliberately, never probed at build), and /sources renders the grammar gap as a third clock line beside builtins and providers. Everything a visitor can copy speaks the shipped grammar and is PROVEN against the released binary: every hero flagship and its served /library file, the /learn walk and its assembled weekly radar, both install hellos with transcripts re-captured verbatim, the verb chapters, the 404, the /convert proof, and every showcase room and template seed, which stay byte-pure ratified projections and convert at the door through one mechanical, idempotent, line-mapped pass. The plan choreography, the hero highlights and the inspector line anchors all re-aim through the same map, so nothing drifts from the text it animates. The playground lint learned the new world (scalar envelope, sequence tasks, duplicate ids, declared-edge DAG-003, after: refused with its fix line), its break-lesson inverted to teach the flip, and a shipped-ahead door renders text-only until the spec lands the room. Alongside the flip: the engine badge reads v0.104.0 everywhere, the tools register carries decide as ratified-not-shipped with its spec contract on the page, the types register lands its primitives read from the schema itself (the last soon chip dies), the provider catalog re-vendors at 0.104, and the hub headers stop sliding under the fixed nav.
release notes on GitHubv0.103.0 · the language tightens
The pre-1.0 window pays for itself: three breaking cuts in one wave, spec and engine merged in the same window. command: is argv-only (execve, no shell: an interpolated value can never break out of its argument) and the string form moves to shell:, the explicit door; semantics ride the field, never the YAML type. A bare ${{ tasks.X }} is now an error (NIKA-VAR-020): name the projection (.output, .status, .error, .duration_ms); the envelope is not a value. And the gate algebra becomes a normative spec table: the when-status pattern is a propagation choice, not redundancy. The whole corpus migrated in lockstep: docs, site, editor, kit and registry re-taught the same day.
release notes on GitHubv0.102.0 · the editor speaks the language
The LSP arc lands server-side: the pause after a colon answers itself (space joins the triggers), args: keys complete from the tool’s own schema, mode: enums scope to the enclosing tool, ${{ vars./secrets./env. }} complete from the FILE’s declarations, hover cards read the graph (wave position, transitive reach, model fallback tiers), and references resolve closure-aware. Around it: wave-sweep.sh, the one-command release sweep, and three new coherence-bot probes born from drifts caught by hand.
release notes on GitHubv0.101.0 · the sovereign lane ships whole
Every release binary now carries local-infer: nika model pull, nika model serve, then a workflow infer against your own machine. No cloud, no external daemon, no build-from-source wall. CPU on every target on purpose (darwin included) until candle’s quantized rms-norm Metal kernel is fixed: honest speed beats a crashing GPU path. The release funnel now pins the teaching both ways: a shipped binary must never utter « built without local inference ».
release notes on GitHubnika.sh v4.17 · one constant stage, and every word wired to the hull
The spec voyage gets its deep rebuild. THE ONE STAGE: the canvas never resizes again (the old flips reallocated the GL buffer and snapped the projection; measured storms of 200ms frames fall to zero frames over 34ms in either direction), the berth is a region of one full-screen stage, the sky drifts under the prose everywhere, and the seam lives in the shaders: the hull melts toward the reading on the site’s own ordered-dither door. The camera answers to a sovereign frame at full-screen stages (a deep link can never paint the close-up over the prose again), poses commit only when the hand calms, the yaw takes the short arc instead of unwinding whole revolutions, and the page opens on a metamorphosis: the 2D elevation fades under the rising hull while the camera glides its approach, the reverse of the close. And the close earns its ceremony: a longer runway holds the assembled flyover grand, the plates melt away so the lay-down plays unannotated, and as the hull dissolves into its own drawing a real shader supernova fires: core flash, twin chromatic-fringed shockwaves cooling from white-blue to ember orange, counter-turning rays, falling dust, the whole hull irradiated by its own light while the drawing wakes stratum by stratum beneath it. Then the birth: a burst, an expanding ring, the butterfly blooms and the nika mark forms out of letter-space. The reference is wired alive now: the read section roots a stratum-hued umbilical INTO its card (a machined joint at the word, a drifting current on the wire, the ignition spark trailing a comet), hovering any word tends an ephemeral wire to ITS block on the vessel in the same hue with a joint at both ends, hovering an index chip or a transport tick spotlights that whole station before the click, and the hover readout leads with its stratum’s dot. Around the voyage: the home film opens at the hero itself (one continuous axis, the seam between poster and runway gone, then no seam at all: the floor opens and the field crosses), the plan becomes the file’s minimap and THE LEAP flies a curve grown mid-flight, the hero strip carries the whole corpus with the selected tab reading as the file it is, /files ships the official mark with a browser strip and per-file sources, the dither glow retreats by its corner, and every exec teaching speaks the 0.103 register (argv default, shell: explicit) with transcripts re-captured from the released binary. Underneath: the runway CSS is pinned to its model, every visitor-readable YAML rides a gate, and the trunk’s drift gates caught the one desync before it shipped.
release notes on GitHubnika.sh v4.16 · the ship lies down in its own drawing
THE LAY-DOWN closes the spec voyage: past the last station the vessel folds its yaw to the whole revolution, lays flat into the exact pose of its 2D engineering drawing, dissolves into it, and the nika mark closes the file over the sources rail (an e2e pin parks inside the window to prove the handoff every run). The home film front-loads its gesture: the YAML becomes the DAG in the first half of the runway, the wires close over the last landings, and the run (terminal, timeline, badges) rides the same scroll from mid-gesture; the verdict keeps its tail. The voice purge lands site-wide: about 345 authored lines rewritten for real (blog posts, llms.txt, every register and room, this ship log itself), each dash a real edit, while the truth layer keeps its own words: engine failure-lines, provider contracts, captured transcripts and quoted artifacts stay verbatim, because rewriting a citation would make the page lie. WHERE THE LANGUAGE LIVES ships one verified sources map (every URL checked against the live repos before it renders) on the rooms, the 3D berths and the spec close, and the cross-reference graph closes: errors and templates point back at every room that names them, derived by inverting the rooms’ own data. The heavy usage registries leave the initial bundle behind inline-JSON islands (their refs twins keep the graph sync), the dither field drops its framework for one raw quad, the run posters go WebP at a third of the bytes, and the language doors get their share cards. Underneath: the version gate now re-captures transcripts against the real binary on every engine wave (it caught a CLI voice change a sed would have missed), and the heal lane opens one idempotent PR that the gate itself judges.
release notes on GitHubv0.100.0 · the terminal sings, the models come home
The terminal learns to sing: a verb band colors every task by its verb, the spinner is a real live probe, and nika run paints the DAG as living wire-art in-frame (states, in-node spinners, edge pulses) while nika inspect --format json|mermaid|dot becomes the ONE graph projector, now projecting declared policy too (retry, timeout, on_error, outputs). nika init becomes a founding wizard: recipes, themes, wiring, everything asked before the first write, and it equips a repo for the agent surfaces project-side. The models come home: nika model pull/list/rm (one models dir by construction, resumable verified downloads) and nika model serve (the sovereign sidecar, OpenAI-compatible on loopback) close the local loop. nika check --fix is an in-binary repair loop that converges, and the machine dry-run ships versioned.
release notes on GitHubnika.sh v4.15 · every word gets its room, every room its machine
The vocabulary completes. Every builtin opens its own room: the arg contract in the binary’s own words, the tool inside a real file (a verbatim skeleton excerpt at its true line numbers, or a crafted workflow that passes check; the drift gates re-prove both on every test run), the skeletons that ship it, the check gates that name it, the family walk. The four verbs get rooms of their own, and every key the schema declares gets its register row: 51 words projected from the served contract, never prose, with an honest miss for anything else. THE PIN DRUM plays the standard library on /tools: one row per builtin, one pin per real argument (bright means required), six family blades, a fixed comb; walking prev/next between rooms turns one persistent machine exactly one notch. Then the parts catalog: every room berths its OWN machine in the ship’s ink: six family archetypes (the file cabinet’s required drawers sit pulled out at you), four verb emblems (infer’s halo carries one spoke per provider), no two parts share a silhouette, every count a catalog count, and a 2D engineering drawing of the same instance tables stands in wherever GL never mounts. The ship links back (every spec section head opens its organ’s page), and ⌘K answers the whole vocabulary now, builtins, verbs and keywords alike. The spec voyage earns its grace: the floating plate dies into the rail: one 42px machined strip whose read segment expands to speak its organ and the chapter keys, titles never break (an overflowing tail fades under a machined window; at narrow berths resting titles fold whole and hover peeks them back); hull plates stand down when the prose column would cut them, and the opening flight flies like a vessel at last: the yaw follower under a hard velocity ceiling, the hull banking into its turns, the pointer’s hand on the wheel only at rest. The sitemap learns class-aware tiers, the nav opens the new doors, and every room speaks schema.org.
release notes on GitHubnika.sh v4.14 · the site names its doors
Two new registers open. The skeleton templates get eleven landings (instantiate, never invent): every SLOT-marked skeleton with its one-command instantiation, deep-linkable, and a deep link lands instantly now (a smooth-scroll hijack had it travelling; the same sweep then made every arrival on the site land instant). The hero names its two moments (audited before a token is spent, a verifiable receipt after every run) and the get-started close names the doors plain: Claude Code, Codex, Cursor, VS Code, Hermes, OpenCode, Zed, GitHub Actions, MCP, one link to the full integrations map. The spec vessel learns to navigate: the position plate grows prev/next chevrons and finally says the chapter keys exist, neighbour stations keep a ghost label on the hull, and the ship sails with the reading: scroll velocity swells the engine wash and pitches the bow into the travel. The DAG becomes a component library (one card, one vocabulary, gated by test), the use-case cards speak it calmer, and the home film’s 3D morph lies down for good: the flat register is the one truth. Post bodies leave the initial bundle (354 → 304 KB gz). Two posts land: the agent workflow spectrum, and the generative AI workflow minus the mystery. And the belts keep pace: the registers get their pins (the first catch shipped fixed), the ship log proves its own truth (this very entry rides the gate it shipped) and the spec pick bus answers a trusted spiral that listens for the cursor.
release notes on GitHubnika.sh v4.13 · the reading wires to the ship
The spec voyage keeps its colours: the hull no longer drops to shadow-blue at the dock. Every station keeps a floor of its own hue through the whole read, the stratum being read stands under a spotlight while its siblings recede, and a block drifting too near the camera dissolves through an ordered screen-door instead of printing a black mass over the read. Three stations reframe their shots (the reactor reads against space, the bridge clears the ring, the extract fan opens from below). The floating labels and the cursor-chasing tooltip die; in their place, the umbilical: one gradient wire from the section you are reading to its station, and on every ignition a spark rides it into the hull on the same clock as the station’s swell. The column reads in order now: index first, glance second, reference third, the protocol plate closing the file beside the license invariants. Site-wide, the poster law generalizes (every mono-section hero paints at first paint, animations earn their start from the first gesture) and the transport drag is 1:1 again (a smooth-scroll hijack had lagged every seek since the rail shipped). Posts stop hiding their article: LCP 4.8s → 2.7s. The standard library gets its register (28 tool landings), providers and a human sitemap join, the trace family becomes a reading path, four graduated showcases join the explorer, and a details pass makes every surface answer the hand. Four posts land from live proof sessions: the local forecast, the chain of custody, the MCP server you didn’t have to build, the pipeline is a file. And the belts reach where nothing looked: the spec voyage itself (stage, ignition, helm, chapter keys), share cards, feeds, the 390px battery, under one honest local gate runner.
release notes on GitHubnika.sh v4.12 · the machined frame
The device frame is rebuilt from zero. Ten rounds of accretion (five stacked layers, per-section tints, hue journeys, a small state machine of moods) collapse into one machined element: a flat near-black slab, one gasket, one recess, one static edge-light in the site’s struck blue, byte-deterministic on every display. The one thing that still moves is the drum: while a run replays, a hairline ring draws around the screen with the recorded progress, beats brighter as each task starts, completes on the verdict, and holds the danger red through a failure. The playground joins that grammar: /play’s run-order simulate now beats the same ring the home film does, and leaving the page mid-run aborts it: the ring never outlives its run, and a belt navigates away mid-sim to prove it. One danger red everywhere: the frame’s flash was a stray coral; it now speaks the same red as the failing verdict and the denied permits row, pinned across files by test. The spec vessel’s opening becomes a full-bleed poster with a precisely measured approach, prose terms wire live to their stations and the gauge becomes a transport of nine real links; the nine steps of /learn feed the wayfinding rail; cargo binstall and nix join the install paths.
release notes on GitHubnika.sh v4.11 · the ship wears its colours
The spec vessel becomes the voyage it promised. It arrives whole and coloured: the permits ring in boundary orange, the standard-library hold and extract array in tool cyan, the provider engines in model blue, the error shield in agent violet, the envelope keel in the struck blue. It turns on its own against a swept starfield, no labels, just the shape. The reading docks it deck by deck; past the last section the finale hands it the whole width, every stratum lit, every station labelled from its plate slot. The wheel never fights the page (zoom moved to ctrl+wheel), a flick of the drag now coasts with real weight, and the exploded drawing pulls the camera back so it always fits. The share card and the phone poster carry the same coloured elevation, extracted from the page itself. And the home’s wayfinding rail goes site-wide: every page with sections gets its ruler, the spec’s S-blocks included.
release notes on GitHubnika.sh v4.10 · one plan language
The film taught the grammar; now every plan on the site speaks it. A shared PlanMap carries the film’s flat map verbatim: the slab card with its verb-hued inset, the wave captions in the film’s own words, the hairline chevron on every wire. /use-cases, the home gallery and /play’s live plan all draw the same object the film flattens into. Plans that outgrow their column scroll inside their own well, keyboard included, on every surface. The journal earns its register filter: deep-linkable, counts derived from the posts themselves, issue numbers absolute under any view. Two engine-truth posts land from live proof sessions: kill -9 a run and resume it (finished work never runs twice), and the approval gate as a task: fails closed headless, the human’s answer rides the resume, a refusal is a run that worked. And a long-lived ghost dies on the way out: the hero’s background field could lose its GL init for a whole session and composite blank; a watchdog now remounts it until the first frame paints, on the site and in the golden harness both.
release notes on GitHubnika.sh v4.9 · the spec ship
The spec machine becomes a vessel. The strata leave the disc and take stations along a spine, read bow to stern: the bridge (the plan), the reactor core (four verbs), one great habitat ring braced by four spokes (the permits boundary every outbound run crosses), the hold (the standard library in five family arcs), the antenna array (nine extract ports off fetch), the engine block (five local nozzles docked on the spine, ten cloud outboard, one mock dim) and the shield skirt (fourteen typed-error plates). And the keel is the envelope itself, its ten keys the spine segments everything mounts on. The drum of liberation lends its heartbeat: a 2.4-second breath sails the hull bow to stern while the reading ignites each station in turn, one exact revolution from opening frame to lit close. The page becomes its engineering plate: the ship rides beside the title from the first paint, labelled by leader lines that carry real counts, over a protocol plate, an honest family microchart and a nine-chip index that tracks the reading. And it answers the hand now: drag to orbit (it springs home), wheel to zoom, one button to explode the drawing apart along the spine: the wires stretch, still connected.
release notes on GitHubnika.sh v4.8 · the spec machine
The language reference becomes an instrument you read with. /spec splits into a measured ledger and a sticky rail where the whole language stands as one concentric machine: the four-verb core, the plan ring, the gate collar, the tool belt, the fetch manifold, the provider halo, the containment shell; every block derived from the spec canon, spoken in the site’s wire-blue ink. The reading assembles it: each section you cross ignites its stratum, the TOC ticks fill, and the HUD keeps the tally until the whole contract stands lit, one full revolution later. Every node answers the pointer (hover reads it out, click lands on its row), and every chip, stamp cell and TOC pill lights its block back. Phones, reduced motion and no-WebGL keep a designed 2D floor plan of the same machine, lit by the same reading. The optional envelope keys and task controls fold behind native disclosures, and a counted drift dies: chart and image_fx take their real families, the family count derives forever.
release notes on GitHubv0.99.0 · the audit tells the whole truth, the run narrates its own
The check ladder earns its MODELS rung: every model: must resolve in THIS binary; a bare id or an undriveable provider is a finding with the fix taught in-line, pricing refuses to conjure what it cannot resolve, and the MCP nika_check lane obeys the same law. Two media builtins graduate: nika:image_fx (15 deterministic op families over a hand-rolled PNG codec, recipe in the tEXt chunk) and nika:chart (five chart types compiled to byte-identical SVG, parity proven across architectures): both zero-dep, both sha256-chained into the trace. Egress to outputs closes the one documented gap: the workflow boundary gets its own sink-only declassification valve, and every embedded template now passes its own audit. explain --forecast computes duration/cost/risk priors from YOUR local traces (p50/p90 earned at n ≥ 5, never a model call); wire covers opencode and hermes (8 targets); and the release tarball itself is funnel-gated: a stranger’s broken first run never uploads.
release notes on GitHubnika.sh v4.7 · the manifesto learns to prove itself
The poem gets a proof layer: THE RECORD, a two-strand timeline of who controls access to intelligence (the cage in grey, the drum in light), every entry dated and carrying its primary source, probed weekly by CI so a dead link fails the build. The founding Friday is pinned (the letter, the switch-off, the tap reopening nineteen days later) and the hero stamp deep-links straight to it. On desktop the record becomes a stage: vertical scroll plays the track left to right through a fixed playhead (drum above the baseline, cage below, the live card lit, a big tabular year turning, a minimap riding the score), while mobile and reduced motion keep the vertical truth. The five promises now carry receipts, the statements ignite as they reveal, and the section frame speaks eight languages.
release notes on GitHubnika.sh v4.6 · the black frame, and the page learns its colour law
The device contour is rebuilt around one rule: the material is black, the colour is light. A near-black frame carries a static edge-light whose hue and richness read the section under it (blue over the hero, coral at the close, calm on reading pages), the screen recesses into the frame on all four edges, and the ambient loop that breathes the iridescence is finally alive at rest: a mount-order race had silenced it since the frame was born. The home composition gains the same clarity: dark is the stage, every light or blue chapter is a sheet laid on it. And a dark-only site learns to print: white paper, black ink, whole code panels.
release notes on GitHubnika.sh v4.5 · the film becomes an instrument
The home film gains a real transport: a docked run monitor with live timecode, seek from any surface (a DAG node, a log line, the file itself), and an ending that lands on the $0.00 · local punchline, then hands the exact file you watched to the playground, one click from editable. The whole site now lives inside a living device frame: a dark skeuomorphic contour whose colour, depth and light read the section and route you are on, igniting while a run plays.
release notes on GitHubv0.98.0 · native answers, one lexer
Structured output rides each provider’s own grammar (Anthropic output_config, Gemini responseJsonSchema, OpenAI strict-mode honesty) with a coercion ladder that repairs before any paid retry; the checker closes run-fail gaps (the block-sequence bomb dies as NIKA-PARSE-001, env: binds at run exactly as checked); the ${{ }} scanner becomes one shared crate for checker AND runtime: parity by construction; and the first 30 seconds learn to speak: nika welcome mirrors your machine, nika explain narrates a file, init briefs six agent surfaces, --max-cost-usd refuses to start past the static floor.
release notes on GitHubv0.97.0 · the run becomes evidence
Every journal line carries a hash chain: trace verify walks it and names the first broken link; trace reproduce says whether a run is reproducible and WHY not; the journal attests which engine on which platform wrote it. Models are priced before the first run (602 rules from models.dev; the VS Code preflight shows $/1M on this tag); check IS the dry-run (the plan names what dispatches when); doctor speaks JSON; bare init/new converse; and the drift warn tells a re-encode from an edit.
release notes on GitHubv0.96.0 · the run becomes a place
nika dap brings time-travel replay debugging over the run journal (breakpoints in your YAML, step forward AND backward; the VS Code F5 integration lights up on this tag); trace export projects any journal to OTLP for Jaeger/Grafana/Langfuse; check --json states the caller contract (requirements: models, keys, secrets, env) before any token; a typo'd field teaches (did you mean `infer`?); runs record their source sha and skips say why.
release notes on GitHubv0.95.0 · the catalog practices local-first
The 5 local servers (Ollama, LM Studio, llama.cpp, LocalAI, vLLM) join the catalog with descriptions, tags and seed models: keyless by construction, sovereign models stay unpriced, never « free ». A bare nika suggests the next command; write honors create_dirs: false loudly, date resolves timezones from the bundled db, log neutralizes control sequences, and the MCP stdio transport bounds its reads.
release notes on GitHubv0.94.0 · the media suite · every run leaves a journal
Two media builtins take the stdlib to 25: image generation and editing plus speech synthesis, sovereign-first with provenance manifests; every run now writes .nika/traces by default, --task scopes execution to one cone, the catalog rides the wire (catalog/tools --json + an 8-tool MCP oracle on 2026-07-28), cost_usd never lies, and doctor --ping actually probes the local ports.
release notes on GitHub17 model providers · Hugging Face and NVIDIA join
Two more ways to bring your own model: Hugging Face and NVIDIA endpoints join the catalog (5 local runtimes unchanged; the sovereign path stays the default).
v0.93.1 · the pack teaches 2026 models
The embedded teaching pack vendors the current spec cascade, so nika init hands a 2026 local model the language on day one; the README gains the daily-commands loop.
release notes on GitHubv0.93.0 · the run becomes durable
Kill a run mid-flight and --resume banks the finished work as visible cache hits; a nika:prompt gate pauses durably for a human answer; nika test joins the CLI and local models get honest timeouts.
release notes on GitHubThe blog is a folder
content/blog in the site repo IS the blog: PR-able markdown compiled to real pages with the product’s editor panels. The archive backfills the journey, one post per milestone, at its real date.
release notes on GitHubThe playground draws the plan
nika.sh/play renders the live DAG of your file as you type, simulates the run order over the real topology (no fabricated timings), and reads the declared blast radius back to you.
release notes on GitHubv0.92.0 · the agent-native release
Agents learn the language from the binary: MCP tools serve the schema, examples and canon; nika init scaffolds AGENTS.md; nika wire reaches Codex and the Claude Code plugin marketplace. macOS binaries ship signed and notarized.
release notes on GitHubv0.91.0 · smoother first fifteen minutes
nika examples run --model previews any embedded workflow offline: no key, no model server; nika init and nika wire handle onboarding; headless Linux builds compile clean.
release notes on GitHubv0.90.0 · first public release
One brew-installable binary for macOS and Linux: the 4 verbs end to end, the nika check static audit, and an embedded examples pack.
release notes on GitHubnika.sh v4 · Intent as Code
The site rebuilt around one idea: a real .nika.yaml file, instant and crawlable, with the spec as the single source of truth.
release notes on GitHubThe playground · validate Nika in the browser
Edit a real workflow at nika.sh/play and watch it check as you type, with the engine’s own NIKA error codes. No install to try it.
release notes on GitHubpermits: · the declared blast radius
Every plan can state exactly what it may touch: files, hosts, programs, tools. Once permits: is present, every category is default-deny.
Enforced before it runs · NIKA-SEC codes
Out-of-bounds is denied, not logged after the fact: an effect past the permits: boundary fails with NIKA-SEC-004 before the action happens.
The provider catalog goes local-first
One verb, any model: five local runtimes (Ollama, LM Studio, llama.cpp, LocalAI, vLLM) and a cloud catalog led by open-weight. Your machine, your choice.
Four verbs, locked forever
infer · exec · invoke · agent: a verb is a distinct native execution model. No fifth verb, ever (D-2026-05-22-N18).
MCP, native · any server through invoke
Reach a Model Context Protocol server the same way as a builtin: invoke a mcp: tool id. Default-deny: the file whitelists what an agent may call.
fetch · 9 extract modes
One builtin turns a page into typed output 9 ways: article, markdown, text, links, metadata, selector, sitemap, feed and jq. Read-only by design.
Standard library v0.1 · 28 builtins
28 builtin tools across files, data, web and flow, all reached the same way, with invoke:. Nothing to install.
The error catalog · 103 typed codes
Every failure has a stable NIKA-* code across 25 namespaces: published, machine-readable, the same in a CLI run and the validator.
The JSON Schema · one workflow contract
workflow.json describes a valid plan end to end: the nika: v1 envelope, the four verbs, the permits: block. Your editor checks it as you write.
The spec, released under Apache-2.0
nika-spec is open and runtime-agnostic: the envelope, the verbs, the JSON schema and the conformance suite, free to adopt.
23 releases · 29 public milestones · spec counts derive from nika-spec canon