synartesis 0.3.4 → 0.4.1

package/dist/cli.js

@@ -15,6 +15,7 @@ import {
   observeState,
   openJournal,
   parseManifest,
+  pathBinaryMatches,
   planInverse,
   planRead,
   proxyCommand,
@@ -24,19 +25,20 @@ import {
   toPayload,
   verifyAgainstServers,
   wasRefused
-} from "./chunk-LNR5GXPG.js";
+} from "./chunk-FOA4UIDE.js";
 import {
   DriftConflict,
   ManifestError,
   RollbackHalted,
   SynartesisError,
   UpstreamError,
+  changedLines,
   describe
-} from "./chunk-WNLRMSDB.js";
+} from "./chunk-YVOO3PTV.js";
 
 // src/cli.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
-import { dirname, join, resolve } from "path";
+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 { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/init/draft.ts
@@ -285,9 +287,9 @@ async function draftManifest(options) {
   return adopted === void 0 || known === void 0 ? { yaml: merged } : { yaml: merged, adopted: { server: known.name, tools: adopted.covered } };
 }
 function mergeInto(existing, server, policies, name) {
-  const serversAt = existing.indexOf("\nservers:");
+  const serversAt2 = existing.indexOf("\nservers:");
   const toolsAt = existing.indexOf("\ntools:");
-  if (serversAt === -1 || toolsAt === -1 || toolsAt < serversAt) {
+  if (serversAt2 === -1 || toolsAt === -1 || toolsAt < serversAt2) {
     throw new ManifestError(
       "the existing manifest does not have a servers: block followed by a tools: block, so it cannot be extended automatically"
     );
@@ -321,7 +323,7 @@ var toolResult = z2.looseObject({ isError: z2.boolean().default(false) });
 function sameState(a, b) {
   return canonical(a) === canonical(b);
 }
-function classify(action, replanning) {
+function classify(action, replanning, goAhead) {
   switch (action.status) {
     case "rolled_back":
       return { kind: "already-reverted", reason: "already rolled back", verified: true };
@@ -342,7 +344,7 @@ function classify(action, replanning) {
       if (action.inverse === void 0) {
         return void 0;
       }
-      return replanning ? void 0 : { kind: "halt", reason: "halted here on an earlier attempt", verified: false };
+      return replanning || goAhead ? void 0 : { kind: "halt", reason: "halted here on an earlier attempt", verified: false };
     case "applied":
     case "rolling_back":
       return void 0;
@@ -351,6 +353,7 @@ function classify(action, replanning) {
 async function rollback(options) {
   const { journal, router, runId } = options;
   const dryRun = options.dryRun ?? false;
+  const force = options.force ?? false;
   const signal = options.signal ?? new AbortController().signal;
   const policies = options.replanWith === void 0 ? void 0 : createPolicyResolver(options.replanWith);
   const replan = (action) => {
@@ -382,13 +385,14 @@ async function rollback(options) {
   let halted;
   let leftInPlace = false;
   for (const action of inScope) {
-    const early = classify(action, policies !== void 0);
+    let forcedOver;
+    const early = classify(action, policies !== void 0, force || dryRun);
     if (early?.kind === "halt") {
       const seen = action.error ?? "";
-      const detail = action.status === "unrecoverable" && seen !== "" ? `what it saw when it halted, which may no longer hold:
-${seen}
-Resolve the conflict, then run undo --replan to check it against the world as it is now.` : seen;
-      halted = { seq: action.seq, reason: early.reason, detail };
+      const conflicted = action.status === "unrecoverable" && seen !== "";
+      const detail = conflicted ? `what it saw last time, which may no longer hold:
+${seen}` : seen;
+      halted = { seq: action.seq, reason: early.reason, detail, ...conflicted ? { conflict: true } : {} };
       steps.push({ ...describeStep(action), ...early });
       break;
     }
@@ -440,9 +444,18 @@ Resolve the conflict, then run undo --replan to check it against the world as it
           journal.markRolledBack(action.id);
         }
         continue;
-      } else {
+      } else if (!force) {
         const conflict = new DriftConflict(action.seq, recordedPost.data, current);
-        halted = { seq: action.seq, reason: "drift detected", detail: conflict.message };
+        halted = {
+          seq: action.seq,
+          reason: "drift detected",
+          detail: conflict.message,
+          conflict: true,
+          // What the person deciding actually needs: not only that it changed,
+          // but which lines undoing would write over. A halt that shows the
+          // first and hides the second leaves them choosing blind.
+          overwrites: overwriteText(current, action)
+        };
         steps.push({
           ...describeStep(action),
           kind: "halt",
@@ -454,6 +467,8 @@ Resolve the conflict, then run undo --replan to check it against the world as it
           journal.markUnrecoverable(action.id, conflict.message);
         }
         break;
+      } else {
+        forcedOver = "the resource had changed since; that change was overwritten";
       }
     }
     if (!verified && action.status === "rolling_back") {
@@ -468,7 +483,7 @@ Resolve the conflict, then run undo --replan to check it against the world as it
     steps.push({
       ...describeStep(action),
       kind: "revert",
-      reason: verified ? "state matches; applying inverse" : unverifiedBecause(action),
+      reason: verified ? "state matches; applying inverse" : forcedOver ?? unverifiedBecause(action),
       verified,
       plan,
       ...rebuilt.inverse === void 0 ? {} : { replanned: true }
@@ -537,6 +552,13 @@ function unverifiedBecause(action) {
 function describeStep(action) {
   return { seq: action.seq, server: action.server, tool: action.tool };
 }
+function overwriteText(current, action) {
+  const intended2 = intendedAfterInverse(action);
+  if (intended2 === void 0) {
+    return "";
+  }
+  return changedLines(current, intended2);
+}
 function intendedAfterInverse(action) {
   return action.snapshot === void 0 ? void 0 : { present: true, value: action.snapshot };
 }
@@ -573,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";
 
@@ -591,23 +705,159 @@ function keysIn(chunk) {
   return keys;
 }
 
+// src/clock.ts
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var pad = (value) => String(value).padStart(2, "0");
+function isToday(when, now) {
+  return when.getFullYear() === now.getFullYear() && when.getMonth() === now.getMonth() && when.getDate() === now.getDate();
+}
+function shortTime(iso, now = /* @__PURE__ */ new Date()) {
+  const when = new Date(iso);
+  if (Number.isNaN(when.getTime())) {
+    return iso.slice(11, 19).padEnd(12);
+  }
+  const time = `${pad(when.getHours())}:${pad(when.getMinutes())}`;
+  if (isToday(when, now)) {
+    return `${time}:${pad(when.getSeconds())}`.padEnd(12);
+  }
+  return `${pad(when.getDate())} ${MONTHS[when.getMonth()] ?? ""} ${time}`.padEnd(12);
+}
+function fullTime(iso, now = /* @__PURE__ */ new Date()) {
+  const when = new Date(iso);
+  if (Number.isNaN(when.getTime())) {
+    return iso;
+  }
+  const clock = `${pad(when.getHours())}:${pad(when.getMinutes())}:${pad(when.getSeconds())}`;
+  if (isToday(when, now)) {
+    return `today at ${clock}`;
+  }
+  return `${pad(when.getDate())} ${MONTHS[when.getMonth()] ?? ""} ${String(when.getFullYear())}, ${clock}`;
+}
+function ago(iso, now = /* @__PURE__ */ new Date()) {
+  const when = new Date(iso);
+  if (Number.isNaN(when.getTime())) {
+    return "";
+  }
+  const seconds = Math.max(0, Math.round((now.getTime() - when.getTime()) / 1e3));
+  if (seconds < 10) {
+    return "just now";
+  }
+  if (seconds < 60) {
+    return `${String(seconds)}s ago`;
+  }
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) {
+    return `${String(minutes)}m ago`;
+  }
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) {
+    return `${String(hours)}h ago`;
+  }
+  return `${String(Math.round(hours / 24))}d ago`;
+}
+
+// src/describe.ts
+import { basename } from "path";
+var SUBJECT_KEYS = [
+  "path",
+  "file_path",
+  "source",
+  "destination",
+  "id",
+  "name",
+  "key",
+  "entity",
+  "query"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function subject(args) {
+  if (!isRecord(args)) {
+    return "";
+  }
+  const record = args;
+  for (const key of SUBJECT_KEYS) {
+    const value = record[key];
+    if (typeof value === "string" && value !== "") {
+      return value.includes("/") ? basename(value) : value;
+    }
+  }
+  for (const value of Object.values(record)) {
+    if (Array.isArray(value) && value.length > 0) {
+      return `${String(value.length)} items`;
+    }
+  }
+  return "";
+}
+function plainly(action) {
+  switch (action.status) {
+    case "gated":
+      return { text: "waiting for you", needs: true };
+    case "applied":
+      return action.class === "readonly" ? { text: "read", needs: false } : action.inverse === void 0 ? { text: "done, cannot undo", needs: false } : { text: "done, can undo", needs: false };
+    case "rolled_back":
+      return { text: "undone", needs: false };
+    case "rolling_back":
+      return { text: "undoing", needs: false };
+    case "denied":
+      return { text: "refused", needs: false };
+    case "failed":
+      return { text: "failed", needs: false };
+    case "approved":
+      return { text: "approved, not yet sent", needs: true };
+    case "pending":
+      return { text: "sent, outcome unknown", needs: true };
+    case "unrecoverable":
+      return action.inverse === void 0 ? { text: "cannot be undone", needs: true } : { text: "changed since; not safe to undo", needs: true };
+    default:
+      return { text: action.status, needs: false };
+  }
+}
+function size(bytes) {
+  if (bytes < 1024) {
+    return `${String(bytes)} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} kB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function summariseArgs(args, limit = 60) {
+  if (!isRecord(args)) {
+    return args === void 0 ? "" : JSON.stringify(args);
+  }
+  const parts = [];
+  for (const [key, value] of Object.entries(args)) {
+    if (typeof value === "string") {
+      parts.push(value.length > 48 ? `${key} ${size(Buffer.byteLength(value))}` : `${key} ${value}`);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      parts.push(`${key} ${String(value.length)} items`);
+      continue;
+    }
+    if (value === null || typeof value !== "object") {
+      parts.push(`${key} ${String(value)}`);
+      continue;
+    }
+    parts.push(`${key} ${size(Buffer.byteLength(JSON.stringify(value)))}`);
+  }
+  const line2 = parts.join("  ");
+  return line2.length <= limit ? line2 : `${line2.slice(0, limit - 1)}\u2026`;
+}
+
 // src/watch.ts
 var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var MARK = {
-  readonly: "\xB7",
-  reversible: "\u2190",
-  compensable: "\u2248",
-  irreversible: "!",
-  unclassified: "?"
-};
 var NOTICE_TICKS = 26;
-function line(action) {
-  const mark = MARK[action.class] ?? "?";
-  const badge = `${mark} ${action.class}`.padEnd(14);
-  const when = action.ts.slice(11, 19);
-  const label = labelFor(action).padEnd(13);
-  const status = action.status === "gated" ? style.strong(label) : wasRefused(action) ? style.accent(label) : style.quiet(label);
-  return `  ${style.quiet(when)}  ${style.quiet(badge)} ${status} ${action.server}.${action.tool}`;
+function line(action, now) {
+  const when = shortTime(action.ts, now);
+  const where = action.server.padEnd(10);
+  const what = action.tool.padEnd(20);
+  const on = subject(action.args);
+  const state = plainly(action);
+  const said = state.needs || wasRefused(action) ? style.accent(state.text) : style.quiet(state.text);
+  return `  ${style.quiet(when)}  ${style.quiet(where)} ${style.strong(what)} ${style.quiet(on.padEnd(20))} ${said}`;
 }
 function waitingForJournal(options, tick) {
   const spinner = options.live ? `${style.accent(FRAMES[tick % FRAMES.length] ?? "")} ` : "";
@@ -625,6 +875,7 @@ function waitingForJournal(options, tick) {
 function render(journal, options, tick, view) {
   const runs = journal.listRuns();
   const recent = journal.recentActions(12);
+  const now = /* @__PURE__ */ new Date();
   const waiting = journal.listGated();
   const active = runs.filter((run) => run.status === "active").length;
   const out2 = [];
@@ -641,7 +892,7 @@ function render(journal, options, tick, view) {
     out2.push(`  ${style.quiet("No agent has done anything through this journal yet.")}`);
   } else {
     for (const action of recent) {
-      out2.push(line(action));
+      out2.push(line(action, now));
     }
   }
   if (waiting.length > 0) {
@@ -789,7 +1040,7 @@ async function watch(options) {
       if (options.maxTicks !== void 0 && tick + 1 >= options.maxTicks) {
         break;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, interval));
+      await new Promise((resolve4) => setTimeout(resolve4, interval));
     }
     return 0;
   } finally {
@@ -804,14 +1055,675 @@ async function watch(options) {
         await reader?.return?.(void 0);
         await reading;
       })(),
-      new Promise((resolve2) => setTimeout(resolve2, 50).unref())
+      new Promise((resolve4) => setTimeout(resolve4, 50).unref())
     ]);
     journal?.close();
   }
 }
 
 // src/console.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync6 } from "fs";
+
+// src/install/connections.ts
+import { existsSync as existsSync5 } from "fs";
+
+// src/install/clients.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "fs";
+import { homedir, platform } from "os";
+import { basename as basename2, dirname, join, resolve } from "path";
+
+// src/install/toml.ts
+var HEADER = /^\s*\[(?!\[)([^[\]]+)\]\s*$/;
+function serverTables(lines) {
+  const tables = [];
+  let open;
+  const close = (at) => {
+    if (open !== void 0) {
+      tables.push({ name: open.name, start: open.start, end: at });
+      open = void 0;
+    }
+  };
+  lines.forEach((line2, index) => {
+    const header2 = HEADER.exec(line2)?.[1];
+    if (header2 === void 0) {
+      return;
+    }
+    const parts = header2.split(".");
+    if (parts[0] === "mcp_servers" && parts.length === 2 && parts[1] !== void 0) {
+      close(index);
+      open = { name: unquote(parts[1]), start: index };
+      return;
+    }
+    close(index);
+  });
+  close(lines.length);
+  return tables;
+}
+function unquote(text) {
+  const trimmed = text.trim();
+  if (/^'.*'$/s.test(trimmed)) {
+    return trimmed.slice(1, -1);
+  }
+  if (!/^".*"$/s.test(trimmed)) {
+    return trimmed;
+  }
+  return trimmed.slice(1, -1).replace(/\\(["\\])/g, "$1");
+}
+function readKey(lines, table, key) {
+  const pattern = new RegExp(`^\\s*${key}\\s*=\\s*(.*)$`);
+  for (let index = table.start + 1; index < table.end; index += 1) {
+    const line2 = lines[index];
+    if (line2 === void 0 || HEADER.test(line2)) {
+      break;
+    }
+    const value = pattern.exec(line2)?.[1];
+    if (value !== void 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function splitItems(inner) {
+  const items = [];
+  let current = "";
+  let quote3;
+  let escaped = false;
+  for (const character of inner) {
+    if (escaped) {
+      current += character;
+      escaped = false;
+      continue;
+    }
+    if (character === "\\" && quote3 === '"') {
+      current += character;
+      escaped = true;
+      continue;
+    }
+    if (quote3 === void 0 && (character === '"' || character === "'")) {
+      quote3 = character;
+      current += character;
+      continue;
+    }
+    if (character === quote3) {
+      quote3 = void 0;
+      current += character;
+      continue;
+    }
+    if (character === "," && quote3 === void 0) {
+      items.push(current);
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  items.push(current);
+  return items;
+}
+function parseArray(value) {
+  if (value === void 0 || !value.startsWith("[")) {
+    return void 0;
+  }
+  if (!value.endsWith("]")) {
+    return void 0;
+  }
+  const inner = value.slice(1, -1).trim();
+  if (inner === "") {
+    return [];
+  }
+  return splitItems(inner).map((item) => item.trim()).filter((item, index, all) => item !== "" || index !== all.length - 1).map(unquote);
+}
+function readServers(text) {
+  const lines = text.split("\n");
+  const servers = {};
+  for (const table of serverTables(lines)) {
+    const command = readKey(lines, table, "command");
+    const entry = {};
+    if (command !== void 0) {
+      entry["command"] = unquote(command);
+    }
+    const args = parseArray(readKey(lines, table, "args"));
+    if (args !== void 0) {
+      entry["args"] = args;
+    }
+    const url = readKey(lines, table, "url");
+    if (url !== void 0) {
+      entry["url"] = unquote(url);
+    }
+    const enabled = readKey(lines, table, "enabled");
+    if (enabled !== void 0) {
+      entry["enabled"] = enabled.trim() === "true";
+    }
+    servers[table.name] = entry;
+  }
+  return servers;
+}
+var quote2 = (text) => `"${text.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+function writeServers(text, servers) {
+  const lines = text.split("\n");
+  const current = readServers(text);
+  for (const table of serverTables(lines).reverse()) {
+    const wanted = servers[table.name];
+    if (wanted === void 0 || wanted.command === void 0) {
+      continue;
+    }
+    const now = current[table.name];
+    if (now?.command === wanted.command && JSON.stringify(now.args ?? []) === JSON.stringify(wanted.args ?? [])) {
+      continue;
+    }
+    setKey(lines, table, "command", quote2(wanted.command));
+    setKey(lines, table, "args", `[${(wanted.args ?? []).map(quote2).join(", ")}]`);
+  }
+  return lines.join("\n");
+}
+function setKey(lines, table, key, value) {
+  const pattern = new RegExp(`^(\\s*)${key}\\s*=`);
+  for (let index = table.start + 1; index < table.end; index += 1) {
+    const line2 = lines[index];
+    if (line2 === void 0 || HEADER.test(line2)) {
+      break;
+    }
+    const indent = pattern.exec(line2)?.[1];
+    if (indent !== void 0) {
+      lines[index] = `${indent}${key} = ${value}`;
+      return;
+    }
+  }
+  lines.splice(table.start + 1, 0, `${key} = ${value}`);
+}
+
+// src/install/clients.ts
+var LABELS = {
+  "claude-code": "Claude Code",
+  "claude-desktop": "Claude Desktop",
+  cursor: "Cursor",
+  codex: "Codex"
+};
+function claudeDesktopPath() {
+  const home = homedir();
+  switch (platform()) {
+    case "darwin":
+      return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    case "win32":
+      return join(process.env["APPDATA"] ?? join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    default:
+      return join(process.env["XDG_CONFIG_HOME"] ?? join(home, ".config"), "Claude", "claude_desktop_config.json");
+  }
+}
+function discover(cwd) {
+  const home = homedir();
+  const sites = [];
+  const claudeCode = join(home, ".claude.json");
+  if (existsSync3(claudeCode)) {
+    const document = readJson(claudeCode);
+    const projects = document?.["projects"];
+    const here = resolve(cwd);
+    if (isRecord2(projects) && Object.prototype.hasOwnProperty.call(projects, here)) {
+      sites.push({
+        client: "claude-code",
+        label: LABELS["claude-code"],
+        format: "json",
+        path: claudeCode,
+        scope: `project ${here}`,
+        at: ["projects", here, "mcpServers"]
+      });
+    }
+    sites.push({
+      client: "claude-code",
+      label: LABELS["claude-code"],
+      format: "json",
+      path: claudeCode,
+      scope: "global",
+      at: ["mcpServers"]
+    });
+  }
+  const projectFile = join(resolve(cwd), ".mcp.json");
+  if (existsSync3(projectFile)) {
+    sites.push({
+      client: "claude-code",
+      label: LABELS["claude-code"],
+      format: "json",
+      path: projectFile,
+      scope: "project file",
+      at: ["mcpServers"]
+    });
+  }
+  const desktop = claudeDesktopPath();
+  if (existsSync3(desktop)) {
+    sites.push({
+      client: "claude-desktop",
+      label: LABELS["claude-desktop"],
+      format: "json",
+      path: desktop,
+      scope: "global",
+      at: ["mcpServers"]
+    });
+  }
+  const codex = join(process.env["CODEX_HOME"] ?? join(home, ".codex"), "config.toml");
+  if (existsSync3(codex)) {
+    sites.push({
+      client: "codex",
+      label: LABELS.codex,
+      format: "toml",
+      path: codex,
+      scope: "global",
+      at: ["mcp_servers"]
+    });
+  }
+  for (const [path, scope] of [
+    [join(resolve(cwd), ".cursor", "mcp.json"), "project"],
+    [join(home, ".cursor", "mcp.json"), "global"]
+  ]) {
+    if (existsSync3(path)) {
+      sites.push({ client: "cursor", label: LABELS.cursor, format: "json", path, scope, at: ["mcpServers"] });
+    }
+  }
+  return sites;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJson(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return isRecord2(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var ConfigError = class extends Error {
+};
+function readDocument(site) {
+  let text;
+  try {
+    text = readFileSync2(site.path, "utf8");
+  } catch (error) {
+    throw new ConfigError(`cannot read ${site.path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new ConfigError(
+      `${site.path} is not valid JSON (${error instanceof Error ? error.message : String(error)}). Fix it or move it aside; synartesis will not rewrite a file it cannot read.`
+    );
+  }
+  if (!isRecord2(parsed)) {
+    throw new ConfigError(`${site.path} is not a JSON object, so it has no server list to change`);
+  }
+  return parsed;
+}
+function readServers2(document, at) {
+  let node = document;
+  for (const key of at) {
+    if (!isRecord2(node)) {
+      return {};
+    }
+    node = node[key];
+  }
+  if (!isRecord2(node)) {
+    return {};
+  }
+  const servers = {};
+  for (const [name, entry] of Object.entries(node)) {
+    if (isRecord2(entry)) {
+      servers[name] = entry;
+    }
+  }
+  return servers;
+}
+function withServers(document, at, servers) {
+  const head = at[0];
+  if (head === void 0) {
+    throw new ConfigError("no path to the server list");
+  }
+  const rest = at.slice(1);
+  const below = document[head];
+  const child = rest.length === 0 ? servers : withServers(isRecord2(below) ? below : {}, rest, servers);
+  return { ...document, [head]: child };
+}
+function indentOf(path) {
+  try {
+    const line2 = /\n([ \t]+)"/.exec(readFileSync2(path, "utf8"));
+    const found = line2?.[1];
+    if (found === void 0) {
+      return 2;
+    }
+    return found.startsWith("	") ? "	" : found.length;
+  } catch {
+    return 2;
+  }
+}
+function backupPathFor(path) {
+  return `${path}.synartesis-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+}
+var KEEP_BACKUPS = 5;
+function pruneBackups(path) {
+  try {
+    const dir = dirname(path);
+    const prefix = `${basename2(path)}.synartesis-backup-`;
+    const ours = readdirSync(dir).filter((name) => name.startsWith(prefix)).sort();
+    for (const name of ours.slice(0, Math.max(0, ours.length - KEEP_BACKUPS))) {
+      rmSync(join(dir, name), { force: true });
+    }
+  } catch {
+  }
+}
+function writeDocument(site, document) {
+  return writeText(site, `${JSON.stringify(document, void 0, indentOf(site.path))}
+`);
+}
+function writeText(site, text) {
+  const backup = backupPathFor(site.path);
+  const original = readFileSync2(site.path);
+  writeFileSync(backup, original);
+  pruneBackups(site.path);
+  const temporary = join(dirname(site.path), `.synartesis-write-${String(process.pid)}.tmp`);
+  try {
+    writeFileSync(temporary, text);
+    renameSync(temporary, site.path);
+  } catch (error) {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    throw new ConfigError(
+      `could not write ${site.path}: ${error instanceof Error ? error.message : String(error)}. The original is untouched, and a copy is at ${backup}.`
+    );
+  }
+  return backup;
+}
+function serversAt(site) {
+  if (site.format === "toml") {
+    try {
+      return readServers(readFileSync2(site.path, "utf8"));
+    } catch (error) {
+      throw new ConfigError(
+        `cannot read ${site.path}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return readServers2(readDocument(site), site.at);
+}
+function saveServers(site, servers) {
+  if (site.format === "toml") {
+    const text = readFileSync2(site.path, "utf8");
+    return writeText(site, writeServers(text, servers));
+  }
+  return writeDocument(site, withServers(readDocument(site), site.at, servers));
+}
+
+// src/install/install.ts
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+function recordPathFor(manifestPath) {
+  return resolve2(dirname2(manifestPath), "installed.json");
+}
+var EMPTY = { version: 1, wrapped: {} };
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+  if (!isRecord3(value)) {
+    return void 0;
+  }
+  const wrapped2 = value["wrapped"];
+  if (!isRecord3(wrapped2)) {
+    return void 0;
+  }
+  const kept = {};
+  for (const [key, entry] of Object.entries(wrapped2)) {
+    if (!isRecord3(entry)) {
+      continue;
+    }
+    const original = entry["original"];
+    const at = entry["at"];
+    if (!isRecord3(original)) {
+      continue;
+    }
+    if (!Array.isArray(at) || !at.every((step) => typeof step === "string")) {
+      continue;
+    }
+    kept[key] = { original, at };
+  }
+  return { version: 1, wrapped: kept };
+}
+function keyFor(site, server) {
+  return [site.path, site.scope, server].join("");
+}
+function readRecord(manifestPath) {
+  const path = recordPathFor(manifestPath);
+  if (!existsSync4(path)) {
+    return EMPTY;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const record = asRecord(parsed);
+    if (record !== void 0) {
+      return record;
+    }
+  } catch {
+  }
+  return EMPTY;
+}
+function writeRecord(manifestPath, record) {
+  mkdirSync(dirname2(recordPathFor(manifestPath)), { recursive: true, mode: 448 });
+  writeFileSync2(recordPathFor(manifestPath), `${JSON.stringify(record, void 0, 2)}
+`);
+}
+function proxyEntry(manifestPath, server, original, invoker) {
+  const command = { command: invoker.command, args: [...invoker.args] };
+  return {
+    ...command,
+    args: [...command.args, "--manifest", resolve2(manifestPath), "--server", server],
+    // The agent's environment, not ours: the upstream is started by the proxy
+    // from the manifest, but a client that set `env` here meant it for the
+    // server, and the manifest reads `${VAR}` out of exactly this environment.
+    ...original.env === void 0 ? {} : { env: original.env },
+    ...original.cwd === void 0 ? {} : { cwd: original.cwd }
+  };
+}
+function isWrapped(entry) {
+  const args = entry.args ?? [];
+  return args.includes("proxy") && (entry.command === "synartesis" || entry.command === "synartesis-proxy" || args.includes("synartesis") || args.some((arg) => arg.endsWith("dist/cli.js") || arg.endsWith("dist/proxy.js")));
+}
+function invokerFor(ourVersion, cliPath) {
+  if (pathBinaryMatches(ourVersion)) {
+    return { command: "synartesis", args: ["proxy"] };
+  }
+  return {
+    command: process.execPath,
+    args: [cliPath, "proxy"],
+    note: "the synartesis on your PATH is a different build, so the entries name this one directly"
+  };
+}
+async function planInstall(sites, manifestPath, invoker) {
+  let yaml = existsSync4(manifestPath) ? readFileSync3(manifestPath, "utf8") : void 0;
+  const plans = [];
+  const claimed = new Set(
+    yaml === void 0 ? [] : Object.keys(parseManifest(yaml, manifestPath).servers)
+  );
+  for (const site of sites) {
+    const servers = serversAt(site);
+    const planned = [];
+    const skipped = [];
+    for (const [name, entry] of Object.entries(servers)) {
+      if (isWrapped(entry)) {
+        skipped.push({ name, why: "already covered" });
+        continue;
+      }
+      if (entry.command === void 0) {
+        skipped.push({ name, why: entry.url === void 0 ? "no command to start" : "remote (http); stdio only today" });
+        continue;
+      }
+      if (entry.enabled === false) {
+        skipped.push({ name, why: "switched off in the config" });
+        continue;
+      }
+      const key = claimed.has(name) ? `${name}-${site.client}` : name;
+      if (claimed.has(key)) {
+        skipped.push({ name, why: `already in the policy as ${key}` });
+        continue;
+      }
+      let draft;
+      try {
+        draft = await draftManifest({
+          name: key,
+          command: entry.command,
+          args: [...entry.args ?? []],
+          ...yaml === void 0 ? {} : { existing: yaml }
+        });
+      } catch (error) {
+        skipped.push({
+          name,
+          why: `will not start: ${(error instanceof Error ? error.message : String(error)).slice(0, 60)}`
+        });
+        continue;
+      }
+      yaml = draft.yaml;
+      claimed.add(key);
+      planned.push({
+        name,
+        original: entry,
+        wrapped: proxyEntry(manifestPath, key, entry, invoker),
+        ...draft.adopted === void 0 ? {} : { adopted: draft.adopted.server, tools: draft.adopted.tools }
+      });
+    }
+    plans.push({ site, servers: planned, skipped });
+  }
+  return { plans, yaml: yaml ?? "" };
+}
+function applyInstall(plans, manifestPath, yaml) {
+  if (!plans.some((plan) => plan.servers.length > 0)) {
+    return [];
+  }
+  parseManifest(yaml, manifestPath);
+  mkdirSync(dirname2(resolve2(manifestPath)), { recursive: true, mode: 448 });
+  writeFileSync2(manifestPath, yaml);
+  const record = readRecord(manifestPath);
+  const wrapped2 = { ...record.wrapped };
+  const applied = [];
+  for (const plan of plans) {
+    if (plan.servers.length === 0) {
+      continue;
+    }
+    const servers = { ...serversAt(plan.site) };
+    for (const server of plan.servers) {
+      servers[server.name] = server.wrapped;
+      wrapped2[keyFor(plan.site, server.name)] = { original: server.original, at: plan.site.at };
+    }
+    writeRecord(manifestPath, { version: 1, wrapped: wrapped2 });
+    const backup = saveServers(plan.site, servers);
+    applied.push({ site: plan.site, backup, servers: plan.servers.map((server) => server.name) });
+  }
+  return applied;
+}
+function applyUninstall(sites, manifestPath) {
+  const record = readRecord(manifestPath);
+  const restoredKeys = /* @__PURE__ */ new Set();
+  const restored = [];
+  for (const site of sites) {
+    const servers = { ...serversAt(site) };
+    const put = [];
+    const unknown = [];
+    for (const [name, entry] of Object.entries(servers)) {
+      if (!isWrapped(entry)) {
+        continue;
+      }
+      const known = record.wrapped[keyFor(site, name)];
+      if (known === void 0) {
+        unknown.push(name);
+        continue;
+      }
+      servers[name] = known.original;
+      put.push(name);
+      restoredKeys.add(keyFor(site, name));
+    }
+    if (put.length === 0 && unknown.length === 0) {
+      continue;
+    }
+    const backup = put.length === 0 ? "" : saveServers(site, servers);
+    restored.push({ site, backup, servers: put, unknown });
+  }
+  const remaining = Object.fromEntries(
+    Object.entries(record.wrapped).filter(([key]) => !restoredKeys.has(key))
+  );
+  writeRecord(manifestPath, { version: 1, wrapped: remaining });
+  return restored;
+}
+
+// src/install/connections.ts
+var ACTIVE_WITHIN_MS = 2 * 60 * 1e3;
+function lastSeenByServer(journal) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const action of journal.recentActions(500)) {
+    const known = seen.get(action.server);
+    if (known === void 0 || action.ts > known) {
+      seen.set(action.server, action.ts);
+    }
+  }
+  return seen;
+}
+function commandMissing(command) {
+  if (command === void 0) {
+    return false;
+  }
+  return (command.includes("/") || command.includes("\\")) && !existsSync5(command);
+}
+function scan(journal, cwd) {
+  const seen = journal === void 0 ? /* @__PURE__ */ new Map() : lastSeenByServer(journal);
+  const groups = [];
+  for (const site of discover(cwd)) {
+    let servers;
+    try {
+      servers = serversAt(site);
+    } catch (error) {
+      groups.push({
+        label: site.label,
+        scope: site.scope,
+        path: site.path,
+        connections: [],
+        problem: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    const connections = Object.entries(servers).map(([server, entry]) => {
+      const covered = isWrapped(entry);
+      const lastSeen = seen.get(server);
+      return {
+        client: site.client,
+        scope: site.scope,
+        path: site.path,
+        server,
+        covered,
+        missing: commandMissing(entry.command),
+        ...lastSeen === void 0 ? {} : { lastSeen },
+        site
+      };
+    });
+    groups.push({ label: site.label, scope: site.scope, path: site.path, connections });
+  }
+  return groups;
+}
+function stateOf(connection, now = /* @__PURE__ */ new Date()) {
+  if (connection.missing) {
+    return "cannot start; the command is not there";
+  }
+  if (!connection.covered) {
+    return "not covered";
+  }
+  if (connection.lastSeen === void 0) {
+    return "covered, nothing through it yet";
+  }
+  const since = now.getTime() - new Date(connection.lastSeen).getTime();
+  return since <= ACTIVE_WITHIN_MS ? "covered, active now" : `covered, last used ${ago(connection.lastSeen, now)}`;
+}
+function needsConnecting(groups) {
+  return groups.flatMap(
+    (group) => group.connections.filter((connection) => !connection.covered && !connection.missing)
+  );
+}
+
+// src/console.ts
 var FRAMES2 = [
   "\u280B",
   "\u2819",
@@ -824,17 +1736,11 @@ var FRAMES2 = [
   "\u2807",
   "\u280F"
 ];
-var MARK2 = {
-  readonly: "\xB7",
-  reversible: "\u2190",
-  compensable: "\u2248",
-  irreversible: "!",
-  unclassified: "?"
-};
 var CURSOR = "\u276F";
 var DOT = "\xB7";
 var ESC = "\x1B";
 var NOTICE_TICKS2 = 26;
+var READING_TICKS = 200;
 function roomFor(options) {
   const rows = options.rows ?? rowsOf(process.stdout.rows) ?? 24;
   return Math.max(3, rows - 11);
@@ -853,6 +1759,9 @@ function windowed(lines, at, room) {
     ...below === 0 ? [] : [`  ${style.quiet(`${String(below)} more below`)}`]
   ];
 }
+function firstLine(text) {
+  return text.split("\n")[0]?.trim() ?? "";
+}
 function truncate2(text, limit) {
   return text.length <= limit ? text : `${text.slice(0, limit - 3)}...`;
 }
@@ -876,6 +1785,8 @@ function modeLabel(screen) {
       return "one run, in the order it happened";
     case "gates":
       return "held until a person decides";
+    case "connections":
+      return "every AI on this machine, and whether it goes through Synartesis";
   }
 }
 function header(options, screen, tick) {
@@ -905,15 +1816,35 @@ function runsView(journal, screen, options) {
     const here = index === at && canPress(options);
     const name = (run.label ?? "an agent").padEnd(24);
     const note = held === 0 ? "" : `  ${style.accent(`${String(held)} awaiting approval`)}`;
-    return `  ${here ? style.accent(CURSOR) : " "} ${here ? style.accent(name) : style.strong(name)} ${style.quiet(run.startedAt.slice(0, 19).replace("T", " "))}  ${style.quiet(run.status.padEnd(11))} ${style.quiet(`${String(actions.length)} actions`)}${note}`;
+    return `  ${here ? style.accent(CURSOR) : " "} ${here ? style.accent(name) : style.strong(name)} ${style.quiet(shortTime(run.startedAt).trimEnd().padEnd(13))}  ${style.quiet(run.status.padEnd(11))} ${style.quiet(`${String(actions.length)} actions`)}${note}`;
   });
 }
-function statusOf(action) {
-  const text = labelFor(action).padEnd(13);
-  if (wasRefused(action)) {
-    return style.accent(text);
+function standing(actions) {
+  let undoable = 0;
+  let conflicted = 0;
+  for (const action of actions) {
+    if (action.inverse === void 0) {
+      continue;
+    }
+    if (action.status === "applied") {
+      undoable += 1;
+    } else if (action.status === "unrecoverable") {
+      conflicted += 1;
+    }
   }
-  return action.status === "gated" ? style.strong(text) : style.quiet(text);
+  return { undoable, conflicted };
+}
+function elsewhere(journal, exceptId) {
+  for (const run of [...journal.listRuns()].reverse()) {
+    if (run.id === exceptId) {
+      continue;
+    }
+    const found = standing(journal.getActions(run.id));
+    if (found.undoable > 0 || found.conflicted > 0) {
+      return run;
+    }
+  }
+  return void 0;
 }
 function runView(journal, screen) {
   const runId = screen.openRun;
@@ -923,22 +1854,86 @@ function runView(journal, screen) {
   const run = journal.getRun(runId);
   const actions = journal.getActions(runId);
   const out2 = [
-    `  ${style.label("run")}  ${style.strong(run?.label ?? "an agent")}  ${style.quiet(runId.slice(0, 8))}`,
+    // "RUN claude 5dce5bda" was read as an instruction to go and run
+    // something: a spaced capital heading followed by two words looks exactly
+    // like a command with two arguments. "Session" is only ever a noun.
+    `  ${style.label("session")}  ${style.strong(run?.label ?? "an agent")}  ${style.quiet(runId.slice(0, 8))}`,
     ""
   ];
   if (actions.length === 0) {
-    out2.push(`  ${style.quiet("nothing was recorded in this run")}`);
+    out2.push(`  ${style.quiet("nothing was recorded in this run, so there is nothing here to undo")}`);
+    const other = elsewhere(journal, runId);
+    if (other !== void 0) {
+      out2.push("");
+      out2.push(
+        `  ${style.quiet("the session that did something:")} ${style.strong(other.label ?? "an agent")}  ${style.accent(other.id.slice(0, 8))}`
+      );
+      out2.push(
+        `  ${style.quiet("esc, then j/k onto it -- or run:")} ` + style.strong(`${cliCommand()} undo ${other.id.slice(0, 8)}`)
+      );
+    }
     return out2;
   }
   for (const action of actions) {
-    const badge = `${MARK2[action.class] ?? "?"} ${action.class}`.padEnd(14);
+    const state = plainly(action);
+    const said = state.needs || wasRefused(action) ? style.accent(state.text) : style.quiet(state.text);
     out2.push(
-      `  ${style.quiet(String(action.seq).padStart(3))}  ${style.quiet(badge)} ${statusOf(action)} ${style.strong(`${action.server}.${action.tool}`)}`
+      `  ${style.quiet(String(action.seq).padStart(3))}  ${style.quiet(action.server.padEnd(10))} ${style.strong(action.tool.padEnd(20))} ${style.quiet(subject(action.args).padEnd(20))} ${said}`
     );
-    out2.push(`        ${style.quiet(truncate2(JSON.stringify(action.args), 62))}`);
-    if (action.inverse !== void 0) {
-      out2.push(`        ${style.quiet(`undo: ${truncate2(JSON.stringify(action.inverse), 56)}`)}`);
+    if (screen.expanded) {
+      for (const line2 of JSON.stringify(action.args, void 0, 2).split("\n")) {
+        out2.push(`        ${style.quiet(line2)}`);
+      }
+      if (action.inverse !== void 0) {
+        out2.push(`        ${style.quiet("undo")}`);
+        for (const line2 of JSON.stringify(action.inverse, void 0, 2).split("\n")) {
+          out2.push(`        ${style.quiet(line2)}`);
+        }
+      }
+    } else {
+      out2.push(`        ${style.quiet(summariseArgs(action.args, 62))}`);
+    }
+  }
+  return out2;
+}
+function connectionRows(screen) {
+  return screen.groups.flatMap((group) => group.connections);
+}
+function connectionsView(screen, options) {
+  if (screen.groups.length === 0) {
+    return [
+      `  ${style.quiet("No MCP client config was found on this machine.")}`,
+      "",
+      `  ${style.quiet("Looked for Claude Code, Claude Desktop, Cursor and Codex.")}`
+    ];
+  }
+  const rows = connectionRows(screen);
+  const at = Math.min(screen.cursor, Math.max(0, rows.length - 1));
+  const now = /* @__PURE__ */ new Date();
+  const out2 = [];
+  let index = 0;
+  for (const group of screen.groups) {
+    out2.push(`  ${style.strong(group.label)} ${style.quiet(group.scope)}`);
+    if (group.problem !== void 0) {
+      out2.push(`      ${style.accent(group.problem)}`);
+      out2.push("");
+      continue;
     }
+    if (group.connections.length === 0) {
+      out2.push(`      ${style.quiet("no servers listed")}`);
+      out2.push("");
+      continue;
+    }
+    for (const connection of group.connections) {
+      const here = index === at && canPress(options);
+      const state = stateOf(connection, now);
+      const shown = connection.covered ? style.quiet(state) : style.accent(state);
+      out2.push(
+        `  ${here ? style.accent(CURSOR) : " "} ${here ? style.accent(connection.server.padEnd(20)) : style.strong(connection.server.padEnd(20))} ${shown}`
+      );
+      index += 1;
+    }
+    out2.push("");
   }
   return out2;
 }
@@ -961,19 +1956,18 @@ function footer(screen, options) {
     return [];
   }
   if (screen.confirming !== void 0) {
-    return [
-      "",
-      `  ${style.accent("undo this whole run?")}  ${keyHint2("y", "yes")}   ${keyHint2("n", "no")}`
-    ];
+    const what = screen.confirmingForce ? `undo ${screen.confirmingLabel ?? "this session"} anyway, losing that change?` : `undo ${screen.confirmingLabel ?? "this session"}?`;
+    return ["", `  ${style.accent(what)}  ${keyHint2("y", "yes")}   ${keyHint2("n", "no")}`];
   }
-  const keys = screen.mode === "gates" ? [keyHint2("a", "approve"), keyHint2("d", "deny"), keyHint2("j/k", "move"), keyHint2("r", "runs")] : screen.mode === "run" ? [
+  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")
@@ -1016,7 +2010,7 @@ async function* terminalKeys2() {
 async function openConsole(options) {
   let journal;
   const open = () => {
-    if (journal === void 0 && existsSync3(options.journalPath)) {
+    if (journal === void 0 && existsSync6(options.journalPath)) {
       journal = openJournal(options.journalPath, { mustExist: true });
     }
     return journal;
@@ -1027,32 +2021,41 @@ async function openConsole(options) {
     cursor: 0,
     openRun: void 0,
     confirming: void 0,
+    confirmingLabel: void 0,
+    confirmingForce: false,
+    warned: void 0,
+    expanded: false,
+    groups: [],
     busy: void 0,
     notice: "",
     noticeUntil: 0
   };
   let tick = 0;
   const stopped = () => screen.stop;
-  const say = (text) => {
+  const say = (text, ticks = NOTICE_TICKS2) => {
     screen.notice = text;
-    screen.noticeUntil = tick + NOTICE_TICKS2;
+    screen.noticeUntil = tick + ticks;
   };
   const frame = () => {
     const ready = open();
     if (ready === void 0) {
       return waitingForJournal2(options, tick);
     }
-    const room = roomFor(options);
-    const body = screen.mode === "runs" ? windowed(runsView(ready, screen, options), screen.cursor, room) : screen.mode === "run" ? windowed(runView(ready, screen), 0, room) : windowed(gatesView(ready, screen, options), screen.cursor, room);
-    const notice = screen.notice === "" ? [] : ["", `  ${style.accent(screen.notice)}`];
+    const tail = command(ready);
+    const shout = screen.notice === "" ? 0 : screen.notice.split("\n").length;
+    const room = Math.max(3, roomFor(options) - tail.length - shout);
+    const body = screen.mode === "runs" ? windowed(runsView(ready, screen, options), screen.cursor, room) : screen.mode === "run" ? windowed(runView(ready, screen), 0, room) : screen.mode === "connections" ? windowed(connectionsView(screen, options), screen.cursor, room) : windowed(gatesView(ready, screen, options), screen.cursor, room);
+    const notice = screen.notice === "" ? [] : ["", ...screen.notice.split("\n").map((line2) => `  ${style.accent(line2)}`)];
     return [
       ...header(options, screen, tick),
       ...body,
       ...notice,
+      ...tail,
       ...footer(screen, 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);
@@ -1060,6 +2063,40 @@ async function openConsole(options) {
     const runs = [...ready.listRuns()].reverse();
     return runs[Math.min(screen.cursor, runs.length - 1)];
   };
+  const nothingToUndo = (ready, run) => {
+    const actions = ready.getActions(run.id);
+    const why = actions.length === 0 ? "nothing was recorded in this session" : actions.every((action) => action.status === "rolled_back" || action.class === "readonly") ? "this session has already been undone" : "nothing in this session can be undone";
+    const other = elsewhere(ready, run.id);
+    return other === void 0 ? why : `${why} ${DOT} try ${other.label ?? "an agent"} ${other.id.slice(0, 8)}`;
+  };
+  const command = (ready) => {
+    if (!canPress(options) || screen.confirming !== void 0) {
+      return [];
+    }
+    if (screen.mode !== "runs" && screen.mode !== "run") {
+      return [];
+    }
+    const run = selectedRun(ready);
+    if (run === void 0) {
+      return [];
+    }
+    const here = standing(ready.getActions(run.id));
+    const id = run.id.slice(0, 8);
+    if (here.undoable > 0) {
+      return [
+        "",
+        `  ${style.quiet("u undoes it here")}  ${style.quiet(DOT)}  ${style.quiet("or from any terminal:")}  ` + style.strong(`${cliCommand()} undo ${id}`)
+      ];
+    }
+    if (here.conflicted > 0) {
+      return [
+        "",
+        `  ${style.accent(`${String(here.conflicted)} changed since this ran`)}  ${style.quiet(DOT)}  ` + style.quiet("u shows what undoing would write over"),
+        `  ${style.quiet("or from any terminal:")}  ${style.strong(`${cliCommand()} undo ${id} --force`)}`
+      ];
+    }
+    return ["", `  ${style.quiet("nothing to undo in this session")}`];
+  };
   const decide = (approve) => {
     const ready = open();
     if (ready === void 0) {
@@ -1076,7 +2113,7 @@ async function openConsole(options) {
     );
     screen.cursor = 0;
   };
-  const perform = async (runId, dryRun) => {
+  const perform = async (runId, dryRun, force = false) => {
     if (options.undo === void 0) {
       say("no way to undo was configured");
       return;
@@ -1087,11 +2124,18 @@ async function openConsole(options) {
     }
     screen.busy = dryRun ? "reading the current state..." : "putting it back...";
     try {
-      const report2 = await options.undo(runId, dryRun);
+      const report2 = await options.undo(runId, dryRun, force);
       const reverted = report2.steps.filter((step) => step.kind === "revert").length;
-      const halted = report2.halted === void 0 ? "" : ` ${DOT} halted: ${report2.halted.reason}`;
+      const why = report2.halted === void 0 ? "" : ` ${DOT} halted: ${firstLine(report2.halted.detail) || report2.halted.reason}`;
+      const headline = dryRun ? `${String(reverted)} would be reverted ${DOT} nothing changed${why}` : `${report2.status} ${DOT} ${String(reverted)} reverted${why}`;
+      const over = report2.halted?.overwrites ?? "";
+      if (over === "") {
+        say(headline);
+        return;
+      }
       say(
-        dryRun ? `${String(reverted)} would be reverted ${DOT} nothing changed${halted}` : `${report2.status} ${DOT} ${String(reverted)} reverted${halted}`
+        ["changed since this ran, so nothing was written", "", "undoing anyway would write:", ...over.split("\n"), "", "u again to do it"].join("\n"),
+        READING_TICKS
       );
     } catch (error) {
       say(error instanceof Error ? error.message : "the undo failed");
@@ -1099,12 +2143,63 @@ 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?.() ?? [];
+  };
+  const connect = async (targets) => {
+    if (options.connect === void 0) {
+      say("no way to connect was configured");
+      return;
+    }
+    if (targets.length === 0) {
+      say("everything here is already covered");
+      return;
+    }
+    if (screen.busy !== void 0) {
+      return;
+    }
+    screen.busy = `connecting ${String(targets.length)}${targets.length === 1 ? " server" : " servers"}`;
+    try {
+      say(await options.connect(targets));
+    } catch (error) {
+      say(error instanceof Error ? error.message : "connecting failed");
+    } finally {
+      screen.busy = void 0;
+      rescan();
+    }
+  };
   const press = (key) => {
     if (screen.confirming !== void 0) {
       const runId = screen.confirming;
+      const forcing = screen.confirmingForce;
       screen.confirming = void 0;
+      screen.confirmingForce = false;
+      screen.confirmingLabel = void 0;
       if (key === "y") {
-        void perform(runId, false);
+        screen.warned = void 0;
+        void perform(runId, false, forcing);
       } else {
         say("left alone");
       }
@@ -1127,7 +2222,23 @@ async function openConsole(options) {
         screen.mode = "gates";
         screen.cursor = 0;
         return;
+      case "c":
+        screen.mode = "connections";
+        screen.cursor = 0;
+        rescan();
+        return;
+      case "f":
+        if (screen.mode === "run") {
+          screen.expanded = !screen.expanded;
+          say(screen.expanded ? "showing everything recorded" : "back to a summary");
+        }
+        return;
       case "r":
+        if (screen.mode === "connections") {
+          rescan();
+          say("rescanned");
+          return;
+        }
         screen.mode = "runs";
         screen.cursor = 0;
         return;
@@ -1138,6 +2249,11 @@ async function openConsole(options) {
         return;
       case "\r":
       case "\n": {
+        if (screen.mode === "connections") {
+          const chosen = connectionRows(screen)[screen.cursor];
+          void connect(chosen === void 0 ? [] : [chosen]);
+          return;
+        }
         const ready = open();
         const run = ready === void 0 ? void 0 : selectedRun(ready);
         if (run !== void 0) {
@@ -1149,6 +2265,10 @@ async function openConsole(options) {
       case "a":
         if (screen.mode === "gates") {
           decide(true);
+          return;
+        }
+        if (screen.mode === "connections") {
+          void connect(needsConnecting(screen.groups));
         }
         return;
       case "d":
@@ -1156,24 +2276,73 @@ 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 (run !== void 0) {
-          void perform(run.id, true);
+        if (ready === void 0 || run === void 0) {
+          return;
+        }
+        const here = standing(ready.getActions(run.id));
+        if (here.undoable === 0 && here.conflicted === 0) {
+          say(nothingToUndo(ready, run));
+          return;
         }
+        void perform(run.id, true);
         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;
         }
         const ready = open();
         const run = ready === void 0 ? void 0 : selectedRun(ready);
-        if (run !== void 0) {
+        if (ready === void 0 || run === void 0) {
+          return;
+        }
+        const here = standing(ready.getActions(run.id));
+        if (here.undoable === 0 && here.conflicted === 0) {
+          say(nothingToUndo(ready, run));
+          return;
+        }
+        const label = `${run.label ?? "an agent"} ${shortTime(run.startedAt).trim()}`;
+        if (here.undoable === 0) {
+          if (screen.warned !== run.id) {
+            screen.warned = run.id;
+            void perform(run.id, true);
+            return;
+          }
           screen.confirming = run.id;
+          screen.confirmingForce = true;
+          screen.confirmingLabel = label;
+          return;
         }
+        screen.confirming = run.id;
+        screen.confirmingForce = false;
+        screen.confirmingLabel = label;
         return;
       }
       default:
@@ -1211,12 +2380,13 @@ 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) {
         break;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, interval));
+      await new Promise((resolve4) => setTimeout(resolve4, interval));
     }
     return 0;
   } finally {
@@ -1232,7 +2402,7 @@ async function openConsole(options) {
         await reader?.return?.(void 0);
         await reading;
       })(),
-      new Promise((resolve2) => setTimeout(resolve2, 50).unref())
+      new Promise((resolve4) => setTimeout(resolve4, 50).unref())
     ]);
     journal?.close();
   }
@@ -1248,24 +2418,36 @@ if (NODE_MAJOR < 22) {
   process.exit(2);
 }
 var COMMANDS = `
-  synartesis                                      the screen; everything below,
-                                                  driven with the arrow keys
+  synartesis                                      start here. Live activity,
+                                                  what is waiting for you, and
+                                                  undo -- all in one place, with
+                                                  the arrow keys. Everything
+                                                  below can be done from it.
+  synartesis install [--client <name>] [--dry-run] [--print]
+  synartesis uninstall [--client <name>]
+  synartesis status
   synartesis init <server> -- <command> [args...]  [--manifest <path>]
   synartesis check [--manifest <path>]
   synartesis list [--journal <path>]
-  synartesis show <runId> [--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>]
-  synartesis proxy --manifest <path> [--journal <path>]   what your agent runs
+  synartesis proxy --manifest <path> [--server <name>]    what your agent runs
+                  [--journal <path>]
                   [--http <port> --token <secret>]      for a client that
                                                         cannot start one
   synartesis watch [--by <name>] [--journal <path>]
   synartesis approve [actionId|--all] [--by <name>] [--journal <path>]
   synartesis deny [actionId|--all] [--by <name>] [--reason <text>] [--journal <path>]
-  synartesis undo [runId] [--to <seq>] [--dry-run] [--replan]
+  synartesis undo [runId] [--to <seq>] [--dry-run] [--replan] [--force [--yes]]
                           [--manifest <path>] [--journal <path>]
 
+install is the short way in: it finds what Claude Code, Claude Desktop,
+Cursor or Codex already list, writes a policy covering all of it -- using the ones that
+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.
+
 close ends a run left active by a proxy that was killed; nothing guesses at
 that, since several proxies can share one journal.
 
@@ -1280,6 +2462,15 @@ adds to an existing manifest rather than replacing it.
 watch is the one to leave running. Anything held for approval appears there,
 and a and d answer it without a second terminal or an id to copy.
 
+undo stops when somebody has changed the resource since, rather than writing
+over them. Three ways past that, and it prints all three: leave it, put the
+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
   --to        lowest sequence to undo; earlier actions are left alone
@@ -1290,6 +2481,8 @@ and a and d answer it without a second terminal or an id to copy.
   --dry-run   read current state and print the plan without changing anything
   --replan    rebuild each undo from the current manifest, for a run recorded
               under a policy that turned out to be wrong
+  --force     undo even where the resource changed after the run. On its own it
+              prints the lines it would write over and stops; add --yes to do it
   --older-than  days of history prune keeps; defaults to 30
   --version   print the version and exit
 
@@ -1314,7 +2507,7 @@ function flag(argv, name) {
   return value;
 }
 function positional(argv) {
-  const skip = /* @__PURE__ */ new Set(["--manifest", "--journal", "--to", "--by", "--reason", "--gate-timeout", "--older-than"]);
+  const skip = /* @__PURE__ */ new Set(["--manifest", "--journal", "--to", "--by", "--reason", "--gate-timeout", "--older-than", "--client"]);
   const values = [];
   const end = argv.indexOf("--");
   const ours = end === -1 ? argv : argv.slice(0, end);
@@ -1369,6 +2562,197 @@ async function runCheck(argv) {
   out("");
   return 0;
 }
+async function runInstall(argv) {
+  const manifestPath = findManifest(flag(argv, "--manifest"));
+  const only = flag(argv, "--client");
+  const dryRun = argv.includes("--dry-run");
+  const printOnly = argv.includes("--print");
+  const sites = discover(process.cwd()).filter(
+    (site) => only === void 0 || site.client === only
+  );
+  if (sites.length === 0) {
+    out("");
+    out(`  ${style.quiet("No MCP client config was found on this machine.")}`);
+    out(`  ${style.quiet("Looked for Claude Code, Claude Desktop, Cursor and Codex.")}`);
+    out("");
+    return 0;
+  }
+  const invoker = invokerFor(version(), fileURLToPath2(import.meta.url));
+  const { plans, yaml } = await planInstall(sites, manifestPath, invoker);
+  const total = plans.reduce((sum, plan) => sum + plan.servers.length, 0);
+  out("");
+  if (invoker.note !== void 0 && total > 0) {
+    out(`  ${style.accent("note")}  ${style.quiet(invoker.note)}`);
+  }
+  out(`  ${style.label(dryRun || printOnly ? "would cover" : "covering")}  ${style.strong(manifestPath)}`);
+  out(`  ${rule(60)}`);
+  for (const plan of plans) {
+    out("");
+    out(`  ${style.strong(plan.site.label)} ${style.quiet(plan.site.scope)}`);
+    out(`  ${style.quiet(plan.site.path)}`);
+    for (const server of plan.servers) {
+      const note = server.adopted === void 0 ? style.accent("drafted, every tool held until you say how to undo it") : style.quiet(`the policy that ships for ${server.adopted} (${String(server.tools ?? 0)} tools)`);
+      out(`    ${style.strong(server.name.padEnd(18))} ${note}`);
+    }
+    for (const skip of plan.skipped) {
+      out(`    ${style.quiet(skip.name.padEnd(18))} ${style.quiet(skip.why)}`);
+    }
+    if (plan.servers.length === 0 && plan.skipped.length === 0) {
+      out(`    ${style.quiet("no servers listed")}`);
+    }
+  }
+  if (printOnly) {
+    out("");
+    out(`  ${style.label("entries")}`);
+    for (const plan of plans) {
+      for (const server of plan.servers) {
+        out(`  ${JSON.stringify({ [server.name]: server.wrapped }, void 0, 2)}`);
+      }
+    }
+    out("");
+    return 0;
+  }
+  if (total === 0) {
+    out("");
+    out(`  ${style.quiet("Nothing to do; everything found is already covered.")}`);
+    out("");
+    return 0;
+  }
+  if (dryRun) {
+    out("");
+    out(`  ${style.quiet("Nothing was written. Run without --dry-run to apply.")}`);
+    out("");
+    return 0;
+  }
+  const applied = applyInstall(plans, manifestPath, yaml);
+  out("");
+  for (const entry of applied) {
+    out(`  ${style.quiet("backed up to")} ${entry.backup}`);
+  }
+  out("");
+  out(`  ${style.quiet("Restart your client, and its servers now run through Synartesis.")}`);
+  out("");
+  out(`  ${style.quiet("One command shows everything and does everything:")}`);
+  out(`  ${style.accent(cliCommand())}`);
+  out("");
+  out(
+    `  ${style.quiet("Live activity, what is held for approval, and undo, all from there.")}`
+  );
+  out(`  ${style.quiet("You do not need a second terminal unless you want one.")}`);
+  out("");
+  return 0;
+}
+async function runUninstall(argv) {
+  const manifestPath = findManifest(flag(argv, "--manifest"));
+  const only = flag(argv, "--client");
+  const sites = discover(process.cwd()).filter(
+    (site) => only === void 0 || site.client === only
+  );
+  const restored = applyUninstall(sites, manifestPath);
+  out("");
+  if (restored.length === 0) {
+    out(`  ${style.quiet("Nothing was covered, so nothing was changed.")}`);
+    out("");
+    return 0;
+  }
+  out(`  ${style.label("restored")}`);
+  out(`  ${rule(60)}`);
+  for (const entry of restored) {
+    out("");
+    out(`  ${style.strong(entry.site.label)} ${style.quiet(entry.site.scope)}`);
+    for (const name of entry.servers) {
+      out(`    ${style.strong(name)}`);
+    }
+    for (const name of entry.unknown) {
+      out(
+        `    ${style.accent(name)} ${style.quiet("is wrapped but its original was not recorded; left as it is")}`
+      );
+    }
+    if (entry.backup !== "") {
+      out(`    ${style.quiet(`backed up to ${entry.backup}`)}`);
+    }
+  }
+  out("");
+  out(`  ${style.quiet("The policy and journal were left alone.")}`);
+  out("");
+  return await Promise.resolve(0);
+}
+function openIfPresent(journalPath) {
+  try {
+    return existsSync7(journalPath) ? openJournal(journalPath, { mustExist: true }) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function connectThese(targets, manifestPath) {
+  const invoker = invokerFor(version(), fileURLToPath2(import.meta.url));
+  const wanted = /* @__PURE__ */ new Map();
+  const sites = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const key = `${target.site.path}${target.site.scope}`;
+    sites.set(key, target.site);
+    (wanted.get(key) ?? wanted.set(key, /* @__PURE__ */ new Set()).get(key))?.add(target.server);
+  }
+  const { plans, yaml } = await planInstall([...sites.values()], manifestPath, invoker);
+  const narrowed = plans.map((plan) => ({
+    ...plan,
+    servers: plan.servers.filter(
+      (server) => wanted.get(`${plan.site.path}${plan.site.scope}`)?.has(server.name) === true
+    )
+  }));
+  const applied = applyInstall(narrowed, manifestPath, yaml);
+  const count = applied.reduce((sum, entry) => sum + entry.servers.length, 0);
+  if (count === 0) {
+    return "nothing was connected; see the reasons above";
+  }
+  return `connected ${String(count)}${count === 1 ? " server" : " servers"} \xB7 restart the client to pick it up`;
+}
+function runStatus(argv) {
+  const manifestPath = findManifest(flag(argv, "--manifest"));
+  const journalPath = findJournal(flag(argv, "--journal"), manifestPath);
+  out("");
+  out(
+    `  ${style.label("policy")}   ${existsSync7(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))}`}`
+  );
+  out("");
+  const journal = openIfPresent(journalPath);
+  try {
+    const groups = scan(journal, process.cwd());
+    if (groups.length === 0) {
+      out(`  ${style.quiet("No MCP client config found.")}`);
+      out(`  ${style.quiet("Looked for Claude Code, Claude Desktop, Cursor and Codex.")}`);
+      out("");
+      return 0;
+    }
+    const now = /* @__PURE__ */ new Date();
+    for (const group of groups) {
+      out(`  ${style.strong(group.label)} ${style.quiet(group.scope)}`);
+      if (group.problem !== void 0) {
+        out(`      ${style.accent(group.problem)}`);
+      } else if (group.connections.length === 0) {
+        out(`      ${style.quiet("no servers listed")}`);
+      }
+      for (const connection of group.connections) {
+        const state = stateOf(connection, now);
+        out(
+          `    ${connection.server.padEnd(20)} ${connection.covered ? style.quiet(state) : style.accent(state)}`
+        );
+      }
+      out("");
+    }
+    const waiting = needsConnecting(groups).length;
+    out(
+      waiting === 0 ? `  ${style.quiet("Everything found is covered.")}` : `  ${style.accent(`${String(waiting)} not covered.`)} ${style.quiet(`${cliCommand()} install covers them.`)}`
+    );
+    out("");
+  } finally {
+    journal?.close();
+  }
+  return 0;
+}
 async function runInit(argv) {
   const name = positional(argv)[1];
   const separator = argv.indexOf("--");
@@ -1381,7 +2765,7 @@ async function runInit(argv) {
   }
   const path = findManifest(flag(argv, "--manifest"));
   const force = argv.includes("--force");
-  const present = existsSync4(path);
+  const present = existsSync7(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.`
@@ -1391,11 +2775,11 @@ async function runInit(argv) {
     name,
     command,
     args: argv.slice(separator + 2),
-    ...present ? { existing: readFileSync2(path, "utf8") } : {}
+    ...present ? { existing: readFileSync4(path, "utf8") } : {}
   });
   parseManifest(draft.yaml, path);
-  mkdirSync(dirname(resolve(path)), { recursive: true, mode: 448 });
-  writeFileSync(path, draft.yaml);
+  mkdirSync2(dirname3(resolve3(path)), { recursive: true, mode: 448 });
+  writeFileSync3(path, draft.yaml);
   out("");
   out(`  ${style.label(present ? "extended" : "wrote")}  ${style.strong(path)}`);
   out(`  ${rule(54)}`);
@@ -1410,7 +2794,7 @@ async function runInit(argv) {
     out(`  ${style.quiet("Read it before you trust it, then point your MCP client at:")}`);
   }
   out("");
-  out(`  ${style.accent(`${proxyCommand()} --manifest ${resolve(path)}`)}`);
+  out(`  ${style.accent(`${proxyCommand()} --manifest ${resolve3(path)}`)}`);
   out("");
   return 0;
 }
@@ -1472,12 +2856,12 @@ function runList(journal, asJson, journalPath) {
     return 0;
   }
   out("");
-  out(`  ${style.label("runs")}  ${style.quiet("most recent first")}`);
+  out(`  ${style.label("sessions")}  ${style.quiet("most recent first")}`);
   out(`  ${rule(96)}`);
   out("");
   out(
     style.quiet(
-      `  ${"run".padEnd(36)}  ${"started".padEnd(24)}  ${"status".padEnd(12)}  actions  agent`
+      `  ${"session".padEnd(36)}  ${"started".padEnd(15)}  ${"status".padEnd(12)}  actions  agent`
     )
   );
   for (const run of runs) {
@@ -1490,7 +2874,7 @@ function runList(journal, asJson, journalPath) {
     ].filter((note2) => note2 !== "");
     const note = notes.length === 0 ? "" : `  ${style.accent(`(${notes.join("; ")})`)}`;
     out(
-      `  ${style.strong(run.id)}  ${style.quiet(run.startedAt)}  ${run.status.padEnd(12)}  ${String(actions.length).padStart(7)}  ${run.label ?? "-"}${note}`
+      `  ${style.strong(run.id)}  ${style.quiet(shortTime(run.startedAt).trimEnd().padEnd(13))}  ${run.status.padEnd(12)}  ${String(actions.length).padStart(7)}  ${run.label ?? "-"}${note}`
     );
   }
   out("");
@@ -1500,22 +2884,34 @@ 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("");
-  out(`  ${style.label("run")}  ${style.strong(run.id)}`);
+  out(`  ${style.label("session")}  ${style.strong(run.label ?? "an agent")}  ${style.quiet(run.id)}`);
   out(`  ${rule(54)}`);
   out("");
   out(`  ${style.quiet("agent  ")} ${run.label ?? "-"}`);
-  out(`  ${style.quiet("started")} ${run.startedAt}`);
+  out(`  ${style.quiet("started")} ${fullTime(run.startedAt)}  ${style.quiet(ago(run.startedAt))}`);
   out(
-    `  ${style.quiet("status ")} ${run.status}` + (run.endedAt === void 0 ? "" : style.quiet(`  ended ${run.endedAt}`))
+    `  ${style.quiet("status ")} ${run.status}` + (run.endedAt === void 0 ? "" : style.quiet(`  ended ${fullTime(run.endedAt)}`))
   );
   const actions = journal.getActions(runId);
   if (actions.length === 0) {
@@ -1528,29 +2924,87 @@ 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)} ${statusOf2(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)}`)
     );
-    out(`       ${style.quiet(truncate3(JSON.stringify(action.args), 96))}`);
+    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)) {
+        out(`         ${line2}`);
+      }
+    } else {
+      out(`       ${style.quiet(summariseArgs(action.args, 96))}`);
+    }
     if (action.approvedAt !== void 0) {
       const verb = action.status === "denied" ? "denied" : "approved";
       out(
-        `       ${style.accent(`${verb} by ${action.approvedBy ?? "nobody"}`)} ${style.quiet(`at ${action.approvedAt}`)}`
+        `       ${style.accent(`${verb} by ${action.approvedBy ?? "nobody"}`)} ${style.quiet(`at ${fullTime(action.approvedAt)}`)}`
       );
     }
     if (action.error !== void 0) {
-      out(`       ${style.quiet(`note: ${truncate3(action.error, 200)}`)}`);
+      out(`       ${style.quiet(`note: ${full ? action.error : truncate3(action.error, 200)}`)}`);
+    }
+    if (action.snapshot !== void 0 && full) {
+      out(`       ${style.quiet("what it replaced")}`);
+      for (const line2 of block(action.snapshot)) {
+        out(`         ${line2}`);
+      }
     }
     if (action.inverse !== void 0) {
-      out(`       ${style.quiet("undo:")} ${truncate3(JSON.stringify(action.inverse), 200)}`);
+      if (full) {
+        out(`       ${style.quiet("undo")}`);
+        for (const line2 of block(action.inverse)) {
+          out(`         ${line2}`);
+        }
+      } else {
+        out(`       ${style.quiet("undo:")} ${style.quiet(summariseArgs(inverseArgs(action.inverse), 90))}`);
+      }
     }
   }
   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",
@@ -1563,7 +3017,7 @@ function badgeOf(action) {
   const plain = `${CLASS_MARK[action.class]} ${action.class}`.padEnd(BADGE_WIDTH);
   return action.class === "irreversible" ? style.accent(plain) : style.quiet(plain);
 }
-function statusOf2(action) {
+function statusOf(action) {
   const text = labelFor(action).padEnd(13);
   if (wasRefused(action)) {
     return style.accent(text);
@@ -1591,6 +3045,15 @@ function wrapped(text, width) {
   }
   return lines;
 }
+function block(value) {
+  return JSON.stringify(value, void 0, 2).split("\n").map((line2) => style.quiet(line2));
+}
+function inverseArgs(inverse) {
+  if (typeof inverse === "object" && inverse !== null && "args" in inverse) {
+    return inverse.args;
+  }
+  return inverse;
+}
 function truncate3(text, limit) {
   return text.length <= limit ? text : `${text.slice(0, limit - 3)}...`;
 }
@@ -1761,7 +3224,7 @@ function runDecision(argv, journal, approving) {
   }
   return failed === 0 ? 0 : 1;
 }
-function report(result) {
+function report(result, alreadyForcing = false) {
   out("");
   out(`  ${style.label(result.dryRun ? "dry run" : "undo")}  ${style.strong(result.runId)}`);
   out(`  ${rule(72)}`);
@@ -1786,15 +3249,37 @@ function report(result) {
     }
   }
   if (result.halted !== void 0) {
+    const halt = result.halted;
     out("");
     out(
-      `  ${style.accent("halted")} ${style.quiet(`at sequence ${String(result.halted.seq)}`)}  ${result.halted.reason}`
+      `  ${style.accent("halted")} ${style.quiet(`at ${String(halt.seq)}`)}  ${halt.reason}
+  ${style.quiet("nothing was written here")}`
     );
-    if (result.halted.detail !== "") {
-      for (const line2 of result.halted.detail.split("\n")) {
+    if (halt.detail !== "") {
+      out("");
+      for (const line2 of halt.detail.split("\n")) {
+        out(`  ${style.quiet(line2)}`);
+      }
+    }
+    if (halt.overwrites !== void 0 && halt.overwrites !== "") {
+      out("");
+      out(`  ${style.accent("undoing anyway would write:")}`);
+      for (const line2 of halt.overwrites.split("\n")) {
         out(`  ${style.quiet(line2)}`);
       }
     }
+    if (halt.conflict === true && !alreadyForcing) {
+      const self = cliCommand();
+      const id = result.runId.slice(0, 8);
+      out("");
+      out(`  ${style.quiet("keep the change, drop the undo:")}   ${style.quiet("nothing to do")}`);
+      out(
+        `  ${style.quiet("put it back as the run left it:")}  ${style.strong(`${self} undo ${id} --replan`)}`
+      );
+      out(
+        `  ${style.quiet("undo anyway, losing the change:")}   ${style.strong(`${self} undo ${id} --force`)}`
+      );
+    }
   }
   const permanent = result.steps.filter((step) => step.kind === "permanent");
   if (permanent.length > 0) {
@@ -1810,37 +3295,99 @@ function report(result) {
   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 }
-        })
-      );
+      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({
-      journal,
-      router: createRouter(upstreams, manifest),
-      runId,
-      ...options.toSeq === void 0 ? {} : { toSeq: options.toSeq },
-      dryRun: options.dryRun,
-      ...options.replan === true ? { replanWith: manifest } : {}
-    });
+    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 runId = pick([...journal.listRuns()].reverse(), positional(argv)[1], RUN, true).id;
+  const given = positional(argv)[1];
+  const chosen = pick([...journal.listRuns()].reverse(), given, RUN, true);
+  const runId = chosen.id;
+  if (given === void 0) {
+    const actions = journal.getActions(runId);
+    const left = actions.filter((action) => action.status === "applied").length;
+    out("");
+    out(
+      `  ${style.quiet("no session named, so the most recent:")} ${style.strong(runId.slice(0, 8))} ` + style.quiet(`${chosen.label ?? "an agent"}, ${shortTime(chosen.startedAt).trim()}`)
+    );
+    if (left === 0) {
+      out("");
+      out(
+        `  ${style.quiet(
+          actions.length === 0 ? "Nothing was recorded in it, so there is nothing to undo." : "Nothing in it is still applied; it has already been undone."
+        )}`
+      );
+      const other = [...journal.listRuns()].reverse().find(
+        (run) => run.id !== runId && journal.getActions(run.id).some((action) => action.status === "applied" && action.inverse !== void 0)
+      );
+      if (other !== void 0) {
+        out("");
+        out(
+          `  ${style.quiet("The session that did something:")} ${style.strong(other.id.slice(0, 8))} ` + style.quiet(`${other.label ?? "an agent"}, ${shortTime(other.startedAt).trim()}`)
+        );
+        out(`  ${style.quiet(`${cliCommand()} undo ${other.id.slice(0, 8)}`)}`);
+      } else {
+        out(
+          `  ${style.quiet(`Name one to undo a different session: ${cliCommand()} undo <session>`)}`
+        );
+      }
+      out("");
+      return 0;
+    }
+  }
   const rawTo = flag(argv, "--to");
   const toSeq = rawTo === void 0 ? void 0 : Number(rawTo);
   if (toSeq !== void 0 && (!Number.isInteger(toSeq) || toSeq < 1)) {
@@ -1854,15 +3401,60 @@ async function runUndo(argv, journal) {
       );
     }
   }
+  const forcing = argv.includes("--force");
+  const said = argv.includes("--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)
+    );
+    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 report(
-    await performUndo(findManifest(flag(argv, "--manifest")), journal, runId, {
+    await performUndo(manifestPath, journal, runId, {
       dryRun: argv.includes("--dry-run"),
       ...toSeq === void 0 ? {} : { toSeq },
-      replan: argv.includes("--replan")
-    })
+      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
+  // accepted at all, and the skip set in positional() decides whether its
+  // value is mistaken for a command. --client was in one and not the other,
+  // so `install --client codex` printed the help instead of installing.
+  "--client",
+  "--print",
+  "--full",
+  "--live",
   "--manifest",
   "--journal",
   "--to",
@@ -1874,6 +3466,7 @@ var FLAGS = /* @__PURE__ */ new Set([
   "--replan",
   "--reason",
   "--force",
+  "--yes",
   "--older-than",
   "--help",
   "-h",
@@ -1882,8 +3475,8 @@ var FLAGS = /* @__PURE__ */ new Set([
 ]);
 function version() {
   try {
-    const root = dirname(fileURLToPath2(import.meta.url));
-    const parsed = JSON.parse(readFileSync2(join(root, "..", "package.json"), "utf8"));
+    const root = dirname3(fileURLToPath2(import.meta.url));
+    const parsed = JSON.parse(readFileSync4(join2(root, "..", "package.json"), "utf8"));
     const found = typeof parsed === "object" && parsed !== null ? parsed.version : void 0;
     return typeof found === "string" ? found : "unknown";
   } catch {
@@ -1901,7 +3494,7 @@ function rejectUnknownFlags(argv) {
   }
 }
 function openJournalOrExplain(journalPath) {
-  if (!existsSync4(journalPath)) {
+  if (!existsSync7(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.`
     );
@@ -1930,13 +3523,30 @@ ${COMMANDS}`);
     const journalPath2 = findJournal(flag(argv, "--journal"), manifestPath);
     return await openConsole({
       journalPath: journalPath2,
+      scan: () => scan(openIfPresent(journalPath2), process.cwd()),
+      connect: async (targets) => await connectThese(targets, manifestPath),
       write: (text) => process.stdout.write(text),
       live: process.stdout.isTTY,
       decideAs: flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown",
-      undo: async (runId, dryRun) => {
+      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 {
-          return await performUndo(manifestPath, journal2, runId, { dryRun });
+          return await performUndo(manifestPath, journal2, runId, {
+            dryRun,
+            ...force === true ? { force: true } : {}
+          });
         } finally {
           journal2.close();
         }
@@ -1949,6 +3559,15 @@ ${COMMANDS}`);
   if (command === "check") {
     return await runCheck(argv);
   }
+  if (command === "install") {
+    return await runInstall(argv);
+  }
+  if (command === "uninstall") {
+    return await runUninstall(argv);
+  }
+  if (command === "status") {
+    return runStatus(argv);
+  }
   const asJson = argv.includes("--json");
   const given = flag(argv, "--journal");
   const journalPath = findJournal(given, findManifest(flag(argv, "--manifest")));
@@ -1964,8 +3583,8 @@ ${COMMANDS}`);
       decideAs: flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown"
     });
   }
-  journalArg = given === void 0 ? "" : ` --journal ${resolve(given)}`;
-  if (!existsSync4(journalPath) && (command === "list" || command === "show" || command === "gates")) {
+  journalArg = given === void 0 ? "" : ` --journal ${resolve3(given)}`;
+  if (!existsSync7(journalPath) && (command === "list" || command === "show" || command === "gates")) {
     if (asJson) {
       out(JSON.stringify(command === "show" ? { run: null, actions: [] } : []));
       return 0;
@@ -1985,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":