v0.1.0-pilot.5

Kemiri v0.1.0-pilot.5

Aiki is now Kemiri, with a new home at https://kemiri.dev. This remains an early,
assisted pilot. A paired device has full backend access, including files, shell
and provider spending. Use your own accounts and repositories; this is not a sandbox.

What's new since pilot.4

• Videos play again in the installed web app. Private videos and partial
  downloads no longer enter the app-shell cache. If playback fails, the viewer
  shows “This video can't play here” and offers Download, Open in new tab and
  Try again instead of leaving a black 0:00 player.
• One name, one command: kemiri. The old aiki command and AIKI_* process
  settings are removed. At startup, existing server.env settings are rewritten
  to KEMIRI_*, with the original saved as server.env.bak. Existing Kemiri keys
  win conflicts. Rename any settings you supply through your shell or service
  environment yourself before restarting. Do not rename data/config folders.
• Releases now contain only kemiri-* downloads and kemiri/ source archives.
  Android custom links use kemiri://. Historical task links still work;
  new commits use the Kemiri-Task trailer.

Coming from pilot.2 or pilot.3?

Since those releases, HTML reports open as real pages on web and Android, follow
light/dark mode, offer Print and retain up to 20 saved versions. A built-in
html-artifacts skill helps agents make readable reports. The phone's page viewer
fills the screen and supports scrolling and zooming. Older chat history loads
again when you scroll back. MCP presets, command servers and reviewed JSON imports
add choices to the remote MCP support already present in pilot.2. After the manual
bridge upgrade, supported supervised installs offer owner-confirmed Update now
from web or Android, with health checks and automatic code rollback; no unattended
updates. The button updates your backend, not your APK.

Update while stopped

Back up config/state while stopped and repositories separately. Stop a foreground
backend with Ctrl-C. If using an installed user service, remove it with the old
command's service remove first; after updating use kemiri service install
instead of kemiri start. Do not uninstall the app or delete pairing/data folders.

Pilot.2 or pilot.3 — first install the bridge:

aiki update --version v0.1.0-pilot.4
kemiri update --version v0.1.0-pilot.5
kemiri start

Pilot.4 — normal standalone install (Linux glibc x64/ARM64, macOS ARM64):

kemiri update --version v0.1.0-pilot.5
kemiri start

Pilot.4 also installs aiki; its update command works for this binary transition,
but the old command is removed after activation. Use kemiri thereafter. Projects,
paired devices, credentials and existing installation paths stay in place.
Rollback changes code, not data; keep your backup.

Bun/source installs, Intel Macs and Linux musl (Alpine): pilot.4's embedded
updater still requires an aiki/ archive and cannot accept pilot.5's kemiri/
archive. After reaching pilot.4, use pilot.5's installer, not its embedded updater:

curl -fL https://github.com/MitzaCoder/kemiri/releases/download/v0.1.0-pilot.5/install.sh -o kemiri-install.sh
curl -fL https://github.com/MitzaCoder/kemiri/releases/download/v0.1.0-pilot.5/install.sh.sha256 -o kemiri-install.sh.sha256
# Compare: shasum -a 256 kemiri-install.sh with the downloaded checksum; read the script.
sh kemiri-install.sh --version v0.1.0-pilot.5 --no-service
kemiri start

If originally installed with --dir, pass that same absolute --dir to the new
installer. Keep custom KEMIRI_INSTALL_DIR/KEMIRI_CONFIG_DIR settings. Do not choose
a new folder. --runtime bun is supported by the new installer. On this source
fallback path, a pilot.4-written aiki launcher can remain: it selects pilot.5
and is harmless. Use kemiri; a later activation removes the owned old launcher.
Direct installed
pilot.2/3 updates to pilot.5 are not supported: go through pilot.4.

Fresh install: use the install guide
or download and review https://kemiri.dev/install.sh with the explicit pilot.5 tag.

Android: get the signed APK from the release page
and install over the old app, without uninstalling. Public application ID remains
io.github.mitzacoder.aiki; the signing key is unchanged. VersionName is
0.1.0-pilot.5, versionCode 1000005 (pilot.4: 1000004). Check the APK hash and
certificate in RELEASE-MANIFEST.json. A private/debug install may use another key.

