synartesis 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 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

package/README.md

@@ -526,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 |
@@ -598,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/cli.js

@@ -553,11 +553,11 @@ function describeStep(action) {
   return { seq: action.seq, server: action.server, tool: action.tool };
 }
 function overwriteText(current, action) {
-  const intended = intendedAfterInverse(action);
-  if (intended === void 0) {
+  const intended2 = intendedAfterInverse(action);
+  if (intended2 === void 0) {
     return "";
   }
-  return changedLines(current, intended);
+  return changedLines(current, intended2);
 }
 function intendedAfterInverse(action) {
   return action.snapshot === void 0 ? void 0 : { present: true, value: action.snapshot };
@@ -595,6 +595,98 @@ async function executeInverse(router, plan, idempotencyKey, signal) {
   return { ok: true };
 }
 
+// src/rollback/inspect.ts
+import { z as z3 } from "zod";
+var inversePlan2 = z3.object({
+  server: z3.string(),
+  tool: z3.string(),
+  args: z3.record(z3.string(), z3.unknown())
+});
+var observation2 = z3.union([
+  z3.object({ present: z3.literal(true), value: z3.unknown() }),
+  z3.object({ present: z3.literal(false) })
+]);
+function sameState2(a, b) {
+  return canonical(a) === canonical(b);
+}
+function intended(action) {
+  return action.snapshot === void 0 ? void 0 : { present: true, value: action.snapshot };
+}
+function resourceKey(plan) {
+  return canonical({ server: plan.server, tool: plan.tool, args: plan.args });
+}
+var SETTLED = /* @__PURE__ */ new Set(["failed", "denied", "gated", "approved"]);
+async function inspect(options) {
+  const { journal, router, runId } = options;
+  const signal = options.signal ?? new AbortController().signal;
+  const actions = journal.getActions(runId);
+  const resources = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const action of [...actions].reverse()) {
+    const at = { seq: action.seq, server: action.server, tool: action.tool };
+    if (action.class === "readonly") {
+      continue;
+    }
+    if (SETTLED.has(action.status)) {
+      resources.push({ ...at, condition: "not-applied", note: action.status });
+      continue;
+    }
+    if (action.status === "rolled_back") {
+      resources.push({ ...at, condition: "restored" });
+      continue;
+    }
+    const verify = inversePlan2.safeParse(action.verify);
+    const post = observation2.safeParse(action.postSnapshot);
+    if (!verify.success || !post.success) {
+      resources.push({
+        ...at,
+        condition: "unknowable",
+        note: action.inverse === void 0 ? "nothing was captured to restore" : "no pre-read was declared"
+      });
+      continue;
+    }
+    const key = resourceKey(verify.data);
+    if (seen.has(key)) {
+      resources.push({ ...at, condition: "superseded" });
+      continue;
+    }
+    seen.add(key);
+    let current;
+    try {
+      current = await observeState(router, verify.data, signal);
+    } catch (error) {
+      resources.push({ ...at, condition: "unknowable", note: `could not read it: ${describe(error)}` });
+      continue;
+    }
+    if (sameState2(current, post.data)) {
+      resources.push({ ...at, condition: "unchanged" });
+      continue;
+    }
+    const back = intended(action);
+    if (back !== void 0 && sameState2(current, back)) {
+      resources.push({ ...at, condition: "restored", note: "put back outside this journal" });
+      continue;
+    }
+    resources.push({
+      ...at,
+      condition: "changed",
+      diff: changedLines(post.data, current)
+    });
+  }
+  return { runId, resources: resources.reverse() };
+}
+function verdict(inspection) {
+  const changed = inspection.resources.filter((r) => r.condition === "changed").length;
+  const undoable = inspection.resources.filter((r) => r.condition === "unchanged").length;
+  if (changed > 0) {
+    return `${String(changed)} changed since this ran; undoing would write over ${changed === 1 ? "it" : "them"}`;
+  }
+  if (undoable > 0) {
+    return `nothing has been touched since; all ${String(undoable)} would undo cleanly`;
+  }
+  return "nothing here is still applied";
+}
+
 // src/watch.ts
 import { existsSync as existsSync2 } from "fs";
 
@@ -1868,13 +1960,14 @@ function footer(screen, options) {
     return ["", `  ${style.accent(what)}  ${keyHint2("y", "yes")}   ${keyHint2("n", "no")}`];
   }
   const keys = screen.mode === "connections" ? [keyHint2("enter", "connect"), keyHint2("a", "connect all"), keyHint2("r", "rescan"), keyHint2("j/k", "move"), keyHint2("h", "back")] : screen.mode === "gates" ? [keyHint2("a", "approve"), keyHint2("d", "deny"), keyHint2("j/k", "move"), keyHint2("r", "runs")] : screen.mode === "run" ? [
+    keyHint2("l", "check now"),
     keyHint2("p", "preview undo"),
     keyHint2("u", "undo"),
-    keyHint2("esc", "back"),
-    keyHint2("g", "held")
+    keyHint2("f", "expand"),
+    keyHint2("esc", "back")
   ] : [
     keyHint2("enter", "open"),
-    keyHint2("p", "preview undo"),
+    keyHint2("l", "check now"),
     keyHint2("u", "undo"),
     keyHint2("j/k", "move"),
     keyHint2("g", "held")
@@ -1962,6 +2055,7 @@ async function openConsole(options) {
       ""
     ].join("\n");
   };
+  const onASession = () => screen.mode === "runs" || screen.mode === "run";
   const selectedRun = (ready) => {
     if (screen.mode === "run" && screen.openRun !== void 0) {
       return ready.getRun(screen.openRun);
@@ -2049,6 +2143,28 @@ async function openConsole(options) {
       screen.busy = void 0;
     }
   };
+  const look = async (runId) => {
+    if (options.check === void 0) {
+      say("no way to read the current state was configured");
+      return;
+    }
+    screen.busy = "reading how things are now...";
+    try {
+      const found = await options.check(runId);
+      const changed = found.resources.filter((one) => one.condition === "changed");
+      say(
+        [
+          verdict(found),
+          ...changed.length === 0 ? [] : ["", ...changed.flatMap((one) => [`${String(one.seq)}  ${one.server}.${one.tool}`, ...(one.diff ?? "").split("\n")])]
+        ].join("\n"),
+        changed.length === 0 ? NOTICE_TICKS2 : READING_TICKS
+      );
+    } catch (error) {
+      say(error instanceof Error ? error.message : "could not read the current state");
+    } finally {
+      screen.busy = void 0;
+    }
+  };
   const rescan = () => {
     screen.groups = options.scan?.() ?? [];
   };
@@ -2160,7 +2276,26 @@ async function openConsole(options) {
           decide(false);
         }
         return;
+      case "l": {
+        if (!onASession()) {
+          return;
+        }
+        if (screen.busy !== void 0) {
+          say("still working on the last one");
+          return;
+        }
+        const ready = open();
+        const run = ready === void 0 ? void 0 : selectedRun(ready);
+        if (ready === void 0 || run === void 0) {
+          return;
+        }
+        void look(run.id);
+        return;
+      }
       case "p": {
+        if (!onASession()) {
+          return;
+        }
         const ready = open();
         const run = ready === void 0 ? void 0 : selectedRun(ready);
         if (ready === void 0 || run === void 0) {
@@ -2175,6 +2310,10 @@ async function openConsole(options) {
         return;
       }
       case "u": {
+        if (!onASession()) {
+          say("undo works on a session; r for the list");
+          return;
+        }
         if (screen.busy !== void 0) {
           say("still working on the last one");
           return;
@@ -2241,6 +2380,7 @@ async function openConsole(options) {
     for (; !screen.stop; tick += 1) {
       if (screen.notice !== "" && tick >= screen.noticeUntil) {
         screen.notice = "";
+        screen.warned = void 0;
       }
       options.write(clear + frame());
       if (options.maxTicks !== void 0 && tick + 1 >= options.maxTicks) {
@@ -2289,7 +2429,7 @@ var COMMANDS = `
   synartesis init <server> -- <command> [args...]  [--manifest <path>]
   synartesis check [--manifest <path>]
   synartesis list [--journal <path>]
-  synartesis show <runId> [--full] [--journal <path>]
+  synartesis show <runId> [--full] [--live] [--journal <path>]
   synartesis gates [--journal <path>]
   synartesis close [runId] [--journal <path>]
   synartesis prune [--older-than <days>] [--dry-run] [--journal <path>]
@@ -2329,6 +2469,7 @@ resource back as the run left it and --replan, or --force to overwrite.
   --client    claude-code, claude-desktop, cursor or codex; all by default
   --print     show the entries install would write, and write nothing
   --full      show every argument, snapshot and inverse in full, nothing elided
+  --live      read each resource as it is now and say what has changed since
   --server    serve one server from the manifest, keeping its tool names
   --manifest  synartesis.yaml, looked for here and upwards, then in the home
   --journal   beside the manifest, or the one in the home
@@ -2743,13 +2884,24 @@ function runList(journal, asJson, journalPath) {
   }
   return 0;
 }
-function runShow(argv, journal, asJson) {
+async function runShow(argv, journal, asJson) {
   const full = argv.includes("--full");
   const runs = [...journal.listRuns()].reverse();
   const run = pick(runs, positional(argv)[1], RUN, true);
   const runId = run.id;
+  const inspection = argv.includes("--live") && journal.getActions(runId).length > 0 ? await withUpstreams(
+    findManifest(flag(argv, "--manifest")),
+    async (router) => await inspect({ journal, router, runId }),
+    serversUsedBy(journal, runId)
+  ) : void 0;
   if (asJson) {
-    out(JSON.stringify({ run, actions: journal.getActions(runId) }));
+    out(
+      JSON.stringify({
+        run,
+        actions: journal.getActions(runId),
+        ...inspection === void 0 ? {} : { live: inspection.resources }
+      })
+    );
     return 0;
   }
   out("");
@@ -2772,10 +2924,17 @@ function runShow(argv, journal, asJson) {
   out(`  ${style.label("timeline")}`);
   out(`  ${rule(72)}`);
   out("");
+  const live = new Map((inspection?.resources ?? []).map((found) => [found.seq, found]));
   for (const action of actions) {
+    const now = live.get(action.seq);
     out(
-      `  ${style.quiet(String(action.seq).padStart(3))}  ${badgeOf(action)} ${statusOf(action)}  ${style.strong(`${action.server}.${action.tool}`)}`
+      `  ${style.quiet(String(action.seq).padStart(3))}  ${badgeOf(action)} ${statusOf(action)}  ${style.strong(`${action.server}.${action.tool}`)}` + (now === void 0 ? "" : `  ${conditionOf(now)}`)
     );
+    if (now?.diff !== void 0) {
+      for (const line2 of now.diff.split("\n")) {
+        out(`       ${style.quiet(line2)}`);
+      }
+    }
     if (full) {
       out(`       ${style.quiet("arguments")}`);
       for (const line2 of block(action.args)) {
@@ -2812,9 +2971,40 @@ function runShow(argv, journal, asJson) {
   }
   out("");
   out(`  ${summarise2(actions)}`);
+  if (inspection !== void 0) {
+    out("");
+    const spoiled = inspection.resources.some((found) => found.condition === "changed");
+    out(`  ${spoiled ? style.accent(verdict(inspection)) : style.quiet(verdict(inspection))}`);
+    if (spoiled) {
+      out(
+        `  ${style.quiet("undo stops at the first of them; ")}${style.strong(`${cliCommand()} undo ${runId.slice(0, 8)} --force`)}${style.quiet(" shows what it would write")}`
+      );
+    }
+  } else {
+    out("");
+    out(
+      `  ${style.quiet("has anything changed since? ")}${style.strong(`${cliCommand()} show ${runId.slice(0, 8)} --live`)}`
+    );
+  }
   out("");
   return 0;
 }
+function conditionOf(found) {
+  switch (found.condition) {
+    case "changed":
+      return style.accent("changed since");
+    case "unchanged":
+      return style.quiet("unchanged");
+    case "restored":
+      return style.quiet(found.note === void 0 ? "back to before" : `back to before, ${found.note}`);
+    case "superseded":
+      return style.quiet("older write to the same thing");
+    case "not-applied":
+      return style.quiet(`never applied (${found.note ?? "settled"})`);
+    default:
+      return style.quiet(found.note ?? "cannot tell");
+  }
+}
 var CLASS_MARK = {
   readonly: "\xB7",
   reversible: "\u2190",
@@ -3105,45 +3295,63 @@ function report(result, alreadyForcing = false) {
   out("");
   return result.status === "rolled_back" ? 0 : 1;
 }
-async function performUndo(manifestPath, journal, runId, options) {
+async function withUpstreams(manifestPath, use, only) {
   const manifest = loadManifest(manifestPath);
   const upstreams = [];
+  const missing = [];
   try {
     for (const [name, spec] of Object.entries(manifest.servers)) {
-      upstreams.push(
-        await connectStdioUpstream({
-          name,
-          command: spec.command,
-          args: spec.args,
-          stderr: "capture",
-          ...spec.env === void 0 ? {} : { env: spec.env }
-        })
-      );
-    }
-    const base = {
-      journal,
-      router: createRouter(upstreams, manifest),
-      runId,
-      ...options.toSeq === void 0 ? {} : { toSeq: options.toSeq },
-      ...options.replan === true ? { replanWith: manifest } : {}
-    };
-    if (options.preflight === true) {
-      const seen = await rollback({ ...base, dryRun: true });
-      if (seen.halted?.conflict === true) {
-        return seen;
+      if (only !== void 0 && !only.has(name)) {
+        continue;
+      }
+      try {
+        upstreams.push(
+          await connectStdioUpstream({
+            name,
+            command: spec.command,
+            args: spec.args,
+            stderr: "capture",
+            ...spec.env === void 0 ? {} : { env: spec.env }
+          })
+        );
+      } catch (error) {
+        missing.push(`${name}: ${describe(error)}`);
       }
     }
-    return await rollback({
-      ...base,
-      dryRun: options.dryRun,
-      ...options.force === true ? { force: true } : {}
-    });
+    if (upstreams.length === 0 && missing.length > 0) {
+      throw new ManifestError(`no server could be started. ${missing.join("; ")}`);
+    }
+    for (const why of missing) {
+      process.stderr.write(`synartesis: ${why}; anything through it cannot be reached
+`);
+    }
+    return await use(createRouter(upstreams, manifest), manifest);
   } finally {
     for (const upstream of upstreams) {
       await upstream.close();
     }
   }
 }
+function serversUsedBy(journal, runId) {
+  return new Set(journal.getActions(runId).map((action) => action.server));
+}
+async function performUndo(manifestPath, journal, runId, options) {
+  return await withUpstreams(
+    manifestPath,
+    async (router, manifest) => await rollback({
+      journal,
+      router,
+      runId,
+      ...options.toSeq === void 0 ? {} : { toSeq: options.toSeq },
+      ...options.replan === true ? { replanWith: manifest } : {},
+      dryRun: options.dryRun,
+      ...options.force === true ? { force: true } : {}
+    }),
+    // A replan re-resolves inverses from the current policy, which may name a
+    // server this run never used; everything else needs only what it touched.
+    options.replan === true ? void 0 : serversUsedBy(journal, runId)
+  );
+}
 async function runUndo(argv, journal) {
   const given = positional(argv)[1];
   const chosen = pick([...journal.listRuns()].reverse(), given, RUN, true);
@@ -3195,21 +3403,48 @@ async function runUndo(argv, journal) {
   }
   const forcing = argv.includes("--force");
   const said = argv.includes("--yes");
-  const result = await performUndo(findManifest(flag(argv, "--manifest")), journal, runId, {
-    dryRun: argv.includes("--dry-run"),
-    ...toSeq === void 0 ? {} : { toSeq },
-    replan: argv.includes("--replan"),
-    ...forcing ? { force: said, preflight: !said } : {}
-  });
-  const code = report(result, forcing);
-  if (forcing && !said && result.halted?.conflict === true) {
-    out(`  ${style.quiet("nothing has been written. To go ahead and lose that change:")}`);
-    out(
-      `  ${style.strong(`${cliCommand()} undo ${runId.slice(0, 8)} --force --yes`)}`
+  const manifestPath = findManifest(flag(argv, "--manifest"));
+  if (said && !forcing) {
+    process.stderr.write("synartesis: --yes only means anything with --force; ignoring it\n");
+  }
+  if (forcing && !said) {
+    const over = (await withUpstreams(
+      manifestPath,
+      async (router) => await inspect({ journal, router, runId }),
+      serversUsedBy(journal, runId)
+    )).resources.filter(
+      // Below --to nothing is undone, so a change down there is not something
+      // this command would write over and must not stand in its way.
+      (one) => one.condition === "changed" && (toSeq === void 0 || one.seq >= toSeq)
     );
-    out("");
+    if (over.length > 0) {
+      out("");
+      out(
+        `  ${style.accent(`${String(over.length)} changed since this ran`)}  ` + style.quiet(`undoing would write over ${over.length === 1 ? "it" : "them"}`)
+      );
+      for (const one of over) {
+        out("");
+        out(`  ${style.quiet(String(one.seq).padStart(3))}  ${style.strong(`${one.server}.${one.tool}`)}`);
+        for (const line2 of (one.diff ?? "").split("\n")) {
+          out(`       ${style.quiet(line2)}`);
+        }
+      }
+      out("");
+      out(`  ${style.quiet("nothing has been written. To go ahead and lose that:")}`);
+      out(`  ${style.strong(`${cliCommand()} undo ${runId.slice(0, 8)} --force --yes`)}`);
+      out("");
+      return 1;
+    }
   }
-  return code;
+  return report(
+    await performUndo(manifestPath, journal, runId, {
+      dryRun: argv.includes("--dry-run"),
+      ...toSeq === void 0 ? {} : { toSeq },
+      replan: argv.includes("--replan"),
+      ...forcing && said ? { force: true } : {}
+    }),
+    forcing
+  );
 }
 var FLAGS = /* @__PURE__ */ new Set([
   // Two lists have to agree about a flag: this one decides whether it is
@@ -3219,6 +3454,7 @@ var FLAGS = /* @__PURE__ */ new Set([
   "--client",
   "--print",
   "--full",
+  "--live",
   "--manifest",
   "--journal",
   "--to",
@@ -3292,6 +3528,18 @@ ${COMMANDS}`);
       write: (text) => process.stdout.write(text),
       live: process.stdout.isTTY,
       decideAs: flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown",
+      check: async (runId) => {
+        const journal2 = openJournal(journalPath2, { mustExist: true });
+        try {
+          return await withUpstreams(
+            manifestPath,
+            async (router) => await inspect({ journal: journal2, router, runId }),
+            serversUsedBy(journal2, runId)
+          );
+        } finally {
+          journal2.close();
+        }
+      },
       undo: async (runId, dryRun, force) => {
         const journal2 = openJournal(journalPath2, { mustExist: true });
         try {
@@ -3356,7 +3604,7 @@ ${COMMANDS}`);
       case "list":
         return runList(journal, asJson, journalPath);
       case "show":
-        return runShow(argv, journal, asJson);
+        return await runShow(argv, journal, asJson);
       case "close":
         return runClose(argv, journal);
       case "prune":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synartesis",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "An undo layer for AI agents.",
   "type": "module",
   "private": false,