Skip to content

Nika v0.124.3 · latest release ·

Nika changelog.

A workflow language earns trust by moving, and by not breaking what you wrote. Every release is here with its notes, newest first, then the public milestones: the spec opened, the verbs locked, the permits: boundary (what a plan is allowed to touch), the tool library and the playground landed.

Install v0.124.3Downloads on GitHub

  1. v0.124.3: An application can ask what a workflow's declared route offers

    On nika serve, GET /v1/access-offers/{name} admits a served workflow by name, reads its run.access and, when the file selects ACP sessions (via under protocol: acp), opens the sessions a run of that file would open: one per shape its tasks run in and per model they resolve to, the route's one-shot completion profile for infer: tasks and its agent session for agent: tasks.

    Each session selects the file's model for that session only, lists the models, the exact reasoning efforts and the service tiers the route has for that model, and ends: no effort, tier or mode is set and no prompt is sent, so an offer uses no turn. The answer is a nika/access-offer@1 document: the file's declared route, then one row per session with observed_at and fresh_until.

    A model the session does not list is a row state, and its efforts and tiers are then left unobserved instead of being read from another model. A session that gives no offer is a row with the code a run would meet (NIKA-1803, NIKA-1804, NIKA-1805), and a workflow that declares no ACP route answers not_applicable and opens no session.

    Rows are kept 60 seconds (15 when unavailable), one reading runs at a time, and a ninth concurrent request answers 503 access_offer_busy. The request names a served workflow and nothing else, and the answer authorizes no run: POST /v1/jobs still selects, reads back and refuses on its own session. The workflow language and the SDK protocol are unchanged; a server that answers this request lists accessSessionOffer in the supportedCapabilities of /health. The TypeScript SDK @supernovae-st/nika 0.124.3 follows in lockstep and reads the offer with accessOffer(workflow).

    v0.124.3 on GitHub
  2. v0.124.2: A workflow can ask its route for a service tier

    run.access.service_tier takes standard or fast on the codex seat over ACP (via: codex, protocol: acp): the session selects the tier with the model and the effort and reads the selection back before its first prompt. The binding is held for codex-acp 1.13.1; another release of the adapter, a model whose session lists no such option or a read-back that does not hold the value is refused before the prompt (NIKA-1805).

    A route that cannot carry a tier (an API or local route, a seat without a measured control, an infer: task outside protocol: acp) is refused before task 1, by nika check and by the run (NIKA-1800). Leaving the key out is not standard: nothing is sent, the route keeps its own tier, and the file keeps its resume identity and its receipt.

    When a file declares a tier, the receipt keeps apart what was requested, offered, sent and read back, and says unknown for the tier a turn carried and the tier that served it, because no ACP answer names them. An ACP task starts its adapter once instead of twice. A refused seat and a refused route declaration no longer suggest a pin the same file refuses, and nika check --infer-permits names the host an exec: URL reaches.

    The SDK protocol is unchanged; an engine that reads the key lists accessServiceTier in supportedCapabilities. The TypeScript SDK @supernovae-st/nika 0.124.2 follows in lockstep and reads the access contract and the service tier of a task.

    v0.124.2 on GitHub
  3. v0.124.1: The first maintenance release of the 0.124 line

    On a direct seat route without ACP (codex exec, claude -p, Grok Build, GitHub Copilot CLI), an infer: task with vision: files is refused with NIKA-432 before the seat starts, instead of running without its images; nika check blocks run ready on the same code, and both name a route that carries the files. nika run --dry-run refuses what the run's seat refuses.

    Where nika check said a mock rehearsal or a file with no model route dials nothing, it names the tasks that can still reach the network, and its estimate adds the paid media calls and the least they cost instead of reading ≤$0.0000. nika explain answers the MCP pin refusals NIKA-MCP-003 to NIKA-MCP-006, a file saved with a byte-order mark is framed on the right line, and nika serve lists the files a for_each fan-out saved. The workflow language, the file format and the SDK protocol are unchanged. The TypeScript SDK @supernovae-st/nika 0.124.1 follows in lockstep.

    v0.124.1 on GitHub
  4. v0.124.0: Contact sheets, a keyless voice and images from agent applications

    nika:image_compose lays 1 to 64 PNG files out as one image (a grid, a row or a column), byte-identical for the same inputs, and nika check judges every input as a read. nika:tts_generate speaks with no key through provider: system (macOS say, Linux espeak-ng), reported as unpriced local work. An agent: task on a seat can declare images: and save, inside permits.fs.write, the images the application sent; today Codex sends them.

    Under a cost cap, paid images and speech are priced from a dated table of public list prices and charged to the cap (GPT Image 2.5 from the usage it reports), and paid media the table cannot price, such as OpenAI's default voice gpt-4o-mini-tts, gpt-image-1.5 and gpt-image-1-mini, is refused before any request, so a beat on one stays unready until it moves to a priced model or the system voice.

    Some workflows 0.123.2 accepted are now refused: a vision: file is a read inside permits.fs.read, and the trifecta and confirm-gate checks follow a child workflow through its call. A Codex command that asks to leave its sandbox always pauses, and one --answer decides one ask. nika doctor and nika welcome name the nika that is running, and doctor lists every other nika on PATH.

    The nine-key envelope and machine protocol 2 are unchanged. Native video is planned for 0.125. The TypeScript SDK @supernovae-st/nika 0.124.0 follows in lockstep.

    v0.124.0 on GitHub
  5. v0.123.2: The second maintenance release of the reference line

    An agent: task on a harness seat (Codex, Claude Code, Gemini CLI) is now held to the workflow's permits as far as the seat allows: Nika selects the seat's asking mode, judges every ask against your grants, pauses for network access, sandbox widening and the harness's own MCP tool approvals, and nika check says what the seat still does without asking. nika serve lists and streams the files a settled job made, each proven against its sealed journal, and verifies journals sealed with an explicit run key pair.

    A mock rehearsal no longer calls itself offline: the mock replaces the model, not the network, and nika try names the hosts a step may reach. crypto-bigint leaves its yanked release. The workflow language, the file format and the SDK protocol are unchanged. The TypeScript SDK @supernovae-st/nika 0.123.2 follows in lockstep, with an access pin on run() and check(), a 16 MiB default buffer for engine frames and results, and artifact downloads.

    v0.123.2 on GitHub
  6. v0.123.1: The first maintenance release of the reference line

    A security update (crypto-bigint 0.7.6, RUSTSEC-2026-0387) and corrections to what Nika says on your first runs. nika welcome opens with "Say it once. Keep it as a file." and no longer advertises a hosted Nika service, which does not exist; access errors, hints and help name commands that exist (nika doctor --verbose, nika key init, plain nika init); nika init --example copies the files its lesson reads; and a new project keeps the nika serve token and job state out of Git. The workflow language, the file format and the SDK protocol are unchanged. The TypeScript SDK @supernovae-st/nika 0.123.1 follows in lockstep.

    v0.123.1 on GitHub
  7. v0.123.0: The open-source reference release

    Bare nika opens the terminal workspace: describe an outcome, answer only what is missing, and Nika writes a .nika workflow, checks it and, where it can, rehearses it on a copy of your files before anything is saved or run. nika check reads the whole file first (permits, where secrets go, literal credentials, cost estimates, the lethal trifecta); --max-cost-usd caps a run, every run is recorded under .nika/traces/, and nika arm emits launchd or systemd units.

    The workflow names its model and Nika never substitutes another silently. After this release the project is maintained for security fixes, bug fixes and compatibility. The TypeScript SDK @supernovae-st/nika 0.123.0 ships with it; the VS Code extension stays at 0.120.0. The release notes list the known limits.

    v0.123.0 on GitHub
  8. v0.122.0: An explicit authoring effort and results a rehearsal is judged by

    nika compile --authoring-reasoning low|high|max asks every authoring and decision call for a named reasoning effort, sent only where the catalog qualifies it and refused before any byte leaves elsewhere. The compiler states, from the request alone, which files it wants written and what they must hold, and judges a rehearsal's output by value.

    v0.122.0 on GitHub
  9. v0.121.0: The conversation from a request to an inspectable result

    Bare nika opens the terminal Session: describe the work, review and correct the proposed .nika workflow, save it, then choose Run explicitly. Check, admitted access, recorded execution and the output stay separate proofs. --plain gives the line interface.

    v0.121.0 on GitHub
  10. v0.120.3: The Serve compile door and rendered approval bindings

    POST /v1/compile is the authenticated, bounded HTTP transport of the same stateless Compile core as nika compile: exact-skeleton CREATE and constant EDIT return the candidate, questions, requested boundary and source-only Check preview as data, with no job, file, provider call or ambient key consent. Both doors advertise the compile capability. Pending human approvals now render resolved task bindings with secrets masked. The One SDK 0.120.3 and the plugin marketplace follow in lockstep.

    v0.120.3 on GitHub
  11. v0.120.2: Source-true compile edits and the v-prefixed image alias

    Compile EDIT replaces only the bytes of the edited constant. Licence header, comments, key order and line endings survive, and integer answers outside the exact i64 range are refused instead of rounded. The release train tags vX.Y.Z on the same GHCR manifest, so the v-prefixed docker alias resolves. The ecosystem coherence bot now reads the live editor identity and this site's llms.txt.

    v0.120.2 on GitHub
  12. v0.120.1: Canonical program paths and consent checks

    Project schemas accept .nika program references with their existing path restrictions. Compile derives private pattern facets from the parsed program. The checker refuses value reads of stages that certainly skip when consent is denied; ambiguous routes remain advisory. SDK and editor publication are separate.

    v0.120.1 on GitHub
  13. v0.120.0: Scheduled beats carry their inputs

    An arm: entry may declare per-beat inputs, so a tenant-parameterized workflow is armed once per tenant instead of rendered once per tenant. nika run --inputs-json - takes typed literal inputs on stdin, nika serve accepts literal inputs on named jobs and carries them through recovery, and a resumed run names the trace it continues.

    v0.120.0 on GitHub
  14. v0.119.0: The token bill, split

    The run card and every metered trace frame name the prompt side of the bill (input, cached, output, reasoning tokens), so a warm-cache call and a cold one no longer look the same; nika trace export carries the GenAI usage counters. Bare nika restores the project conversation after reopening, and a job may carry a durable access pin.

    v0.119.0 on GitHub
  15. v0.118.7: Hash checks and bounded journals

    Hash arguments agree across check and execution, and Gemini tool declarations carry their canonical JSON Schema. File journals refuse bytes beyond the verifier bounds while preserving runtime settlement; incomplete trace diagnostics describe the evidence available. Agent guidance distinguishes readiness from execution and effects. Complete proofs for oversized runs remain follow-up #1458.

    v0.118.7 on GitHub
  16. v0.118.6: Release identity stays bound

    The published release preserves its tag and source commit while updating OCI and release metadata. Authoring guidance distinguishes draft checks from child execution and follows the cleanup contract. SDK and editor delivery remain separate.

    v0.118.6 on GitHub
  17. v0.116.2: The gauntlet closes on the final tree

    The published recovery train supersedes the unpublished v0.116.1 tag. Relative permits keep their identity during concurrent ancestry changes, resident schedules settle before store shutdown, oversized authenticated HTTP uploads return their typed 413 response, and secret-bearing workflows stay out of panic and fallback diagnostics. The release carries the complete night gauntlet and its final-tree estate proof.

    v0.116.2 on GitHub
  18. v0.116.0: One SDK, two live transports

    nika serve gains the durable authenticated HTTP authority owned by its OpenAPI contract: immutable snapshot admission, persisted jobs, ordered SSE replay, cancellation, contained workflow discovery, schedule CAS and typed trace diagnostics. The root Nika facade carries the same lifecycle vocabulary across native process and HTTP. The npm client 0.116 publication remains blocked at its trusted publisher; the engine release is available now.

    v0.116.0 on GitHub
  19. v0.115.0: The resident HTTP boundary becomes machine-visible

    The OpenAPI record names live POST statuses, failed jobs and refused captures carry typed NIKA codes, token files fail closed with a pasteable mint, and downloadable binaries include the access-harness lane. The checker adds one-obvious-way hints while keeping warnings distinct from admission failure.

    v0.115.0 on GitHub
  20. v0.114.0: Loopback HTTP and a named project

    Default nika serve stays the resident firer. --bind with --workflows and --token-file opens authenticated loopback HTTP: jobs, SSE and OpenAPI. Cancel, artifacts and POST /v1/run stay 404. A project file names itself (nika: my-project); nika: v1 on nika.yaml is the retired schema tag.

    v0.114.0 on GitHub
  21. v0.113.0: The judge the agent can see

    Error codes and nika explain ride MCP, CLI JSON and wasm as one well. Pipelines are judged per segment. Four form-first skeletons join nika new. The workflow envelope is unchanged since 0.112.

    v0.113.0 on GitHub
  22. v0.112.0: The instrument tells the same story

    nika list names every workflow below the directory. Check JOURNEY counts model endpoints, not tasks. A recovered fan-out says so in its record. A cargo test binary can no longer open the OS keychain.

    v0.112.0 on GitHub
  23. v0.111.0: The authoring loop closes

    The checker now distinguishes a legal file from one ready to spend: paid_ready goes quiet only when no paid-run hint remains, compiled means the law was proven, and next names the first repair. nika:inspect is live from the first task and follows the run after every wave, so a workflow can read its DAG, records, spend and threads. nika:compose stays inside an agent loop after nika:done, where the model can draft, read the whole check verdict and revise without making check execute the draft.

    The arm lock now survives the shot, and the paid extract wave repairs structured hashing, string schemas, scalar anyOf coercion and resumed for_each item fields.

    v0.111.0 on GitHub
  24. v0.110.0: The file proposes, the machine fires

    The project file gains an arm registry for scheduled workflows. Every beat names its workflow, cadence, execution place, cost ceiling and missed-run policy; choices that decide spend or lost work have no silent default. One firer serves the direct command, emitted launchd and systemd units, and the resident serve loop, so locks, overlap rules and ceilings do not change with the launch door. Unsupported policies refuse instead of being approximated, suspended beats carry a reason and an end date, and every skip is written as an event.

    v0.110.0 on GitHub
  25. v0.109.1: A tag without binaries

    It repaired the release gates that refused v0.109.0, then the Linux builders refused it one leg later (no bubblewrap on the runner). No asset was published under this tag; the installable nine-key engine is v0.109.2.

    v0.109.1 on GitHub
  26. v0.109.0: The nine-key language change, tagged without binaries

    The tag names the language change: the envelope shrinks from fourteen keys to nine. Its own pre-upload gates refused every builder, because they still wrote the fourteen-key envelope; no asset was published. The installable nine-key engine is v0.109.2.

    v0.109.0 on GitHub
  27. v0.109.2: The nine-key envelope ships

    The envelope is nine keys: nika: is the mark and the name, never a version marker. Values come from three authorities (inputs · const · secrets). The first two 0.109 tags died at the release gates before any asset landed; this is the one a visitor can install. Linux builders now install bubblewrap so a permits: file is judged confined, the same way macOS already was.

    v0.109.2 on GitHub
  28. 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.

    v0.108.0 on GitHub
  29. v0.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.

    v0.107.2 on GitHub
  30. v0.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.

    v0.107.1 on GitHub
  31. v0.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.

    v0.107.0 on GitHub
  32. v0.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.

    v0.106.1 on GitHub
  33. v0.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.

    v0.106.0 on GitHub
  34. v0.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.

    v0.105.0 on GitHub
  35. v0.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.

    v0.104.0 on GitHub
  36. v0.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.

    v0.103.0 on GitHub
  37. v0.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.

    v0.102.0 on GitHub
  38. v0.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 ».

    v0.101.0 on GitHub
  39. v0.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.

    v0.100.0 on GitHub
  40. v0.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.

    v0.99.0 on GitHub
  41. v0.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.

    v0.98.0 on GitHub
  42. v0.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.

    v0.97.0 on GitHub
  43. v0.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.

    v0.96.0 on GitHub
  44. v0.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.

    v0.95.0 on GitHub
  45. v0.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), cost_usd never lies, and doctor --ping actually probes the local ports.

    v0.94.0 on GitHub
  46. 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.

    v0.93.1 on GitHub
  47. v0.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.

    v0.93.0 on GitHub
  48. v0.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.

    v0.92.0 on GitHub
  49. v0.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.

    v0.91.0 on GitHub
  50. v0.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.

    v0.90.0 on GitHub

