synartesis 0.3.4 → 0.4.1

package/CHANGELOG.md

@@ -2,6 +2,169 @@
 
 What changed, and why it mattered. Dates are release dates.
 
+## 0.4.1 — 2026-09-09
+
+### Added
+
+- **`synartesis show <session> --live`**, and `l` in the screen. Synartesis
+  records what an agent does, not what happens to a file — nothing you do by
+  hand goes through the proxy. That is what makes the drift check work, and it
+  meant the commonest question about this tool had no answer: has somebody
+  edited that file since? You found out by attempting an undo and having it
+  refuse.
+
+  `--live` reads every resource the session touched as it is now and says
+  which of them still match what the run left. 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.
+
+  An earlier write to a resource is reported as superseded rather than
+  changed. Undo walks backwards, so each older write is checked against a
+  state the one above it restores; measuring them all against the world as it
+  is now would call every write but the last one changed.
+
+### Fixed
+
+- **Undo acted on a session nobody was looking at.** One cursor serves four
+  views, and in the held-calls and connections lists its number counts
+  something else entirely — but `u`, `p` and `l` read it against the sessions
+  regardless. `g`, `j`, `u`, `y`, four keys pressed while looking at the list
+  of held calls, undid a session that was never on screen. That is the failure
+  this tool exists to prevent, committed by the tool. Those keys now do
+  nothing outside the session views and say why.
+
+- **`--force` showed one conflict and overwrote several.** The ask ran a
+  dry-run rollback, and a rollback halts at the first drift — so with two
+  people's edits underneath it, one diff was printed, `--force --yes` was
+  typed, and both were written over. It now reads every conflict and prints
+  each one.
+
+- **One broken server stopped you undoing anything at all.** `install` covers
+  every AI on the machine with one policy, so a manifest routinely names
+  servers that have nothing to do with the session in hand — and undo started
+  all of them. An entry whose command is not there made every session
+  unreadable and unundoable. Undo and `--live` now start only the servers the
+  session actually went to, and skip with a reported reason any that still
+  will not start. `--replan` still starts everything, since it re-resolves
+  inverses from the current policy.
+
+- **`--force` ignored `--to`.** A change below the floor — an action the undo
+  would not touch — refused the whole command.
+
+- The overwrite warning in the screen now expires with the diff that
+  justified it, so the second `u` cannot be answered after the evidence has
+  scrolled away. `--yes` without `--force` says it is being ignored rather
+  than being silently dropped, and `--live` no longer starts every server to
+  inspect a session that recorded nothing.
+
+## 0.4.0 — 2026-09-08
+
+### Added
+
+- **`synartesis install`.** One command wraps every server your MCP client
+  already lists. It knows Claude Code, Claude Desktop, Cursor and Codex, finds
+  their config files, writes a policy covering everything it finds — adopting
+  the bundled policies where they fit — and points each entry at the proxy.
+  `uninstall` puts the configs back; `status` says what is covered.
+
+  Setting a single server up used to mean reading your client's JSON, retyping
+  the command into `init`, hand-editing the policy, then editing the JSON back.
+  Two hand edits across two files, per server, which is most of the reason
+  anyone gave up before seeing an undo work.
+
+  Your config is copied aside first, the write lands by rename rather than in
+  place, a file that does not parse is refused rather than repaired, and every
+  key we do not recognise is carried through. Codex's TOML is edited by line so
+  its comments, ordering and env subtables survive.
+
+- **A connections screen**, on `c` in `synartesis`. Every AI on the machine,
+  whether its config points here, and when anything last actually came through
+  it — read from the journal, which records the server on every action, rather
+  than guessed from processes. `enter` connects one, `a` connects everything
+  uncovered, `r` rescans. Nothing is written without a keypress.
+
+- **`--server <name>` on the proxy**, so one policy can back several client
+  entries. A proxy carrying two servers has to qualify tool names to tell them
+  apart, which renames every tool the agent already knows; one entry per server
+  keeps the names.
+
+- **`synartesis show <session> --full`**, and `f` in the screen: every argument,
+  the captured snapshot and the inverse, pretty-printed with nothing elided.
+
+### Fixed
+
+- **A tool a client would not call at all.** The official filesystem server
+  declares its `outputSchema` as JSON Schema draft-07, and a client whose
+  validator only knows 2020-12 refuses to call the tool — nothing reaches the
+  proxy, and there is nothing in the journal to explain the silence. The
+  dialect is now dropped from advertised output schemas. `inputSchema` is
+  untouched, so the tool list is byte-identical wherever a server declares no
+  output schema.
+
+- **Times are shown where you are standing.** The journal stores UTC, which is
+  right, and every view printed that UTC string unchanged — so somebody in
+  Kolkata watching an agent work saw 10:05 while their own clock said 15:35.
+
+### Changed
+
+- **Actions read as sentences.** `10:36:56 reversible rolled_back
+  sim.edit_file`, twelve times over, is a class and a status and never once
+  which file. Rows now say the server, the tool, what it acted on and what it
+  means: `15:36:56 sim edit_file loadtest.mjs undone`. Arguments are summarised
+  rather than truncated JSON; `--full` shows everything.
+
+- **`synchronous = NORMAL` under WAL.** Measured on the journal alone: writes
+  0.188 → 0.125 ms per action, rollback marks 0.079 → 0.039 ms. A crash of the
+  process still loses nothing; only the machine going down can cost the tail of
+  the WAL, and what is there is the record of a call, never the call.
+
+- Headings and names are a softer ink. Bold near-white smears at terminal
+  sizes, and the palette only works if one thing is bright.
+
+- **A halt says what it refused, not only that it stopped.** `halted: halted
+  here on an earlier attempt` explains nothing; the sentence worth reading is
+  the one saying somebody edited the resource since. And a dry run now re-reads
+  the world rather than quoting the message from the last attempt — that halt
+  exists so a retry cannot silently repeat what a person stopped, and a dry run
+  writes nothing, so it is not a retry.
+
+- **Undo says which session, before acting on it.** Without an id it takes the
+  most recent, which is not necessarily the one on your screen — somebody undid
+  a session they were not looking at and read the result as the tool acting on
+  its own. It now names its pick first, and where that session is empty it says
+  so and names the one that did something.
+
+### Fixed (undo, from using it)
+
+- **`u` in the screen appeared to do nothing.** A client that connects and calls
+  nothing still opens a session, so the newest one is regularly empty while the
+  one you mean is a line below it. Pressing undo on it confirmed, reverted zero
+  and said nothing about why. `u` and `p` now count what could actually be put
+  back first, and answer with the reason and the id of the session that has
+  something.
+
+- **The screen prints the command for what `u` would do**, for the session under
+  the cursor: `synartesis undo <id>`. A screen that only answers keystrokes
+  gives you nothing to carry to another window and nothing to check when a key
+  seems to have done nothing.
+
+### Added (drift)
+
+- **`undo --force`**, for a resource somebody changed after the run. Asked for
+  twice: on its own it reads the world, prints the lines it would write over,
+  and writes nothing; `--force --yes` goes ahead. Two flags rather than a
+  prompt, so it reads the same in a terminal and in a script.
+
+  A refusal with no way past it is half an answer. The halt now carries what
+  undoing would overwrite — not only what changed since the run, which is
+  history, but which of *your* lines would go — and prints the three ways on as
+  three commands: leave it, put the resource back and `--replan`, or `--force`.
+
+  In the screen, a conflicted session says so and names the command. `u` shows
+  the overwrite diff, and only a second `u` will offer to do it, with `y` still
+  required after that.
+
 ## 0.3.4 — 2026-09-03
 
 ### Changed

