Changelog

​

New features

• The command is there when the install finishes. Installing Wolffish on a Linux server used to end with homework: add a directory to your PATH, restart your shell, and launch the app once so it could write itself a launcher — and on a server the middle step was circular, because the thing you had to launch was the thing you were trying to reach. The .deb and .rpm now ship the wolffish command themselves, alongside the app binary: it exists the moment the package manager finishes — no first launch, no PATH line, no new shell, the same command for every account on the machine, and removed cleanly when the package is. The AppImage has no package manager to do this, so there the installer writes the PATH line for you — once, never twice however often you reinstall, and --no-modify-path if you’d rather it kept its hands off your dotfiles. And where the terminal used to be told to start the agent by hand, with a flag and an ampersand it had to explain, it now says the only true thing left: run wolffish — the agent starts itself, in the background, with everything a root server needs already applied.
• Unread counts that know what you’ve read. A notification about a conversation now feeds a per-conversation unread badge on the phone: on the conversation rows, summed on the floating menu button, and as the number on the app icon — correct even before the app has woken, because the relay stamps its running count onto every platform push. Clearing is reading: open the conversation and its count is gone, tray notifications included; delete a conversation anywhere and its count goes with it. The phone’s own total is authoritative — the moment the app runs, it overwrites the relay’s stand-in absolutely, so the two can never drift apart.

​

Updates

• Disconnecting leaves nothing behind. Unpairing the phone used to be thorough about the phone and forgetful about the middle: the relay kept the device’s push registration, and a later notification would still be flung at a phone that had left. Disconnect now runs in the right order — badges cleared everywhere, the relay’s count zeroed, then the relay told to forget the device registration entirely — and only then does the phone drop its keys and wipe what it synced. Every later notification addressed to that phone is answered dropped, honestly, and pairing again starts from a clean slate at badge zero.

​

Updates

• The install that stopped saying it worked. curl … | sh on a fresh Linux box could end with “installed successfully!” on a machine that had no Wolffish on it whatsoever — a package manager’s own way of fixing an unsatisfiable dependency is to remove the package it just unpacked and exit reporting success. The installer now asks dpkg or rpm whether the package is actually installed and configured, which is the only honest question. It also refreshes stale package lists and retries before concluding anything (a fresh VPS image is often one apt-get update away from working), never lets the package manager remove things to make an install succeed, cleans up after itself rather than leaving a half-unpacked package that breaks every later apt run, and when it genuinely cannot proceed it names the libraries that are missing.
• An agent that starts on a server. Two invisible faults kept Wolffish off the one machine the terminal exists for. The package never declared libasound2 — Electron links ALSA at load time whether or not the machine has a sound card, so the app died at exec on the minimal image a server starts from; it is now declared, and versioned, which is what makes it resolve on Ubuntu 24.04, where the package was renamed and the old name became ambiguous. And Chromium refuses to run as root unless --no-sandbox arrives on the command line — before a single line of app code runs, so appending it at startup never counted. The flag is now on every path that starts the app: the menu entry, the systemd unit, the autostart entry, and the daemon the CLI spawns.
• An AppImage that outlives its own mount. An AppImage runs from a temporary mount with a different name every launch — and everything Wolffish wrote for later (the wolffish command, the systemd unit, the autostart entry) recorded that doomed path. All three now record the .AppImage itself, the CLI client is lifted out of the image so it still exists once the app has closed, the whole install lives under ~/.wolffish so rm -rf ~/.wolffish remains a complete uninstall, and on a machine that can’t mount one at all — no FUSE, a container without /dev/fuse — the launcher unpacks and runs instead, carrying that decision into the shim and the service so nothing disagrees with the installer that just got them working.

​

New features

• Wolffish in a terminal. Wolffish has always needed a window, which has always meant needing a screen — so the machine most likely to run an agent around the clock, a server you reach over SSH, was the one machine it could not run on. There is now a wolffish command, and it is not a smaller second Wolffish: every command it has is a call into the same code the desktop windows call, so a setting changed there is the setting here, carrying the same label and description, in your own language, Arabic included. Type wolffish for an interactive session or wolffish "…" for a one-shot answer; pipe context in, attach files by path with -f, resume old conversations, read and change every setting — provider keys typed hidden, never landing in shell history — switch the model, edit Soul, User and Agents, run procedures and automations, and pair a phone, WhatsApp or Telegram from the same command. The important part is what the terminal is: a view, not the app. Wolffish runs as a background process and the command attaches — close the terminal or drop the SSH connection and the turn keeps working; a tool call waiting on your approval parks instead of failing, answerable when you return or from your phone. Replies arrive as rendered markdown — headings, tables, bordered code blocks — and wolffish settings walks the settings the way the app does, page → card → setting, with blank always meaning up. Editing works even on a box with nothing installed: your $EDITOR, else nano or vi, else a built-in editor with no dependencies at all.
• A service for a machine nobody logs into. Autostart is the app’s own business on every platform now — a login item or launchd agent on macOS, a login item or Task Scheduler task on Windows, an XDG entry or systemd user unit on Linux, where the toggle used to silently do nothing. It also gained the mode a server needs: a background service that starts with the machine, with no session and no window at all — which is what keeps automations firing and channels answering on a box nobody has logged into, and what the terminal attaches to. On Linux, lingering is enabled alongside the unit, because a user service without it dies the moment your SSH session ends; a unit missing it is reported as a warning, not a healthy state. The whole route — install script to headless boot to systemd to the CLI attaching — is verified end to end on a pristine Ubuntu 24.04 VPS, and with a paired phone as the daily interface, a headless server is not a degraded Wolffish but the desktop experience with the desk removed.
• Automations and procedures bring their own files. A project could carry files; the automations and procedures that do the unattended work could not — where it matters most, since nobody is there to attach anything when they run. Both now carry attached files and working folders of their own, editable from the app, the terminal or your phone. An attached file is copied in, so a run can never break because you moved the original; working folders are deliberately not copied — every run gets a fresh listing of the real folder as it is that moment. A project’s folders now flow into everything that runs inside it, and each of the three got a full-height prompt editor that scrolls instead of cutting off. On the phone, the same files and folders ride the workspace cards — a folder chip wears the full desktop path, typed and validated against the desktop’s own filesystem.
• A memory you can correct. Everything Wolffish believed long-term was, from its own side, write-once: telling it “that’s wrong, she moved” earned an agreement in prose and changed nothing on disk. It can now add, amend and forget across all nine files that carry its long-term self — its playbook, your standing instructions, its character, your profile, and the five knowledge files. The rule it works to is forget beats contradict — two entries that disagree is worse than one that is missing — and the correction lands in the same turn you say it, not tonight. Every write keeps the previous version, so any change is one step from undone, and it removes only what you challenged; pruning by its own judgement is still the nightly clean’s job.

​

Updates

• The channels it could actually see. The agent decides how to reach you by reading its own channel roster, and that roster named Telegram, WhatsApp and the window — not your phone, and not the terminal. Both are on it now, with the distinction that makes the phone’s row worth having: paired is not connected, so a phone in a pocket reads as down-but-paired, never gone. Most consequential of the three: on a headless box, in-app chat stopped claiming to be available — it was telling the agent someone was there to answer in a window that does not exist.
• One notification, not three. A notification the relay never answered for was reported as failed, and failed is retryable — so one decision became three buzzes on a phone in someone’s pocket, each with a fresh id nothing could fold together. An unanswered send is now reported as unconfirmed rather than failed, and the tool declares its own failures non-retryable, so nothing re-fires a send on its own. The per-run caps that stood in for restraint went away in the same change: whether a second interruption is worth it is a judgement rather than a quota — the agent’s to make, with the reasons spelled out where it reads them.
• A turn from the terminal, seen everywhere. Terminal conversations wear their own origin mark in the desktop’s History and rail — and on your phone, where the origin glyph now rides the very first live update, so a conversation the phone has only ever seen running still shows where it came from. A phone whose tunnel comes up mid-run also finally knows the run exists: it asks the desktop what is running on every connect, so a busy conversation shows its stop button and streaming pulse instead of an idle composer, and the rating bar waits for the desktop to actually say the turn ended. Answering an automation’s conversation from the terminal now unseals it like every other channel, and long-lived terminal conversations grew the rolling summary they were missing — without it, every reply replayed the whole transcript and cost more each turn, precisely on the headless box where terminal conversations are the long ones.
• Linking WhatsApp where a QR won’t fit. A WhatsApp QR is a 49×49 matrix — 27 printed rows against the 24 an SSH window gives you, unscannable no matter how it is drawn. WhatsApp can now be linked by phone number instead: give it the number and it prints the eight-character code WhatsApp shows under “Link with phone number instead” — the route that works in a window too small to hold a square.
• Arabic, whole again. Eighteen strings had no Arabic and quietly fell back to English — the entire Debugger Mode card, every message the updater shows when an update fails, five browser actions. All translated, and the two locales are back in exact parity. The name is settled too: Arabic had been writing it two ways, and it is وولفيش everywhere now — the app, the tray, the browser extension and the back changelogs alike.

