v0.4.0

Added

• Client: the app now keeps a log that follows its flows. Every use case — sign-in, session restore, the feeds and threads, posting, the chat's polls and pushes, the image cache, the local files, and the platform heads' own workers (the scheme registrars, the audio capture and playback, the system sounds) — records what it starts, what finishes, and what fails, so a misbehaving session can be read instead of guessed at. The log lands in the console and in one file per day under the app's data folder. Secrets and user content stay out: no tokens, no key material, no message bodies, and server answers are trimmed to the error reason. A DEVNULL_LOG_LEVEL value (TRACE, DEBUG, INFO, WARN, ERROR) overrides the build's default level, so a release install can be traced without a rebuild.
• Core: the site's direct messages ("Remotes") are now available end to end: the inbox with its tabs, search, and pins; one-to-one and org threads with typing, read receipts, and live reaction changes; messages pushed with images or a voice note; stashing, muting, pinning, and emoji reactions; merging or dropping an incoming request; and finding people to write to, then starting, renaming, and staffing orgs. The Remotes settings on the signed account (who can push, whether pulls are shared) come with it and can be changed.
• Core: a voice note is checked before it is sent: Opus WebM or WAV, within the server's upload cap, carrying the 48 loudness bars the player draws.
• Core: a draft can be previewed as the commit it would become — the body it is kept as, the segments it renders from, its excerpt, and its mentions — without the draft being kept.
• Remotes: messages wear their reactions. A bubble carries a chip per emoji with its count; the chip's tip names who left it, a long-press-free picker offers the three quick picks and the thread's most-used emojis, and a tap reacts (or takes your reaction back) with the chip updating at once before the server settles it. Double-clicking a bubble toggles the heart.
• Remotes: every conversation action is at hand. The thread header's menu pins/unpins, stashes/pops, and mutes for an hour, until tomorrow, for a week, forever, or off; direct threads add view-profile and block, org threads add leave — and the destructive picks ask first, with the site's own words on what they do. Org headers show the member stack, and maintainers get the org menu: rename, add members with the share-history choice, promote or demote each member, and remove any one of them. The inbox's "new org" picker starts an org from the people the search found, with an optional name, and opens its thread when the server answers. When the server refuses any of these, the pane says so with the server's own message.
• Remotes: conversations are now two-way. Push stages the message at once and swaps in the stored one; a refused push offers a retry that reuses the same message id, so the server stores it once at most. The composer carries a 2,000-character counter (quiet until 80%, warning color from 95%, danger at the limit, thousands grouped the way the site shows them); Enter pushes and Shift+Enter makes the newline, while Esc cancels the reply or discards a live recording. The input fills the whole space between its tool buttons and Push on any window size, a pasted image (Ctrl/Cmd+V) stages the same way a picked one does, and typing @ offers the thread's handles — the partner's, or the org's members — with a pick completing the handle at the caret. Staged images wear the commit composer's own chip — a thumbnail, the name, and remove — and a voice note rides alone the way the site keeps it: while one is staged, the box closes to typing and images can no longer be added. The link-card picker chooses which link gets the card, and an unsent draft parks itself per conversation and comes back on return, silently the way the site's chat does. When the thread does not take pushes, the composer is replaced by the word on why — merge/drop for a fetched request, or the waiting/restricted/closed line.
• Remotes: a conversation now reads like the site's: the checked-out thread shows day breaks, author runs as bubbles (yours on the accent fill, theirs on the quiet surface), quiet org event lines, org author labels, a typing line whose three dots chase while the partner types, and pushed/pulled/pulled by N receipts under the newest message. Every run ends in its clock time — yours right-aligned, theirs left — except the one run whose line is the receipt. Reply ghosts peek above their answers and clicking one walks the thread back to the original and rings it — or says the site's own word when the original is beyond reach. Scrolling up loads older pages, the HEAD · N new divider marks the messages that arrived unseen, back to present (or the unread count) returns to the bottom, images open from their bubbles, and a pending link card settles once the server has read it. Leaving the page and coming back reopens the same conversation at the same reading place.
• Remotes: the direct-message inbox now has a page of its own (/remotes): the Open, Fetched, and Stashed tabs (Fetched only while the account takes requests, and carrying the waiting count), a search that lists both matching conversations and people to start a new remote with, rows with unread pills, pins, mute marks, and org previews, and merge/drop actions on fetched requests. The sidebar carries a Remotes entry with the live unread badge, hidden while the account has the feature off. Wide windows show the site's two columns — the inbox takes a fixed share of the strip, floored so its rows stay readable — and below the breakpoint the page shows one pane: the inbox until a conversation opens, then the thread full-width with a back row above it. Scroll to the end of a tab and the next page loads by itself. The chat's polls follow the window's own visibility, the way a visible tab polls on the web: they run while the window stands on screen — focused or not — pause only once it hides (minimized or in the tray), and wake at once when it returns.
• Remotes: voice notes record and play. The composer's mic opens a recording lane with a live meter and clock (a half second minimum, a minute ceiling, the warning color through the last ten seconds); a stop stages the note as a chip that pushes alone or with a draft, and a cancel keeps nothing. A stop pressed while the microphone is still opening cancels the take the moment the open lands — one click stops, the lane never resurrects — and an open that beats the lane's first layout still records instead of vanishing. A received note draws its 48-bar waveform: play/pause with the clock, a speed cycle (1x/1.5x/2x) that retimes the note from where it stands rather than restarting it, a volume control whose moves land on the sounding note and are saved for the next one, and the bars filling as it sounds — one note at a time, the way the site plays them. Leaving a conversation stops the sounding note, and a recording opened there releases the microphone. The microphone opens only when the mic is clicked, never when a conversation opens. On Windows the OS's own media player decodes each note's format, so the web's Opus notes sound too, and a take records the room's real sound; on Linux this build plays WAV notes. On a platform that hands the app no audio engine, the mic stays hidden.
• Remotes: pings run both ways. The composer carries a ping button — a quiet nudge for the partner or the whole org — and a ping that lands on an open conversation logs the site's own event word (you got a ping) and plays the system's notification note: your own ping sounds even while muted, a partner's stays silent through a mute, and pings that were already there when the conversation opened stay still.
• Audio (Windows): the microphone and speaker run through Windows' own audio stack (WinRT AudioGraph): capture at the voice-note format with a live level meter, playback with speed and volume, permission refusals named in plain words. The system notification sound plays through the OS media player.
• Audio (Linux, Windows): Added the native infra in order to handle sound play.

Changed

• Packaging: the app is now built from a shared client plus one executable per platform (Windows and Linux) instead of a single cross-platform build. Nothing changes for existing installs: the shipped executable keeps its name and the devnull:// handler keeps working. This is groundwork for platform-native features (audio, notifications) implemented per platform behind shared contracts.

Fixed

• Core: the site renamed the user field username to handle across its whole API, which broke the client's timelines, notifications, and mentions. Every decoder reads the new field, the client's own vocabulary follows the site's, and a chat message's reply id now reads as absent where the server hides it. Saved sign-in sessions keep working.