synartesis 0.9.1 → 0.9.2

package/CHANGELOG.md

@@ -2,6 +2,54 @@
 
 What changed, and why it mattered. Dates are release dates.
 
+## 0.9.2 — 2026-09-24
+
+For someone who has never used a terminal. Every screen was walked through as a
+new user would meet it, in a real terminal, from a fresh machine. Each place
+they would have got stuck is fixed.
+
+### Added
+
+- **`synartesis clean`**: one command, no questions to answer first. It clears
+  every finished session with nothing left to undo, and closes sessions left
+  open by an app that has since exited. It keeps anything you could still undo,
+  anything waiting for you, and anything whose outcome is unknown. Your
+  connected apps and your policy are not touched. It shows what it will do and
+  asks once. On a journal three weeks old it cleared 119 of 126 sessions.
+  `list` suggests it once there is clutter worth clearing.
+- Sessions now record which process opened them, so one left open by an app
+  that crashed or was force-quit can be told apart from one still in use.
+
+### Fixed
+
+- **The first screen was a dead end.** `synartesis` on a fresh machine said
+  "point your client at it" and accepted no keys. It now opens on the AI apps
+  found and their tools: `a` covers all of them, `enter` covers one. When the
+  first session arrives it switches to the sessions by itself.
+- **`watch` ignored keys.** With nothing waiting it showed no keys at all, not
+  even how to quit, and silently swallowed every key pressed. It always shows
+  its keys now, says so when there is nothing to approve yet, and answers a key
+  that does nothing instead of ignoring it. The console does the same.
+- **Opening `synartesis` because of a notification landed on the wrong
+  screen.** Approving was a screen away, behind a key labelled "held", so `a`
+  did nothing. It opens on the waiting call now, shows why it was held, and
+  flags new ones from any other screen.
+- **The notification said to type an approve command** with an id and an
+  absolute path, cut off before its end. It now says to open a terminal and run
+  `synartesis`.
+- After covering apps from the screen, it names which apps to quit and reopen,
+  and says why any server was not covered. It used to say "see the reasons
+  above" on a screen with nothing above.
+- The proxy wrote a routine schema note into the client's log as a warning, once
+  per tool on every start (fourteen for the filesystem server). It is debug
+  level now.
+
+### Docs
+
+- The README's Install section is three steps for somebody who has never used a
+  terminal, then what to do when something needs your OK, how to undo, how to
+  clean up, and how to take it all out.
+
 ## 0.9.1 — 2026-09-24
 
 This release attacks undo instead of describing it. The new tests generate the

package/README.md

@@ -92,23 +92,48 @@ and `--replan`, or `--force` to overwrite deliberately.
 ---
 ## Install
 
