pushary 1.8.0

package/dist/bin/pushary-clean.js

@@ -0,0 +1,1300 @@
+#!/usr/bin/env node
+import {
+  PUSHARY_SKILL_NAME,
+  PUSHARY_SKILL_SOURCE,
+  createGuards,
+  withoutPusharyCursorHooks
+} from "../chunk-KVQBWI5T.js";
+import {
+  HERMES_PIP_PACKAGE,
+  planFxRemoval,
+  readHermesStatus,
+  removeInstructionBlock,
+  resolveHermesPython,
+  runHermesConfigScript,
+  shortenHome,
+  unregisterPluginLocation,
+  vscodeSettingsTargets
+} from "../chunk-MDEPU45E.js";
+import "../chunk-SLFABHW3.js";
+import {
+  OPENCODE_PLUGIN_SIBLING,
+  OPENCODE_PLUGIN_SIBLING_CONTENTS,
+  hasForeignPlugins,
+  isOpenCodePluginOurs,
+  openCodeConfigDir,
+  openCodeConfigFile,
+  openCodeInstructionsFile,
+  openCodePluginDir,
+  openCodePluginFile,
+  removeOpenCodeMcpServer
+} from "../chunk-AHV4LNB5.js";
+import {
+  compatibleConfigFile,
+  compatibleInstructionsFile,
+  compatibleMcpFile,
+  compatiblePermissionRuleFile,
+  removeCompatibleHooks,
+  removeCompatibleMcpServer
+} from "../chunk-J5TIV3J6.js";
+import {
+  isClaudeMcpSnapshot,
+  removeClaudeMcpServers,
+  removePusharySettings,
+  removePusharyToolPermissions,
+  restoreClaudeMcpServer
+} from "../chunk-AXPCESYO.js";
+import {
+  hookOwnerOf,
+  isHookTakeoverReceipt,
+  restoreHookTakeover,
+  restoreMcpServer
+} from "../chunk-EYK3GSRH.js";
+import "../chunk-ZVSKMPBZ.js";
+import {
+  liveBridgeProbe,
+  resolveBridgeStub
+} from "../chunk-C2WCPBF7.js";
+import "../chunk-6J2JC2RT.js";
+import {
+  disableDaemonService
+} from "../chunk-WE2J62NC.js";
+import {
+  removeGeminiSettings
+} from "../chunk-3EVPNIBE.js";
+import "../chunk-OKXS7WDZ.js";
+import "../chunk-XHKBHWLX.js";
+import "../chunk-CULUZTWQ.js";
+import "../chunk-N6IOSZOE.js";
+import "../chunk-EPCXUP3P.js";
+import "../chunk-NGDD6TXY.js";
+import "../chunk-CVQYGMSR.js";
+import "../chunk-POFBE6ZY.js";
+import {
+  ansiPainter,
+  useColor
+} from "../chunk-U4TMAANR.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-HZVVNGEW.js";
+import {
+  rejectUnknownFlags
+} from "../chunk-GMXKITVA.js";
+import {
+  CANDIDATE_RCS,
+  isDisabledExport,
+  removeClaudeAlias
+} from "../chunk-P7WQEVWA.js";
+import "../chunk-M5ICYGHT.js";
+import "../chunk-2ABTSGFT.js";
+import "../chunk-2OY3ZZ5N.js";
+import "../chunk-LXQ5FBBD.js";
+import "../chunk-7QLSKOSU.js";
+import {
+  EXIT
+} from "../chunk-KZERVKTD.js";
+import "../chunk-DB3ONZB4.js";
+import {
+  bridgeAgentKey,
+  claudeJson,
+  claudeMcpReceipt,
+  claudeSettings,
+  claudeSettingsLocal,
+  claudeSkillDir,
+  cleanNpmEnv,
+  codexAgentsMd,
+  codexConfigToml,
+  codexHookPositions,
+  codexHooksJson,
+  codexSkillDir,
+  cursorPluginDir,
+  cursorUserHooks,
+  cursorUserMcp,
+  fxAgentsMd,
+  fxConfigDir,
+  fxMcpProfile,
+  fxQuestionRuleReceipt,
+  fxSettings,
+  geminiMd,
+  geminiSettings,
+  globalPackageState,
+  hermesConfig,
+  hermesConfigReceipt,
+  hookTakeoverReceipt,
+  npmIsOnPath,
+  pusharyDir,
+  readCodexMcpAuth,
+  readGlobalFolder,
+  readGlobalPrefix,
+  removeCodexHookTrust,
+  removeCodexHooks,
+  restoreCodexHookTrust,
+  vscodePluginDir,
+  vscodePluginMcp
+} from "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import {
+  CLI_PACKAGE_NAMES,
+  HOOK_COMPATIBLE_PROFILES,
+  HOOK_LOCATOR_BINARY,
+  SUPPORT_DISCORD,
+  SUPPORT_EMAIL,
+  globalPackageFolder,
+  globalPackagesToUninstall,
+  globalRootFor,
+  isValidApiKey,
+  redactSecrets
+} from "../chunk-NQTHFF4W.js";
+
+// bin/pushary-clean.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4, copyFileSync, readdirSync as readdirSync4 } from "fs";
+import { dirname, join as join6 } from "path";
+import { homedir as homedir5, tmpdir } from "os";
+import { confirm } from "@inquirer/prompts";
+import { parse as parseTOML, stringify as stringifyTOML } from "smol-toml";
+
+// src/cli/mac-leftovers.ts
+import { execSync, execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var MAC_APP_BUNDLE = "/Applications/Pushary.app";
+var installedPusharyBundles = (home = homedir()) => [MAC_APP_BUNDLE, join(home, "Applications", "Pushary.app")];
+var LSREGISTER = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
+var TEST_DEFAULTS_PREFIXES = [
+  "com.pushary.mac.tests.",
+  "com.pushary.tests.",
+  "pushary.tests.",
+  "pushary.quiet-mode-test.",
+  "pushary-optin-"
+];
+var isTestDefaultsDomain = (domain) => TEST_DEFAULTS_PREFIXES.some((prefix) => domain.startsWith(prefix));
+var leakedTestDefaultsDomains = () => {
+  try {
+    return execSync("defaults domains", { encoding: "utf-8", timeout: 2e4 }).split(",").map((entry) => entry.trim()).filter(isTestDefaultsDomain).filter(liveMacStatePresence.defaultsDomain);
+  } catch {
+    return [];
+  }
+};
+var BUNDLE_NAME = "Pushary.app";
+var DUMP_PATH_LINE = /^\s*path:\s+(.+?)(?: \(0x[0-9a-f]+\))?\s*$/;
+var bundlesInLaunchServicesDump = (dump) => {
+  const found = /* @__PURE__ */ new Set();
+  for (const line of dump.split("\n")) {
+    const path = DUMP_PATH_LINE.exec(line)?.[1];
+    const bundle = path?.indexOf(`/${BUNDLE_NAME}`);
+    if (path === void 0 || bundle === void 0 || bundle === -1) continue;
+    found.add(path.slice(0, bundle + BUNDLE_NAME.length + 1));
+  }
+  return [...found];
+};
+var registeredPusharyBundles = (installed = installedPusharyBundles()) => {
+  if (!existsSync(LSREGISTER)) return [];
+  try {
+    const dump = execSync(`${LSREGISTER} -dump`, {
+      encoding: "utf-8",
+      timeout: 6e4,
+      maxBuffer: 256 * 1024 * 1024
+    });
+    return bundlesInLaunchServicesDump(dump).filter((path) => !installed.includes(path));
+  } catch {
+    return [];
+  }
+};
+var MAC_KEYCHAIN_SERVICE = "com.pushary.app.mac";
+var MAC_KEYCHAIN_ACCOUNTS = [
+  "pushary.site-api-key",
+  "pushary.site-id",
+  "clerk.device-token",
+  "clerk.session-id",
+  "clerkDeviceToken",
+  "cachedClient",
+  "cachedClientServerDate",
+  "cachedEnvironment"
+];
+var MAC_DEFAULTS_DOMAINS = ["com.pushary.app", "pushary-bridge", "pushary.render"];
+var PRESENCE_PROBE_TIMEOUT_MS = 1e4;
+var commandSucceeds = (file, args) => {
+  try {
+    execFileSync(file, args, { stdio: "ignore", timeout: PRESENCE_PROBE_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var KEYCHAIN_ITEM_NOT_FOUND = 44;
+var keychainItemMayExist = (service, account) => {
+  try {
+    execFileSync("security", ["find-generic-password", "-s", service, "-a", account], { stdio: "ignore" });
+    return true;
+  } catch (error) {
+    return !(error instanceof Error && "status" in error && error.status === KEYCHAIN_ITEM_NOT_FOUND);
+  }
+};
+var liveMacStatePresence = {
+  keychainItem: keychainItemMayExist,
+  defaultsDomain: (domain) => commandSucceeds("defaults", ["read", domain])
+};
+var macLibraryState = (home = homedir()) => [
+  join(home, "Library", "Application Support", "Pushary"),
+  join(home, "Library", "Caches", "com.pushary.app"),
+  join(home, "Library", "Caches", "com.pushary.app.sparkle"),
+  join(home, "Library", "Saved Application State", "com.pushary.app.savedState"),
+  join(home, "Library", "Caches", "pushary-bridge"),
+  join(home, "Library", "HTTPStorages", "com.pushary.app"),
+  join(home, "Library", "HTTPStorages", "com.pushary.app.binarycookies"),
+  join(home, "Library", "HTTPStorages", "pushary-bridge")
+];
+var DUMP_SERVICE_LINE = /^\s*"svce"<blob>="(.+)"\s*$/;
+var pusharyKeychainServices = (dump) => {
+  const found = /* @__PURE__ */ new Set();
+  for (const line of dump.split("\n")) {
+    const service = DUMP_SERVICE_LINE.exec(line)?.[1];
+    if (service?.startsWith(MAC_KEYCHAIN_SERVICE)) found.add(service);
+  }
+  return [...found];
+};
+var storedPusharyKeychainServices = () => {
+  const dump = execFileSync("security", ["dump-keychain"], {
+    encoding: "utf-8",
+    timeout: 3e4,
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const stored = pusharyKeychainServices(dump);
+  return stored.includes(MAC_KEYCHAIN_SERVICE) ? stored : [MAC_KEYCHAIN_SERVICE, ...stored];
+};
+var MAC_APP_BUNDLE_ID = "com.pushary.app";
+var runningMacAppPIDs = () => {
+  if (process.platform !== "darwin") return [];
+  try {
+    return execSync('pgrep -f "Pushary.app/Contents/MacOS/Pushary"', {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isInteger(pid) && pid > 0);
+  } catch {
+    return [];
+  }
+};
+var waitForMacAppExit = (attempts = 20, everyMs = 250) => {
+  const idle = new Int32Array(new SharedArrayBuffer(4));
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    if (runningMacAppPIDs().length === 0) return true;
+    Atomics.wait(idle, 0, 0, everyMs);
+  }
+  return runningMacAppPIDs().length === 0;
+};
+
+// src/cli/clean-mac.ts
+import { existsSync as existsSync2 } from "fs";
+var removeDeveloperLeftovers = (guards2, domains, bundles) => {
+  let removed = 0;
+  for (const domain of domains) {
+    try {
+      guards2.execFile("defaults", ["delete", domain], { stdio: "ignore", timeout: 1e4 }, `delete preferences ${domain}`);
+      removed++;
+    } catch {
+      continue;
+    }
+  }
+  for (const bundle of bundles) {
+    try {
+      guards2.execFile(LSREGISTER, ["-u", bundle], { stdio: "ignore", timeout: 2e4 }, `unregister ${bundle}`);
+      removed++;
+    } catch {
+      continue;
+    }
+  }
+  return removed;
+};
+var removeMacAppState = (guards2, readServices, home, present) => {
+  let removed = 0;
+  let failed = 0;
+  let services;
+  try {
+    services = readServices();
+  } catch {
+    return { removed, failed: 1 };
+  }
+  for (const service of services) {
+    for (const account of MAC_KEYCHAIN_ACCOUNTS.filter((account2) => present.keychainItem(service, account2))) {
+      try {
+        guards2.execFile(
+          "security",
+          ["delete-generic-password", "-s", service, "-a", account],
+          { stdio: "ignore" },
+          `remove keychain item ${service} (${account})`
+        );
+        removed++;
+      } catch (error) {
+        if (!(error instanceof Error && "status" in error && error.status === 44)) failed++;
+      }
+    }
+  }
+  for (const domain of MAC_DEFAULTS_DOMAINS.filter(present.defaultsDomain)) {
+    try {
+      guards2.execFile("defaults", ["delete", domain], { stdio: "ignore", timeout: 1e4 }, `delete preferences ${domain}`);
+      removed++;
+    } catch {
+      continue;
+    }
+  }
+  for (const path of macLibraryState(home)) {
+    if (!existsSync2(path)) continue;
+    guards2.remove(path, { force: true });
+    removed++;
+  }
+  return { removed, failed };
+};
+var quitMacApp = (guards2, state) => {
+  if (state.platform !== "darwin" || state.running().length === 0) return "not-running";
+  try {
+    guards2.execFile(
+      "osascript",
+      ["-e", `tell application id "${MAC_APP_BUNDLE_ID}" to quit`],
+      { stdio: "ignore", timeout: 3e4 },
+      "quit Pushary"
+    );
+  } catch {
+  }
+  return state.dryRun || state.waitForExit() ? "quit" : "running";
+};
+
+// src/cli/editor-extension.ts
+import { existsSync as existsSync3, readFileSync, readdirSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var EDITOR_EXTENSION_ID = "pushary.pushary";
+var EDITOR_EXTENSION_DIRS = [
+  join2(".cursor", "extensions"),
+  join2(".vscode", "extensions")
+];
+var EXTENSIONS_JSON = "extensions.json";
+var isOurEntry = (entry) => {
+  if (typeof entry !== "object" || entry === null) return false;
+  const identifier = entry.identifier;
+  if (typeof identifier !== "object" || identifier === null) return false;
+  const id = identifier.id;
+  return typeof id === "string" && id.toLowerCase() === EDITOR_EXTENSION_ID;
+};
+var recordWithoutUs = (directory) => {
+  const path = join2(directory, EXTENSIONS_JSON);
+  try {
+    const entries = JSON.parse(readFileSync(path, "utf-8"));
+    if (!Array.isArray(entries)) return void 0;
+    const kept = entries.filter((entry) => !isOurEntry(entry));
+    return kept.length === entries.length ? void 0 : { path, contents: JSON.stringify(kept) };
+  } catch {
+    return void 0;
+  }
+};
+var editorExtensionRemovals = (home = homedir2()) => EDITOR_EXTENSION_DIRS.map((relative) => join2(home, relative)).filter(existsSync3).map((directory) => {
+  const folders = readdirSync(directory).filter((name) => name.startsWith(`${EDITOR_EXTENSION_ID}-`)).map((name) => join2(directory, name));
+  return { directory, folders, record: recordWithoutUs(directory) };
+}).filter((removal) => removal.folders.length > 0 || removal.record !== void 0);
+
+// src/cli/skills-store.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var SKILLS_STORE_DIR = ".agents";
+var LOCK_FILE = ".skill-lock.json";
+var lockWithoutUs = (path) => {
+  try {
+    const lock = JSON.parse(readFileSync2(path, "utf-8"));
+    if (!lock || typeof lock !== "object" || Array.isArray(lock) || !("skills" in lock)) return void 0;
+    const entries = lock.skills;
+    if (!entries || typeof entries !== "object" || Array.isArray(entries) || !(PUSHARY_SKILL_NAME in entries)) return void 0;
+    const entry = entries[PUSHARY_SKILL_NAME];
+    if (!entry || typeof entry !== "object" || !("source" in entry) || entry.source !== PUSHARY_SKILL_SOURCE) return void 0;
+    const { [PUSHARY_SKILL_NAME]: _ours, ...skills } = entries;
+    return { path, contents: `${JSON.stringify({ ...lock, skills }, null, 2)}
+` };
+  } catch {
+    return void 0;
+  }
+};
+var skillsStoreRemoval = (home = homedir3()) => {
+  const store = join3(home, SKILLS_STORE_DIR);
+  const skillDir = join3(store, "skills", PUSHARY_SKILL_NAME);
+  const lock = lockWithoutUs(join3(store, LOCK_FILE));
+  return {
+    skillDir: lock && existsSync4(skillDir) ? skillDir : void 0,
+    lock
+  };
+};
+
+// src/cli/claude-backups.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+var BACKUP_PREFIX = ".claude.json.backup";
+var claudeJsonBackups = (home = homedir4()) => {
+  const rollingDir = join4(home, ".claude", "backups");
+  const legacy = join4(home, BACKUP_PREFIX);
+  const rolling = existsSync5(rollingDir) ? readdirSync2(rollingDir).filter((name) => name.startsWith(BACKUP_PREFIX)).sort().map((name) => join4(rollingDir, name)) : [];
+  return existsSync5(legacy) ? [...rolling, legacy] : rolling;
+};
+var parsed = (path) => {
+  try {
+    const value = JSON.parse(readFileSync3(path, "utf-8"));
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+};
+var claudeBackupRewrites = (receipt, home = homedir4()) => claudeJsonBackups(home).flatMap((path) => {
+  const backup = parsed(path);
+  if (!backup) return [];
+  const changed = receipt ? restoreClaudeMcpServer(backup, receipt) : removeClaudeMcpServers(backup);
+  return changed ? [{ path, contents: `${JSON.stringify(backup, null, 2)}
+` }] : [];
+});
+
+// src/cli/clean-global-package.ts
+var UNINSTALL_TIMEOUT_MS = 3e4;
+var readRemovalEvidence = (prefix, platform) => CLI_PACKAGE_NAMES.map((name) => ({
+  name,
+  listing: globalPackageState(name),
+  folder: prefix === void 0 ? "unseen" : readGlobalFolder(globalRootFor(prefix, platform), name, platform).kind
+}));
+var uninstallGlobalPackage = (guards2, name) => {
+  guards2.execFile(
+    `npm uninstall -g --no-workspaces ${name}`,
+    [],
+    { stdio: "ignore", timeout: UNINSTALL_TIMEOUT_MS, env: cleanNpmEnv(), shell: true },
+    `npm uninstall -g ${name}`
+  );
+};
+var removeLeftoverFolders = (guards2, prefix, platform) => {
+  const root = globalRootFor(prefix, platform);
+  for (const name of CLI_PACKAGE_NAMES) {
+    if (readGlobalFolder(root, name, platform).kind === "ours") {
+      guards2.remove(globalPackageFolder(root, name, platform), { force: true });
+    }
+  }
+};
+var removeGlobalCliPackages = (guards2, request) => {
+  const platform = request.platform ?? process.platform;
+  const prefix = readGlobalPrefix();
+  const names = globalPackagesToUninstall(readRemovalEvidence(prefix, platform));
+  if (names.length === 0) return { kind: "not_installed" };
+  try {
+    for (const name of names) uninstallGlobalPackage(guards2, name);
+    if (!request.dryRun && prefix !== void 0) removeLeftoverFolders(guards2, prefix, platform);
+    return { kind: "removed", names };
+  } catch {
+    return { kind: "failed", names };
+  }
+};
+
+// src/cli/config-temp-leftovers.ts
+import { lstatSync, readdirSync as readdirSync3 } from "fs";
+import { join as join5 } from "path";
+var MAC_APP_WRITE_TEMP = /^\..+\.pushary-[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/;
+var PID_STAMPED_WRITE_TEMP = /^\.\d+-[^/]+\.pushary-tmp$/;
+var CONFIG_TEMP_MIN_AGE_MS = 6e4;
+var isLeakedConfigTempName = (name) => MAC_APP_WRITE_TEMP.test(name) || PID_STAMPED_WRITE_TEMP.test(name);
+var leakedConfigTemps = (entries, nowMs) => entries.filter((entry) => entry.isFile && isLeakedConfigTempName(entry.name) && nowMs - entry.modifiedAtMs >= CONFIG_TEMP_MIN_AGE_MS).map((entry) => entry.name);
+var directoryEntries = (directory) => {
+  try {
+    return readdirSync3(directory).flatMap((name) => {
+      const stats = lstatSync(join5(directory, name), { throwIfNoEntry: false });
+      return stats ? [{ name, isFile: stats.isFile(), modifiedAtMs: stats.mtimeMs }] : [];
+    });
+  } catch {
+    return [];
+  }
+};
+var configTempLeftovers = (directories, nowMs) => [...new Set(directories)].flatMap((directory) => leakedConfigTemps(directoryEntries(directory), nowMs).map((name) => join5(directory, name)));
+
+// src/app-owned-paths.ts
+var APP_OWNED_ENTRIES = [
+  // PusharyPaths.bin: bridgeStub, bridgeCache
+  "bin",
+  // PusharyPaths.run: pushary.sock, pushary.lastrun, gate-state.json, pending-commands.json
+  "run",
+  // PusharyPaths.spool
+  "spool",
+  // Shared: AgentInstaller.vscodePlugin writes .pushary/plugins/vscode, and so
+  // does the CLI. Not attributable, so it is kept whenever the app is installed
+  // rather than removed and left registered against a path that is gone.
+  "plugins",
+  "bridge-auth"
+];
+var isAppOwned = (name) => APP_OWNED_ENTRIES.includes(name);
+
+// src/shared-mcp-key.ts
+var asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var pusharyKey = (value) => typeof value === "string" && isValidApiKey(value.trim()) ? value.trim() : null;
+var bearerKey = (authorization) => typeof authorization === "string" && authorization.startsWith("Bearer ") ? pusharyKey(authorization.slice("Bearer ".length)) : null;
+var mcpServerBearer = (mcpServers) => bearerKey(asRecord(asRecord(asRecord(mcpServers)?.pushary)?.headers)?.Authorization);
+var appAgentKey = (bridgeAgentKey2) => pusharyKey(asRecord(bridgeAgentKey2)?.key);
+var setupReceiptKey = (claudeMcpReceipt2) => bearerKey(asRecord(asRecord(asRecord(claudeMcpReceipt2)?.installedPushary)?.headers)?.Authorization);
+var macAppKeepsMcpEntry = (entryKey, keys) => {
+  if (!entryKey) return true;
+  if (keys.appKey) return entryKey === keys.appKey;
+  return entryKey !== keys.setupKey;
+};
+
+// bin/pushary-clean.ts
+exitOnHelpFlag("clean");
+var paint = ansiPainter(() => useColor());
+var dim = paint("\x1B[2m");
+var bold = paint("\x1B[1m");
+var green = paint("\x1B[32m");
+var yellow = paint("\x1B[33m");
+var red = paint("\x1B[31m");
+var check = green("\u2713");
+var skip = yellow("\u2013");
+var cross = red("\u2717");
+var incompleteClean = false;
+var keepCliRuntime = false;
+var CLAUDE_SETTINGS = claudeSettings();
+var CLAUDE_SETTINGS_LOCAL = claudeSettingsLocal();
+var CLAUDE_JSON = claudeJson();
+var CLAUDE_MCP_RECEIPT = claudeMcpReceipt();
+var HERMES_CONFIG_RECEIPT = hermesConfigReceipt();
+var HERMES_CONFIG_FILE = hermesConfig();
+var SKILL_DIR = claudeSkillDir();
+var CURSOR_MCP = cursorUserMcp();
+var CURSOR_PLUGIN_DIR = cursorPluginDir();
+var CURSOR_USER_HOOKS = cursorUserHooks();
+var VSCODE_PLUGIN_DIR = vscodePluginDir();
+var PUSHARY_DIR = pusharyDir();
+var SHELL_FILES = [".zshrc", ".zprofile", ".bashrc", ".bash_profile"].map((f) => join6(homedir5(), f));
+var PRESENCE_BY_RESOLUTION = {
+  bundle: "present",
+  missing: "gone",
+  "no-stub": "absent"
+};
+var macAppPresence = () => PRESENCE_BY_RESOLUTION[resolveBridgeStub(join6(PUSHARY_DIR, "bin", HOOK_LOCATOR_BINARY), liveBridgeProbe()).kind];
+var removalScope = (keepMcpServer, keepAppWiring) => ({
+  keepAppWiring,
+  keepMcpServer
+});
+var codexMcpKey = (config) => {
+  const auth = readCodexMcpAuth(config);
+  return auth?.method === "embedded" ? pusharyKey(auth.key) : null;
+};
+var readJson = (path) => {
+  try {
+    return JSON.parse(readFileSync4(path, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+var dryRun = false;
+var did = (past) => dryRun ? `(would ${past === "cleaned" ? "clean" : past === "removed" ? "remove" : past === "uninstalled" ? "uninstall" : past})` : `(${past})`;
+var wouldNote = (action, path) => {
+  console.log(`  ${dim("would")} ${action} ${path}`);
+};
+var guards = createGuards(() => dryRun, wouldNote);
+var guardedWrite = (path, contents) => guards.write(path, contents);
+var guardedRemove = (path, options) => guards.remove(path, options);
+var CURSOR_PLUGIN_STAGING = ".pushary-staging-";
+var cursorPluginLeftovers = () => {
+  const parent = dirname(CURSOR_PLUGIN_DIR);
+  const backupPrefix = `${CURSOR_PLUGIN_DIR.split("/").pop()}.pushary-backup-`;
+  try {
+    return readdirSync4(parent).filter((name) => name.startsWith(backupPrefix) || name.startsWith(CURSOR_PLUGIN_STAGING)).map((name) => join6(parent, name));
+  } catch {
+    return [];
+  }
+};
+var guardedDaemonRemoval = async () => {
+  if (dryRun) {
+    wouldNote("stop and uninstall", "Pushary background service");
+    return true;
+  }
+  return (await disableDaemonService({ requireAbsenceProof: true })).kind === "ok";
+};
+var guardedInstructionBlockRemoval = (path) => {
+  if (!dryRun) return removeInstructionBlock(path);
+  if (!existsSync6(path)) return false;
+  const hasBlock = readFileSync4(path, "utf-8").includes("pushary");
+  if (hasBlock) wouldNote("rewrite", path);
+  return hasBlock;
+};
+var guardedAliasRemoval = () => {
+  if (!dryRun) return removeClaudeAlias();
+  const shells = CANDIDATE_RCS.map((name) => join6(homedir5(), name)).filter((path) => existsSync6(path) && readFileSync4(path, "utf-8").includes("pushary claude"));
+  for (const path of shells) wouldNote("rewrite", path);
+  return shells;
+};
+var writeJson = (path, data) => {
+  guardedWrite(path, JSON.stringify(data, null, 2) + "\n");
+};
+var removeFxConfiguration = () => {
+  for (const action of planFxRemoval(fxMcpProfile(), fxSettings(), fxQuestionRuleReceipt())) {
+    if (action.kind === "write") {
+      guardedWrite(action.path, action.text);
+      console.log(`  ${check} ${action.label} ${dim(did("removed"))}`);
+    } else if (action.kind === "remove-receipt") {
+      guardedRemove(action.path, { force: true });
+    } else {
+      console.log(`  ${skip} ${action.label} ${dim(`(${action.detail})`)}`);
+    }
+  }
+};
+var removeFxInstructions = () => {
+  if (guardedInstructionBlockRemoval(fxAgentsMd())) {
+    console.log(`  ${check} fx instructions ${dim(did("removed"))}`);
+  }
+};
+var removeCursorUserHook = (scope) => {
+  if (!existsSync6(CURSOR_USER_HOOKS)) return "absent";
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(readFileSync4(CURSOR_USER_HOOKS, "utf-8"));
+  } catch {
+    return "failed";
+  }
+  if (!parsed2 || typeof parsed2 !== "object") return "failed";
+  const removal = withoutPusharyCursorHooks(parsed2.hooks ?? {}, scope);
+  if (removal.removed === 0) return "absent";
+  parsed2.hooks = removal.hooks;
+  try {
+    writeJson(CURSOR_USER_HOOKS, parsed2);
+  } catch {
+    return "failed";
+  }
+  if (dryRun) return "removed";
+  try {
+    const after = JSON.parse(readFileSync4(CURSOR_USER_HOOKS, "utf-8"));
+    if (withoutPusharyCursorHooks(after?.hooks ?? {}, scope).removed > 0) return "failed";
+  } catch {
+    return "failed";
+  }
+  return "removed";
+};
+var cleanSettingsFile = (path, label, scope) => {
+  const data = readJson(path);
+  if (!data) {
+    console.log(`  ${skip} ${label} ${dim("(not found)")}`);
+    return;
+  }
+  const changed = removePusharySettings(data, scope);
+  if (changed) {
+    writeJson(path, data);
+    console.log(`  ${check} ${label} ${dim(did("cleaned"))}`);
+    return;
+  }
+  const wouldHaveChanged = removePusharySettings(
+    JSON.parse(JSON.stringify(data))
+  );
+  console.log(
+    `  ${skip} ${label} ${dim(wouldHaveChanged ? "(kept: written by the Mac app)" : "(no pushary entries)")}`
+  );
+};
+var agentConfigDirectories = () => [
+  homedir5(),
+  dirname(CLAUDE_SETTINGS),
+  dirname(codexConfigToml()),
+  dirname(geminiSettings()),
+  dirname(CURSOR_USER_HOOKS),
+  openCodeConfigDir(),
+  fxConfigDir(),
+  ...vscodeSettingsTargets(existsSync6).map((settings) => dirname(settings))
+];
+var restoreTakeoverReceipts = () => {
+  const targets = [
+    ["claude_code", CLAUDE_SETTINGS, CLAUDE_JSON, "mcpServers", "json"],
+    ["codex", codexHooksJson(), codexConfigToml(), "mcp_servers", "toml"],
+    ["gemini_cli", geminiSettings(), geminiSettings(), "mcpServers", "json"],
+    ["cursor", CURSOR_USER_HOOKS, null, null, null],
+    ["vscode", join6(VSCODE_PLUGIN_DIR, "hooks", "hooks.json"), vscodePluginMcp(), "mcpServers", "json"]
+  ];
+  for (const [agent, hookFile, mcpFile, mcpKey, mcpFormat] of targets) {
+    const receiptPath = hookTakeoverReceipt(agent);
+    if (!existsSync6(receiptPath)) continue;
+    try {
+      const receipt = readJson(receiptPath);
+      if (!isHookTakeoverReceipt(receipt) || receipt.agent !== agent) throw new Error("invalid receipt");
+      const document = existsSync6(hookFile) ? JSON.parse(readFileSync4(hookFile, "utf-8")) : {};
+      if (!document || typeof document !== "object" || Array.isArray(document)) throw new Error("invalid hooks file");
+      const appAlreadyOwns = hookOwnerOf(document) === "app";
+      const cliPositions = agent === "codex" ? codexHookPositions(document) : {};
+      restoreHookTakeover(document, receipt);
+      let mcpDocument = null;
+      let mcpChanged = false;
+      if (!appAlreadyOwns && receipt.mcpServer && mcpFile && mcpKey) {
+        if (mcpFile === hookFile) {
+          mcpDocument = document;
+        } else {
+          const raw = existsSync6(mcpFile) ? readFileSync4(mcpFile, "utf-8") : "";
+          mcpDocument = raw.trim() ? mcpFormat === "toml" ? parseTOML(raw) : JSON.parse(raw) : {};
+        }
+        mcpChanged = restoreMcpServer(mcpDocument, mcpKey, receipt.mcpServer);
+      }
+      let codexConfig = null;
+      let codexConfigChanged = false;
+      if (!appAlreadyOwns && agent === "codex") {
+        if (!mcpDocument) {
+          const configPath = codexConfigToml();
+          const raw = existsSync6(configPath) ? readFileSync4(configPath, "utf-8") : "";
+          mcpDocument = raw.trim() ? parseTOML(raw) : {};
+        }
+        codexConfig = mcpDocument;
+        codexConfigChanged = removeCodexHookTrust(codexConfig, hookFile, cliPositions);
+        codexConfigChanged = restoreCodexHookTrust(
+          codexConfig,
+          hookFile,
+          codexHookPositions(document),
+          receipt.codexTrust ?? {}
+        ) || codexConfigChanged;
+      }
+      if (mcpDocument && mcpFile !== hookFile && mcpFormat === "json" && mcpChanged) writeJson(mcpFile, mcpDocument);
+      if (codexConfig && (codexConfigChanged || mcpChanged)) guardedWrite(codexConfigToml(), stringifyTOML(codexConfig));
+      writeJson(hookFile, document);
+      guardedRemove(receiptPath, { force: true });
+      const status = dryRun ? "would restore Mac app wiring" : "restored Mac app wiring";
+      console.log(`  ${check} ${agent.replace("_", " ")} hooks ${dim(`(${status})`)}`);
+    } catch {
+      incompleteClean = true;
+      keepCliRuntime = true;
+      console.log(`  ${cross} ${agent.replace("_", " ")} hooks ${dim("(could not restore Mac app wiring; receipt and CLI kept)")}`);
+    }
+  }
+};
+var main = async () => {
+  console.log();
+  console.log(`  ${bold("Pushary Clean")}`);
+  console.log(`  ${dim("Removes all Pushary configuration")}`);
+  console.log();
+  try {
+    rejectUnknownFlags(
+      process.argv.slice(2).filter((a) => a !== "clean"),
+      ["--dry-run", "--everything", "--yes", "-y", "--help", "-h"]
+    );
+  } catch (err) {
+    process.stderr.write(`  ! ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(EXIT.USAGE);
+  }
+  dryRun = process.argv.includes("--dry-run");
+  const everything = process.argv.includes("--everything");
+  if (dryRun) {
+    console.log(`  ${bold("Dry run")} ${dim("- nothing will be changed")}`);
+    console.log();
+  }
+  const assumeYes = dryRun || process.argv.includes("--yes") || process.argv.includes("-y");
+  if (!assumeYes && !process.stdin.isTTY) {
+    console.log(`  ${yellow("!")} Non-interactive shell. Re-run with --yes to confirm removal.`);
+    process.exit(1);
+  }
+  const proceed = assumeYes || await confirm({ message: "Remove all Pushary configuration?", default: false });
+  if (!proceed) {
+    console.log(`  ${dim("Cancelled.")}`);
+    process.exit(0);
+  }
+  console.log();
+  const presence = macAppPresence();
+  const keepShared = presence === "present" && !everything;
+  const scope = removalScope(keepShared, keepShared);
+  if (keepShared) {
+    console.log(`  ${dim("The Mac app is installed, so its wiring and the state it owns are left alone.")}`);
+    console.log(`  ${dim("To remove that too, re-run with")} --everything`);
+  } else if (presence === "gone") {
+    console.log(`  ${dim("The Mac app is gone, so the wiring it left behind is removed too.")}`);
+  } else if (everything && presence === "present") {
+    console.log(`  ${dim("Removing the Mac app's wiring and state as well.")}`);
+  }
+  if (everything) {
+    const quit = quitMacApp(guards, { platform: process.platform, dryRun, running: runningMacAppPIDs, waitForExit: waitForMacAppExit });
+    if (quit === "quit") {
+      console.log(`  ${check} Pushary ${dim(did("quit"))} ${dim("(running, and its watcher puts back what this removes)")}`);
+    } else if (quit === "running") {
+      incompleteClean = true;
+      console.log(`  ${cross} Pushary ${dim("would not quit, and it puts back what this removes")}`);
+      console.log(`    ${dim("Quit it from the notch menu, then re-run.")}`);
+      process.exit(EXIT.FAILED);
+    }
+  }
+  if (presence !== "absent") console.log();
+  const restoredByTakeover = new Set(
+    ["claude_code", "codex", "gemini_cli"].filter((agent) => existsSync6(hookTakeoverReceipt(agent)))
+  );
+  if (keepShared) restoreTakeoverReceipts();
+  const sharedMcpKeys = {
+    appKey: appAgentKey(readJson(bridgeAgentKey())),
+    setupKey: setupReceiptKey(readJson(CLAUDE_MCP_RECEIPT))
+  };
+  const macAppKeeps = (agent, entryKey) => keepShared && (restoredByTakeover.has(agent) || macAppKeepsMcpEntry(entryKey, sharedMcpKeys));
+  if (keepCliRuntime) {
+    console.log(`  ${yellow(bold("Clean stopped before changing provider configuration."))}`);
+    console.log(`  ${dim("Fix the hooks file or receipt above, then re-run")} npx @pushary/agent-hooks@latest clean`);
+    process.exit(EXIT.FAILED);
+  }
+  const daemonRemoved = await guardedDaemonRemoval();
+  if (!daemonRemoved) {
+    console.log(`  ${cross} Background service ${dim("(could not stop or uninstall)")}`);
+    console.log(`  ${yellow(bold("Clean stopped before changing provider configuration or local state."))}`);
+    console.log(`  ${dim("Fix the background service, then re-run")} npx @pushary/agent-hooks@latest clean`);
+    console.log();
+    process.exit(EXIT.FAILED);
+  }
+  console.log(`  ${check} Background service ${dim(did("uninstalled"))}`);
+  const claudeJson2 = readJson(CLAUDE_JSON);
+  const keepClaudeMcp = macAppKeeps("claude_code", mcpServerBearer(claudeJson2?.mcpServers));
+  const claudeHasPusharyEntry = () => Boolean(claudeJson2?.mcpServers?.pushary);
+  const claudeHadPusharyEntry = claudeHasPusharyEntry();
+  const rawReceipt = readJson(CLAUDE_MCP_RECEIPT);
+  const receipt = isClaudeMcpSnapshot(rawReceipt) ? rawReceipt : null;
+  const receiptUnreadable = existsSync6(CLAUDE_MCP_RECEIPT) && !receipt;
+  if (keepClaudeMcp) {
+    console.log(`  ${skip} Claude Code MCP servers ${dim("(kept: the Mac app uses it)")}`);
+  } else if (claudeJson2) {
+    if (receiptUnreadable) {
+      if (!keepShared) incompleteClean = true;
+      console.log(`  ${skip} Claude Code MCP servers ${dim("(setup receipt is unreadable; left unchanged)")}`);
+    } else if (receipt && restoreClaudeMcpServer(claudeJson2, receipt) || !receipt && removeClaudeMcpServers(claudeJson2)) {
+      writeJson(CLAUDE_JSON, claudeJson2);
+      console.log(`  ${check} Claude Code MCP servers ${dim(receipt ? "(previous entry restored)" : "(removed from ~/.claude.json)")}`);
+      if (keepShared && receipt) guardedRemove(CLAUDE_MCP_RECEIPT, { force: true });
+    } else {
+      if (receipt && !keepShared) incompleteClean = true;
+      console.log(`  ${skip} Claude Code MCP servers ${dim(receipt ? "(changed after setup; left unchanged)" : "(no pushary entries)")}`);
+    }
+  } else if (existsSync6(CLAUDE_MCP_RECEIPT)) {
+    incompleteClean = true;
+    console.log(`  ${skip} Claude Code MCP servers ${dim("(config missing; setup receipt kept for retry)")}`);
+  } else {
+    console.log(`  ${skip} Claude Code MCP servers ${dim("(not found)")}`);
+  }
+  if (!keepClaudeMcp && !receiptUnreadable) {
+    const rewrites = claudeBackupRewrites(receipt);
+    for (const rewrite of rewrites) guardedWrite(rewrite.path, rewrite.contents);
+    if (rewrites.length > 0) {
+      console.log(`  ${check} Claude Code backups ${dim(did("cleaned"))} ${dim(`(the Pushary entry and its key, in ${rewrites.length})`)}`);
+    }
+  }
+  const claudeScope = removalScope(keepShared && !(claudeHadPusharyEntry && !claudeHasPusharyEntry()), keepShared);
+  cleanSettingsFile(CLAUDE_SETTINGS, "Claude Code settings", claudeScope);
+  cleanSettingsFile(CLAUDE_SETTINGS_LOCAL, "Claude Code settings.local", claudeScope);
+  const cursorData = keepShared ? null : readJson(CURSOR_MCP);
+  if (keepShared) {
+    console.log(`  ${skip} Cursor MCP config ${dim("(kept: the Mac app uses it)")}`);
+  } else if (cursorData) {
+    const mcpServers = cursorData.mcpServers;
+    if (mcpServers?.pushary) {
+      delete mcpServers.pushary;
+      writeJson(CURSOR_MCP, cursorData);
+      console.log(`  ${check} Cursor MCP config ${dim(did("cleaned"))}`);
+    } else {
+      console.log(`  ${skip} Cursor MCP config ${dim("(no pushary entries)")}`);
+    }
+  } else {
+    console.log(`  ${skip} Cursor MCP config ${dim("(not found)")}`);
+  }
+  const cursorGate = removeCursorUserHook(scope);
+  if (cursorGate === "removed") {
+    console.log(`  ${check} Cursor gate ${dim("(removed from ~/.cursor/hooks.json)")}`);
+  } else if (cursorGate === "absent") {
+    console.log(`  ${skip} Cursor gate ${dim("(not registered)")}`);
+  } else {
+    incompleteClean = true;
+    console.log(`  ${cross} Cursor gate ${dim("(could not read or write ~/.cursor/hooks.json)")}`);
+    console.log(`    ${yellow("!")} The gate is registered failClosed, so matched commands would be blocked.`);
+    console.log(`    ${dim("Keeping the plugin in place so Cursor keeps working. Fix the file, then re-run clean.")}`);
+  }
+  if (cursorGate === "failed") {
+    console.log(`  ${skip} Cursor plugin ${dim("(kept: removing it now would block matched commands)")}`);
+  } else if (existsSync6(CURSOR_PLUGIN_DIR)) {
+    guardedRemove(CURSOR_PLUGIN_DIR);
+    console.log(`  ${check} Cursor plugin ${dim("(removed from ~/.cursor/plugins/local)")}`);
+  } else {
+    console.log(`  ${skip} Cursor plugin ${dim("(not installed)")}`);
+  }
+  if (cursorGate !== "failed") {
+    const stale = cursorPluginLeftovers();
+    for (const path of stale) guardedRemove(path);
+    if (stale.length > 0) {
+      console.log(`  ${check} Cursor plugin copies ${dim(did("removed"))} ${dim(`(${stale.length}, each holding the key of an earlier install)`)}`);
+    }
+  }
+  if (keepShared) {
+    console.log(`  ${skip} VS Code plugin ${dim("(kept: the Mac app writes the same plugin directory)")}`);
+  }
+  for (const settingsPath of keepShared ? [] : vscodeSettingsTargets(existsSync6)) {
+    const label = `VS Code plugin ${dim(`(${shortenHome(settingsPath)})`)}`;
+    if (!existsSync6(settingsPath)) {
+      console.log(`  ${skip} ${label} ${dim("(no settings.json)")}`);
+      continue;
+    }
+    const result = unregisterPluginLocation(readFileSync4(settingsPath, "utf-8"), VSCODE_PLUGIN_DIR);
+    if (result.kind === "removed") {
+      guardedWrite(settingsPath, result.content);
+      console.log(`  ${check} ${label} ${dim(did("unregistered"))}`);
+    } else if (result.kind === "manual") {
+      console.log(`  ${skip} ${label} ${yellow("(remove the chat.pluginLocations entry by hand)")}`);
+    } else {
+      console.log(`  ${skip} ${label} ${dim("(no pushary entry)")}`);
+    }
+  }
+  if (!keepShared && existsSync6(VSCODE_PLUGIN_DIR)) {
+    guardedRemove(VSCODE_PLUGIN_DIR);
+    console.log(`  ${check} VS Code plugin files ${dim(did("removed"))}`);
+  }
+  if (keepShared) {
+    console.log(`  ${skip} Editor extension ${dim("(kept: installed and updated by the Mac app)")}`);
+  } else {
+    const removals = editorExtensionRemovals();
+    for (const removal of removals) {
+      if (removal.record) guardedWrite(removal.record.path, removal.record.contents);
+      for (const folder of removal.folders) guardedRemove(folder);
+      console.log(`  ${check} Editor extension ${dim(`(${did("removed")} from ${shortenHome(removal.directory)})`)}`);
+    }
+    if (removals.length === 0) {
+      console.log(`  ${skip} Editor extension ${dim("(not installed in Cursor or VS Code)")}`);
+    }
+  }
+  if (keepShared) {
+    console.log(`  ${skip} Skill directory ${dim("(kept: the Mac app uses it)")}`);
+  } else if (existsSync6(SKILL_DIR)) {
+    guardedRemove(SKILL_DIR);
+    console.log(`  ${check} Skill directory ${dim(did("removed"))}`);
+  } else {
+    console.log(`  ${skip} Skill directory ${dim("(not found)")}`);
+  }
+  const codexConfig = codexConfigToml();
+  const codexHooksJson2 = codexHooksJson();
+  const codexHooksData = readJson(codexHooksJson2);
+  const codexPositions = codexHookPositions(codexHooksData ?? void 0);
+  try {
+    const config = readFileSync4(codexConfig, "utf-8");
+    const parsed2 = parseTOML(config);
+    const trustRemoved = hookOwnerOf(codexHooksData) === "app" && keepShared ? false : removeCodexHookTrust(parsed2, codexHooksJson2, codexPositions);
+    const hadPushary = config.includes("pushary");
+    if (hadPushary || trustRemoved) {
+      const macAppKeepsCodexMcp = macAppKeeps("codex", codexMcpKey(parsed2));
+      if (!macAppKeepsCodexMcp) {
+        const mcpServers = parsed2.mcp_servers ?? {};
+        delete mcpServers.pushary;
+        if (Object.keys(mcpServers).length === 0) delete parsed2.mcp_servers;
+        else parsed2.mcp_servers = mcpServers;
+      }
+      if (Array.isArray(parsed2.notify)) {
+        parsed2.notify = parsed2.notify.filter((n) => typeof n !== "string" || !n.includes("pushary-codex"));
+        if (parsed2.notify.length === 0) delete parsed2.notify;
+      }
+      guardedWrite(codexConfig, stringifyTOML(parsed2));
+      const what = trustRemoved ? "cleaned, hook trust removed" : "cleaned";
+      console.log(`  ${check} Codex config ${dim(did(what))}`);
+      if (macAppKeepsCodexMcp && parsed2.mcp_servers?.pushary) {
+        console.log(`  ${skip} Codex MCP server ${dim("(kept: the Mac app uses it)")}`);
+      }
+    } else {
+      console.log(`  ${skip} Codex config ${dim("(no pushary entries)")}`);
+    }
+  } catch {
+    console.log(`  ${skip} Codex config ${dim("(not found)")}`);
+  }
+  if (codexHooksData) {
+    if (removeCodexHooks(codexHooksData, scope)) {
+      writeJson(codexHooksJson2, codexHooksData);
+      console.log(`  ${check} Codex hooks ${dim("(removed from ~/.codex/hooks.json)")}`);
+    } else {
+      console.log(`  ${skip} Codex hooks ${dim("(no pushary entries)")}`);
+    }
+  } else {
+    console.log(`  ${skip} Codex hooks ${dim("(not found)")}`);
+  }
+  const codexAgentsMd2 = codexAgentsMd();
+  if (keepShared) {
+    console.log(`  ${skip} Codex AGENTS.md ${dim("(kept: the Mac app uses it)")}`);
+  } else if (guardedInstructionBlockRemoval(codexAgentsMd2)) {
+    console.log(`  ${check} Codex AGENTS.md ${dim("(removed Pushary block)")}`);
+  } else {
+    console.log(`  ${skip} Codex AGENTS.md ${dim("(no pushary block)")}`);
+  }
+  const codexSkillDir2 = codexSkillDir();
+  if (keepShared) {
+    console.log(`  ${skip} Codex skill directory ${dim("(kept: the Mac app uses it)")}`);
+  } else if (existsSync6(codexSkillDir2)) {
+    guardedRemove(codexSkillDir2);
+    console.log(`  ${check} Codex skill directory ${dim(did("removed"))}`);
+  } else {
+    console.log(`  ${skip} Codex skill directory ${dim("(not found)")}`);
+  }
+  for (const profile of HOOK_COMPATIBLE_PROFILES) {
+    const edits = [
+      [compatibleConfigFile(profile), (config) => removeCompatibleHooks(config, profile)],
+      ...compatibleMcpFile(profile) ? [[compatibleMcpFile(profile), (config) => removeCompatibleMcpServer(config, profile)]] : [],
+      ...compatiblePermissionRuleFile(profile) ? [[compatiblePermissionRuleFile(profile), removePusharyToolPermissions]] : []
+    ];
+    const byPath = /* @__PURE__ */ new Map();
+    for (const [path, edit] of edits) byPath.set(path, [...byPath.get(path) ?? [], edit]);
+    for (const [path, removals] of byPath) {
+      const config = readJson(path);
+      if (!config) {
+        console.log(`  ${skip} ${profile.label} ${shortenHome(path)} ${dim("(not found)")}`);
+        continue;
+      }
+      if (removals.reduce((changed, remove) => remove(config) || changed, false)) {
+        writeJson(path, config);
+        console.log(`  ${check} ${profile.label} ${shortenHome(path)} ${dim(did("cleaned"))}`);
+      } else {
+        console.log(`  ${skip} ${profile.label} ${shortenHome(path)} ${dim("(no pushary entries)")}`);
+      }
+    }
+    const instructions = compatibleInstructionsFile(profile);
+    if (!instructions) continue;
+    if (guardedInstructionBlockRemoval(instructions)) {
+      console.log(`  ${check} ${profile.label} ${shortenHome(instructions)} ${dim("(removed Pushary block)")}`);
+    } else {
+      console.log(`  ${skip} ${profile.label} ${shortenHome(instructions)} ${dim("(no pushary block)")}`);
+    }
+  }
+  const geminiSettingsPath = geminiSettings();
+  const geminiSettings2 = readJson(geminiSettingsPath);
+  if (geminiSettings2) {
+    if (removeGeminiSettings(geminiSettings2, removalScope(macAppKeeps("gemini_cli", mcpServerBearer(geminiSettings2.mcpServers)), keepShared))) {
+      writeJson(geminiSettingsPath, geminiSettings2);
+      console.log(`  ${check} Gemini CLI settings ${dim(did("cleaned"))}`);
+    } else {
+      console.log(`  ${skip} Gemini CLI settings ${dim("(no pushary entries)")}`);
+    }
+  } else {
+    console.log(`  ${skip} Gemini CLI settings ${dim("(not found)")}`);
+  }
+  const geminiMd2 = geminiMd();
+  if (keepShared) {
+    console.log(`  ${skip} Gemini GEMINI.md ${dim("(kept: the Mac app uses it)")}`);
+  } else if (guardedInstructionBlockRemoval(geminiMd2)) {
+    console.log(`  ${check} Gemini GEMINI.md ${dim("(removed Pushary block)")}`);
+  } else {
+    console.log(`  ${skip} Gemini GEMINI.md ${dim("(no pushary block)")}`);
+  }
+  const openCodePlugin = openCodePluginFile();
+  const openCodePluginContents = existsSync6(openCodePlugin) ? readFileSync4(openCodePlugin, "utf-8") : null;
+  if (openCodePluginContents === null) {
+    console.log(`  ${skip} OpenCode plugin ${dim("(not installed)")}`);
+  } else if (!isOpenCodePluginOurs(openCodePluginContents)) {
+    console.log(`  ${skip} OpenCode plugin ${dim("(a pushary.js we did not write)")}`);
+  } else if (openCodePluginContents.includes(HOOK_LOCATOR_BINARY) && keepShared) {
+    console.log(`  ${skip} OpenCode plugin ${dim("(kept: written by the Mac app)")}`);
+  } else {
+    guardedRemove(openCodePlugin, { force: true });
+    console.log(`  ${check} OpenCode plugin ${dim(did("removed"))}`);
+    const sibling = join6(openCodePluginDir(), OPENCODE_PLUGIN_SIBLING);
+    const remaining = (() => {
+      try {
+        return readdirSync4(openCodePluginDir()).filter((name) => name !== OPENCODE_PLUGIN_SIBLING);
+      } catch {
+        return [];
+      }
+    })();
+    const siblingIsOurs = existsSync6(sibling) && readFileSync4(sibling, "utf-8") === OPENCODE_PLUGIN_SIBLING_CONTENTS;
+    if (siblingIsOurs && !hasForeignPlugins(remaining)) {
+      guardedRemove(sibling, { force: true });
+      console.log(`  ${check} OpenCode plugin sibling ${dim(did("removed"))}`);
+    }
+  }
+  const openCodeConfig = keepShared ? null : readJson(openCodeConfigFile());
+  if (keepShared) {
+    console.log(`  ${skip} OpenCode MCP ${dim("(kept: the Mac app uses it)")}`);
+  } else if (openCodeConfig) {
+    if (removeOpenCodeMcpServer(openCodeConfig)) {
+      writeJson(openCodeConfigFile(), openCodeConfig);
+      console.log(`  ${check} OpenCode MCP ${dim(did("removed"))}`);
+    } else {
+      console.log(`  ${skip} OpenCode MCP ${dim("(no pushary entries)")}`);
+    }
+  } else {
+    console.log(`  ${skip} OpenCode MCP ${dim("(not found)")}`);
+  }
+  if (keepShared) {
+    console.log(`  ${skip} OpenCode AGENTS.md ${dim("(kept: the Mac app uses it)")}`);
+  } else if (guardedInstructionBlockRemoval(openCodeInstructionsFile())) {
+    console.log(`  ${check} OpenCode AGENTS.md ${dim("(removed Pushary block)")}`);
+  } else {
+    console.log(`  ${skip} OpenCode AGENTS.md ${dim("(no pushary block)")}`);
+  }
+  removeFxConfiguration();
+  removeFxInstructions();
+  const hermesPython = resolveHermesPython();
+  if (hermesPython) {
+    const configRun = runHermesConfigScript(hermesPython, dryRun ? "clean-preview" : "clean", HERMES_CONFIG_RECEIPT);
+    if (configRun === "failed") {
+      incompleteClean = true;
+      console.log(`  ${skip} Hermes config ${dim("(could not update config.yaml)")}`);
+    } else {
+      if (configRun === "changed") {
+        if (dryRun) wouldNote("rewrite", HERMES_CONFIG_FILE);
+        console.log(`  ${check} Hermes config ${dim(did("removed"))} ${dim("(Pushary settings)")}`);
+      } else {
+        console.log(`  ${skip} Hermes config ${dim("(no Pushary settings)")}`);
+      }
+      if (readHermesStatus(hermesPython)?.pluginInstalled === false) {
+        console.log(`  ${skip} Hermes plugin ${dim("(not installed)")}`);
+      } else {
+        try {
+          guards.execFile(hermesPython, ["-m", "pip", "uninstall", "-y", HERMES_PIP_PACKAGE], { stdio: "pipe", timeout: 6e4 }, `pip uninstall ${HERMES_PIP_PACKAGE}`);
+          console.log(`  ${check} Hermes plugin ${dim(did("uninstalled"))}`);
+        } catch {
+          incompleteClean = true;
+          console.log(`  ${skip} Hermes plugin ${dim("(could not uninstall; setup receipt kept for retry)")}`);
+        }
+      }
+    }
+  } else if (existsSync6(HERMES_CONFIG_RECEIPT)) {
+    incompleteClean = true;
+    console.log(`  ${skip} Hermes ${dim("(runtime not found; setup receipt kept for retry)")}`);
+  } else {
+    console.log(`  ${skip} Hermes ${dim("(not found)")}`);
+  }
+  for (const shellFile of SHELL_FILES) {
+    try {
+      const content = readFileSync4(shellFile, "utf-8");
+      if (content.includes("PUSHARY_API_KEY")) {
+        const isOurExport = (line) => /^\s*export\s+PUSHARY_API_KEY=['"]?pk_[A-Za-z0-9]+\.[A-Za-z0-9]+['"]?\s*$/.test(line) || isDisabledExport(line);
+        const lines = content.split("\n");
+        const declined = lines.filter((l) => l.includes("PUSHARY_API_KEY") && !isOurExport(l));
+        const cleaned = lines.filter((l) => !isOurExport(l)).join("\n");
+        const name = shellFile.split("/").pop();
+        if (cleaned !== content) {
+          const backup = `${shellFile}.pushary-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+          if (!dryRun) copyFileSync(shellFile, backup);
+          guardedWrite(shellFile, cleaned);
+          const confirmed = !dryRun && readFileSync4(shellFile, "utf-8") === cleaned;
+          if (confirmed) guardedRemove(backup, { force: true });
+          const kept = confirmed ? "" : `, backup at ${backup}`;
+          console.log(`  ${check} ${name} ${dim(`(removed the export${kept})`)}`);
+        }
+        for (const line of declined) {
+          if ((line.match(/pk_[A-Za-z0-9_]+\.[A-Za-z0-9_]+/g) ?? []).some(isValidApiKey)) {
+            incompleteClean = true;
+            console.log(`  ${cross} ${name} ${dim("still sets PUSHARY_API_KEY, in a form this command will not rewrite:")}`);
+            console.log(`    ${dim(redactSecrets(line.trim()))}`);
+            console.log(`    ${dim("Remove it yourself. A setup run would sign this machine in as that account.")}`);
+          } else {
+            console.log(`  ${skip} ${name} ${dim(`left a line referencing PUSHARY_API_KEY: ${redactSecrets(line.trim())}`)}`);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const aliasRemovedFrom = guardedAliasRemoval();
+  if (aliasRemovedFrom.length > 0) {
+    console.log(`  ${check} claude alias ${dim(`(removed from ${aliasRemovedFrom.map((p) => p.split("/").pop()).join(", ")})`)}`);
+  } else {
+    console.log(`  ${skip} claude alias ${dim("(not set)")}`);
+  }
+  const leakedTemps = configTempLeftovers(agentConfigDirectories(), Date.now());
+  for (const temp of leakedTemps) guardedRemove(temp, { force: true });
+  if (leakedTemps.length > 0) {
+    console.log(`  ${check} Leftover temp files ${dim(`(${dryRun ? "would remove" : "removed"} ${leakedTemps.length} left by an interrupted config write)`)}`);
+  }
+  if (existsSync6(PUSHARY_DIR)) {
+    let removed = 0;
+    const kept = [];
+    for (const entry of readdirSync4(PUSHARY_DIR)) {
+      if (keepShared && isAppOwned(entry) || entry === "setup" && (keepShared || incompleteClean)) {
+        kept.push(entry);
+        continue;
+      }
+      guardedRemove(join6(PUSHARY_DIR, entry), { force: true });
+      removed++;
+    }
+    if (removed > 0) {
+      const what = `${removed} entr${removed === 1 ? "y" : "ies"} from ~/.pushary: stored API key, ledger`;
+      console.log(`  ${check} Local state ${dim(dryRun ? `(would remove ${what})` : `(removed ${what})`)}`);
+    } else {
+      console.log(`  ${skip} Local state ${dim("(nothing of ours in ~/.pushary)")}`);
+    }
+    if (kept.length > 0) {
+      console.log(`    ${dim(`left ${kept.sort().join(", ")} for ${keepShared ? "the Mac app" : "a cleanup retry"}`)}`);
+    }
+  } else {
+    console.log(`  ${skip} Local state ${dim("(~/.pushary not found)")}`);
+  }
+  try {
+    let swept = 0;
+    for (const f of readdirSync4(tmpdir())) {
+      if (!f.startsWith("pushary-")) continue;
+      try {
+        guardedRemove(join6(tmpdir(), f), { force: true });
+        swept++;
+      } catch {
+      }
+    }
+    if (swept > 0) console.log(`  ${check} Temp state ${dim(`(${swept} pushary entries swept)`)}`);
+  } catch {
+  }
+  if (everything) {
+    const store = skillsStoreRemoval();
+    if (store.skillDir) guardedRemove(store.skillDir);
+    if (store.lock) guardedWrite(store.lock.path, store.lock.contents);
+    if (store.skillDir || store.lock) {
+      console.log(`  ${check} skills.sh registration ${dim(did("removed"))} ${dim("(~/.agents)")}`);
+    }
+    const leftovers = process.platform === "darwin" ? removeDeveloperLeftovers(guards, leakedTestDefaultsDomains(), registeredPusharyBundles()) : 0;
+    if (leftovers > 0) {
+      console.log(`  ${check} Developer leftovers ${dim(did("removed"))} ${dim(`(${leftovers} leaked test preferences and stale app registrations)`)}`);
+    }
+    const { removed, failed } = process.platform === "darwin" ? removeMacAppState(guards, storedPusharyKeychainServices, homedir5(), liveMacStatePresence) : { removed: 0, failed: 0 };
+    if (failed > 0) {
+      incompleteClean = true;
+      console.log(`  ${cross} Mac keychain ${dim(`(${failed} operations failed; unlock your keychain and re-run)`)}`);
+    }
+    if (removed > 0) {
+      console.log(`  ${check} Mac app state ${dim(did("removed"))} ${dim(`(${removed} across the keychain, preferences and caches)`)}`);
+    } else if (failed === 0) {
+      console.log(`  ${skip} Mac app state ${dim("(nothing of ours in the keychain, preferences or caches)")}`);
+    }
+  }
+  if (!npmIsOnPath()) {
+    console.log(`  ${skip} Global package ${dim(`(npm not found; remove ${CLI_PACKAGE_NAMES.join(" or ")} with the tool that installed it)`)}`);
+  } else {
+    const removal = removeGlobalCliPackages(guards, { dryRun });
+    if (removal.kind === "not_installed") {
+      console.log(`  ${skip} Global package ${dim("(not installed)")}`);
+    } else if (removal.kind === "removed") {
+      console.log(`  ${check} Global package ${dim(did("uninstalled"))} ${dim(`(${removal.names.join(", ")})`)}`);
+    } else {
+      incompleteClean = true;
+      console.log(`  ${cross} Global package ${dim(`(npm uninstall failed; run npm uninstall -g ${removal.names.join(" ")})`)}`);
+    }
+  }
+  console.log();
+  if (incompleteClean) {
+    console.log(`  ${yellow(bold("Clean finished with something left behind."))}`);
+    console.log(`  ${dim("See the \u2717 above. Fix it, then re-run")} npx @pushary/agent-hooks@latest clean`);
+    console.log(`  ${dim("Still stuck? Send this output to")} ${SUPPORT_EMAIL} ${dim("or")} ${SUPPORT_DISCORD}`);
+  } else if (everything) {
+    console.log(`  ${green(bold("Clean complete. Nothing of ours is left in any agent config."))}`);
+    const bundle = installedPusharyBundles().find(existsSync6);
+    if (bundle) {
+      console.log(`  ${dim("The app itself is still installed. Drag")} ${bundle} ${dim("to the Trash to finish.")}`);
+    }
+    console.log(`  ${dim("Signing in as someone else? Sign out at pushary.com in your browser first.")}`);
+    console.log(`  ${dim("The app and")} pushary login ${dim("both sign in through it, and would pick the old account back up.")}`);
+  } else {
+    console.log(`  ${green(bold("Clean complete."))}`);
+    if (keepShared) {
+      console.log(`  ${dim("The Mac app's wiring and its stored key are still here. Re-run with")} --everything ${dim("to remove them.")}`);
+    }
+  }
+  console.log(`  ${dim("Run")} npx @pushary/agent-hooks@latest setup ${dim("to reinstall.")}`);
+  const exportedKey = process.env.PUSHARY_API_KEY?.trim();
+  if (aliasRemovedFrom.length > 0 || exportedKey) {
+    console.log();
+    console.log(`  ${yellow("!")} ${bold("In your current terminal")}`);
+  }
+  if (exportedKey) {
+    console.log(`  ${dim("PUSHARY_API_KEY is still exported here. Run")} ${bold("unset PUSHARY_API_KEY")}`);
+    console.log(`  ${dim("(or open a new terminal) before setup, or it signs back in as the old account.")}`);
+  }
+  if (aliasRemovedFrom.length > 0) {
+    console.log(`  ${dim("It still has the")} ${bold("claude")} ${dim("alias loaded from before. Run")} ${bold("unalias claude")}`);
+    console.log(`  ${dim("(or open a new terminal) so")} ${bold("claude")} ${dim("runs Claude Code again.")}`);
+  }
+  console.log();
+  if (incompleteClean) process.exit(EXIT.FAILED);
+};
+main();