Known limits and help

Linux is the tested host path; macOS and Windows through WSL remain experimental.
No signed/notarized Mac binary. Android needs Android 12+, a backend reachable over
HTTPS and an awake computer; the APK is not a tunnel. Real-network Android pairing
and native macOS service updates still need acceptance. There are no phone push
notifications. Review MCP permissions and command arguments before enabling tools.

Write to support@kemiri.dev with your version and redacted symptoms. Never send
credentials, pairing links or private session data. The published RELEASE-NOTES.md
adds the exact commit, signed APK hash and certificate from RELEASE-MANIFEST.json.

Published build identity

• Source commit: c4602ec0def630d2d95d4540155512af175be788
• Android: 0.1.0-pilot.5, versionCode 1000005, package io.github.mitzacoder.aiki
• APK SHA-256: a6e8234bca599e5fa607a4cb58dbee8ddbfb943c5a91cd4b00c794c38260c4f8
• Signing certificate SHA-256: a97bdfae948d34c2589afb4bc78acce22f079d51e6aaa2e4025f7d7d38e611e2

v0.1.0-pilot.4

Kemiri v0.1.0-pilot.4

The first Kemiri release, previously called Aiki. This is still an early, assisted
pilot: run coding agents on your own computer and follow their work in a browser
or Android. Use your own repositories and provider accounts. A paired device has
full backend access, including shell, files and provider spending. This is not a
sandbox or a shared hosting service.

What's new since pilot.3

• The Kemiri name. The app and command are now Kemiri. The old aiki command
  and AIKI_* settings still work. Existing installation folders, credentials,
  pairings, projects and settings stay in place. Do not rename or delete them.
• HTML artifacts open as pages, on web and Android, with a source view when
  needed. Pages follow your theme, offer Print and can open in a separate web tab.
  Android's page fills the viewer and supports scrolling, panning and zooming.
• Artifact history. Saving the same filename on a task updates one card with
  previous/next version controls. Up to 20 snapshots are retained; downloads use
  the selected version. Existing cards remain available as version 1.
• A bundled html-artifacts skill gives agents report, proof index, dashboard
  and slide templates. It loads only when needed; your own design instructions
  take precedence. Project settings can optionally block page connections and
  forms. That switch is not a guarantee of an offline page: permitted images,
  media, CDN requests and external links can still send data.
• Older conversation history loads again when you scroll back.
• Owner-confirmed backend updates, from web or Android after this first manual
  upgrade. Review the version and notes, then confirm. The backend waits for running
  tool calls, not whole agent turns; Cancel is available before restart. An unhealthy
  new backend automatically restores the previous code. No unattended updates.
• More MCP choices. Search developer-service presets, run command-based MCP
  servers and review JSON imports before adding them. Presets explain sign-in and
  permissions; they do not connect or enable tools automatically.
• Roomier MCP/artifact dialogs and quieter update notices. The temporary
  top-level-only board task filter has been removed.

How friends update

From pilot.3 (also pilot.2 or pilot.1): back up state/config while stopped and
back up repositories separately. Stop the foreground backend with Ctrl-C, then:

aiki update --version v0.1.0-pilot.4
kemiri start

aiki start still works too. For an installed user service, stop it first with
aiki service remove, run the update above, then use kemiri service install
instead of kemiri start. The old installed updater deliberately downloads
compatible aiki-* assets; this release also publishes canonical kemiri-* assets.
No re-pairing, folder move or uninstall is needed. Pilot.3 lacks the new updater
API/supervisor, so use this stopped CLI update once before trying Update now.
A code rollback does not undo database migrations; keep your backup.

Fresh install: see the install guide.

curl -fL https://github.com/MitzaCoder/kemiri/releases/download/v0.1.0-pilot.4/install.sh -o install.sh
# Read install.sh and verify the release checksum before running it.
sh install.sh --version v0.1.0-pilot.4 --no-service
kemiri start

In another terminal run kemiri open, then kemiri pair. Keep the one-time pairing
URL/code private. The website bootstrap is at https://kemiri.dev/install.sh
until the Kemiri domain cutover; download/read it first and keep the explicit
--version v0.1.0-pilot.4 argument.