-```bash
-npm install -g synartesis
-```
-
-Then, from anywhere:
-
-```bash
-synartesis install
-```
-
-That finds what Claude Code, Claude Desktop, Cursor, Codex, Gemini CLI, Copilot
-CLI, Antigravity or Devin Desktop (Windsurf) already list,
-writes one policy covering all of it, and points each entry at the proxy.
-Servers it recognises get the policy that ships for them and work immediately;
-the rest are drafted with every tool held until you say how to undo it. Your
-config is copied aside first, `synartesis uninstall` puts it back, and
-`synartesis status` says what is covered.
+**Three steps, if you have never used a terminal.** Open the Terminal app
+(on a Mac: press ⌘ Space, type *Terminal*, press Return), then:
+
+1. If `npm --version` says *command not found*, install Node.js from
+   [nodejs.org](https://nodejs.org) first (the LTS button), and open a new
+   Terminal window.
+2. Install Synartesis:
+
+   ```bash
+   npm install -g synartesis
+   ```
+
+3. Start it:
+
+   ```bash
+   synartesis
+   ```
+
+   It lists the AI apps on your computer and the tools they use. Press **a** to
+   cover all of them, then **quit and reopen** those apps (it names them).
+
+That is the whole setup. From then on:
+
+- **Something needs your OK.** A notification says a call is waiting. Open
+  Terminal, type `synartesis`: it opens on that call. **a** approves, **d**
+  denies, **A** approves and stops asking about that tool for an hour.
+- **Undo what an agent did.** Type `synartesis`, press **r** if it is showing
+  waiting calls, move to the session with the arrow keys, press **u**, then
+  **y**. Press **p** first to see what it would do without changing anything.
+- **Too many old sessions.** `synartesis clean` clears the finished ones and
+  keeps anything you could still undo or still need to decide.
+- **Take it all back out.** `synartesis uninstall` restores every app's
+  settings exactly as they were.
+
+The same thing without the screen: `synartesis install`. It finds what Claude
+Code, Claude Desktop, Cursor, Codex, Gemini CLI, Copilot CLI, Antigravity or
+Devin Desktop (Windsurf) already list, writes one policy covering all of it,
+and points each entry at the proxy. Servers it recognises get the policy that
+ships for them and work immediately; the rest are drafted with every tool held
+until you say how to undo it. Your config is copied aside first,
+`synartesis uninstall` puts it back, and `synartesis status` says what is
+covered.
 
 Each server keeps its own entry and its own proxy, so **no tool is renamed** —
 the agent sees exactly the names it saw before. **Your agent needs nothing
@@ -487,6 +512,7 @@ get it if it is not installed.
 | `undo <id> --replan` | Rebuild each undo from the current manifest |
 | `undo <id> --force [--yes]` | Print what it would write over; `--yes` goes ahead |
 | `watch` | Live activity, with approvals answerable in place |
+| `clean` | Clear finished sessions; keep anything you could undo or still need to decide |
 | `prune` | Delete sessions older than 30 days and reclaim the space |
 | `close [id]` | End a session a killed proxy left open |
 

package/dist/{chunk-H4SPMXQW.js → chunk-MTPUG26S.js}

@@ -31,10 +31,10 @@ function shown(name) {
 function unmarked(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function words(notice) {
+function words(notice, open) {
   return {
     title: "Synartesis: a call is waiting for you",
-    body: `${shown(notice.server)}.${shown(notice.tool)} -- ${notice.approve}`
+    body: `${shown(notice.server)}.${shown(notice.tool)} -- open a terminal and run: ${open ?? notice.approve}`
   };
 }
 var KILL_AFTER_MS = 5e3;
@@ -51,13 +51,13 @@ function launch(command, args) {
   } catch {
   }
 }
-function desktopNotifier(env = process.env, os = platform()) {
+function desktopNotifier(env = process.env, os = platform(), open) {
   if (env["SYNARTESIS_NOTIFY"] === "0") {
     return SILENT;
   }
   if (os === "darwin") {
     return (notice) => {
-      const { title, body } = words(notice);
+      const { title, body } = words(notice, open);
       launch("osascript", [
         "-e",
         "on run argv",
@@ -73,7 +73,7 @@ function desktopNotifier(env = process.env, os = platform()) {
   }
   if (os === "linux") {
     return (notice) => {
-      const { title, body } = words(notice);
+      const { title, body } = words(notice, open);
       launch("notify-send", ["--app-name=Synartesis", "--", title, unmarked(body)]);
     };
   }
@@ -439,6 +439,19 @@ CREATE TABLE IF NOT EXISTS allows (
 );
 CREATE INDEX IF NOT EXISTS allows_current ON allows(server, tool, until);
 
+-- Which process opened each session, so a session left open by an app that
+-- has since exited can be told from one still in use. Without it, closing an
+-- abandoned session was a person's guess (synartesis close), and every
+-- session a crashed or force-quit app left behind stayed "still open" in the
+-- list for ever. host and pid for the reason leases have both.
+--
+-- Not a schema version bump, for the reason the tables above are not.
+CREATE TABLE IF NOT EXISTS run_owners (
+  run_id  TEXT PRIMARY KEY REFERENCES runs(id),
+  host    TEXT NOT NULL,
+  pid     INTEGER NOT NULL
+);
+
 CREATE INDEX IF NOT EXISTS actions_by_run ON actions(run_id, seq);
 
 -- Deliberately not a schema version bump. Adding an index changes no row and
@@ -752,7 +765,10 @@ var SqliteJournal = class {
   beginRun(label) {
     const id = crypto.randomUUID();
     this.#run("beginRun", () => {
-      this.#db.prepare("INSERT INTO runs (id, label, started_at, status) VALUES (?, ?, ?, 'active')").run(id, label ?? null, (/* @__PURE__ */ new Date()).toISOString());
+      this.#db.transaction(() => {
+        this.#db.prepare("INSERT INTO runs (id, label, started_at, status) VALUES (?, ?, ?, 'active')").run(id, label ?? null, (/* @__PURE__ */ new Date()).toISOString());
+        this.#db.prepare("INSERT INTO run_owners (run_id, host, pid) VALUES (?, ?, ?)").run(id, hostname(), process.pid);
+      })();
     });
     return id;
   }
@@ -1230,6 +1246,64 @@ var SqliteJournal = class {
   close() {
     this.#db.close();
   }
+  cleanable(idleBefore) {
+    return this.#run("cleanable", () => {
+      const here = hostname();
+      const open = z.array(
+        z.object({
+          id: z.string(),
+          host: z.string().nullable(),
+          pid: z.number().nullable(),
+          last: z.string()
+        })
+      ).parse(
+        this.#db.prepare(
+          `SELECT r.id, o.host, o.pid,
+                      COALESCE((SELECT MAX(a.ts) FROM actions a WHERE a.run_id = r.id), r.started_at) AS last
+                 FROM runs r LEFT JOIN run_owners o ON o.run_id = r.id
+                WHERE r.status = 'active'`
+        ).all()
+      );
+      const abandoned = open.filter(
+        (run) => run.pid === null ? run.last < idleBefore : (
+          // Only a process on this machine can be asked about; one opened
+          // elsewhere on a shared journal is left alone.
+          run.host === here && !running(run.pid)
+        )
+      ).map((run) => run.id);
+      const closing = new Set(abandoned);
+      const finished = z.array(
+        z.object({
+          id: z.string(),
+          label: z.string().nullable(),
+          status: z.enum(["active", "complete", "rolled_back", "partial"]),
+          at: z.string(),
+          actions: z.number()
+        })
+      ).parse(
+        this.#db.prepare(
+          `SELECT r.id, r.label, r.status, COALESCE(r.ended_at, r.started_at) AS at,
+                      (SELECT COUNT(*) FROM actions a WHERE a.run_id = r.id) AS actions
+                 FROM runs r
+                WHERE NOT EXISTS (
+                        SELECT 1 FROM actions a
+                         WHERE a.run_id = r.id
+                           AND a.status IN ('pending','gated','approved','rolling_back','unrecoverable'))
+                  AND NOT EXISTS (
+                        SELECT 1 FROM actions a
+                         WHERE a.run_id = r.id AND a.status = 'applied' AND a.inverse_json IS NOT NULL)
+                ORDER BY at, r.rowid`
+        ).all()
+      ).filter((run) => run.status !== "active" || closing.has(run.id)).map((run) => ({
+        id: run.id,
+        label: run.label ?? void 0,
+        at: run.at,
+        status: run.status === "active" ? "complete" : run.status,
+        actions: run.actions
+      }));
+      return { abandoned, finished };
+    });
+  }
   prunableRuns(before) {
     return this.#run(
       "prunableRuns",
@@ -1285,7 +1359,9 @@ var SqliteJournal = class {
         const dropDenials = this.#db.prepare(
           "DELETE FROM denials WHERE action_id IN (SELECT id FROM actions WHERE run_id = ?)"
         );
+        const dropOwner = this.#db.prepare("DELETE FROM run_owners WHERE run_id = ?");
         for (const id of ids) {
+          dropOwner.run(id);
           dropServers.run(id);
           dropLeases.run(id);
           dropDenials.run(id);
@@ -3908,6 +3984,8 @@ export {
   cliCommand,
   cliCommandFrom,
   proxyCommand,
+  JOURNAL_NAME,
+  home,
   findManifest,
   findJournal,
   counted,
@@ -3973,4 +4051,4 @@ export {
   applyUninstall,
   clientEnvFor
 };
-//# sourceMappingURL=chunk-H4SPMXQW.js.map
+//# sourceMappingURL=chunk-MTPUG26S.js.map

package/dist/cli.js

@@ -62,7 +62,7 @@ import {
   verifyAgainstServers,
   warnUntested,
   wasRefused
-} from "./chunk-H4SPMXQW.js";
+} from "./chunk-MTPUG26S.js";
 import {
   DriftConflict,
   ManifestError,
@@ -1126,7 +1126,12 @@ function render(journal, options, tick, view) {
     });
     out2.push("");
     out2.push(
-      canDecide(options) ? `  ${keyHint("a", "approve")}   ${keyHint("A", "and for an hour")}   ${keyHint("d", "deny")}   ${keyHint("j/k", "move")}   ${keyHint("q", "quit")}` : `  ${style.quiet(`${options.approveWith} approve --all`)}`
+      canDecide(options) ? `  ${keyHint("a", "approve")}   ${keyHint("A", "approve for an hour")}   ${keyHint("d", "deny")}   ${keyHint("j/k", "move")}   ${keyHint("q", "quit")}` : `  ${style.quiet(`${options.approveWith} approve --all`)}`
+    );
+  } else if (canDecide(options)) {
+    out2.push("");
+    out2.push(
+      `  ${keyHint("q", "quit")}   ${style.quiet("A held call appears here; answer it with")} ${style.strong("a")} ${style.quiet("approve,")} ${style.strong("A")} ${style.quiet("approve for an hour, or")} ${style.strong("d")} ${style.quiet("deny.")}`
     );
   }
   if (view.notice !== "") {
@@ -1193,6 +1198,8 @@ async function watch(options) {
     const waiting = ready.listGated();
     const action = waiting[Math.min(view.cursor, waiting.length - 1)];
     if (action === void 0) {
+      view.notice = "Nothing is waiting right now. When an agent's call is held, it appears above and this key answers it.";
+      view.noticeUntil = tick + NOTICE_TICKS;
       return;
     }
     const changed = approve ? ready.approve(action.id, options.decideAs) : ready.denyByPerson(action.id, options.decideAs, "denied from the watch view");
@@ -1227,6 +1234,10 @@ async function watch(options) {
         view.cursor = Math.max(0, view.cursor - 1);
         return;
       default:
+        if (key.length === 1 && key >= " ") {
+          view.notice = `${key} does nothing here. Keys: a approve, A approve for an hour, d deny, j/k move, q quit`;
+          view.noticeUntil = tick + NOTICE_TICKS;
+        }
         return;
     }
   };
@@ -1570,12 +1581,13 @@ function gatesView(journal, screen, options) {
     return [`  ${style.quiet("Nothing is waiting for a decision.")}`];
   }
   const at = Math.min(screen.cursor, waiting.length - 1);
-  return waiting.map((action, index) => {
+  return waiting.flatMap((action, index) => {
     const here = index === at && canPress(options);
     const name = `${action.server}.${action.tool}`;
     const shown = here ? style.accent(name) : style.quiet(name);
     const args = style.quiet(truncate2(JSON.stringify(action.args), 54));
-    return `  ${here ? style.accent(CURSOR) : " "} ${shown}  ${args}`;
+    const why = here && action.error !== void 0 ? [`      ${style.quiet(truncate2(action.error, 90))}`] : [];
+    return [`  ${here ? style.accent(CURSOR) : " "} ${shown}  ${args}`, ...why];
   });
 }
 function footer(screen, options) {
@@ -1586,7 +1598,7 @@ function footer(screen, options) {
     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 === "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("A", "and for an hour"), 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("A", "approve for an hour"), keyHint2("d", "deny"), keyHint2("j/k", "move"), keyHint2("r", "runs")] : screen.mode === "run" ? [
     keyHint2("l", "check now"),
     keyHint2("p", "preview undo"),
     keyHint2("u", "undo"),
@@ -1597,10 +1609,38 @@ function footer(screen, options) {
     keyHint2("l", "check now"),
     keyHint2("u", "undo"),
     keyHint2("j/k", "move"),
-    keyHint2("g", "held")
+    keyHint2("g", "waiting calls")
   ];
   return ["", `  ${keys.join("   ")}   ${keyHint2("q", "quit")}`];
 }
+function welcomeFrame(screen, options, tick) {
+  const spinner = options.live ? `${style.accent(FRAMES2[tick % FRAMES2.length] ?? "")} ` : "";
+  const waiting = needsConnecting(screen.groups).length;
+  const lead = screen.groups.length === 0 ? [] : waiting === 0 ? [
+    `  ${style.strong("Everything below is covered.")} ${style.quiet("Restart those apps if you have not,")}`,
+    `  ${style.quiet("then use your agent as usual. Its sessions will appear here.")}`
+  ] : [
+    `  ${style.strong("Welcome.")} ${style.quiet("These are the AI apps on this machine and the tools they use.")}`,
+    `  ${style.quiet("Press")} ${style.strong("a")} ${style.quiet("to cover all of them, or move to one and press")} ${style.strong("enter")}${style.quiet(".")}`,
+    `  ${style.quiet("Nothing else on your machine is changed, and")} ${style.strong("synartesis uninstall")} ${style.quiet("puts it all back.")}`
+  ];
+  const notice = screen.notice === "" ? [] : ["", ...screen.notice.split("\n").map((line2) => `  ${style.accent(line2)}`)];
+  return [
+    "",
+    `  ${style.plate(WORDMARK)}`,
+    `  ${rule(70)}`,
+    "",
+    `  ${spinner}${style.quiet(screen.busy ?? "nothing has run through Synartesis yet")}`,
+    "",
+    ...lead,
+    ...lead.length === 0 ? [] : [""],
+    ...windowed(connectionsView(screen, options), screen.cursor, roomFor(options)),
+    ...notice,
+    "",
+    `  ${[keyHint2("a", "cover all"), keyHint2("enter", "cover this one"), keyHint2("j/k", "move"), keyHint2("r", "look again"), keyHint2("q", "quit")].join("   ")}`,
+    ""
+  ].join("\n");
+}
 function waitingForJournal2(options, tick) {
   const spinner = options.live ? `${style.accent(FRAMES2[tick % FRAMES2.length] ?? "")} ` : "";
   return [
@@ -1655,7 +1695,8 @@ async function openConsole(options) {
     groups: [],
     busy: void 0,
     notice: "",
-    noticeUntil: 0
+    noticeUntil: 0,
+    welcome: false
   };
   let tick = 0;
   const stopped = () => screen.stop;
@@ -1666,15 +1707,30 @@ async function openConsole(options) {
   const frame = () => {
     const ready = open();
     if (ready === void 0) {
+      if (options.scan !== void 0 && canPress(options)) {
+        return welcomeFrame(screen, options, tick);
+      }
       return waitingForJournal2(options, tick);
     }
+    if (screen.welcome) {
+      screen.welcome = false;
+      screen.mode = "runs";
+      screen.cursor = 0;
+      say("the first session has arrived");
+    }
     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)}`)];
+    const held2 = screen.mode === "gates" || screen.mode === "connections" ? 0 : ready.listGated().length;
+    const alert = held2 === 0 ? [] : [
+      `  ${style.accent(`${String(held2)} ${held2 === 1 ? "call is" : "calls are"} waiting for you`)}  ${style.quiet("press")} ${style.strong("g")} ${style.quiet("to answer")}`,
+      ""
+    ];
     return [
       ...header(options, screen, tick),
+      ...alert,
       ...body,
       ...notice,
       ...tail,
@@ -1798,6 +1854,13 @@ async function openConsole(options) {
   const rescan = () => {
     screen.groups = options.scan?.() ?? [];
   };
+  if (!existsSync3(options.journalPath) && options.scan !== void 0) {
+    screen.welcome = true;
+    screen.mode = "connections";
+    rescan();
+  } else if (canPress(options) && (open()?.listGated().length ?? 0) > 0) {
+    screen.mode = "gates";
+  }
   const connect = async (targets) => {
     if (options.connect === void 0) {
       say("no way to connect was configured");
@@ -1981,6 +2044,9 @@ async function openConsole(options) {
         return;
       }
       default:
+        if (key.length === 1 && key >= " ") {
+          say(`${key} does nothing here; the keys that work are listed on the bottom line`);
+        }
         return;
     }
   };
@@ -1998,6 +2064,9 @@ async function openConsole(options) {
         return;
       }
       press(next.value);
+      if (screen.welcome && open() === void 0) {
+        screen.mode = "connections";
+      }
       if (stopped()) {
         return;
       }
@@ -2108,11 +2177,12 @@ if (NODE_MAJOR < 22) {
   process.exit(2);
 }
 var COMMANDS = `
-  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                                      start here. The first time,
+                                                  it lists your AI apps: press a
+                                                  to cover them. After that it
+                                                  opens on anything waiting for
+                                                  you, and on what agents did,
+                                                  with undo on the arrow keys.
   synartesis install [--client <name>] [--remote] [--dry-run] [--print]
   synartesis uninstall [--client <name>]
   synartesis status
@@ -2123,6 +2193,8 @@ var COMMANDS = `
   synartesis show <runId> [--full] [--live] [--journal <path>]
   synartesis gates [--journal <path>]
   synartesis close [runId] [--journal <path>]
+  synartesis clean [--dry-run] [--yes]              clear finished sessions,
+                                                  keep what still matters
   synartesis prune [--older-than <days>] [--dry-run] [--journal <path>]
   synartesis proxy --manifest <path> [--server <name>]    what your agent runs
                   [--journal <path>]
@@ -2644,10 +2716,16 @@ async function connectThese(targets, manifestPath) {
   );
   const applied = applyInstall(plans, manifestPath, yaml);
   const count = applied.reduce((sum, entry) => sum + entry.servers.length, 0);
+  const skipped = plans.flatMap((plan) => plan.skipped.map((skip) => `${skip.name}: ${skip.why}`));
   if (count === 0) {
-    return "nothing was connected; see the reasons above";
+    return skipped.length === 0 ? "nothing needed connecting" : `not connected -- ${skipped.join("; ")}`;
   }
-  return `connected ${String(count)}${count === 1 ? " server" : " servers"} \xB7 restart the client to pick it up`;
+  const apps = [...new Set(applied.map((entry) => entry.site.label))];
+  const restart = `quit and reopen ${apps.join(" and ")} to start using it`;
+  return [
+    `covered ${String(count)}${count === 1 ? " server" : " servers"} \xB7 ${restart}`,
+    ...skipped.length === 0 ? [] : [`not covered -- ${skipped.join("; ")}`]
+  ].join("\n");
 }
 function runStatus(argv) {
   const manifestPath = findManifest(flag(argv, "--manifest"));
@@ -2934,10 +3012,15 @@ function runList(journal, asJson, journalPath) {
   }
   hint(firstOf(
     () => heldCalls(journal),
+    () => {
+      const clearable = journal.cleanable(new Date(Date.now() - CLEAN_IDLE_MS).toISOString()).finished.length;
+      return clearable >= CLEAN_NAG_SESSIONS ? { why: `${String(clearable)} of these are finished with nothing left to undo; to clear them`, run: "clean", needs: ["journal"] } : void 0;
+    },
     () => whatChanged(journal)
   ));
   return 0;
 }
+var CLEAN_NAG_SESSIONS = 10;
 async function runShow(argv, journal, asJson) {
   const full = argv.includes("--full");
   const runs = [...journal.listRuns()].reverse();
@@ -3227,6 +3310,66 @@ function runPrune(argv, journal, journalPath) {
   out("");
   return 0;
 }
+var CLEAN_IDLE_MS = 24 * 60 * 60 * 1e3;
+async function runClean(argv, journal, journalPath) {
+  const idleBefore = new Date(Date.now() - CLEAN_IDLE_MS).toISOString();
+  const { abandoned, finished } = journal.cleanable(idleBefore);
+  const total = journal.listRuns().length;
+  const empty = finished.filter((run) => run.actions === 0).length;
+  const kept = total - finished.length;
+  const sizeBefore = sizeOf(journalPath);
+  out("");
+  out(`  ${style.label("clean")}  ${style.quiet(journalPath)}`);
+  out(`  ${rule(54)}`);
+  out("");
+  if (finished.length === 0 && abandoned.length === 0) {
+    out(`  ${style.quiet("Nothing to clear: every session here is still in use, or still has")}`);
+    out(`  ${style.quiet("something you could undo or decide.")}`);
+    out("");
+    return 0;
+  }
+  out(
+    `  ${style.strong("clears")}  ${counted(finished.length, "finished session")} with nothing left to undo` + (empty > 0 ? style.quiet(` (${String(empty)} of them empty)`) : "")
+  );
+  if (abandoned.length > 0) {
+    out(`  ${style.strong("closes")}  ${counted(abandoned.length, "session")} left open by an app that is no longer running`);
+  }
+  out(
+    `  ${style.strong("keeps ")}  ${counted(kept, "session")} ${style.quiet("still running, or with something to undo or decide")}`
+  );
+  out(`  ${style.quiet("        your connected apps and your policy are not touched")}`);
+  out("");
+  if (argv.includes("--dry-run")) {
+    out(`  ${style.quiet("Nothing was changed.")}`);
+    out("");
+    return 0;
+  }
+  if (!argv.includes("--yes")) {
+    if (!process.stdin.isTTY) {
+      out(`  ${style.quiet("Nothing was changed. Run it in a terminal to be asked, or add --yes.")}`);
+      out("");
+      return 1;
+    }
+    const answer = (await ask("  Go ahead? [y/N] ")).trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+      out(`  ${style.quiet("Nothing was changed.")}`);
+      out("");
+      return 0;
+    }
+  }
+  for (const id of abandoned) {
+    journal.closeAbandonedRun(id);
+  }
+  const now = journal.cleanable(idleBefore).finished;
+  const removed = journal.deleteRuns(now.map((run) => run.id));
+  journal.vacuum();
+  out("");
+  out(
+    `  ${style.accent(`cleared ${counted(removed.runs, "session")}`)}` + style.quiet(`${abandoned.length > 0 ? `, closed ${String(abandoned.length)}` : ""} \xB7 journal ${sizeBefore} \u2192 ${sizeOf(journalPath)}`)
+  );
+  out("");
+  return 0;
+}
 function runResolve(argv, journal) {
   const applied = argv.includes("--applied");
   const failed = argv.includes("--failed");
@@ -3914,6 +4057,7 @@ var KNOWN_COMMANDS = [
   "show",
   "gates",
   "close",
+  "clean",
   "prune",
   "proxy",
   "desktop",
@@ -4139,6 +4283,8 @@ ${COMMANDS}`);
         return runClose(argv, journal);
       case "prune":
         return runPrune(argv, journal, journalPath);
+      case "clean":
+        return await runClean(argv, journal, journalPath);
       case "gates":
         return runGates(journal, asJson);
       case "resolve":

package/dist/proxy.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  JOURNAL_NAME,
   PROXY_FLAGS,
   SILENT,
   canonical,
@@ -13,6 +14,7 @@ import {
   findJournal,
   findManifest,
   fingerprint2 as fingerprint,
+  home,
   isDisconnected,
   listAll,
   loadManifest,
@@ -34,7 +36,7 @@ import {
   warnUntested,
   withIdempotencyKey,
   withoutMissingTools
-} from "./chunk-H4SPMXQW.js";
+} from "./chunk-MTPUG26S.js";
 import {
   SnapshotError,
   UpstreamError,
@@ -42,7 +44,7 @@ import {
 } from "./chunk-YVOO3PTV.js";
 
 // src/proxy/stdio.ts
-import { resolve } from "path";
+import { join, resolve } from "path";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/proxy/http.ts
@@ -642,7 +644,7 @@ function createProxyServer(options) {
             }
             tools.push({
               ...compatible(tool, (dialect) => {
-                log?.warn(
+                log?.debug(
                   `${upstream.name}.${tool.name} declares JSON Schema ${dialect}; the dialect was dropped so clients that only accept 2020-12 can call it`
                 );
               }),
@@ -1362,7 +1364,13 @@ async function main() {
       logger: log,
       // Absolute, because whoever approves may be in any directory at all.
       approveHint: (actionId) => `${cliCommandFrom(import.meta.url)} approve ${actionId.slice(0, 8)} --journal ${resolve(argv.journal)}`,
-      notify: desktopNotifier()
+      // Plain `synartesis` when this is the journal it finds by itself, which
+      // is the usual case; otherwise told where to look.
+      notify: desktopNotifier(
+        process.env,
+        void 0,
+        resolve(argv.journal) === resolve(join(home(), JOURNAL_NAME)) ? cliCommandFrom(import.meta.url) : `${cliCommandFrom(import.meta.url)} --journal ${resolve(argv.journal)}`
+      )
     });
     proxy2.ready.then((runId) => {
       for (const [server, started] of startedWith) {

package/package.json

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