@hienlh/ppm 0.23.11 → 0.23.13

package/CHANGELOG.md

@@ -1,5 +1,209 @@
 # Changelog
 
+## [0.23.13] - 2026-10-08
+
+### Added
+
+- **One click installs what Settings used to give you commands for.**
+  - **Settings → Design** installs the suggested design skill, ui-ux-pro-max 2.15.0, for each design provider you use (Claude's `~/.claude/skills`, Codex's `~/.agents/skills`) and names it in your design instructions. The result is the same as running `uipro init --global`, checked file for file, from a download pinned by checksum; a skill folder that is already there is left alone. Its scripts need Python 3, and PPM says so when the machine has none. The commands are still there under "Install it yourself instead".
+  - **Settings → Language Servers** and the editor's missing-server dialog install clangd and the Lua server by downloading the project's own release (pinned by version and SHA-256, and started once to check it runs on this machine), and Solargraph with the machine's Ruby, all into PPM's own folder; Remove deletes them again. Every server in the list now has an Install button wherever the machine can carry it out. Solargraph is not offered on Windows, and says so when a gem needs a C compiler the machine lacks.
+  - **Tailscale on Linux** and **Voice Input on a Mac**: a step that needs your password or Homebrew has a button that types its command into a PPM terminal, where you press Enter. For Tailscale one command installs, starts and lets PPM manage it, so the password is asked once; for Voice it is `brew install whisper.cpp`, and the pane carries on once whisper.cpp is there. Nothing runs until you press Enter.
+
+- **The AI can open files and show you the pages it makes, in PPM tabs.** Turn on **Settings → AI Provider → Let the AI open tabs in PPM** and Claude and Codex get two tools. Each opens a tab on the device you sent the message from: beside the chat on a desktop, or in place of the chat on a phone. PPM serves the page itself, so it works the same over a LAN address, the tunnel and a phone. Turning the setting on also turns off Claude's claude.ai Artifact tool inside PPM. It applies to new chats.
+  - **`open_file`** opens a file the way you would: code in the editor, at a line when the AI points at one, and HTML, Markdown, images, PDF and CSV in their viewers.
+  - **`open_preview`** is for what the AI made: a page, chart, report or mockup. The tab opens and the page loads. The AI then gets the page's script and loading errors, its layout problems, and a screenshot at the size the tab has on your screen, so it can fix what it sees and call again; a tab that is already open reloads in place. Tried with real Claude and Codex: each fixed a page whose chart library 404'd in one round, in 73 s (Claude) and 107 s (Codex) end to end.
+  - **HTML previews may load scripts, styles and fonts from a CDN**: cdn.tailwindcss.com, cdn.jsdelivr.net, unpkg.com, fonts.googleapis.com and fonts.gstatic.com. `fetch`/XHR still reach only the files next to the page.
+  - **Every call is a card in the chat**, such as "Preview · dashboard.html · 2 problems" or "Opened · totals.ts:20". Its **Open** button brings the tab back after you closed it, from the chat's history, or on another device.
+  - If no PPM window is showing the chat, the tool answers at once that nothing was shown and says where the file is, and the AI passes that on.
+
+- **A Logs window in place of Report Bug: read what PPM logged, see what AI made of the errors, and report a bug from the lines that show it.** The Logs button at the bottom of the rail (in the menu on a phone; Logs and Report a Bug in the command palette) opens a window on a desktop and a tab on a phone, with three tabs:
+  - **Logs** reads `ppm.log` and its rotated copies, `cloudflared.log` and the consoles of open PPM tabs as one list, sorted into AI & chat, Shell & tools, Server, Extensions, Files, Automation, Tunnel and Browser, each with its count of errors and warnings. Filter by level, tag, text (plain or a regular expression), chat and time (15 minutes, an hour, since the last restart, today, everything kept). Repeats fold into one line with a count, restarts are marked, and new lines arrive live while the window is open: Follow keeps the newest in view and stops once you select lines, so the list holds still while you pick; Pause holds them back. The list keeps its place when you go to Issues or Report and back. Select lines with click, Shift, Ctrl or a drag (on a phone, long-press one and tap the last) and add them to the current chat, a new chat or the report, or copy them; the lines in view can be saved as a `.log` file. A chat's ⋯ menu has Show logs for this chat.
+  - **Issues** is the last 24 hours of errors and warnings, grouped by cause by Claude Haiku 4.5 on your own Claude account and labelled a likely PPM bug, your setup, upstream or expected, with why and, where it can, a fix. Info lines are never sent, and secrets, home folders, email addresses and chat ids are removed first. Each issue leads to its lines, into a chat, or to a drafted report. Auto sorts new patterns at most every ten minutes and only while something is looking at them; the Logs button shows a red count of likely bugs, which can be switched off.
+  - **Report** turns the chosen lines into a GitHub issue for hienlh/ppm: a title, labels, what happened, steps and what was expected, written by you or drafted by Claude from the lines, each snippet with 5 or 20 lines of context either side if you want them, and your environment. Home folder, email addresses, chat ids and project names can be masked, secrets and quick tunnel addresses always are, and the preview marks every masked spot. Nothing is sent from PPM: Open GitHub issue opens GitHub with the report filled in for you to read and submit (copying the body instead when it is too long for a link), and open issues that look like the same problem are listed beside it.
+  - The login screen's Report Bug opens a GitHub issue holding only the PPM version and browser, since the Logs window needs signing in. `/api/logs/recent`, the log tail it used to read, needs signing in now too.
+
+- **Log levels, and a log that records what PPM did.** Every line in `~/.ppm/ppm.log` now carries one of `DEBUG`, `INFO`, `WARN`, `ERROR` or `FATAL`, and `ppm logs --level warn` shows only that level and above (with `-n` and `-f` too). `INFO` is the default; `ppm config set log_level debug` turns on the detail without a restart, and `PPM_LOG_LEVEL` pins a level for one process.
+  - Every HTTP request is logged once, with method, path, status and time — a change at `INFO`, a read at `DEBUG`, a failure at `ERROR` with the message it returned (and the stack when a handler threw) — and every WebSocket opening and closing. Secrets in query strings and preview tokens in paths are cut out.
+  - Settings changes (the field names, never the values), database creation and migrations, server start-up and shutdown are logged; a database that will not open and a port that will not bind are `FATAL` before the process exits.
+  - Each part of PPM now records what it did: every chat turn's start and end with its outcome (`success`, `aborted`, `error`, …), account token refreshes and accounts taken out of rotation, git writes (commit, push, branch, merge, …), terminals opening and exiting, Remote Desktop and Android sessions, language servers, database pools, SSH tunnels and import/export jobs, extensions (including their own console output), Task Manager kills and signals, and the supervisor's restarts, upgrades, tunnels and PPM Cloud connection — a server that keeps crashing and is given up on is `FATAL`.
+  - A helper process that dies on its own — ffmpeg, the emulator, a language server, the Codex app-server, the WebRTC relay, the extension host — is an `ERROR` with the last of its output, where it used to vanish without a trace. Failures that were caught and dropped are logged, and one that repeats on every poll is logged once and then at `DEBUG`.
+  - The log used to be 81% one streamed SDK event, which rotated everything else out within about nine hours. Per-event chatter is `DEBUG` now, and chat text, tool output and shell commands, some of which used to be written into the log, are not logged at all. Accounts are named by id, never by email.
+  - `/api/logs/recent` (the old bug report's log tail) returns only `INFO` and above, and a Telegram bot token, an ntfy topic and a Remote Desktop stream name are redacted like the other secrets. A bug report also drops a quick tunnel's address, which lets anyone reach the forwarded dev server.
+  - CLI commands write their log lines to stderr, so a command's own output (`--json`, a pipe) stays clean.
+
+- **Settings → Remote Access → Tailscale: PPM at a private address on your tailnet, with an on/off switch.** Turned on, PPM answers at `https://ppm.<your-tailnet>.ts.net` on every device signed in to your tailnet: a Tailscale Service hosted by this machine, with a real certificate and nothing opened to the internet. Tailscale decides most of the setup in its admin console, so the pane walks through it and checks each step itself: install Tailscale, let PPM manage it (Linux), sign in, turn on MagicDNS and HTTPS, tag the machine, and create the service. Each step links to the page that does it and turns green on its own once Tailscale reports the change. Signing in happens in the pane, with the sign-in link and a QR code so a phone can finish it, and a bottom sheet on a phone.
+  - Once on, the pane says whether an admin still has to approve this machine as the service's host, and gives the `autoApprovers` snippet that makes that automatic. When it is live, the address can be copied, opened or shown as a QR code.
+  - The address survives restarts and reboots: Tailscale keeps it, and PPM puts it back at start-up if it went missing. A `svc:ppm` set up by hand before this shows as on.
+  - It never takes over a name that already points somewhere else without asking, turning it off clears it only while it still points at PPM, and turning it on needs PPM's password to be on, since anyone in the tailnet could otherwise open PPM. The name (`ppm`, `ppm-mac`, …) can be changed while it is off.
+
+- **Forward a dev server and open it in a PPM tab, over Tailscale or Cloudflare.** Forward, in the sidebar's Port Forwarding panel, offers Tailscale (`https://<machine>.<tailnet>.ts.net:<port>/`, reachable from your tailnet only, at a URL that stays the same from one forward to the next) or Cloudflare (a public link), and Open in a tab shows the page inside PPM, with its toolbar under the thumb on a phone. Both go through a small hop on the host that makes the request look local to the dev server: Vite 8 listens on `[::1]` only and refuses a Host that is not localhost, so forwarding a Vite server with its defaults used to fail either way. A page that refuses to be framed (Rails and Django do by default) still shows in the tab: the hop lets the address PPM is open at frame it, and every other site is still refused. A Tailscale forward lasts as long as the `tailscale serve` process PPM runs for it, and PPM stops those when it exits, so a restart leaves no dead handler behind (only a `kill -9` of PPM itself can).
+
+- **Every file a chat changed, in one place, like Cursor's review.** A bar above the composer reads "N files changed +X −Y" for the whole session, across all its turns — the chip under each answer still covers that turn only. It opens into the file list (a bottom sheet on a phone), and Review or any file opens a Review tab that goes through the changes block by block, the way Cursor and Zed review an agent's edits: each block sits in place in its file, compared with the state the file was in *before the session first touched it*, and is kept or reverted right there. That is not git: an uncommitted edit from before the session is not counted as the session's, and a file edited in three turns is one set of blocks. The tab follows the chat while it runs and works on its own after a reload.
+  - PPM keeps that "before" itself, under `session-baselines/` in its directory, because nothing else has it: Claude Code's transcript drops a tool's `originalFile` above ~10 KB (kept at 9.8 KB, gone at 13.6 KB), and an Edit's `old_string` is a fragment. Claude's copy is taken by a PreToolUse hook just before the write, in every permission mode, sub-agents included; Codex applies a patch before PPM hears of it, so its "before" is the patch reverse-applied to the file. The first copy wins, a file over 5 MB or binary is listed without a diff, credential paths are never copied, and a session's copies go when it is deleted or after 30 days without a change.
+  - Files a Claude session changed with shell commands are listed too — a `cp`, a `sed -i`, a `printf >>`, a formatter, a `git checkout --` that threw a change away. PPM runs `git status` just before and just after each command in the repositories it can reach (its directory, the ones it `cd`s into or names, and the ones the session has written in), about 6 ms each, and a file whose status or timestamps moved in between is one the command changed. Its "before" is read ahead of the command when git already listed the file, and from HEAD otherwise. An edit committed in the same command is still found. A file git ignores or one outside any repository is not, and the list says so. Codex's shell commands are not followed yet.
+  - A session from before this falls back to git HEAD for the files its transcript names, inside the project only, and says so above its blocks.
+  - **Keep or revert, block by block.** Keep (Y) leaves a change and moves on; Revert (N) writes the block's original lines back to the file on disk at once, byte for byte (line endings and a missing last newline included), and leaves what it put back in place, dimmed. Every answer can be undone from a toast for 5 seconds, and a decided block has Change, which opens it again or undoes its revert later. J and K move between blocks across files; Keep file and Revert file… (confirmed first) answer a whole file, and a binary or very large file is only answered whole; Keep all remaining keeps everything still open. Lines are coloured like the chat's code blocks, with the changed part of each line marked. On a phone the tab shows the file in focus with Previous, Revert, Keep and Next under the thumb and the file list in a sheet; in a narrow split the list folds behind an "N files" button.
+  - **Answers are kept on the server**, so a phone and a desktop agree and a reload loses nothing. An answer applies only to the version on screen: a file the agent changed while you were reading it is left alone and drawn again. A file whose blocks are all kept is marked reviewed and leaves the bar's totals behind one "N reviewed — Show" row, as a checkbox or "Mark all reviewed" in the bar does; the bar shrinks to "All N files reviewed" once nothing is left. If the agent changes a reviewed file again it comes back as "New since review" with only the new blocks open.
+  - **Each block names the turn that wrote it.** A chip on the block ("Turn 2 · 14:03") opens the prompt that asked for the change, with Copy prompt and Show in chat, which brings the chat to the tool call and flashes it; a block two turns wrote names both. PPM records each file's state just before and just after every call that writes it — a file tool, a shell command, a Codex patch — as small deltas beside its "before", and works out which call put each line in the way `git blame` walks commits. A change no call made, such as your own edit or a formatter, names no turn.
+  - **Keep, revert, or revert a whole turn from the chat.** The pill under each answer says how that turn's edits stand ("3 edits to review", "Kept", "2 reverted"), and its tray — a sheet on a phone — keeps or reverts each edit, keeps them all, or opens the Review tab. Revert turn… shows first what it will do: what goes back in which file, a file the turn created removed, and any line a later turn changed again named and left alone ("app.ts line 2 stays as it is — Turn 2 changed it again."). It writes nothing if a file changed since that preview, leaves alone one that changes while it writes, and Undo puts it all back.
+
+- **Add selected code to chat.** Select code in the editor and Monaco's own yellow lightbulb offers Add to current chat and Add to new chat, in the same menu as a language server's quick fixes and refactorings (Ctrl+. opens it too). Selecting does not open anything by itself. The chip carries the file path, the selected line range and the editor's current text, unsaved edits included. When the line has no room for the bulb, Monaco puts it in the glyph margin left of the line numbers, which standalone Monaco turns off; it is now on, two lanes wide, with the bulb centred in it instead of pressed against the editor's edge, and the line-number column reserves three digits instead of five so the code starts where it did (2px further right). A click anywhere on the bulb opens the menu and keeps the selection.
+
+- **Add a terminal selection to chat.** Select text in a terminal and Add to current chat and Add to new chat appear right under it, as the editor offers them for a code selection (and as Cursor shows its Add to Chat). Either one adds the selection as a "Terminal selection" chip without sending anything, and clears the selection. On a phone, select in select mode; the buttons are finger-sized.
+
+- **Fix with AI and Explain with AI on errors and warnings in the editor.** Every error and warning offers both, the way Copilot's Fix and Explain do (Cursor has the first as Fix in Chat): in the lightbulb menu beside the language server's own quick fixes, each marked with a sparkle, and Fix with AI also as a one-click action in the problem's hover, next to Quick Fix. When they are the only fixes on offer, the bulb itself is a sparkle. Either one opens a new chat and sends the request at once: each problem with its line, column, source and code, then the code three lines either side as the editor has it, unsaved edits included. Explain asks for an explanation without changing any files. Hints and infos are not offered. TypeScript and most other languages report errors only while the language server is on (LSP in the editor toolbar); Monaco's own JSON and CSS checks report them either way.
+
+- **Reply to a user or AI chat message.** Select Reply to quote a completed message while keeping your draft and attachments. Quotes reach the AI on normal and mid-turn sends, survive history reloads, and remain readable if their source is unavailable. Reply drafts recover after reload or rejected sends; quote cards jump to a uniquely identified original message.
+
+- **The database sidebar is now a DBGate-style workspace, for SQLite, PostgreSQL, MySQL and MariaDB.** It was a list of connections, a table list and a read-mostly grid. It now follows DBGate's screens, one area at a time:
+  - **Connections**: a connection tab with General, Advanced, SSH Tunnel and SSL pages; Test shows the server version and its databases. A connection can **ask for its password** instead of storing it (Database Log In holds it until Disconnect), be limited to a list of databases, set the isolation level and a query timeout. The sidebar shows CONNECTIONS above TABLES, VIEWS, FUNCTIONS, with folders, status, filters and menus.
+  - **MySQL and MariaDB**: the `mysql2` driver installs from **Settings → Database Drivers** (or `ppm db driver install mysql`) rather than shipping in the binary; SSH tunnels use `ssh2` the same way.
+  - **Data grid**: DBGate's filter row and filter syntax with Set filter, Filter multiple values, Choose value and Lookup dialogs and a Filters panel; sort on several columns; 100 rows at a time with Fetch all; a Columns panel; the Rows / Count / Sum label.
+  - **Editing**: edit cells, add and delete rows, undo and redo, then **Save** shows the script and runs it in one transaction. Deleting a row other rows still point at offers **Delete references CASCADE**.
+  - **Form view (F4), Cell data and References**, including following a foreign key from a cell.
+  - **Copy advanced** in nine formats, **Generate SQL** (INSERT / UPDATE / DELETE) from selected rows, and **Export ▾** of the current view as CSV, TSV, JSON, NDJSON, SQL, XML or XLSX.
+  - **Structure tab**: add, change, rename and drop columns, keys and indexes with a preview of the DDL; new tables. SQLite changes that `ALTER TABLE` cannot express rebuild the table in SQLite's 12 documented steps.
+  - **Import/Export tab**: export several tables at once (one file each, one XLSX workbook with a sheet per table, or a zip) and import CSV, JSON or JSON-lines files into new or existing tables, as jobs you can stop.
+  - **Query tab**: runs a script one statement at a time with a **Messages** tab and a **Result** tab per statement, marks the line that failed, can go on past an error, **Stop** cancels the running statement on PostgreSQL and MySQL / MariaDB, a row limit per tab, EXPLAIN, **Format** (Shift+Alt+F: the script laid out by `sql-formatter` in the engine's own dialect, a MySQL `DELIMITER` block left as typed), a **History** panel read from the query audit log, and Ctrl+S to save the script as a `.sql` file.
+  - **On a phone**: the tree is a drawer, menus open on long-press as bottom sheets, filters and columns are sheets, a tapped row opens as a form, and Run sits in the thumb zone.
+
+- **Source Control, a new Review changes tab and the Git Graph now work as one flow: stage block by block, review, commit.** The three show the same changes, the same staged blocks and the same commit message, and an action in one shows in the others straight away.
+  - **Source Control** lists every changed file in one Changes group — staged, unstaged and new together — each with a checkbox (ticked, partly ticked or empty), a dot per block (green once staged), its +/− and its status letter. The branch row always says where the branch stands and offers the one action it needs: Push ↑n, Pull ↓n, Sync, Publish for a branch with no upstream, or Synced. The commit box adds Commit and push, Amend last commit, Commit with sign-off and Undo last commit (only while that commit is not pushed; its message goes back in the box). A merge, rebase or cherry-pick that stopped part way shows a banner with Abort and Continue, each conflict gets a Resolve that opens the conflict editor, and ticking a file that still has conflict markers asks first. Stashes (apply, pop, drop) and worktrees fold out below. On a phone the rows are 56 px, the checkboxes 48 px, and the commit box sits at the bottom, under the thumb.
+  - **Review changes** goes through what you have not committed block by block, the way the chat's session review goes through an agent's edits: Stage (Y), Discard (N), or Lines… (L) to stage single lines. J and K move between blocks across files, and the commit box is in the tab. A binary, very large or renamed file is one block for the whole file. Clicking a file in Source Control opens it here. On a phone the tab shows one block at a time with Discard and Stage at the bottom, and the file list and the commit box in sheets.
+  - **Git Graph** takes the app's colours, icons and font. A commit opens in an inspector on the right — an overlay below 900 px wide, a bottom sheet on a phone — with Checkout, Branch…, Cherry-pick, its message and its files, each with its own file-type icon. The Uncommitted changes row opens the commit box with a checkbox per file, and Review. The toolbar picks which branches are drawn, searches by message, author or hash, lists stashes and worktrees, and has Fetch, Pull ↓n and Push ↑n. A branch, tag or stash changed outside PPM, in a terminal for example, shows within the 5-second refresh instead of waiting for Refresh.
+  - **One commit message per repository**, kept on the server: what you type in one of the three boxes appears in the others, it survives a reload, and a commit from any of them clears all three.
+  - **A discard can be undone.** Discarding a block or a file shows a toast with Undo, and a discarded block keeps its Undo in the Review tab. git keeps nothing of a discarded change, so PPM keeps a copy for a day, up to 100 per repository, under `git-discards/` in its directory. Undo refuses rather than overwrite anything changed since; a file over 20 MB is not copied, and its discard says it cannot be undone.
+  - **Every view follows a change at once.** A git action made through PPM's git routes — everything in Source Control and the Review tab, and in the Git Graph its commit box, its toolbar and applying, popping or dropping a stash — tells Source Control, the Review tab, the Git Graph, the status bar and the file tree's colours to look again. The Git Graph's commit, branch and tag menus still run git themselves, and are seen at the next poll at the latest. After the Git Graph's Fetch, Pull or Push the status bar used to wait up to 10 seconds for its own poll; it now follows in about 0.6 s. The Git Graph's Fetch goes through PPM for that reason, and fetches every remote with prune.
+
+- **Push notifications to your phone or computer, switched on per device in Settings → Notifications.** It is standard Web Push: Chrome and Android deliver it through Firebase Cloud Messaging, Firefox and Safari through their own services, and PPM signs each push with its own key, so there is no Firebase project to set up. A notification says what happened and on which machine, with the detail worth reading without opening PPM — the end of the answer, the command waiting for approval, the question asked — and tapping it opens that session in the PPM window already open, or in a new one. A session has one notification at a time: a newer one replaces it. Push needs PPM on HTTPS or localhost, and on iPhone and iPad it works only once PPM is added to the Home Screen; the pane says which applies. Every device that receives push is listed with when it last got one, Send a test and Remove.
+
+- **Settings → Notifications decides what is sent and when, for push, Telegram and ntfy alike.** Each kind can be switched off (chat finished, needs approval, AI has a question, scheduled run, Jira). By default a notification waits a minute and goes out only if the chat is still unread by then: opening it on any device, or answering the approval, cancels it. "Right away" sends at once.
+
+- **Connect Telegram in one tap.** Connect Telegram makes a single-use link (with a QR code on a desktop); opening it in Telegram and pressing Start connects that chat — no pairing code to copy, and PPMBot does not have to be on. The pane walks through creating a bot with @BotFather, and a token is checked with Telegram before it is saved, so a mistyped one is refused with Telegram's reason instead of failing silently later. Telegram messages carry the same detail as push and link to the session.
+
+- **PPMBot has a Telegram bot and chats of its own, set up the way Notifications are.** Settings → PPMBot → Telegram now has the same parts as Notifications → Telegram: the bot token with the steps to create a bot in @BotFather (checked with Telegram before it is saved), a switch that turns PPMBot on and says whether it is running, the chats that can use PPMBot with Disconnect, and Connect Telegram with a single-use link and a QR code. There are no pairing codes any more: Connect Telegram is the only way in, as with Notifications, so nothing waits for approval, and a chat that writes to the bot without being connected is told once where to connect it. Notifications and PPMBot used to share one bot and one list of chats, so connecting a chat for alerts also let it command PPMBot, which runs tasks on this machine, and alerts arrived in the middle of PPMBot conversations. Now a chat connected in Notifications gets alerts and nothing else, and a chat connected in PPMBot can use PPMBot and gets no alerts. Controls are 44 px on a phone.
+  - Upgrading leaves nothing behind: every chat that got alerts still does, and a PPMBot that was on keeps answering on the bot it used, with a note in both panes suggesting a bot of its own. A PPMBot that was off starts with no bot. PPMBot's token is stored outside the config object, so nothing that shows config can reveal it.
+
+- **Notifications through ntfy**, on ntfy.sh or a server of your own. Enter the server, a topic (PPM suggests one that is hard to guess) and, for a server that requires sign-in, an access token; PPM checks that the address answers as ntfy and that the server accepts the token before saving, and saving a different server in Settings drops the token saved for the old one instead of sending it to the new one. Every phone or computer subscribed to the topic gets the same text as push, with a tap that opens the session; an approval or a question goes out at ntfy's high priority. ntfy has its own switch, Send a test, a link to the topic and a short guide, including the `upstream-base-url` setting an iPhone needs to get instant alerts from a self-hosted server.
+
+- **The System Monitor's Apps page works on Windows.** It used to say "This host does not list desktop applications". An app is now what Task Manager's Apps group shows — a process owning a visible, titled, top-level window — read over Win32 and named by its executable's own description. The page is sorted by memory, biggest first.
+
+- **The System Monitor's Services page works on Windows.** It used to say the host had no service manager; it now reads the Service Control Manager, with startup type, exit code and pid on the list and this boot's Event Log entries behind each service. One long-lived PowerShell session answers every poll rather than a process per poll.
+
+- **Remote Desktop offers each Windows monitor separately.** Windows listed one display — the whole virtual desktop — so monitors of different sizes streamed as one oversized frame holding area no screen shows. Each monitor is now its own entry to capture and control.
+
+- **An Install ffmpeg button on Remote Desktop's Windows readiness screen.** The checklist used to offer only a `winget` command to type into a terminal. It now runs the install on the host, shows its progress and WinGet's own error, and the re-check picks up the result without restarting PPM.
+
+- **A long chat opens a page at a time.** Opening a chat tab used to parse and render every message since the last compaction, which on a long session is thousands of bubbles and, on the server, minutes of CPU for a transcript in the hundreds of megabytes. History now arrives in windows, and scrolling up asks for the next one.
+
+- **An opt-in server memory monitor, `PPM_MEM_DIAG=1`.** Off unless set. It appends memory use, what grew and a few gauges to `<ppm dir>/mem-diag.log` every 30 seconds, and writes a heap snapshot the first time the heap crosses 1, 2, 4 and 8 GB — for diagnosing a server whose memory climbs.
+
+### Changed
+
+- **PPM's own public link moved from the sidebar's Tunnels panel to Settings → Remote Access, next to Tailscale; forwarding a port stays in the sidebar.** Remote Access has one sub-tab per way to reach PPM itself: Tailscale (the pane as it was) and Public link, which puts the on/off switch first, shows the link with Copy, Open and a QR code, and sets the two kinds of address side by side — a temporary trycloudflare.com one, or your own domain, set up right there. The sidebar panel, now Port Forwarding, opens with one row each for Tailscale and Cloudflare saying where it stands, and Set up (Manage once it is done) opens that service's sub-tab: signing in happens there, never in the panel. Below them it takes a port and a choice of Tailscale (your tailnet only) or Cloudflare (anyone with the link, no sign-in needed), and lists every forward with Open in a tab, Copy and Stop; a tunnel started outside PPM asks before it is stopped, and PPM's own link opens the Public link tab instead of offering Stop. Remote Access and Forward a Port in the command palette open them, on a phone too.
+- **A readonly connection is now enforced by the database itself, on every path — `ppm db query` included.** It used to be protected by a check of the SQL text alone, which let a write hidden in a function call through: `SELECT nextval('s')`, `setval`, any function that writes. PostgreSQL now runs each statement inside `BEGIN READ ONLY`, MySQL / MariaDB inside a READ ONLY transaction on a READ ONLY session, and SQLite opens a readonly handle. A statement that ran before on a readonly connection can now fail.
+- **Dates and times come back as the database prints them.** `ppm db data` and `/api/db/connections/:id/data` used to turn PostgreSQL timestamps into ISO strings in UTC; they now pass the database's own text through, as `psql` shows it. Anything that parsed the old ISO / UTC form needs updating.
+- **`verify-full` (PostgreSQL) and `VERIFY_IDENTITY` (MySQL) now check the certificate's name when the host is an IP address.** Bun did not check the name at all for an IP target, so a certificate that does not list that IP was accepted; it is now refused.
+- The separate PostgreSQL viewer and its CodeMirror SQL editor are gone: every connection, and a `.db` file opened from the file tree, uses the same data and Query tabs. `@codemirror/lang-sql` and `@uiw/react-codemirror` are no longer dependencies.
+- **Clicking a file in Source Control opens it in the Review changes tab instead of a diff.** Open diff in the file's menu still shows the whole file's diff. The list is now the default view; if you had picked the tree, it stays a tree.
+- **The Git Graph's commit details moved from the pane under the graph to an inspector on the right, and the Refs column is gone**: branch and tag labels lead the commit's subject, keep their whole names and take the colour of their line in the graph, the subject being what is cut short. Create worktree, Rebase and Interactive rebase are no longer on the commit menu — rebase is on a branch label's menu, interactive rebase in the command palette, and Add worktree… in the Worktrees menu. Refresh is in the View menu.
+- `POST /git/pull` now takes `{ rebase? }` and pulls from the branch's upstream; it no longer takes a remote or a branch. `POST /git/fetch` takes `prune`.
+- **Telegram alerts are no longer held back while a PPM tab is open.** They used to go out only when no browser was connected, so a tab left open anywhere — even in the background — meant no alert at all. They now follow the delay and unread rule in Settings → Notifications.
+
+### Fixed
+
+- **A container started from a PPM terminal or chat could restart PPM and end every session.** Under systemd, every process PPM started inherited systemd's notify socket, and systemd believed what any of them told it. `podman run` reports its container's monitor as the service's main process, so PPM "ended" when the container did, and a private `dbus-daemon` reports the service as stopping when it exits. Only the supervisor holds the socket now; the server, the edge forwarder, cloudflared and everything they start no longer get it (#38).
+
+- **The running-agents bar listed every named agent twice, and grew over the chat.** An agent given a name was reported once as an Agent card and again as a teammate, so a session that fanned out to eleven agents showed 22 rows covering the whole conversation. Each agent is one row now, and from four agents on the list scrolls inside about three rows under an "N agents running" header that folds it away: open on a desktop, folded on a phone.
+
+- **Save closed a new database connection's form.** It now stays open, as DBGate's does, as that connection's form: a second Save updates the connection instead of adding another one, and Edit on the connection brings that tab forward when it is in the focused panel. Connect still closes it.
+
+- **Account rotation sent most chats to one account.** A chat kept the account it started on for as long as it existed, so chats resumed days later all went back to it: five landed on one account in a single morning while another sat at 3%. A chat now keeps its account only while that account still holds the chat's prompt cache, which is all that staying saves, and is routed like a new chat once the cache has lapsed. Round-robin also started over at the first account after every restart, and skipped an account whenever another one dropped out of the list; it now carries on after the account it handed out last. And moving an idle Claude chat to another account in the usage panel now applies to its next message, as it already did for Codex, instead of waiting until something restarted the chat's process.
+
+- **A tool call made alongside another one lost its result when the turn ended.** The card showed a tick and nothing in it. Each block of a reply is stored as its own message, so two calls made at once sit in two messages with both results after the second, and the history reload that ends every turn put both results under the second call. Each result now stays with the call that made it.
+
+- **A chat that stopped on an error looked like it had simply finished.** A turn that hit Max Turns (500 steps for one message by default) showed its red line only until the chat reloaded its history, which happens on every reload and at the end of a long turn, and the notification still said "Chat completed". A bar above the composer now says why the last turn stopped — "Stopped after 500 steps (Max Turns)", with where the limit is set — and stays through reloads and reconnects until the next message, with a Continue button that picks the work up again. The notification for such a turn reads "Chat stopped" with the reason. The stop is read back from the session trace, because Claude's own transcript ends at the last tool result and has no record of it.
+
+- **A link into Settings did nothing while Settings was already open.** Open General in the Tailscale pane's password notice and Codex accounts & login in AI Provider did nothing at all, and Manage accounts in the chat's usage panel, or the link from a missing database driver, focused an open Settings window or tab but left it on the pane it was showing. It now moves to the pane the link names.
+
+- **A tap on a Telegram or ntfy notification opened PPM at this machine's LAN address** (`http://192.168.x.x:<port>`) whenever no Cloudflare tunnel was running: plain HTTP on an insecure origin, where the browser turns off notifications, the clipboard and the other permissions PPM asks for, and where you had to sign in again. The link now goes to the tunnel, else to PPM's Tailscale address, else to `localhost`.
+
+- **"Open in PPM" on a scheduled run's notification opened the wrong project.** The link was given the project's path where it needs the project's name, so it fell back to whichever project sorted first.
+
+- **A notification's link opened a Codex session as a Claude chat.** Links now name the session's provider, as the app's own chat URLs do.
+
+- **Extensions could read the Telegram bot token** through `workspace:config:get`. It is now withheld like PPM's other secrets.
+
+- **Scrolling up in a long chat failed with "File too large: 542MB exceeds 256MB limit".** A session that had run for five days reached 543MB and 141 compactions, and "Load previous conversation" refused the whole file on every scroll up, although the part each scroll shows is about 3MB. Only that part is parsed now: the file is scanned as bytes, as far as the end of the part, to find where the part starts and ends. The 256MB bound applies to the part parsed rather than the file.
+
+- **A Codex patch that touched several files counted only the first, and a file it created counted +0.** The chip under the answer and the transcript's change list now name every file in the patch, live and in both rollout formats, and a created or deleted file counts its lines: Codex sends those as the file's content, not as a diff.
+
+- **A refused turn said only "Invalid request sent to the API."** The API reports a refusal as an `invalid_request` error, and the chat showed the generic hint for that error. The CLI's own text in the message says what happened and what to do next (rephrase in a new session, or change the model), and it is now the error the chat shows.
+
+- **A diff on a phone was one changed line between screens of hatching.** The inline view hides the original side in a 35px column, and the diff viewer forced word wrap on it there too, so every original line was many rows tall and the visible side was padded to match. It now stays unwrapped in that mode, as Monaco keeps it itself; the Source Control diff tab had the same problem.
+
+- **Closing or switching a diff no longer throws "TextModel got disposed before DiffEditorWidget model got reset".** `@monaco-editor/react` disposes the two models before the diff editor still showing them; the viewer now detaches them first.
+
+- **A terminal could die with "double free or corruption" the first time you typed in it.** Some terminals are mounted but not on screen: the dock's active tab while the dock is hidden, and on a phone every dock terminal, because the dock is always restored collapsed there. Such a terminal was fitted to xterm's smallest size, 2 columns by 1 row, and that size went to the shell. zsh with a themed prompt corrupts its own memory redrawing that narrow. It then aborted on the first keystroke after the terminal was shown, which could be an hour later and at an ordinary size, so the crash pointed nowhere near its cause. Replaying the sequence against zsh with an oh-my-zsh + oh-my-posh config, 20 of 20 shells left at 2x1 died on that keystroke and none of the shells left at 80x24 did. A terminal is now never fitted below 20x2. The server also drops a smaller size, which covers a browser still running an older bundle. In Chrome against a scratch server, a terminal in a hidden dock gave its shell 2x1 before the fix and 80x24 after, then 140x11 once the dock was opened.
+
+- **The language server's quick fixes never appeared for an error.** The code-action request handed the server an empty list of diagnostics, and typescript-language-server finds its fixes from that list, so with LSP on an error had no Change spelling, no Add import, nothing. Measured against the real server, the same request offered no quick fix with the list empty, and Change spelling to 'answer' plus Remove unused declaration with the two diagnostics it had published. The request now carries the diagnostics touching the range, exactly as the server sent them.
+
+- **The lightbulb menu cut off its longest action** ("Move to a new…"). Monaco sizes that menu to its widest row and expects its 4px padding outside that width; Tailwind's global `box-sizing: border-box` put the padding inside, so every menu was 8px too narrow.
+
+- **New File and New Folder from a right-click menu did nothing.** In the project explorer the name box appeared and was gone about 10 ms later, so the toolbar button was the only way to create a file. Radix hands focus back to whatever held it before the menu opened — the right-clicked row — a moment after the menu closes, and does it unconditionally; the box had already taken focus, reads a blur as "done", and done with nothing typed means cancel. Rename escaped only because its box replaces the very row focus would have gone back to. The explorer window lost the same race another way: its name field focused while the menu's focus trap was still up, so it sat there unfocused and whatever was typed next went to the list behind it. A context menu now leaves focus where the chosen item put it (and still returns it to the row when the item moved it nowhere), and the window's field takes focus again once the menu has closed. In Chrome against a scratch server the box survived 0 of 5 attempts before and 5 of 5 after.
+
+- **The video player's seek bar came and went between two opens of the same file.** A video already in the media cache fires its load events before React has put the element in the page, and React drops them, so the player never learned the duration. It now reads that state from the element whenever the source changes.
+
+- **Dragging the video player's seek bar showed no frame until the release, and then the thumb jumped back.** A drag now seeks as it goes and holds a playing video still until the release (a transcoded stream still waits for the release, since each seek there is a new ffmpeg job), and the thumb stays where it was let go. The spinner fades in after 300 ms instead of flashing over every quick seek.
+
+- **On a phone, a long press that opens a menu no longer closes it when the finger lifts.** The menu opens after 400 ms, but the browser still treats a touch shorter than its own long-press delay as a tap: 500 ms by default on a phone, up to 1.5 s with a longer "Touch & hold delay". That tap landed on the menu's backdrop and closed it. This applied to every long-press menu in the app.
+
+- **On a phone, three controls outside the database screens are now 44 px touch targets:** the drawer's close button (which also had no accessible name), the version line at the foot of the drawer, and a toast's close button. Each was 17 to 32 px; the two close buttons look as they did.
+
+- **Pull failed whenever the branch had diverged from its remote.** git 2.33 and later refuse a plain `git pull` then ("Need to specify how to reconcile divergent branches") unless the repository says how to combine the two. PPM now merges, as GitHub Desktop does, when the repository sets none of `pull.rebase`, `pull.ff` or `branch.<name>.rebase`, and leaves it to git when it sets one.
+
+- **Popping or applying a stash from the Git Graph brought staged changes back unstaged.** It now restores the index too; when the staged part no longer fits, the changes come back unstaged and a toast says so.
+
+- **The conflict editor never showed the file.** It measured the space for the editor while its loading spinner was still up, found none, and never measured again.
+
+- **The Git Graph lost your place every 5 seconds.** Its refresh cleared the selected commit and the search results, and Refresh or loading more commits dropped the branch filter.
+
+- **The Git Graph drew `origin/HEAD` as a label of its own, and listed a branch called "origin".** git 2.48 and later create that pointer on every fetch; it is the remote's default branch, not a branch.
+
+- **The file tree's git colours stood still while Source Control was open.**
+
+- **On a phone, a long-press menu's sheet could be scrolled sideways by 4 px.**
+
+- **An extension panel such as the Git Graph came back in the old theme after its tab moved.** Change the theme, then split the panel, drag its tab elsewhere, or cross between the desktop and phone layouts, and the panel reloaded in the theme it had opened with and kept it until the next theme change. A panel is now told the current theme each time it loads; in Chrome the right theme was in place before the panel's first paint.
+
+- **A Claude chat could be resumed as Codex, answer "transcript was not found" and drop the message.** A session row written while marking a chat unread or claiming an account carried no provider, so every reader fell back to the install's default — which on a Codex-default install was the wrong one. The provider is recorded now.
+
+- **A long chat stopped loading its history and kept the server busy parsing.** Each state update asked the tab to refetch, and the refetch cancelled the one already on its way; on a transcript big enough that an answer takes longer than the gap between asks, none ever finished. Measured on an 85 MB transcript, it took 110 seconds a round and 368 requests piled up.
+
+- **Scrolling up in a long chat could drop the page just loaded, and lose an edit's place.** A refetch that answered after an older page had landed replaced the window with its own stale slice.
+
+- **Two Windows Store apps shared one row in the System Monitor**, because every Store app window is framed by one shared host process. End on either row killed both, and each counted the other's CPU and memory. Each app is its own row now, and a process is counted under one app only.
+
+- **A Windows service could be stopped through the API without the guard that protects critical services.** The guard and the no-op shortcuts read the last listing, which is empty until the page has been opened once and stale after any change — so a direct request could stop RPC or Audio, and a stop followed by a start answered "already running" without starting it.
+
+## [0.23.12] - 2026-10-02
+
+### Added
+- Open System Monitor from the command palette on phones and desktops.
+- Record session runs and browser console events in a retained trace that can be read back.
+- Stream Remote Desktop over HTTP through a WebRTC relay, with Wayland screen capture.
+- Run and control an opt-in Android emulator from the browser.
+
+### Improved
+- Start a new Claude chat faster by preparing its CLI while the composer is open.
+- Open tabs, floating windows, and Settings panes without a spinner once their code is loaded.
+
+### Fixed
+- File changes no longer freeze large projects or repeatedly download the file index.
+- Large file indexes walk, compress, and search off the server event loop; content search uses ripgrep when available.
+- Linux directory watching avoids per-directory descriptors and self-inflicted inotify queue overflows.
+- Release binaries include both the extension host and file index workers.
+
 ## [0.23.11] - 2026-10-01
 
 ### Added