@rewind-ai/cli 0.6.2

package/dist/src/cli.js

@@ -0,0 +1,823 @@
+#!/usr/bin/env node
+import { loadRewindEnv } from "./commercial/env.js";
+loadRewindEnv();
+import { createSandbox } from "./sandbox.js";
+import { createCheckpoint, loadCheckpoint } from "./checkpoint.js";
+import { destroySandbox } from "./destroy.js";
+import { recordDiffTransaction, printTransactionSummary } from "./diff.js";
+import { restoreSandbox } from "./restore.js";
+import { verifyLatest, printVerification } from "./verify.js";
+import { buildManifest } from "./manifest.js";
+import { getProjectRoot, getSandboxPath, PathSafetyError, } from "./paths.js";
+import { formatMs } from "./timing.js";
+import { startSession, stopSession, sessionStatus, rewindSession, showSessionReport, printProcessProbe, demoV1, } from "./session/index.js";
+import { runMcpServer, printActionCli, printMcpSessionReport, } from "./mcp/server.js";
+import { undoAction, formatUndoConflict } from "./action/undo.js";
+import { markIncompleteFailed } from "./action/store.js";
+import { enableEnforcement, disableEnforcement, loadEnforcementState, runUnderWriteDenySeatbelt, writeSeatbeltProfile, } from "./enforcement/setup.js";
+import { probeDirectWriteBlocked, unlockEnforcedWritable, } from "./enforcement/readonly.js";
+import { listPolicyEvents } from "./enforcement/policy.js";
+import { listTrustRecords } from "./enforcement/trust.js";
+import { measureMs, formatPerfTable } from "./enforcement/perf.js";
+import { defaultMediateContext, mediateWriteFile, } from "./action/mediate.js";
+import { ENFORCED_SANDBOX_DIR_NAME, getEnforcedSandboxPath } from "./paths.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { protectProject, unprotectProject, resolveProtectTarget, formatProtectStatus, formatSessionsList, formatActionsList, undoProtectAction, undoProtectedSession, loadProtectState, } from "./protect/index.js";
+import { cliStatus, cliTransactions, cliTransaction, cliUndo, cliApprovals, cliApprove, cliDeny, cliPolicy, cliPolicyInit, } from "./cli/v5.js";
+import { startLocalApiServer } from "./api/server.js";
+import { PRODUCT_VERSION, runSetup, runDoctor, runUninstall, versionText, } from "./product/setup.js";
+import { getAuthProvider, loadSession } from "./commercial/auth/provider.js";
+import { createCheckoutSession, confirmSimulatedCheckout, LOCAL_API_DEFAULT_PORT, } from "./commercial/stripe/checkout.js";
+import { issueEntitlementForCurrentUser, SignedEntitlementProvider, } from "./commercial/entitlement/provider.js";
+import { setEntitlementProvider } from "./entitlement/provider.js";
+import { execFile } from "node:child_process";
+function printUsage() {
+    console.log(`REWIND ${PRODUCT_VERSION} — Undo for AI agents (REWIND Personal)
+
+Setup:    setup | doctor | open | uninstall | version | update
+Account:  login | logout | subscribe | whoami
+Product:  status | transactions | transaction <id> | undo <id>
+          approvals | approve <id> | deny <id> | policy
+Service:  api | mcp
+Legacy:   protect | enforce | session | sandbox:create | …
+
+Honesty: REWIND CONNECTED means mediated actions are recorded.
+Native agent writes outside REWIND are not authoritative transactions.
+`);
+}
+async function cmdSandboxCreate() {
+    const result = await createSandbox();
+    console.log("REWIND");
+    console.log("");
+    console.log("Disposable sandbox created.");
+    console.log(`Root: ${result.root}`);
+    console.log(`Files:       ${result.fileCount}`);
+    console.log(`Directories: ${result.directoryCount}`);
+    console.log(`Symlinks:    ${result.symlinkCount}`);
+    console.log(`Total entries: ${result.totalEntries}`);
+}
+async function cmdCheckpoint() {
+    const cp = await createCheckpoint();
+    console.log("REWIND");
+    console.log("");
+    console.log("Checkpoint created.");
+    console.log(`ID:          ${cp.meta.id}`);
+    console.log(`Fingerprint: ${cp.meta.fingerprint}`);
+    console.log(`Files:       ${cp.meta.fileCount}`);
+    console.log(`Directories: ${cp.meta.directoryCount}`);
+    console.log(`Symlinks:    ${cp.meta.symlinkCount}`);
+    console.log(`Timings: manifest ${formatMs(cp.meta.timingsMs.manifest)}, store ${formatMs(cp.meta.timingsMs.contentStore)}, total ${formatMs(cp.meta.timingsMs.total)}`);
+}
+async function cmdDestroy() {
+    const result = await destroySandbox();
+    console.log("");
+    console.log("Chaos complete.");
+    console.log(`Modified:    ${result.modified}`);
+    console.log(`Deleted:     ${result.deleted}`);
+    console.log(`Created:     ${result.created}`);
+    console.log(`Renamed:     ${result.renamed}`);
+    console.log(`Moved:       ${result.moved}`);
+    console.log(`Chmod:       ${result.permissionChanges}`);
+    console.log(`Actions:     ${result.totalActions}`);
+    console.log(`Time:        ${formatMs(result.timingsMs)}`);
+}
+async function cmdDiff() {
+    const projectRoot = getProjectRoot();
+    const sandbox = getSandboxPath(projectRoot);
+    const cp = await loadCheckpoint("latest", projectRoot);
+    const current = await buildManifest(sandbox, "sandbox-test-project");
+    const tx = await recordDiffTransaction(cp.manifest, current, cp.meta.id, sandbox, projectRoot);
+    printTransactionSummary(tx);
+    console.log("");
+    console.log(`Transaction ID: ${tx.id}`);
+    console.log(`Diff time: ${formatMs(tx.timingsMs.diff)}`);
+    console.log("");
+    console.log("Sample changes:");
+    for (const c of tx.changes.slice(0, 25)) {
+        const from = c.pathBefore ?? "—";
+        const to = c.pathAfter ?? "—";
+        if (c.type === "RENAMED" || c.type === "MOVED") {
+            console.log(`  ${c.type.padEnd(8)} ${from} → ${to}`);
+        }
+        else if (c.type === "DELETED") {
+            console.log(`  ${c.type.padEnd(8)} ${from}`);
+        }
+        else if (c.type === "CREATED") {
+            console.log(`  ${c.type.padEnd(8)} ${to}`);
+        }
+        else {
+            console.log(`  ${c.type.padEnd(8)} ${from}`);
+        }
+    }
+    if (tx.changes.length > 25) {
+        console.log(`  … ${tx.changes.length - 25} more`);
+    }
+}
+async function cmdRewind() {
+    console.log("REWINDING…");
+    console.log("");
+    console.log("Restoring files…");
+    console.log("Removing created files…");
+    console.log("Recreating deleted files…");
+    console.log("Restoring modified files…");
+    console.log("");
+    const result = await restoreSandbox("latest");
+    console.log(`Restored from checkpoint: ${result.checkpoint.meta.id}`);
+    console.log(`Timings: clear ${formatMs(result.timingsMs.clear)}, materialize ${formatMs(result.timingsMs.materialize)}, verify ${formatMs(result.timingsMs.verify)}, total ${formatMs(result.timingsMs.total)}`);
+    console.log("");
+    printVerification(result.verification);
+}
+async function cmdVerify() {
+    const result = await verifyLatest();
+    printVerification(result);
+    if (!result.ok)
+        process.exitCode = 1;
+}
+async function cmdDemo() {
+    const line = "⸻";
+    console.log(line);
+    console.log("");
+    console.log("REWIND V0");
+    console.log("");
+    console.log("Creating disposable project…");
+    const sandbox = await createSandbox();
+    console.log("");
+    console.log(`${sandbox.fileCount} files created.`);
+    console.log("");
+    console.log("Creating checkpoint…");
+    const cp = await createCheckpoint();
+    console.log("");
+    console.log("Checkpoint:");
+    console.log(cp.meta.id);
+    console.log("");
+    console.log("Project fingerprint:");
+    console.log(cp.meta.fingerprint);
+    console.log("");
+    console.log(`(checkpoint ${formatMs(cp.meta.timingsMs.total)} — manifest ${formatMs(cp.meta.timingsMs.manifest)}, store ${formatMs(cp.meta.timingsMs.contentStore)})`);
+    console.log("");
+    console.log("DESTROYING PROJECT…");
+    console.log("");
+    const destroyed = await destroySandbox();
+    const afterManifest = await buildManifest(getSandboxPath(), "sandbox-test-project");
+    const tx = await recordDiffTransaction(cp.manifest, afterManifest, cp.meta.id, getSandboxPath());
+    console.log("");
+    console.log(`${tx.summary.total} filesystem changes performed.`);
+    console.log("");
+    console.log("Current fingerprint:");
+    console.log(afterManifest.fingerprint);
+    console.log("");
+    console.log("Project no longer matches checkpoint.");
+    console.log(`(destroy ${formatMs(destroyed.timingsMs)}, diff ${formatMs(tx.timingsMs.diff)})`);
+    console.log("");
+    console.log("REWINDING…");
+    console.log("");
+    console.log("Restoring files…");
+    console.log("Removing created files…");
+    console.log("Recreating deleted files…");
+    console.log("Restoring modified files…");
+    console.log("");
+    const restored = await restoreSandbox("latest");
+    console.log(`(rewind ${formatMs(restored.timingsMs.total)})`);
+    console.log("");
+    console.log("VERIFYING…");
+    console.log("");
+    console.log("Original:");
+    console.log(cp.meta.fingerprint);
+    console.log("");
+    console.log("Restored:");
+    console.log(restored.verification.actualFingerprint);
+    console.log("");
+    if (restored.verification.ok) {
+        console.log("✓ EXACT MATCH");
+        console.log("");
+        console.log("REWIND SUCCESSFUL");
+    }
+    else {
+        console.log("✗ RESTORE FAILED");
+        printVerification(restored.verification);
+        process.exitCode = 1;
+    }
+    console.log("");
+    console.log(line);
+}
+async function cmdCycles(count) {
+    console.log(`REWIND CYCLE TEST — ${count} iterations`);
+    console.log("");
+    await createSandbox();
+    const cp = await createCheckpoint();
+    const original = cp.meta.fingerprint;
+    console.log(`Baseline fingerprint: ${original}`);
+    console.log("");
+    for (let i = 1; i <= count; i++) {
+        await destroySandbox();
+        const result = await restoreSandbox(cp.meta.id);
+        const fp = result.verification.actualFingerprint;
+        const ok = result.verification.ok && fp === original;
+        console.log(`Cycle ${String(i).padStart(2, "0")}/${count}: ${ok ? "PASS" : "FAIL"}  fp=${fp.slice(0, 12)}…  (${formatMs(result.timingsMs.total)})`);
+        if (!ok) {
+            printVerification(result.verification);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    console.log("");
+    console.log(`All ${count} cycles passed. Fingerprint stable: ${original}`);
+}
+async function dispatchSession(args) {
+    const sub = args[0];
+    switch (sub) {
+        case "start":
+            await startSession({
+                recreateSandbox: args.includes("--recreate"),
+            });
+            break;
+        case "stop":
+            await stopSession();
+            break;
+        case "status":
+            await sessionStatus();
+            break;
+        case "report":
+            await showSessionReport("latest");
+            break;
+        case "rewind":
+            await rewindSession("latest");
+            break;
+        case "probe":
+            await printProcessProbe();
+            break;
+        default:
+            console.error(`Unknown session subcommand: ${sub ?? "(none)"}`);
+            printUsage();
+            process.exitCode = 1;
+    }
+}
+async function dispatchEnforce(args) {
+    const sub = args[0];
+    const projectRoot = getProjectRoot();
+    switch (sub) {
+        case "enable": {
+            const mechanismArg = args.find((a) => a.startsWith("--mechanism="));
+            const mechanism = (mechanismArg?.split("=")[1] ??
+                "combined");
+            const state = await enableEnforcement(projectRoot, { mechanism });
+            console.log("REWIND V3 ENFORCEMENT ENABLED");
+            console.log(`Sandbox: ${state.sandboxName}`);
+            console.log(`Mechanism: ${state.mechanism}`);
+            console.log(`FS locked: ${state.locked ? "YES" : "NO"}`);
+            console.log(`Seatbelt profile: ${state.seatbeltProfilePath ?? "—"}`);
+            console.log(`Hooks: .cursor/hooks.json (Cursor tool-loop)`);
+            console.log("");
+            console.log("Human editor writes are NOT blocked by Cursor hooks — only agent tools.");
+            break;
+        }
+        case "disable": {
+            await disableEnforcement(projectRoot, {
+                removeTree: args.includes("--remove"),
+            });
+            console.log("REWIND V3 ENFORCEMENT DISABLED");
+            if (args.includes("--remove")) {
+                console.log("sandbox-enforced-project removed.");
+            }
+            break;
+        }
+        case "status": {
+            const state = await loadEnforcementState(projectRoot);
+            console.log("REWIND V3 ENFORCEMENT STATUS");
+            console.log(JSON.stringify(state, null, 2));
+            break;
+        }
+        case "probe": {
+            const state = await loadEnforcementState(projectRoot);
+            if (!state?.enabled) {
+                console.log("Enforcement not enabled. Run: rewind enforce enable");
+                process.exitCode = 1;
+                return;
+            }
+            const direct = await probeDirectWriteBlocked(projectRoot);
+            console.log("TEST A — direct write (fs-readonly)");
+            console.log(direct.blocked
+                ? `BLOCKED ✓  (${direct.error})`
+                : "NOT BLOCKED ✗ — V3 fs-readonly failed");
+            let profile = state.seatbeltProfilePath;
+            if (!profile)
+                profile = await writeSeatbeltProfile(projectRoot);
+            const target = path.join(getEnforcedSandboxPath(projectRoot), "shell-bypass.txt");
+            const seatbelt = await runUnderWriteDenySeatbelt("/bin/bash", ["-c", `echo bypass > '${target}'`], profile);
+            console.log("");
+            console.log("TEST B — shell under sandbox-exec wrapper");
+            console.log(seatbelt.code !== 0
+                ? `BLOCKED ✓  exit=${seatbelt.code} ${seatbelt.stderr.trim() || seatbelt.stdout.trim()}`
+                : "NOT BLOCKED ✗ — seatbelt wrapper failed");
+            // Unrestricted shell (same UID) may still succeed if tree unlocked —
+            // with fs-readonly lock it should fail without chmod.
+            console.log("");
+            console.log("NOTE: Unrestricted same-UID shell without seatbelt:");
+            try {
+                const { writeFile } = await import("node:fs/promises");
+                await writeFile(target, "unrestricted");
+                console.log("SUCCEEDED — tree writable to owner (lock may be off, or chmod bypass).");
+                await unlockEnforcedWritable(projectRoot).catch(() => undefined);
+            }
+            catch (err) {
+                console.log(`BLOCKED ✓  (${err instanceof Error ? err.message : String(err)})`);
+            }
+            break;
+        }
+        case "perf": {
+            await enableEnforcement(projectRoot, { mechanism: "combined" });
+            const samples = [];
+            const readPath = path.join(getEnforcedSandboxPath(projectRoot), "src/index.ts");
+            {
+                const { sample } = await measureMs("read_enforced_file", async () => readFile(readPath));
+                samples.push(sample);
+            }
+            {
+                const { sample } = await measureMs("mediated_write", async () => {
+                    const ctx = defaultMediateContext(projectRoot, { name: "perf", version: "0" }, ENFORCED_SANDBOX_DIR_NAME);
+                    return mediateWriteFile(ctx, {
+                        path: "perf-mediated.txt",
+                        content: `perf ${Date.now()}`,
+                    });
+                });
+                samples.push(sample);
+            }
+            {
+                const { sample } = await measureMs("probe_blocked_write", async () => probeDirectWriteBlocked(projectRoot));
+                samples.push(sample);
+            }
+            console.log(formatPerfTable(samples));
+            break;
+        }
+        default:
+            console.error(`Unknown enforce subcommand: ${sub ?? "(none)"}`);
+            printUsage();
+            process.exitCode = 1;
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const cmd = args[0];
+    try {
+        switch (cmd) {
+            case "sandbox:create":
+                await cmdSandboxCreate();
+                break;
+            case "checkpoint":
+                await cmdCheckpoint();
+                break;
+            case "destroy":
+                await cmdDestroy();
+                break;
+            case "diff":
+                await cmdDiff();
+                break;
+            case "rewind":
+                await cmdRewind();
+                break;
+            case "verify":
+                await cmdVerify();
+                break;
+            case "demo":
+                await cmdDemo();
+                break;
+            case "demo:v1":
+                await demoV1();
+                break;
+            case "session":
+                await dispatchSession(args.slice(1));
+                break;
+            case "session:start":
+                await startSession({
+                    recreateSandbox: args.includes("--recreate"),
+                });
+                break;
+            case "session:stop":
+                await stopSession();
+                break;
+            case "session:status":
+                await sessionStatus();
+                break;
+            case "session:report":
+                await showSessionReport("latest");
+                break;
+            case "session:rewind":
+                await rewindSession("latest");
+                break;
+            case "session:probe":
+                await printProcessProbe();
+                break;
+            case "mcp":
+                await runMcpServer();
+                break;
+            case "setup": {
+                console.log(await runSetup(getProjectRoot()));
+                break;
+            }
+            case "doctor": {
+                const { text, checks } = await runDoctor(getProjectRoot());
+                console.log(text);
+                if (checks.some((c) => c.status === "FAIL"))
+                    process.exitCode = 1;
+                break;
+            }
+            case "version":
+            case "--version":
+            case "-V": {
+                console.log(versionText());
+                break;
+            }
+            case "update": {
+                console.log("REWIND UPDATE");
+                console.log("");
+                console.log(`Current version: ${PRODUCT_VERSION}`);
+                console.log("");
+                console.log("Packaging channels (when published):");
+                console.log("  npm:      npm update -g @rewind-ai/cli");
+                console.log("  Homebrew: brew upgrade rewind   # after tap exists");
+                console.log("");
+                console.log("Updates never delete .rewind transaction history or CAS objects.");
+                console.log("See docs/PACKAGING.md for release status.");
+                break;
+            }
+            case "uninstall": {
+                const deleteData = args.includes("--delete-recovery-data");
+                if (deleteData && !args.includes("--yes")) {
+                    console.error("Refusing to delete recovery data without --yes.\n" +
+                        "Usage: rewind uninstall --delete-recovery-data --yes");
+                    process.exitCode = 2;
+                    break;
+                }
+                console.log(await runUninstall({
+                    deleteRecoveryData: deleteData,
+                    removeMcp: !args.includes("--keep-mcp"),
+                    projectRoot: getProjectRoot(),
+                }));
+                break;
+            }
+            case "login": {
+                const emailIdx = args.indexOf("--email");
+                const email = emailIdx >= 0 ? args[emailIdx + 1] : undefined;
+                const provider = getAuthProvider();
+                const session = await provider.login(email ? { email, openBrowser: false } : { openBrowser: true });
+                setEntitlementProvider(new SignedEntitlementProvider());
+                await issueEntitlementForCurrentUser().catch(() => undefined);
+                console.log("REWIND");
+                console.log("");
+                console.log(`✓ Signed in as ${session.email}`);
+                console.log(`  Installation ${session.installationId}`);
+                break;
+            }
+            case "logout": {
+                await getAuthProvider().logout();
+                console.log("Signed out.");
+                break;
+            }
+            case "whoami": {
+                const session = await loadSession();
+                if (!session) {
+                    console.log("Not signed in. Run: rewind login");
+                    process.exitCode = 1;
+                }
+                else {
+                    console.log(`${session.email} (${session.provider})`);
+                    console.log(`user=${session.userId} install=${session.installationId}`);
+                }
+                break;
+            }
+            case "subscribe": {
+                const session = await loadSession();
+                if (!session) {
+                    console.error("Sign in first: rewind login");
+                    process.exitCode = 1;
+                    break;
+                }
+                const checkout = await createCheckoutSession({
+                    userId: session.userId,
+                    email: session.email,
+                    successUrl: `http://127.0.0.1:${LOCAL_API_DEFAULT_PORT}/subscribed`,
+                    cancelUrl: `http://127.0.0.1:${LOCAL_API_DEFAULT_PORT}/canceled`,
+                });
+                console.log("REWIND PERSONAL — £2.99/month");
+                console.log("");
+                if (checkout.mode === "test-simulated") {
+                    console.log("SIMULATED DEVELOPMENT MODE");
+                    console.log("");
+                    console.log(checkout.message);
+                    await confirmSimulatedCheckout(session.userId, checkout.sessionId);
+                    setEntitlementProvider(new SignedEntitlementProvider());
+                    await issueEntitlementForCurrentUser();
+                    console.log("");
+                    console.log("✓ Simulated subscription activated (not Stripe).");
+                    console.log("  Entitlement refreshed.");
+                }
+                else {
+                    console.log("STRIPE TEST MODE");
+                    console.log("");
+                    console.log(checkout.message);
+                    console.log("");
+                    console.log("Personal is NOT activated locally yet — wait for the signed Stripe webhook.");
+                    console.log(`Webhook: POST http://127.0.0.1:${LOCAL_API_DEFAULT_PORT}/v1/commercial/stripe/webhook`);
+                    console.log("Keep `rewind api` (or `rewind open`) running and forward with Stripe CLI.");
+                    if (checkout.url) {
+                        console.log("");
+                        console.log(`Checkout URL: ${checkout.url}`);
+                        execFile(process.platform === "darwin" ? "open" : "xdg-open", [checkout.url], () => undefined);
+                    }
+                }
+                break;
+            }
+            case "open": {
+                const handle = await startLocalApiServer({
+                    projectRoot: getProjectRoot(),
+                    port: 7429,
+                    listen: false,
+                });
+                console.log("");
+                console.log("Opening control app…");
+                execFile(process.platform === "darwin" ? "open" : "xdg-open", [handle.url], () => undefined);
+                // Keep process alive for the UI
+                await new Promise(() => {
+                    /* until killed */
+                });
+                break;
+            }
+            case "protect": {
+                const { summary } = await protectProject(args[1]);
+                console.log(summary);
+                break;
+            }
+            case "unprotect": {
+                const msg = await unprotectProject(args[1]);
+                console.log(msg);
+                break;
+            }
+            case "status": {
+                // V5 product status; append protect summary when a protected project is given
+                console.log(await cliStatus(getProjectRoot()));
+                if (args[1]) {
+                    const root = resolveProtectTarget(args[1]);
+                    console.log("");
+                    console.log(await formatProtectStatus(root));
+                }
+                else {
+                    const root = resolveProtectTarget(undefined);
+                    const state = await loadProtectState(root);
+                    if (state?.protected) {
+                        console.log("");
+                        console.log(await formatProtectStatus(root));
+                    }
+                }
+                break;
+            }
+            case "transactions": {
+                const limitIdx = args.indexOf("--limit");
+                const limit = limitIdx >= 0 && args[limitIdx + 1]
+                    ? Number(args[limitIdx + 1])
+                    : undefined;
+                console.log(await cliTransactions(getProjectRoot(), limit));
+                break;
+            }
+            case "transaction": {
+                const id = args[1];
+                if (!id)
+                    throw new Error("Usage: transaction <id>");
+                console.log(await cliTransaction(id, getProjectRoot()));
+                break;
+            }
+            case "approvals": {
+                console.log(await cliApprovals(getProjectRoot()));
+                break;
+            }
+            case "approve": {
+                const id = args[1];
+                if (!id)
+                    throw new Error("Usage: approve <approvalId>");
+                console.log(await cliApprove(id, getProjectRoot()));
+                break;
+            }
+            case "deny": {
+                const id = args[1];
+                if (!id)
+                    throw new Error("Usage: deny <approvalId>");
+                console.log(await cliDeny(id, getProjectRoot()));
+                break;
+            }
+            case "api": {
+                const portArg = args.indexOf("--port");
+                const port = portArg >= 0 && args[portArg + 1]
+                    ? Number(args[portArg + 1])
+                    : 7429;
+                await startLocalApiServer({
+                    projectRoot: getProjectRoot(),
+                    port: Number.isFinite(port) ? port : 7429,
+                });
+                break;
+            }
+            case "sessions": {
+                const root = resolveProtectTarget(args[1]);
+                console.log(await formatSessionsList(root));
+                break;
+            }
+            case "actions": {
+                // V4 protect actions when project is protected; else V2 MCP actions
+                const root = resolveProtectTarget(args[1]?.startsWith("rw_") || args[1]?.startsWith("act_") ? undefined : args[1]);
+                const state = await loadProtectState(root);
+                if (state?.protected || args.includes("--protect")) {
+                    const sessionFilter = args.find((a) => a.startsWith("rw_"));
+                    console.log(await formatActionsList(root, sessionFilter));
+                }
+                else {
+                    await printActionCli(args[1]);
+                }
+                break;
+            }
+            case "undo": {
+                const id = args[1];
+                if (!id)
+                    throw new Error("Usage: undo <id>");
+                // Protect-session actions (non act_/txn_) use V4 undo when protected
+                const root = resolveProtectTarget(args[2]);
+                const state = await loadProtectState(root);
+                if (state?.protected &&
+                    !id.startsWith("act_") &&
+                    !id.startsWith("txn_")) {
+                    try {
+                        const result = await undoProtectAction(id, root);
+                        if (result.conflict) {
+                            console.log(result.message);
+                            process.exitCode = 3;
+                        }
+                        else if (!result.ok) {
+                            console.log(result.message);
+                            process.exitCode = 1;
+                        }
+                        else {
+                            console.log(result.message);
+                            console.log(`Status: ${result.action.status}`);
+                        }
+                        break;
+                    }
+                    catch {
+                        /* fall through */
+                    }
+                }
+                const v5 = await cliUndo(id, getProjectRoot());
+                console.log(v5.text);
+                process.exitCode = v5.exitCode;
+                break;
+            }
+            case "undo-session": {
+                const id = args[1];
+                if (!id)
+                    throw new Error("Usage: undo-session <sessionId>");
+                const root = resolveProtectTarget(args[2]);
+                const result = await undoProtectedSession(id, root);
+                console.log(result.message);
+                if (result.conflicts.length > 0)
+                    process.exitCode = 3;
+                else if (result.failed > 0)
+                    process.exitCode = 1;
+                break;
+            }
+            case "mcp:actions":
+                await printActionCli(args[1]);
+                break;
+            case "mcp:undo": {
+                const id = args[1];
+                if (!id)
+                    throw new Error("Usage: mcp:undo <actionId>");
+                const result = await undoAction(id, getProjectRoot());
+                if (result.conflict) {
+                    console.log(formatUndoConflict(result));
+                    process.exitCode = 3;
+                }
+                else if (!result.ok) {
+                    console.log(result.message);
+                    process.exitCode = 1;
+                }
+                else {
+                    console.log(result.message);
+                    console.log(`Status: ${result.action.status}`);
+                }
+                break;
+            }
+            case "mcp:sessions":
+                await printMcpSessionReport();
+                break;
+            case "mcp:recover": {
+                const n = await markIncompleteFailed();
+                console.log(`Marked ${n} incomplete action(s) as FAILED`);
+                break;
+            }
+            case "enforce":
+                await dispatchEnforce(args.slice(1));
+                break;
+            case "policy": {
+                const sub = args[1];
+                if (sub === "init") {
+                    console.log(await cliPolicyInit(getProjectRoot()));
+                    break;
+                }
+                if (sub === "events") {
+                    const events = await listPolicyEvents();
+                    console.log("REWIND POLICY EVENTS (V3 enforcement)");
+                    for (const e of events) {
+                        console.log(`${e.time} ${e.id} ${e.status} ${e.type} ${e.path ?? "—"}`);
+                    }
+                    console.log(`Total: ${events.length}`);
+                    break;
+                }
+                if (sub === "set") {
+                    // policy set <id> <ALLOW|ASK|DENY> [--op write] [--resource 'src/**'] [--enable]
+                    const id = args[2];
+                    const effect = args[3];
+                    if (!id || !effect || !["ALLOW", "ASK", "DENY"].includes(effect)) {
+                        throw new Error("Usage: policy set <id> <ALLOW|ASK|DENY> [--op op] [--resource glob] [--adapter filesystem] [--enable|--disable]");
+                    }
+                    const opIdx = args.indexOf("--op");
+                    const resIdx = args.indexOf("--resource");
+                    const adIdx = args.indexOf("--adapter");
+                    const rule = {
+                        id,
+                        priority: 100,
+                        effect,
+                        reason: `cli policy set ${id}`,
+                        enabled: !args.includes("--disable"),
+                    };
+                    if (opIdx >= 0 && args[opIdx + 1])
+                        rule.operation = args[opIdx + 1];
+                    if (resIdx >= 0 && args[resIdx + 1]) {
+                        rule.resourcePattern = args[resIdx + 1];
+                    }
+                    if (adIdx >= 0 && args[adIdx + 1]) {
+                        rule.adapter = args[adIdx + 1];
+                    }
+                    else {
+                        rule.adapter = "filesystem";
+                    }
+                    const { cliPolicySetRule } = await import("./cli/v5.js");
+                    console.log(await cliPolicySetRule(rule, getProjectRoot()));
+                    break;
+                }
+                console.log(await cliPolicy(getProjectRoot()));
+                break;
+            }
+            case "policy:events": {
+                const events = await listPolicyEvents();
+                console.log("REWIND POLICY EVENTS (V3 enforcement)");
+                for (const e of events) {
+                    console.log(`${e.time} ${e.id} ${e.status} ${e.type} ${e.path ?? "—"}`);
+                }
+                console.log(`Total: ${events.length}`);
+                break;
+            }
+            case "trust": {
+                const trust = await listTrustRecords();
+                console.log("REWIND TRUST STATE");
+                for (const t of trust) {
+                    console.log(`${t.state} ${t.path}`);
+                }
+                console.log(`Total: ${trust.length}`);
+                break;
+            }
+            case "cycles": {
+                const idx = args.indexOf("--count");
+                const count = idx >= 0 && args[idx + 1] ? Number(args[idx + 1]) : 10;
+                if (!Number.isFinite(count) || count < 1) {
+                    throw new Error("Invalid --count");
+                }
+                await cmdCycles(count);
+                break;
+            }
+            case "help":
+            case "--help":
+            case "-h":
+            case undefined:
+                printUsage();
+                break;
+            default:
+                console.error(`Unknown command: ${cmd}`);
+                printUsage();
+                process.exitCode = 1;
+        }
+    }
+    catch (err) {
+        if (err instanceof PathSafetyError) {
+            console.error("");
+            console.error("REWIND SAFETY REFUSAL");
+            console.error(err.message);
+            console.error("");
+            process.exitCode = 2;
+            return;
+        }
+        console.error("");
+        console.error("REWIND ERROR");
+        console.error(err instanceof Error ? err.message : String(err));
+        console.error("");
+        process.exitCode = 1;
+    }
+}
+await main();
+//# sourceMappingURL=cli.js.map