package/README.md

@@ -83,6 +83,22 @@ clone on macOS run `xcode-select --install`; on Debian or Ubuntu,
 npm install -g synartesis
 ```
 
+Then, from anywhere:
+
+```bash
+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.
 
@@ -510,11 +526,13 @@ was refused with the file untouched.
 | `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 |
@@ -582,6 +600,39 @@ protocol traffic.
   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

package/dist/{chunk-LNR5GXPG.js → chunk-FOA4UIDE.js}

@@ -4,9 +4,10 @@ import {
   SnapshotError,
   UpstreamError,
   describe
-} from "./chunk-WNLRMSDB.js";
+} from "./chunk-YVOO3PTV.js";
 
 // src/invocation.ts
+import { spawnSync } from "child_process";
 import { accessSync, constants } from "fs";
 import { basename, delimiter, join } from "path";
 import { fileURLToPath } from "url";
@@ -57,6 +58,17 @@ function proxyCommand() {
   }
   return `node ${fileURLToPath(new URL("cli.js", import.meta.url))} proxy`;
 }
+function pathBinaryMatches(ourVersion) {
+  if (!onPath("synartesis")) {
+    return false;
+  }
+  try {
+    const result = spawnSync("synartesis", ["--version"], { encoding: "utf8", timeout: 1e4 });
+    return result.status === 0 && result.stdout.trim() === ourVersion;
+  } catch {
+    return false;
+  }
+}
 
 // src/locate.ts
 import { existsSync } from "fs";
@@ -115,7 +127,7 @@ function findJournal(given, manifest) {
 var ESC = "\x1B[";
 var ACCENT = `${ESC}38;2;226;134;118m`;
 var ON_ACCENT = `${ESC}48;2;94;20;32m${ESC}38;2;246;233;229m`;
-var BRIGHT = `${ESC}38;2;246;233;229m`;
+var INK = `${ESC}38;2;214;201;197m`;
 var DIM = `${ESC}2m`;
 var BOLD = `${ESC}1m`;
 var RESET = `${ESC}0m`;
@@ -129,9 +141,9 @@ function spaced(text) {
 var style = {
   /** A section label: small, capital, spaced out. */
   label: (text) => paint(ACCENT + DIM, spaced(text.toUpperCase())),
-  heading: (text) => paint(BRIGHT + BOLD, text.toUpperCase()),
+  heading: (text) => paint(INK, text.toUpperCase()),
   accent: (text) => paint(ACCENT, text),
-  strong: (text) => paint(BOLD, text),
+  strong: (text) => paint(INK, text),
   quiet: (text) => paint(DIM, text),
   /** Off-white on oxblood, the way the wordmark is set. */
   plate: (text) => paint(ON_ACCENT + BOLD, ` ${text} `)
@@ -327,6 +339,7 @@ function openDatabase(path) {
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
     db.pragma("busy_timeout = 5000");
+    db.pragma("synchronous = NORMAL");
     if (path !== ":memory:") {
       restrictToOwner(path);
     }
@@ -1451,6 +1464,7 @@ export {
   cliCommand,
   cliCommandFrom,
   proxyCommand,
+  pathBinaryMatches,
   findManifest,
   findJournal,
   style,
@@ -1479,4 +1493,4 @@ export {
   observeState,
   connectStdioUpstream
 };
-//# sourceMappingURL=chunk-LNR5GXPG.js.map
+//# sourceMappingURL=chunk-FOA4UIDE.js.map

package/dist/{chunk-WNLRMSDB.js → chunk-YVOO3PTV.js}

@@ -95,15 +95,17 @@ function brief(value) {
     return "(a value too deeply nested to print)";
   }
 }
+function changedLines(expected, actual) {
+  const before = longestString(expected);
+  const after = longestString(actual);
+  return before !== "" && after !== "" && before !== after ? lineDiff(before, after) : `  expected: ${brief(expected)}
+  actual:   ${brief(actual)}`;
+}
 var DriftConflict = class extends SynartesisError {
   constructor(seq, expected, actual) {
-    const before = longestString(expected);
-    const after = longestString(actual);
-    const body = before !== "" && after !== "" && before !== after ? lineDiff(before, after) : `  expected: ${brief(expected)}
-  actual:   ${brief(actual)}`;
     super(
       `drift at sequence ${String(seq)}: the resource is not in the state this run left it in.
-${body}`
+` + changedLines(expected, actual)
     );
     this.seq = seq;
     this.expected = expected;
@@ -140,9 +142,10 @@ export {
   ManifestError,
   UpstreamError,
   SnapshotError,
+  changedLines,
   DriftConflict,
   RollbackHalted,
   JournalError,
   describe
 };
-//# sourceMappingURL=chunk-WNLRMSDB.js.map
+//# sourceMappingURL=chunk-YVOO3PTV.js.map