DogEar 1.1.0

Release candidate. DogEar 1.1.0 ships as an RC - it becomes final on the owner's phone verdict plus a clean soak, on this same build. Web app 1.6.0, certified live at app.getdogear.app (worker sha256 83293d98c8f75550...).

Install: download dogear.apk below and open it on the phone - same signer as every DogEar build, so it upgrades in place. dogear.aab is the Play bundle for the Nov 12 store push.

What's new - the voice-quality release:

• The app answers questions about itself by voice: what it is, what the controls do, how Talk works, the plan - 600 listening minutes free each month, and the one-time US$24.99 unlock.
• Speech finishes what it starts: a watchdog re-speaks from any cut point and accounts for every job - a lost piece is a logged defect now, never a silent stop.
• Failures explain themselves out loud, cause and remedy (microphone blocked, no speech heard, voice pack missing); the bare "listening failed" is gone.
• The transport wedge that killed beta.5's press series is fixed by construction - a speech cancel no longer holds Stop authority. 25/25 press cycles and the process-death Continue-at-the-pin proof pass on this build.
• Minimize and screen-off during playback: the position advances through both - proven clean on this candidate.

Known limits, in plain words:

• After a permission revoke (Android kills the app) and a relaunch, the player can rarely show "playing" while nothing sounds. Stop, then Play, revives from the saved place. A named soak item: fixed, or re-accepted by name, before this release is called final.
• Server-side Play purchase verification switches on when the Play Console credential is provisioned; until then the entitlement lives on the device.
• Bigger voice models (Small and up) stay capability-gated in the shelf, with the reason shown.

Gate: PASS WITH FINDINGS (release-gate pack dogear-app-2026-10-24-final). Guardian Mesh probes NOT RUN (spec inputs filed), as on prior DogEar verdicts.

DogEar v1.1.0-beta.5 — app-first (RC)

DogEar v1.1.0-beta.5 — the controls are the app's now

The buttons are native. That is the whole release.

Beta.4's owner phone test found the truth: while the app was
speaking, the Talk button and the pause/stop presses lived on
the web page — the busiest thread in the app at exactly that
moment — and presses queued, vanished, or landed late. Beta.5
rebuilds the scaffolding app-first. The core was fine; the
scaffolding was not. Now:

• A standing native control bar sits under the page from
  the first frame — before any document, before any page has
  rendered — painted and pressed on Android's own UI thread.
  No press can be starved by the page again.
• One native state machine (PlayerCore) owns playback,
  voice, position and marks. The bar, the lock-screen and
  notification controls, headset buttons, and the page all
  command the same machine and read the same state. A pause
  is a pause everywhere, at once.
• All eight in-playback controls, live during speech:
  Stop · Pause · Save place · Continue · Bookmark · Favorite
  · Tag · Note — each timestamped to the part sounding when
  you press it, each kept in a native store on the device.
• Talk is native. Pressing Talk while the app speaks
  stops the voice FIRST and opens the microphone only into
  that silence — the ordering is by construction, not by
  hope. Capture is the device's own recorder; the on-device
  Whisper engine (downloaded separately, as always) does the
  transcription.
• Save means save. Your place is written natively at
  every part, and Save pins it. Kill the app mid-book;
  Continue resumes at exactly the pin.
• Playback still runs through minimize and screen-off via
  the foreground service, and the battery-exemption prompt
  from beta.4 is unchanged — on Samsung phones, accepting it
  still matters.

Stated plainly — the limits:

• The wake word is still designed, not built. Talk is
  tap-to-start, tap-to-stop.
• Real-speech transcription is proven on the engine bytes
  this build carries, but not yet on a physical phone's
  microphone in this build — the deciding test is the
  owner's hand, as it was for beta.4's battery leg.
• Small / Medium / Large voice models remain gated in-app
  (the in-page engine cannot safely hold them); Tiny and
  Base are offered, with the reason shown on the shelf.
• During the candidate exercise, one playback wedge was
  observed once under test-harness racing — the app reported
  "reading" while nothing sounded; Stop → Continue recovered
  it in one press. Cause not isolated; it is carried as a
  named watch item for this release candidate rather than
  papered over, and the fix (a native utterance watchdog)
  ships as its own exercised change, not smuggled into this
  one.
• Purchase verification still answers through the beta
  seam until the Play Console credential lands (no pricing
  code changed: free tier 600 minutes/month; one-time
  unlock US$24.99 including the Whisper voice capability).

