synartesis 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 What changed, and why it mattered. Dates are release dates.
 
+## 0.6.0 — 2026-09-12
+
+### Added
+
+- **A desktop window.** You talk to a model; every tool it calls goes through
+  the same proxy the CLI installs, so what it did is journalled and reversible
+  without the window implementing any of that itself. Each call gets a card
+  naming the server, the tool, the class it was given and whether the state it
+  replaced was captured; a call that cannot be undone stops and waits for a
+  person rather than happening behind one; and "put it back" is the CLI's own
+  two steps — the real plan, then the confirmation. Claude, Gemini, Mistral,
+  OpenAI, and anything speaking `/v1/chat/completions`, which includes Ollama,
+  LM Studio and vLLM on the same machine. Keys are pasted by you and kept in the
+  OS keychain; they are never written to the journal or a log.
+
+  It is a separate download rather than part of this package: a browser engine
+  inside a CLI would put 200 MB into every install of a command that is a few
+  hundred kilobytes. Both share one journal, so either can undo what the other
+  did.
+
+- **`synartesis desktop`** opens that window if it is installed, and says where
+  to get it if it is not.
+
+### Fixed
+
+- **Opening the window no longer leaves an empty session behind.** A run is
+  begun whether or not anybody says anything, and closing one is a chain of
+  waits — each server is asked to stop, and a child process takes its time
+  going. Quitting the application ended the process partway through, so the
+  empty row survived: thirteen of them in one afternoon of testing, thirteen
+  lines of `synartesis list` between somebody and the run they were looking for.
+  The tidy-up now happens before the servers are waited on — nothing can be
+  recorded once the model's client is shut, so the count is already final — and
+  quit is held until the engine has put itself away.
+
+- **A held call explains itself in words.** An MCP server returns its errors as
+  a content envelope, and the most common reason of all — the file does not
+  exist yet, so there is nothing to keep — was reaching the screen as a wall of
+  `{"content":[{"type":"text"...` with the sentence that mattered inside it.
+
+## 0.5.2 — 2026-09-10
+
+### Changed
+
+- **The README is a third of its former length** — 714 lines to 210. It had
+  grown a full walkthrough and a manifest-authoring guide, both of which already
+  exist in the user guide, so it was three documents pretending to be one and
+  the first screen was a long way from `npm install`. What is left is the
+  argument, the two real terminal shots, install, the four classes, the commands,
+  and the limits; the walkthrough and manifest authoring are one link away.
+
+  It also documents what has shipped since it was last written: `show --live`,
+  `show --full`, `undo --force [--yes]`, `undo --replan`, the `l` key and the
+  rest of the screen's keys, `SYNARTESIS_SYNC`, and which policies are actually
+  proven against a real server rather than merely checked for tool existence.
+
+  No code changed. npm cannot refresh a package page without a version, and this
+  also carries 0.5.1's latency fix to anyone installing from npm.
+
 ## 0.5.1 — 2026-09-10
 
 ### Changed

package/README.md

@@ -23,59 +23,23 @@ tells you `update_customer` ran forty times, not what the values were before.
 
 ## What it looks like
 
