synartesis 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -2,6 +2,99 @@
 
 What changed, and why it mattered. Dates are release dates.
 
+## 0.4.2 — 2026-09-09
+
+Three bugs, found by auditing the paths the last pass did not touch. Each is
+pinned by a test that fails against 0.4.1.
+
+### Fixed
+
+- **One approval could authorise two irreversible calls.** Spending a standing
+  approval was an announcement rather than a claim: `markInFlight` and
+  `adoptApproval` both wrote unconditionally, so two proxies — which share one
+  journal, the reason `close` is never automatic — could read the same approved
+  row before either had used it, and both proceed. One person's yes, two emails
+  sent, which is the single thing this is here to prevent.
+
+  Both are now conditional on the row still being `approved` and report whether
+  they won it. `adoptApproval` spends first and only carries the approval across
+  if it did. The proxy treats losing the race as never having had an approval:
+  it asks. The guard already existed for inverses, and its comment describes
+  this exact failure; the approval path never got one.
+
+- **`prune` deleted sessions still waiting on a person.** `--help` and the
+  README both promise that nothing waiting on a person is ever pruned. The query
+  enforced it for `pending`, `gated` and `rolling_back`, and not for the two
+  other statuses that mean the same thing: `approved`, somebody's yes the agent
+  has not spent, and `unrecoverable`, an undo that stopped because somebody had
+  changed the resource and is waiting for them to choose. Pruning the first threw
+  away a human decision; the second threw away both the conflict and the undo
+  they were deciding about.
+
+- **Forcing an undo walked around the double-apply guard.** `markRollingBack`
+  claims an action by moving it out of `applied`, so two rollbacks cannot both
+  send one inverse. `undo --force`, added in 0.4.1, acts on rows an earlier
+  refusal left `unrecoverable` — which the claim did not know about, so it never
+  claimed them and never reported that it had not. Two concurrent forced undos
+  both sent the inverse: harmless for an idempotent write, a second real change
+  to the world for a compensable one.
+
+## 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/{chunk-FOA4UIDE.js → chunk-LAZLEAZW.js}

@@ -470,9 +470,26 @@ var SqliteJournal = class {
       this.#db.prepare("UPDATE actions SET status = 'pending', error = ? WHERE id = ?").run(error, actionId);
     });
   }
-  markRollingBack(actionId) {
+  /**
+   * Claim an action to send its inverse, or report that somebody else has.
+   *
+   * Conditional, so the transition is a claim rather than an announcement. Two
+   * rollbacks of one run both read the action as applied and both sent its
+   * inverse; for a compensating call rather than a restore, that is a second
+   * real change to the world.
+   *
+   * `from` is which statuses may be claimed. It exists because `undo --force`
+   * acts on rows left `unrecoverable` by an earlier refusal, and a claim that
+   * only knew `applied` never claimed those at all -- so the guard above was
+   * simply absent on the one path where a person had already been told the
+   * resource is contested.
+   */
+  markRollingBack(actionId, from = ["applied"]) {
     return this.#run("markRollingBack", () => {
-      const result = this.#db.prepare("UPDATE actions SET status = 'rolling_back' WHERE id = ? AND status = 'applied'").run(actionId);
+      const slots = from.map(() => "?").join(",");
+      const result = this.#db.prepare(
+        `UPDATE actions SET status = 'rolling_back' WHERE id = ? AND status IN (${slots})`
+      ).run(actionId, ...from);
       return result.changes === 1;
     });
   }
@@ -507,9 +524,19 @@ var SqliteJournal = class {
       this.#db.prepare("UPDATE actions SET status = 'gated', error = ? WHERE id = ?").run(why ?? null, actionId);
     });
   }