Web app v1.5.0 is live and certified with this build; the
bundled copy inside the APK is byte-pinned to it. Release
gate: PASS WITH FINDINGS (pack:
release-gate-runs/dogear-app-2026-10-24-beta5). This is a
release candidate; the soak runs from today.

DogEar v1.1.0-beta.4

The phone fixes — beta.4

Every fix in this build comes from the owner's own phone test of beta.3. Each defect was pinned to its cause on the bench before it was fixed, and the finished package was exercised end to end in the sandbox (fresh install → import → read → minimize → screen off → Talk → ask the document → airplane mode) before this release was cut.

1. Background reading is defended, and proven on the shipped package. Playback already ran through a native foreground service; what was missing was protection against phone makers that put apps to sleep (the Samsung app-sleep class). The reader now offers a one-time battery exemption — please accept it on first launch if your phone ever stops DogEar when the screen is off. The background legs (minimized and screen-off, the reading place keeps advancing) are now permanent release-proof legs, re-run on this exact artifact.

2. Talk works now. The microphone could never open inside the app: Chromium's capture path needs a second system permission (MODIFY_AUDIO_SETTINGS) that the app did not declare. It is declared, and Talk was proven with real captured audio transcribed on the device.

3. Error messages tell the truth. When the microphone failed, beta.3 blamed your permission setting no matter the real cause. Errors now name their actual class — permission denied, microphone busy, no microphone, interrupted — and only a true denial mentions permission.

4. Models that cannot run here are no longer offered. Small, Medium and Large downloaded fully (Large is 1.5 GB) and then could never load in the in-app engine — on a real phone that failure killed the app. The shelf now gates them with the reason stated, and Delete still removes a copy you already downloaded. Tiny and Base run safely. The larger models return when the native-inference engine lands.

5. The top buttons work. The header row was painted under the phone's status bar, where taps never reached it. The shell now respects the window insets; every primary control was tapped through in the exercise.