34 milestones

Milestones

The spec, the language, the tools, the boundary and this site. A milestone is dated to its month.

  1. nika.sh v4.23: The origin becomes one story

    The six origin records now read as one continuous arc, from the first objection to the name. The series page replaces its generic card grid with a dated ledger that shows reading order, source receipts and the evidence boundary before a reader opens a chapter.

  2. nika.sh v4.22: The honest origin ledger

    Four retrospective field notes fill the public story from November through February without pretending they were published then. Story dates and publication dates are now separate across the journal, feeds and structured metadata, and six records form one origin series from the first note to the name.

  3. nika.sh v4.21: The SDK control room

    The SDK now connects nika.yaml project setup, local runs, runtime proof and the resident firer, separate from the future HTTP service.

  4. nika.sh v4.20: Ten field notes, one calmer instrument

    Ten long-form field notes close the July and August gap across access, local models, MCP, receipts, CI, coding agents and the workflow ecosystem. The catalog gains a compact two-clock resolver with one-shot motion and a settled reduced-motion state. Blog cards now derive from post frontmatter, the public queue advances, the missing arming release rejoins the changelog, and every lazy enhancement waits until hydration so the static page and the live page agree.

  5. nika.sh v4.19: The operational map

    Searchable map, catalog clocks, install guides and a gated publishing loop.

  6. nika.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.

  7. nika.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.

  8. nika.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.

  9. nika.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.

  10. nika.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.

  11. nika.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.

  12. nika.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.

  13. nika.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.

  14. nika.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.

  15. nika.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.

  16. nika.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.

  17. nika.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.

  18. nika.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.

  19. nika.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.

  20. 16 model providers · Hugging Face and NVIDIA join

    Two more ways to bring your own model: Hugging Face and NVIDIA endpoints join the catalog (the 5 local runtimes unchanged; the sovereign path stays the default).

  21. The 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.

  22. The 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.

  23. nika.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.

  24. The 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.

  25. permits: · 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.

  26. 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.

  27. 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.

  28. 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).

  29. 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.

  30. fetch · one builtin, typed extract modes

    One builtin turns a page into typed output: article, markdown, text, links, metadata, selector, sitemap, feed, jq and raw (the body as fetched). Read-only by design.

  31. Standard library v0.1

    Builtin tools across files, data, web and flow, all reached the same way, with invoke:. Nothing to install.

  32. The error catalog · typed codes

    Every failure has a stable NIKA-* code, grouped by namespace: published, machine-readable, the same in a CLI run and the validator.

  33. The JSON Schema · one workflow contract

    workflow.json describes a valid plan end to end: the nine-key envelope (nika: is the mark AND the name), the four verbs, the permits: block. Your editor checks it as you write.

  34. 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.

The same record, elsewhere

50 releases and 34 public milestones. The counts an entry states about the language come from the nika-spec canon.