@goodfolder/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2416 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/credentials.ts
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function accountMeta() {
+  try {
+    return JSON.parse(readFileSync(META_FILE(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveMeta(patch) {
+  mkdirSync(CONFIG_DIR(), { recursive: true });
+  writeFileSync(
+    META_FILE(),
+    JSON.stringify({ ...accountMeta(), ...patch }, null, 2) + "\n",
+    { mode: 384 }
+  );
+}
+function loadAccountToken() {
+  if (cached !== void 0) return cached;
+  const env = process.env.GF_ACCOUNT_TOKEN?.trim();
+  if (env) {
+    cached = env;
+    return env;
+  }
+  if (process.platform === "darwin") {
+    try {
+      const out = execFileSync("security", ["find-generic-password", "-s", SERVICE, "-w"], {
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim();
+      if (out) {
+        cached = out;
+        return out;
+      }
+    } catch {
+    }
+  }
+  try {
+    const raw = readFileSync(TOKEN_FILE(), "utf8").trim();
+    cached = raw || null;
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+function saveAccountToken(token) {
+  let stored = "file";
+  if (process.platform === "darwin") {
+    try {
+      execFileSync(
+        "security",
+        ["add-generic-password", "-U", "-s", SERVICE, "-a", "goodfolder", "-w", token],
+        { stdio: ["ignore", "pipe", "ignore"] }
+      );
+      stored = "keychain";
+    } catch {
+      stored = "file";
+    }
+  }
+  if (stored === "file") {
+    mkdirSync(CONFIG_DIR(), { recursive: true });
+    writeFileSync(TOKEN_FILE(), `${token.trim()}
+`, { mode: 384 });
+  }
+  saveMeta({ savedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  cached = token.trim();
+  return stored;
+}
+function readFolderTokens() {
+  try {
+    const parsed = JSON.parse(readFileSync(FOLDER_TOKENS_FILE(), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeFolderTokens(all) {
+  mkdirSync(CONFIG_DIR(), { recursive: true, mode: 448 });
+  writeFileSync(FOLDER_TOKENS_FILE(), JSON.stringify(all, null, 2) + "\n", { mode: 384 });
+}
+function loadFolderToken(gitDir) {
+  const env = process.env.GF_FOLDER_TOKEN?.trim();
+  if (env) return { token: env };
+  return readFolderTokens()[gitDir] ?? null;
+}
+function saveFolderToken(gitDir, credential) {
+  const all = readFolderTokens();
+  all[gitDir] = credential;
+  writeFolderTokens(all);
+}
+var SERVICE, CONFIG_DIR, TOKEN_FILE, META_FILE, cached, FOLDER_TOKENS_FILE;
+var init_credentials = __esm({
+  "src/credentials.ts"() {
+    "use strict";
+    SERVICE = "goodfolder-account";
+    CONFIG_DIR = () => join(homedir(), ".config", "goodfolder");
+    TOKEN_FILE = () => join(CONFIG_DIR(), "account-token");
+    META_FILE = () => join(CONFIG_DIR(), "account.json");
+    FOLDER_TOKENS_FILE = () => join(CONFIG_DIR(), "folder-tokens.json");
+  }
+});
+
+// src/config.ts
+import { chmodSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function withCredentials(base, token) {
+  const m = /^(https?:\/\/)(.*)$/.exec(base);
+  const scheme = m?.[1];
+  const rest = m?.[2];
+  if (!scheme || !rest) return base;
+  return `${scheme}x:${token}@${rest}`;
+}
+function transportUrl(cfg) {
+  return `${cfg.apiUrl}/git/${cfg.projectId}`;
+}
+function largeFileUrl(cfg) {
+  return `${cfg.apiUrl}/lfs/${cfg.projectId}`;
+}
+function transportEnv(cfg) {
+  return {
+    GIT_CONFIG_COUNT: "4",
+    GIT_CONFIG_KEY_0: `url.${withCredentials(cfg.apiUrl, cfg.token)}/git/${cfg.projectId}.insteadOf`,
+    GIT_CONFIG_VALUE_0: transportUrl(cfg),
+    GIT_CONFIG_KEY_1: "lfs.url",
+    GIT_CONFIG_VALUE_1: `${withCredentials(cfg.apiUrl, cfg.token)}/lfs/${cfg.projectId}`,
+    // The engine offers a credential that worked to the system's password
+    // store afterwards. Ours is renewed on its own and must not pile up there.
+    GIT_CONFIG_KEY_2: "credential.helper",
+    GIT_CONFIG_VALUE_2: "",
+    // Unless told, the large-file helper probes for a locking service the
+    // first time and writes its finding into the folder's settings under the
+    // full address — credential included. Telling it up front keeps that out.
+    GIT_CONFIG_KEY_3: "lfs.locksverify",
+    GIT_CONFIG_VALUE_3: "false",
+    GIT_TERMINAL_PROMPT: "0"
+  };
+}
+function configPath(gitDir) {
+  return join2(gitDir, "goodfolder.json");
+}
+function loadConfig(gitDir) {
+  let stored;
+  try {
+    stored = JSON.parse(readFileSync2(configPath(gitDir), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!stored || typeof stored.projectId !== "string" || typeof stored.apiUrl !== "string") return null;
+  const { token: legacyToken, ...rest } = stored;
+  let credential = loadFolderToken(gitDir);
+  if (!credential && legacyToken) {
+    credential = { token: legacyToken };
+    saveFolderToken(gitDir, credential);
+  }
+  const cfg = { ...rest, token: credential?.token ?? "" };
+  if (credential?.expiresAt) cfg.tokenExpiresAt = credential.expiresAt;
+  if (legacyToken) saveConfig(gitDir, cfg);
+  return cfg;
+}
+function saveConfig(gitDir, cfg) {
+  const { token, tokenExpiresAt, ...written } = cfg;
+  if (token) saveFolderToken(gitDir, tokenExpiresAt ? { token, expiresAt: tokenExpiresAt } : { token });
+  writeFileSync2(configPath(gitDir), JSON.stringify(written, null, 2), { mode: 384 });
+  try {
+    chmodSync(configPath(gitDir), 384);
+  } catch {
+  }
+}
+var configuredApiUrl, DEFAULT_API_URL;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_credentials();
+    configuredApiUrl = process.env.GF_API_URL?.trim().replace(/\/+$/, "");
+    DEFAULT_API_URL = configuredApiUrl || "https://api.trygoodfolder.com";
+  }
+});
+
+// src/git.ts
+import { spawn, spawnSync } from "node:child_process";
+import { closeSync, openSync, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+function tempCapture() {
+  const base = join3(
+    tmpdir(),
+    `gf-git-${process.pid}-${Math.random().toString(36).slice(2)}`
+  );
+  const paths = [`${base}.out`, `${base}.err`];
+  writeFileSync3(paths[0], "");
+  writeFileSync3(paths[1], "");
+  return { fds: [openSync(paths[0], "r+"), openSync(paths[1], "r+")], paths };
+}
+function finishCapture(cap) {
+  for (const fd of cap.fds) {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+  for (const p of cap.paths) {
+    try {
+      unlinkSync(p);
+    } catch {
+    }
+  }
+}
+function git(cwd, args, input, env) {
+  const cap = tempCapture();
+  try {
+    const r = spawnSync("git", args, {
+      cwd,
+      stdio: [input === void 0 ? "ignore" : "pipe", ...cap.fds],
+      ...input === void 0 ? {} : { input },
+      ...env ? { env: { ...process.env, ...env } } : {}
+    });
+    const stdout = readFileSync3(cap.paths[0], "utf8");
+    let stderr = readFileSync3(cap.paths[1], "utf8");
+    if (r.error && !stderr) stderr = String(r.error.message ?? "spawn failed");
+    return { code: r.status ?? 1, stdout, stderr };
+  } finally {
+    finishCapture(cap);
+  }
+}
+function gitOk(cwd, args) {
+  return git(cwd, args).code === 0;
+}
+function findGitDir(folder) {
+  const r = git(folder, ["rev-parse", "--absolute-git-dir"]);
+  return r.code === 0 ? r.stdout.trim() : null;
+}
+function readFileNow(path) {
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function gitAsync(cwd, args) {
+  const cap = tempCapture();
+  return new Promise((resolve3) => {
+    const child = spawn("git", args, { cwd, stdio: ["ignore", ...cap.fds] });
+    child.on("close", (code) => {
+      const result = {
+        code: code ?? 1,
+        stdout: readFileNow(cap.paths[0]),
+        stderr: readFileNow(cap.paths[1])
+      };
+      finishCapture(cap);
+      resolve3(result);
+    });
+    child.on("error", () => {
+      const result = {
+        code: 1,
+        stdout: readFileNow(cap.paths[0]),
+        stderr: readFileNow(cap.paths[1]) || "spawn failed"
+      };
+      finishCapture(cap);
+      resolve3(result);
+    });
+  });
+}
+function gitStream(cwd, args, onProgress, env) {
+  const base = join3(
+    tmpdir(),
+    `gf-git-${process.pid}-${Math.random().toString(36).slice(2)}`
+  );
+  const outPath = `${base}.out`;
+  const errPath = `${base}.err`;
+  writeFileSync3(outPath, "");
+  writeFileSync3(errPath, "");
+  const outFd = openSync(outPath, "r+");
+  const errFd = openSync(errPath, "r+");
+  let errCursor = 0;
+  const child = spawn("git", args, {
+    cwd,
+    stdio: ["ignore", outFd, errFd],
+    ...env ? { env: { ...process.env, ...env } } : {}
+  });
+  const kill = () => child.kill("SIGTERM");
+  const poller = onProgress && process.platform !== "win32" ? setInterval(() => {
+    const text = readFileNow(errPath);
+    if (text.length <= errCursor) return;
+    const fresh = text.slice(errCursor);
+    errCursor = text.length;
+    for (const frag of fresh.split(/[\r\n]/)) {
+      const t = frag.trim();
+      if (t) onProgress(t);
+    }
+  }, 120) : null;
+  const done = new Promise((resolve3) => {
+    child.on("close", (code) => {
+      if (poller) clearInterval(poller);
+      const stderr = readFileNow(errPath);
+      if (poller && onProgress) {
+        const rest = stderr.slice(errCursor);
+        for (const frag of rest.split(/[\r\n]/)) {
+          const t = frag.trim();
+          if (t) onProgress(t);
+        }
+      }
+      const result = {
+        code: code ?? 1,
+        stdout: readFileNow(outPath),
+        stderr,
+        kill
+      };
+      try {
+        closeSync(outFd);
+        closeSync(errFd);
+        unlinkSync(outPath);
+        unlinkSync(errPath);
+      } catch {
+      }
+      resolve3(result);
+    });
+    child.on("error", () => {
+      if (poller) clearInterval(poller);
+      const result = {
+        code: 1,
+        stdout: readFileNow(outPath),
+        stderr: readFileNow(errPath) || "spawn failed",
+        kill
+      };
+      try {
+        closeSync(outFd);
+        closeSync(errFd);
+        unlinkSync(outPath);
+        unlinkSync(errPath);
+      } catch {
+      }
+      resolve3(result);
+    });
+  });
+  return { done, kill };
+}
+var init_git = __esm({
+  "src/git.ts"() {
+    "use strict";
+  }
+});
+
+// src/perf.ts
+async function trace(name, fn) {
+  if (!enabled()) return fn();
+  const t0 = performance.now();
+  try {
+    return await fn();
+  } finally {
+    marks.push([name, Math.round(performance.now() - t0)]);
+  }
+}
+function traceSync(name, fn) {
+  if (!enabled()) return fn();
+  const t0 = performance.now();
+  try {
+    return fn();
+  } finally {
+    marks.push([name, Math.round(performance.now() - t0)]);
+  }
+}
+function renderTrace() {
+  if (!enabled() || marks.length === 0) return "";
+  const parts = marks.map(([n, ms]) => `${n} ${ms}ms`);
+  const total = marks.reduce((a, [, ms]) => a + ms, 0);
+  marks.length = 0;
+  return `\u23F1 ${parts.join(" \xB7 ")} \u2014 total ${total}ms`;
+}
+function snapshotMarks() {
+  return [...marks];
+}
+function configureRepo(folder) {
+  git(folder, ["config", "core.fsmonitor", "true"]);
+  git(folder, ["config", "core.untrackedcache", "true"]);
+  git(folder, ["config", "feature.manyfiles", "true"]);
+  git(folder, ["config", "core.preloadindex", "true"]);
+  git(folder, ["config", "gc.auto", "0"]);
+  git(folder, ["config", "gc.autodetach", "false"]);
+  git(folder, ["config", "status.renames", "false"]);
+  const gitDir = findGitDir(folder);
+  if (!gitDir) return;
+  git(folder, ["fsmonitor--daemon", "start"]);
+}
+var enabled, marks;
+var init_perf = __esm({
+  "src/perf.ts"() {
+    "use strict";
+    init_git();
+    enabled = () => process.env.GOODFOLDER_TRACE === "1";
+    marks = [];
+  }
+});
+
+// ../../packages/shared/src/index.ts
+function extensionOf(path) {
+  const base = path.split("/").pop() ?? path;
+  const idx = base.lastIndexOf(".");
+  return idx > 0 ? base.slice(idx + 1).toLowerCase() : "";
+}
+function routeFile(path, sizeBytes) {
+  if (sizeBytes < ROUTING_FLOOR_BYTES) {
+    return { path, sizeBytes, target: "git", reason: "under-floor" };
+  }
+  if (sizeBytes > ROUTING_CEILING_BYTES) {
+    return { path, sizeBytes, target: "lfs", reason: "over-ceiling" };
+  }
+  const ext = extensionOf(path);
+  if (INCOMPRESSIBLE_EXTENSIONS.has(ext)) {
+    return { path, sizeBytes, target: "lfs", reason: "incompressible-type" };
+  }
+  if (COMPRESSIBLE_EXTENSIONS.has(ext)) {
+    return { path, sizeBytes, target: "git", reason: "compressible-type" };
+  }
+  return { path, sizeBytes, target: "lfs", reason: "unknown-type-size-fallback" };
+}
+function categoryOfPattern(pattern) {
+  return SKIP_RULES.find((r) => r.pattern === pattern)?.category ?? null;
+}
+function findCaseCollisions(paths) {
+  const seen = /* @__PURE__ */ new Map();
+  const collisions = [];
+  for (const p of [...paths].sort()) {
+    const key = p.toLowerCase();
+    const prior = seen.get(key);
+    if (prior !== void 0 && prior !== p) {
+      collisions.push({ a: prior, b: p });
+    } else {
+      seen.set(key, p);
+    }
+  }
+  return collisions;
+}
+function friendlyHarness(name) {
+  if (!name) return null;
+  const n = String(name).toLowerCase();
+  const known = [
+    [/claude/, "Claude Code"],
+    [/codex/, "Codex"],
+    [/cursor/, "Cursor"],
+    [/opencode/, "OpenCode"],
+    [/gemini/, "Gemini CLI"],
+    [/cline/, "Cline"],
+    [/windsurf/, "Windsurf"],
+    [/vscode/, "VS Code"]
+  ];
+  for (const [re, label] of known) if (re.test(n)) return label;
+  const trimmed = String(name).trim().slice(0, 40);
+  return trimmed ? trimmed.charAt(0).toUpperCase() + trimmed.slice(1) : null;
+}
+var ROUTING_FLOOR_BYTES, ROUTING_CEILING_BYTES, INCOMPRESSIBLE_EXTENSIONS, COMPRESSIBLE_EXTENSIONS, SKIP_CATEGORY_LABEL, SKIP_RULES, KEEP_PATTERNS, CREDENTIAL_PATHSPECS, LABEL_EXCERPT_CHAR_BUDGET;
+var init_src = __esm({
+  "../../packages/shared/src/index.ts"() {
+    "use strict";
+    ROUTING_FLOOR_BYTES = 1 * 1024 * 1024;
+    ROUTING_CEILING_BYTES = 100 * 1024 * 1024;
+    INCOMPRESSIBLE_EXTENSIONS = /* @__PURE__ */ new Set([
+      // images
+      "jpg",
+      "jpeg",
+      "png",
+      "gif",
+      "webp",
+      "heic",
+      "heif",
+      "avif",
+      "tif",
+      "tiff",
+      "ico",
+      "bmp",
+      "psd",
+      "ai",
+      "raw",
+      "dng",
+      // audio
+      "mp3",
+      "wav",
+      "aac",
+      "ogg",
+      "flac",
+      "m4a",
+      "aiff",
+      // video
+      "mp4",
+      "mov",
+      "avi",
+      "mkv",
+      "webm",
+      "m4v",
+      "wmv",
+      "prores",
+      "braw",
+      // zip containers
+      "zip",
+      "docx",
+      "xlsx",
+      "pptx",
+      "pdf",
+      "7z",
+      "rar",
+      "jar",
+      "apk",
+      "ipa",
+      "epub",
+      "odt",
+      "ods",
+      "odp",
+      // archives / disk
+      "tar",
+      "gz",
+      "tgz",
+      "bz2",
+      "xz",
+      "zst",
+      "iso",
+      "dmg"
+    ]);
+    COMPRESSIBLE_EXTENSIONS = /* @__PURE__ */ new Set([
+      "txt",
+      "md",
+      "markdown",
+      "csv",
+      "tsv",
+      "json",
+      "jsonl",
+      "ndjson",
+      "yaml",
+      "yml",
+      "xml",
+      "svg",
+      "html",
+      "htm",
+      "css",
+      "scss",
+      "js",
+      "mjs",
+      "cjs",
+      "ts",
+      "tsx",
+      "jsx",
+      "py",
+      "rb",
+      "go",
+      "rs",
+      "java",
+      "kt",
+      "swift",
+      "c",
+      "h",
+      "cpp",
+      "hpp",
+      "cs",
+      "php",
+      "sh",
+      "bash",
+      "zsh",
+      "fish",
+      "sql",
+      "toml",
+      "ini",
+      "cfg",
+      "conf",
+      "env",
+      "gitignore",
+      "log",
+      "srt",
+      "vtt",
+      "fountain"
+    ]);
+    SKIP_CATEGORY_LABEL = {
+      installed: "packages the project downloaded",
+      rebuildable: "files the project's own tools rebuild",
+      credentials: "files that look like they hold passwords or keys",
+      noise: "files the computer writes on its own"
+    };
+    SKIP_RULES = [
+      // Downloaded packages — restored by re-running the project's own installer.
+      { pattern: "node_modules/", category: "installed" },
+      { pattern: "bower_components/", category: "installed" },
+      { pattern: ".pnpm-store/", category: "installed" },
+      { pattern: ".yarn/cache/", category: "installed" },
+      { pattern: ".venv/", category: "installed" },
+      { pattern: "venv/", category: "installed", needs: "venv/pyvenv.cfg" },
+      // Build output and tool caches.
+      { pattern: ".next/", category: "rebuildable" },
+      { pattern: ".nuxt/", category: "rebuildable" },
+      { pattern: ".svelte-kit/", category: "rebuildable" },
+      { pattern: ".astro/", category: "rebuildable" },
+      { pattern: ".turbo/", category: "rebuildable" },
+      { pattern: ".parcel-cache/", category: "rebuildable" },
+      { pattern: ".vite/", category: "rebuildable" },
+      { pattern: ".gradle/", category: "rebuildable" },
+      { pattern: ".terraform/", category: "rebuildable" },
+      { pattern: "__pycache__/", category: "rebuildable" },
+      { pattern: "*.pyc", category: "rebuildable" },
+      { pattern: "*.pyo", category: "rebuildable" },
+      { pattern: ".pytest_cache/", category: "rebuildable" },
+      { pattern: ".mypy_cache/", category: "rebuildable" },
+      { pattern: ".ruff_cache/", category: "rebuildable" },
+      { pattern: "dist/", category: "rebuildable", needs: "package.json" },
+      { pattern: "build/", category: "rebuildable", needs: "package.json" },
+      { pattern: "out/", category: "rebuildable", needs: "package.json" },
+      { pattern: "target/", category: "rebuildable", needs: "Cargo.toml" },
+      // Credentials. Never `*.key`: that is a Keynote presentation, and dropping
+      // someone's slides to catch a private key would be the worse trade.
+      { pattern: ".env", category: "credentials" },
+      { pattern: ".env.*", category: "credentials" },
+      { pattern: "*.pem", category: "credentials" },
+      { pattern: "id_rsa", category: "credentials" },
+      { pattern: "id_dsa", category: "credentials" },
+      { pattern: "id_ecdsa", category: "credentials" },
+      { pattern: "id_ed25519", category: "credentials" },
+      { pattern: ".npmrc", category: "credentials" },
+      // What the operating system leaves behind.
+      { pattern: ".DS_Store", category: "noise" },
+      { pattern: "Thumbs.db", category: "noise" },
+      { pattern: "desktop.ini", category: "noise" },
+      { pattern: "~$*", category: "noise" },
+      { pattern: "npm-debug.log*", category: "noise" },
+      { pattern: "yarn-error.log*", category: "noise" }
+    ];
+    KEEP_PATTERNS = [
+      "!.env.example",
+      "!.env.sample",
+      "!.env.template",
+      "!.env.defaults"
+    ];
+    CREDENTIAL_PATHSPECS = SKIP_RULES.filter(
+      (r) => r.category === "credentials"
+    ).map((r) => `:(glob)**/${r.pattern}`);
+    for (const pattern of [...SKIP_RULES.map((r) => r.pattern), ...KEEP_PATTERNS]) {
+      const body = pattern.replace(/^!/, "").replace(/\/$/, "");
+      if (!body || /[?\[\]{}!\\]/.test(body) || body.includes("**")) {
+        throw new Error(`skip rule "${pattern}" is not a shape skipRuleFor can match`);
+      }
+    }
+    LABEL_EXCERPT_CHAR_BUDGET = 8e3;
+  }
+});
+
+// src/skip.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync } from "node:fs";
+import { dirname, join as join4 } from "node:path";
+function excludeFilePath(gitDir) {
+  return join4(gitDir, "info", "exclude");
+}
+function activePatterns(folder) {
+  const patterns = [];
+  for (const rule of SKIP_RULES) {
+    if (rule.needs !== void 0 && !existsSync(join4(folder, rule.needs))) continue;
+    patterns.push(rule.pattern);
+  }
+  patterns.push(...KEEP_PATTERNS);
+  return patterns;
+}
+function applySkipRules(folder, gitDir) {
+  const path = excludeFilePath(gitDir);
+  let existing = "";
+  try {
+    existing = readFileSync4(path, "utf8");
+  } catch {
+  }
+  const stripped = existing.replace(
+    new RegExp(`${escapeRe(BEGIN)}[\\s\\S]*?${escapeRe(END)}\\n?`, "g"),
+    ""
+  );
+  const block = [BEGIN, ...activePatterns(folder), END, ""].join("\n");
+  const head = stripped.length && !stripped.endsWith("\n") ? stripped + "\n" : stripped;
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync4(path, head + block);
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function credentialFilesLeftOut(folder, alsoProtect = []) {
+  const r = git(folder, [
+    "ls-files",
+    "-o",
+    "-i",
+    "--exclude-standard",
+    "-z",
+    "--",
+    ...CREDENTIAL_PATHSPECS
+  ]);
+  if (r.code !== 0) return [];
+  const opted = new Set(alsoProtect);
+  return r.stdout.split("\0").filter((p) => p && !opted.has(p));
+}
+function skippedGroups(folder, alsoProtect = []) {
+  const status = git(folder, ["status", "--porcelain", "--ignored", "-z"]);
+  if (status.code !== 0) return [];
+  const opted = new Set(alsoProtect);
+  const paths = status.stdout.split("\0").filter((entry) => entry.startsWith("!! ")).map((entry) => entry.slice(3)).filter((p) => p && !opted.has(p));
+  if (paths.length === 0) return [];
+  const check = git(folder, ["check-ignore", "-v", "--no-index", "--stdin"], paths.join("\n"));
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const line of check.stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const tab = line.lastIndexOf("	");
+    if (tab < 0) continue;
+    const path = line.slice(tab + 1);
+    const source = line.slice(0, tab);
+    const pattern = source.slice(source.lastIndexOf(":") + 1);
+    const category = categoryOfPattern(pattern) ?? "their-own";
+    const list = byCategory.get(category) ?? [];
+    list.push(path);
+    byCategory.set(category, list);
+  }
+  const order = [
+    "credentials",
+    "installed",
+    "rebuildable",
+    "noise",
+    "their-own"
+  ];
+  const groups = [];
+  for (const category of order) {
+    const list = byCategory.get(category);
+    if (!list?.length) continue;
+    groups.push({
+      category,
+      label: category === "their-own" ? THEIR_OWN_LABEL : SKIP_CATEGORY_LABEL[category],
+      paths: [...list].sort()
+    });
+  }
+  return groups;
+}
+var BEGIN, END, THEIR_OWN_LABEL;
+var init_skip = __esm({
+  "src/skip.ts"() {
+    "use strict";
+    init_src();
+    init_git();
+    BEGIN = "# --- GoodFolder: what it leaves out (managed automatically) ---";
+    END = "# --- end GoodFolder ---";
+    THEIR_OWN_LABEL = "files this project's own settings leave out";
+  }
+});
+
+// src/repo-setup.ts
+function ensureSaveAuthor(folder) {
+  const name = git(folder, ["config", "--get", "user.name"]);
+  if (name.code !== 0 || !name.stdout.trim()) {
+    git(folder, ["config", "user.name", DEFAULT_SAVE_AUTHOR]);
+  }
+  const email = git(folder, ["config", "--get", "user.email"]);
+  if (email.code !== 0 || !email.stdout.trim()) {
+    git(folder, ["config", "user.email", DEFAULT_SAVE_EMAIL]);
+  }
+}
+function pushCurrentHistory(folder, cfg) {
+  return git(folder, ["push", GF_REMOTE, "HEAD:main"], void 0, transportEnv(cfg));
+}
+function fetchHistory(folder, cfg) {
+  return git(folder, ["fetch", GF_REMOTE], void 0, transportEnv(cfg));
+}
+function bindRepo(folder, gitDir, cfg) {
+  saveConfig(gitDir, cfg);
+  ensureRemote(folder, cfg);
+  applySkipRules(folder, gitDir);
+  ensureSaveAuthor(folder);
+  configureRepo(folder);
+}
+function ensureRemote(folder, cfg) {
+  const url = transportUrl(cfg);
+  const existing = git(folder, ["remote", "get-url", GF_REMOTE]);
+  if (existing.code === 0) {
+    if (existing.stdout.trim() !== url) {
+      git(folder, ["remote", "set-url", GF_REMOTE, url]);
+    }
+  } else {
+    git(folder, ["remote", "add", GF_REMOTE, url]);
+  }
+  const lfs = git(folder, ["config", "--get", "lfs.url"]);
+  if (lfs.code !== 0 || lfs.stdout.trim() !== largeFileUrl(cfg)) {
+    git(folder, ["config", "lfs.url", largeFileUrl(cfg)]);
+  }
+  const leaked = git(folder, ["config", "--local", "--name-only", "--get-regexp", "^lfs\\.https?://[^/]*@"]);
+  for (const name of leaked.stdout.split("\n").map((l) => l.trim()).filter(Boolean)) {
+    const section = name.slice(0, name.lastIndexOf("."));
+    git(folder, ["config", "--local", "--remove-section", section]);
+  }
+  if (git(folder, ["config", "--local", "--get", "lfs.locksverify"]).stdout.trim() !== "false") {
+    git(folder, ["config", "--local", "lfs.locksverify", "false"]);
+  }
+  const legacy = git(folder, ["remote", "get-url", "origin"]);
+  if (legacy.code === 0 && legacy.stdout.includes(`/git/${cfg.projectId}`)) {
+    git(folder, ["remote", "remove", "origin"]);
+  }
+}
+var GF_REMOTE, DEFAULT_SAVE_AUTHOR, DEFAULT_SAVE_EMAIL;
+var init_repo_setup = __esm({
+  "src/repo-setup.ts"() {
+    "use strict";
+    init_config();
+    init_git();
+    init_perf();
+    init_skip();
+    GF_REMOTE = "goodfolder";
+    DEFAULT_SAVE_AUTHOR = "GoodFolder";
+    DEFAULT_SAVE_EMAIL = "goodfolder@local";
+  }
+});
+
+// src/cli-error.ts
+var CliError;
+var init_cli_error = __esm({
+  "src/cli-error.ts"() {
+    "use strict";
+    CliError = class extends Error {
+      exitCode;
+      constructor(message, exitCode = 1) {
+        super(message);
+        this.name = "CliError";
+        this.exitCode = exitCode;
+      }
+    };
+  }
+});
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  accountCall: () => accountCall,
+  createProject: () => createProject,
+  listProjects: () => listProjects,
+  listSaves: () => listSaves,
+  mintProjectToken: () => mintProjectToken,
+  preflightSave: () => preflightSave,
+  recordSave: () => recordSave,
+  renewFolderToken: () => renewFolderToken
+});
+async function call(cfg, method, path, body) {
+  const init = {
+    method,
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${cfg.token}`
+    },
+    signal: AbortSignal.timeout(3e4)
+  };
+  if (body !== void 0) init.body = JSON.stringify(body);
+  const res = await fetch(`${cfg.apiUrl}${path}`, init);
+  let json = null;
+  try {
+    json = await res.json();
+  } catch {
+  }
+  return { ok: res.ok, status: res.status, json };
+}
+async function accountCall(apiUrl, accountToken, method, path, body, subscriptionAction) {
+  const init = {
+    method,
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${accountToken}`
+    },
+    signal: AbortSignal.timeout(3e4)
+  };
+  if (body !== void 0) init.body = JSON.stringify(body);
+  const res = await fetch(`${apiUrl}${path}`, init);
+  let json = null;
+  try {
+    json = await res.json();
+  } catch {
+  }
+  if (!res.ok) {
+    const billing = billingErrorMessage(json?.error?.code, subscriptionAction);
+    if (billing) throw new CliError(`\u2717 ${billing}`);
+    if (res.status === 401 || res.status === 403) throw new CliError(`\u2717 ${authHint()}`);
+    throw new CliError(
+      `\u2717 ${json?.error?.message ?? `GoodFolder request failed (${res.status})`}`
+    );
+  }
+  return json;
+}
+function billingErrorMessage(code, subscriptionAction = "saving new work") {
+  if (code === "subscription-required") return `Start your GoodFolder Hosted trial before ${subscriptionAction}.`;
+  if (code === "read-only") return "This account is in read and export mode. Your existing files and earlier versions are still available.";
+  if (code === "quota-exceeded") return "You have reached your protected-data limit. Nothing was removed; increase your limit or free some capacity before saving again.";
+  if (code === "billing-unavailable") return "Hosted billing is unavailable right now. Try again shortly.";
+  return null;
+}
+async function preflightSave(cfg) {
+  const result = await call(cfg, "GET", "/api/save/preflight");
+  if (result.ok) return;
+  const message = billingErrorMessage(result.json?.error?.code);
+  throw new CliError(`\u2717 ${message ?? result.json?.error?.message ?? `GoodFolder request failed (${result.status})`}`);
+}
+function createProject(apiUrl, name, accountToken, deviceName) {
+  return accountCall(apiUrl, accountToken, "POST", "/api/projects", {
+    name,
+    ...deviceName ? { deviceName } : {}
+  }, "connecting a folder");
+}
+function listProjects(apiUrl, accountToken) {
+  return accountCall(apiUrl, accountToken, "GET", "/api/projects");
+}
+function mintProjectToken(apiUrl, projectId, accountToken, deviceName) {
+  return accountCall(apiUrl, accountToken, "POST", `/api/projects/${projectId}/token`, deviceName ? { deviceName } : void 0);
+}
+async function renewFolderToken(cfg) {
+  const result = await call(cfg, "POST", "/api/folder-token/renew");
+  if (result.status === 401 || result.status === 403 || result.status === 404) return null;
+  if (!result.ok || typeof result.json?.token !== "string") {
+    throw new CliError(`\u2717 ${result.json?.error?.message ?? `GoodFolder request failed (${result.status})`}`);
+  }
+  return { token: result.json.token, expiresAt: String(result.json.expiresAt ?? "") };
+}
+function recordSave(cfg, input) {
+  return call(cfg, "POST", "/api/saves", {
+    label: input.label,
+    labelSource: input.label ? "user" : "agent",
+    changedPaths: input.changedPaths,
+    commitSha: input.commitSha,
+    collision: input.collision,
+    ai: input.ai ?? void 0,
+    counts: input.counts,
+    topPaths: input.topPaths,
+    harness: input.harness ?? void 0
+  }).then((r) => {
+    if (!r.ok) throw new Error(r.json?.error?.message ?? `save failed (${r.status})`);
+    return r.json;
+  });
+}
+async function listSaves(cfg) {
+  const r = await call(cfg, "GET", "/api/saves");
+  if (!r.ok) throw new Error(`could not load timeline (${r.status})`);
+  const rows = r.json;
+  return rows.map((row) => ({
+    ...row,
+    createdAt: row.created_at ?? row.createdAt,
+    // The timeline endpoint returns camelCase `commitSha` since the
+    // save-receipts change (2026-08-26); older shapes used `commit_sha`.
+    // Normalize here so restore/undo have one field to read.
+    commit_sha: row.commit_sha ?? row.commitSha,
+    harness: row.harness ?? null
+  }));
+}
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    init_cli_error();
+    init_auth();
+  }
+});
+
+// src/auth.ts
+import { spawn as spawn2 } from "node:child_process";
+function authHint() {
+  return "GoodFolder can't act for your account on this computer.\n  Fix: run  goodfolder login\n  (this opens a one-time browser approval)";
+}
+async function friendlyDeviceName() {
+  const os = await import("node:os");
+  return os.hostname().replace(/\.local$/i, "").trim() || "This computer";
+}
+function openBrowser(url) {
+  if (process.env.GF_NO_OPEN) return;
+  try {
+    if (process.platform === "win32") {
+      spawn2("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true }).unref();
+    } else {
+      const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+      spawn2(cmd, [url], { stdio: "ignore", detached: true }).unref();
+    }
+  } catch {
+  }
+}
+async function ensureAccount(apiUrl = DEFAULT_API_URL) {
+  const existing = loadAccountToken();
+  if (existing) return existing;
+  const paired = await pairDevice(apiUrl);
+  return paired.token;
+}
+async function pairDevice(apiUrl = DEFAULT_API_URL) {
+  const deviceName = await friendlyDeviceName();
+  const startRes = await fetch(`${apiUrl}/api/pair/start`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ deviceName }),
+    signal: AbortSignal.timeout(2e4)
+  });
+  const start = await startRes.json().catch(() => ({}));
+  if (!startRes.ok || !start.code || !start.url) {
+    throw new CliError(
+      `\u2717 Could not start the approval: ${start.error?.message ?? startRes.status}`
+    );
+  }
+  console.log(`
+One-time setup \u2014 approve "${deviceName}" to connect this computer.`);
+  console.log("Your browser should open in a moment. Sign in, then choose Approve.");
+  console.log(`The page will show the code  ${pairingCheckCode(start.code)}  \u2014 approve only if it matches.`);
+  console.log(`If nothing opened, visit:
+  ${start.url}
+`);
+  openBrowser(start.url);
+  const deadline = Date.now() + 10 * 6e4;
+  while (Date.now() < deadline) {
+    await sleep(2e3);
+    let status = "";
+    let token;
+    try {
+      const res = await fetch(`${apiUrl}/api/pair/${start.code}/wait`, {
+        signal: AbortSignal.timeout(15e3)
+      });
+      const j = await res.json().catch(() => ({}));
+      status = j.status ?? "";
+      token = j.token;
+    } catch {
+      continue;
+    }
+    if (status === "approved" && token) {
+      const where = saveAccountToken(token);
+      console.log(
+        where === "keychain" ? "\u2713 This computer is approved (credential stored in your Keychain)." : "\u2713 This computer is approved."
+      );
+      return { token };
+    }
+    if (status === "expired") {
+      throw new CliError(
+        "\u2717 The approval window closed before anyone approved.\n  Start again: goodfolder login"
+      );
+    }
+    if (status === "denied") {
+      throw new CliError("\u2717 This approval was declined.");
+    }
+    if (status === "consumed") {
+      throw new CliError(
+        "\u2717 That approval was already collected by another process."
+      );
+    }
+  }
+  throw new CliError(
+    "\u2717 Gave up waiting for approval after 10 minutes.\n  Start again: goodfolder login"
+  );
+}
+function pairingCheckCode(code) {
+  return code.slice(0, 6).toUpperCase();
+}
+async function cmdDevices(action, target) {
+  const accountToken = loadAccountToken();
+  if (!accountToken) throw new CliError(`\u2717 ${authHint()}`);
+  const { accountCall: accountCall2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  const listed = await accountCall2(DEFAULT_API_URL, accountToken, "GET", "/api/account/devices");
+  const devices = listed.devices ?? [];
+  if (action === "forget") {
+    const wanted = (target ?? "").trim().toLowerCase();
+    const match = devices.filter((d) => d.id === wanted || d.name.toLowerCase() === wanted);
+    if (!wanted || match.length === 0) {
+      throw new CliError(`\u2717 No approved computer called "${target ?? ""}". Run: goodfolder devices`);
+    }
+    if (match.length > 1) {
+      throw new CliError(`\u2717 More than one computer is called "${target}". Use its id from: goodfolder devices`);
+    }
+    const [device] = match;
+    await accountCall2(DEFAULT_API_URL, accountToken, "DELETE", `/api/account/devices/${device.id}`);
+    console.log(`\u2713 "${device.name}" can no longer act for your account.`);
+    if (device.thisOne) console.log("  That was this computer. Run goodfolder login to approve it again.");
+    return;
+  }
+  if (devices.length === 0) {
+    console.log("No computers are approved on this account.");
+    return;
+  }
+  console.log("Computers approved on your account:\n");
+  for (const d of devices) {
+    const used = d.lastUsedAt ? `last used ${d.lastUsedAt.slice(0, 10)}` : "not used yet";
+    console.log(`  ${d.name}${d.thisOne ? "  (this computer)" : ""}`);
+    console.log(`      approved ${d.approvedAt.slice(0, 10)} \xB7 ${used} \xB7 id ${d.id}`);
+  }
+  console.log("\nTo take one back:  goodfolder devices forget <name or id>");
+}
+async function cmdLogin() {
+  if (loadAccountToken()) {
+    console.log("This computer already has an approval. Approving again replaces it.");
+  }
+  const meta = accountMeta();
+  void meta;
+  await pairDevice(DEFAULT_API_URL);
+}
+var sleep;
+var init_auth = __esm({
+  "src/auth.ts"() {
+    "use strict";
+    init_config();
+    init_cli_error();
+    init_credentials();
+    sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  }
+});
+
+// src/nested.ts
+import { lstatSync, readlinkSync } from "node:fs";
+import { join as join5 } from "node:path";
+function foreignHistories(folder) {
+  const r = git(folder, ["ls-files", "-s", "-z"]);
+  if (r.code !== 0) return [];
+  const dirs = [];
+  for (const entry of r.stdout.split("\0")) {
+    if (!entry.startsWith("160000 ")) continue;
+    const tab = entry.indexOf("	");
+    if (tab < 0) continue;
+    dirs.push(entry.slice(tab + 1));
+  }
+  return dirs;
+}
+function filesWorthTaking(folder, dir) {
+  const r = git(join5(folder, dir), [
+    "ls-files",
+    "--cached",
+    "--others",
+    "--exclude-standard",
+    "-z"
+  ]);
+  if (r.code !== 0) return [];
+  return r.stdout.split("\0").filter(Boolean);
+}
+function absorbForeignHistories(folder, dirs) {
+  const taken = [];
+  for (const dir of dirs) {
+    git(folder, ["update-index", "--force-remove", "--", dir]);
+    for (const rel of filesWorthTaking(folder, dir)) {
+      const path = `${dir}/${rel}`;
+      let st;
+      try {
+        st = lstatSync(join5(folder, path));
+      } catch {
+        continue;
+      }
+      let mode;
+      let blob;
+      if (st.isSymbolicLink()) {
+        mode = "120000";
+        const target = readlinkSync(join5(folder, path));
+        blob = git(folder, ["hash-object", "-w", "--stdin"], target).stdout.trim();
+      } else if (st.isFile()) {
+        mode = st.mode & 73 ? "100755" : "100644";
+        blob = git(folder, ["hash-object", "-w", "--path", path, "--", path]).stdout.trim();
+      } else {
+        continue;
+      }
+      if (!blob) continue;
+      const add = git(folder, ["update-index", "--add", "--cacheinfo", mode, blob, path]);
+      if (add.code === 0) taken.push(path);
+    }
+  }
+  return taken;
+}
+function pathsInside(folder, dirs) {
+  return dirs.flatMap((dir) => filesWorthTaking(folder, dir).map((rel) => `${dir}/${rel}`));
+}
+var init_nested = __esm({
+  "src/nested.ts"() {
+    "use strict";
+    init_git();
+  }
+});
+
+// src/save-core.ts
+import { appendFileSync, readFileSync as readFileSync5, statSync } from "node:fs";
+import { join as join6 } from "node:path";
+function scanChanges(folder) {
+  const r = git(folder, ["status", "--porcelain", "-z", "-uall"]);
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  const all = [];
+  const entries = r.stdout.split("\0").filter(Boolean);
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const xy = entry.slice(0, 2);
+    let path = entry.slice(3);
+    if (xy.includes("R") || xy.includes("C")) {
+      i++;
+    }
+    if (path.startsWith('"')) continue;
+    all.push(path);
+    if (xy.includes("D") && !xy.includes("?")) deleted.push(path);
+    else if (xy.includes("A") || xy.includes("?")) added.push(path);
+    else modified.push(path);
+  }
+  return { added, modified, deleted, all };
+}
+function hasHead(folder) {
+  return gitOk(folder, ["rev-parse", "-q", "--verify", "HEAD"]);
+}
+async function enforceCaseGate(folder, changes, trackedPromise, extraPaths = []) {
+  const tracked = (await trackedPromise).stdout.split("\n").filter(Boolean);
+  const collisions = findCaseCollisions([
+    .../* @__PURE__ */ new Set([...changes.all, ...tracked, ...extraPaths])
+  ]);
+  if (collisions.length === 0) return;
+  console.error("\u2717 This save was refused.\n");
+  console.error(
+    "Two files differ only by capitalization, which would silently overwrite"
+  );
+  console.error("one of them on Windows or macOS:");
+  for (const c of collisions.slice(0, 10)) {
+    console.error(`   \u2022 ${c.a}  \u2194  ${c.b}`);
+  }
+  throw new CliError("\nRename one of them, then save again.", 1);
+}
+function applyRouting(folder, paths) {
+  const attrPath = join6(folder, ".gitattributes");
+  let existing = "";
+  try {
+    existing = readFileSync5(attrPath, "utf8");
+  } catch {
+  }
+  const lines = new Set(existing.split("\n").map((l) => l.trim()));
+  let dirty = false;
+  for (const p of paths) {
+    let size = 0;
+    try {
+      size = statSync(join6(folder, p)).size;
+    } catch {
+      continue;
+    }
+    if (routeFile(p, size).target !== "lfs") continue;
+    const entry = `${p.includes(" ") ? `"${p}"` : p} filter=lfs diff=lfs merge=lfs -text`;
+    if (!lines.has(entry)) {
+      lines.add(entry);
+      dirty = true;
+    }
+  }
+  if (dirty) {
+    const header = existing.includes("# goodfolder-managed") ? "" : "# goodfolder-managed large-file routing\n";
+    appendFileSync(
+      attrPath,
+      (existing.endsWith("\n") || existing === "" ? "" : "\n") + header + [...lines].filter((l) => l && !existing.split("\n").includes(l)).join("\n") + "\n"
+    );
+  }
+}
+function buildAiContext(folder, changes) {
+  const diff = git(folder, ["diff", "--cached"]);
+  const mediaPaths = /* @__PURE__ */ new Set();
+  for (const p of [...changes.added, ...changes.modified]) {
+    try {
+      if (routeFile(p, statSync(join6(folder, p)).size).target === "lfs") mediaPaths.add(p);
+    } catch {
+    }
+  }
+  const parts = [];
+  let used = 0;
+  let truncated = false;
+  for (const line of diff.stdout.split("\n")) {
+    if (line.startsWith("Binary files") || /^GIT binary patch/.test(line)) {
+      continue;
+    }
+    if (used + line.length + 1 > LABEL_EXCERPT_CHAR_BUDGET) {
+      truncated = true;
+      break;
+    }
+    parts.push(line);
+    used += line.length + 1;
+  }
+  if (!changes.all.length) return null;
+  const mediaNote = mediaPaths.size > 0 ? ` Media files (contents not shown): ${[...mediaPaths].slice(0, 20).map((p) => {
+    try {
+      return `${p} (${Math.round(statSync(join6(folder, p)).size / 1024)} KB)`;
+    } catch {
+      return p;
+    }
+  }).join(", ")}.` : "";
+  return {
+    summary: `${changes.added.length} added, ${changes.modified.length} modified, ${changes.deleted.length} removed.${mediaNote}`,
+    excerpt: parts.join("\n"),
+    truncated
+  };
+}
+function pickTopPaths(changes, limit = 8) {
+  const clean = (list) => list.filter((p) => !NOISE_FILES.has(p.split(/[\\/]/).pop() ?? ""));
+  const ordered = [...clean(changes.modified), ...clean(changes.added), ...clean(changes.deleted)];
+  return [...new Set(ordered)].slice(0, limit);
+}
+function renderImportProgress(fragment) {
+  if (!process.stdout.isTTY) return;
+  const pct = /(\d+)%/.exec(fragment);
+  const nums = /(\d[\d,]*)\s*\/\s*(\d[\d,]*)/.exec(fragment.replace(/,/g, ""));
+  let line;
+  if (pct?.[1] && nums?.[1] && nums[2]) {
+    line = `Importing your folder\u2026 ${pct[1]}% (${fmt(Number(nums[1].replace(/,/g, "")))} / ${fmt(Number(nums[2].replace(/,/g, "")))} files)`;
+  } else if (nums?.[1] && nums[2]) {
+    line = `Importing your folder\u2026 ${fmt(Number(nums[1].replace(/,/g, "")))} / ${fmt(Number(nums[2].replace(/,/g, "")))} files`;
+  } else if (pct?.[1]) {
+    line = `Importing your folder\u2026 ${pct[1]}%`;
+  } else {
+    return;
+  }
+  process.stdout.write(`\r\x1B[2K${line}`);
+}
+function reportWhatStayedOut(folder, alsoProtect, wasImport) {
+  if (wasImport) {
+    const groups = skippedGroups(folder, alsoProtect);
+    if (groups.length === 0) return;
+    console.log("  Left out, because your own tools remake them or they hold secrets:");
+    for (const group of groups) {
+      const shown = group.paths.slice(0, 3).join(", ");
+      const rest = group.paths.length - 3;
+      const more = rest > 0 ? `, and ${fmt(rest)} more` : "";
+      console.log(`    \u2022 ${group.label}: ${shown}${more}`);
+    }
+    console.log("  To see the whole list, or protect one anyway: goodfolder skipped");
+    return;
+  }
+  const secrets = credentialFilesLeftOut(folder, alsoProtect);
+  if (secrets.length === 0) return;
+  const many = secrets.length === 1 ? "file that looks" : "files that look";
+  console.log(
+    `  ${secrets.length} ${many} like passwords or keys stayed out \u2014 goodfolder skipped`
+  );
+}
+async function runSavePipeline(folder, cfg, opts = {}) {
+  const gitDir = findGitDir(folder);
+  if (!gitDir) throw new CliError("\u2717 This folder is not connected.", 1);
+  const wasImport = !traceSync("head-check", () => hasHead(folder));
+  const trackedPromise = gitAsync(folder, ["ls-files"]);
+  const changes = traceSync("scan", () => scanChanges(folder));
+  if (wasImport) {
+    console.log(
+      "First save on this folder \u2014 bringing everything into GoodFolder."
+    );
+    console.log("Large folders take a moment; you can keep working meanwhile.");
+  } else if (changes.all.length === 0) {
+    void trackedPromise;
+    console.log("Nothing new to save \u2014 your folder matches the last save.");
+    const nothing = { sha: "", changedCount: 0, wasImport: false, seq: void 0, label: "", truncated: false, pushSkipped: opts.skipPush ?? false, timings: {}, counts: { added: 0, changed: 0, removed: 0 }, topPaths: [] };
+    return nothing;
+  }
+  if (wasImport && changes.all.length === 0) {
+    void trackedPromise;
+    console.log("Connected. The folder is empty right now \u2014 anything you add and save is protected from then on.");
+    const empty = { sha: "", changedCount: 0, wasImport: true, seq: void 0, label: "", truncated: false, pushSkipped: opts.skipPush ?? false, timings: {}, counts: { added: 0, changed: 0, removed: 0 }, topPaths: [] };
+    return empty;
+  }
+  if (!opts.skipPush) await trace("access-preflight", () => preflightSave(cfg));
+  traceSync(
+    "routing",
+    () => applyRouting(folder, [...changes.added, ...changes.modified])
+  );
+  let interrupted = false;
+  const staged = await trace("stage", async () => {
+    if (!wasImport) {
+      const ok = gitOk(folder, ["add", "-A"]);
+      if (!ok) throw new CliError("\u2717 Could not prepare your changes.", 1);
+      return;
+    }
+    let seen = 0;
+    const total = Math.max(1, changes.all.length);
+    const tick = () => {
+      seen++;
+      if (seen % 200 === 0 || seen === total) {
+        renderImportProgress(`${seen} / ${total} files`);
+      }
+    };
+    const { done, kill } = gitStream(folder, ["add", "-A", "--verbose"], () => tick());
+    const sigint = () => {
+      interrupted = true;
+      kill();
+    };
+    process.on("SIGINT", sigint);
+    try {
+      const r = await done;
+      if (process.stdout.isTTY) process.stdout.write("\r\x1B[2K");
+      if (interrupted || r.code !== 0) {
+        if (interrupted) {
+          throw new CliError(
+            "\nImport paused \u2014 nothing is lost. Run goodfolder save again to pick up where it left off.",
+            130
+          );
+        }
+        throw new CliError(`\u2717 Could not prepare your changes: ${r.stderr.trim()}`, 1);
+      }
+    } finally {
+      process.off("SIGINT", sigint);
+    }
+  });
+  void staged;
+  let dirsWithForeignHistory = [];
+  const absorbed = traceSync("nested", () => {
+    dirsWithForeignHistory = foreignHistories(folder);
+    const dirs = dirsWithForeignHistory;
+    if (dirs.length === 0) return [];
+    const inside = pathsInside(folder, dirs);
+    applyRouting(folder, inside);
+    gitOk(folder, ["add", "-A", "--", ".gitattributes"]);
+    return absorbForeignHistories(folder, dirs);
+  });
+  if (absorbed.length > 0) {
+    const placeholders = new Set(
+      dirsWithForeignHistory.flatMap((dir) => [dir, `${dir}/`])
+    );
+    const drop = (list) => {
+      const kept = list.filter((p) => !placeholders.has(p));
+      list.length = 0;
+      list.push(...kept);
+    };
+    drop(changes.added);
+    drop(changes.modified);
+    drop(changes.all);
+    changes.added.push(...absorbed);
+    changes.all.push(...absorbed);
+  }
+  const alsoProtect = cfg.alsoProtect ?? [];
+  if (alsoProtect.length > 0) {
+    gitOk(folder, ["add", "-f", "--", ...alsoProtect]);
+  }
+  await trace(
+    "case-gate",
+    () => enforceCaseGate(folder, changes, trackedPromise, absorbed)
+  );
+  const ai = opts.recorder ? traceSync("label-context", () => buildAiContext(folder, changes)) : null;
+  const commitMsg = opts.message ?? (wasImport ? "First save" : "Save");
+  const commit = await trace("commit", async () => {
+    ensureSaveAuthor(folder);
+    const r = git(folder, ["commit", "-m", commitMsg]);
+    if (r.code !== 0) {
+      const detail = r.stderr.trim();
+      throw new CliError(
+        detail ? `\u2717 Could not record this Save: ${detail}` : "\u2717 Could not record this Save right now.",
+        1
+      );
+    }
+    return git(folder, ["rev-parse", "HEAD"]).stdout.trim();
+  });
+  let pushSkipped = opts.skipPush ?? false;
+  if (!pushSkipped) {
+    await trace("push", async () => {
+      const push = pushCurrentHistory(folder, cfg);
+      if (push.code !== 0) {
+        if (/non-fast-forward|rejected/i.test(push.stderr)) {
+          throw new CliError("\u2717 Another device saved first. Run: goodfolder sync");
+        }
+        throw new CliError(`\u2717 Could not reach GoodFolder: ${push.stderr.trim()}`);
+      }
+    });
+  }
+  let label = commitMsg;
+  let seq;
+  let truncated = false;
+  if (opts.recorder) {
+    try {
+      const input = {
+        changedPaths: changes.all,
+        commitSha: commit,
+        counts: {
+          added: changes.added.length,
+          changed: changes.modified.length,
+          removed: changes.deleted.length
+        },
+        topPaths: pickTopPaths(changes)
+      };
+      if (opts.message) input.label = opts.message;
+      if (ai) input.ai = ai;
+      const res = await opts.recorder(input);
+      seq = res.seq;
+      label = res.label ?? label;
+    } catch (e) {
+      console.warn(
+        `\u26A0 Saved locally and uploaded, but the timeline update failed (${e.message}).`
+      );
+    }
+  }
+  truncated = ai?.truncated ?? false;
+  const counts = {
+    added: changes.added.length,
+    changed: changes.modified.length,
+    removed: changes.deleted.length
+  };
+  if (wasImport) {
+    console.log(`\u2713 Imported and safe \u2014 ${fmt(changes.all.length)} files are now protected.`);
+  } else {
+    const what = counts.added + counts.removed > 0 ? `${counts.added} added \xB7 ${counts.changed} changed \xB7 ${counts.removed} removed` : `${counts.changed} file${counts.changed === 1 ? "" : "s"} updated`;
+    console.log(`\u2713 Saved${seq !== void 0 ? ` #${seq}` : ""}`);
+    console.log(`  ${what}`);
+  }
+  console.log(`  ${label}`);
+  if (truncated) console.log("  (large change \u2014 the label saw a partial preview)");
+  reportWhatStayedOut(folder, alsoProtect, wasImport);
+  const timings = {};
+  for (const [name, ms] of snapshotMarks()) {
+    timings[name] = (timings[name] ?? 0) + ms;
+  }
+  const tr = renderTrace();
+  if (tr) console.log(tr);
+  const outcome = { sha: commit, changedCount: changes.all.length, wasImport, seq, label, truncated, pushSkipped, timings, counts, topPaths: pickTopPaths(changes) };
+  return outcome;
+}
+var fmt, NOISE_FILES;
+var init_save_core = __esm({
+  "src/save-core.ts"() {
+    "use strict";
+    init_src();
+    init_cli_error();
+    init_git();
+    init_perf();
+    init_api();
+    init_repo_setup();
+    init_nested();
+    init_skip();
+    fmt = (n) => n.toLocaleString("en-US");
+    NOISE_FILES = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db", "desktop.ini"]);
+  }
+});
+
+// src/save.ts
+var save_exports = {};
+__export(save_exports, {
+  cmdSave: () => cmdSave
+});
+async function cmdSave(folder, cfg, opts) {
+  await runSavePipeline(folder, cfg, {
+    message: opts.message,
+    ...opts.harness ? { harness: opts.harness } : {},
+    async recorder(input) {
+      const res = await recordSave(cfg, {
+        changedPaths: input.changedPaths,
+        commitSha: input.commitSha,
+        counts: input.counts,
+        topPaths: input.topPaths,
+        harness: opts.harness ?? null,
+        ...input.label !== void 0 ? { label: input.label } : {},
+        ...input.ai !== void 0 ? { ai: input.ai } : {}
+      });
+      return { seq: res.seq, label: res.label };
+    }
+  });
+}
+var init_save = __esm({
+  "src/save.ts"() {
+    "use strict";
+    init_api();
+    init_save_core();
+  }
+});
+
+// src/index.ts
+import { resolve as resolve2 } from "node:path";
+
+// src/connect.ts
+init_config();
+init_repo_setup();
+init_cli_error();
+init_git();
+init_auth();
+init_api();
+init_credentials();
+import { existsSync as existsSync2 } from "node:fs";
+import { basename, resolve } from "node:path";
+var RENEW_WHEN_LEFT_MS = 30 * 864e5;
+async function ensureFreshToken(folder, gitDir, cfg) {
+  const left = cfg.tokenExpiresAt ? Date.parse(cfg.tokenExpiresAt) - Date.now() : Number.NaN;
+  if (cfg.token && Number.isFinite(left) && left > RENEW_WHEN_LEFT_MS) return;
+  let fresh = null;
+  try {
+    if (cfg.token) fresh = await renewFolderToken(cfg);
+    if (!fresh) {
+      const accountToken = loadAccountToken();
+      if (!accountToken) {
+        throw new CliError(
+          "\u2717 This folder's connection to GoodFolder needs approving again.\n  Fix: run  goodfolder login  and then try again."
+        );
+      }
+      fresh = await mintProjectToken(cfg.apiUrl, cfg.projectId, accountToken, await friendlyDeviceName());
+    }
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    return;
+  }
+  cfg.token = fresh.token;
+  if (fresh.expiresAt) cfg.tokenExpiresAt = fresh.expiresAt;
+  else delete cfg.tokenExpiresAt;
+  saveConfig(gitDir, cfg);
+}
+async function requireConnection(folder) {
+  const gitDir = findGitDir(folder);
+  const cfg = gitDir ? loadConfig(gitDir) : null;
+  if (!gitDir || !cfg) {
+    throw new CliError(
+      "\u2717 This folder isn't connected to GoodFolder yet. Run:\n    goodfolder connect"
+    );
+  }
+  await ensureFreshToken(folder, gitDir, cfg);
+  ensureRemote(folder, cfg);
+  return { gitDir, cfg };
+}
+function enclosingManagedFolder(folder) {
+  const prefix = git(folder, ["rev-parse", "--show-prefix"]);
+  if (prefix.code !== 0) return null;
+  if (prefix.stdout.trim() === "") return null;
+  const root = git(folder, ["rev-parse", "--show-toplevel"]).stdout.trim();
+  return root || null;
+}
+function projectNameForFolder(folder) {
+  return basename(resolve(folder));
+}
+async function cmdConnect(folder) {
+  if (!existsSync2(folder)) {
+    throw new CliError(`\u2717 No such folder: ${folder}`, 1);
+  }
+  const enclosing = enclosingManagedFolder(folder);
+  if (enclosing !== null) {
+    throw new CliError(
+      `\u2717 This folder sits inside "${enclosing}", which another tool already looks after.
+    Connecting it here would protect that whole outer folder instead of this one.
+    Connect the outer folder instead, or move this one somewhere of its own.`,
+      1
+    );
+  }
+  let gitDir = findGitDir(folder);
+  const fresh = gitDir === null;
+  if (fresh) {
+    if (!gitOk(folder, ["init", "-b", "main"])) {
+      throw new CliError("\u2717 Could not initialize the folder.", 1);
+    }
+    gitDir = findGitDir(folder);
+  }
+  if (loadConfig(gitDir)) {
+    console.log("Already connected \u2014 nothing to do.");
+    return;
+  }
+  const name = projectNameForFolder(folder);
+  console.log("Connecting\u2026");
+  const accountToken = await ensureAccount(DEFAULT_API_URL);
+  const boot = await createProject(DEFAULT_API_URL, name, accountToken, await friendlyDeviceName());
+  if (!boot.projectId || !boot.token) {
+    throw new CliError("\u2717 Could not create your project. Try again shortly.", 1);
+  }
+  const cfg = {
+    projectId: boot.projectId,
+    apiUrl: DEFAULT_API_URL,
+    token: boot.token,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (boot.expiresAt) cfg.tokenExpiresAt = boot.expiresAt;
+  bindRepo(folder, gitDir, cfg);
+  console.log(`\u2713 Connected "${name}" at ${resolve(folder)} to GoodFolder.`);
+  if (fresh) console.log("  (nothing visible changed \u2014 your folder just became protected)");
+  const status = git(folder, ["status", "--porcelain"]);
+  if (status.stdout.trim() !== "") {
+    console.log("Saving everything in this folder for the first time\u2026");
+    await new Promise((r) => setTimeout(r, 100));
+    const { cmdSave: cmdSave2 } = await Promise.resolve().then(() => (init_save(), save_exports));
+    await cmdSave2(folder, cfg, {});
+  } else {
+    console.log("Folder is empty of changes; run goodfolder save when ready.");
+  }
+}
+
+// src/index.ts
+init_save();
+
+// src/sync.ts
+init_cli_error();
+init_git();
+init_api();
+init_repo_setup();
+async function cmdSync(folder, opts = {}) {
+  const { cfg } = await requireConnection(folder);
+  const fetchRes = fetchHistory(folder, cfg);
+  if (fetchRes.code !== 0) {
+    throw new CliError(`\u2717 Could not reach GoodFolder: ${fetchRes.stderr.trim()}`, 1);
+  }
+  if (!gitOk(folder, ["rev-parse", "-q", "--verify", `${GF_REMOTE}/main`])) {
+    console.log("Everything is already up to date.");
+    return;
+  }
+  const count = git(folder, [
+    "rev-list",
+    "--left-right",
+    "--count",
+    `HEAD...${GF_REMOTE}/main`
+  ]);
+  const [ahead, behind] = count.stdout.trim().split(/\s+/).map(Number);
+  if (ahead === void 0 || behind === void 0) {
+    throw new CliError("\u2717 Could not compare with your other devices.", 1);
+  }
+  if (ahead === 0 && behind === 0) {
+    console.log("Everything is already up to date.");
+    return;
+  }
+  if (ahead > 0 && behind > 0) {
+    console.log("You and another device both made changes \u2014 combining them\u2026");
+    const merge = git(folder, ["merge", `${GF_REMOTE}/main`, "-m", "Sync changes"]);
+    if (merge.code !== 0) {
+      const conflicted = git(folder, ["diff", "--name-only", "--diff-filter=U"]).stdout.split("\n").filter(Boolean);
+      throw new CliError(
+        "\nBoth versions are kept \u2014 nothing was lost.\n" + conflicted.map((f) => `  \u2022 ${f}`).join("\n") + '\n\nOpen those files, keep what you want, then run:\n   goodfolder save -m "Resolved changes"',
+        2
+      );
+    }
+    const sha = git(folder, ["rev-parse", "HEAD"]).stdout.trim();
+    const push = pushCurrentHistory(folder, cfg);
+    if (push.code !== 0) {
+      throw new CliError("\u2717 Combined locally but could not upload. Try again.", 1);
+    }
+    try {
+      await recordSave(cfg, {
+        label: `Synced changes from another device`,
+        changedPaths: git(folder, ["diff", "--name-only", "HEAD^", "HEAD"]).stdout.split("\n").filter(Boolean),
+        commitSha: sha,
+        collision: "auto-merged",
+        harness: opts.harness ?? null
+      });
+    } catch {
+    }
+    console.log("\u2713 Combined and saved.");
+    return;
+  }
+  if (behind > 0) {
+    const ff = git(folder, ["merge", "--ff-only", `${GF_REMOTE}/main`]);
+    if (ff.code !== 0) {
+      throw new CliError("\u2717 Update failed mid-way \u2014 your work is untouched.", 1);
+    }
+    console.log(`\u2713 Brought in ${behind} change${behind === 1 ? "" : "s"} from your other device${behind === 1 ? "" : "s"}.`);
+    return;
+  }
+  console.log("Your folder has unsaved local changes ahead \u2014 run: goodfolder save");
+}
+
+// src/restore.ts
+init_cli_error();
+init_git();
+init_api();
+init_repo_setup();
+async function cmdRestore(folder, seqArg, opts = {}) {
+  const { cfg } = await requireConnection(folder);
+  const seq = Number(seqArg);
+  if (!Number.isInteger(seq)) {
+    throw new CliError("\u2717 Use a save number from the timeline. Try: goodfolder log", 1);
+  }
+  const saves = await listSaves(cfg);
+  const target = saves.find((s) => s.seq === seq);
+  if (!target) {
+    throw new CliError(`\u2717 No save #${seq} in your timeline. Try: goodfolder log`, 1);
+  }
+  const haveObjects = gitOk(folder, ["cat-file", "-e", `${target.commit_sha}^{commit}`]);
+  if (!haveObjects) {
+    console.log("That save lives deeper than this device keeps copies \u2014 downloading its contents\u2026");
+    const fetchRes = fetchHistory(folder, cfg);
+    if (fetchRes.code !== 0 || !gitOk(folder, ["cat-file", "-e", `${target.commit_sha}^{commit}`])) {
+      throw new CliError("\u2717 Could not download that save's contents. Check your connection.", 1);
+    }
+  }
+  if (!gitOk(folder, ["restore", "--source", target.commit_sha, "--worktree", "--staged", "."])) {
+    throw new CliError("\u2717 Could not apply that save.", 1);
+  }
+  const sourceFiles = new Set(
+    git(folder, ["ls-tree", "-r", "--name-only", target.commit_sha]).stdout.split("\n").filter(Boolean)
+  );
+  const current = git(folder, ["ls-files"]).stdout.split("\n").filter(Boolean);
+  const extras = current.filter((f) => !sourceFiles.has(f));
+  for (const f of extras) git(folder, ["rm", "-q", "--cached", f]);
+  if (!gitOk(folder, ["commit", "-m", `Restore of save #${seq}`])) {
+    console.log("Already identical to that save \u2014 nothing to do.");
+    return;
+  }
+  const sha = git(folder, ["rev-parse", "HEAD"]).stdout.trim();
+  const push = pushCurrentHistory(folder, cfg);
+  if (push.code !== 0) {
+    throw new CliError("\u2717 Restored locally but could not upload. Run: goodfolder sync", 1);
+  }
+  try {
+    await recordSave(cfg, {
+      label: `Restored save #${seq}: ${target.label}`,
+      changedPaths: [],
+      commitSha: sha,
+      harness: opts.harness ?? null
+    });
+  } catch {
+  }
+  console.log(`\u2713 Your folder now matches save #${seq}.`);
+  console.log("  Changed your mind? Restore the newest number to undo this.");
+}
+
+// src/undo.ts
+init_src();
+init_cli_error();
+import { createInterface } from "node:readline/promises";
+init_git();
+init_api();
+init_repo_setup();
+var NOISE_FILES2 = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db", "desktop.ini"]);
+function detectAgentRun(saves) {
+  const top = saves[0]?.harness;
+  if (!top || saves.length < 2) return 1;
+  let n = 1;
+  while (n < saves.length - 1 && saves[n]?.harness === top) n++;
+  return n;
+}
+function parseNameStatus(out) {
+  let added = 0;
+  let changed = 0;
+  let removed = 0;
+  const paths = [];
+  for (const line of out.split("\n")) {
+    if (!line.trim()) continue;
+    const tab = line.lastIndexOf("	");
+    if (tab < 0) continue;
+    const code = line[0];
+    paths.push(line.slice(tab + 1));
+    if (code === "A") added++;
+    else if (code === "D") removed++;
+    else changed++;
+  }
+  return { paths, counts: { added, changed, removed } };
+}
+function summarizeReverseEffect(nameStatus) {
+  let back = 0;
+  let remove = 0;
+  let roll = 0;
+  for (const line of nameStatus.split("\n")) {
+    if (!line.trim()) continue;
+    const code = line[0];
+    if (code === "A") remove++;
+    else if (code === "D") back++;
+    else roll++;
+  }
+  const parts = [];
+  if (back) parts.push(`brings back ${back} file${back === 1 ? "" : "s"}`);
+  if (remove) {
+    parts.push(
+      `removes ${remove} file${remove === 1 ? "" : "s"} that ${remove === 1 ? "was" : "were"} added`
+    );
+  }
+  if (roll) parts.push(`rolls back ${roll} change${roll === 1 ? "" : "s"}`);
+  if (parts.length === 0) {
+    return "It changes nothing \u2014 your folder already matches that state.";
+  }
+  if (parts.length === 1) return `It ${parts[0]}.`;
+  return `It ${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}.`;
+}
+var clip = (s, n = 90) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+function buildUndoLabel(scope, harnessName) {
+  if (scope.length === 1) {
+    return clip(`Undid save #${scope[0].seq} \u2014 ${scope[0].label}`, 110);
+  }
+  const who = harnessName ? ` from ${harnessName}` : "";
+  return `Undid ${scope.length} saves${who} (#${scope[scope.length - 1].seq}\u2013#${scope[0].seq})`;
+}
+function buildPreview(input) {
+  const { scope, harnessName, effect, runLen } = input;
+  const lines = [];
+  if (scope.length === 1) {
+    const who = harnessName ? `${harnessName}'s last save` : "the last save";
+    lines.push(
+      `This undoes ${who} (#${scope[0].seq})${scope[0].label ? `: \u201C${clip(scope[0].label)}\u201D` : ""}.`
+    );
+  } else {
+    const who = harnessName ? ` from ${harnessName}` : "";
+    lines.push(
+      `This undoes the ${scope.length} most recent saves${who} (#${scope[scope.length - 1].seq} through #${scope[0].seq}).`
+    );
+  }
+  lines.push(effect);
+  lines.push(
+    scope.length === 1 ? "The undone save stays visible in your timeline." : "The undone saves stay visible in your timeline."
+  );
+  if (scope.length === 1 && runLen >= 2) {
+    lines.push("");
+    lines.push(
+      `The ${runLen} most recent saves are all ${harnessName ? `from ${harnessName}` : "part of one run"}.`
+    );
+  }
+  return lines.join("\n");
+}
+function meaningfulUnsaved(folder) {
+  const out = git(folder, ["status", "--porcelain", "-uall"]).stdout;
+  const paths = [];
+  for (const line of out.split("\n")) {
+    if (!line.trim()) continue;
+    const path = line.slice(3).split(" -> ").pop() ?? "";
+    const base = path.split(/[\\/]/).pop() ?? "";
+    if (!NOISE_FILES2.has(base)) paths.push(path);
+  }
+  return paths;
+}
+function ensureObjects(folder, cfg, sha) {
+  if (gitOk(folder, ["cat-file", "-e", `${sha}^{commit}`])) return;
+  console.log("Getting that save's contents\u2026");
+  fetchHistory(folder, cfg);
+  if (!gitOk(folder, ["cat-file", "-e", `${sha}^{commit}`])) {
+    throw new CliError(
+      "\u2717 Could not download that save's contents. Check your connection.",
+      1
+    );
+  }
+}
+async function confirm(question, choices, fallback) {
+  if (!process.stdin.isTTY) return fallback;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${question} `)).trim().toLowerCase();
+    return choices.find((c) => c === answer) ?? fallback;
+  } finally {
+    rl.close();
+  }
+}
+async function cmdUndo(folder, opts = {}) {
+  const { cfg } = await requireConnection(folder);
+  const saves = await listSaves(cfg);
+  if (saves.length === 0) {
+    console.log("No saves yet \u2014 there's nothing to undo.");
+    return;
+  }
+  if (saves.length === 1) {
+    console.log("This is your only save. There's no earlier state to go back to.");
+    console.log("You can still look through it with: goodfolder log");
+    return;
+  }
+  const last = saves[0];
+  if (!last.commit_sha) {
+    throw new CliError("\u2717 Could not read your timeline. Try again in a moment.", 1);
+  }
+  const harnessName = friendlyHarness(last.harness ?? null);
+  const runLen = detectAgentRun(saves);
+  const wantRun = opts.session === true;
+  if (wantRun && runLen < 2) {
+    console.log("The last save isn't part of a same-agent run \u2014 undoing just that one.");
+  }
+  const effectiveLen = wantRun && runLen >= 2 ? runLen : 1;
+  const scope = saves.slice(0, effectiveLen);
+  const target = saves[effectiveLen];
+  const effect = summarizeReverseEffect(
+    git(folder, ["diff", "--name-status", target.commit_sha, last.commit_sha]).stdout
+  );
+  const preview = buildPreview({ scope, harnessName, effect, runLen });
+  console.log(preview);
+  if (opts.previewOnly) {
+    console.log("");
+    console.log("Run this again to confirm the undo.");
+    return;
+  }
+  let proceedScope = scope;
+  let proceedTarget = target;
+  if (!opts.yes && !wantRun) {
+    if (!process.stdin.isTTY) {
+      console.log("");
+      console.log(
+        runLen >= 2 ? "Re-run with --yes to undo this save, or --session to undo the whole run." : "Re-run with --yes to undo this save."
+      );
+      return;
+    }
+    if (runLen >= 2) {
+      const pick = await confirm(
+        `Undo one save (o), the whole run of ${runLen} (r), or cancel (c)?`,
+        ["o", "r", "c"],
+        "c"
+      );
+      if (pick === "c") {
+        console.log("Nothing changed.");
+        return;
+      }
+      if (pick === "r") {
+        proceedScope = saves.slice(0, runLen);
+        proceedTarget = saves[runLen];
+        console.log(`Undoing ${runLen} saves (#${proceedScope[proceedScope.length - 1].seq}\u2013#${proceedScope[0].seq}).`);
+      }
+    } else {
+      const pick = await confirm("Undo this save? (y/N)", ["y", "n"], "n");
+      if (pick !== "y") {
+        console.log("Nothing changed.");
+        return;
+      }
+    }
+  }
+  const unsaved = meaningfulUnsaved(folder);
+  if (unsaved.length > 0) {
+    throw new CliError(
+      `\u2717 You have unsaved changes (${unsaved.slice(0, 3).join(", ")}${unsaved.length > 3 ? `, +${unsaved.length - 3} more` : ""}).
+  Save them first:  goodfolder save
+  Then run:  goodfolder undo`,
+      1
+    );
+  }
+  ensureObjects(folder, cfg, proceedTarget.commit_sha);
+  if (!gitOk(folder, ["restore", "--source", proceedTarget.commit_sha, "--worktree", "--staged", "."])) {
+    throw new CliError("\u2717 Could not undo right now \u2014 your folder is untouched.", 1);
+  }
+  const targetFiles = new Set(
+    git(folder, ["ls-tree", "-r", "--name-only", proceedTarget.commit_sha]).stdout.split("\n").filter(Boolean)
+  );
+  for (const f of git(folder, ["ls-files"]).stdout.split("\n").filter(Boolean)) {
+    if (!targetFiles.has(f)) git(folder, ["rm", "-q", "--cached", f]);
+  }
+  const label = buildUndoLabel(proceedScope, harnessName);
+  if (!gitOk(folder, ["commit", "-m", label])) {
+    console.log("Your folder already matches that state \u2014 nothing to undo.");
+    return;
+  }
+  const sha = git(folder, ["rev-parse", "HEAD"]).stdout.trim();
+  const push = pushCurrentHistory(folder, cfg);
+  if (push.code !== 0) {
+    if (/non-fast-forward|rejected/i.test(push.stderr)) {
+      throw new CliError(
+        "\u2717 Another device saved first. Run:  goodfolder sync\n  then undo again.",
+        1
+      );
+    }
+    throw new CliError("\u2717 Undone here, but the upload failed. Run:  goodfolder sync", 1);
+  }
+  const changed = parseNameStatus(
+    git(folder, ["diff", "--name-status", "HEAD^", "HEAD"]).stdout
+  );
+  try {
+    await recordSave(cfg, {
+      label,
+      changedPaths: changed.paths,
+      commitSha: sha,
+      counts: changed.counts,
+      topPaths: changed.paths.slice(0, 8),
+      harness: opts.harness ?? null
+    });
+  } catch {
+  }
+  console.log(
+    proceedScope.length === 1 ? `\u2713 Undone. Your folder is back to how it was before save #${proceedScope[0].seq}.` : `\u2713 Undone. Your folder is back to how it was before those ${proceedScope.length} saves.`
+  );
+  console.log(`  Changed your mind? Run goodfolder undo again, or:  goodfolder restore ${proceedTarget.seq}`);
+}
+
+// src/log.ts
+init_src();
+init_cli_error();
+init_api();
+function countSummary(added = 0, changed = 0, removed = 0) {
+  const parts = [];
+  if (added > 0) parts.push(`${added} added`);
+  if (changed > 0) parts.push(`${changed} changed`);
+  if (removed > 0) parts.push(`${removed} removed`);
+  return parts.join(" \xB7 ");
+}
+async function cmdLog(folder) {
+  const { cfg } = await requireConnection(folder);
+  const saves = await listSaves(cfg);
+  if (saves.length === 0) {
+    console.log("No saves yet. Your first one is one command away: goodfolder save");
+    return;
+  }
+  console.log("\nTimeline (newest first):\n");
+  for (const s of saves) {
+    const when = new Date(s.createdAt).toLocaleString(void 0, {
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+    const tag = s.collision && s.collision !== "none" ? `  [needs attention]` : "";
+    console.log(`  #${String(s.seq).padStart(3)}  ${when}  ${s.label}${tag}`);
+    const bits = [];
+    const by = s.harness ? friendlyHarness(s.harness) : null;
+    if (by) bits.push(`saved by ${by}`);
+    else if (s.deviceName) bits.push(`saved on ${s.deviceName}`);
+    const counts = countSummary(
+      Number(s.addedCount ?? 0),
+      Number(s.changedCount ?? 0),
+      Number(s.removedCount ?? 0)
+    );
+    if (counts) bits.push(counts);
+    const paths = Array.isArray(s.topPaths) ? s.topPaths : [];
+    if (paths.length > 0) {
+      const shown = paths.slice(0, 3).join(", ");
+      bits.push(paths.length > 3 ? `${shown} +${paths.length - 3} more` : shown);
+    }
+    if (bits.length > 0) console.log(`        ${bits.join(" \xB7 ")}`);
+  }
+  console.log(`
+${saves.length} save${saves.length === 1 ? "" : "s"}. Restore with: goodfolder restore <number>`);
+}
+
+// src/create.ts
+init_config();
+init_cli_error();
+init_git();
+init_repo_setup();
+init_api();
+init_auth();
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join7 } from "node:path";
+function defaultParent(cwd) {
+  const home = homedir2();
+  const landing = ["Desktop", "Documents", "Downloads"].map(
+    (d) => join7(home, d)
+  );
+  if (cwd === home || landing.includes(cwd)) return join7(home, "Desktop");
+  return cwd;
+}
+function sanitizeName(name) {
+  const cleaned = name.replace(/[/\\:]+/g, "-").trim().replace(/\s+/g, " ");
+  return cleaned || "My Folder";
+}
+function dedupePath(base) {
+  if (!existsSync3(base)) return base;
+  for (let i = 2; i < 100; i++) {
+    const candidate = `${base}-${i}`;
+    if (!existsSync3(candidate)) return candidate;
+  }
+  throw new CliError(`\u2717 Too many folders named "${base}" already exist.`);
+}
+async function cmdCreate(name, opts) {
+  const clean = sanitizeName(name);
+  const parent = opts.dest ?? defaultParent(process.cwd());
+  if (!existsSync3(parent)) {
+    throw new CliError(`\u2717 Destination folder does not exist: ${parent}`);
+  }
+  const dir = dedupePath(join7(parent, clean));
+  mkdirSync3(dir, { recursive: true });
+  if (!gitOk(dir, ["init", "-b", "main"])) {
+    throw new CliError("\u2717 Could not set up the folder internally.");
+  }
+  const gitDir = findGitDir(dir);
+  const accountToken = await ensureAccount(DEFAULT_API_URL);
+  const boot = await createProject(
+    DEFAULT_API_URL,
+    clean,
+    accountToken,
+    `${clean} \xB7 ${await friendlyDeviceName()}`
+  );
+  if (!boot.projectId || !boot.token) {
+    throw new CliError(
+      "\u2717 Could not create the project on GoodFolder. Try again shortly."
+    );
+  }
+  const cfg = {
+    projectId: boot.projectId,
+    apiUrl: DEFAULT_API_URL,
+    token: boot.token,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (boot.expiresAt) cfg.tokenExpiresAt = boot.expiresAt;
+  bindRepo(dir, gitDir, cfg);
+  console.log(`\u2713 Created "${clean}" at ${dir}`);
+  console.log("  Empty and ready. Saves stay protected while this account has access and capacity.");
+  return { path: dir, projectId: cfg.projectId };
+}
+
+// src/clone.ts
+init_config();
+init_cli_error();
+init_git();
+init_repo_setup();
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join8 } from "node:path";
+init_api();
+init_auth();
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function cmdClone(query, opts) {
+  const accountToken = await ensureAccount(DEFAULT_API_URL);
+  const projects = await listProjects(DEFAULT_API_URL, accountToken);
+  let project;
+  if (UUID_RE.test(query)) {
+    project = projects.find((p) => p.id === query);
+  } else {
+    const matches = projects.filter(
+      (p) => p.name.toLowerCase() === query.toLowerCase()
+    );
+    if (matches.length > 1) {
+      throw new CliError(
+        `\u2717 Several folders share that name:
+` + matches.map((m) => `  \u2022 ${m.name} (${m.id})`).join("\n") + `
+Open by id instead.`
+      );
+    }
+    project = matches[0];
+  }
+  if (!project) {
+    const available = projects.length === 0 ? "No GoodFolders exist yet." : `Available: ${projects.slice(0, 10).map((p) => `"${p.name}"`).join(", ")}`;
+    throw new CliError(`\u2717 No GoodFolder called "${query}". ${available}`);
+  }
+  console.log(`Getting "${project.name}" ready on this computer\u2026`);
+  const minted = await mintProjectToken(
+    DEFAULT_API_URL,
+    project.id,
+    accountToken,
+    `${project.name} \xB7 ${await friendlyDeviceName()}`
+  );
+  const parent = opts.dest ?? defaultParent(process.cwd());
+  if (!existsSync4(parent)) {
+    throw new CliError(`\u2717 Destination folder does not exist: ${parent}`);
+  }
+  const dir = dedupePath(join8(parent, sanitizeName(project.name)));
+  console.log(`Downloading "${project.name}"\u2026`);
+  const cfg = {
+    projectId: project.id,
+    apiUrl: DEFAULT_API_URL,
+    token: minted.token,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (minted.expiresAt) cfg.tokenExpiresAt = minted.expiresAt;
+  const clone = git(parent, ["clone", "--origin", GF_REMOTE, transportUrl(cfg), dir], void 0, transportEnv(cfg));
+  if (clone.code !== 0 && !/empty repository/i.test(clone.stderr)) {
+    throw new CliError(`\u2717 Download failed: ${clone.stderr.trim()}`);
+  }
+  const gitDir = findGitDir(dir);
+  bindRepo(dir, gitDir, cfg);
+  console.log(
+    /empty repository/i.test(clone.stderr) ? `\u2713 Connected to the empty "${project.name}" at ${dir}` : `\u2713 "${project.name}" is ready at ${dir} \u2014 fully up to date.`
+  );
+  return { path: dir, projectId: project.id };
+}
+
+// src/index.ts
+init_auth();
+
+// src/protect.ts
+init_config();
+init_cli_error();
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join9 } from "node:path";
+init_skip();
+async function cmdSkipped(folder) {
+  const { cfg } = await requireConnection(folder);
+  const alsoProtect = cfg.alsoProtect ?? [];
+  const groups = skippedGroups(folder, alsoProtect);
+  if (groups.length === 0 && alsoProtect.length === 0) {
+    console.log("Everything in this folder is protected.");
+    return;
+  }
+  if (groups.length > 0) {
+    console.log("Not protected, and why:\n");
+    for (const group of groups) {
+      console.log(`  ${group.label}`);
+      for (const path of group.paths.slice(0, 12)) {
+        console.log(`    \u2022 ${path}`);
+      }
+      const rest = group.paths.length - 12;
+      if (rest > 0) console.log(`    \u2026and ${rest.toLocaleString("en-US")} more`);
+      console.log("");
+    }
+    console.log("To protect one of them anyway:");
+    console.log("   goodfolder protect <name>");
+  }
+  if (alsoProtect.length > 0) {
+    console.log("\nProtected because you asked for it:");
+    for (const path of alsoProtect) console.log(`  \u2022 ${path}`);
+  }
+}
+async function cmdProtect(folder, paths) {
+  const { gitDir, cfg } = await requireConnection(folder);
+  if (paths.length === 0) {
+    throw new CliError(
+      "Which one? Run goodfolder skipped to see what is being left out.",
+      1
+    );
+  }
+  const already = new Set(cfg.alsoProtect ?? []);
+  const added = [];
+  for (const raw of paths) {
+    const path = raw.replace(/^\.\//, "").replace(/\/+$/, "");
+    if (!existsSync5(join9(folder, path))) {
+      throw new CliError(`\u2717 There is nothing called "${path}" in this folder.`, 1);
+    }
+    if (already.has(path)) {
+      console.log(`Already protected: ${path}`);
+      continue;
+    }
+    already.add(path);
+    added.push(path);
+  }
+  if (added.length === 0) return;
+  cfg.alsoProtect = [...already].sort();
+  saveConfig(gitDir, cfg);
+  for (const path of added) console.log(`\u2713 ${path} will be protected from now on.`);
+  const secretish = added.filter((p) => /(^|\/)\.env($|\.)|\.pem$|(^|\/)id_(rsa|dsa|ecdsa|ed25519)$/.test(p));
+  if (secretish.length > 0) {
+    console.log(
+      "\n  Note: this file looks like it holds passwords or keys. It will be"
+    );
+    console.log("  uploaded and kept in this folder's history from the next save on.");
+  }
+  console.log("\nRun goodfolder save to include it.");
+}
+
+// src/rename.ts
+init_auth();
+init_api();
+init_cli_error();
+async function cmdRename(folder, name) {
+  if (name.length === 0 || name.trim().length === 0) {
+    throw new CliError("\u2717 Enter a name for this folder.");
+  }
+  const { cfg } = await requireConnection(folder);
+  const accountToken = await ensureAccount(cfg.apiUrl);
+  const result = await accountCall(
+    cfg.apiUrl,
+    accountToken,
+    "PATCH",
+    `/api/projects/${cfg.projectId}`,
+    { name }
+  );
+  console.log(`\u2713 Renamed this GoodFolder to "${result.name}".`);
+}
+
+// src/index.ts
+var HELP = `goodfolder \u2014 keep your folder safe
+
+  goodfolder create <name>        Start a brand-new GoodFolder on this machine
+  goodfolder clone <name>         Download an existing GoodFolder to here
+  goodfolder connect [folder]     Connect an existing folder (first time)
+  goodfolder rename <name>        Change the folder name shown in GoodFolder
+  goodfolder save [-m note]       Save a point you can come back to
+  goodfolder sync                 Bring in changes from your other devices
+  goodfolder log                  Show the timeline
+  goodfolder undo                 Undo the last save (shows what changes first)
+  goodfolder restore <number>     Go back to an earlier save
+  goodfolder skipped              Show what isn't being protected, and why
+  goodfolder protect <name>       Protect something that is being left out
+  goodfolder login                Approve this computer (one-time setup)
+  goodfolder devices              Show the computers approved on your account
+  goodfolder devices forget <n>   Take an approval back
+
+Set GF_API_URL to use a GoodFolder server you run yourself. Folders remember
+the server they were set up against, so this only affects new ones.
+`;
+async function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0];
+  const flags = {};
+  const bools = /* @__PURE__ */ new Set();
+  const positional = [];
+  for (let i = 1; i < argv.length; i++) {
+    if (argv[i] === "-m" || argv[i] === "--message") flags.message = argv[++i] ?? "";
+    else if (argv[i] === "--dest") flags.dest = argv[++i] ?? "";
+    else if (argv[i] === "-y" || argv[i] === "--yes") bools.add("yes");
+    else if (argv[i] === "--session") bools.add("session");
+    else positional.push(argv[i]);
+  }
+  const folder = process.cwd();
+  switch (cmd) {
+    case "create":
+      if (!positional[0]) {
+        console.error('What should it be called? e.g.: goodfolder create "Trip Planning"');
+        process.exit(1);
+      }
+      await cmdCreate(positional[0], { dest: flags.dest });
+      break;
+    case "clone":
+      if (!positional[0]) {
+        console.error('Which GoodFolder? e.g.: goodfolder clone "Recipe Book"');
+        process.exit(1);
+      }
+      await cmdClone(positional[0], { dest: flags.dest });
+      break;
+    case "connect":
+      await cmdConnect(resolve2(positional[0] ?? folder));
+      break;
+    case "skipped":
+      await cmdSkipped(folder);
+      break;
+    case "protect":
+      await cmdProtect(folder, positional);
+      break;
+    case "login":
+      await cmdLogin();
+      break;
+    case "devices":
+      await cmdDevices(positional[0], positional[1]);
+      break;
+    case "save":
+      await cmdSave(folder, (await requireConnection(folder)).cfg, flags);
+      break;
+    case "sync":
+      await cmdSync(folder);
+      break;
+    case "rename":
+      if (!positional[0]) {
+        console.error('What should this folder be called? e.g.: goodfolder rename "Trip Planning"');
+        process.exit(1);
+      }
+      await cmdRename(folder, positional[0]);
+      break;
+    case "log":
+      await cmdLog(folder);
+      break;
+    case "restore":
+      if (!positional[0]) {
+        console.error("Which save? Pick a number from: goodfolder log");
+        process.exit(1);
+      }
+      await cmdRestore(folder, positional[0]);
+      break;
+    case "undo":
+      await cmdUndo(folder, { yes: bools.has("yes"), session: bools.has("session") });
+      break;
+    default:
+      console.log(HELP);
+      if (cmd !== void 0 && cmd !== "help" && cmd !== "--help") {
+        console.error(`Unknown command: ${cmd}`);
+        process.exit(1);
+      }
+  }
+}
+main().catch((e) => {
+  const err = e;
+  console.error(err.message ?? "Something went wrong.");
+  process.exit(err.exitCode ?? 1);
+});