Also: silence is no longer "quoted" back as speech (Whisper's [BLANK_AUDIO] token) — the app now says it couldn't make that out.

Honest limits

• No wake word yet. Talk is a single tap (press once to start, once to stop — never hold). The wake word is designed — on-device spotter, visible listening state, battery cost stated up front — and ships as its own phase only when it passes the same proof bar as everything else here.
• Small / Medium / Large stay gated until the native-inference phase (above). On the web endpoint the same gate applies wherever the in-page engine runs; Medium and Large also remain unmeasured on our speech-accuracy bench (registry F-P1, carried from 1.3.0).
• Battery exemption is your tap. DogEar asks once, in the reader, with the reason; playback works without it on stock Android, but some phones need it.
• The web app (app.getdogear.app) is at 1.4.0 with the same fixes, deployed and certified (worker sha256 428daa2044e82cd1…). Release gate for this build: PASS WITH FINDINGS — pack in ~/workspace/release-gate-runs/dogear-app-2026-10-22-beta4/.

DogEar v1.1.0-beta.3 — slim shell, model picker (the MyMilo route)

Build status (2026-10-22): CI run 39801529120 SUCCESS — signed APK (4,276,831 bytes) and AAB (4,457,086 bytes) attached; signer certificate SHA-256 95b84a3e… asserted in the workflow and re-verified on the downloaded APK. The APK contains zero model files (checked by listing its contents).

Proven in the emulator (API 35, this CI APK, fresh install): the app boots from its bundle and the reader works with no model downloaded (document imported and opened, Listen mounted); the owner licence applied through the app's own licence field and the shelf rendered all five models with sizes, measured word-error notes, the F-P1 memory warning on Medium/Large, and each model's licence; Tiny downloaded through the real picker UI — 13/13 files, exactly 44,500,564 bytes, checksum-verified by the app — and the Whisper engine loaded from it and transcribed a test clip on-device; ask-the-text answered with verbatim quotes and honestly refused an off-document question; in airplane mode the answers kept coming, and after a force-stop and cold relaunch offline the document, the reader, and the downloaded model were all intact and the engine answered again; the model was then deleted through the picker UI (back to absent, Download offered again) with the reader unaffected throughout.

DogEar changes shape: the Whisper model is no longer inside the app. Following the MyMilo pattern, the app ships slim and offers the listener as a choice of model downloads — each model under its own licence (shown on the shelf before download), fetched on demand, verified by checksum on the device, and fully offline once downloaded. Nothing is bundled at any tier: the app artifact carries only DogEar's own code, so no model's licence rides with the product's.

The shelf (web app v1.3.0, live and certified at app.getdogear.app):

Model	Download	Word error on our 24-clip bench
Tiny (whisper-tiny.en)	44.5 MB	5.7%
Base (whisper-base.en) — recommended	80.6 MB	4.3%
Small (whisper-small.en)	252.8 MB	3.0%
Medium (whisper-medium.en)	779.8 MB	not measured — see F-P1
Large (whisper-large-v3)	1,564.7 MB	not measured — see F-P1

Sizes are exact bytes; the shared runtime (33.7 MB) downloads with the first model. Every file is pinned to an upstream commit and sha256-verified by the app itself on download; a mismatch is refused. All five models are Apache-2.0 (per their HuggingFace repos); the picker shows each licence before you download. Download, switch, and delete per model in the app; your choice persists on the device. Transcription stays on-device — no audio is ever uploaded.

Finding F-P1 (carried from the release gate, stated plainly): Medium and Large are not measured on our bench yet. In the current single-threaded WASM runtime they could not complete a run on our bench machine (the wasm32 ~4 GB memory ceiling), so on modest hardware they may fail rather than merely run slowly. The picker says so, with a memory note, on both models. Tiny, Base, and Small are measured and proven. Threaded WASM is the known lever and remains future work.

Sizes. The bundle inside the APK is now just the app shell: 27 files, 2,726,696 bytes, staged by CI from the live gated deploy and verified file-by-file against the committed bundle manifest (worker sha256 e1df6e66…, web v1.3.0). The APK is 4,276,831 bytes — the 115 MB passenger is gone. Beta.2 (pack bundled) remains published as the proven fallback.

Your phone test list:

1. Install beta.3 — the reader works with no model downloaded: open a document, listen with the device voice, background/screen-off playback as before.
2. In "Talk to DogEar", download Tiny from the shelf; ask a question about the open document — it should answer with a verbatim quote.
3. Turn on airplane mode and ask again — the downloaded model answers fully offline.
4. Delete the model from the shelf — the reader is unaffected and Talk invites a fresh download.
5. The carried item from beta.1/beta.2: the live speak → answer-aloud round trip (the emulator's microphone could never complete it; the permission flow and on-device transcription are proven — your phone is the vantage that closes it).

Web endpoint (backup) is unchanged in role: purchase verification, improvement requests, tips — no reading or listening feature depends on it.

DogEar v1.1.0-beta.2 — the bundled app (two endpoints)

Build status (2026-10-22): CI failed closed at the bundle-staging step — the live site's served bytes no longer match the certified tree (a Cloudflare Web Analytics beacon is being injected into HTML at the edge), so no APK is attached yet. The bundle tool refuses to ship anything but the gated tree. Once the injection is off, the release workflow re-runs and the signed APK lands here. The offline proof below was run against the byte-identical bundle staged from the certified deploy.

DogEar is now a self-contained app. Everything it needs ships inside the APK; the website stays as its second door.

Endpoint 1 — local (primary). The full app — reader, documents, device voices, background listening, and the Whisper voice pack (whisper-base.en, 114 MB) — is bundled in the APK and served on-device under the app's real address, so your library, your place, and the voice pack behave exactly as they do on the web. Works entirely offline: open, import, listen (including with the screen off), ask your document questions — nothing is uploaded, ever.

Endpoint 2 — web (backup). app.getdogear.app remains the browser product and the app's backup pathway. It carries only: purchase verification, improvement requests, and the tip link. No reading, listening, or document feature depends on it.

Sizes. APK ≈ 120 MB (the app shell plus 116.9 MB of bundled, checksum-pinned content: web tree 2.7 MB + voice pack 114.2 MB). Every bundled file is verified against a signed-off checksum list at build time; CI stages the bundle from the live, gated site deploy and fails closed on any drift.

Proven in the emulator with the network killed (airplane mode): cold open from the bundle, document import, listening in foreground / minimized / screen-off (place advanced in every state), notification pause/play (place froze and resumed exactly), the full document played end to end, place kept across a force-stop and relaunch, voice pack installed 18/18 files checksum-verified with no network, on-device transcription of a test clip, and ask-the-text answered with verbatim quotes (and an honest refusal for a question the document can't answer). With the network back: purchase verification and improvement requests answered by the web endpoint from inside the app.

One item for the phone test: the live Talk round-trip (speak → answer aloud) could not be completed in the emulator — its microphone source cannot start (the emulator reported the audio source unavailable even after the permission was granted; the permission flow itself is proven, and transcription/asking are proven on the same code). Please try Talk on the phone: tap Talk, allow the microphone, ask about your document.

Samsung note: if listening ever stalls with the screen off, set DogEar to Battery → Unrestricted (One UI parks background apps aggressively).

Signed with the same release key as beta.1 (CI verifies the signer against the published asset links before the build is accepted). Beta — the gate judges the line before any final tag.

DogEar v1.1.0-beta.1 — background playback (pre-release)

DogEar now keeps reading when you leave the app.

This beta fixes the stop-on-minimize defect in v1.0.1. Reading is no
longer done by the web page's voice (which Android freezes when the app
leaves the screen). The app now carries its own playback service:

• Playback continues with the app minimized, and with the screen off.
• A media notification and lock-screen controls: previous, play/pause,
  next, stop.
• Calls and other media pause the reading; it resumes when they end.
• The voice is still your device's own text-to-speech voice. Nothing is
  recorded, nothing is uploaded — the reading happens on the phone.
• Your place is kept exactly as before, and the screen shows where the
  voice is when you come back.

One phone setting matters (Samsung / One UI especially): if reading
ever stops after several minutes away, open Settings → Apps → DogEar →
Battery and choose Unrestricted. One UI's app-sleep can still park
apps it decides are idle; Unrestricted tells it DogEar is a player, not
a bystander.

Pricing, for the record: 10 hours of listening free every month; the
one-time unlock is US$24.99 and includes the Whisper voice pack — the
pack is part of the unlock, not a separate purchase.

Pairing note, stated plainly: the native playback activates only
when the web app it loads carries the matching bridge hooks. The live
site at app.getdogear.app still serves the previous web build today;
the web update that pairs with this beta is deployed separately (it is
release-gated on its own). Until that web deploy lands, this APK will
behave like v1.0.1 in ordinary use — the background playback switches
on when the paired web build goes live. The emulator proof for this
beta ran against the paired web build.

This is a beta for device testing — the release gate reviews it before
any final v1.1.0. Web behaviour at app.getdogear.app is unchanged.

DogEar Android v1.0.1 — the fixed build

DogEar — hear your documents, as an Android app. DogEar reads your documents aloud on app.getdogear.app; this package opens it full-screen on your phone.

v1.0.1 — the fixed build

v1.0.0 crashed the moment it opened. The cause: that package was assembled by a hand-rolled local build whose manifest merger silently dropped an AndroidX startup entry, so Android killed the app before its first screen — while every static check passed. Full record: android/CRASH-FIX-NOTE.md.

v1.0.1 is built with the real Gradle pipeline and proven to open — it launches to the DogEar home screen in an emulator with a clean log. From here on, Android packages are built by GitHub Actions from the source in this repo (android/), never hand-assembled locally.

Install (test build)

1. Download dogear.apk below (on your phone).
2. Open the downloaded file and install. It updates the broken v1.0.0 in place — nothing to uninstall first.
3. Open DogEar — you should land on "Hear your documents."

Verify it's ours

Signing certificate SHA-256: 95:B8:4A:3E:09:77:FF:25:E3:D1:E7:A0:7A:CB:50:92:32:3F:D4:57:09:C1:58:EB:71:6D:E1:CD:19:95:7F:F0
(CN=Nrupal Akolkar, OU=AIMLDS, O=2351485 Alberta Inc. — the same key the live site trusts in assetlinks.json.)

Asset SHA-256:

• dogear.apk — ff87f837c9f40c846d0ed61c1cdddf39f81a860284a0fab4e71a55b2be7d98dc
• dogear.aab — 28b805ad13cb6e87b76edb3602531b0401fd4689349d6b16667b1f7694d60a6e (Play Store bundle format, for the future store upload)

The assets on this release were built by GitHub Actions from the source in this repo and signed in CI with the key above (the workflow asserts the signer fingerprint before publishing). The APK is byte-identical to the build proven in the emulator; the AAB carries identical app content from the same source and key.