backstep 0.1.19 → 0.1.21

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/adapters/fs.js

@@ -2,14 +2,12 @@
 // Restoring "the state each path was in" handles writes, edits, deletes,
 // creates and moves with one rule.
 import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, rmSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join } from "node:path";
 import { snapshotDir } from "../store.js";
+import { insidePath, resolveIn } from "../paths.js";
 const MAX_BYTES = 50 * 1024 * 1024;
 export function resolvePath(p, cwd) {
-    if (p === "~" || p.startsWith("~/"))
-        return join(homedir(), p.slice(1));
-    return resolve(cwd, p);
+    return resolveIn(p, cwd);
 }
 function sizeOf(p, budget) {
     const st = lstatSync(p);
@@ -27,9 +25,7 @@ function sizeOf(p, budget) {
 // Whether a path sits in the folder Claude Code has open. Edits elsewhere belong to
 // other projects: Backstep never records them, so undo here can never touch them.
 export function insideDir(path, dir) {
-    const p = resolvePath(path, dir);
-    const d = resolve(dir).replace(/\/$/, "");
-    return p === d || p.startsWith(d + "/");
+    return insidePath(resolvePath(path, dir), dir);
 }
 export function snapshotPaths(actionId, paths, cwd) {
     const dir = snapshotDir(actionId);

package/dist/adapters/tree.js

@@ -6,7 +6,8 @@
 import { createHash } from "node:crypto";
 import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readdirSync, readSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isDiskRoot } from "../paths.js";
 import { execFileSync } from "node:child_process";
 import { homeDir, snapshotDir } from "../store.js";
 const SQLITE_BUDGET = () => Number(process.env.BACKSTEP_DB_SNAPSHOT_MB ?? 250) * 1024 * 1024;
@@ -26,6 +27,8 @@ function isSqlite(path) {
 // SQLite database files in a project, four folders deep at most.
 export function sqliteFiles(root) {
     const out = [];
+    // Backstep's own folder holds its live history: never saved or put back as a project's database.
+    const own = resolve(homeDir());
     const walk = (dir, depth) => {
         let entries = [];
         try {
@@ -37,7 +40,7 @@ export function sqliteFiles(root) {
         for (const e of entries) {
             const p = join(dir, e.name);
             if (e.isDirectory()) {
-                if (depth > 0 && !SKIP_DIRS.test(e.name))
+                if (depth > 0 && !SKIP_DIRS.test(e.name) && resolve(p) !== own)
                     walk(p, depth - 1);
             }
             else if (/\.(db|sqlite3?|db3)$/i.test(e.name) && isSqlite(p))
@@ -137,7 +140,9 @@ function tryGit(args, cwd) {
 }
 // The project a command runs in: its git repository, or the folder itself.
 export function projectRoot(cwd) {
-    return tryGit(["rev-parse", "--show-toplevel"], cwd) ?? resolve(cwd);
+    // git answers C:/Users/me/app on Windows; resolve gives the system's own spelling.
+    const top = tryGit(["rev-parse", "--show-toplevel"], cwd);
+    return resolve(top ?? cwd);
 }
 function shadowFor(root) {
     const gitDir = join(homeDir(), "trees", createHash("sha256").update(root).digest("hex").slice(0, 16) + ".git");
@@ -147,7 +152,7 @@ function shadowFor(root) {
         mkdirSync(join(gitDir, "info"), { recursive: true });
         // Backstep's own folder, when it sits inside the project, holds the live journal: never snapshotted.
         const own = relative(root, resolve(homeDir()));
-        const skipOwn = own && !own.startsWith("..") && !isAbsolute(own) ? [`/${own}/`] : [];
+        const skipOwn = own && !own.startsWith("..") && !isAbsolute(own) ? [`/${own.split(sep).join("/")}/`] : [];
         writeFileSync(join(gitDir, "info", "exclude"), [...EXCLUDE, ...skipOwn].join("\n") + "\n");
         writeFileSync(join(gitDir, "description"), `Backstep snapshots of ${root}\n`);
     }
@@ -191,7 +196,7 @@ function projectGit(root, actionId, pushes) {
 // whole disk, or a folder too big to stage in time.
 export function snapshotTree(actionId, cwd, opts = {}) {
     const root = projectRoot(cwd);
-    if (root === "/" || root === homedir() || root === resolve(homeDir()))
+    if (isDiskRoot(root) || root === homedir() || root === resolve(homeDir()))
         return null;
     try {
         const gitDir = shadowFor(root);

package/dist/check.js

@@ -2,7 +2,7 @@
 // what to connect next. Setup prints it, `backstep status` prints it, and the
 // Claude Code mod checks it as a session starts, so nobody assumes a service
 // is covered when it isn't.
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { configServers, projectConnected, projectUses, supabaseDirs } from "./connect.js";
 import { supabaseProjects } from "./supabase.js";
 import { watchRules } from "./watch.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/connect.js

@@ -7,7 +7,7 @@
 //  - Firebase: undo runs through Firebase's own MCP server, so there's nothing
 //    to connect once Claude can reach Firebase. When the project uses Firebase
 //    and Claude can't, this adds that server (behind Backstep).
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -107,7 +107,7 @@ export function firebaseCreds(dir) {
     const vars = envVars(dir);
     const named = vars.find(([k]) => k === "GOOGLE_APPLICATION_CREDENTIALS")?.[1] ?? process.env.GOOGLE_APPLICATION_CREDENTIALS;
     if (named) {
-        const f = named.startsWith("/") ? named : join(dir, named);
+        const f = resolve(dir, named);
         if (existsSync(f))
             return f;
     }

package/dist/github.js

@@ -1,7 +1,7 @@
 // Things Claude makes on GitHub with the gh command line (a repository, an
 // issue, a pull request, a release), noted from what gh printed, so undo can
 // offer to take them away again with gh itself, signed in as the person.
-import { spawn, spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "./spawn.js";
 const CREATES = /\bgh\s+(repo|issue|pr|release)\s+create\b/g;
 const URL = /https:\/\/github\.com\/([\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/(issues|pull)\/(\d+)|\/releases\/tag\/([^\s)]+))?(?=[\s)'"]|$)/g;
 // What a gh command made, from the command and what it printed.

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/paths.js

@@ -0,0 +1,31 @@
+// Paths on every system Claude Code runs on. Windows writes C:\Users\me\app,
+// and its Bash (Git Bash) writes the same folder as /c/Users/me/app; macOS and
+// Linux write /Users/me/app. Each check here takes the path module to use, so
+// tests can ask the Windows question on any machine.
+import nodePath from "node:path";
+import { homedir } from "node:os";
+const native = nodePath;
+const isWin = (p) => p.sep === "\\";
+// A path as Git Bash on Windows writes it (/c/Users/me), turned into Windows' own (C:\Users\me).
+export function fromShellPath(raw, p = native) {
+    if (!isWin(p))
+        return raw;
+    const m = raw.match(/^\/([a-zA-Z])(\/.*)?$/);
+    return m ? p.normalize(`${m[1].toUpperCase()}:${m[2] ?? "\\"}`) : raw;
+}
+// A path a tool or command named, made absolute against the folder it ran in. `~` is the home folder.
+export function resolveIn(raw, cwd, p = native, home = homedir()) {
+    if (raw === "~" || raw.startsWith("~/") || (isWin(p) && raw.startsWith("~\\")))
+        return p.join(home, raw.slice(1));
+    return p.resolve(fromShellPath(cwd, p), fromShellPath(raw, p));
+}
+// Whether `path` is `dir` or inside it. Windows ignores letter case in paths.
+export function insidePath(path, dir, p = native) {
+    const rel = p.relative(p.resolve(fromShellPath(dir, p)), p.resolve(fromShellPath(path, p)));
+    return rel === "" || (rel !== ".." && !rel.startsWith(".." + p.sep) && !p.isAbsolute(rel));
+}
+// The root of a disk: / on macOS and Linux, C:\ on Windows.
+export function isDiskRoot(dir, p = native) {
+    const abs = p.resolve(dir);
+    return p.parse(abs).root === abs;
+}

package/dist/servers.js

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";

package/dist/setup.js

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { cpSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -53,7 +53,7 @@ export async function setup() {
     if (run("claude", ["--version"]).missing) {
         throw new Error("Claude Code isn't installed (no `claude` on PATH). Install it from https://claude.com/claude-code, then run this again.");
     }
-    const { root, onPath } = ROOT.includes("/_npx/") ? keepCopy() : { root: ROOT, onPath: true };
+    const { root, onPath } = /[\\/]_npx[\\/]/.test(ROOT) ? keepCopy() : { root: ROOT, onPath: true };
     const cli = join(root, "dist", "cli.js");
     // Without `backstep` on the PATH, the commands printed below go through npx.
     const bs = onPath ? "backstep" : "npx -y backstep";

package/dist/shell.js

@@ -1,6 +1,7 @@
 // Decides what a shell command Claude is about to run could do, before it runs.
 // Reads pass straight through; commands that reach outside the machine can't be
 // taken back, so they're held; everything else gets the project snapshotted.
+import { resolveIn } from "./paths.js";
 // Programs that only look. A pipeline or chain is a read only if every part is.
 const READ_PROGRAMS = new Set([
     "ls", "ll", "la", "cat", "head", "tail", "less", "more", "grep", "egrep", "fgrep", "rg", "ag", "fd", "find", "tree",
@@ -139,7 +140,7 @@ export function commandDir(command, cwd) {
     const to = m?.[1] ?? m?.[2] ?? m?.[3];
     if (!to)
         return cwd;
-    return to.startsWith("/") ? to : to.startsWith("~") ? to.replace(/^~/, process.env.HOME ?? "~") : `${cwd.replace(/\/$/, "")}/${to}`;
+    return resolveIn(to, cwd);
 }
 // Commands that change Firebase's data some other way than its MCP server.
 const FIREBASE_DATA = /\bfirebase(-tools)?\s+(firestore:|database:)|firestore\.googleapis\.com|firebaseio\.com|firebasedatabase\.app/;

package/dist/spawn.js

@@ -0,0 +1,6 @@
+// Starting other programs (claude, npm, npx, gh) the same way on every system.
+// On Windows most of them are .cmd scripts, which Node's own spawn can't start
+// without a shell; cross-spawn finds them and quotes their arguments safely.
+import crossSpawn from "cross-spawn";
+export const spawnSync = crossSpawn.sync;
+export const spawn = crossSpawn.spawn;

package/dist/undo.js

@@ -8,6 +8,7 @@ import { snapshotDir } from "./store.js";
 import { dbKey, firebaseConn, freshUrl, restKey } from "./supabase.js";
 import { undoFirebase } from "./adapters/firestore.js";
 import { undoRest } from "./adapters/rest.js";
+import { insidePath } from "./paths.js";
 const INVERSE_TIMEOUT_MS = 20_000;
 // Database copies sit in the person's own database, so only the newest few per
 // database are kept; older commands keep their file undo but not their database undo.
@@ -60,7 +61,7 @@ function overlaps(a, b) {
         return true;
     if (!a.startsWith("fs:") || !b.startsWith("fs:"))
         return false;
-    return a.startsWith(b + "/") || b.startsWith(a + "/");
+    return insidePath(a.slice(3), b.slice(3)) || insidePath(b.slice(3), a.slice(3));
 }
 // Failed calls stay undoable: a tool can change things before it errors out.
 function undoable(a) {
@@ -119,7 +120,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/uninstall.js

@@ -6,7 +6,7 @@
 //   4. the Claude Code plugin and its source are removed
 //   5. ~/.backstep (history, snapshots, saved connections) is deleted
 //   6. the global npm package, when setup installed one
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { existsSync, rmSync } from "node:fs";
 import { homeDir, Store } from "./store.js";
 import { unwrapServers } from "./servers.js";
@@ -23,9 +23,12 @@ async function dropDatabaseCopies() {
     if (!existsSync(homeDir()))
         return null;
     const store = new Store();
+    // Closed right after reading: Windows won't delete a file that's still open.
+    const copies = store.databaseCopies();
+    store.close();
     const urls = new Map();
     let dropped = 0;
-    for (const a of store.databaseCopies()) {
+    for (const a of copies) {
         const u = JSON.parse(a.undo);
         for (const d of u.dbs ?? []) {
             const url = await freshUrl(d.url).catch(() => d.url);

package/dist/update.js

@@ -2,7 +2,7 @@
 // whether npm has a newer version; if so it asks the person, and an update
 // runs the new version's own setup, the same command a first install runs.
 // Off with BACKSTEP_UPDATE_CHECK=0.
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "./spawn.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homeDir } from "./store.js";

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.21",
   "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

@@ -11,11 +11,11 @@ const CLI = '/opt/backstep/cli.js'
 
 // The engine beneath the mod: a repo at /repo, and a Backstep CLI whose
 // `undo` answers with `undo`. Every argv the mod runs is recorded.
-function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: string }, shell: object = { kind: 'read', undoable: false }) {
+function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: string }, shell: object = { kind: 'read', undoable: false }, cwd = '/repo') {
   const runs: string[][] = []
   const logs: string[] = []
   const prompts: { text: string; context?: readonly string[] }[] = []
-  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.cwd', () => ({ value: cwd }))
   on('session.id', () => ({ value: 's1' }))
   on('ui.log', (_, e) => {
     logs.push(e.text)
@@ -75,6 +75,25 @@ test('edits outside the open folder are never tracked', { options: { cli: CLI }
   await ui.unmount()
 })
 
+test('on Windows, edits in the open folder are tracked however the path is written, and others never are', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const { runs } = engine(on, { exitCode: 0, stdout: '[]' }, undefined, 'C:\\Users\\me\\app')
+
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: 'C:\\Users\\me\\app\\src\\a.ts', old_string: 'a', new_string: 'b' })
+  await $.tool.call({ tool: 'Edit', file_path: 'c:/users/me/APP/src/b.ts', old_string: 'a', new_string: 'b' })
+  await $.tool.call({ tool: 'Write', file_path: '/c/Users/me/app/src/c.ts', content: 'x' })
+  await $.tool.call({ tool: 'Write', file_path: 'C:\\Users\\me\\app-old\\x.ts', content: 'x' })
+  await $.tool.call({ tool: 'Write', file_path: 'C:\\Users\\me\\app\\..\\other\\x.ts', content: 'x' })
+  await $.tool.call({ tool: 'Write', file_path: 'D:\\Users\\me\\app\\x.ts', content: 'x' })
+
+  expect(runs.filter((r) => r.includes('snap')).map((r) => r.at(-1))).toEqual([
+    'C:\\Users\\me\\app\\src\\a.ts',
+    'c:/users/me/APP/src/b.ts',
+    '/c/Users/me/app/src/c.ts',
+  ])
+})
+
 test('a long last turn stays on one line with a fixed gap after the logo', { options: { cli: CLI } }, async ($, on) => {
   mock.clock(on, { now: 5000 })
   engine(on, { exitCode: 0, stdout: '[]' }, { kind: 'write', undoable: true })
@@ -251,7 +270,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 +289,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 +334,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[]
 }
@@ -183,17 +183,38 @@ async function offerPushUndo($: EngineInterface, outcomes: Outcome[], repoGone =
 // The first press asks, right there above the prompt; a second press within a
 // few seconds undoes. A dialog would take the band off screen, and with it the
 // key, which would then suspend Claude Code in a terminal.
-// Whether a file path is inside the folder this session has open.
-function within(path: string, cwd: string): boolean {
-  const abs = path.startsWith('/') ? path : `${cwd}/${path}`
+// Whether a file path is inside the folder this session has open. Works for
+// macOS and Linux paths (/Users/me/app), Windows ones (C:\Users\me\app, any
+// letter case) and Git Bash's spelling of them (/c/Users/me/app).
+function normPath(path: string, cwd: string): string {
+  const win = /^[a-zA-Z]:[\\/]/.test(cwd) || cwd.startsWith('\\\\')
+  let raw = path.replace(/\\/g, '/')
+  if (win) raw = raw.replace(/^\/([a-zA-Z])(?=\/|$)/, '$1:')
+  const base = cwd.replace(/\\/g, '/')
+  const absolute = win ? /^[a-zA-Z]:\//.test(raw) || raw.startsWith('//') : raw.startsWith('/')
+  const abs = absolute ? raw : `${base}/${raw}`
+  const unc = win && abs.startsWith('//')
   const parts: string[] = []
   for (const seg of abs.split('/')) {
     if (seg === '..') parts.pop()
     else if (seg && seg !== '.') parts.push(seg)
   }
-  const p = '/' + parts.join('/')
-  const d = cwd.replace(/\/+$/, '')
-  return p === d || p.startsWith(d + '/')
+  const p = (unc ? '//' : win ? '' : '/') + parts.join('/')
+  return win ? p.toLowerCase() : p
+}
+
+function within(path: string, cwd: string): boolean {
+  const p = normPath(path, cwd)
+  const d = normPath('.', cwd)
+  return p === d || p.startsWith(d.replace(/\/$/, '') + '/')
+}
+
+// A file's path from the session's folder, for showing; anything else as given.
+function relPath(path: string, cwd: string): string {
+  if (!within(path, cwd)) return path
+  const slashed = path.replace(/\\/g, '/')
+  const base = cwd.replace(/\\/g, '/').replace(/\/$/, '')
+  return slashed.length > base.length + 1 && slashed.toLowerCase().startsWith(base.toLowerCase() + '/') ? slashed.slice(base.length + 1) : path
 }
 
 async function pressUndo($: EngineInterface) {
@@ -229,7 +250,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   })
 
   const cwd = await $.session.cwd()
-  const short = (p: string) => (p.startsWith(cwd + '/') ? p.slice(cwd.length + 1) : p)
+  const short = (p: string) => relPath(p, cwd)
   const [ran] = await Promise.all([
     $.process.run(backstep(['undo', '--since', String(target.startedAt), '--session', await $.session.id(), '--json', '--via-claude-code'])).catch((err: unknown) => ({
       exitCode: 1,
@@ -254,18 +275,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 +396,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 {
@@ -778,7 +826,7 @@ export const register: Register = (on, options) => {
         if (snap?.exitCode === 0) {
           await bump($, t.id, (x) => ({ ...x, gitOnly: false, edits: x.edits + 1, files: x.files.includes(path) ? x.files : [...x.files, path] }))
         } else {
-          await bump($, t.id, (x) => lostOne({ ...x, gitOnly: false }, `edit to ${path.split('/').pop()}: Backstep couldn't save a copy first`))
+          await bump($, t.id, (x) => lostOne({ ...x, gitOnly: false }, `edit to ${path.split(/[\\/]/).pop()}: Backstep couldn't save a copy first`))
         }
       }
     } else if (tool === 'Bash') {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "backstep",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "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",
@@ -14,6 +15,7 @@
   "type": "module",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.2",
+    "cross-spawn": "^7.0.6",
     "pg": "^8.23.1",
     "zod": "^4.6.7"
   },
@@ -21,6 +23,7 @@
     "@electric-sql/pglite": "^0.5.12",
     "@electric-sql/pglite-socket": "^0.2.15",
     "@modelcontextprotocol/server-filesystem": "^2.0.1",
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^26.6.5",
     "@types/pg": "^8.23.1",
     "typescript": "^7.0.2"