backstep 0.1.19 → 0.1.20

package/README.md

@@ -8,6 +8,7 @@ Undo for everything your agents touch. Backstep sits between your agent (Claude
 - **Supabase:** `execute_sql` and `apply_migration` snapshot the tables they change, over a connection to the project's database. Backstep never connects it on its own: when Claude Code opens a project that uses Supabase and isn't connected, it asks (Connect, Not now, or Don't ask for this project). Connect uses a connection string in the project's `.env` files, the local `supabase start` database, or a Supabase sign-in (`supabase login`, `SUPABASE_ACCESS_TOKEN`, or an access token you give Backstep once), with which the project gets a temporary database login that Backstep renews as it runs out. You can also ask Claude to "connect Backstep to Supabase" any time. Deleted rows, dropped tables and migrations, including the migration's history row, all come back. Works for the claude.ai Supabase connector and a local Supabase MCP server alike.
 - **Firebase:** before a change, Backstep reads what's there through the Firebase MCP server itself, and undoes through it too, so there's nothing to set up. Firestore documents updated, deleted or added; Realtime Database writes; Remote Config publishes (rolled back to the version before); and users enabled or disabled.
 - **claude.ai connectors and servers Claude Code signs in to:** Backstep can't sit in front of these, so the Claude Code mod watches their calls instead. Calls with an undo rule are undone through Claude Code's own connection.
+- **Notion** (the claude.ai connector, or Notion's own MCP server): built in, nothing to set up. Pages and rows Claude creates, duplicates or databases it makes go to Notion's Trash on undo; pages it deletes come back from Trash; an edit (content, properties, icon, cover) is undone by writing back the page as the mod read it just before; moved pages go back where each came from. A page too big to read whole, or a result Backstep can't read the new pages from, is recorded and marked not undoable rather than guessed at.
 - **Database commands Claude runs** (`supabase db push`, `supabase migration up`, `supabase db reset`, `psql`, `prisma migrate`, `drizzle-kit push`, seed scripts…): in a project whose Supabase database is connected, the whole database is noted before the command runs, and ctrl+u puts it back in one transaction: rows, new tables dropped, dropped or altered tables rebuilt with their constraints, indexes, foreign keys, row level security policies, triggers and grants, sequence counters, and the migration history. Copies sit in a `backstep` schema in the same database; the newest 10 per database are kept. On a very big database it keeps every table's structure and the migration history, and rows smallest-table-first up to a budget (`BACKSTEP_DB_SNAPSHOT_MB`, default 250); undo names any table whose rows it couldn't bring back. Functions, views, types and extensions aren't restored.
 - **Supabase through its web API** (curl to `/rest/v1`, seed and app scripts using supabase-js): Backstep finds Supabase projects in the folder Claude Code opened or a level or two below, and the first time Claude is about to change one that isn't connected, it asks before the command runs. Connect uses the project's own `SUPABASE_URL` and service role key from its `.env`, no password: every table's rows are saved on this machine before each such command (smallest first, up to the size budget), and ctrl+u removes rows added since and writes back the old ones. Table changes need the database itself connected (password or access token).
 - **Any Postgres database** (Neon, Railway, Render, AWS, a local one) named in the project's `.env` (`DATABASE_URL` and the like): Backstep asks once, then saves the whole database before Claude's database commands (`psql`, `prisma migrate`, `drizzle-kit push`, seed and app scripts) and puts it back on undo, the same way as Supabase.

package/dist/check.js

@@ -11,6 +11,7 @@ import { DEFAULT_KEY, keyLabel, undoKeys } from "./keys.js";
 const WRAPPED = /(^|[/\s])(backstep|cli\.[jt]s) wrap\b/;
 const SUPABASE = /supabase/i;
 const FIREBASE = /firebase|firestore/i;
+const NOTION = /notion/i;
 // `claude mcp list` sees everything a session would, plugins and claude.ai
 // connectors included, and whether each works; it prints "name: target - ✔ Connected".
 function listed(dir) {
@@ -47,6 +48,9 @@ function classify(s, supabaseConnected, ruled) {
         if (wrappable)
             return { name, level: "connect", detail: "undoable from the next Claude Code session", signIn };
     }
+    // Notion's own opposite calls are built in (src/notion.ts), through the connector or its own server.
+    if (NOTION.test(s.name))
+        return { name, level: "undoable", detail: "pages, edits, moves and deletes", signIn };
     if (ruled.has(s.name.replace(/[^a-zA-Z0-9_-]/g, "_")))
         return { name, level: "undoable", detail: "the tools your undo rules cover", signIn };
     if (wrapped)

package/dist/cli.js

@@ -542,12 +542,19 @@ async function main() {
     // arguments, and later its result, come as JSON on stdin.
     if (cmd === "watch-start") {
         const sep = rest.indexOf("--");
-        const { values } = parseArgs({ args: sep === -1 ? rest : rest.slice(0, sep), options: { session: { type: "string" }, cwd: { type: "string" } } });
+        const { values } = parseArgs({
+            args: sep === -1 ? rest : rest.slice(0, sep),
+            options: { session: { type: "string" }, cwd: { type: "string" }, before: { type: "boolean", default: false } },
+        });
         const tool = sep === -1 ? "" : rest[sep + 1];
         if (!values.session || !tool)
-            throw new Error("usage: backstep watch-start --session <id> [--cwd <dir>] -- <mcp__server__tool>  (arguments as JSON on stdin)");
+            throw new Error("usage: backstep watch-start --session <id> [--cwd <dir>] [--before] -- <mcp__server__tool>  (arguments as JSON on stdin)");
         const input = readFileSync(0, "utf8").trim();
-        console.log(JSON.stringify(await watchStart(new Store(), values.session, values.cwd ?? process.cwd(), tool, input ? JSON.parse(input) : {})));
+        const parsed = input ? JSON.parse(input) : {};
+        // --before: stdin is { args, before }, with the pages the mod read just before the call.
+        const args = values.before ? (parsed.args ?? {}) : parsed;
+        const before = values.before ? (parsed.before ?? {}) : {};
+        console.log(JSON.stringify(await watchStart(new Store(), values.session, values.cwd ?? process.cwd(), tool, args, before)));
         return;
     }
     if (cmd === "watch-end") {

package/dist/notion.js

@@ -0,0 +1,191 @@
+// Notion, through Claude Code's connector (or Notion's own MCP server): Backstep
+// can't copy Notion, so each change is undone with Notion's opposite call.
+//
+//   create pages or rows, duplicate a page  → move what was made to Trash
+//   create a database                       → move it to Trash
+//   delete pages or databases               → restore them from Trash
+//   edit a page                             → write back the page as read just before
+//   move pages                              → move them back to where they were
+//
+// Edits and moves need the page as it was: the Claude Code mod reads it with
+// Notion's fetch right before the call and hands it over as `before`.
+// Tools that only read, never change anything.
+const READS = /^notion-(fetch|search|get-|list-|query-|view-|download-)/;
+// Notion's own ids: 32 hex characters, with or without dashes.
+const ID = /[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}/gi;
+const bare = (id) => id.replace(/-/g, "").toLowerCase();
+export const isNotionTool = (tool) => /^notion-/.test(tool);
+// Which pages the mod should read before the call runs.
+export function notionReadsFirst(tool, args) {
+    if (tool === "notion-update-page" && typeof args.page_id === "string")
+        return [args.page_id];
+    if (tool === "notion-move-pages" && Array.isArray(args.page_or_database_ids))
+        return args.page_or_database_ids.filter((x) => typeof x === "string").slice(0, 20);
+    return [];
+}
+// Arguments to change before the call: page creation must answer with the new pages' ids.
+export function notionArgs(tool, args) {
+    if (tool === "notion-create-pages" && args.allow_async !== false)
+        return { allow_async: false };
+    return undefined;
+}
+function parseRead(raw) {
+    let outer = {};
+    try {
+        outer = JSON.parse(raw);
+    }
+    catch {
+        outer = { text: raw };
+    }
+    const text = typeof outer.text === "string" ? outer.text : raw;
+    if (!/<page[\s>]/.test(text) && !/<database[\s>]/.test(text))
+        return null;
+    const between = (tag) => {
+        const m = text.match(new RegExp(`<${tag}>\\n?([\\s\\S]*?)\\n?</${tag}>`));
+        return m ? m[1] : null;
+    };
+    let properties = null;
+    try {
+        const p = between("properties");
+        properties = p ? JSON.parse(p) : null;
+    }
+    catch {
+        properties = null;
+    }
+    const icon = text.match(/<page [^>]*\bicon="([^"]*)"/)?.[1] ?? null;
+    const c = outer.cover;
+    const cover = c === null ? null : c?.type === "external" && c.external?.url ? c.external.url : undefined;
+    // The first entry of the ancestor path is the direct parent; none means the workspace.
+    const path = between("ancestor-path");
+    let parent = null;
+    const first = path?.match(/<(parent-[a-z-]+)\s+url="([^"]+)"/);
+    if (!path || !first)
+        parent = { type: "workspace" };
+    else if (first[1] === "parent-data-source" && first[2].startsWith("collection://"))
+        parent = { type: "data_source_id", data_source_id: first[2].slice(13) };
+    else if (first[1] === "parent-page")
+        parent = { type: "page_id", page_id: bare(first[2].match(ID)?.at(-1) ?? "") };
+    else if (first[1] === "parent-database")
+        parent = { type: "database_id", database_id: bare(first[2].match(ID)?.at(-1) ?? "") };
+    if (parent && Object.values(parent).some((v) => v === ""))
+        parent = null;
+    // A page fetched in part can't be written back whole.
+    const complete = !outer.truncated && !(typeof outer.unknown_block_count === "number" && outer.unknown_block_count > 0) && !/"truncated":\s*true/.test(text);
+    return { text, properties, content: between("content"), icon, cover, parent, complete };
+}
+function editUndo(args, raw) {
+    const page = typeof args.page_id === "string" ? args.page_id : "";
+    const read = raw ? parseRead(raw) : null;
+    if (!page || !read)
+        return { kind: "never", reason: "Backstep couldn't read the page before it changed" };
+    const undo = { page_id: page };
+    // An icon or cover can ride along with any command.
+    if ("icon" in args)
+        undo.icon = read.icon ?? "none";
+    if ("cover" in args) {
+        if (read.cover === undefined)
+            return { kind: "never", reason: "the page's old cover was an upload Notion can't set back" };
+        undo.cover = read.cover ?? "none";
+    }
+    const command = args.command;
+    if (command === "update_properties") {
+        const changed = args.properties && typeof args.properties === "object" ? Object.keys(args.properties) : [];
+        if (changed.length && !read.properties)
+            return { kind: "never", reason: "Backstep couldn't read the page's properties before they changed" };
+        if (changed.length)
+            undo.properties = Object.fromEntries(changed.map((k) => [k, read.properties[k] ?? null]));
+        return { kind: "now", calls: [{ tool: "notion-update-page", args: { ...undo, command: "update_properties" } }], label: "put back a page's properties" };
+    }
+    if (command === "update_content" || command === "replace_content" || command === "insert_content" || command === "apply_template") {
+        if (read.content === null || !read.complete)
+            return { kind: "never", reason: "the page was too big for Backstep to read whole before it changed" };
+        return {
+            kind: "now",
+            calls: [{ tool: "notion-update-page", args: { ...undo, command: "replace_content", new_str: read.content, allow_deleting_content: true } }],
+            label: "put back a page's content",
+        };
+    }
+    return { kind: "never", reason: `Notion's ${String(command)} can't be taken back` };
+}
+function moveUndo(args, before) {
+    const ids = Array.isArray(args.page_or_database_ids) ? args.page_or_database_ids : [];
+    if (!ids.length || ids.length > 20)
+        return { kind: "never", reason: "too many pages moved at once for Backstep to note where each came from" };
+    // One call per old parent: pages that came from the same place go back together.
+    const groups = new Map();
+    for (const id of ids) {
+        const parent = before[id] ? parseRead(before[id])?.parent : null;
+        if (!parent)
+            return { kind: "never", reason: "Backstep couldn't tell where a moved page came from" };
+        const key = JSON.stringify(parent);
+        if (!groups.has(key))
+            groups.set(key, { parent, ids: [] });
+        groups.get(key).ids.push(id);
+    }
+    return {
+        kind: "now",
+        calls: [...groups.values()].map((g) => ({ tool: "notion-move-pages", args: { page_or_database_ids: g.ids, new_parent: g.parent } })),
+        label: `moved ${ids.length === 1 ? "a page" : `${ids.length} pages`} back`,
+    };
+}
+export function notionPlan(tool, args, before = {}) {
+    if (READS.test(tool))
+        return { kind: "read" };
+    const ids = (k) => (Array.isArray(args[k]) ? args[k].filter((x) => typeof x === "string") : []);
+    switch (tool) {
+        case "notion-create-pages":
+            return { kind: "after", made: "pages", label: "moved the pages Claude made to Trash" };
+        case "notion-duplicate-page":
+            return { kind: "after", made: "page", label: "moved the copy Claude made to Trash" };
+        case "notion-create-database":
+            return { kind: "after", made: "database", label: "moved the database Claude made to Trash" };
+        case "notion-delete-pages":
+        case "notion-delete-databases": {
+            const gone = ids(tool === "notion-delete-pages" ? "page_ids" : "database_ids");
+            if (!gone.length)
+                return { kind: "never", reason: "nothing to restore" };
+            return { kind: "now", calls: [{ tool: "notion-restore-pages", args: { page_ids: gone } }], label: `restored ${gone.length === 1 ? "it" : `${gone.length} of them`} from Trash` };
+        }
+        case "notion-restore-pages": {
+            const back = ids("page_ids");
+            return back.length ? { kind: "now", calls: [{ tool: "notion-delete-pages", args: { page_ids: back, user_confirmed: true } }], label: "moved them back to Trash" } : { kind: "never", reason: "nothing to put back" };
+        }
+        case "notion-update-page":
+            return editUndo(args, typeof args.page_id === "string" ? before[args.page_id] : undefined);
+        case "notion-move-pages":
+            return moveUndo(args, before);
+    }
+    return { kind: "never", reason: "Notion has no way to take this one back" };
+}
+// The ids of what a create call made, from its result, never the parent it was made under.
+export function notionMade(made, args, text, want) {
+    const known = new Set((JSON.stringify(args).match(ID) ?? []).map(bare));
+    // The data source and views a new database comes with have ids of their own, written collection:// and view://.
+    const sources = new Set([...text.matchAll(/(?:collection|view):\/\/([0-9a-f-]{32,36})/gi)].map((m) => bare(m[1])));
+    let found = [];
+    try {
+        const r = JSON.parse(text);
+        if (Array.isArray(r.pages))
+            found = r.pages.map((p) => p.id ?? "").filter(Boolean);
+        else if (typeof r.id === "string")
+            found = [r.id];
+    }
+    catch {
+        // not JSON: read the ids from the text
+    }
+    if (!found.length)
+        found = text.match(ID) ?? [];
+    const ids = [...new Set(found.map(bare))].filter((id) => !known.has(id) && !sources.has(id));
+    return ids.length === want ? ids : null;
+}
+export function notionUndoAfter(made, args, text) {
+    const want = made === "pages" ? (Array.isArray(args.pages) ? args.pages.length : 0) : 1;
+    if (!want || want > 20)
+        return null;
+    const ids = notionMade(made, args, text, want);
+    if (!ids)
+        return null;
+    return made === "database"
+        ? { tool: "notion-delete-databases", args: { database_ids: ids, user_confirmed: true } }
+        : { tool: "notion-delete-pages", args: { page_ids: ids, user_confirmed: true } };
+}

package/dist/undo.js

@@ -119,7 +119,13 @@ function undoEngine(store, a, u, opts) {
     if (!store.transition(a.id, a.status, "undo_requested")) {
         return { id: a.id, tool: a.tool, ok: false, detail: "this action changed while undoing; try again" };
     }
-    return { id: a.id, tool: a.tool, ok: true, detail: `runs ${u.tool}`, run: { server: u.server, tool: u.tool, args: u.args } };
+    return {
+        id: a.id,
+        tool: a.tool,
+        ok: true,
+        detail: u.label ?? `runs ${u.tool}`,
+        run: { server: u.server, tool: u.tool, args: u.args, ...(u.more?.length ? { more: u.more } : {}), ...(u.label ? { label: u.label } : {}) },
+    };
 }
 async function undoOne(store, a, opts = {}) {
     const u = JSON.parse(a.undo);

package/dist/watch.js

@@ -12,6 +12,7 @@ import { buildInverse, findRule, loadRules } from "./rules.js";
 import { isWrappedServer } from "./servers.js";
 import { homeDir } from "./store.js";
 import { CONNECT_HINT, isSupabaseSql, supabaseDb, supabasePlanOptions, supabaseUrl } from "./supabase.js";
+import { isNotionTool, notionArgs, notionPlan, notionUndoAfter } from "./notion.js";
 const DELETES = /(^|_|-)(delete|remove|trash|destroy|drop|purge|erase|archive)(_|-|$)/i;
 const MAX_RESULT = 20_000;
 // The engine spells MCP tools mcp__<server>__<tool>.
@@ -34,7 +35,8 @@ function unconnected(server, tool, args) {
     const plan = planCall(undefined, tool, args);
     return plan.kind === "sql" && !supabaseDb(typeof args.project_id === "string" ? args.project_id : undefined);
 }
-export async function watchStart(store, session, cwd, name, args) {
+// `before`: pages the mod read right before the call (Notion edits and moves), by id.
+export async function watchStart(store, session, cwd, name, args, before = {}) {
     const t = splitTool(name);
     if (!t)
         return { kind: "read" };
@@ -54,6 +56,22 @@ export async function watchStart(store, session, cwd, name, args) {
         release_at: null,
     });
     const rule = findRule(watchRules(), t.server, t.tool);
+    // Notion: its own opposite calls, built in. A rule the person wrote still wins.
+    if (!rule && isNotionTool(t.tool)) {
+        const n = notionPlan(t.tool, args, before);
+        if (n.kind === "read")
+            return { kind: "read" };
+        if (n.kind === "never")
+            return { kind: "write", id: record("write", n.reason).id, reason: n.reason };
+        const a = record("reversible", null);
+        if (n.kind === "now") {
+            const [first, ...more] = n.calls;
+            const undo = { adapter: "engine", server: t.server, tool: first.tool, args: first.args, ...(more.length ? { more } : {}), label: `Notion: ${n.label}` };
+            store.updateAction(a.id, { undo: JSON.stringify(undo) });
+        }
+        const rewrite = notionArgs(t.tool, args);
+        return rewrite ? { kind: "reversible", id: a.id, args: rewrite } : { kind: "reversible", id: a.id };
+    }
     const plan = rule ? null : planCall(undefined, t.tool, args);
     if (plan?.kind === "read")
         return { kind: "read" };
@@ -92,6 +110,14 @@ export async function watchStart(store, session, cwd, name, args) {
         reason = "no undo rule for this tool";
     return { kind, id: record(kind, reason ?? null).id, reason };
 }
+// All the text in a result: what the model read, else the result's text parts.
+function resultText(result, text) {
+    if (text)
+        return text;
+    if (result.structuredContent)
+        return JSON.stringify(result.structuredContent);
+    return (result.content ?? []).map((c) => (c.type === "text" ? c.text : "")).join("\n");
+}
 // The engine hands the mod the tool's record and the text the model read.
 function asResult(r) {
     const rec = r.result;
@@ -121,7 +147,24 @@ export async function watchEnd(store, id, r) {
         return { undoable: true };
     }
     if (r.isError) {
-        store.updateAction(id, { status: "error", error: text });
+        // An opposite call kept ahead (a Notion restore or rewrite) is dropped: the call changed nothing to take back.
+        store.updateAction(id, { status: "error", error: text, ...(kept?.adapter === "engine" ? { undo: null } : {}) });
+        return { undoable: false };
+    }
+    // Notion: kept ahead from the page as it was, or read now from what the call made.
+    if (isNotionTool(a.tool) && !findRule(watchRules(), server, a.tool)) {
+        if (kept?.adapter === "engine") {
+            store.updateAction(id, { status: "ok", result: text });
+            return { undoable: true };
+        }
+        const n = notionPlan(a.tool, args);
+        const call = n.kind === "after" ? notionUndoAfter(n.made, args, resultText(result, r.text)) : null;
+        if (n.kind === "after" && call) {
+            const undo = { adapter: "engine", server, tool: call.tool, args: call.args, label: `Notion: ${n.label}` };
+            store.updateAction(id, { status: "ok", result: text, undo: JSON.stringify(undo) });
+            return { undoable: true };
+        }
+        store.updateAction(id, { status: "ok", result: text, kind: "write", reason: "Backstep couldn't tell what Notion made from its answer" });
         return { undoable: false };
     }
     let undo = null;

package/mod/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Press ctrl+z to rewind everything Claude did in its last turn: file edits, shell commands, and database and tool changes.",
   "types": "./types/index.d.ts",
   "userConfig": {

package/mod/hooks/register.test.tsx

@@ -251,7 +251,7 @@ test('servers added since setup are wrapped as a session starts', { options: { c
 
 // A claude.ai connector: Backstep can't sit in front of it, so the mod reports
 // the call and, on undo, runs the rule's opposite call through Claude Code.
-function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?: boolean }) {
+function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?: boolean; undo?: object }) {
   const runs: { argv: string[]; stdin?: string }[] = []
   const calls: { server: string; tool: string; args: Record<string, unknown> }[] = []
   const ran: Record<string, unknown>[] = []
@@ -270,12 +270,13 @@ function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?:
       : e.argv.includes('watch-end')
         ? { undoable: opts.undoable }
         : e.argv.includes('undo')
-          ? [{ id: 'w1', tool: 'create-page', ok: true, detail: 'runs archive-page', run: { server: 'claude_ai_Notion', tool: 'archive-page', args: { id: 'p1' } } }]
+          ? [opts.undo ?? { id: 'w1', tool: 'create-page', ok: true, detail: 'runs archive-page', run: { server: 'claude_ai_Notion', tool: 'archive-page', args: { id: 'p1' } } }]
           : null
     return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
   })
   on('mcp.call', (_, e) => {
     calls.push({ server: e.server, tool: e.tool, args: e.args })
+    if (e.tool === 'notion-fetch') return { value: { content: [{ type: 'text', text: `page ${String(e.args.id)} as it was` }], isError: false } }
     return { value: { content: [{ type: 'text', text: opts.mcpFails ? 'no such page' : 'archived' }], isError: opts.mcpFails === true } }
   })
   on('tool.call', (_, e) => {
@@ -314,6 +315,39 @@ test('a connector call with an undo rule is undone through Claude Code', { optio
   await ui.unmount()
 })
 
+test('a Notion move: the pages are read first, and undo runs every opposite call', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const back = { tool: 'notion-move-pages', args: { page_or_database_ids: ['p2'], new_parent: { type: 'workspace' } } }
+  const { runs, calls } = connector(on, {
+    start: { kind: 'reversible', id: 'w1' },
+    undoable: true,
+    undo: {
+      id: 'w1',
+      tool: 'notion-move-pages',
+      ok: true,
+      detail: 'Notion: moved 2 pages back',
+      run: { server: 'claude_ai_Notion', tool: 'notion-move-pages', args: { page_or_database_ids: ['p1'], new_parent: { type: 'page_id', page_id: 'home' } }, more: [back], label: 'Notion: moved 2 pages back' },
+    },
+  })
+
+  await $.prompt.submit({ text: 'tidy my notion', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'mcp__claude_ai_Notion__notion-move-pages', page_or_database_ids: ['p1', 'p2'], new_parent: { type: 'page_id', page_id: 'archive' } } as never)
+
+  // Read before the move, through Claude Code's own connection, and handed over with the call.
+  expect(calls.map((c) => [c.tool, c.args.id])).toEqual([['notion-fetch', 'p1'], ['notion-fetch', 'p2']])
+  expect(runs[0].argv.slice(3)).toEqual(['watch-start', '--session', 's1', '--cwd', '/repo', '--before', '--', 'mcp__claude_ai_Notion__notion-move-pages'])
+  expect(JSON.parse(runs[0].stdin ?? '').before).toEqual({ p1: 'page p1 as it was', p2: 'page p2 as it was' })
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  expect(calls.slice(2).map((c) => c.args.page_or_database_ids)).toEqual([['p1'], ['p2']])
+  expect(runs.at(-1)?.argv.slice(3)).toEqual(['settle', 'w1'])
+  await ui.unmount()
+})
+
 test('when the opposite call fails, the rewind says so', { options: { cli: CLI } }, async ($, on) => {
   const clock = mock.clock(on, { now: 5000 })
   const { runs } = connector(on, { start: { kind: 'reversible', id: 'w1' }, undoable: true, mcpFails: true })

package/mod/hooks/register.tsx

@@ -57,7 +57,7 @@ type Outcome = {
   tool: string
   ok: boolean
   detail: string
-  run?: { server: string; tool: string; args: Record<string, unknown> }
+  run?: { server: string; tool: string; args: Record<string, unknown>; more?: { tool: string; args: Record<string, unknown> }[]; label?: string }
   pushed?: { root: string; pushes: Pushed[] }
   github?: GhMade[]
 }
@@ -254,18 +254,27 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   // Opposite calls on servers only Claude Code is connected to run here, newest first.
   for (const o of outcomes) {
     if (!o.ok || !o.run) continue
-    const done = await $.mcp.call(o.run.server, o.run.tool, o.run.args).catch((err: unknown) => ({
-      isError: true,
-      content: [{ type: 'text' as const, text: err instanceof Error ? err.message : String(err) }],
-    }))
-    if (done.isError) {
-      const why = done.content.map((c) => (c.type === 'text' ? c.text : '')).join(' ').trim().split('\n')[0] || 'failed'
+    const run = o.run
+    let failed: { tool: string; why: string } | null = null
+    // The first opposite call, then any more on the same server (a move back to several places).
+    for (const call of [{ tool: run.tool, args: run.args }, ...(run.more ?? [])]) {
+      const done = await $.mcp.call(run.server, call.tool, call.args).catch((err: unknown) => ({
+        isError: true,
+        content: [{ type: 'text' as const, text: err instanceof Error ? err.message : String(err) }],
+      }))
+      if (done.isError) {
+        const why = done.content.map((c) => (c.type === 'text' ? c.text : '')).join(' ').trim().split('\n')[0] || 'failed'
+        failed = { tool: call.tool, why }
+        break
+      }
+    }
+    if (failed) {
       o.ok = false
-      o.detail = `${o.run.tool} failed: ${why}`
-      await $.process.run(backstep(['settle', o.id, '--failed', why])).catch(() => null)
+      o.detail = `${failed.tool} failed: ${failed.why}`
+      await $.process.run(backstep(['settle', o.id, '--failed', failed.why])).catch(() => null)
       break
     }
-    o.detail = `ran ${o.run.tool}`
+    o.detail = run.label ?? `ran ${run.tool}`
     await $.process.run(backstep(['settle', o.id])).catch(() => null)
   }
   // Stop the list at the first failure, as the CLI does.
@@ -366,14 +375,32 @@ const RESERVED = new Set(['tool', 'tool_use_id', 'consent', 'agentId', 'requestM
 // call here and keeps an opposite call when an undo rule matches, which undo
 // runs through Claude Code's own connection. Supabase SQL is snapshotted
 // first, and a DROP comes back rewritten as a move to Backstep's trash.
+// Notion edits and moves are undone by writing back the page as it was, so it's
+// read here, through Claude Code's own connection, right before the call.
+async function readNotionFirst($: EngineInterface, tool: string, args: Record<string, unknown>): Promise<Record<string, string> | null> {
+  const m = tool.match(/^mcp__(.+?)__(notion-update-page|notion-move-pages)$/)
+  if (!m) return null
+  const ids = m[2] === 'notion-update-page' ? [args.page_id] : Array.isArray(args.page_or_database_ids) ? args.page_or_database_ids.slice(0, 20) : []
+  const before: Record<string, string> = {}
+  for (const id of ids) {
+    if (typeof id !== 'string') continue
+    const r = await $.mcp.call(m[1], 'notion-fetch', { id }).catch(() => null)
+    if (r && !r.isError) before[id] = r.content.map((c) => (c.type === 'text' ? c.text : '')).join('')
+  }
+  return before
+}
+
 async function watchMcp($: EngineInterface, e: Record<string, unknown>, next: Next) {
   const tool = String(e.tool)
   const t = await current($)
   const args = Object.fromEntries(Object.entries(e).filter(([k]) => !RESERVED.has(k)))
   const cwd = await $.session.cwd()
   const sid = await $.session.id()
+  const before = await readNotionFirst($, tool, args)
   const started = await $.process
-    .run(backstep(['watch-start', '--session', sid, '--cwd', cwd, '--', tool]), { stdin: JSON.stringify(args) })
+    .run(backstep(['watch-start', '--session', sid, '--cwd', cwd, ...(before ? ['--before'] : []), '--', tool]), {
+      stdin: JSON.stringify(before ? { args, before } : args),
+    })
     .catch(() => null)
   let plan: WatchPlan | null = null
   try {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "backstep",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
+  "homepage": "https://getbackstep.com",
   "scripts": {
     "dev": "node src/cli.ts",
     "ui": "node --disable-warning=ExperimentalWarning src/cli.ts ui",