​

Updates

• A rating bar that knows when it’s done. The 0–10 strip above the composer asked you to score a turn, and then went on asking — an answered question still sitting over the composer. It retires the moment the turn has a score now: one click, the vote is in, the strip is gone. And because a score is a fact about the turn rather than the device that cast it, the bar goes away wherever the vote came from — the window, your phone, or a bare number typed into Telegram or WhatsApp — without waiting for anything to reload.
• Text you can actually take. On the phone, long-press any bubble or tool card to select from the rendered reply — in place on Android, and on iPhone in a dedicated sheet where you drag across the styled text and copy exactly the part you need, instead of fighting a screenshot.

​

New features

• A notification that opens what it’s about. A phone notification could always take you somewhere when you tapped it, but the agent had to name the destination by id — and a run does not reliably know the id of the conversation it is answering in. So it either went looking for it or guessed, and a guessed id opens someone else’s transcript on your phone; or it left the destination out altogether, and the tap merely opened the app wherever you had left it. It can now simply ask for this run’s own conversation (wolffish://chat?id=current), and the desktop fills the id in from the run itself — the same place the run’s identity already comes from, never the model’s guess. A link naming a screen the app does not have is refused before anything is sent, together with the list of screens that do exist, instead of traveling all the way to the phone to quietly drop you on the home screen. And the destinations now cover every screen your phone actually has — Projects, Automations, Procedures and Customization included — read from the app’s own route table, so what the agent is told can no longer drift from what the phone can open. On the phone, a tap that launched the app is read on the entry screen’s first render, so its destination is the boot destination rather than a second navigation racing the redirect.

​

Updates

• PDFs, read where they sit (Android). A PDF in a conversation used to be a file row on the mobile app’s Android build — tap it and the document left for whatever viewer the phone happened to have. It now opens in the card itself, showing a real first page and expanding to the whole document, scrollable and pinch-zoomable, exactly as it already did on iPhone. The reader travels with the app instead of depending on one being installed, and the page drawing it can reach no file but the one you opened. Very large PDFs still go to the system viewer.
• A tab group label worth reading. The Wolffish tab group was told to announce itself for everything, including opening a single page — where the plain Wolffish name already said all there was to say. Labeling is a judgement now rather than a ritual: a one-off lookup keeps the plain name, and a real task — several steps, more than one page, more than a moment — carries an emoji and a few words, updated as the work moves from one phase to the next. You still see what your browser is doing when it matters, without a label on every trivial thing.
• Arabic that reads in one script. Four Arabic strings still spelled the brand in Latin letters mid-sentence — the capability gate, the memory rebuild overlay, the diagnostics overlay, and the name an untitled conversation carries into a PDF export — so the eye crossed from one script to the other and back inside a single line. They read وولفيش now, and the prose runs in one script throughout. The pairing screen’s code hint also lost a sentence it never needed, in both languages.

​

New features

• The phone catches up with the desktop. Pairing brought your conversations across; everything that shapes them stayed behind. Your phone now carries Projects, Procedures and Automations — create, edit, run and delete them from either device, against the very same files, so an edit made on one screen lands on the other instead of in a second copy that quietly disagrees. The three documents that define the agent — Soul, User and Agents — are editable there too, and the desktop’s editor adopts a save made on the phone live, unless you are mid-draft, in which case your unsaved text stands and wins when you save it. You can score a turn from your phone and watch the vote land on the desktop chat you have open, file a conversation under a project, add files to a project, and collect a diagnostic bundle when a run has gone wrong. Work that takes the desktop’s whole screen shows on the phone as a card in a stack — a memory rebuild, a nightly reflection, a compaction, an automation mid-run — so the phone stays usable while they happen instead of looking broken. And a turn you are watching from your phone finally shows the question above the answer: the prompt now travels with every live update, so a phone that pairs, or opens a conversation, mid-turn is no longer reading a reply to nothing.
• Automations you can open and watch. A scheduled automation or a procedure used to run somewhere you couldn’t see. Its conversation appeared in the list only once it was over, and if the app quit halfway everything the run had written was lost. Every autonomous run now creates its conversation before it starts: it takes its place in the rail with the same processing pulse a Telegram turn gets, you can open it and watch the reply arrive live, and the Stop button works on it — the same button, the same gesture, for a run nobody typed. Progress is written to disk while the run works, so quitting or crashing halfway leaves a real transcript rather than a bare prompt, and reopening the app mid-run finds the automation still going instead of sitting idle.
• The web, read in your own browser. Wolffish had three ways to reach the web and habitually reached for the weakest. A plain fetch sees only what a server hands a bare request, so a modern page comes back empty and paywalls, logins and bot checks all defeat it — yet that is where the agent went first, often failing twice before doing the obvious thing. It now leans on your real browser, where your logins already are and pages render as you see them, and keeps search for what search is genuinely good at: settling one fact, or finding which link to open. When no browser is running it starts one itself with the new ext_launch_browser. And it works in its own tab group — a blue group named Wolffish, created the first time it needs a page — so your own tabs are never navigated away from mid-task; it reads the tab you are on only when you ask it to. That group’s label says what it is doing right now, in the agent’s own words: 🔎 Comparing flights, 🛒 Checking out, ✍️ Writing reply.
• Web pages that come out designed. Ask for a guide, a handbook, or a report as a web page, and what came back depended on the model’s mood that day. A new core web design manual now loads before the agent writes a line of HTML, exactly as the document manual already works for PDFs. It carries a planning step, a responsive rail-and-column layout, light and dark themes with a toggle, a component kit, hand-drawn SVG figures themed to the page, Arabic and RTL rules, and a mandatory verify pass: the agent screenshots the finished page in both themes, at desktop and phone widths, and looks at it before handing it over. Pages arrive as one self-contained file that reads complete with scripts switched off. And because the preview card in chat is deliberately sandboxed, every website card now carries an Open in browser button — the live page, from its real location, with its scripts running.

​

Updates

• A composer that stopped collecting buttons. The composer had grown a button per feature — reasoning, chat mode, local/cloud, logs, files, export — until the row was mostly chrome. It is back to three controls on each side, and nothing was lost. Thinking effort and Single/Workflow mode moved inside the model card, two chip rows above the search, so every model knob sits in one panel. That card now also lists the Ollama models you have installed, read fresh each time it opens — pull one in a terminal and it is there without a relaunch — which turns “switch to local” and “pick which local model” into a single click instead of a trip through Settings. Logs and Files moved into the context meter, at the foot of the card that was already about this conversation. Diagnostic export now lives in History alone, where it works for the conversation you have open too and says “Not indexed yet” instead of going quietly dead. Choosing a model you have already downloaded no longer pretends to download it again. And a voice note you record shows just its player: the transcript is still stored, still sent, still searchable — printing it back underneath only repeated what you had said out loud a moment earlier.

​

New features

• Wolffish, now on your phone. Wolffish runs on your machine — which has always meant being at your machine. A phone can now pair with this desktop and carry the same conversations, the same settings, the same usage with it. Pairing happens once: scan a QR with your camera, or type a short code when the camera can’t see the screen — the secret travels screen to camera and never crosses the network. From then on the two devices talk end to end encrypted (X25519 · ChaCha20-Poly1305), sealed on your devices before anything is sent. What carries the bytes is a blind relay: it only helps the two find each other and passes sealed frames along — it cannot read, alter or replay them, and it stores nothing at all, no database, no logs, no accounts, no message history. Both devices show the same fingerprints so you can confirm at a glance that nothing sits in between, and the relay is open source and self-hostable — point this desktop at your own deployment and the next pairing carries that address to your phone. The link runs the other way too: with phone notifications on, the agent can reach you with its notify_phone tool when a run finishes, fails, or needs you — never automatically, always a deliberate call, and Off makes the tool refuse outright. A Task results switch decides whether your phone’s feed relays every tool call or stays clean with just replies, files and errors.
• Video generation, directed by your own model. Wolffish can now make video, and the interesting part is who writes the prompt. Ask for a clip in any conversation and your current chat model directs it — it rewrites your request into a full cinematic brief (subject, camera movement, lighting, mood) and chooses duration, resolution, aspect ratio, and which images serve as first frame, last frame or style reference. That rewriting is where most of the quality lives, so a stronger chat model gets a better video from the identical request; if a clip misses what you pictured, telling your model what to change usually beats rewording the original ask. Turn director mode off and your words go to the video model exactly as you wrote them. MiniMax H3 does the rendering — text to video, image to video, first-and-last-frame transitions, or reference images, clips and audio for consistent subjects, motion and voice, up to twelve media items in one request — producing H.264 mp4 with a generated soundtrack, 24 fps, 768P or 2K, four to fifteen seconds. Because a render takes minutes rather than moments, a task card appears in the chat carrying the task id, live status and a progress estimate; it updates itself, you can cancel from the card, and the finished mp4 downloads automatically and plays inline. If a generation outlives its turn — the app restarts, or the model has moved on — Wolffish finishes the job on its own: it keeps polling, saves the video, updates the card, and delivers it to the channel the request came from, compressing oversized clips to fit Telegram or WhatsApp while keeping the original here at full quality. Attached media is checked and optimized for you, and the composer’s paperclip grows an Attach media URL option that hands MiniMax a link directly — the way around the size limit on large references. Videos are stored per conversation and deleted along with it, and the key lives in Settings → Services → Video generation, kept deliberately separate from the MiniMax chat provider so rotating one never drags the other with it.
• Zip archives, handled where they land. Wolffish couldn’t open a zip. Attach one and it came back an unrecognized file type; ask what was inside and there was no tool to ask with. A new archive capability closes both halves at once: the agent can list what a zip contains without unpacking it, read a single file straight out of it, extract all of it or just the part you want, and pack files and folders into a new archive. Nothing is unpacked by default — an archive dropped in with no instructions gets listed, described in a line, and then you’re asked what you want done with it. The composer now takes .zip as a first-class attachment, up to 512 MB, so the archive arrives somewhere the tools can actually reach it.

​

Updates

• A settings panel that says why it’s dark. Every service page in Settings used to assume its capability was present and working; when one wasn’t, the controls simply sat there doing nothing. Each panel now checks for itself and, when its capability is missing, switched off, or failed to load, says exactly which of the three it is — showing the underlying error when there is one — and offers a way straight through to the Capabilities page. The controls below go visibly inert rather than pretending to work.
• Legends that stay off the axis. A chart legend long enough to wrap onto a second row used to spill over the x-axis labels underneath it. Wrapped rows now have their height reserved in the plot’s grid, re-measured whenever the chart is resized or its data changes — so a legend gains room instead of taking someone else’s.
• Newer defaults from DeepSeek and Qwen. The model catalog picks up deepseek-v4-flash — now frontier-badged and auto-selected when you connect DeepSeek, at a third of Pro’s price — and qwen3.8-max, Qwen’s new flagship and the first Max tier with vision, cheaper than the 3.7 Max it replaces. deepseek-v4-pro stays listed alongside for the heavier reasoning work.

​

New features

• Every browser you own, one extension. The browser extension used to assume one browser — connect it from Chrome and that was the whole story. It now speaks to several browsers at once, and two profiles of the same browser count as two browsers, told apart by each profile’s signed-in email, so “work Chrome” and “personal Chrome” stop being guesswork. Every connected browser introduces itself on arrival — name, version, operating system, profile — and takes its own row in Settings → Services → Browser Extension, a row that holds steady through extension reloads instead of flickering away. The agent sees the same roster: it can list what’s connected and choose which browser a conversation drives — a choice that sticks for that conversation until it deliberately switches — picking for itself when you named a browser or the context makes it obvious, and asking you first when nothing does. Each browser remains a fully separate world — its own tabs, logins, and cookies — and the agent is taught never to mix them up.
• The reasoning behind a reply, one click away. When the model thinks before it answers, that thinking no longer evaporates. A reply that carries reasoning now ends with a small collapsed Reasoning card in the chat feed — click it to unfold the model’s raw thinking text, click again to tuck it away. Nothing appears when there was no reasoning, and the card mirrors the one the mobile app already shows.

​

Updates

• Your phone vote lands on the open chat. Score a reply from WhatsApp or Telegram — a bare number, 0 to 10 — and the desktop app used to sit there looking as if nothing had happened; worse, a conversation reopened later showed no scores at all, even though every vote was safely on disk. Scores travel now: a vote cast on any surface appears live on the rating bar of the chat you have open, reopened conversations show every score they’ve earned, and when the same turn ends up voted on twice, the most recent vote wins — a re-vote from your phone can no longer be quietly overwritten by a stale copy the desktop was still holding. In-app clicks paint instantly and roll themselves back on the rare failed write.

​

New features

• Wolffish sleeps on it. Every night, Wolffish now reviews its own finished conversations — scheduled automations included — the way a careful colleague reviews their day: what was attempted and how it actually ended, what worked well enough to repeat, what failed and why, and what you showed it about how you like things done. The lessons distill into a playbook — do this, avoid that, recipes for recurring tasks — and that playbook rides into every future conversation, so a lesson learned Tuesday night shapes Wednesday’s first reply. It is a living document rewritten in place: the newest evidence wins a contradiction, stale guesses fade unless reinforced, and your live instruction always outranks it. Once a month, a deep reflection takes the opposite stance and attacks what the nights accumulated — stale rules, sweeping conclusions built on one incident — the structural guard against self-taught bad habits. A laptop asleep at 3 AM simply runs its review on the next launch, and the schedule, quiet window, run-now buttons, and last-run reports live in Settings → Knowledge → Reflection.
• Your 0–10 becomes its ground truth. The strongest signal in that nightly review is yours to give: a 0–10 rating bar appears above the composer once a reply completes — one click scores the turn, another changes your mind. On WhatsApp and Telegram, a reply that is nothing but a number from 0 to 10 is quietly captured as your score for the last reply — acknowledged with a small ✍ reaction, never a chat bubble — and digits typed on an Arabic keyboard count the same. The plumbing stays careful: a “3” answering a numbered question card still means option 3, and a number opening a fresh chat is just a message. Scoring is optional everywhere — each surface has its own switch in the same Reflection settings.
• Charts — live in chat, drawn in print. Wolffish can now show data instead of narrating it: interactive chart cards in the app chat — line, area, column, bar, stacked, pie, donut, scatter, heatmap, radar, gauge, and funnel — themed to the app in light and dark, with tooltips, legends, an expandable full-screen view, the underlying data one toggle away, and Save as image for sharing. Inside generated PDFs, charts are drawn to the same visual system with print-perfect geometry and a colorblind-validated palette. A new core dataviz manual teaches the agent when a chart earns its place (and when a number or a table is the honest answer), and which chart fits which data.
• Documents designed by a manual, not a mood. Wolffish’s PDFs used to swing between genuinely good and visibly broken — dark slide-like pages, half-empty sheets, a different look every time — because the full design recipe lived where the model rarely read it. That recipe is now a core document design manual the agent loads before authoring anything you’ll read: a page-planning step so no page ships half empty, a fixed-sheet architecture with running footers and real page numbers, one type scale, one accent color with light body pages always, a component kit, Arabic/RTL rules, and a mandatory verify pass — the agent renders sample pages as images and looks at them before sending you anything. Your own instructions still win: an automation that asks for a minimal layout keeps getting exactly that.

​

Updates

• Raw Markdown stops reaching your phone. WhatsApp and Telegram render no Markdown — yet an agent deep in a task could still write **bold**, # headings, or | tables |, and the raw symbols landed in your chat. That leak is now sealed at both ends: the send tools refuse Markdown outright — the agent rewrites the message in the chat’s own formatting before anything goes out — with careful guards keeping honest text flowing (x**2 and f(**kwargs) read as math and code, not bold). The live narration between tool steps is watched instead of blocked: when a line lands carrying raw markup, Wolffish tells the agent exactly what you received, and on Telegram points it at the delivered message so it can quietly edit it clean. Nothing ever rewrites the agent’s words and nothing is withheld.
• A memory that curates instead of piling up. The nightly pass that turns the day’s conversations into long-term knowledge used to be an extractor: it never saw what it had already written, so it re-derived the same facts night after night — the same phone number recorded a dozen times, facts drifting onto the wrong person. It now works as a curator: it reads the current knowledge files alongside the day’s log and rewrites them whole — one tidy section per person, project, and topic, near-duplicates merged into a single line, contradictions resolved in favour of the newest evidence, junk deleted on sight. Every rewrite keeps the previous version as a backup right beside the original, so a bad night is one copy away from undone, and your own hand-written edits survive curation.
• Relative paths find the workspace. Ask the agent to touch a file by a bare relative path — files/report.pdf rather than the full address — and it used to resolve against wherever the app happened to be launched from. Relative paths now resolve against the workspace, the folder where generated files actually live, so the file the agent names is the file it finds.

​

Updates

• Settings tabs that say what they hold. Two tabs in settings were named after parts of a brain rather than after anything you would go looking for. Cellebrum — the page listing every skill, plugin, and tool Wolffish can call on — is now Capabilities, and Hippocampus, where the memory compaction schedule lives, is now Knowledge. The pages themselves are unchanged down to the last switch; only the words you navigate by have moved into plain English. The Data page follows suit — its storage breakdown now reports what memory costs you under Knowledge. Wolffish’s inner workings keep their anatomical names; what changed is the labels you actually click.
• Room at the bottom of the conversations list. Scroll to the end of the Conversations page and the last row stopped flush against the window’s edge, close enough to look cut off rather than finished. The list now keeps a margin of space past its final row, so the bottom of a long scroll reads as the bottom.

​

Updates

• Find a conversation by when it happened. Every conversation list was one long stack sorted newest-first — fine to about the twentieth row, useless after it. All three lists — the right-hand rail, the Conversations page, and a project’s conversation list — now break themselves into dated groups: Today, Yesterday, Previous 7 days, Previous 30 days, then quarter, half-year, year, and Older. The windows widen as they recede, deliberately — recent work is the kind you look for by its exact day, older work by roughly its era. A heading only appears when something sits under it, the numbered chips keep counting straight through the headings, and groups are cut on calendar days, so something from eleven last night reads as Yesterday rather than falling inside a rolling twenty-four hours. The collapsed rail keeps its chips-only look and marks each boundary with a thin rule.

​

New features

• Zoom into what you’re looking at. An image in a conversation opened big and stopped there. The expanded view now zooms to your cursor: scroll and the pixel under the pointer stays exactly where it is, up to eight times in, then drag to pan around what you’ve magnified. A small toolbar carries the live percentage; +, -, and 0 do the same from the keyboard, and a double-click jumps in or back out. Videos got the same surface — a new expand button opens the player sized to the picture’s real shape rather than an assumed widescreen — and PDFs expand too, to a full 80% of the window, where the built-in viewer keeps its own scrolling and paging.
• Report a bug without opening the conversation first. The bug button that packs up everything about a conversation that went wrong was reachable only from inside that conversation. Every row on the History page now carries its own bug button, so you can hand over a bundle for a conversation you aren’t in. The export itself got steadier in three places: the collecting screen no longer spins forever over an archive that already landed, returning to a run already in flight attaches to it instead of reporting failure, and the optional step that asks the model what it thinks went wrong gives up after ninety seconds — a stalled provider costs the bundle one section rather than the whole export.

​

Updates

• One conversation, one story, whichever list you read it in. The right-hand rail, the History page, and a project’s conversation list now share one definition, and each keeps up on its own: start a chat in the app, message from WhatsApp or Telegram, or let an automation or saved procedure open one, and the row appears the moment its first turn starts — pulsing chip and source emoji included — instead of surfacing only once the work was over. On the Projects page, conversation counts and “last used” stamps refresh themselves live too.
• Point at a folder mid-answer. Handing Wolffish a working folder was locked the moment it started answering. Adding one is live now, exactly like attaching a file — the folder rides your next queued message rather than the running one. Removing a folder still waits for the turn to end, deliberately: the agent may be reading files in there this second, and the delete button says as much on hover.
• Windows: PDF tools and shell commands, unstuck. Two Windows-only faults, both invisible from the outside. Every PDF tool — reading, searching, rendering a page — failed on its very first call, because a file path was assembled with the platform’s own separator where the PDF engine insists on one particular character. And a shell command that printed anything to the error stream — how npm, git, pip, and ffmpeg report ordinary progress — could be reported as failed when it had fully succeeded whenever a stray 2>&1 was appended out of habit; that redirect is now dropped before the command runs.
• The project dialog stops shifting under you. Adding a file to a project moved everything below it twice. The progress card and the file list now share one shell and one row height, so the block claims its space once and keeps it — and the copy button on a project’s standing instructions appears on hover, like every other code block in the app.

​

New features

• One button packs up everything that went wrong. Explaining a broken conversation to the developer used to mean hunting down which log, which task file, and which prompt snapshot actually belonged to it. A new bug button in every chat runs the whole errand: one press bundles that conversation and nothing else — the transcript, the event log for the days it spans plus a slice filtered to its own turns, the task files it spawned, the memory behind it, the prompts and capability contracts it was working against, and your settings — into a single zip you can forward as-is. Every credential is redacted (a length marker, never the value) and attachment media is left out, so the archive is safe to hand over. On a cloud model it also asks the model itself what it thinks went wrong and tucks that into the bundle. See Diagnostic Export.
• Show me the figure. Ask about a diagram, chart, algorithm or table inside a PDF and Wolffish could only ever read you the words around it. The new pdf_render_pages renders the page itself as an image — the figure exactly as printed, at whatever zoom the small print calls for — and sends it into the conversation. This is the fix for a quiet failure: a textbook figure is usually drawn, not stored, so there is no image inside the file to pull out and pdf_extract_images correctly came back with nothing. Extraction got sharper too — it now works on the pages you name rather than the whole book, and skips the sub-80px fragments that used to bury the one figure you wanted under thousands of unusable files. See the pdf capability.

​

Updates

• Big files say so while they copy. Attach something large and the composer used to sit blank while it was copied into Wolffish, until the chip simply appeared seconds or minutes later. Every file you pick, drop, or paste now claims its chip the instant you choose it, with a filling ring and a live percentage counting real bytes, and hands over to the finished attachment when those bytes land. Send waits for them — the button rests, the Enter key is caught too, and a tooltip says why — because a message sent mid-copy would have quietly gone without the file. Stopping a running turn is never blocked. Adding files to a project got the same treatment: one bar across the whole batch, with which file of how many is moving.
• Record while it’s still working. The microphone used to go dark the moment Wolffish started answering. Recording stays live now, exactly like attaching: a take started mid-answer waits in the row above the composer — with a play button and its length, so you can hear it back before it goes — and sends itself when the turn finishes, uploaded, transcribed, and answered in its proper place in the queue.

​

New features

• Core capabilities can’t be switched off by accident. Settings lets you toggle individual capabilities on and off — but a handful are load-bearing: the workflow engine, your secrets, the skills capability, projects, automations, procedures, and the shared tools the rest leans on. Those now wear a Core badge, settle at the bottom of the list, and can no longer be turned off — a locked Always on marker sits where their switch used to be. Everything you added yourself stays exactly as toggleable as before; only the essentials are protected, so a stray click can’t pull the floor out from under a feature you depend on.

​

Updates

• Workflow mode, working again. In v1.0.227, workflow mode quietly stopped delegating: the tools it uses to plan phases, spawn agents, and gather their results failed to load, so it fell back to working alone with no hint of why. The cause was a small formatting slip in an internal file — now fixed, and workflow mode plans, delegates, and collects work the way it should again.

​

New features

• Nothing you send has to be resent. Message Wolffish from Telegram or WhatsApp while it’s still working and the message is now queued, not bounced with a “hold on, I’m busy” — files and voice notes included, downloaded and transcribed the instant they arrive so nothing goes stale in line. A reply confirms where it sits, and each queued message runs on its own turn, in order, the moment the current task finishes. Two commands keep you in charge: /cancel drops everything waiting and leaves the running task alone, while /stop stops the run and lets the queue carry on. Starting or switching conversations (/new, /resume, /delete, a project switch) clears the queue with the conversation it belonged to. One habit to unlearn: on Telegram /cancel is no longer another name for /stop.
• Your phone’s chat, live on your desk. A conversation that Telegram, WhatsApp, or an automation is answering right now used to open in the app looking idle and finished, the whole reply landing in one lump at the end. It reads as live now: the reply streams into the feed as it’s written, the Stop button genuinely stops the run whichever device started it, and a message you type mid-run queues and sends itself when that run lands — even if you opened the window in the middle of one.
• A stuck agent says so. In workflow mode, a delegated agent that wedged itself — re-issuing the same tool call to no effect — used to be invisible while the master sat blocked waiting for a result that never came. Both ends are told now: the spinning agent gets a note to wrap up with what it has, and the master is woken out of agents_await with the agent’s name, the repeated call, and the count — then decides for itself whether to wait it out for partial findings or cancel it and cover that slice another way. Nothing is capped, nothing is killed automatically.

​

Updates

• Memory compaction shows its work. The Memory compaction card in Settings used to show only the next scheduled run. It now also shows each job’s last completed run — when it ran, how long it took, the output it produced, and (for the daily summary’s model call) the tokens in and out — and skipped or failed passes never overwrite it, so you’re always reading the last pass that did something. The background side-calls got quicker too: naming a conversation and writing a summary now run with reasoning off on your configured Brain, whatever reasoning level you’ve picked for chat.

​

Updates

• Low on disk? Warned, not walled. Launching with less than 5 GB free used to be a locked door — the low-space screen had no way past it short of deleting files. It’s a warning now: a Continue anyway button takes you straight to your usual screen, with a plain note that models, saves, and downloads can fail until you free room. The choice lasts one sitting — the warning still greets every launch while the disk stays low — and Recalculate now answers out loud, ending each re-check in a toast: a green “enough to continue” with the exact free amount when you’ve cleared the bar, the familiar warning when you haven’t.
• One Arabic label, mended. A garbled character had crept into the Arabic label for recording a voice note. It reads «تسجيل رسالة صوتية» again, as it should.

​

New features

• Background runs stop taking over. A firing automation used to swap the whole app for a full-screen “chat is paused” overlay. Now it surfaces as a floating live card pinned over the top of the screen — pulsing icon, the job’s name and mode, a live feed of what it’s doing — while the rest of Wolffish stays fully usable. Click the card to expand the full activity panel (timer, instruction, step-by-step log); Escape or a click outside folds it back without losing a line of history. Procedure runs deliberately get no card at all — a saved prompt doing its job needs no stage — though a failed run still raises a toast naming what broke.
• Three at once, the rest in line. Background jobs used to run strictly one at a time — a slow nightly digest made the whole schedule late. The engine now runs up to three jobs side by side, each with its own card, and everything past three waits in a visible queue — a row under the cards counts and names what’s waiting, and nothing is ever dropped: a queued job starts the moment a slot frees, and a job that fires while already running or queued folds into the pending run instead of stacking copies. On the Automations page, a running or queued job says so on its card and its Run now button rests until the run ends.

​

Updates

• An edit counts, whoever makes it. The “Edited” stamp on an automation card used to notice only the card editor’s own saves. Stamps now come from the engine watching heartbeat.md itself: any writer counts — the dialog, the markdown view, Wolffish’s own automation_* tools, an external editor, even an edit made while the app was closed — while merely toggling a job on or off correctly doesn’t restamp. The Automations, Procedures, and Projects pages all refresh themselves live when something changes underneath them — ask Wolffish mid-chat to add an automation and watch the card appear — and project cards now show their own Edited time next to last-used. The card editor’s schedule field also stopped flashing red mid-keystroke: it waits out your typing pause before calling a schedule wrong.
• Admin rights reach the agents. Wolffish keeps one saved admin session per app run — you type your password into a native dialog once, and sudo authenticates app-side from then on. That session is now genuinely app-wide: workflow agents and scheduled runs — automations and procedures — elevate through the same session as the chat, so a delegated task that needs admin rights just runs instead of coming back with “this needs elevation.”

​

New features

• Projects. Some work is a dozen conversations sharing one context — projects give it a home. A project is a name, an emoji, standing instructions, and a set of files; every conversation inside it starts already briefed: instructions ride each turn, files are known by name and read on demand rather than stuffed into context. Manage them on the new Projects page; start one by hovering the New Chat button (your projects fan out as cards), and the rail and History group and badge every conversation under its project. Procedures and automations can be bound to a project too, and /project on WhatsApp and Telegram starts project conversations from your phone — with /new deliberately staying inside the project and /project close the way out. Wolffish manages projects itself through eight new project_* tools.
• Files the size of books. Attachment content is never injected into context anymore — every file becomes a compact reference note (name, path, real facts — a PDF’s page count is probed lazily from its own index), and Wolffish reads on demand: new pdf_info and pdf_search plus a lazy, cached pdf_read walk thousand-page documents a page range at a time, file_read streams slices of giant text files, and vision models pull an image’s pixels with the new image_view only when they actually look. The arbitrary size caps (100 MB documents/spreadsheets, 500 MB audio) are gone, and Wolffish narrates long reads instead of going silent.
• Automations, now with faces. The Automations page is rebuilt around cards: each job wears its own emoji (📧 for the inbox sweep, 📰 for the news digest), with a proper editor dialog — schedule chips for every form including full cron, a real time input, a live next-run preview, and autosave. The emoji is stamped on every conversation the job’s runs create, so the rail tells you at a glance which automation an overnight run belongs to. Procedures got the same treatment — an emoji per procedure, stamped on its runs.
• Several questions, one card. ask_user now takes a list of questions: in the app they arrive as one card with chip tabs — flip through, answer everything, one resolution — and on WhatsApp and Telegram the same request walks you through them one message at a time, in order. Quizzes run through it too: every question up front, graded and explained after.

​

Updates

• Replies that fold. Chat replies can use a careful, sanitized slice of real HTML: collapsible <details> sections with a clickable summary, highlighted <mark> text, keyboard keys, sub- and superscripts. Scripts, styles, frames, and event handlers are stripped outright; unknown tags degrade to their text. The PDF export renders the exact same subset, so an exported conversation shows what the feed showed.
• A card that opens the folder. When the deliverable is a place rather than an attachable file — a folder Wolffish scaffolded, a batch of outputs, a file deliberately left where you asked — it pushes an openable location card: Open for folders, Reveal for files. The old path-guessing that parsed cards out of prose is deleted — a card now exists exactly because Wolffish chose to hand you the place, through a real tool with a checked path.

​

New features

• Keep typing while Wolffish works. The composer no longer locks during a turn. Type your next message mid-run and Enter queues it in a row above the composer — cancelable until the moment it goes — and it sends itself when the current turn ends; queue several and they go out one by one, in order. Attachments keep pace: the attach button, drag-and-drop, and paste all stay live during a run, with staged files riding the queued message instead of interrupting the running one. Stopping a run counts as ending it, so Stop advances the queue too — your queued follow-up steps straight into the room the stop just made.
• Your spending, added up for you. The Usage panel always knew what every call cost — it left the adding to you, one provider card at a time. A new Costs section now does the arithmetic for the range you’re viewing: Total Spend, Top Day Spend with the date it happened, and Daily Average across the days you actually used Wolffish. The total counts Brave search fees too, so it genuinely equals the sum of the provider cards below it, and the new cards load under the same skeletons as the rest of the panel, so nothing jumps when the figures land.

​

Updates

• A zoom that fits the picture. Clicking an image to see it big used to float it in a general-purpose dialog, with empty bars wherever its shape and the box’s disagreed. It’s now a proper lightbox: a clean overlay that hugs the image’s exact proportions, growing it until it reaches 80% of the window on whichever edge gets there first — no title bar, no letterboxing, just the picture. Click anywhere outside it, or press Escape, to dismiss. The same lightbox serves the chat and the workspace file viewer alike.

​

New features

• Phone conversations, continued at your desk. A conversation that started on Telegram or WhatsApp — or one an automation ran overnight — used to open in the app read-only. Now every conversation is a live chat everywhere: continue a phone thread with a real keyboard, or pick up a finished automation run and ask the follow-up — it unseals and grows like any other chat. If a message lands on your phone while the same conversation is open on your desk, the new tail simply appears in place, and voice notes survive the round-trip untouched. The conversations rail and History now badge each conversation with its origin — Telegram, WhatsApp, automation, procedure — so a mixed list stays legible.
• /resume reaches every conversation. On both channels the picker now lists everything Wolffish has — every channel, newest first, 25 to a page with next — each row tagged with its origin and the numbering continuous across pages. A number you were never actually shown selects nothing, which matters most for /delete, now served by the same picker, where a wrong pick is unrecoverable. Scheduled automation runs stay out of /resume by default — a new toggle in both channels’ settings — while remaining in /delete and the app.
• Replies land where you meant them. When Wolffish messages you out of band — an automation reporting a finished job, an in-app conversation dropping you a note — the chat now points itself at the sending conversation, idle clock restarted so the staleness guard can’t bounce you back out. You reply, and you’re already in the conversation that messaged you.
• Kimi K3. Moonshot’s new flagship, supported in full from day one: a 1M-token context window, 128K max output, vision, and its three-step reasoning dial — Off / High / Max — on the reasoning button, with Off verified to genuinely disable thinking. K3 is now the Kimi provider’s default model, priced in usage tracking down to the cached-token discount, and available through OpenRouter as well. Vision also unlocked across the rest of the line: everything from k2.5 onward is natively multimodal, so images now flow to k2.5, k2.6, and the k2.7 code models instead of being stripped as text-only. And the model picker stopped burying the flagship — Moonshot stamps its whole catalog with one shared release date, so the list now sorts newest family first.
• Try again on failed turns. When a provider dies mid-turn — overloaded, timing out, erroring — the error card now carries a Try again button. One click continues the conversation with the failure named, so Wolffish checks what already completed (files written, tool results in hand) and picks up from the break instead of restarting the task blind.
• Per-agent spend in the meter. The context pill’s card now itemizes workflow runs: one row per agent — live status dot, tokens, cost, a bar scaled to the run’s biggest spender — plus run totals of tool calls, tokens, and cost. It restores with the rest of the meter when you reopen a conversation whose last turn was a workflow run.

​

Updates

• Conversations merge instead of clobbering. Every message now carries a permanent identity, and two copies of the same conversation reconcile message-by-message instead of last-writer-wins — so a Telegram message landing while the same thread runs an in-app turn survives alongside it, the rolling summary stays pinned to the exact message where its coverage ends, and a window holding a stale copy can no longer save over a finished turn. Existing conversations pick up their identities on first launch, invisibly.
• The end of permanent “Untitled”. The conversation-naming call silently defaulted to a full high-effort reasoning call — thinking hard about five words — blew its deadline, and wrote nothing, stranding roughly one in five Telegram conversations (one in ten on WhatsApp) as “Untitled” forever. Naming now runs with thinking off and lands in about a second; a title that still runs late degrades to a readable slice of your own message instead of to nothing; a photo sent with no caption is named from its filename; and the conversations already stranded heal on launch, deterministically, without a single model call.
• Arabic that reads like Arabic. Every size the app shows — model downloads, disk usage, free space, transfer speeds — was hardcoded English, a “1.5 GB” sitting mid-Arabic-sentence. All of it now reads natively, the bidirectional-text bug that tore numerals away from their unit words is fixed, and hardware specs dropped their false precision — “16 GB”, and never a meaningless “0 GB” for a small model.
• Settings numbers that tell the truth. The Data panel’s CPU gauge was measuring its own disk scan — an idle app reported 93% when the truth was 0.3% — and showing a share of a single core, so a busy moment on a twelve-core machine read as 141%. It now samples after the scan and shows whole-CPU utilization, with a “Less than 0.1%” floor so a small real load reads as one. Usage paints the instant you open it, every range warmed at launch — the loading skeleton is gone from the panel you check most.
• Small polish. The one-time post-update memory-index rebuild now owns the screen properly — rendered once at app level, with the conversations rail stepping aside instead of floating over it — and its “database growing large” health warning trips at 1 GB instead of 50 MB; /resume and /delete render as proper LTR command chips inside Arabic settings copy; and the verbose-toggle description on all three channels now matches exactly what the clean feed delivers.

​

New features

• Concurrent conversations. Wolffish is no longer a single chat window that empties when you open another. Every conversation now runs at once — each keeps its own feed, composer, context meter, and in-flight turn, all mounted together. Start a second chat while the first is still streaming, flip back to it, and both are exactly where you left them; switching conversations never pauses, resets, or drops a turn that’s mid-flight. A conversation only advances when its turn does.
• The conversations rail. A new rail down the right edge lists every conversation across every channel, newest first, each with a numbered status chip that pulses while a turn runs and settles into a color when it’s done — green finished, red failed, amber stopped — held for the rest of the session. Collapsed it’s just the chips; expanded each shows its title. Click any to jump straight in, including a conversation still mid-turn that hasn’t been written to disk yet (the rail reopens it by its live session instead of dead-ending on a missing file). The History page carries the same live chips and shares one open-or-activate path with the rail.
• Conversations name themselves. The moment a conversation begins, Wolffish reads your first message and writes a short, specific title for it — so the rail and History read like a table of contents instead of a wall of identical “New chat” rows. Titling runs quietly in the background on your chosen model; its cost is recorded on your usage ledger but walled off from the conversation’s own context meter, so naming a chat never eats into its window. If the model can’t be reached the title falls back to a trimmed slice of your opening line, and a later turn tries again.

​

Updates

• Channels stop waiting in line. Turns were globally serialized: a Telegram message landing mid-in-app-turn had to wait for it to finish. That queue is now per conversation — a single conversation is still one ordered transcript, but different conversations run in parallel, in any mix of in-app, WhatsApp, and Telegram. Every turn reports its live status back to the app, which is what lets the rail’s chips pulse for channel runs and not just the one on your screen. See Channels Overview.
• Sidebars, squared up. Both rails were rebuilt to match: mirror-symmetric widths, both defaulting to collapsed, and they now snap open and closed instead of animating a width that made the icons jump mid-slide. Each ends cleanly at the top of the action bar.
• Small polish. Running procedure and heartbeat overlays now wear a Single / Workflow badge so you can see which mode an automated run is executing in (a job with no marker shows the global mode it inherits); opening a conversation warms its file cards before it paints, so a resumed chat lands fully formed instead of popping its attachments in one by one; and the Arabic interface caught up on the “automated task — read only” heartbeat notice.

​

New features

• Workflow mode. Orchestrator mode is gone, rebuilt as workflow mode: the agent you talk to becomes the master of a run it designs itself — it declares its phases (workflow_plan), spawns live parallel agents (agent_spawn), collects each report the moment it lands (agents_await), sends follow-ups (agent_send), and cancels dead ends (agent_cancel). The fixed “Worker model” slot is retired: the master picks each agent’s model individually from every provider you’ve connected — it sees a catalog of your models with context windows, reasoning support, and vision, and matches frontier models to hard slices and cheap ones to mechanical sweeps. Agents are single-shot (the master owns every retry decision), can’t reach you or spawn agents of their own, and each one’s context is budgeted against its own model’s window.
• The workflow card. Every workflow run gets one collapsible card in the chat: the phase plan as chips moving from pending to active to done, a live table with a row per agent (name, task, model, phase, status, elapsed time, tokens, tool calls, cost), and run totals including the true whole-turn cost. Every number comes from harness telemetry — never from what the model claims — so the live card and the reloaded card are the same card. The chat’s PDF export prints a finished run as a static table.
• Model and mode pickers in the composer. The drag-and-drop Brain settings page is gone; choosing what runs your conversation moved to where the conversation happens. Beside the chat input: a Local/Cloud model switch that opens into a searchable catalog of every connected provider’s models (capability badges, context sizes, one click to switch), a mode pill (Single / Workflow), and a redesigned reasoning button — hover for a card of every effort level the current model supports instead of blind-cycling. API keys stay in Settings → Models.
• Every job picks its own mode. Heartbeat jobs and procedures each carry their own Single/Workflow toggle — under the hood an optional mode: workflow first line in the job’s block, stripped before the instruction reaches the agent. automation_create / automation_edit / procedure_create / procedure_edit take an optional mode, so Wolffish can set it by conversation. Jobs without a marker follow the global mode.

​

Updates

• Workflows on the channels. The old per-worker narration is retired. Telegram and WhatsApp now get deterministic progress from workflow runs — the phase plan at start, a line per completed phase, and a closing summary with totals — with verbose adding a landing line per agent (name, model, duration, tool calls). Verbose off keeps the clean feed: the master’s reply, nothing else.
• Migration on first launch. If you were running orchestrator mode you wake up in workflow mode (multi-agent intent preserved, not silently downgraded); the Worker-model slot, the Greedy effort and Autonomy toggles, and the old orchestrator capability are removed, and their leftovers are swept from deployed workspaces. config.llm.mode replaces orchestratorMode / workerModel / greedy / autonomous in config.json.
• GitHub and Notion tests that fail loudly. A failed connection test in the GitHub or Notion panel now leaves a persistent red alert with the reason on the connection card — cleared when you edit the token or a test passes, and translated live when you switch the app language.
• Small polish. .txt attachments open in a line-numbered text viewer instead of a bare file card; the attachments grid got wider tiles and more spacing; the clocks on running procedure and heartbeat overlays follow your app language’s time format; model names display compactly in the pickers; error messages are shorter and plainer.

​

New features

• Save any conversation as a PDF. A new download button in the chat footer exports the conversation you’re looking at to a PDF that mirrors the feed exactly — your messages, Wolffish’s replies, tool cards, code blocks, and file attachments — laid out for print and offline reading.
• The usage meter, rebuilt. The opt-in “Show in-chat analytics” strip (and its showChatAnalytics setting) is gone. In its place the context pill beside the chat input is always there and now opens: hover or pin it for the full picture — how much of the context window is in use and exactly where auto-compaction triggers (drawn as a tick, so the visible percentage and the trigger are finally the same number), how much of that context arrived warm from cache versus freshly ingested, and a running ledger for this turn, last turn, and all time of input/output tokens, API calls, tool calls, and cost. In orchestrator mode its workers and background summaries get their own sub-totals.

​

Updates

• Send an image to any model. The capability gate that rejected images on non-vision models is gone. Attach an image to any model on any surface — in-app, Telegram, WhatsApp — and it goes through; a model that can’t see the pixels receives the file’s name, location, and the tools that can read it, and tells you plainly what it can and can’t do instead of bouncing the upload.
• Workers narrate on Telegram and WhatsApp. In orchestrator mode with verbose enabled, background workers now surface their own labeled thread on the channels — prose and tool cards, coalesced per worker so concurrent workers never scramble into one another — mirroring the subagent rail in the app. Verbose off still shows only the orchestrator’s final reply.
• Offline, treated as a state. The offline notice is now a sticky warning pinned to the top of the window with its own close button, swapped in place for a brief “connection restored” when you reconnect. Wolffish itself now knows when it’s offline and leans on tools that work without a network (memory, files, shell) instead of burning turns on ones that don’t. Every toast can now be dismissed with a click.

​

New features

• The lean context system. The biggest internal rebuild Wolffish has ever had. A fresh request now costs ~9.4K tokens instead of ~94K — a 10× reduction — because the prompt carries only the essentials plus two compact indexes: a capability index of everything installed and a memory map of everything recallable. The memory dumps, episode dumps, and the 16K-token tool catalog are gone; the prompt prefix is byte-stable, so ~99% of it serves from the provider’s cache. Measured live: the hourly automation dropped from 96,442 input tokens ($0.046) to a ~5.1K prompt ($0.019).
• Total recall, on demand. Everything Wolffish has ever done, said, produced, or spent is now in one indexed store it searches in milliseconds — every conversation including every tool call and its output, daily activity, long-term knowledge, task runs, generated files, costs, and even incoming WhatsApp messages. A new retrieval toolset (memory_search / memory_get / conversation_list / conversation_read / memory_save / usage_report) reaches any of it surgically, and the operating contract teaches unprompted recall: “send me the flight plan” searches the past before doing anything else, whether it was yesterday or a month ago. “What did today cost?” finally has an answer.
• Tools that scale to thousands. Instead of shipping 300+ tool definitions with every request, ~30 essentials stay loaded and the rest — including every MCP server — load themselves mid-task via tool_search/tool_activate, usable the same turn. Activation is per-conversation (an automation loading a tool never disturbs your chat’s cache), bounded by an invisible LRU, and tunable via pinnedCapabilities in config.json.
• Files, hand-delivered. File delivery is now entirely the agent’s own decision: nothing auto-attaches, and the operating contract requires it to send_file the result of any file-producing task the moment the work is done — rendered natively in-app and uploaded for real on Telegram and WhatsApp. No more “saved to ~/some/path” dead ends, and no more surprise attachments it never chose to send.

​

Updates

• Endless conversations, one summary. A conversation that outgrows verbatim replay now folds its early turns into one persisted rolling summary instead of re-paying a hidden summarization call on every message — and the folded turns stay on disk, indexed, retrievable verbatim via conversation_read. Conversations can never outgrow the context window, and the History view always shows the complete, untouched transcript.
• One system for every model. The “Stateless local models” and “Restrict local models” settings are gone. Local models run the exact same lean context, full toolset, and memory as cloud models — they’ll say so honestly when a task is beyond them, but nothing is withheld. Models with very small context windows automatically get a slimmed bootstrap toolset.
• Instant everywhere. The memory index no longer rebuilds from scratch at every launch (incremental, ~22ms; a full rebuild of a 2GB workspace takes ~1.3s and only runs on upgrades). The History page loads from the index — instant at any size. The context meter shows your model’s full window and measures real provider-billed tokens.
• Memory hygiene. Episode entries are tagged with their origin ([heartbeat], [worker], channels), knowledge promotion deduplicates, the weekly review writes a digest instead of pasting seven days of raw logs, automation runs are recorded durably (run-history.md), and prompt debug snapshots rotate at 50 instead of growing forever.

​

Bug fixes

• Task history was silently empty — every indexed task record had NULL fields due to a parser/format mismatch; all 340+ tasks are now queryable.
• Memory search ranked backwards — stronger matches scored lower; ranking is fixed across the index.
• MCP servers with hostname-derived names no longer register as doubled mcp-mcp-* capabilities, and per-tool descriptions from servers are sanitized and capped so a server can’t inject fake structure into the prompt.
• A ghost tool (channel_status) the agent was told to call but couldn’t reach is now properly routable.
• Cloud-provider PDFs are no longer needlessly flattened to plain text on several providers — they arrive as native document blocks.

​

New features

• MCP servers. Connect any Model Context Protocol server from the new Settings → MCP page — paste a command for a local server (uvx tafsir-mcp) or an http(s):// URL for a remote one, and every tool it exposes is available to Wolffish on your next message, in normal chat and to orchestrator workers alike. No connect step, no restart. Remote servers that require sign-in get a one-click browser OAuth flow (tokens stored, refreshed silently, and revoked at the provider on removal). Crashed or offline servers reconnect silently in the background with their tools quietly stepping aside until they’re back — one misbehaving server can never affect another or the app.
• Wolffish manages MCP by conversation. A new mcp capability (mcp_list / mcp_add / mcp_test / mcp_enable / mcp_disable / mcp_remove / mcp_authorize) mirrors the settings page exactly — “connect the tafsir MCP server,” “which servers are on?”, “remove that one” — with every change reflected live in the UI.
• Network awareness. A quiet toast when your connection drops and when it’s back — real transitions only, silent on a normal launch. Background-run failures now state why in plain words (“no internet connection,” “rate-limited,” “invalid API key”) instead of raw machine errors.

​

New features

• Procedures. A new Procedures page holds prompts you want to reuse — write one once, hit Play, and it runs in a fresh background conversation under a live overlay with a timer and activity log, then lands in History marked with a Play icon. Wolffish manages them by conversation too — “save this as a procedure,” “run my morning brief” — through a new procedures capability (procedure_list / procedure_view / procedure_create / procedure_edit / procedure_delete / procedure_run).
• Multiple GitHub and Notion accounts. The GitHub and Notion panels now hold any number of connections, each with its own label (“Personal,” “Work”) and a per-connection Test button showing the account it resolves to. Every tool takes an optional connection label — picked automatically when only one is linked — and new github_connections / notion_connections tools list what’s configured. Existing single-token setups migrate on their own.
• WhatsApp accepts any file. Send a PDF, document, image, video, audio file, or sticker over WhatsApp and Wolffish downloads and reads it like an in-app attachment — previously only voice notes made it through. Files without a name or extension are typed from the media itself; Telegram gained the same nameless-file handling.
• Conversation files at a glance. A new files button in the chat footer opens everything a conversation holds — your uploads and every file Wolffish produced — in a full-width grid. The timeline beside it now spans the whole conversation, with a collapsible divider per prompt.
• HTML attachments. .html files can now be attached, rendering in the code viewer with a one-click toggle between the sandboxed page preview and the highlighted source.

​

Updates

• WhatsApp messages in WhatsApp’s own formatting. Replies no longer arrive as raw Markdown — the agent writes in WhatsApp’s native style, and everything sent passes through a converter that translates leftover Markdown (headings, links, tables, task lists) into clean WhatsApp text.
• Chat stays live across navigation. Visiting Settings or other pages no longer reloads the context meter or timeline; playing media pauses on the way out.
• Faster long conversations. Feed rows re-render only when their message changes, and code highlighting no longer runs language detection on every block.

​

Bug fixes

• Background runs are isolated. Procedures and automations can no longer skew the live chat’s context meter, hijack its Stop button, or overwrite a conversation created in the same second.
• No double file delivery. A file a tool already delivered isn’t re-sent in the same turn — and the agent now reliably hands you every file it produces.
• No silent endings. A turn can no longer end mid-task with no message and no tool calls.

​

New features

• Orchestrator mode. The one agent you talk to can now become an orchestrator that spins up live parallel worker sessions on a second model, briefs and drives them, reviews their output against the goal, and folds everything into a single reply. It’s opt-in and decides per turn whether to delegate — reaching for workers only when a task genuinely splits into independent parts. Single mode stays the default for quick, sequential work.
• A “Modes” settings page. Model setup moved to its own Modes page — the first thing you land on in Settings. Pick one model (your Brain) by drag-and-drop or a click; switch on orchestrator mode to add a second Worker model in a slot beside it.
• Subagent transparency. With Verbose task results on, each worker’s text and tool calls render inline in the chat, tagged with the worker’s label, so you can see exactly how the orchestrator split the work. Off — the default — shows only the final synthesized reply.
• Greedy & Autonomy toggles. Two behavior switches on the Modes page tune how hard the agent works on every turn, regardless of mode — Greedy effort (persist harder: more retries, several approaches, keep going until the job is truly done) and Autonomy (act with high agency, ask you as little as possible). Both off by default.
• Run an automation now. A Run now button on the Heartbeat page fires any active scheduled job immediately, with a live overlay tracking its tool calls, results, and finish.
• Save a file to your computer. Save a copy of any file Wolffish has read or written — wherever it lives on your machine — to a location you choose through a normal save dialog.

​

Updates

• One Brain, no provider cascade. The old fallback-order / priority cascade is gone. You now select one Brain model explicitly — the one you choose is the one that runs, and you always know which. Existing setups migrate automatically: your top provider becomes the Brain and the dead settings are cleaned out. On a transient error the same model retries on a backoff; there’s no silent switch to another provider. See config.json for the updated llm shape.
• A default model on connect. Connecting a provider for the first time auto-selects a sensible default model, so you’re ready to go immediately — it never overrides a model you’ve already chosen.
• Crash-safe writes. Config, conversations, and channel state now write through one ordered, atomic path — temporary file, flushed to disk, then swapped into place — so a crash or hard quit can never leave a half-written, corrupted file. You always get the complete old version or the complete new one.

​

New features

• Automations. Wolffish now manages its own scheduled jobs — its heartbeat — entirely through conversation. Say “every morning brief me on my calendar,” “in 2 days remind me to renew the lease,” or “check the build every hour,” and it creates the automation; ask it to list, change, delete, or test one and it does. One-time jobs fire once and remove themselves, recurring ones keep going, and jobs never overlap — one that comes due mid-run waits its turn instead of being dropped. Anything missed while the app was closed runs once, collapsed, on the next launch.
• Read a WhatsApp chat. A new whatsapp_read tool catches Wolffish up on the latest messages in any WhatsApp contact or group, returned oldest-first. It covers traffic seen while Wolffish is connected — not older history from before it started — and that buffer now survives restarts instead of resetting every launch.

​

New features

• Ask cards. When a decision is genuinely yours to make, Wolffish poses it as an interactive multiple-choice card — a question, 2–5 options, and a free-text “something else” box — and waits for your pick instead of guessing. On Telegram and WhatsApp you reply with the option number.
• Self-managed skills. A new skills capability lets Wolffish list, search, enable, disable, delete, and even author its own capabilities at runtime — turning “do this every time” into a reusable skill, or “turn off the browser” into a disabled one.
• Channel status. A new channel_status tool reports which messaging channels are connected and how to reconnect any that aren’t.

​

Updates

• Channels aren’t apps. Asked to message you on Telegram or WhatsApp, Wolffish no longer tries to launch a phantom desktop app that doesn’t exist — it reaches channels only through their own send tools and fails gracefully with reconnect steps when one is down.
• Openable path cards. File and folder paths Wolffish mentions in a reply now render as a card with a one-click “open in file manager” button — shown only for paths that actually exist on disk.

​

Bug fixes

• grep -c zero counts. A grep -c that finds no matches exits with code 1 and prints “0” — that’s now read as the valid zero-count it is, not a failed command, so it no longer triggers needless retries.

​

New features

• Fully local voice. Text-to-speech now runs on Kokoro and speech-to-text on faster-whisper — both entirely on-device, with no cloud, no API keys, and no Microsoft servers. Voice memos work fully offline after a one-time setup. The default voice is af_bella (English, US); voices are English-only (American af_/am_, British bf_/bm_).
• Install voice engines on demand. Settings → Text-to-Speech and Speech-to-Text now offer an Install button with a live progress bar. The voice and model pickers stay disabled until the engine is ready, and the Preview button plays the actual selected Kokoro voice — not a browser stand-in.
• Managed Python runtime. The voice engines provision into an isolated, app-managed Python runtime automatically — no system Python or developer tools required on the machine.
• Z.ai (GLM) provider support. You can now run Wolffish on Z.ai — Zhipu’s GLM models with toggleable thinking and a 1M-token context flagship (GLM-5.2). OpenAI-compatible streaming and tool-calling at budget-tier pricing; bring your own API key.
• Verbose task results toggle. Each channel now has a Verbose task results switch — off by default — that controls how much of the agent’s step-by-step work you see. Off keeps a clean feed (replies, files, and errors only); on surfaces every tool call, result, and activity card as the turn runs.

​

Updates

• Install progress survives navigation. Starting an install — or a Google Workspace setup/update — then switching tabs or reloading the window no longer resets the progress; it resumes exactly where the real work is.
• One voice memo per reply. Sending a voice note now returns exactly one voice memo across Desktop, Telegram, and WhatsApp — no duplicate memos and no echo of your own recording. Multi-step requests run normally first, then close with a single spoken reply.
• Verbose changes display only. Flipping the verbose toggle re-renders the feed without changing what the agent does — every tool call and result is still saved to history and memory in full, so nothing is lost when it’s off.

​

New features

• Context compaction redesign. The compaction system has been rebuilt to use instant proportional truncation plus a single LLM summary call, replacing the previous per-message approach that required N separate API calls. Compaction that took 6 minutes now completes in under 30 seconds, and a structured continuation nudge ensures the model finishes multi-step tasks after compaction instead of treating shorter context as “done.”
• Planning skill. A built-in skill that injects planning discipline into every turn — the agent must state its understanding, lay out phases with verification criteria, and confirm each definition of done after execution.
• Conversation timeline. Conversations now track a timeline of key events (tool calls, results, compaction, model switches) that persists across sessions.
• Multi-turn tool history. Channel conversations (Telegram, WhatsApp) now reconstruct full tool-call history from stored segments, so the model can see its prior tool interactions across turns.

​

Updates

• Batch completion enforcement. New runtime instruction ensures the agent completes every item in batch operations (e.g. reading all emails, not just a subset).
• Structured provider error cards. Error details now always show provider name, HTTP status, error reason, retry count, and duration — even when the API returns no error body.
• Provider failure tracking. Per-provider failure details are now surfaced when a stream errors mid-response, not just when all providers are exhausted.
• Tool transcript detail logs. A separate detail log captures full raw tool output alongside the truncated transcript preview.

​

New features

• DeepSeek provider support. You can now run Wolffish on DeepSeek, the recommended default for agentic workloads. Bring your own API key and start chatting in seconds.
• Ollama is now optional. You no longer need a local Ollama install to use Wolffish — pick any combination of cloud providers or local models that fits your setup.
• Microphone and audio permissions. Wolffish now requests mic and audio access on first launch, paving the way for voice-driven workflows.
• Instant conversation titles. New chats get a title the moment you send your first message, so your sidebar stays organized without waiting on the model.

​

Updates

• Smarter chat rendering. Cards, code blocks, and tool outputs now render more reliably in long conversations.
• Refined sidebar and chat navigation. Cleaner layout, better keyboard navigation, and quicker access to past conversations.
• Tray menu improvements. The system tray menu is more responsive and reflects the current app state correctly.
• Better token display. Token usage indicators are now accurate and easier to read at a glance.
• Windows performance. Shell execution and app startup have been optimized for Windows users, including a cleaner installer name.

​

Bug fixes

• Fixed web fetch failing on certain URLs.
• Fixed channel connection errors and intermittent API failures.
• Fixed a JSON parsing crash that could interrupt long agent runs.
• Fixed microphone access on macOS.
• Fixed DeepSeek streaming and tool-call edge cases.
• Fixed docs handling so attached files render correctly in chat.
• Fixed bypass mode not engaging in some sessions.
• Fixed blank request timeouts that could stall the agent.