Android: install the new APK
over the old one; do not uninstall. The package remains io.github.mitzacoder.aiki
and the owner signing key is unchanged. VersionName is 0.1.0-pilot.4, versionCode
1000004 (pilot.3 was 1000003). Compare checksums and the certificate fingerprint
in RELEASE-MANIFEST.json with the owner's invitation. Private/debug installations
may use a different key. The APK is not updated by the backend update button.

Known limits

• Linux is the tested host path. macOS and Windows through WSL are experimental;
  native macOS service update acceptance is still needed. Linux binaries need
  glibc; unsupported binary platforms use the private-Bun fallback. macOS binaries
  are not signed/notarized.
• Android needs Android 12+, a backend reachable over HTTPS and an awake computer.
  The APK supplies no tunnel. Keep authentication on and approve matching pairing
  codes in an already paired browser. A real-network pairing check is still needed
  before inviting phone use; local preparation does not certify it.
• No phone push notifications in this pilot. Ordinary foreground use needs no
  Google account or Firebase setup.
• MCP tools have your backend's authority. Review imports, permissions and command
  arguments. Preset sign-in may need a vendor account or registered OAuth app.

Send redacted symptoms and version details, never credentials, pairing links or
session data. Before publication the owner appends the exact source commit, APK
hash and signing certificate to the draft's RELEASE-NOTES.md.

Exact release identity

• tag: v0.1.0-pilot.4
• commit: 4e3f658c2b3dd4d832b451d7f96381540849a9ab
• package: io.github.mitzacoder.aiki
• versionName: 0.1.0-pilot.4
• versionCode: 1000004
• apkSHA256: 1d1a9d04c18cc55ee5b2587543d0a56cd47a59c0ad22770b51ba5390d80c91fc
• certificateSHA256: a97bdfae948d34c2589afb4bc78acce22f079d51e6aaa2e4025f7d7d38e611e2

v0.1.0-pilot.3

Aiki v0.1.0-pilot.3

An early, assisted pilot: run coding agents on your own computer, then follow their
work in a browser or Android. Use your own repositories and provider accounts.
A paired device has full backend access, including shell, files and provider
spending. This is not a sandbox or a shared hosting service.

What's new since pilot.2

• Fixed “Could not start MCP sign-in” with Notion on local installs, on both
  localhost and 127.0.0.1. Sign-in errors now explain the reason more clearly.
• Copy sign-in link lets you finish MCP sign-in in another browser. If it
  cannot return to the initiating app, copy its callback URL and paste it there.
• The bottom-left corner now shows your backend version and an update available
  notice. Open it for Settings → About and release notes. Updates stay manual.

Install or update

See the install guide
for prerequisites and reviewed download steps.

curl -fL https://github.com/MitzaCoder/aiki/releases/download/v0.1.0-pilot.3/install.sh -o install.sh
# Read install.sh before running it.
sh install.sh --version v0.1.0-pilot.3 --no-service
aiki start

In another terminal, run aiki open, then aiki pair. Keep the one-time pairing
URL/code private; connect a provider and choose a project. The short installer is
curl -fsSL https://aikilabs.dev/install.sh | sh; it checks the release installer's
checksum. Download and read it first if you prefer.

From pilot.2: stop Aiki and back up state/config and repositories, then run:

aiki update
aiki start

Pilot.2 already follows its saved pilot channel, which includes later pilots and
stable releases. No --version is needed unless you deliberately switched channels
or want an exact tag. Nothing updates or restarts automatically. For a user
service, stop with aiki service remove and start with aiki service install
instead; for foreground use, stop with Ctrl-C. A code rollback does not undo
database migrations. If you added the AIKI_ALLOWED_ORIGINS workaround for Notion,
you can keep or remove its local-origin entries after upgrading. Preserve any
other trusted origins you still need.

From pilot.1: use aiki update --version v0.1.0-pilot.3 once while stopped to
acquire pilot-channel support, then start Aiki. That first update may use Bun.