+  /**
+   * Spend a standing approval, or report that somebody else already has.
+   *
+   * Conditional for the same reason markRollingBack is. Several proxies share
+   * one journal, so two can read the same approved row before either has used
+   * it, and an unconditional write let both proceed -- one person's yes
+   * authorising two irreversible calls, which is the single thing this is here
+   * to prevent.
+   */
   markInFlight(actionId) {
-    this.#run("markInFlight", () => {
-      this.#db.prepare("UPDATE actions SET status = 'pending' WHERE id = ?").run(actionId);
+    return this.#run("markInFlight", () => {
+      const result = this.#db.prepare("UPDATE actions SET status = 'pending' WHERE id = ? AND status = 'approved'").run(actionId);
+      return result.changes === 1;
     });
   }
   /**
@@ -542,12 +569,18 @@ var SqliteJournal = class {
     });
   }
   adoptApproval(actionId, granted) {
-    this.#run("adoptApproval", () => {
+    return this.#run("adoptApproval", () => {
       const move = this.#db.transaction(() => {
+        const spent = this.#db.prepare(
+          "UPDATE actions SET status = 'denied', error = ? WHERE id = ? AND status = 'approved'"
+        ).run(`${SPENT_APPROVAL} ${actionId}`, granted.id);
+        if (spent.changes !== 1) {
+          return false;
+        }
         this.#db.prepare("UPDATE actions SET approved_by = ?, approved_at = ? WHERE id = ?").run(granted.approvedBy ?? null, granted.approvedAt ?? null, actionId);
-        this.#db.prepare("UPDATE actions SET status = 'denied', error = ? WHERE id = ?").run(`${SPENT_APPROVAL} ${actionId}`, granted.id);
+        return true;
       });
-      move.immediate();
+      return move.immediate();
     });
   }
   listGated() {
@@ -639,10 +672,18 @@ var SqliteJournal = class {
              FROM runs r
             WHERE r.status != 'active'
               AND COALESCE(r.ended_at, r.started_at) < ?
+              -- Everything a person still has business with. approved is
+              -- somebody's yes that the agent has not spent yet, and
+              -- unrecoverable is an undo that stopped because somebody had
+              -- changed the resource, waiting for them to choose. Both were
+              -- missing, so the promise made in --help and the README -- that
+              -- nothing waiting on a person is ever pruned -- was not one this
+              -- query kept.
               AND NOT EXISTS (
                     SELECT 1 FROM actions a
                      WHERE a.run_id = r.id
-                       AND a.status IN ('pending','gated','rolling_back'))
+                       AND a.status IN
+                           ('pending','gated','approved','rolling_back','unrecoverable'))
             ORDER BY at, r.rowid`
       ).all(before).map(
         (row) => z.object({
@@ -1493,4 +1534,4 @@ export {
   observeState,
   connectStdioUpstream
 };
-//# sourceMappingURL=chunk-FOA4UIDE.js.map
+//# sourceMappingURL=chunk-LAZLEAZW.js.map

package/dist/cli.js

@@ -25,7 +25,7 @@ import {
   toPayload,
   verifyAgainstServers,
   wasRefused
-} from "./chunk-FOA4UIDE.js";
+} from "./chunk-LAZLEAZW.js";
 import {
   DriftConflict,
   ManifestError,
@@ -491,8 +491,11 @@ ${seen}` : seen;
     if (dryRun) {
       continue;
     }
-    const claimed = journal.markRollingBack(action.id);
-    if (!claimed && action.status === "applied") {
+    const claimed = journal.markRollingBack(
+      action.id,
+      force ? ["applied", "unrecoverable"] : ["applied"]
+    );
+    if (!claimed && action.status !== "rolling_back") {
       const reason = "another undo is already working on this action";
       halted = { seq: action.seq, reason, detail: "" };
       steps[steps.length - 1] = {
@@ -553,11 +556,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 +598,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 +1963,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 +2058,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 +2146,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 +2279,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 +2313,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 +2383,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 +2432,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 +2472,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 +2887,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 +2927,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 +2974,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 +3298,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 +3406,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 +3457,7 @@ var FLAGS = /* @__PURE__ */ new Set([
   "--client",
   "--print",
   "--full",
+  "--live",
   "--manifest",
   "--journal",
   "--to",
@@ -3292,6 +3531,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 +3607,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/dist/proxy.js

@@ -19,7 +19,7 @@ import {
   runRead,
   toPayload,
   verifyAgainstServers
-} from "./chunk-FOA4UIDE.js";
+} from "./chunk-LAZLEAZW.js";
 import {
   SnapshotError,
   UpstreamError,
@@ -588,10 +588,11 @@ function createProxyServer(options) {
           seq: reusable.seq,
           idempotencyKey: reusable.idempotencyKey
         };
+        let spent = true;
         if (inherited !== void 0) {
-          journal.adoptApproval(pending.actionId, inherited);
+          spent = journal.adoptApproval(pending.actionId, inherited);
         } else if (granted !== void 0 && waiting === void 0) {
-          journal.markInFlight(granted.id);
+          spent = journal.markInFlight(granted.id);
         }
         if (granted !== void 0) {
           log?.info(
@@ -654,7 +655,7 @@ function createProxyServer(options) {
           }
         };
         const askedAlready = wantsGate;
-        if (wantsGate && granted === void 0) {
+        if (wantsGate && (granted === void 0 || !spent)) {
           await decide("this action cannot be undone");
         }
         let snapshot;

package/package.json

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