-Two commands, both real. The output below was produced by
-[`./demo/filesystem-demo.sh`](demo/filesystem-demo.sh) against the official
-filesystem MCP server and pasted, not typeset.
-
-An agent overwrote a file and tried to move another. One command puts the
-first back and reports that the second never happened:
+Both shots are real output from [`./demo/filesystem-demo.sh`](demo/filesystem-demo.sh),
+pasted rather than typeset. An agent overwrote a file and tried to move another.
+One command puts the first back and reports that the second never happened:
 
 ![synartesis undo, reverting a write and skipping a gated move](https://raw.githubusercontent.com/ArhaanDev24/Synartesis/main/brand/synartesis-undo.png)
 
-`skip` is the interesting row. `move_file` is irreversible on that server, so
-it was never applied in the first place — there is nothing to undo.
+`skip` is the interesting row. `move_file` is irreversible on that server, so it
+was never applied in the first place — there is nothing to undo.
 
 Now the same damage, except a colleague edited the file before you got to the
 undo. Writing the old contents back would destroy their work, so it does not:
 
 ![synartesis undo halting on drift, showing the human's line](https://raw.githubusercontent.com/ArhaanDev24/Synartesis/main/brand/synartesis-drift.png)
 
-It stops at the record that moved and exits non-zero. Anything it had already
-put back stays put back; `synartesis show` tells you what is left.
-
-## What it can and cannot do
-
-Every tool gets one of four classifications, which you write down in a manifest:
-
-| Class | Meaning | Example | What happens |
-|---|---|---|---|
-| `readonly` | Changes nothing | `get_customer` | Recorded, forwarded |
-| `reversible` | Prior state can be restored exactly | `update_customer` | State captured before the write; written back on undo |
-| `compensable` | Cannot be reversed, but can be offset | `create_charge` | A different call neutralises it |
-| `irreversible` | Neither | `send_email` | **Suspended until a human approves it** |
-
-A tool your manifest does not mention is treated as `irreversible`. That is
-deliberate: silently forwarding an unknown destructive call is the one failure
-worth avoiding most.
-
-## Requirements
-
-| Tool | Version | Check with |
-|---|---|---|
-| Node | 22 or newer | `node --version` |
-| pnpm | 9 or newer | `pnpm --version` |
-| A C toolchain | any | `cc --version` |
-
-`pnpm` comes with Node via corepack:
-
-```bash
-corepack enable pnpm
-```
-
-The C toolchain is only needed if you build from source: npm ships a prebuilt
-SQLite binding for common platforms and installs without one. To build from a
-clone on macOS run `xcode-select --install`; on Debian or Ubuntu,
-`apt install build-essential`.
+It stops at the record that moved and exits non-zero. Anything already put back
+stays put back, and it prints the three ways on: leave it, restore the resource
+and `--replan`, or `--force` to overwrite deliberately.
 
 ## Install
 
@@ -89,612 +53,196 @@ Then, from anywhere:
 synartesis install
 ```
 
-That finds what Claude Code, Claude Desktop, Cursor or Codex already list, writes one
-policy covering all of it, and points each entry at the proxy. Servers it
-recognises get the policy that ships for them and work immediately; the rest
-are drafted with every tool held until you say how to undo it. Your config is
-copied aside first, `synartesis uninstall` puts it back, and `synartesis
-status` says what is covered.
-
-Each server keeps its own entry and its own proxy, selected with `--server`,
-so **no tool is renamed** — the agent sees exactly the names it saw before.
-
-That is for you: the screen, `undo`, `watch`, `approve`. **Your agent needs
-nothing installed** — the config block below fetches the proxy on demand.
-
-Or the script, which builds from source and links the same two commands:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/ArhaanDev24/Synartesis/main/install.sh | bash
-```
-
-Or from a clone, if you would rather read it first:
-
-```bash
-git clone https://github.com/ArhaanDev24/Synartesis.git && cd Synartesis && ./install.sh
-```
-
-The script checks your Node version, builds, and links `synartesis` and
-`synartesis-proxy` into the first writable directory already on your PATH. It
-edits no shell profile and needs no sudo. Pass `--no-link` to build only.
-
-```bash
-synartesis --help
-```
-
-If nothing could be linked, nothing breaks: every command Synartesis prints
-spells itself out in whichever form actually runs on your machine.
-
-## Walkthrough
-
-This uses a toy CRM that ships with the repo, so you can see the whole loop
-without pointing anything at real data. Run it from a scratch directory.
-
-```bash
-mkdir -p /tmp/synartesis-demo && cd /tmp/synartesis-demo
-```
-
-### 1. Write a policy
-
-`init` starts a server, asks it what tools it has, and writes a manifest.
-Replace `SYNARTESIS` with the path you cloned into.
-
-```bash
-node SYNARTESIS/dist/cli.js init crm -- node SYNARTESIS/dist/toy-crm.js --state ./crm.json
-```
+That finds what Claude Code, Claude Desktop, Cursor or Codex already list,
+writes one policy covering all of it, and points each entry at the proxy.
+Servers it recognises get the policy that ships for them and work immediately;
+the rest are drafted with every tool held until you say how to undo it. Your
+config is copied aside first, `synartesis uninstall` puts it back, and
+`synartesis status` says what is covered.
 
-For the servers most people start with — files, memory, git, github — `init`
-recognises the server and uses the finished policy bundled here, after checking
-every rule against the tools that server actually advertises. If a rule names a
-snapshot or an inverse the server does not have, the whole policy is dropped
-and you get the TODOs instead: a policy whose inverses cannot be called is
-worse than none, because it looks done.
+Each server keeps its own entry and its own proxy, so **no tool is renamed** —
+the agent sees exactly the names it saw before. **Your agent needs nothing
+installed.**
 
-The toy CRM below is deliberately not one it knows, so this walkthrough shows
-the manual path.
+Needs Node 22 or newer. npm ships a prebuilt SQLite binding, so no toolchain is
+required unless you build from a clone.
 
-`init` prints the path it wrote to. Unless a policy already sits above the
-directory you are standing in, that is `~/.synartesis/synartesis.yaml`. Open it:
-every tool that isn't a self-declared read starts as `irreversible` with a
-`TODO`. **Working through those TODOs is the job.** A finished policy for this
-fixture ships in the repo, so copy it into this directory rather than typing it
-out — a policy here takes precedence over the one in your home:
+Then just:
 
 ```bash
-cp SYNARTESIS/manifests/toy-crm.yaml ./synartesis.yaml
+synartesis
 ```
 
-Then edit the `args` line so it points at your clone and keeps its data in
-this directory. The copy ships with `args: ["dist/toy-crm.js"]`; it needs both
-the path to your clone and the `--state` file:
+One screen: what agents have done, what is held for approval, every AI on the
+machine, and undo — all on the arrow keys.
 
-```yaml
-servers:
-  crm:
-    command: node
-    args: ["SYNARTESIS/dist/toy-crm.js", "--state", "./crm.json"]
-```
+## The desktop window
 
-### 2. Point your agent at the proxy
-
-Wherever your MCP client lists servers, replace the entry for the server you
-want covered with the proxy. For Claude Desktop or Claude Code that is a
-`mcpServers` block:
-
-```json
-{
-  "mcpServers": {
-    "crm": {
-      "command": "node",
-      "args": ["SYNARTESIS/dist/proxy.js", "--manifest", "/tmp/synartesis-demo/synartesis.yaml"]
-    }
-  }
-}
-```
+The same engine, with a conversation in front of it. You talk to a model — any
+model — and every tool it calls goes through the proxy on its way out, so the
+undo is not a feature the window implements. It is one it can already offer.
 
-That spells out the clone, because this walkthrough runs from one. Outside it,
-there is nothing to install first and nothing to point at:
-
-```json
-{
-  "mcpServers": {
-    "synartesis": {
-      "command": "npx",
-      "args": ["-y", "synartesis", "proxy", "--manifest", "/Users/you/.synartesis/synartesis.yaml"]
-    }
-  }
-}
-```
+![The Synartesis desktop window: a turn that wrote a file, with the tool card showing it was captured and can be put back](https://raw.githubusercontent.com/ArhaanDev24/Synartesis/main/brand/synartesis-desktop.png)
 
-The agent sees the same tools with the same names and the same results. That is
-the point: nothing about your agent changes.
+Every call gets a card: which server, which tool, the class Synartesis gave it,
+and whether the state it replaced was captured. The ledger at the top counts the
+same thing for the whole conversation. Nothing there is a promise about what
+should have happened — it is read back out of the journal after the fact.
 
-For this walkthrough you do not need a real agent. This does the same thing:
+A call that cannot be undone does not happen behind your back. It stops, and
+waits for you, with the reason it cannot be reversed written out:
 
-```bash
-printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"demo-agent","version":"0"}}}' '{"jsonrpc":"2.0","method":"notifications/initialized"}' '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"update_customer","arguments":{"id":"c_001","plan":"free","notes":"wrong edit"}}}' '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"delete_customer","arguments":{"id":"c_002"}}}' | node SYNARTESIS/dist/proxy.js --manifest ./synartesis.yaml --journal ./journal.db > /dev/null
-```
+![A held call in the desktop window, asking whether to allow a write whose prior state could not be captured](https://raw.githubusercontent.com/ArhaanDev24/Synartesis/main/brand/synartesis-desktop-approval.png)
 
-Look at the damage:
+And putting it back is the same two steps the CLI takes: the real plan first,
+built from the journal, then the confirmation.
 
-```bash
-cat crm.json
-```
-
-Ada is on the wrong plan with the wrong notes, and Grace is gone.
-
-### 3. See what it did
-
-```bash
-node SYNARTESIS/dist/cli.js list --journal ./journal.db
-```
-
-```bash
-node SYNARTESIS/dist/cli.js show RUN_ID --journal ./journal.db
-```
+![The undo plan in the desktop window, showing one call skipped and one reverted](https://raw.githubusercontent.com/ArhaanDev24/Synartesis/main/brand/synartesis-desktop-undo.png)
 
-`show` prints each call with its class, its status, and the exact call that
-would undo it, already resolved to literal values.
+It talks to Claude, Gemini, Mistral, OpenAI, or anything speaking
+`/v1/chat/completions` — including Ollama, LM Studio and vLLM on your own
+machine, which cost nothing and send nothing anywhere. Keys are pasted by you,
+kept in the OS keychain through Electron's `safeStorage`, and never written to
+the journal or a log. There is a parchment and a dark setting:
 
-### 4. Undo it
+![The desktop window in its dark setting](https://raw.githubusercontent.com/ArhaanDev24/Synartesis/main/brand/synartesis-desktop-dark.png)
 
-Look before you leap:
+**Getting it.** `synartesis desktop` opens it, and says where to get it if it is
+not installed. It is a separate download on purpose: shipping a browser engine
+inside a CLI would put 200 MB into every install of a command that is a few
+hundred kilobytes. Until there is a signed build to download, it is built from a
+clone:
 
 ```bash
-node SYNARTESIS/dist/cli.js undo RUN_ID --dry-run --journal ./journal.db
+pnpm install && pnpm app:dist
 ```
 
-Then do it:
-
-```bash
-node SYNARTESIS/dist/cli.js undo RUN_ID --journal ./journal.db
-```
-
-```bash
-cat crm.json
-```
-
-Grace is back and Ada is on her original plan, with her original notes.
-
-### 5. Watch it refuse
-
-Undo is not a blunt instrument. If something else changed a record after the
-agent touched it, writing the old value back would destroy that work, so
-Synartesis stops and shows you both values.
-
-Run the damage command from step 2 again. That creates a second run, so take
-the run id from the top of `list`, which is ordered most recent first. Then
-edit the record by hand:
-
-```bash
-node -e 'const f="./crm.json",s=JSON.parse(require("fs").readFileSync(f));s.customers.c_001.notes="a human wrote this";require("fs").writeFileSync(f,JSON.stringify(s,null,2))'
-```
-
-```bash
-node SYNARTESIS/dist/cli.js undo RUN_ID --journal ./journal.db
-```
-
-It halts at the record that moved, prints the expected and actual state, and
-exits non-zero. It is not all-or-nothing: undo works newest first, so anything
-it had already put back before reaching the drifted record stays put back —
-here `delete_customer` is reversed and `c_002` comes back, and then it stops.
-`show` afterwards tells you which actions are still outstanding. Once you have
-resolved the conflict yourself, `undo --replan` rebuilds the plan against the
-world as it now is and carries on.
-
-## Approving what cannot be undone
-
-`send_email` is classified `irreversible`, so the agent cannot send one on its
-own. The call is **refused immediately** with an action id and the command that
-would approve it. The agent tells you, you decide, and it tries again.
-
-It does not hold the call open while waiting. That was the first design and it
-does not survive contact with a real client: every useful window for a person
-to notice, open a terminal and decide is longer than a client will wait for a
-tool, so the two cannot be reconciled by picking a better timeout.
+That writes an installer for the machine it runs on to `app/release` — a `.dmg`
+and a `.app` on macOS, an `.exe` on Windows, an AppImage and a `.deb` on Linux.
+It is unsigned, so it runs where it was built and Gatekeeper refuses it
+anywhere it has been downloaded to: signing and notarisation need an Apple
+developer account, and [`app/README.md`](app/README.md) lists the two
+environment variables that turn them on. Both the window and the terminal share
+one journal, so either can undo what the other did.
 
-Approval also does not happen on the terminal the agent is using: the proxy
-talks MCP over stdin and stdout, so there is nothing there to prompt on, and a
-desktop client has no terminal at all. The request goes to the journal, and you
-answer it from anywhere:
-
-```bash
-node SYNARTESIS/dist/cli.js gates --journal ./journal.db
-```
-
-```bash
-node SYNARTESIS/dist/cli.js approve ACTION_ID --by your-name --journal ./journal.db
-```
-
-```bash
-node SYNARTESIS/dist/cli.js deny ACTION_ID --by your-name --reason "not this one" --journal ./journal.db
-```
-
-An approval is **single use** and expires after an hour, so it covers the retry
-it was granted for and cannot quietly authorise the same call tomorrow. It is
-not tied to one session, because people restart their client and an approval
-stranded in a dead session would be no approval at all.
+## What it can and cannot do
 
-Nothing is ever approved by silence. An unanswered request simply stays
-unanswered, visible in `synartesis gates` until someone decides.
+Every tool gets one of four classifications, written down in a manifest:
 
-The agent is told all of this when it connects, so it can explain itself rather
-than reporting an opaque failure.
+| Class | Meaning | Example | What happens |
+|---|---|---|---|
+| `readonly` | Changes nothing | `get_customer` | Recorded, forwarded |
+| `reversible` | Prior state can be restored exactly | `update_customer` | State captured before the write; written back on undo |
+| `compensable` | Cannot be reversed, but can be offset | `create_charge` | A different call neutralises it |
+| `irreversible` | Neither | `send_email` | **Suspended until a human approves it** |
 
-## Real servers
+A tool your manifest does not mention is treated as `irreversible`. That is
+deliberate: silently forwarding an unknown destructive call is the one failure
+worth avoiding most.
 
-Synartesis has nothing to do with email in particular. It sits on the MCP
-protocol, so its subject is whatever the servers you have connected can do:
-your files, your repositories, your database, your tickets, your agent's own
-memory. What it can undo depends entirely on what those servers expose, and
-each manifest below says plainly where that runs out.
+## Has anybody touched it since?
 
-| Manifest | Server | State it governs |
-| --- | --- | --- |
-| [`filesystem.yaml`](manifests/filesystem.yaml) | `@modelcontextprotocol/server-filesystem` | real files on disk |
-| [`memory.yaml`](manifests/memory.yaml) | `@modelcontextprotocol/server-memory` | the knowledge graph an agent keeps about you |
-| [`git.yaml`](manifests/git.yaml) | `mcp-server-git` | a real repository's index and history |
-| [`github.yaml`](manifests/github.yaml) | `github/github-mcp-server` | issues, pull requests, file contents |
-| [`toy-crm.yaml`](manifests/toy-crm.yaml) | the fixture in this repo, not in the published package | the worked example of every class |
+Synartesis records what an agent does, not what happens to a file. Nothing you
+do by hand goes through the proxy — which is exactly what makes the drift check
+work: when undo reads a file and finds bytes it never recorded, it knows
+somebody else has been there.
 
-Every one of those but `github.yaml` was checked against the server actually
-running. Two demos run the whole loop for real:
+To ask before you find out the hard way:
 
 ```bash
-./demo/filesystem-demo.sh
-./demo/memory-demo.sh
-```
-
-The filesystem demo overwrites a file and moves another, restores both, then
-shows undo refusing when a human edited the file in between, and the gate
-refusing to create a directory this server has no way to remove.
-
-The memory demo is the sharper one. The agent adds two people to the graph, one
-of whom was already there, and the server quietly ignores the duplicate. Undo
-therefore has to remove exactly one of them: the inverse is built from what the
-server said it created, not from what the agent asked for, so the person who
-was there first survives being undone. The same session then tries to delete an
-entity and is held, because deleting an entity also deletes every relation
-touching it and one inverse call cannot put back both.
-
-### Where each one runs out
-
-The limits are the interesting part, and they are properties of the servers
-rather than of Synartesis.
-
-- **filesystem**: `move_file` is reversible from its arguments alone, so no
-  pre-read is declared and drift cannot be checked for it. `create_directory`
-  is `irreversible` not because directories are precious but because this
-  server exposes no way to remove one.
-- **memory**: `add_observations` and `delete_observations` are exact opposites
-  that disagree about what to call the same field. A path can read a field and
-  cannot rename one, so that inverse cannot be written at all and the call is
-  gated instead.
-- **git**: nearly every read this server offers answers in prose meant for a
-  person, so almost nothing can be inverted from a captured state however
-  reversible the underlying git operation is. Commits are gated because this
-  server exposes no reset, no revert, and no way to move a branch.
-
-Two things worth knowing if you write your own, both found by running these
-against live servers rather than by reading documentation:
-
-`$result` is the structured block, and it need not match the text one. The
-memory server answers `create_entities` with a bare list in its text block and
-`{"entities": [...]}` in `structuredContent`. Synartesis walks the structured
-one, because that is the machine-readable contract.
-
-And `synartesis check` proves a tool exists, not that a path resolves. It
-cannot: no call has been made, so there is no result to walk. Run the thing
-once and read `synartesis show` before you rely on an inverse.
-
-## Writing a manifest
-
-The manifest is the whole product. It should take fifteen minutes for an API
-you know.
-
-```yaml
-version: 1
-
-servers:
-  crm:
-    command: node
-    args: ["./crm-server.js"]
-
-tools:
-  - match: "crm.get_customer"
-    class: readonly
-
-  # Read the record before overwriting it, then write that record back.
-  - match: "crm.update_customer"
-    class: reversible
-    snapshot:
-      tool: "crm.get_customer"
-      args:
-        id: "$.id"
-    inverse:
-      tool: "crm.update_customer"
-      args:
-        id: "$.id"
-        name: "$snapshot.name"
-        plan: "$snapshot.plan"
-
-  # Nothing to read beforehand; the id only exists once the call returns.
-  - match: "crm.create_customer"
-    class: compensable
-    inverse:
-      tool: "crm.delete_customer"
-      args:
-        id: "$result.id"
-
-  - match: "crm.send_*"
-    class: irreversible
-    gate: always
-```
-
-There are exactly three things a value can refer to:
-
-| Prefix | Refers to | Available in |
-|---|---|---|
-| `$.` | the arguments the agent sent | `snapshot` and `inverse` |
-| `$snapshot.` | what the pre-read captured | `inverse` |
-| `$result.` | what the forward call returned | `inverse` |
-
-Anything else is a literal. A reference can stand alone, in which case the
-value keeps its type, or sit inside a sentence, in which case it is substituted
-as text:
-
-```yaml
-sha: "$result.content.sha"                 # the value itself
-message: "Revert agent change to $.path"   # text with the path substituted
-```
-
-Write `$$` for a literal dollar sign. There are no expressions, conditionals or
-functions, and there will not be: the moment this becomes a language it stops
-being something you can write in fifteen minutes.
-
-Paths can index a list with `[0]` and read one field from every element with
-`[]`:
-
-```yaml
-labels: "$snapshot.labels[].name"   # [{name: "bug"}, ...] becomes ["bug", ...]
-```
-
-That covers the common case where an API hands a field back richer than it
-takes it, which is what GitHub does with issue labels. `[]` reads the same key
-from each element and nothing else: it is still a path, not a transform. A
-reference copies values, it cannot compute them, so an API needing a genuinely
-different shape is one the inverse should leave that field out of, and say so.
-
-Other things to know:
-
-- `match` supports `*`, which matches within one segment: `crm.send_*` matches
-  `crm.send_email` but not `crm.a.b`. The most specific pattern wins regardless
-  of the order rules are written in.
-- The inverse of a patch should restore **every** field, not re-apply a patch.
-  If the same record is edited twice in one run, a partial inverse leaves the
-  fields the second edit touched behind.
-- `gate: on_write` is a heuristic for tools like a raw SQL runner, where
-  destructiveness cannot be read from the tool name. Anything it cannot
-  confidently read as a single read statement is gated. Use `gate: always`
-  wherever certainty matters.
-- A malformed manifest stops the proxy from starting, with the file and line to
-  fix. It will never run with a policy it could not understand.
-
-### Saying what absence looks like
-
-A pre-read that fails tells you nothing about *why*. MCP has no code for "not
-found", so a snapshot that comes back with an error could mean the resource was
-never there — an agent creating a file — or that it exists and could not be
-read. Those need opposite answers: the first is a call to ask a person about,
-the second is a call to refuse outright.
-
-Tell the policy what its server says when a thing is not there:
-
-```yaml
-- match: "fs.write_file"
-  class: reversible
-  snapshot:
-    tool: "fs.read_text_file"
-    args:
-      path: "$.path"
-    absent_when: ["ENOENT", "no such file"]
+synartesis show <session> --live
 ```
 
-Anything else the pre-read reports is then a failed snapshot, and the write is
-refused rather than offered for approval as a creation. Without `absent_when`,
-every error has to be read as absence, which is the safe reading but a blunt
-one. Every policy bundled here declares it.
+It reads every resource the session touched as it is now and says which still
+match. Nothing is written, no reversing call is sent, and unlike
+`undo --dry-run` it does not stop at the first conflict — five writes get five
+answers. `l` in the screen does the same.
 
-### The size of what you can snapshot
-
-Past a few megabytes a resource cannot be read back through a stdio MCP
-connection — the reply is too large to carry, and the connection closes.
-Synartesis reconnects and says so, and refuses the write rather than applying a
-change it could not capture. That is the right answer, but it does mean
-**writes to very large files are refused, not undone**. Nothing is lost; the
-call simply does not go through.
-
-Where the ceiling falls depends on the server and its transport, so no exact
-figure here would be true of every one. Measured against the bundled
-filesystem policy: a 4 MB file was captured and restored intact; 8 MB and above
-was refused with the file untouched.
+If you decide the recorded value is the one worth keeping, `undo --force` prints
+every line it would write over and stops; `--force --yes` goes ahead.
 
 ## Commands
 
+`synartesis desktop` opens [the window](#the-desktop-window), and says where to
+get it if it is not installed.
+
 | Command | Does |
 |---|---|
+| `synartesis` | The screen. Everything below can be done from it |
+| `install` / `uninstall` / `status` | Cover the clients on this machine, put them back, say what is covered |
 | `init <server> -- <cmd>` | Introspect a server and draft a manifest |
-| `list` | Every recorded run |
-| `show <runId>` | One run's timeline, with the undo for each step |
-| `show <runId> --live` | The same, plus what has changed in the world since |
-| `gates` | What is waiting for a decision |
-| `approve <actionId>` | Allow a suspended call |
-| `deny <actionId>` | Refuse one |
-| `undo <runId>` | Reverse a run, newest action first |
-| `undo <runId> --replan` | Same, but rebuild each undo from the current manifest |
-| `undo <runId> --force` | Print every change it would write over; `--yes` goes ahead |
 | `check` | Load a manifest and verify it against the servers it names |
-| `prune` | Delete runs older than 30 days and reclaim the space |
-| `close [runId]` | End a run a killed proxy left open. Nothing guesses at this: several proxies can share one journal, so a run left active is indistinguishable from one still being worked on |
-
-`--manifest` and `--journal` are found rather than typed. Both are looked for
-from the current directory upwards, the way a version control tool finds its
-root, so inside a project that has a `synartesis.yaml` every command works with
-no flags at all. When there is nothing above you either, both come from
-`~/.synartesis` — most of what anyone guards is not part of a project, and
-should not need a directory of its own. `SYNARTESIS_HOME` moves that. A journal
-that does not exist yet is placed beside the policy, so the proxy that creates
-it and the CLI that reads it agree without either being told.
-
-Other flags: `--dry-run`, `--to <seq>` and `--replan` on `undo`, `--all` on
-`approve` and `deny`, `--json` on `list`, `show` and `gates`, `--older-than
-<days>` and `--dry-run` on `prune`. `synartesis --version` prints the version
-and nothing else.
-
-Exit codes: `0` succeeded, `1` halted or refused, `2` bad usage or
-configuration.
-
-### Serving over HTTP
-
-Most clients start the proxy themselves over stdio. ChatGPT's connectors do
-not: they take a remote HTTPS endpoint and will not run a process on your
-machine. For those, serve it:
-
-```bash
-synartesis proxy --manifest ~/.synartesis/synartesis.yaml --http 9123 --token "$SYNARTESIS_TOKEN"
-```
-
-The endpoint is `/mcp` and every request needs `Authorization: Bearer <token>`.
-A token of at least 16 characters is **required** — it refuses to start without
-one — and it binds to `127.0.0.1` unless `--http-host` says otherwise, which
-warns when it is not loopback. A session that goes quiet for half an hour is
-closed; `--http-idle <seconds>` changes that.
-
-Reaching it from the internet means putting a tunnel in front of it. That is
-deliberately your decision and not a flag: what is on the other end can write
-through every server in your policy, so treat the token like a password and
-prefer a tunnel that does its own authentication.
-
-The proxy takes `--manifest`, `--journal` and `--log-level`. It also still
-accepts `--gate-timeout <seconds>`, which does nothing: a held call is refused
-immediately rather than holding the connection open, so there is no wait to cut
-short. Passing it logs a warning saying as much. It logs structured JSON to stderr; stdout is reserved for
-protocol traffic.
+| `list` | Every recorded session |
+| `show <id>` | One session's timeline, with the undo for each step |
+| `show <id> --live` | The same, plus what has changed in the world since |
+| `show <id> --full` | Every argument, snapshot and inverse, nothing elided |
+| `gates` / `approve <id>` / `deny <id>` | What is waiting, and answering it |
+| `undo <id>` | Reverse a session, newest action first |
+| `undo <id> --dry-run` | Plan it and change nothing |
+| `undo <id> --replan` | Rebuild each undo from the current manifest |
+| `undo <id> --force [--yes]` | Print what it would write over; `--yes` goes ahead |
+| `watch` | Live activity, with approvals answerable in place |
+| `prune` | Delete sessions older than 30 days and reclaim the space |
+| `close [id]` | End a session a killed proxy left open |
+
+In the screen: `enter` opens, `u` undoes, `p` previews, `l` checks the world
+now, `f` expands, `c` shows every AI on the machine, `g` shows what is held.
+
+`--manifest` and `--journal` are found rather than typed, from the current
+directory upwards the way a version control tool finds its root, then from
+`~/.synartesis`. `SYNARTESIS_HOME` moves that. `--json` works on `list`, `show`
+and `gates`. Exit codes: `0` succeeded, `1` halted or refused, `2` bad usage.
+
+**Full walkthrough, writing a manifest, and serving over HTTP for clients that
+cannot start a process:** see the [user guide](docs/synartesis-user-guide.md).
 
 ## What it does not do
 
 - **It cannot un-send what has been seen.** An email that has been read, a
   posted message, a file deleted with no backup. This is why the gate exists.
 - **Compensable actions cannot be checked for drift.** They declare no pre-read,
-  so undo compensates them and marks them `[unverified]` in its report.
+  so undo compensates them and marks them `[unverified]`.
 - **Undo halts on uncertainty, and steps over the merely permanent.** Drift, an
-  unknown outcome, or a failed reversing call stop it, because continuing past
-  those could destroy something. An action that simply cannot be undone, like a
-  sent email, is reported and left in place while everything else is reverted:
-  no amount of stopping un-sends it, and stopping would only leave the rest
-  wrong too. Either way the run is marked `partial`.
-- **A call interrupted mid-flight is recorded as unknown**, not as failed. Undo
-  refuses to walk past it, because whether it applied cannot be determined.
+  unknown outcome, or a failed reversing call stop it. An action that simply
+  cannot be undone is reported and left in place while everything else is
+  reverted. Either way the session is marked `partial`.
+- **An error is not proof that nothing happened.** A timeout or a tool-level
+  error after a write leaves the outcome *unknown*, not failed, and undo will
+  not step past it. Where a pre-read exists it is consulted to settle the
+  question instead of guessing.
 - **An undo is only as good as the policy that recorded it.** Inverses are
-  resolved when the call happens, not when you undo, so a mistake in a manifest
-  is baked into every run made under it. `undo --replan` rebuilds them from a
-  corrected manifest using the state already captured, which is the way out.
-
-## Has anybody touched it since?
-
-Synartesis records what an agent does, not what happens to a file. Nothing you
-do by hand goes through the proxy, so an edit of your own is invisible to the
-journal — and that is what makes the drift check work: when undo reads a file
-and finds bytes it never recorded, it knows somebody else has been there.
-
-The cost used to be that you found out by walking into it. You ran the undo,
-and it refused. To ask first:
-
-```bash
-synartesis show <session> --live
-```
-
-It reads every resource the session touched, as it is now, and says which of
-them still match what the run left:
-
-```
-  1  ← reversible   applied   filesystem.write_file  changed since
-       at line 13:
-       + A HUMAN WAS HERE
-       0 removed, 1 added.
-
-  1 changed since this ran; undoing would write over it
-```
-
-Nothing is written, no reversing call is sent, and no row changes status.
-Unlike `undo --dry-run`, it does not stop at the first conflict — a session
-with five writes reports on all five. `l` in the screen does the same thing.
-
-If you decide the recorded value is the one worth keeping, `undo --force`
-prints every line it would write over and stops; `--force --yes` goes ahead.
-
-## Watching it work
-
-Synartesis is not a daemon and cannot be one. An MCP client spawns a stdio
-server itself and owns its lifetime, so nothing long-running could sit in
-between and see those calls. What a person wants from a daemon is usually the
-reassurance that it is there and doing something, and that needs somewhere to
-look rather than a background process:
-
-```bash
-synartesis watch
-```
+  resolved when the call happens, so a mistake in a manifest is baked into every
+  run made under it. `undo --replan` rebuilds them from a corrected one.
 
-It redraws as the agent works: what has been called, what class each call was,
-and anything waiting on a decision, with the command to approve it. Ctrl-C
-stops it. Piped rather than run in a terminal, it prints the state once and
-exits.
+The bundled **filesystem** policy is tested against the real server: exact
+byte-for-byte restoration, drift refusal, and absence told apart from a read
+that failed. The **memory, git and github** policies are checked only for tool
+existence — their recovery guarantees are not yet proven.
 
 ## Trust
 
 A manifest names commands and Synartesis runs them. Treat one you did not write
 the way you would treat a shell script from the same source: read it first.
-There is no sandbox here, and there is not meant to be.
-
-### What the journal holds
-
-Putting a file back means having kept what was in it, so the journal is not a
-log of what happened. It is a copy of the data: the contents of every resource
-before it was written, the arguments of every call, and what each server sent
-back. A key that was sitting in a file your agent touched is in there in plain
-text. That is not a leak to be closed — it is the thing that makes undo work.
-
-So it is treated as private data. The journal is created `0600` and the
-directory Synartesis makes for it `0700`, and `0600` is re-applied every time a
-journal is opened, which closes one written by an older version the first time
-a newer one touches it. A directory that already existed is left alone, because
-a journal can sit beside a policy inside a project and silently making your
-project directory `0700` would be the worse surprise. If your `~/.synartesis`
-predates 0.3.0, `chmod 700 ~/.synartesis` is worth doing once by hand.
-
-Nothing is encrypted. Full-disk encryption answers a stolen laptop; file
-permissions answer another account on a machine you share.
-
-### How fast it grows
-
-Every write keeps the resource as it was, the resource as it became, and the
-call that did it, so the journal grows at roughly **four times the bytes your
-agent writes** and never shrinks on its own. Thirty edits of one 200 kB file
-came to 24 MB.
-
-```bash
-synartesis prune                      # runs finished more than 30 days ago
-synartesis prune --older-than 7 --dry-run
-```
-
-It deletes whole runs and then `VACUUM`s, since deleting rows leaves a SQLite
-file exactly the size it was. It will not touch a run that is still active, or
-one holding a call that is waiting on a person or whose outcome is unknown —
-age is not an answer to a question nobody answered. A pruned run cannot be
-undone afterwards, which is the whole of the trade.
 
-Nothing prunes on a timer. A tool for undoing things should not discard the
-record of what was done unless it is asked to.
+**The journal is a copy of your data, not a log.** Putting a file back means
+having kept what was in it, so the contents of every resource before it was
+written are in there in plain text — including any key that was sitting in a
+file your agent touched. That is not a leak to be closed; it is the thing that
+makes undo work. It is created `0600` in a `0700` directory, and nothing is
+encrypted: full-disk encryption answers a stolen laptop, permissions answer
+another account on a machine you share.
+
+**It grows at roughly four times the bytes your agent writes** and never shrinks
+on its own — thirty edits of one 200 kB file came to 24 MB. `synartesis prune`
+deletes whole sessions and `VACUUM`s. It will not touch one still active, or one
+holding a call waiting on a person, or one whose undo halted on a conflict. A
+pruned session cannot be undone afterwards, which is the whole of the trade.
+Nothing prunes on a timer.
+
+**Durability.** The journal runs `synchronous = NORMAL`. A crash of the process
+or of the CLI mid-undo loses nothing; only the machine losing power can cost the
+tail of the write-ahead log. `SYNARTESIS_SYNC=full` asks for an fsync per commit
+instead — worth it where fsync is cheap, and measurably not where it is not.
 
 ## Development
 

package/dist/cli.js

@@ -39,8 +39,9 @@ import {
 } from "./chunk-YVOO3PTV.js";
 
 // src/cli.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join2, resolve as resolve3 } from "path";
+import { spawn } from "child_process";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/init/draft.ts
@@ -389,6 +390,10 @@ async function rollback(options) {
   const projected = /* @__PURE__ */ new Map();
   for (const action of inScope) {
     let forcedOver;
+    if (action.class === "readonly") {
+      steps.push({ ...describeStep(action), kind: "skip", reason: "readonly", verified: true });
+      continue;
+    }
     const early = classify(action, policies !== void 0, force || dryRun);
     if (early?.kind === "halt") {
       const seen = action.error ?? "";
@@ -403,10 +408,6 @@ ${seen}` : seen;
       steps.push({ ...describeStep(action), ...early });
       continue;
     }
-    if (action.class === "readonly") {
-      steps.push({ ...describeStep(action), kind: "skip", reason: "readonly", verified: true });
-      continue;
-    }
     const rebuilt = replan(action);
     const parsedPlan = inversePlan.safeParse(rebuilt.inverse ?? action.inverse);
     if (!parsedPlan.success) {
@@ -2465,6 +2466,61 @@ async function openConsole(options) {
   }
 }
 
+// src/desktop.ts
+import { existsSync as existsSync7 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var RELEASES = "https://github.com/ArhaanDev24/Synartesis/releases";
+function candidates(platform2 = process.platform) {
+  const home = homedir2();
+  if (platform2 === "darwin") {
+    return [
+      "/Applications/Synartesis.app",
+      join2(home, "Applications/Synartesis.app")
+    ];
+  }
+  if (platform2 === "win32") {
+    const local = process.env["LOCALAPPDATA"] ?? join2(home, "AppData/Local");
+    return [
+      join2(local, "Programs/Synartesis/Synartesis.exe"),
+      join2(process.env["PROGRAMFILES"] ?? "C:/Program Files", "Synartesis/Synartesis.exe")
+    ];
+  }
+  return [
+    "/opt/Synartesis/synartesis-desktop",
+    "/usr/bin/synartesis-desktop",
+    join2(home, ".local/bin/synartesis-desktop"),
+    join2(home, "Applications/Synartesis.AppImage")
+  ];
+}
+function findDesktop(platform2 = process.platform, here = existsSync7) {
+  for (const path of candidates(platform2)) {
+    if (!here(path)) {
+      continue;
+    }
+    if (platform2 === "darwin") {
+      return { path, open: { command: "open", args: ["-a", path] } };
+    }
+    return { path, open: { command: path, args: [] } };
+  }
+  return void 0;
+}
+function whereToGetIt(platform2 = process.platform) {
+  const asset = platform2 === "darwin" ? "the .dmg for your chip (Apple silicon or Intel)" : platform2 === "win32" ? "the Windows installer" : "the AppImage or .deb";
+  return [
+    "The Synartesis desktop application is not installed.",
+    "",
+    `Download ${asset} from:`,
+    `  ${RELEASES}`,
+    "",
+    "It is a separate download on purpose. Shipping it through npm would mean",
+    "every install of this command line tool pulled a browser engine with it.",
+    "",
+    "The journal is shared either way: something the window does is undoable",
+    "here with `synartesis undo`, and the other way round."
+  ].join("\n");
+}
+
 // src/cli.ts
 var NODE_MAJOR = Number(process.versions.node.split(".")[0]);
 if (NODE_MAJOR < 22) {
@@ -2494,6 +2550,7 @@ var COMMANDS = `
                   [--journal <path>]
                   [--http <port> --token <secret>]      for a client that
                                                         cannot start one
+  synartesis desktop
   synartesis watch [--by <name>] [--journal <path>]
   synartesis approve [actionId|--all] [--by <name>] [--journal <path>]
   synartesis deny [actionId|--all] [--by <name>] [--reason <text>] [--journal <path>]
@@ -2505,6 +2562,10 @@ Cursor or Codex already list, writes a policy covering all of it -- using the on
 ship where they fit -- and points each entry at the proxy. The original config
 is copied aside first, and uninstall puts it back. status says what is covered.
 
+desktop opens the window, if it is installed. It is a separate download --
+shipping it through npm would put a browser engine inside every install of
+this command. Both share one journal, so either can undo what the other did.
+
 close ends a run left active by a proxy that was killed; nothing guesses at
 that, since several proxies can share one journal.
 
@@ -2736,7 +2797,7 @@ async function runUninstall(argv) {
 }
 function openIfPresent(journalPath) {
   try {
-    return existsSync7(journalPath) ? openJournal(journalPath, { mustExist: true }) : void 0;
+    return existsSync8(journalPath) ? openJournal(journalPath, { mustExist: true }) : void 0;
   } catch {
     return void 0;
   }
@@ -2769,7 +2830,7 @@ function runStatus(argv) {
   const journalPath = findJournal(flag(argv, "--journal"), manifestPath);
   out("");
   out(
-    `  ${style.label("policy")}   ${existsSync7(manifestPath) ? style.strong(manifestPath) : style.quiet(`${manifestPath} (none yet)`)}`
+    `  ${style.label("policy")}   ${existsSync8(manifestPath) ? style.strong(manifestPath) : style.quiet(`${manifestPath} (none yet)`)}`
   );
   out(
     `  ${style.label("journal")}  ${bytesOf(journalPath) === void 0 ? style.quiet(`${journalPath} (none yet)`) : `${style.strong(journalPath)} ${style.quiet(sizeOf(journalPath))}`}`
@@ -2822,7 +2883,7 @@ async function runInit(argv) {
   }
   const path = findManifest(flag(argv, "--manifest"));
   const force = argv.includes("--force");
-  const present = existsSync7(path);
+  const present = existsSync8(path);
   if (present && force) {
     throw new UsageError(
       `--force would discard ${path}. Delete it yourself if that is what you want; init will otherwise add to it.`
@@ -2855,17 +2916,17 @@ async function runInit(argv) {
   out("");
   return 0;
 }
-function pick(candidates, given, noun, newest = false) {
+function pick(candidates2, given, noun, newest = false) {
   const listed = (items) => items.map((item) => `  ${item.id}`).join("\n");
   if (given === void 0) {
-    const [only, ...rest2] = candidates;
+    const [only, ...rest2] = candidates2;
     if (only === void 0) {
       throw new UsageError(`there is no ${noun.one} to act on`);
     }
     if (rest2.length > 0 && !newest) {
       throw new UsageError(
-        `there are ${String(candidates.length)} ${noun.many}; name one, or use --all:
-${listed(candidates)}`
+        `there are ${String(candidates2.length)} ${noun.many}; name one, or use --all:
+${listed(candidates2)}`
       );
     }
     return only;
@@ -2873,11 +2934,11 @@ ${listed(candidates)}`
   if (given === "") {
     throw new UsageError(`no ${noun.one} was named; an empty id is usually an unset variable`);
   }
-  const exact = candidates.find((item) => item.id === given);
+  const exact = candidates2.find((item) => item.id === given);
   if (exact !== void 0) {
     return exact;
   }
-  const matches = candidates.filter((item) => item.id.startsWith(given));
+  const matches = candidates2.filter((item) => item.id.startsWith(given));
   const [first, ...rest] = matches;
   if (first === void 0) {
     throw new UsageError(`no ${noun.one} matches ${given}`);
@@ -3533,7 +3594,7 @@ var FLAGS = /* @__PURE__ */ new Set([
 function version() {
   try {
     const root = dirname3(fileURLToPath2(import.meta.url));
-    const parsed = JSON.parse(readFileSync4(join2(root, "..", "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync4(join3(root, "..", "package.json"), "utf8"));
     const found = typeof parsed === "object" && parsed !== null ? parsed.version : void 0;
     return typeof found === "string" ? found : "unknown";
   } catch {
@@ -3551,7 +3612,7 @@ function rejectUnknownFlags(argv) {
   }
 }
 function openJournalOrExplain(journalPath) {
-  if (!existsSync7(journalPath)) {
+  if (!existsSync8(journalPath)) {
     throw new UsageError(
       `nothing has been recorded yet: there is no journal at ${journalPath}. One appears the first time an agent calls a tool through synartesis proxy.`
     );
@@ -3641,7 +3702,7 @@ ${COMMANDS}`);
     });
   }
   journalArg = given === void 0 ? "" : ` --journal ${resolve3(given)}`;
-  if (!existsSync7(journalPath) && (command === "list" || command === "show" || command === "gates")) {
+  if (!existsSync8(journalPath) && (command === "list" || command === "show" || command === "gates")) {
     if (asJson) {
       out(JSON.stringify(command === "show" ? { run: null, actions: [] } : []));
       return 0;
@@ -3655,6 +3716,9 @@ ${COMMANDS}`);
     out("");
     return 0;
   }
+  if (command === "desktop") {
+    return runDesktop();
+  }
   const journal = openJournalOrExplain(journalPath);
   try {
     switch (command) {
@@ -3681,6 +3745,21 @@ ${COMMANDS}`);
     journal.close();
   }
 }
+function runDesktop() {
+  const found = findDesktop();
+  if (found === void 0) {
+    process.stderr.write(`${whereToGetIt()}
+`);
+    return 2;
+  }
+  const child = spawn(found.open.command, [...found.open.args], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  out(`opening ${found.path}`);
+  return 0;
+}
 try {
   process.exitCode = await main(process.argv.slice(2));
 } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synartesis",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "An undo layer for AI agents.",
   "type": "module",
   "private": false,
@@ -43,11 +43,18 @@
   },
   "scripts": {
     "build": "tsup",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc -p app/renderer --noEmit",
     "lint": "eslint .",
     "test": "vitest run",
     "test:watch": "vitest",
     "pretest": "tsup --silent",
+    "app": "pnpm app:build && electron app/dist/main/index.js",
+    "app:build": "tsup --config app/tsup.config.ts && vite build --config app/vite.config.ts",
+    "app:icon": "electron app/build/make-icon.mjs",
+    "app:logo": "python3 app/build/make-logo.py && pnpm app:icon",
+    "app:sandbox": "pnpm app:build && node app/dev/sandbox.mjs",
+    "app:pack": "pnpm app:build && node app/build/pack.mjs --dir",
+    "app:dist": "pnpm app:build && node app/build/pack.mjs",
     "demo": "tsup --silent && ./demo/filesystem-demo.sh",
     "demo:memory": "tsup --silent && ./demo/memory-demo.sh",
     "prepublishOnly": "tsup"
@@ -60,13 +67,27 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@anthropic-ai/sdk": "^0.125.0",
+    "@electron/notarize": "^3.1.1",
+    "@fontsource/cormorant-garamond": "^5.3.0",
+    "@fontsource/ibm-plex-mono": "^5.3.0",
+    "@fontsource/ibm-plex-sans": "^5.3.0",
+    "@google/genai": "^2.22.0",
     "@modelcontextprotocol/server-filesystem": "^2026.7.10",
     "@types/better-sqlite3": "^9.6.0",
     "@types/node": "^26.2.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.1",
+    "electron": "^44.3.0",
+    "electron-builder": "^26.15.3",
     "eslint": "^10.8.1",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.67.0",
+    "vite": "^8.3.0",
     "vitest": "^4.1.11"
   },
   "packageManager": "pnpm@9.15.9+sha512.68046141893c66fad01c079231128e9afb89ef87e2691d69e4d40eee228988295fd4682181bae55b58418c3a253bde65a505ec7c5f9403ece5cc3cd37dcf2531"