Android: install the new APK
over the old one; do not uninstall. It uses the same owner signing key and package
io.github.mitzacoder.aiki, versionName 0.1.0-pilot.3, versionCode 1000003
(pilot.2 was 1000002). Check its checksum and the certificate fingerprint in
RELEASE-MANIFEST.json against the owner's invitation. Private/debug installations
may have a different key. Settings → About and licences has dependency notices.

Known limits

• Linux is the tested host path. macOS and Windows through WSL are experimental.
  Linux binaries require glibc; macOS x64 and Linux musl use the Bun fallback.
  macOS binaries are not signed/notarized.
• Android needs Android 12+, your own backend reachable over HTTPS and a computer
  that stays awake. The APK supplies no tunnel. Keep authentication on and approve
  the matching pairing code in an already paired browser.
• No phone push notifications in this pilot. No Google account or Firebase setup
  is needed for ordinary foreground use.
• MCP tools run with your backend's authority. Review permissions and approval
  arguments. Notion requires an account before consent. Remote/source backends
  still need an explicitly trusted callback origin.

Expect rough edges. Send redacted symptoms and version details, never credentials,
pairing links or session data. The owner adds exact source/APK/certificate details
to the draft's RELEASE-NOTES.md before publication.

Exact release identity

• tag: v0.1.0-pilot.3
• commit: 20b0e10752a934ceaec0831034293944417cbc8e
• package: io.github.mitzacoder.aiki
• versionName: 0.1.0-pilot.3
• versionCode: 1000003
• apkSHA256: 85c079c1be0f8b30cbbabad220e962664c48d5554373d86167807645e1c68a84
• certificateSHA256: a97bdfae948d34c2589afb4bc78acce22f079d51e6aaa2e4025f7d7d38e611e2

v0.1.0-pilot.2

Aiki v0.1.0-pilot.2

An early, assisted pilot: run coding agents on your own computer, then follow their
work in a browser or Android. Use your own repositories and provider accounts.
A paired device has full backend access, including shell, files and provider
spending. This is not a sandbox or a shared hosting service.

What's new since pilot.1

• Text files now open when the installed app uses localhost and its backend uses
  127.0.0.1 (or the other way around). Failed reads offer a retry.
• An Update available notice and Settings → About link to release notes.
  Installed backends check about once a day; checks can be turned off. Updates
  stay manual. The saved pilot channel includes later pilot releases.
• A single executable for Linux x64/arm64 and macOS arm64. Matching installs need
  no Bun or JavaScript dependencies. The private, pinned Bun fallback remains.
• Attach files to chat on web and Android, including Android sharing. PDFs supply
  extracted text, not scanned-page OCR.
• Connect MCP servers, including Notion and remote servers. Choose tool policies
  and enable them separately for coordinator, workers and background work. Servers
  start off; sign-in and available tools depend on the server.
• Anthropic limit reset details, with explicit confirmation before a free reset.
• Task reports now show freshness and an automatic Now line. Timelines group by
  hour; project delivery settings can follow an integration branch and deploy feed.

Install or update

See the install guide
for prerequisites and reviewed download steps.
The short install command is:

curl -fsSL https://aikilabs.dev/install.sh | sh

This runs a checksum-verifying bootstrap pinned to this pilot. Download and read
it first if you prefer. The direct GitHub release URLs remain valid:

curl -fL https://github.com/MitzaCoder/aiki/releases/download/v0.1.0-pilot.2/install.sh -o install.sh
# Read install.sh before running it.
sh install.sh --version v0.1.0-pilot.2 --no-service
aiki start

In another terminal, run aiki open, then aiki pair. Keep the one-time pairing
URL/code private; connect a provider and choose a project.

From pilot.1: stop Aiki and back up state/config and repositories, then run:

aiki update --version v0.1.0-pilot.2
aiki start

That one exact-version update gives the old updater pilot-channel support. It may
use Bun for this first update. Later updates are simply aiki update, while
stopped; restart afterward. Nothing updates or restarts automatically. A code
rollback does not undo database migrations. /releases/latest excludes pilots.

Android: install the new APK over the old one; do not uninstall. It uses the
same owner signing key and package io.github.mitzacoder.aiki, versionName
0.1.0-pilot.2, versionCode 1000002 (pilot.1 was 1000001). Check its checksum
and the certificate fingerprint in RELEASE-MANIFEST.json against the owner's
invitation. Private/debug installations may have a different key. Settings →
About and licences has dependency notices and source pointers.

