backstep 0.1.8 → 0.1.10

package/README.md

@@ -9,6 +9,7 @@ Undo for everything your agents touch. Backstep sits between your agent (Claude
 - **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.
 - **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).
 - **Code Claude pushed:** ctrl+u rewinds the commits locally, then asks whether to undo them on GitHub (or any remote) too. Yes pushes one new commit that undoes Claude's, made in a temporary worktree: no force push, no rewritten history, so it works on protected branches and for teammates who already pulled. Newer commits that clash, or a rewritten branch, stop it. A branch Claude created is deleted instead, if nobody has added to it. It uses the project's own git sign-in, so there's nothing to connect.
 - **Things that can't be undone** (sending email, payments, deploys, `ALTER TABLE`…) run as normal and are marked in the journal, so you know what an undo didn't cover.
 - **Anything else, by rule:** a rules file maps a tool to its opposite (`create_issue` → close the issue, `send_message` → retract it), filled in from the call and its result. See [Undo rules](#undo-rules).

package/dist/adapters/rest.js

@@ -0,0 +1,170 @@
+// Supabase undo through its own web API (PostgREST), for a project Backstep
+// reaches with the keys in its .env rather than a database password. Before a
+// command that could change it (a curl to /rest/v1, a seed script, an app
+// script using supabase-js), every table's rows are read and kept on this
+// machine, smallest tables first up to a budget. Undo deletes rows added
+// since and writes the old rows back. Rows only: the web API can't drop or
+// rebuild tables, so table changes need the database itself connected.
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { snapshotDir } from "../store.js";
+const PAGE = 1000;
+const budget = () => Number(process.env.BACKSTEP_DB_SNAPSHOT_MB ?? 250) * 1024 * 1024;
+async function call(url, key, path, init = {}) {
+    const r = await fetch(`${url.replace(/\/$/, "")}/rest/v1/${path}`, {
+        ...init,
+        headers: { apikey: key, authorization: `Bearer ${key}`, "content-type": "application/json", ...init.headers },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!r.ok)
+        throw new Error(`Supabase said ${r.status}: ${(await r.text()).slice(0, 200)}`);
+    return r;
+}
+// The tables the API can write, and each one's primary key, from its OpenAPI description.
+async function describe(url, key) {
+    const spec = (await (await call(url, key, "", { headers: { accept: "application/openapi+json" } })).json());
+    const out = [];
+    for (const [name, def] of Object.entries(spec.definitions ?? {})) {
+        if (!spec.paths?.[`/${name}`]?.post)
+            continue; // a view or a read-only table
+        const pk = Object.entries(def.properties ?? {})
+            .filter(([, p]) => /<pk\/>|primary key/i.test(p.description ?? ""))
+            .map(([col]) => col);
+        out.push({ name, pk });
+    }
+    return out;
+}
+async function count(url, key, table) {
+    const r = await call(url, key, `${encodeURIComponent(table)}?select=*`, { method: "HEAD", headers: { prefer: "count=exact", range: "0-0", "range-unit": "items" } });
+    return Number(r.headers.get("content-range")?.split("/")[1] ?? 0) || 0;
+}
+async function rows(url, key, table) {
+    const out = [];
+    for (let from = 0;; from += PAGE) {
+        const r = await call(url, key, `${encodeURIComponent(table)}?select=*`, { headers: { range: `${from}-${from + PAGE - 1}`, "range-unit": "items" } });
+        const page = (await r.json());
+        out.push(...page);
+        if (page.length < PAGE)
+            return out;
+    }
+}
+export async function snapshotRest(actionId, url, key) {
+    const tables = await describe(url, key);
+    const sized = await Promise.all(tables.map(async (t) => ({ ...t, n: await count(url, key, t.name) })));
+    const dir = join(snapshotDir(actionId), "rest");
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    let spent = 0;
+    const out = [];
+    // Smallest first: the most tables for the budget.
+    for (const t of sized.sort((a, b) => a.n - b.n)) {
+        if (t.pk.length === 0) {
+            out.push({ name: t.name, pk: [], file: null, skipped: "it has no primary key" });
+            continue;
+        }
+        const data = JSON.stringify(await rows(url, key, t.name));
+        if (spent + data.length > budget()) {
+            out.push({ name: t.name, pk: t.pk, file: null, skipped: "it was too big to copy" });
+            continue;
+        }
+        spent += data.length;
+        const file = join(dir, `${out.length}.json`);
+        writeFileSync(file, data, { mode: 0o600 });
+        out.push({ name: t.name, pk: t.pk, file });
+    }
+    return { adapter: "rest", url, tables: out };
+}
+const keyOf = (pk, r) => JSON.stringify(pk.map((c) => r[c]));
+const same = (a, b) => JSON.stringify(Object.entries(a).sort()) === JSON.stringify(Object.entries(b).sort());
+// PostgREST's filter syntax for one row's key.
+function match(pk, r) {
+    return pk.map((c) => `${encodeURIComponent(c)}=eq.${encodeURIComponent(String(r[c]))}`).join("&");
+}
+export async function undoRest(u, key) {
+    const log = [];
+    const plans = [];
+    const live = new Set((await describe(u.url, key)).map((t) => t.name));
+    for (const t of u.tables) {
+        if (!t.file) {
+            if (t.skipped === "it was too big to copy")
+                log.push(`couldn't put back the rows of ${t.name}: ${t.skipped}`);
+            continue;
+        }
+        if (!live.has(t.name)) {
+            log.push(`couldn't put back ${t.name}: the table is gone, and bringing back a table needs the database connected`);
+            continue;
+        }
+        const was = JSON.parse(readFileSync(t.file, "utf8"));
+        const now = await rows(u.url, key, t.name);
+        const before = new Map(was.map((r) => [keyOf(t.pk, r), r]));
+        const after = new Map(now.map((r) => [keyOf(t.pk, r), r]));
+        const del = now.filter((r) => !before.has(keyOf(t.pk, r)));
+        const put = was.filter((r) => {
+            const cur = after.get(keyOf(t.pk, r));
+            return !cur || !same(cur, r);
+        });
+        if (del.length || put.length)
+            plans.push({ t, del, put });
+    }
+    // Foreign keys decide the order, which the API doesn't say: deletes and
+    // writes that fail are tried again after the others, until nothing moves.
+    const deleted = new Map();
+    for (let left = plans.flatMap((p) => p.del.map((r) => ({ p, r }))), pass = 0; left.length && pass < 6; pass++) {
+        const failed = [];
+        for (const { p, r } of left) {
+            try {
+                await call(u.url, key, `${encodeURIComponent(p.t.name)}?${match(p.t.pk, r)}`, { method: "DELETE" });
+                deleted.set(p.t.name, (deleted.get(p.t.name) ?? 0) + 1);
+            }
+            catch {
+                failed.push({ p, r });
+            }
+        }
+        if (failed.length === left.length)
+            throw new Error(`couldn't delete the rows added to ${failed[0].p.t.name}`);
+        left = failed;
+    }
+    const restored = new Map();
+    for (let left = plans.filter((p) => p.put.length), pass = 0; left.length && pass < 6; pass++) {
+        const failed = [];
+        for (const p of left) {
+            try {
+                await upsert(u.url, key, p.t, p.put);
+                restored.set(p.t.name, p.put.length);
+            }
+            catch {
+                failed.push(p);
+            }
+        }
+        if (failed.length === left.length)
+            throw new Error(`couldn't write back the rows of ${failed[0].t.name}`);
+        left = failed;
+    }
+    for (const p of plans) {
+        const parts = [restored.get(p.t.name) ? `put back ${restored.get(p.t.name)} rows` : "", deleted.get(p.t.name) ? `removed ${deleted.get(p.t.name)} new rows` : ""].filter(Boolean);
+        if (parts.length)
+            log.unshift(`${p.t.name}: ${parts.join(", ")}`);
+    }
+    return log.length ? log.join("\n") : "nothing had changed in Supabase";
+}
+// Writes rows back over whatever has their key. Columns the database fills in
+// itself (generated ones) are dropped and tried again when it refuses them.
+async function upsert(url, key, t, put) {
+    let body = put;
+    for (let i = 0; i < 5; i++) {
+        try {
+            await call(url, key, `${encodeURIComponent(t.name)}?on_conflict=${t.pk.map(encodeURIComponent).join(",")}`, {
+                method: "POST",
+                headers: { prefer: "resolution=merge-duplicates,return=minimal" },
+                body: JSON.stringify(body),
+            });
+            return;
+        }
+        catch (err) {
+            const col = String(err).match(/column "([^"]+)" can only be updated to DEFAULT|cannot insert a non-DEFAULT value into column "([^"]+)"/);
+            const name = col?.[1] ?? col?.[2];
+            if (!name)
+                throw err;
+            body = body.map(({ [name]: _, ...rest }) => rest);
+        }
+    }
+}

package/dist/check.js

@@ -3,7 +3,7 @@
 // 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 { configServers, projectUses } from "./connect.js";
+import { configServers, projectConnected, projectUses, supabaseDirs } from "./connect.js";
 import { supabaseProjects } from "./supabase.js";
 import { watchRules } from "./watch.js";
 import { dim, pink, white, width, wrap } from "./look.js";
@@ -60,12 +60,13 @@ function classify(s, supabaseConnected, ruled) {
 // which starts every server: for a check as a session starts.
 export function check(dir, opts = {}) {
     const found = (opts.quick ? null : listed(dir)) ?? configServers(dir);
-    const connected = supabaseProjects().length > 0;
+    // A database connection, or the project's own API keys.
+    const connected = supabaseProjects().length > 0 || supabaseDirs(dir).some(projectConnected);
     const ruled = new Set(watchRules().map((r) => r.server ?? "").filter(Boolean));
     const items = found.map((s) => classify(s, connected, ruled));
     const uses = projectUses(dir);
     const suggest = [];
-    const supabaseHere = items.some((i) => SUPABASE.test(i.name)) || uses.supabase;
+    const supabaseHere = items.some((i) => SUPABASE.test(i.name)) || uses.supabase || supabaseDirs(dir).length > 0;
     if (!connected && supabaseHere) {
         suggest.push({ title: "Connect Supabase", why: "so Claude's database changes can be undone", how: 'Ask Claude: "connect Backstep to Supabase"' });
     }

package/dist/cli.js

@@ -9,16 +9,23 @@ import { snapshotPaths } from "./adapters/fs.js";
 import { notePushed, snapshotTree } from "./adapters/tree.js";
 import { revertPush } from "./push.js";
 import { snapshotDb } from "./adapters/dbsnap.js";
-import { projectDatabases } from "./connect.js";
+import { projectConnected, projectDatabases, restKeys, supabaseDirs } from "./connect.js";
+import { snapshotRest } from "./adapters/rest.js";
 const PUSH = /\bgit\b[^;&|]*\bpush\b/;
-import { classifyShell, supabaseTarget, touchesDatabase } from "./shell.js";
+import { classifyShell, commandDir, supabaseTarget, touchesDatabase, touchesSupabase } from "./shell.js";
 import { watchEnd, watchStart } from "./watch.js";
 import { sendActive } from "./telemetry.js";
 import { readFileSync, rmSync } from "node:fs";
 import { loadRules } from "./rules.js";
 import { setup } from "./setup.js";
 import { autoWrap, printChanges, unwrapServers, wrapServers } from "./servers.js";
-import { disconnectSupabase, dismissSupabase } from "./supabase.js";
+import { disconnectSupabase, dismissSupabase, restKey, supabaseDismissed } from "./supabase.js";
+// The Supabase projects a shell command could change: those in the folder it
+// works in (or a level or two below), when the command is one that reaches a database.
+function reachedProjects(command, cwd) {
+    const dirs = supabaseDirs(commandDir(command, cwd));
+    return touchesDatabase(command) || touchesSupabase(command, dirs.length > 0) ? dirs : [];
+}
 import { connect } from "./connect.js";
 import { check, printCheck } from "./check.js";
 import { logo } from "./look.js";
@@ -343,11 +350,15 @@ async function main() {
         // A push also notes where the remote branches stood, so undo can take it back there too.
         const cwd = values.cwd ?? process.cwd();
         const tree = snapshotTree(a.id, cwd, { pushes: PUSH.test(command) });
-        // A migration, reset, seed or raw SQL: the connected databases it could change are noted too.
+        // A migration, reset, seed, raw SQL, or anything reaching Supabase's API: the
+        // connected databases it could change are noted too, or their rows through
+        // the API where only the project's keys connect it.
         const dbs = [];
+        const rests = [];
         const missed = [];
-        if (touchesDatabase(command)) {
-            for (const url of await projectDatabases(cwd, supabaseTarget(command))) {
+        for (const d of reachedProjects(command, cwd)) {
+            const urls = await projectDatabases(d, supabaseTarget(command));
+            for (const url of urls) {
                 try {
                     dbs.push(await snapshotDb(a.id, url));
                 }
@@ -355,12 +366,23 @@ async function main() {
                     missed.push(err instanceof Error ? err.message : String(err));
                 }
             }
+            const rest = restKeys(d);
+            if (!urls.length && rest && restKey(rest.url)) {
+                try {
+                    rests.push(await snapshotRest(a.id, rest.url, restKey(rest.url)));
+                }
+                catch (err) {
+                    missed.push(err instanceof Error ? err.message : String(err));
+                }
+            }
         }
-        const undo = tree ? { ...tree, ...(dbs.length ? { dbs } : {}) } : dbs.length ? { adapter: "dbs", dbs } : null;
+        const extra = { ...(dbs.length ? { dbs } : {}), ...(rests.length ? { rests } : {}) };
+        const undo = tree ? { ...tree, ...extra } : dbs.length || rests.length ? { adapter: "dbs", dbs, rests } : null;
         if (undo)
             store.updateAction(a.id, { undo: JSON.stringify(undo) });
         // With its database saved, a command that reaches it is no longer lost to undo.
-        const kind = plan.kind === "outbound" && dbs.length && plan.reason === "changes a database directly" ? "write" : plan.kind;
+        const saved = dbs.length + rests.length;
+        const kind = plan.kind === "outbound" && saved && /database|request/.test(plan.reason ?? "") ? "write" : plan.kind;
         if (kind !== plan.kind)
             store.updateAction(a.id, { kind: "reversible", reason: null });
         if (!undo && kind !== "outbound")
@@ -369,7 +391,17 @@ async function main() {
             store.updateAction(a.id, { reason: `couldn't save the database first: ${missed[0]}` });
         if (dbs.length)
             await pruneDatabaseCopies(store).catch(() => { });
-        console.log(JSON.stringify({ kind, reason: kind === plan.kind ? plan.reason : undefined, id: a.id, undoable: undo !== null, db: dbs.length }));
+        console.log(JSON.stringify({ kind, reason: kind === plan.kind ? plan.reason : undefined, id: a.id, undoable: undo !== null, db: saved }));
+        return;
+    }
+    // Before a shell command, from the Claude Code mod: does it reach a Supabase project Backstep
+    // isn't connected to? Then the mod asks first, so the project can be saved before it changes.
+    if (cmd === "db-check") {
+        const sep = rest.indexOf("--");
+        const { values } = parseArgs({ args: sep === -1 ? rest : rest.slice(0, sep), options: { cwd: { type: "string" } } });
+        const command = sep === -1 ? "" : rest.slice(sep + 1).join(" ");
+        const ask = reachedProjects(command, values.cwd ?? process.cwd()).find((d) => !projectConnected(d) && !supabaseDismissed(d));
+        console.log(JSON.stringify({ ask: ask ?? null }));
         return;
     }
     // After a shell command that pushed: notes what it sent (run by the Claude Code mod).

package/dist/connect.js

@@ -8,11 +8,11 @@
 //    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 { existsSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { claudeConfigFile, wrapServers } from "./servers.js";
-import { connectSupabase, hasSavedToken, LOCAL, mintSupabase, projectRef, saveSupabaseToken, supabaseDb, supabaseDismissed, supabaseProjects, supabaseToken, supabaseUrl, } from "./supabase.js";
+import { connectSupabase, hasSavedToken, LOCAL, mintSupabase, projectRef, saveSupabaseToken, supabaseDb, restKey, saveRest, supabaseDismissed, supabaseProjects, supabaseToken, supabaseUrl, } from "./supabase.js";
 const ENV_FILES = [".env", ".env.local", ".env.development", ".env.development.local"];
 const PG = /^postgres(ql)?:\/\//;
 const FIREBASE_SERVER = ["npx", "-y", "firebase-tools@latest", "mcp"];
@@ -75,6 +75,41 @@ export function projectUses(dir) {
         firebase: existsSync(join(dir, "firebase.json")) || existsSync(join(dir, ".firebaserc")) || d.some((x) => x === "firebase" || x === "firebase-admin"),
     };
 }
+// Folders a session in `dir` works in that use Supabase: the folder itself, or
+// its projects a level or two down (Claude Code opened in a parent folder).
+export function supabaseDirs(dir) {
+    if (projectUses(dir).supabase)
+        return [dir];
+    const out = [];
+    const walk = (d, depth) => {
+        if (depth === 0)
+            return;
+        let names = [];
+        try {
+            names = readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory() && !/^(\.|node_modules$|dist$|build$|out$|coverage$)/.test(e.name)).map((e) => e.name);
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            const child = join(d, n);
+            if (projectUses(child).supabase)
+                out.push(child);
+            else
+                walk(child, depth - 1);
+        }
+    };
+    walk(dir, 2);
+    return out;
+}
+// The project's API URL and service key, from its .env files: enough to read
+// and write its rows through Supabase's own API, with no database password.
+export function restKeys(dir) {
+    const vars = envVars(dir);
+    const url = vars.find(([k, v]) => /SUPABASE_URL$/.test(k) && /^https?:\/\//.test(v))?.[1];
+    const key = vars.find(([k, v]) => /SERVICE_ROLE|SERVICE_KEY|SECRET_KEY/.test(k) && (/SUPABASE/.test(k) || v.startsWith("sb_secret_")) && v.length > 20)?.[1];
+    return url && key ? { url: url.replace(/\/$/, ""), key } : null;
+}
 // Connection strings worth trying, best first: the ones that say they're
 // direct, then any other Postgres URL in the project's env files.
 function candidates(dir) {
@@ -94,7 +129,7 @@ const TOKENS = "https://supabase.com/dashboard/account/tokens";
 const WHERE = "Supabase → your project → Connect (top of the page) → Direct connection (or Session pooler) → copy the URI and put the database password in place of [YOUR-PASSWORD]";
 // The hosted project a folder belongs to: `supabase link` notes it, and the
 // app's own settings name it in its API URL.
-function linkedRef(dir) {
+export function linkedRef(dir) {
     const linked = read(join(dir, "supabase", ".temp", "project-ref")).trim();
     if (/^[a-z0-9]{20}$/.test(linked))
         return linked;
@@ -136,8 +171,11 @@ async function signedIn(dir, token, ref, isNew) {
     }
     return isNew ? { service: "supabase", state: "connected", detail: "signed in to Supabase, so each project connects itself as Claude uses it" } : null;
 }
-// Whether the project this folder uses already has its database connected.
-function projectConnected(dir) {
+// Whether the project this folder uses is connected: its database, or its API through the project's keys.
+export function projectConnected(dir) {
+    const rest = restKeys(dir);
+    if (rest && restKey(rest.url))
+        return true;
     const ref = linkedRef(dir);
     return ref ? supabaseProjects().includes(ref) : supabaseProjects().length > 0;
 }
@@ -145,12 +183,16 @@ async function supabase(dir, given, ref, interactive = false, auto = false) {
     const label = (r) => (r === LOCAL ? "the local database" : `project ${r}`);
     // On its own, Backstep only notices: connecting is the person's call.
     if (auto) {
-        if (!projectUses(dir).supabase || supabaseDismissed(dir))
-            return { service: "supabase", state: "unused", detail: "nothing to ask" };
-        if (projectConnected(dir))
-            return { service: "supabase", state: "covered", detail: "already connected" };
-        return { service: "supabase", state: "ask", detail: "this project uses Supabase, but Backstep isn't connected to it" };
+        const dirs = supabaseDirs(dir);
+        const unconnected = dirs.find((d) => !supabaseDismissed(d) && !projectConnected(d));
+        if (unconnected)
+            return { service: "supabase", state: "ask", detail: "this project uses Supabase, but Backstep isn't connected to it", dir: unconnected };
+        // Connected, or the person said not to ask.
+        return dirs.some(projectConnected) ? { service: "supabase", state: "covered", detail: "already connected" } : { service: "supabase", state: "unused", detail: "nothing to ask" };
     }
+    // Opened in a parent folder: connect the Supabase project inside it.
+    if (!projectUses(dir).supabase)
+        dir = supabaseDirs(dir)[0] ?? dir;
     // An access token (sbp_…) rather than a connection string: one sign-in for every project.
     if (given?.startsWith("sbp_")) {
         try {
@@ -200,6 +242,24 @@ async function supabase(dir, given, ref, interactive = false, auto = false) {
     }
     if (had.length)
         return { service: "supabase", state: "covered", detail: `already connected: ${had.map(label).join(", ")}` };
+    // No database to reach, but the project's own API keys: rows can be undone through them.
+    const rest = restKeys(dir);
+    if (rest) {
+        try {
+            const r = await fetch(`${rest.url}/rest/v1/`, { headers: { apikey: rest.key, authorization: `Bearer ${rest.key}` }, signal: AbortSignal.timeout(15_000) });
+            if (!r.ok)
+                throw new Error(`Supabase said ${r.status}`);
+            saveRest(rest.url, rest.key);
+            return {
+                service: "supabase",
+                state: "connected",
+                detail: "connected with the project's own Supabase keys: rows Claude adds, changes or deletes can be undone (undoing changes to tables themselves needs the database password or an access token)",
+            };
+        }
+        catch (err) {
+            errors.push(`the project's Supabase keys didn't work: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     const used = /supabase/i.test(servers(dir).join("\n")) || projectUses(dir).supabase;
     if (!used && errors.length === 0)
         return { service: "supabase", state: "unused", detail: "this project doesn't use Supabase" };

package/dist/shell.js

@@ -125,3 +125,19 @@ export function supabaseTarget(command) {
         return "local";
     return /--linked\b|--db-url\b|\bdb\s+push\b/.test(command) ? "hosted" : "local";
 }
+// Commands that reach a Supabase project some other way: its web API (curl to
+// /rest/v1, its URL or keys from .env), or a script or package script that
+// might use supabase-js, judged together with whether the project uses Supabase.
+const SUPABASE_API = /supabase\.co\b|\/rest\/v1\b|SUPABASE_[A-Z_]*(URL|KEY)|(localhost|127\.0\.0\.1):54321\b/;
+const SCRIPT = /(^|[\s;&|(])((node|tsx|ts-node|bun|deno|python3?)\s+(run\s+)?[^\s;&|]+\.(m?[jt]s|cjs|py)\b|(npm|pnpm|yarn|bun)\s+(run\s+)?(seed|db|migrate|reset)[\w:-]*)/;
+export function touchesSupabase(command, projectUsesSupabase) {
+    return SUPABASE_API.test(command) || (projectUsesSupabase && SCRIPT.test(command));
+}
+// The folder a command works in: where its leading `cd` goes, else where it runs.
+export function commandDir(command, cwd) {
+    const m = command.match(/^\s*cd\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*(&&|;|$)/);
+    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}`;
+}

package/dist/supabase.js

@@ -159,6 +159,12 @@ async function api(token, method, path, body) {
     return (await r.json());
 }
 export const hasSavedToken = () => Boolean(load().token);
+export function saveRest(url, key) {
+    const c = load();
+    c.rest = { ...c.rest, [url.replace(/\/$/, "")]: key };
+    save(c);
+}
+export const restKey = (url) => load().rest?.[url.replace(/\/$/, "")] ?? null;
 export function dismissSupabase(dir) {
     const c = load();
     c.dismissed = [...new Set([...(c.dismissed ?? []), dir])];

package/dist/undo.js

@@ -5,7 +5,8 @@ import { undoSql } from "./adapters/postgres.js";
 import { undoTree } from "./adapters/tree.js";
 import { discardDb, undoDb } from "./adapters/dbsnap.js";
 import { snapshotDir } from "./store.js";
-import { dbKey, freshUrl } from "./supabase.js";
+import { dbKey, freshUrl, restKey } from "./supabase.js";
+import { undoRest } from "./adapters/rest.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.
@@ -38,10 +39,11 @@ function resources(store, a) {
         return new Set(u.entries.map((e) => `fs:${e.path}`));
     // A project snapshot rewinds every file under its folder, and any whole database saved with it.
     const whole = (dbs = []) => dbs.map((d) => `pgdb:${dbKey(d.url)}`);
+    const apis = (rests = []) => rests.map((r) => `pgdb:${r.url}`);
     if (u.adapter === "tree")
-        return new Set([`fs:${u.root}`, ...whole(u.dbs)]);
+        return new Set([`fs:${u.root}`, ...whole(u.dbs), ...apis(u.rests)]);
     if (u.adapter === "dbs")
-        return new Set(whole(u.dbs));
+        return new Set([...whole(u.dbs), ...apis(u.rests)]);
     // An opposite tool call doesn't rewind shared state, so it never conflicts.
     if (u.adapter === "inverse" || u.adapter === "engine")
         return new Set();
@@ -134,6 +136,12 @@ async function undoOne(store, a, opts = {}) {
             const lines = [];
             for (const d of u.dbs ?? [])
                 lines.push(await undoDb(await freshUrl(d.url), d));
+            for (const r of u.rests ?? []) {
+                const key = restKey(r.url);
+                if (!key)
+                    throw new Error(`Backstep isn't connected to ${r.url} any more`);
+                lines.push(await undoRest(r, key));
+            }
             if (u.adapter === "tree")
                 lines.unshift(undoTree(u, a.id));
             detail = lines.filter((l) => !/^nothing had changed/.test(l)).join("\n") || lines[0];

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

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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

@@ -13,9 +13,14 @@ const CLI = '/opt/backstep/cli.js'
 // `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 }) {
   const runs: string[][] = []
+  const logs: string[] = []
   const prompts: { text: string; context?: readonly string[] }[] = []
   on('session.cwd', () => ({ value: '/repo' }))
   on('session.id', () => ({ value: 's1' }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
   on('process.run', (_, e) => {
     runs.push([...e.argv])
     const r = e.argv.includes('undo') ? undo : e.argv.includes('shell') ? { exitCode: 0, stdout: JSON.stringify(shell) } : { exitCode: 0, stdout: '' }
@@ -30,7 +35,7 @@ function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: strin
     const { Text } = $.ui.resolve(e)
     return <Text>engine</Text>
   })
-  return { runs, prompts }
+  return { runs, prompts, logs }
 }
 
 test('an edit is snapshotted and the band offers to undo the turn', { options: { cli: CLI } }, async ($, on) => {
@@ -43,6 +48,7 @@ test('an edit is snapshotted and the band offers to undo the turn', { options: {
 
   expect(runs).toEqual([
     ['node', '--disable-warning=ExperimentalWarning', CLI, 'snap', '--session', 's1', '--tool', 'Edit', '--cwd', '/repo', '--', '/repo/src/a.ts'],
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'db-check', '--cwd', '/repo', '--', 'ls'],
     ['node', '--disable-warning=ExperimentalWarning', CLI, 'shell', '--session', 's1', '--cwd', '/repo', '--', 'ls'],
   ])
 
@@ -109,11 +115,12 @@ test('a change that cannot be undone stops the rewind and says so', { options: {
   const pressed = ui.press({ key: 'undo' })
   await clock.advance(1000)
   await pressed
+  await clock.advance(500)
   expect((await ui.find({ type: 'Text', text: /Stopped/ }))?.text).toContain('Stopped after 1 change')
   expect((await ui.find({ type: 'Text', text: /row changed since/ }))).toBeTruthy()
 
   // Still undoable once the band folds, since the turn was not fully rewound.
-  await clock.advance(10000)
+  await clock.advance(13000)
   expect(await ui.find({ type: 'Button', key: 'undo' })).toBeTruthy()
   await ui.unmount()
   expect(prompts).toHaveLength(1)
@@ -218,6 +225,7 @@ function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?:
     toasts.push(e.text)
     return { value: undefined }
   })
+  on('ui.log', () => ({ value: undefined }))
   on('session.cwd', () => ({ value: '/repo' }))
   on('session.id', () => ({ value: 's1' }))
   on('process.run', (_, e) => {
@@ -529,7 +537,7 @@ test('one press only asks; it lets go after a few seconds, or on cancel, and und
   const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
 
   await ui.press({ key: 'undo' })
-  expect((await ui.find({ type: 'Text', text: /Undo Claude's last turn\?/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /Undo Claude's last turn \("fix it"\)\?/ }))).toBeTruthy()
   expect((await ui.find({ type: 'Button', key: 'undo' }))?.text).toBe('ctrl+u again to undo')
   await clock.advance(6000)
   expect((await ui.find({ type: 'Text', text: /Last turn/ }))).toBeTruthy()
@@ -566,3 +574,123 @@ test('with two keys bound the band names both', { options: { cli: CLI } }, async
   expect((await ui.find({ type: 'Button', key: 'undo' }))?.text).toBe('ctrl+u / ctrl+q to undo')
   await ui.unmount()
 })
+
+test('about to change a Supabase project that is not connected, Backstep asks first, then saves it', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const runs: string[][] = []
+  const asked: string[] = []
+  on('session.cwd', () => ({ value: '/work' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('ui.toast', () => ({ value: undefined }))
+  on('process.run', (_, e) => {
+    runs.push([...e.argv])
+    const stdout = e.argv.includes('db-check')
+      ? JSON.stringify({ ask: '/work/taskflow' })
+      : e.argv.includes('connect')
+        ? JSON.stringify([{ service: 'supabase', state: 'connected', detail: "connected with the project's own Supabase keys" }])
+        : e.argv.includes('shell')
+          ? JSON.stringify({ kind: 'write', id: 'r1', undoable: true, db: 1 })
+          : '[]'
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('tool.call', { tool: 'AskUserQuestion' }, (_, e) => {
+    const questions = (e as unknown as { questions: { question: string }[] }).questions
+    asked.push(questions[0].question)
+    return { result: { questions, answers: { [questions[0].question]: 'Connect' } } }
+  })
+  on('tool.call', () => ({ result: {} }))
+  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+
+  await $.prompt.submit({ text: 'seed it', wait: false, origin: { kind: 'composer' } })
+  const command = 'cd taskflow && curl -X POST "$NEXT_PUBLIC_SUPABASE_URL/rest/v1/tasks"'
+  await $.tool.call({ tool: 'Bash', command })
+  expect(asked).toHaveLength(1)
+  const order = runs.map((r) => r[3])
+  expect(order).toEqual(['db-check', 'connect', 'shell'])
+  expect(runs[1].slice(3)).toEqual(['connect', 'supabase', '--dir', '/work/taskflow', '--json'])
+
+  // Asked once a session per project, whatever the answer.
+  await $.tool.call({ tool: 'Bash', command })
+  expect(asked).toHaveLength(1)
+})
+
+// An engine where each shell command's plan is given by a test, and undo answers as told.
+function shellEngine(on: On, plans: (command: string) => object, undo: object[]) {
+  const runs: string[][] = []
+  const logs: string[] = []
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('ui.toast', () => ({ value: undefined }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
+  on('process.run', (_, e) => {
+    runs.push([...e.argv])
+    const command = e.argv.at(-1) ?? ''
+    const out = e.argv.includes('undo') ? undo : e.argv.includes('shell') ? plans(command) : e.argv.includes('db-check') ? { ask: null } : null
+    return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('tool.call', { tool: 'AskUserQuestion' }, () => ({ result: { questions: [], answers: {} } }))
+  on('tool.call', () => ({ result: {} }))
+  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+  return { runs, logs }
+}
+
+test('when the last turn only committed and pushed, undo offers to take back the work it saved too', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs } = shellEngine(on, () => ({ kind: 'outbound', reason: 'pushes to a remote', id: 'p1', undoable: true }), [])
+
+  await $.prompt.submit({ text: 'add the kanban board', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/board.tsx', old_string: 'a', new_string: 'b' })
+  await clock.advance(1000)
+  await $.prompt.submit({ text: 'commit and push it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'git add -A && git commit -m "board" && git push' })
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect((await ui.find({ type: 'Text', text: /Last turn \("commit and push it"\)/ }))).toBeTruthy()
+  await ui.press({ key: 'undo' })
+  expect((await ui.find({ type: 'Text', text: /only saved and pushed to git/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Button', key: 'undo' }))?.text).toBe('ctrl+u again to undo it and the turn before ("add the kanban board")')
+  expect(await ui.find({ type: 'Button', key: 'just' })).toBeTruthy()
+
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  // Both turns: everything since the first one started.
+  expect(runs.find((r) => r.includes('undo'))?.slice(3)).toEqual(['undo', '--since', '5000', '--json', '--via-claude-code'])
+  await ui.unmount()
+})
+
+test('after an undo, everything undone and everything that was not is listed, in the band and the conversation', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { logs } = shellEngine(
+    on,
+    (command) => (command.startsWith('curl') ? { kind: 'outbound', reason: 'sends a request', id: 'r1', undoable: true } : { kind: 'write', id: 'w1', undoable: true }),
+    [{ id: 'w1', tool: 'Bash', ok: true, detail: 'restored /repo/src/a.ts\nremoved /repo/src/b.ts' }],
+  )
+
+  await $.prompt.submit({ text: 'tidy and notify', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'rm src/a.ts' })
+  await $.tool.call({ tool: 'Bash', command: 'curl -X POST https://hooks.example.com/notify -d done' })
+
+  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
+  await clock.advance(500)
+  expect((await ui.find({ type: 'Text', text: /src\/a\.ts restored/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /Not undone/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /curl -X POST https:\/\/hooks\.example\.com\/notify -d done: sends a request/ }))).toBeTruthy()
+
+  const report = logs.find((l) => l.includes('Backstep undid'))!
+  expect(report).toContain('undid 2 changes from the last turn ("tidy and notify")')
+  expect(report).toContain('◀ src/b.ts removed')
+  expect(report).toContain('Not undone:\n  ✗ curl -X POST')
+  await ui.unmount()
+})

package/mod/hooks/register.tsx

@@ -19,6 +19,8 @@ const keys = atom({ plugin: 'backstep', key: 'keys' } as const, ['ctrl+u'] as st
 // Backstep's mark, as on the logo: the front rewind triangle in the terminal's
 // own black or white, the one behind it in the logo's pink.
 const PINK = '#ee7bb6'
+// The mark where only plain text goes (a transcript line).
+const MARK_TEXT = '◀◀'
 // How long the "press again to undo" question waits before it lets go.
 const CONFIRM_MS = 5000
 
@@ -71,7 +73,10 @@ async function offerPushUndo($: EngineInterface, outcomes: Outcome[]) {
           ? `Claude pushed a new branch, ${p.branch}, to ${p.host}. Delete it there too?`
           : `Claude pushed ${p.commits === 1 ? '1 commit' : `${p.commits} commits`} to ${p.branch} on ${p.host}. Undo ${p.commits === 1 ? 'it' : 'them'} there too?`
       const answer = await $.ui.ask(what, { header: 'Backstep', options: [p.before === null ? 'Delete the branch' : PUSH_ASK.yes, PUSH_ASK.no] }).catch(() => null)
-      if (!answer || answer === PUSH_ASK.no) continue
+      if (!answer || answer === PUSH_ASK.no) {
+        $.ui.log(`${MARK_TEXT} Not undone on ${p.host}: Claude's ${p.before === null ? `branch ${p.branch}` : p.commits === 1 ? 'commit' : `${p.commits} commits`} stay there (you chose to leave it).`)
+        continue
+      }
       const ran = await $.process
         .run(backstep(['revert-push', '--root', o.pushed.root]), { stdin: JSON.stringify(p), timeoutMs: 180_000 })
         .catch((err: unknown) => ({ exitCode: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) }))
@@ -82,6 +87,7 @@ async function offerPushUndo($: EngineInterface, outcomes: Outcome[]) {
         // keep the error above
       }
       $.ui.toast(r.ok ? `Backstep ${r.detail}.` : `Backstep ${r.detail}. Nothing was changed on ${p.host}.`)
+      $.ui.log(r.ok ? `${MARK_TEXT} On ${p.host}: ${r.detail}.` : `${MARK_TEXT} Not undone on ${p.host}: ${r.detail}. Nothing was changed there.`)
       await update($, note, (n) =>
         n ? `${n}\n${r.ok ? `On ${p.host}: ${r.detail}.` : `${p.host} was left as it was: ${r.detail}.`}` : n,
       )
@@ -103,7 +109,8 @@ async function pressUndo($: EngineInterface) {
   const now = await $.clock.now()
   if (at !== null && now - at < CONFIRM_MS) {
     await update($, armed, () => null)
-    return undoLastTurn($)
+    const { before } = await undoTargets($)
+    return undoLastTurn($, before ? 2 : 1)
   }
   await update($, armed, () => now)
   $.clock.after(CONFIRM_MS, () => {
@@ -111,9 +118,11 @@ async function pressUndo($: EngineInterface) {
   })
 }
 
-async function undoLastTurn($: EngineInterface) {
+// Undoes the last `count` turns that changed something, newest first.
+async function undoLastTurn($: EngineInterface, count = 1) {
   if (await read($, rewind)) return
-  const target = (await read($, turns)).findLast(hasWork)
+  const taken = (await read($, turns)).filter(hasWork).slice(-count)
+  const target = taken[0]
   if (!target) return
 
   await update($, rewind, (): Rewind => ({ phase: 'running', frame: 0, shown: 0, items: [], message: '' }))
@@ -165,17 +174,28 @@ async function undoLastTurn($: EngineInterface) {
   const cut = outcomes.findIndex((o) => !o.ok)
   if (cut !== -1) outcomes = outcomes.slice(0, cut + 1)
 
-  const items: RewindItem[] = outcomes.map((o) => {
-    const first = o.detail.split('\n')[0] ?? ''
-    const what = first.replace(/^(restored|removed) (.*)$/, (_, verb: string, p: string) => `${short(p)} ${verb}`)
-    return { label: o.ok ? what || o.tool : `${o.tool}: ${first}`, ok: o.ok }
-  })
-  const done = items.filter((i) => i.ok).length
-  const failed = items.some((i) => !i.ok)
-  // A push counted as lost when it ran, but undo can now offer to take it back there.
-  const offered = outcomes.filter((o) => o.ok && o.pushed).length
-  const lost = Math.max(0, (target.lost ?? 0) - offered)
-  const shell = lost ? ` ${plural(lost, 'action')} that reached outside couldn't be undone.` : ''
+  // Every change undone, one per line, and every one that wasn't, with why.
+  const undone: RewindItem[] = outcomes
+    .filter((o) => o.ok)
+    .flatMap((o) =>
+      (o.detail || o.tool)
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => ({ label: line.replace(/^(restored|removed) (.*)$/, (_, verb: string, p: string) => `${short(p)} ${verb}`), ok: true })),
+    )
+  const stopped = outcomes.filter((o) => !o.ok).map((o) => ({ label: `${o.tool}: ${o.detail.split('\n')[0] ?? 'failed'}`, ok: false }))
+  // A push is offered back on GitHub below, so it isn't listed as lost.
+  const offered = outcomes.some((o) => o.ok && o.pushed)
+  const kept = taken
+    .flatMap((t) => t.lostItems ?? [])
+    .filter((l) => !(offered && /pushes to a remote/.test(l)))
+    .map((label) => ({ label, ok: false }))
+  const items: RewindItem[] = [...undone, ...stopped, ...kept]
+  const done = undone.length
+  const failed = stopped.length > 0
+  const lost = kept.length
+  const which = taken.length > 1 ? `the last ${taken.length} turns` : 'the last turn'
+  const shell = lost ? ` ${plural(lost, 'thing')} couldn't be undone: listed below.` : ''
 
   await update($, rewind, (): Rewind => ({
     phase: failed ? 'failed' : items.length ? 'done' : 'empty',
@@ -185,16 +205,24 @@ async function undoLastTurn($: EngineInterface) {
     message: failed
       ? `Stopped after ${plural(done, 'change')}: the next one couldn't be undone.`
       : items.length
-        ? `Rewound ${plural(done, 'change')} from the last turn.${shell}`
-        : `Nothing in the last turn could be undone.${shell}`,
+        ? `Rewound ${plural(done, 'change')} from ${which}.${shell}`
+        : `Nothing in ${which} could be undone.${shell}`,
   }))
-  await bump($, target.id, (t) => ({ ...t, undone: !failed }))
+  for (const t of taken) await bump($, t.id, (x) => ({ ...x, undone: !failed }))
+
+  // The whole account, kept in the conversation, where the band's few rows fold away.
+  const report = [
+    `${MARK_TEXT} Backstep undid ${plural(done, 'change')} from ${which}${taken.length === 1 ? named(target) : ''}${done ? ':' : '.'}`,
+    ...undone.map((i) => `  ◀ ${i.label}`),
+    ...(stopped.length || kept.length ? ["Not undone:", ...[...stopped, ...kept].map((i) => `  ✗ ${i.label}`)] : []),
+  ]
+  $.ui.log(report.join('\n'))
 
   if (done) {
     const list = items.filter((i) => i.ok).map((i) => `- ${i.label}`).join('\n')
     const key = await keysLabel($)
     await update($, note, () =>
-      `[Backstep] The user pressed undo (${key}) on your previous turn. These changes were reverted:\n${list}\n` +
+      `[Backstep] The user pressed undo (${key}) on your ${taken.length > 1 ? `last ${taken.length} turns` : 'previous turn'}. These changes were reverted:\n${list}\n` +
         (lost ? `${plural(lost, 'action')} from that turn couldn't be undone (they reached outside this machine with no way back, or the project was too big to snapshot).\n` : '') +
         `Treat them as not having happened, re-read files before editing them, and don't redo them unless asked.`,
     )
@@ -207,7 +235,7 @@ async function undoLastTurn($: EngineInterface) {
   const reveal = $.clock.every(90, () => {
     void update($, rewind, (r) => (r && r.shown < r.items.length ? { ...r, shown: r.shown + 1 } : r))
   })
-  $.clock.after(failed ? 9000 : 4200, () => {
+  $.clock.after(failed || lost ? 12_000 : 4200, () => {
     reveal.cancel()
     void update($, rewind, () => null)
   })
@@ -257,7 +285,7 @@ async function watchMcp($: EngineInterface, e: Record<string, unknown>, next: Ne
   hint($, plan)
   // Behind Backstep, or Backstep couldn't be reached: count it as before.
   if (!plan || plan.kind === 'wrapped' || !plan.id) {
-    if (plan?.kind !== 'read') await bump($, t.id, (x) => ({ ...x, mcp: x.mcp + 1 }))
+    if (plan?.kind !== 'read') await bump($, t.id, (x) => ({ ...x, gitOnly: false, mcp: x.mcp + 1 }))
     return next(e)
   }
   const r = await next(plan.args ? { ...e, ...plan.args } : e)
@@ -274,7 +302,9 @@ async function watchMcp($: EngineInterface, e: Record<string, unknown>, next: Ne
   } catch {
     undoable = false
   }
-  if (!r.isError) await bump($, t.id, (x) => (undoable ? { ...x, mcp: x.mcp + 1 } : { ...x, lost: (x.lost ?? 0) + 1 }))
+  if (!r.isError) {
+    await bump($, t.id, (x) => (undoable ? { ...x, gitOnly: false, mcp: x.mcp + 1 } : lostOne({ ...x, gitOnly: false }, `${tool.replace(/^mcp__/, '').replace('__', ' ')}: ${plan.reason ?? 'there is no way to undo it'}`)))
+  }
   return r
 }
 
@@ -289,8 +319,40 @@ function backstep(args: string[]): string[] {
   return cli === 'backstep' ? ['backstep', ...args] : ['node', '--disable-warning=ExperimentalWarning', cli, ...args]
 }
 
-function newTurn(startedAt: number): Turn {
-  return { id: `t${startedAt}`, startedAt, edits: 0, files: [], mcp: 0, shell: 0, lost: 0, undone: false }
+function newTurn(startedAt: number, prompt?: string): Turn {
+  return { id: `t${startedAt}`, startedAt, edits: 0, files: [], mcp: 0, shell: 0, lost: 0, undone: false, ...(prompt ? { prompt } : {}) }
+}
+
+// A command as it reads in a list: without its leading `cd`, cut short.
+const brief = (command: string) => {
+  const c = command.replace(/^\s*cd\s+(?:"[^"]*"|'[^']*'|\S+)\s*&&\s*/, '').replace(/\s+/g, ' ').trim()
+  return c.length > 60 ? `${c.slice(0, 59)}…` : c
+}
+
+// Something in a turn that can't be undone, named, so undo can list it.
+const lostOne = (x: Turn, what: string): Turn => ({ ...x, lost: (x.lost ?? 0) + 1, lostItems: [...(x.lostItems ?? []), what].slice(-20) })
+
+// A turn named by what the person asked: ("commit and push it").
+const named = (t: Turn) => {
+  const p = (t.prompt ?? '').replace(/\s+/g, ' ').trim()
+  return p ? ` ("${p.length > 40 ? `${p.slice(0, 39)}…` : p}")` : ''
+}
+
+// Each part only saves to git (add, commit, push and friends), or only moves around.
+const GIT_SAVE = /^(git\s+(add|commit|push|status|log|diff|show|branch|remote|fetch|rev-parse|config)\b|cd\s|echo\s|true$)/
+const onlySavesToGit = (command: string) =>
+  command
+    .split(/&&|\|\||;|\n/)
+    .map((p) => p.trim())
+    .filter(Boolean)
+    .every((p) => GIT_SAVE.test(p))
+
+// What one press would take back: the last turn, and, when that turn only
+// committed and pushed, the turn whose work it saved.
+async function undoTargets($: EngineInterface): Promise<{ target: Turn | undefined; before: Turn | undefined }> {
+  const list = (await read($, turns)).filter(hasWork)
+  const target = list.at(-1)
+  return { target, before: target?.gitOnly ? list.at(-2) : undefined }
 }
 
 // The turn tool calls belong to; one opens if none is (a call before any prompt).
@@ -332,7 +394,7 @@ async function checkCoverage($: EngineInterface, cwd: string) {
   const found = await $.process.run(backstep(['connect', '--dir', cwd, '--json', '--auto']), { timeoutMs: 120_000 }).catch(() => null)
   try {
     for (const c of JSON.parse(found?.stdout || '[]') as Connected[]) {
-      if (c.service === 'supabase' && c.state === 'ask') await askSupabase($, cwd)
+      if (c.service === 'supabase' && c.state === 'ask') await askSupabase($, c.dir ?? cwd)
       if (c.state === 'added') $.ui.toast('Backstep added Firebase for this project, so Claude can reach it and its changes can be undone. Restart Claude Code to use it.')
     }
   } catch {
@@ -357,9 +419,15 @@ const ASK = {
   never: "Don't ask for this project",
 }
 
-// Asked when Claude Code opens a project that uses Supabase and Backstep isn't
-// connected to it; the answer is the only thing that connects it.
+// Projects asked about this session: "Not now" means not again until the next one.
+const asked = new Set<string>()
+
+// Asked when Claude Code opens a project that uses Supabase, or Claude is about
+// to change one, and Backstep isn't connected to it; the answer is the only
+// thing that connects it.
 async function askSupabase($: EngineInterface, cwd: string) {
+  if (asked.has(cwd)) return
+  asked.add(cwd)
   const answer = await $.ui
     .ask("This project uses Supabase, but Backstep isn't connected to it, so Claude's changes to its database can't be undone. Connect it?", {
       header: 'Backstep',
@@ -478,7 +546,7 @@ const CONNECT_TOOL = {
   },
 }
 
-type Connected = { service: string; state: string; detail: string }
+type Connected = { service: string; state: string; detail: string; dir?: string }
 
 async function connectServices($: EngineInterface, input: { service?: string; connection_string?: string; project_ref?: string }) {
   const cwd = await $.session.cwd()
@@ -528,7 +596,7 @@ export const register: Register = (on, options) => {
   on('prompt.submit', async ($, e, next) => {
     if (e.command || e.isMeta || (e.origin.kind !== 'composer' && e.origin.kind !== 'bridge')) return next(e)
     const startedAt = await $.clock.now()
-    await update($, turns, (l) => [...(l ?? []), newTurn(startedAt)].slice(-KEEP_TURNS))
+    await update($, turns, (l) => [...(l ?? []), newTurn(startedAt, e.text)].slice(-KEEP_TURNS))
     const pending = await read($, note)
     if (!pending) return next(e)
     await update($, note, () => null)
@@ -554,7 +622,9 @@ export const register: Register = (on, options) => {
           .run(backstep(['snap', '--session', sid, '--tool', tool, '--cwd', cwd, '--', path]))
           .catch(() => null)
         if (snap?.exitCode === 0) {
-          await bump($, t.id, (x) => ({ ...x, edits: x.edits + 1, files: x.files.includes(path) ? x.files : [...x.files, path] }))
+          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`))
         }
       }
     } else if (tool === 'Bash') {
@@ -562,6 +632,15 @@ export const register: Register = (on, options) => {
       const t = await current($)
       const cwd = await $.session.cwd()
       const sid = await $.session.id()
+      // About to change a Supabase project Backstep isn't connected to: ask now,
+      // so it can be saved before the command runs.
+      const checked = await $.process.run(backstep(['db-check', '--cwd', cwd, '--', command])).catch(() => null)
+      try {
+        const ask = (JSON.parse(checked?.stdout || '{}') as { ask?: string | null }).ask
+        if (ask) await askSupabase($, ask)
+      } catch {
+        // can't tell: run it as before
+      }
       // Never blocks the command: if Backstep can't be reached it just won't be undoable.
       const ran = await $.process
         // A database command copies the database first, which takes longer on a big one.
@@ -575,9 +654,15 @@ export const register: Register = (on, options) => {
       }
       if (plan?.kind === 'outbound') {
         // What it changed here comes back with the project snapshot; what it sent out doesn't (a push is offered back after undo).
-        await bump($, t.id, (x) => ({ ...x, shell: (x.shell ?? 0) + (plan.undoable ? 1 : 0), lost: (x.lost ?? 0) + 1 }))
+        const git = onlySavesToGit(command)
+        await bump($, t.id, (x) =>
+          lostOne({ ...x, gitOnly: x.gitOnly !== false && git, shell: (x.shell ?? 0) + (plan.undoable ? 1 : 0) }, `${brief(command)}: ${plan.reason ?? 'it reached outside this computer'}`),
+        )
       } else if (plan?.kind === 'write') {
-        await bump($, t.id, (x) => (plan.undoable ? { ...x, shell: (x.shell ?? 0) + 1 } : { ...x, lost: (x.lost ?? 0) + 1 }))
+        const git = onlySavesToGit(command)
+        await bump($, t.id, (x) =>
+          plan.undoable ? { ...x, gitOnly: x.gitOnly !== false && git, shell: (x.shell ?? 0) + 1 } : lostOne({ ...x, gitOnly: false }, `${brief(command)}: ${plan.reason ?? "Backstep couldn't save a copy first"}`),
+        )
       }
       // A push: once it's run, note what it sent, so undo can offer to take it back there.
       if (plan?.id && PUSH.test(command)) {
@@ -611,33 +696,63 @@ export const register: Register = (on, options) => {
     if (r) {
       const tone = r.phase === 'failed' ? 'error' : r.phase === 'empty' ? 'warning' : undefined
       const glyph = r.phase === 'failed' ? '✗' : r.phase === 'empty' ? '!' : '✓'
-      const visible = r.items.slice(0, Math.min(r.shown, 6))
-      const more = r.items.length - 6
+      // What came back (the first few; the conversation has them all), then everything that didn't.
+      const shown = r.items.slice(0, r.shown)
+      const back = shown.filter((i) => i.ok)
+      const kept = shown.filter((i) => !i.ok)
+      const more = r.items.filter((i) => i.ok).length - 5
       return (
         <Box flexDirection="column">
           <Text color={tone} bold>
             {glyph} {r.message}
           </Text>
-          {visible.map((i, n) => (
-            <Text key={`i${n}`} color={i.ok ? undefined : 'error'} dimColor={i.ok}>
-              {'  '}
-              {i.ok ? '◀ ' : '✗ '}
+          {back.slice(0, 5).map((i, n) => (
+            <Text key={`b${n}`} dimColor>
+              {'  ◀ '}
+              {i.label}
+            </Text>
+          ))}
+          {back.length >= 5 && more > 0 ? <Text dimColor>{`  and ${more} more (all listed in the conversation)`}</Text> : null}
+          {kept.length ? <Text bold>{'  Not undone:'}</Text> : null}
+          {kept.slice(0, 6).map((i, n) => (
+            <Text key={`k${n}`} color="error">
+              {'  ✗ '}
               {i.label}
             </Text>
           ))}
-          {r.shown >= 6 && more > 0 ? <Text dimColor>{`  and ${more} more`}</Text> : null}
         </Box>
       )
     }
 
-    const target = (await read($, turns)).findLast(hasWork)
+    const { target, before } = await undoTargets($)
     const label = (await read($, keys)).map(keyLabel).join(' / ')
     if (target && (await read($, armed)) !== null) {
+      // The last turn only committed and pushed: the work it saved is what the person most likely wants back.
+      if (before) {
+        return (
+          <Box>
+            <Text bold>◀</Text>
+            <Text color={PINK} bold>◀</Text>
+            <Text color="warning" bold> That turn only saved and pushed to git. </Text>
+            <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
+              {`${label} again to undo it and the turn before${named(before)}`}
+            </Button>
+            <Text dimColor>  ·  </Text>
+            <Button key="just" plain dimColor onPress={() => void update($, armed, () => null).then(() => undoLastTurn($, 1))}>
+              just the push
+            </Button>
+            <Text dimColor>  ·  </Text>
+            <Button key="cancel" plain dimColor onPress={() => void update($, armed, () => null)}>
+              cancel
+            </Button>
+          </Box>
+        )
+      }
       return (
         <Box>
           <Text bold>◀</Text>
           <Text color={PINK} bold>◀</Text>
-          <Text color="warning" bold> Undo Claude's last turn? </Text>
+          <Text color="warning" bold>{` Undo Claude's last turn${named(target)}? `}</Text>
           <Text dimColor>{summary(target)}  </Text>
           <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
             {`${label} again to undo`}
@@ -658,7 +773,7 @@ export const register: Register = (on, options) => {
         <Text bold>◀</Text>
         <Text color={PINK} bold>◀</Text>
         <Text> </Text>
-        <Text dimColor>{target ? `Last turn: ${summary(target)}  ` : 'Backstep is on · nothing to undo yet  '}</Text>
+        <Text dimColor>{target ? `Last turn${named(target)}: ${summary(target)}  ` : 'Backstep is on · nothing to undo yet  '}</Text>
         <Button key="undo" action={UNDO_ACTION} plain dimColor onPress={() => void pressUndo($)}>
           {`${label} to undo`}
         </Button>

package/mod/types/index.d.ts

@@ -10,6 +10,12 @@ export type Turn = {
   // Shell commands and tool calls whose effects can't be taken back: they reached outside the machine with no undo rule, or the project was too big to snapshot.
   lost: number
   undone: boolean
+  // What the person asked for, so undo can name the turn it would take back.
+  prompt?: string
+  // Every change was a git commit or push (saving the turn before's work), so undo offers to take both.
+  gitOnly?: boolean
+  // What in this turn can't be undone, and why, so undo can say so by name.
+  lostItems?: string[]
 }
 
 export type RewindItem = { label: string; ok: boolean }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "scripts": {
     "dev": "node src/cli.ts",