Known limits

• Linux is the tested host path. macOS and Windows through WSL are experimental.
  Linux binaries require glibc; macOS x64 and Linux musl use the Bun fallback.
  macOS binaries are not signed/notarized.
• Android needs Android 12+, your own backend reachable over HTTPS and a computer
  that stays awake. The APK supplies no tunnel. Keep authentication on and approve
  the matching pairing code in an already paired browser.
• No phone push notifications in this pilot. No Google account or Firebase setup
  is needed for ordinary foreground use.
• MCP tools run with your backend's authority. Review permissions and approval
  arguments. OAuth needs a correctly configured callback origin; Android offers
  paste-callback recovery if the browser does not return to the app.
• PDF extraction is text-only and bounded; encrypted, scanned or malformed files
  may provide little or no text. Provider subscription eligibility still applies;
  a saved credential does not prove inference works.

Expect rough edges. Send redacted symptoms and version details, never credentials,
pairing links or session data. The owner adds exact source/APK/certificate details
to the draft's RELEASE-NOTES.md before publication.

Exact release identity

• tag: v0.1.0-pilot.2
• commit: 766cb08e4659267278bc3ce93b21506bf87205a5
• package: io.github.mitzacoder.aiki
• versionName: 0.1.0-pilot.2
• versionCode: 1000002
• apkSHA256: a373a7ec5f9b3b061efe0d17b2e43a95fefb8a219f33d45da1f6c3c8eae22112
• certificateSHA256: a97bdfae948d34c2589afb4bc78acce22f079d51e6aaa2e4025f7d7d38e611e2

v0.1.0-pilot.1

Aiki v0.1.0-pilot.1

An early, assisted pilot for a few friends: run coding agents on your own computer,
then follow their work in a browser or the Android app. Use your own repositories
and provider accounts. A paired device has full backend access, including shell,
files and provider spending; this is not a sandbox or a shared hosting service.

• Linux is the tested host path. macOS and Windows through WSL are experimental.
• Install Git/jj and the prerequisites in INSTALL.md. Download and
  inspect this release's install.sh, then run
  sh install.sh --version v0.1.0-pilot.1 --no-service.
  Start with aiki start; in another terminal use aiki open, then aiki pair.
  Keep the one-time pairing URL/code private. Set up your provider and project.
• Android needs Android 12+ and your own backend reachable over HTTPS, for
  example with assisted Tailscale Serve. The computer must stay awake. The APK
  does not supply a tunnel; keep backend authentication on. Use a fresh device
  pairing link from the paired browser, then approve the matching code there.
• No phone push notifications in this pilot. No Google account or Firebase
  setup is required for ordinary use. Foreground connections still work.
• The APK is signed for io.github.mitzacoder.aiki. Check its checksum and the
  certificate fingerprint in RELEASE-MANIFEST.json against the owner's invitation.
  Settings → About and licences contains the dependency notices and source pointers.
• Before updating, stop the backend and back up state/config and repositories.
  Install APK updates over the existing app; do not uninstall first. The public
  key/package is not automatically compatible with an older private/debug install.
  Code rollback does not undo data migrations.

Use the exact prerelease tag in download links and update commands:
aiki update --version v0.1.0-pilot.1. /releases/latest and unqualified updates
select stable releases, not this pilot. Expect rough edges. Send only redacted
symptoms and version details, never credentials, pairing links or session data.

Exact pilot build

Source commit: fa25e23b81d2dc9e56acf7b96faf7e8f12f9e51c.
Package: io.github.mitzacoder.aiki.
Android version: 0.1.0-pilot.1 / code 1000001.
APK SHA-256: 4442fd1bfba94e53ac2edccd64ffb9da0601be3e5a262c03c138ecb7fa1e5405.
Certificate SHA-256: a97bdfae948d34c2589afb4bc78acce22f079d51e6aaa2e4025f7d7d38e611e2.

This is a draft prerelease for owner review, not a published release. Keep the owner-held signing key and password backed up outside this release. Complete the licence/SDK review and assisted HTTPS pairing acceptance before invitations.