xclaude-cli 0.1.2

package/dist/xclaude.js

@@ -0,0 +1,4293 @@
+#!/usr/bin/env node
+
+// src/runtime-check.ts
+import fs from "node:fs";
+
+// src/runtime.ts
+var MIN_NODE = [22, 15];
+function runtimeProblem(platform, nodeVersion) {
+  if (platform !== "darwin" && platform !== "linux") {
+    return `${platform} isn't supported; xclaude runs on macOS and Linux (including WSL)`;
+  }
+  const [major = 0, minor = 0] = nodeVersion.split(".").map(Number);
+  if (major < MIN_NODE[0] || major === MIN_NODE[0] && minor < MIN_NODE[1]) {
+    return `Node ${MIN_NODE.join(".")} or later is required (this is ${nodeVersion})`;
+  }
+  return null;
+}
+
+// src/runtime-check.ts
+var problem = runtimeProblem(process.platform, process.versions.node);
+if (problem) {
+  fs.writeSync(2, `xclaude: ${problem}
+`);
+  process.exit(1);
+}
+
+// src/core/errors.ts
+var EXIT_OK = 0;
+var EXIT_ERROR = 1;
+var EXIT_USAGE = 2;
+var EXIT_CANCELLED = 130;
+var XError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = EXIT_ERROR) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+};
+var UsageError = class extends XError {
+  constructor(message) {
+    super(message, EXIT_USAGE);
+  }
+};
+var Cancelled = class extends XError {
+  constructor() {
+    super("", EXIT_CANCELLED);
+  }
+};
+
+// src/core/io.ts
+import fs2 from "node:fs";
+
+// src/core/sleep.ts
+var cell = new Int32Array(new SharedArrayBuffer(4));
+function sleepSync(ms) {
+  Atomics.wait(cell, 0, 0, ms);
+}
+
+// src/core/io.ts
+function writeAll(fd, text) {
+  const buf = Buffer.from(text);
+  let offset = 0;
+  while (offset < buf.length) {
+    try {
+      offset += fs2.writeSync(fd, buf, offset);
+    } catch (e) {
+      const code = e.code;
+      if (code === "EAGAIN") {
+        sleepSync(2);
+        continue;
+      }
+      if (code === "EPIPE") return;
+      throw e;
+    }
+  }
+}
+var stdio = {
+  out: (text) => writeAll(1, text),
+  err: (text) => writeAll(2, text)
+};
+
+// src/ctx.ts
+import tty from "node:tty";
+
+// src/core/paths.ts
+import fs3 from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function resolvePaths(env) {
+  const home = path.resolve(env.HOME || os.homedir());
+  const xhome = path.resolve(env.XCLAUDE_HOME || path.join(home, ".xclaude"));
+  return {
+    home,
+    store: path.join(home, ".claude"),
+    xhome,
+    config: path.join(xhome, "config.json"),
+    state: path.join(xhome, "state.json"),
+    cache: path.join(xhome, "cache"),
+    shell: path.join(xhome, "shell"),
+    locks: path.join(xhome, "locks"),
+    accounts: path.join(xhome, "accounts")
+  };
+}
+function accountDir(paths, name) {
+  return path.join(paths.xhome, "accounts", name);
+}
+function ensureXHome(paths) {
+  fs3.mkdirSync(paths.xhome, { recursive: true, mode: 448 });
+}
+function mkdirPrivate(dir) {
+  fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+}
+function realpathOrNull(p) {
+  try {
+    return fs3.realpathSync.native(p);
+  } catch {
+    return null;
+  }
+}
+function tildify(p, home) {
+  if (p === home) return "~";
+  return p.startsWith(home + path.sep) ? `~${p.slice(home.length)}` : p;
+}
+
+// src/launch/exec.ts
+import { spawn } from "node:child_process";
+import fs6 from "node:fs";
+import os2 from "node:os";
+
+// src/claude/runnable.ts
+import fs5 from "node:fs";
+import path3 from "node:path";
+
+// src/claude/resolve.ts
+import fs4 from "node:fs";
+import path2 from "node:path";
+var INSTALL_HINT = "install it with: curl -fsSL https://claude.ai/install.sh | bash (or npm i -g @anthropic-ai/claude-code)";
+function isExecutableFile(p) {
+  try {
+    fs4.accessSync(p, fs4.constants.X_OK);
+    return fs4.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function fallbackLocations(home) {
+  return [path2.join(home, ".local", "bin", "claude"), "/opt/homebrew/bin/claude", "/usr/local/bin/claude", "/usr/bin/claude"];
+}
+function findClaude(env, config, home, selfPath) {
+  const explicit = [
+    [env.XCLAUDE_CLAUDE_PATH, "XCLAUDE_CLAUDE_PATH"],
+    [config.claudePath, "claudePath in ~/.xclaude/config.json"]
+  ];
+  for (const [value, where] of explicit) {
+    if (!value) continue;
+    if (isExecutableFile(value)) return value;
+    throw new XError(`${where} is set to ${value}, which isn't an executable file`);
+  }
+  const self = selfPath ? realpathOrNull(selfPath) : null;
+  for (const dir of (env.PATH ?? "").split(path2.delimiter)) {
+    if (!dir || !path2.isAbsolute(dir)) continue;
+    const candidate = path2.join(dir, "claude");
+    if (!isExecutableFile(candidate)) continue;
+    if (self && realpathOrNull(candidate) === self) continue;
+    return candidate;
+  }
+  for (const candidate of fallbackLocations(home)) {
+    if (isExecutableFile(candidate)) return candidate;
+  }
+  throw new XError(`Claude Code isn't installed (no \`claude\` found); ${INSTALL_HINT}`);
+}
+
+// src/claude/runnable.ts
+function readHead(file) {
+  try {
+    const fd = fs5.openSync(file, "r");
+    try {
+      const buf = Buffer.alloc(256);
+      return buf.subarray(0, fs5.readSync(fd, buf, 0, buf.length, 0));
+    } finally {
+      fs5.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+var isBinary = (head) => head.length >= 4 && (head[0] === 127 && head.subarray(1, 4).toString("latin1") === "ELF" || [4277009102, 4277009103, 3472551422, 3489328638, 3405691582, 3199925962].includes(head.readUInt32BE(0)));
+var hasShebang = (head) => head[0] === 35 && head[1] === 33;
+function interpreterOf(head) {
+  const line = head.subarray(2).toString("utf8").split("\n")[0];
+  return /^[ \t]*([^ \t]*)/.exec(line)[1];
+}
+function directlyExecutable(file) {
+  const head = readHead(file);
+  if (!head) return false;
+  if (isBinary(head)) return true;
+  if (!hasShebang(head)) return false;
+  const interpreter = interpreterOf(head);
+  const interpreterHead = path3.isAbsolute(interpreter) && isExecutableFile(interpreter) ? readHead(interpreter) : null;
+  return interpreterHead !== null && isBinary(interpreterHead);
+}
+function isShellScript(file) {
+  const head = readHead(file);
+  return head !== null && head.length > 0 && !isBinary(head) && !hasShebang(head) && !head.includes(0);
+}
+function shellWay(file, args) {
+  return isShellScript(file) ? ["/bin/sh", [file, ...args]] : [file, args];
+}
+function isEmptyFile(file) {
+  try {
+    return fs5.statSync(file).size === 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/launch/exec.ts
+function restoreDefaultSignals() {
+  const noop = () => {
+  };
+  for (const sig of ["SIGPIPE", "SIGXFSZ"]) {
+    process.on(sig, noop);
+    process.off(sig, noop);
+  }
+}
+function makeExec(opts) {
+  return async (file, argv, env) => {
+    try {
+      fs6.accessSync(file, fs6.constants.X_OK);
+    } catch {
+      throw new XError(`${file} isn't executable`);
+    }
+    if (isEmptyFile(file)) throw new XError(`${file} is empty, so there's nothing to run`);
+    const [runFile, args] = shellWay(file, argv.slice(1));
+    const runArgv = runFile === file ? argv : ["sh", ...args];
+    if (!opts.spawnFallback && typeof process.execve === "function" && directlyExecutable(runFile)) {
+      restoreDefaultSignals();
+      try {
+        process.execve(runFile, runArgv, env);
+      } catch (e) {
+        throw new XError(`couldn't start ${file}: ${e.message}`);
+      }
+    }
+    return spawnAndMirror(runFile, args, env);
+  };
+}
+function spawnAndMirror(file, args, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, { stdio: "inherit", env });
+    const ignore = () => {
+    };
+    const forwardTerm = () => child.kill("SIGTERM");
+    const forwardHup = () => child.kill("SIGHUP");
+    process.on("SIGINT", ignore);
+    process.on("SIGQUIT", ignore);
+    process.on("SIGTERM", forwardTerm);
+    process.on("SIGHUP", forwardHup);
+    const cleanup = () => {
+      process.off("SIGINT", ignore);
+      process.off("SIGQUIT", ignore);
+      process.off("SIGTERM", forwardTerm);
+      process.off("SIGHUP", forwardHup);
+    };
+    child.on("error", (e) => {
+      cleanup();
+      reject(new XError(`couldn't start ${file}: ${e.message}`));
+    });
+    child.on("exit", (code, signal) => {
+      cleanup();
+      if (signal) {
+        process.kill(process.pid, signal);
+        resolve(128 + (os2.constants.signals[signal] ?? 0));
+        return;
+      }
+      resolve(code ?? 1);
+    });
+  });
+}
+function runChild(file, args, env) {
+  if (isEmptyFile(file)) return Promise.reject(new XError(`${file} is empty, so there's nothing to run`));
+  return new Promise((resolve, reject) => {
+    const child = spawn(...shellWay(file, args), { stdio: "inherit", env });
+    const ignore = () => {
+    };
+    process.on("SIGINT", ignore);
+    process.on("SIGQUIT", ignore);
+    const done = () => {
+      process.off("SIGINT", ignore);
+      process.off("SIGQUIT", ignore);
+    };
+    child.on("error", (e) => {
+      done();
+      reject(new XError(`couldn't start ${file}: ${e.message}`));
+    });
+    child.on("exit", (code, signal) => {
+      done();
+      resolve(signal ? 128 + (os2.constants.signals[signal] ?? 0) : code ?? 1);
+    });
+  });
+}
+
+// src/switches.ts
+var SWITCHES = {
+  shareSessions: true,
+  agentsPerAccount: false,
+  shareHistory: true,
+  shareSkills: true,
+  shareChrome: true,
+  spawnFallback: false,
+  linkIde: false,
+  normalizePaths: false,
+  keepSameEmailLogin: false
+};
+function loadSwitches(env) {
+  const switches = { ...SWITCHES };
+  for (const item of (env.XCLAUDE_SWITCHES ?? "").split(",")) {
+    const [name = "", value = "1"] = item.trim().split("=");
+    if (Object.hasOwn(switches, name)) switches[name] = value === "1" || value === "true";
+  }
+  return switches;
+}
+
+// src/ctx.ts
+function processCtx(io) {
+  const switches = loadSwitches(process.env);
+  return {
+    env: process.env,
+    cwd: process.cwd(),
+    paths: resolvePaths(process.env),
+    io,
+    // tty.isatty, never process.stdin.isTTY: touching Node's stdio streams makes
+    // a terminal fd non-blocking, and claude would inherit that through exec.
+    tty: { stdin: tty.isatty(0), stdout: tty.isatty(1), stderr: tty.isatty(2) },
+    switches,
+    exec: makeExec({ spawnFallback: switches.spawnFallback }),
+    selfPath: process.argv[1] ?? null
+  };
+}
+
+// src/commands/add.ts
+import fs14 from "node:fs";
+
+// src/claude/auth.ts
+import { execFile } from "node:child_process";
+function runClaude(claude, args, env, timeoutMs = 3e4) {
+  return new Promise((resolve) => {
+    const [file, fileArgs] = shellWay(claude, args);
+    execFile(file, fileArgs, { env, timeout: timeoutMs, encoding: "utf8", maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+      const code = error ? typeof error.code === "number" ? error.code : null : 0;
+      resolve({ code, stdout: stdout ?? "", stderr: stderr ?? (error ? error.message : "") });
+    });
+  });
+}
+async function authStatus(claude, env) {
+  const res = await runClaude(claude, ["auth", "status"], env);
+  try {
+    const json = JSON.parse(res.stdout);
+    const str = (v) => typeof v === "string" && v ? v : null;
+    return {
+      loggedIn: json.loggedIn === true,
+      email: str(json.email),
+      orgId: str(json.orgId),
+      orgName: str(json.orgName),
+      error: null
+    };
+  } catch {
+    const why = (res.stderr || res.stdout).trim().split("\n")[0] || `exit code ${res.code}`;
+    return { loggedIn: false, email: null, orgId: null, orgName: null, error: why };
+  }
+}
+function describeLogin(s) {
+  if (s.error) return `unknown (${s.error})`;
+  if (!s.loggedIn) return "not logged in";
+  const who = s.email ?? "logged in";
+  return s.orgName ? `${who} (${s.orgName})` : who;
+}
+
+// src/core/config.ts
+import fs8 from "node:fs";
+
+// src/core/fsutil.ts
+import fs7 from "node:fs";
+import path4 from "node:path";
+var fsops = {
+  link: (src, dst) => fs7.linkSync(src, dst)
+};
+function errCode(e) {
+  return e?.code;
+}
+function lstatOrNull(p) {
+  try {
+    return fs7.lstatSync(p);
+  } catch (e) {
+    if (errCode(e) === "ENOENT" || errCode(e) === "ENOTDIR") return null;
+    throw e;
+  }
+}
+function statOrNull(p) {
+  try {
+    return fs7.statSync(p);
+  } catch (e) {
+    if (errCode(e) === "ENOENT" || errCode(e) === "ENOTDIR" || errCode(e) === "ELOOP") return null;
+    throw e;
+  }
+}
+function readlinkOrNull(p) {
+  try {
+    return fs7.readlinkSync(p);
+  } catch (e) {
+    if (errCode(e) === "ENOENT" || errCode(e) === "EINVAL" || errCode(e) === "ENOTDIR") return null;
+    throw e;
+  }
+}
+function readFileOrNull(p) {
+  try {
+    return fs7.readFileSync(p, "utf8");
+  } catch (e) {
+    if (errCode(e) === "ENOENT" || errCode(e) === "ENOTDIR") return null;
+    throw e;
+  }
+}
+var counter = 0;
+function siblingName(target, tag) {
+  return path4.join(path4.dirname(target), `.xclaude-${tag}-${path4.basename(target)}-${process.pid}-${Date.now()}-${counter++}`);
+}
+function writeFileAtomic(path_, data, opts = {}) {
+  let file = path_;
+  try {
+    file = fs7.realpathSync(path_);
+  } catch {
+  }
+  const existing = statOrNull(file);
+  const mode = existing ? existing.mode & 4095 : opts.mode ?? 384;
+  const tmp = siblingName(file, "tmp");
+  const fd = fs7.openSync(tmp, "wx", mode);
+  try {
+    fs7.writeFileSync(fd, data);
+    if (opts.fsync) fs7.fsyncSync(fd);
+  } finally {
+    fs7.closeSync(fd);
+  }
+  try {
+    fs7.chmodSync(tmp, mode);
+    fs7.renameSync(tmp, file);
+  } catch (e) {
+    fs7.rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+function removeTree(p) {
+  const st = lstatOrNull(p);
+  if (!st) return;
+  if (!st.isDirectory()) {
+    fs7.unlinkSync(p);
+    return;
+  }
+  const retry = (op) => {
+    try {
+      return op();
+    } catch (e) {
+      if (errCode(e) !== "EACCES" && errCode(e) !== "EPERM") throw e;
+      fs7.chmodSync(p, 448);
+      return op();
+    }
+  };
+  for (const name of retry(() => fs7.readdirSync(p))) {
+    retry(() => removeTree(path4.join(p, name)));
+  }
+  fs7.rmdirSync(p);
+}
+function moveNoClobber(src, dst, srcStat) {
+  try {
+    if (srcStat.isSymbolicLink()) fs7.symlinkSync(fs7.readlinkSync(src), dst);
+    else fsops.link(src, dst);
+  } catch (e) {
+    if (errCode(e) === "EEXIST") return "exists";
+    throw e;
+  }
+  fs7.unlinkSync(src);
+  return "moved";
+}
+function sameContent(a, b) {
+  const sa = fs7.statSync(a);
+  const sb = fs7.statSync(b);
+  if (sa.size !== sb.size) return false;
+  if (sa.ino === sb.ino && sa.dev === sb.dev) return true;
+  const fa = fs7.openSync(a, "r");
+  const fb = fs7.openSync(b, "r");
+  try {
+    const ba = Buffer.alloc(65536);
+    const bb = Buffer.alloc(65536);
+    for (; ; ) {
+      const na = fs7.readSync(fa, ba, 0, ba.length, null);
+      const nb = fs7.readSync(fb, bb, 0, bb.length, null);
+      if (na !== nb) return false;
+      if (na === 0) return true;
+      if (!ba.subarray(0, na).equals(bb.subarray(0, nb))) return false;
+    }
+  } finally {
+    fs7.closeSync(fa);
+    fs7.closeSync(fb);
+  }
+}
+function stamp(now = /* @__PURE__ */ new Date()) {
+  return now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+}
+
+// src/core/config.ts
+var EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultracode"];
+var COMMANDS = ["add", "rm", "ls", "set", "tmux", "doctor", "shell", "guard", "help"];
+var MAIN = "main";
+var ACCOUNT_NAME = /^[a-z][a-z0-9-]{0,31}$/;
+function defaultConfig() {
+  return {
+    version: 1,
+    main: { enabled: false, model: null, effort: null, args: [] },
+    accounts: {},
+    share: { add: [], remove: [] },
+    guard: false,
+    tmux: { statusRight: true },
+    claudePath: null
+  };
+}
+function isEffort(value) {
+  return EFFORTS.includes(value);
+}
+function accountNameProblem(name) {
+  if (name === MAIN) return `"${MAIN}" is reserved for the main identity (xclaude set main --enable)`;
+  if (COMMANDS.includes(name)) return `"${name}" is reserved: it's an xclaude command`;
+  if (name.startsWith("-") || name.startsWith("_")) return `"${name}" is reserved: names can't start with - or _`;
+  if (!ACCOUNT_NAME.test(name)) {
+    return `"${name}" isn't a valid account name: use lowercase letters, digits and dashes, start with a letter, at most 32 characters`;
+  }
+  return null;
+}
+function isEntryName(name) {
+  return name.length > 0 && name !== "." && name !== ".." && !name.includes("/") && !name.includes("\0");
+}
+var ConfigProblem = class extends Error {
+};
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function field(obj, key, where, fallback, check, expected) {
+  if (!(key in obj) || obj[key] === void 0) return fallback;
+  const v = obj[key];
+  if (!check(v)) throw new ConfigProblem(`${where}${key} must be ${expected}`);
+  return v;
+}
+var isBool = (v) => typeof v === "boolean";
+var isStringOrNull = (v) => v === null || typeof v === "string" && v.length > 0;
+var isStringArray = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
+var isEffortOrNull = (v) => v === null || typeof v === "string" && isEffort(v);
+function parseDefaults(raw, where) {
+  if (!isObject(raw)) throw new ConfigProblem(`${where.replace(/\.$/, "")} must be an object`);
+  return {
+    ...raw,
+    model: field(raw, "model", where, null, isStringOrNull, "a model name or null"),
+    effort: field(raw, "effort", where, null, isEffortOrNull, `one of ${EFFORTS.join(", ")}, or null`),
+    args: field(raw, "args", where, [], isStringArray, "a list of strings")
+  };
+}
+function validateConfig(raw) {
+  if (!isObject(raw)) throw new ConfigProblem("the top level must be an object");
+  const version = raw.version ?? 1;
+  if (version !== 1) throw new ConfigProblem(`version ${JSON.stringify(version)} isn't supported (expected 1)`);
+  const mainRaw = raw.main ?? {};
+  const main2 = parseDefaults(mainRaw, "main.");
+  const enabled = field(mainRaw, "enabled", "main.", false, isBool, "true or false");
+  const accountsRaw = raw.accounts ?? {};
+  if (!isObject(accountsRaw)) throw new ConfigProblem("accounts must be an object");
+  const accounts = {};
+  for (const [name, value] of Object.entries(accountsRaw)) {
+    const problem2 = accountNameProblem(name);
+    if (problem2) throw new ConfigProblem(`accounts: ${problem2}`);
+    accounts[name] = parseDefaults(value, `accounts.${name}.`);
+  }
+  const shareRaw = raw.share ?? {};
+  if (!isObject(shareRaw)) throw new ConfigProblem("share must be an object");
+  const share = {
+    ...shareRaw,
+    add: field(shareRaw, "add", "share.", [], isStringArray, "a list of entry names"),
+    remove: field(shareRaw, "remove", "share.", [], isStringArray, "a list of entry names")
+  };
+  for (const name of [...share.add, ...share.remove]) {
+    if (!isEntryName(name)) throw new ConfigProblem(`share: "${name}" isn't an entry name (one path component)`);
+  }
+  const tmuxRaw = raw.tmux ?? {};
+  if (!isObject(tmuxRaw)) throw new ConfigProblem("tmux must be an object");
+  return {
+    ...raw,
+    version: 1,
+    main: { ...main2, enabled },
+    accounts,
+    share,
+    guard: field(raw, "guard", "", false, isBool, "true or false"),
+    tmux: { ...tmuxRaw, statusRight: field(tmuxRaw, "statusRight", "tmux.", true, isBool, "true or false") },
+    claudePath: field(raw, "claudePath", "", null, isStringOrNull, "a path or null")
+  };
+}
+function parseConfig(text, file) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    throw new XError(`${file} isn't valid JSON: ${e.message}`);
+  }
+  try {
+    return validateConfig(raw);
+  } catch (e) {
+    if (e instanceof ConfigProblem) throw new XError(`${file}: ${e.message}`);
+    throw e;
+  }
+}
+function loadConfig(paths, opts) {
+  let text;
+  try {
+    text = fs8.readFileSync(paths.config, "utf8");
+  } catch (e) {
+    if (errCode(e) !== "ENOENT") throw e;
+    const config = defaultConfig();
+    if (!opts.create) return { config, created: false };
+    ensureXHome(paths);
+    saveConfig(paths, config);
+    if (!fs8.existsSync(paths.state)) writeFileAtomic(paths.state, "{}\n", { mode: 384 });
+    return { config, created: true };
+  }
+  return { config: parseConfig(text, tildify(paths.config, paths.home)), created: false };
+}
+function saveConfig(paths, config) {
+  ensureXHome(paths);
+  writeFileAtomic(paths.config, `${JSON.stringify(config, null, 2)}
+`, { mode: 384, fsync: true });
+}
+function identities(config) {
+  const names = Object.keys(config.accounts);
+  if (config.main.enabled) names.push(MAIN);
+  return names;
+}
+function defaultsOf(config, name) {
+  if (name === MAIN) return config.main.enabled ? config.main : null;
+  return Object.hasOwn(config.accounts, name) ? config.accounts[name] : null;
+}
+function describeDefaults(d) {
+  const parts = [d.model, d.effort, d.args.length ? d.args.join(" ") : null].filter((x) => Boolean(x));
+  return parts.join(" \xB7 ");
+}
+
+// src/core/options.ts
+function parseOptions(args, defs, command) {
+  const values = {};
+  const positionals = [];
+  const byShort = new Map(Object.entries(defs).filter(([, d]) => d.short).map(([n, d]) => [`-${d.short}`, n]));
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--") {
+      positionals.push(...args.slice(i + 1));
+      break;
+    }
+    if (!a.startsWith("-") || a === "-") {
+      positionals.push(a);
+      continue;
+    }
+    const eq = a.indexOf("=");
+    const flag = a.startsWith("--") && eq > 0 ? a.slice(0, eq) : a;
+    const name = flag.startsWith("--") ? flag.slice(2) : byShort.get(flag);
+    const def = name !== void 0 ? defs[name] : void 0;
+    if (name === void 0 || !def) throw new UsageError(`${command}: unknown option ${flag} (see xclaude help ${command})`);
+    let value = true;
+    if (def.value) {
+      if (eq > 0 && flag !== a) value = a.slice(eq + 1);
+      else if (i + 1 < args.length) value = args[++i];
+      else throw new UsageError(`${command}: ${flag} needs a value`);
+    } else if (flag !== a) {
+      throw new UsageError(`${command}: ${flag} doesn't take a value`);
+    }
+    if (def.repeat) values[name] = [...values[name] ?? [], value];
+    else values[name] = value;
+  }
+  return { values, positionals };
+}
+function stringOption(p, name) {
+  const v = p.values[name];
+  return typeof v === "string" ? v : void 0;
+}
+
+// src/launch/env.ts
+function buildEnv(base, identity) {
+  const env = {};
+  for (const [k, v] of Object.entries(base)) if (v !== void 0) env[k] = v;
+  if (identity.configDir) env.CLAUDE_CONFIG_DIR = identity.configDir;
+  else delete env.CLAUDE_CONFIG_DIR;
+  delete env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+  env.XCLAUDE_ACCOUNT = identity.name;
+  return env;
+}
+function identityEnv(ctx, name) {
+  return buildEnv(ctx.env, { name, configDir: name === MAIN ? null : accountDir(ctx.paths, name) });
+}
+
+// src/link/repair.ts
+import fs13 from "node:fs";
+import path9 from "node:path";
+
+// src/core/lock.ts
+import fs9 from "node:fs";
+import path5 from "node:path";
+var STORE_LOCK = { staleMs: 3e4, refreshMs: 5e3 };
+var HISTORY_LOCK = { staleMs: 1e4, refreshMs: 2500 };
+var DirLock = class _DirLock {
+  path;
+  timing;
+  mtimeMs = 0;
+  lastRefresh = 0;
+  released = false;
+  constructor(lockPath, timing) {
+    this.path = lockPath;
+    this.timing = timing;
+    this.stampNow();
+  }
+  /** Takes the lock, or returns null if it stayed busy for waitMs. */
+  static acquire(lockPath, timing, opts) {
+    const deadline = Date.now() + opts.waitMs;
+    for (; ; ) {
+      try {
+        fs9.mkdirSync(lockPath, { mode: 448 });
+        return new _DirLock(lockPath, timing);
+      } catch (e) {
+        if (errCode(e) === "ENOENT") {
+          fs9.mkdirSync(path5.dirname(lockPath), { recursive: true, mode: 448 });
+          continue;
+        }
+        if (errCode(e) !== "EEXIST") throw e;
+      }
+      const st = statOrNull(lockPath);
+      if (st && Date.now() - st.mtimeMs > timing.staleMs) {
+        takeOverStale(lockPath);
+        continue;
+      }
+      if (Date.now() >= deadline) return null;
+      opts.onWait?.();
+      sleepSync(opts.pollMs ?? 50);
+    }
+  }
+  /** True while the lock dir exists with the mtime this holder last set. */
+  held() {
+    if (this.released) return false;
+    const st = statOrNull(this.path);
+    return st !== null && st.mtimeMs === this.mtimeMs;
+  }
+  /**
+   * Refreshes the mtime if refreshMs has passed (or always, with force).
+   * Returns false, without touching anything, when the lock is no longer ours.
+   */
+  refresh(force = false) {
+    if (!this.held()) return false;
+    if (force || Date.now() - this.lastRefresh >= this.timing.refreshMs) this.stampNow();
+    return true;
+  }
+  /** Removes the lock dir, but only while it's still ours. */
+  release() {
+    if (this.held()) {
+      try {
+        fs9.rmdirSync(this.path);
+      } catch (e) {
+        if (errCode(e) !== "ENOENT") throw e;
+      }
+    }
+    this.released = true;
+  }
+  stampNow() {
+    const now = /* @__PURE__ */ new Date();
+    fs9.utimesSync(this.path, now, now);
+    this.mtimeMs = fs9.statSync(this.path).mtimeMs;
+    this.lastRefresh = Date.now();
+  }
+};
+function takeOverStale(lockPath) {
+  try {
+    fs9.rmdirSync(lockPath);
+  } catch (e) {
+    if (errCode(e) === "ENOENT") return;
+    if (errCode(e) === "ENOTEMPTY" || errCode(e) === "EEXIST") removeTree(lockPath);
+    else throw e;
+  }
+}
+
+// src/link/history.ts
+import fs11 from "node:fs";
+import path7 from "node:path";
+
+// src/link/merge.ts
+import fs10 from "node:fs";
+import path6 from "node:path";
+var counter2 = 0;
+function asideName(entry) {
+  return `.xclaude-merge-${entry}-${stamp()}-${process.pid}-${counter2++}`;
+}
+function parseAside(name) {
+  const m = /^\.xclaude-merge-(.+)-\d{8}T\d{6}Z-\d+-\d+$/.exec(name);
+  return m ? m[1] : null;
+}
+var LockLost = class extends Error {
+  constructor() {
+    super("another xclaude took over the repair lock");
+  }
+};
+function emptyStats() {
+  return { moved: 0, dropped: 0, conflicts: [] };
+}
+function newRecord() {
+  return { placed: /* @__PURE__ */ new Map(), created: [], byPath: /* @__PURE__ */ new Map() };
+}
+function remember(rec, c) {
+  rec.created.push(c);
+  rec.byPath.set(c.path, c);
+}
+function requireRealDir(dir) {
+  const st = fs10.lstatSync(dir);
+  if (!st.isDirectory()) throw new Error(`${dir} isn't a real directory; it won't be read through`);
+  return st;
+}
+function linkText(src, root) {
+  const text = fs10.readlinkSync(src);
+  if (path6.isAbsolute(text)) return text;
+  const resolved = path6.resolve(path6.dirname(src), text);
+  return resolved === root || resolved.startsWith(`${root}${path6.sep}`) ? text : resolved;
+}
+function identicalEntry(src, srcStat, dst, root) {
+  const dstStat = lstatOrNull(dst);
+  if (!dstStat) return false;
+  if (srcStat.isSymbolicLink()) {
+    if (!dstStat.isSymbolicLink()) return false;
+    const there = fs10.readlinkSync(dst);
+    return there === linkText(src, root) || there === fs10.readlinkSync(src);
+  }
+  return srcStat.isFile() && dstStat.isFile() && sameContent(src, dst);
+}
+function sameInode(a, b) {
+  return b !== null && a.ino === b.ino && a.dev === b.dev;
+}
+function stillPlaced(p, src, st, root) {
+  if (p.identical || st.isSymbolicLink()) return identicalEntry(src, st, p.target, root);
+  return sameInode(st, lstatOrNull(p.target));
+}
+function conflictName(dir, name, ctx) {
+  const base = `${name}.xclaude-conflict-${ctx.account}-${ctx.stamp}`;
+  for (let n = 1; ; n++) {
+    const candidate = n === 1 ? base : `${base}-${n}`;
+    if (!lstatOrNull(path6.join(dir, candidate))) return candidate;
+  }
+}
+var join = (rel, name) => rel ? `${rel}/${name}` : name;
+function linkTree(src, dst, ctx, stats, rec, root = src, rel = "") {
+  let fresh = 0;
+  for (const d of fs10.readdirSync(src, { withFileTypes: true })) {
+    ctx.refresh();
+    const s = path6.join(src, d.name);
+    const t = path6.join(dst, d.name);
+    const relName = join(rel, d.name);
+    const st = fs10.lstatSync(s);
+    const prior = rec.placed.get(relName);
+    if (st.isDirectory()) {
+      let target = t;
+      if (prior && lstatOrNull(prior.target)?.isDirectory()) {
+        target = prior.target;
+      } else {
+        try {
+          fs10.mkdirSync(t, { mode: st.mode & 4095 | 448 });
+          remember(rec, { path: t, kind: "dir" });
+        } catch (e) {
+          if (errCode(e) !== "EEXIST") throw e;
+          if (!fs10.lstatSync(t).isDirectory()) {
+            const name2 = conflictName(dst, d.name, ctx);
+            target = path6.join(dst, name2);
+            fs10.mkdirSync(target, { mode: st.mode & 4095 | 448 });
+            remember(rec, { path: target, kind: "dir" });
+            stats.conflicts.push(join(rel, name2));
+          }
+        }
+        rec.placed.set(relName, { target });
+        fresh++;
+      }
+      fresh += linkTree(s, target, ctx, stats, rec, root, relName);
+      continue;
+    }
+    if (prior && stillPlaced(prior, s, st, root)) continue;
+    const place = (to) => {
+      if (st.isSymbolicLink()) {
+        const link = linkText(s, root);
+        fs10.symlinkSync(link, to);
+        remember(rec, { path: to, kind: "symlink", link });
+      } else {
+        fsops.link(s, to);
+        remember(rec, { path: to, kind: "file", ino: st.ino, dev: st.dev });
+      }
+    };
+    fresh++;
+    try {
+      place(t);
+      rec.placed.set(relName, { target: t });
+      stats.moved++;
+      continue;
+    } catch (e) {
+      if (errCode(e) !== "EEXIST") throw e;
+    }
+    if (!st.isSymbolicLink() && sameInode(st, lstatOrNull(t))) {
+      rec.placed.set(relName, { target: t });
+      continue;
+    }
+    if (identicalEntry(s, st, t, root)) {
+      rec.placed.set(relName, { target: t, identical: true });
+      stats.dropped++;
+      continue;
+    }
+    const name = conflictName(dst, d.name, ctx);
+    place(path6.join(dst, name));
+    rec.placed.set(relName, { target: path6.join(dst, name) });
+    stats.moved++;
+    stats.conflicts.push(join(rel, name));
+  }
+  return fresh;
+}
+function undoLinks(rec) {
+  for (const c of [...rec.created].reverse()) {
+    const st = lstatOrNull(c.path);
+    if (!st) continue;
+    try {
+      if (c.kind === "dir" && st.isDirectory()) fs10.rmdirSync(c.path);
+      else if (c.kind === "symlink" && st.isSymbolicLink() && fs10.readlinkSync(c.path) === c.link) fs10.unlinkSync(c.path);
+      else if (c.kind === "file" && st.ino === c.ino && st.dev === c.dev) fs10.unlinkSync(c.path);
+    } catch {
+    }
+  }
+}
+function openForEmptying(dir) {
+  const st = requireRealDir(dir);
+  if ((st.mode & 448) !== 448) fs10.chmodSync(dir, st.mode & 4095 | 448);
+  return fs10.readdirSync(dir, { withFileTypes: true });
+}
+function takeOver(src, placed, rec, dst, ctx, stats, rel) {
+  const ours = rec.byPath.get(placed.target);
+  const there = lstatOrNull(placed.target);
+  if (!ours || ours.kind !== "file" || !there || there.ino !== ours.ino || there.dev !== ours.dev) return false;
+  const base = path6.basename(placed.target);
+  const old = conflictName(dst, base, ctx);
+  fsops.link(placed.target, path6.join(dst, old));
+  const tmp = path6.join(dst, `.xclaude-tmp-${base}-${process.pid}-${counter2++}`);
+  fsops.link(src, tmp);
+  fs10.renameSync(tmp, placed.target);
+  fs10.unlinkSync(src);
+  stats.conflicts.push(join(rel, old));
+  return true;
+}
+function moveTree(src, dst, ctx, stats, rec = null, root = src, rel = "") {
+  const entries = openForEmptying(src);
+  const isPlaced = (name) => Boolean(rec?.placed.has(join(rel, name)));
+  entries.sort((a, b) => Number(isPlaced(a.name)) - Number(isPlaced(b.name)));
+  for (const d of entries) {
+    ctx.refresh();
+    const s = path6.join(src, d.name);
+    const st = fs10.lstatSync(s);
+    const relName = join(rel, d.name);
+    const placed = rec?.placed.get(relName);
+    if (st.isDirectory()) {
+      let target = path6.join(dst, d.name);
+      if (placed && lstatOrNull(placed.target)?.isDirectory()) {
+        target = placed.target;
+      } else {
+        try {
+          fs10.mkdirSync(target, { mode: st.mode & 4095 | 448 });
+        } catch (e) {
+          if (errCode(e) !== "EEXIST") throw e;
+          if (!fs10.lstatSync(target).isDirectory()) {
+            const name2 = conflictName(dst, d.name, ctx);
+            target = path6.join(dst, name2);
+            fs10.mkdirSync(target, { mode: st.mode & 4095 | 448 });
+            stats.conflicts.push(join(rel, name2));
+          }
+        }
+      }
+      moveTree(s, target, ctx, stats, rec, root, relName);
+      fs10.rmdirSync(s);
+      continue;
+    }
+    if (placed) {
+      if (stillPlaced(placed, s, st, root)) {
+        fs10.unlinkSync(s);
+        continue;
+      }
+      if (st.isFile() && !placed.identical && rec && takeOver(s, placed, rec, dst, ctx, stats, rel)) {
+        stats.moved++;
+        continue;
+      }
+    }
+    if (st.isSymbolicLink()) {
+      const link = linkText(s, root);
+      const to = path6.join(dst, d.name);
+      try {
+        fs10.symlinkSync(link, to);
+        fs10.unlinkSync(s);
+        stats.moved++;
+        continue;
+      } catch (e) {
+        if (errCode(e) !== "EEXIST") throw e;
+      }
+    } else if (moveNoClobber(s, path6.join(dst, d.name), st) === "moved") {
+      stats.moved++;
+      continue;
+    }
+    if (identicalEntry(s, st, path6.join(dst, d.name), root)) {
+      fs10.unlinkSync(s);
+      stats.dropped++;
+      continue;
+    }
+    const name = conflictName(dst, d.name, ctx);
+    if (st.isSymbolicLink()) {
+      fs10.symlinkSync(linkText(s, root), path6.join(dst, name));
+      fs10.unlinkSync(s);
+    } else if (moveNoClobber(s, path6.join(dst, name), st) !== "moved") {
+      throw new Error(`can't place ${relName}: ${name} is taken`);
+    }
+    stats.moved++;
+    stats.conflicts.push(join(rel, name));
+  }
+}
+function summarize(account, entry, storeLabel, stats) {
+  if (stats.moved + stats.dropped === 0 && stats.conflicts.length === 0) return null;
+  const parts = [`${stats.moved} moved`];
+  if (stats.dropped) parts.push(`${stats.dropped} identical dropped`);
+  let line = `xclaude: merged ${account}/${entry} into ${storeLabel}: ${parts.join(", ")}`;
+  if (stats.conflicts.length) {
+    const shown = stats.conflicts.slice(0, 3).join(", ");
+    const more = stats.conflicts.length > 3 ? ` and ${stats.conflicts.length - 3} more` : "";
+    line += `; ${stats.conflicts.length} conflict${stats.conflicts.length > 1 ? "s" : ""} kept as ${shown}${more}`;
+  }
+  return line;
+}
+
+// src/link/table.ts
+var HISTORY = "history.jsonl";
+var STUB = "CLAUDE.md";
+var SHARED_DIRS = [
+  "projects",
+  "sessions",
+  "session-env",
+  "file-history",
+  "tasks",
+  "todos",
+  "teams",
+  "plans",
+  "paste-cache",
+  "image-cache",
+  "uploads",
+  "downloads",
+  "debug",
+  "chrome",
+  "skills",
+  "agents",
+  "commands",
+  "rules",
+  "output-styles",
+  "themes",
+  "workflows",
+  "hooks",
+  "agent-memory",
+  "memory",
+  "plugins"
+];
+var OPTIONAL_DIRS = /* @__PURE__ */ new Set(["memory"]);
+var NEVER_SHARED = [
+  ".claude.json",
+  ".claude.json.backup",
+  ".credentials.json",
+  "settings.json",
+  "settings.local.json",
+  "keybindings.json",
+  "remote-settings.json",
+  "policy-limits.json",
+  "jobs",
+  "daemon"
+];
+var PER_ACCOUNT = [
+  ...NEVER_SHARED,
+  "backups",
+  "cache",
+  "shell-snapshots",
+  "stats-cache.json",
+  "usage-data",
+  "ide"
+];
+var APPENDIX_A = [
+  ".claude.json",
+  ".claude.json.backup",
+  ".credentials.json",
+  "projects",
+  "sessions",
+  "todos",
+  "shell-snapshots",
+  "statsig",
+  "file-history",
+  "history.jsonl",
+  "ide",
+  "logs",
+  "backups",
+  ".session_ingress_token",
+  "policy-limits.json",
+  "remote-settings.json",
+  "hfi-auth.json",
+  "daemon",
+  "jobs",
+  "teams",
+  "usage-data",
+  "shares",
+  "state",
+  "uploads",
+  "feedback",
+  "feedback-bundles",
+  "plans",
+  "telemetry",
+  "dump-prompts",
+  "debug",
+  "traces",
+  "startup-perf",
+  "cache",
+  "mcp-discovery-cache",
+  "mcp-needs-auth-cache.json",
+  "gh-pr-status-cache.json",
+  "tasks",
+  "local",
+  "antproto.json",
+  "ccr",
+  "session-env",
+  "bridge-spawn",
+  "active-time.json",
+  "loop.md",
+  "server-sessions.json",
+  "image-cache",
+  "paste-cache",
+  "file-transfers",
+  "mcp-skill-archives",
+  "stats-cache.json",
+  "computer-use.lock",
+  "server.lock",
+  "api-dumps",
+  "chrome",
+  "downloads",
+  "local-settings",
+  "project-settings",
+  "remote",
+  "scratch",
+  "seed-admin",
+  "storage-v2",
+  "systemd"
+];
+var APPENDIX_A_PATTERNS = [/^daemon\.log/, /^policy-limits\.json\.stamp\.json$/];
+function shareTable(config, switches) {
+  const off = new Set(config.share.remove);
+  if (!switches.shareSessions) off.add("sessions");
+  if (!switches.shareSkills) off.add("skills");
+  if (!switches.shareChrome) off.add("chrome");
+  const dirs = SHARED_DIRS.filter((e) => !off.has(e));
+  if (switches.linkIde && !off.has("ide")) dirs.push("ide");
+  const refused = [];
+  for (const name of config.share.add) {
+    if (!isShareableDirName(name)) refused.push(name);
+    else if (!dirs.includes(name) && !off.has(name)) dirs.push(name);
+  }
+  return {
+    dirs,
+    history: switches.shareHistory && !off.has(HISTORY),
+    stub: !off.has(STUB),
+    refused
+  };
+}
+function isShareableDirName(name) {
+  const lower = name.toLowerCase();
+  const perAccount = [...PER_ACCOUNT, ...APPENDIX_A, HISTORY, STUB].filter((n) => !SHARED_DIRS.includes(n)).map((n) => n.toLowerCase());
+  if (perAccount.includes(lower)) return false;
+  return !name.startsWith(".") && !/\.(json|jsonl|md|txt|log|lock|yaml|yml|toml|db|sqlite)$/i.test(name);
+}
+function isIgnored(name) {
+  return name.endsWith(".lock") || name.startsWith(".xclaude-") || name === ".DS_Store" || /\.tmp(?:[.-]|$)/.test(name);
+}
+function isKnown(name, table) {
+  return table.dirs.includes(name) || name === HISTORY || name === STUB || SHARED_DIRS.includes(name) || PER_ACCOUNT.includes(name) || APPENDIX_A.includes(name) || APPENDIX_A_PATTERNS.some((re) => re.test(name));
+}
+
+// src/link/history.ts
+function timestampOf(line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (typeof entry !== "object" || entry === null) return null;
+  const ts = entry.timestamp;
+  if (typeof ts === "number" && Number.isFinite(ts)) return ts;
+  if (typeof ts === "string") {
+    const ms = Date.parse(ts);
+    return Number.isNaN(ms) ? null : ms;
+  }
+  return null;
+}
+function mergeHistoryLines(store, account) {
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  [store, account].forEach((lines, src) => {
+    let key = -Infinity;
+    lines.forEach((line, idx) => {
+      if (line.trim() === "" || seen.has(line)) return;
+      seen.add(line);
+      key = timestampOf(line) ?? key;
+      items.push({ line, key, src, idx });
+    });
+  });
+  items.sort((a, b) => a.key - b.key || a.src - b.src || a.idx - b.idx);
+  return items.map((i) => i.line);
+}
+function readLines(file) {
+  return (readFileOrNull(file) ?? "").split("\n");
+}
+function storeLockPath(S) {
+  return `${realpathOrNull(path7.join(S, HISTORY)) ?? path7.join(S, HISTORY)}.lock`;
+}
+function mergeAsideIntoStore(ctx, aside, alsoHeld) {
+  const refreshAll = () => {
+    ctx.refreshStoreLock();
+    alsoHeld?.refresh();
+  };
+  const waitMs = alsoHeld ? Math.min(ctx.lockWaitMs, 5e3) : ctx.lockWaitMs;
+  const storeLock = DirLock.acquire(storeLockPath(ctx.S), HISTORY_LOCK, { waitMs, onWait: refreshAll });
+  if (!storeLock) return { ok: false, reason: "the shared history.jsonl is busy" };
+  try {
+    const storeFile = realpathOrNull(path7.join(ctx.S, HISTORY));
+    if (!storeFile) return { ok: false, reason: "~/.claude/history.jsonl doesn't resolve" };
+    const storeLines = readLines(storeFile);
+    const merged = mergeHistoryLines(storeLines, readLines(aside));
+    refreshAll();
+    if (!storeLock.refresh() || alsoHeld && !alsoHeld.refresh()) return { ok: false, reason: "a history lock was taken over" };
+    writeFileAtomic(storeFile, merged.length ? `${merged.join("\n")}
+` : "", { mode: 384, fsync: true });
+    fs11.unlinkSync(aside);
+    const before = new Set(storeLines);
+    return { ok: true, added: merged.filter((line) => !before.has(line)).length };
+  } finally {
+    storeLock.release();
+  }
+}
+function mergeHistory(ctx) {
+  const file = path7.join(ctx.A, HISTORY);
+  const accountLock = DirLock.acquire(`${file}.lock`, HISTORY_LOCK, { waitMs: ctx.lockWaitMs, onWait: ctx.refreshStoreLock });
+  if (!accountLock) return { ok: false, reason: `this account's history.jsonl is busy` };
+  try {
+    const st = lstatOrNull(file);
+    if (!st?.isFile()) return { ok: true, added: 0 };
+    const storeFile = realpathOrNull(path7.join(ctx.S, HISTORY));
+    if (!storeFile) return { ok: false, reason: "~/.claude/history.jsonl doesn't resolve" };
+    const aside = path7.join(ctx.A, asideName(HISTORY));
+    fs11.linkSync(file, aside);
+    const tmp = siblingName(file, "link");
+    fs11.symlinkSync(storeFile, tmp);
+    fs11.renameSync(tmp, file);
+    return mergeAsideIntoStore(ctx, aside, accountLock);
+  } finally {
+    accountLock.release();
+  }
+}
+function resumeHistoryAside(ctx, aside, shared) {
+  const file = path7.join(ctx.A, HISTORY);
+  const st = lstatOrNull(file);
+  const asideStat = fs11.lstatSync(aside);
+  if (st?.isFile() && st.ino === asideStat.ino && st.dev === asideStat.dev) {
+    fs11.unlinkSync(aside);
+    return { ok: true, added: 0 };
+  }
+  if (!shared) return mergeAsideIntoAccount(ctx, aside);
+  return mergeAsideIntoStore(ctx, aside, null);
+}
+function mergeAsideIntoAccount(ctx, aside) {
+  const file = path7.join(ctx.A, HISTORY);
+  const lock = DirLock.acquire(`${file}.lock`, HISTORY_LOCK, { waitMs: ctx.lockWaitMs, onWait: ctx.refreshStoreLock });
+  if (!lock) return { ok: false, reason: "this account's history.jsonl is busy" };
+  try {
+    const st = lstatOrNull(file);
+    if (st && !st.isFile()) return { ok: false, reason: "this account's history.jsonl isn't a regular file" };
+    const own = readLines(file);
+    const merged = mergeHistoryLines(own, readLines(aside));
+    if (!lock.refresh()) return { ok: false, reason: "a history lock was taken over" };
+    writeFileAtomic(file, merged.length ? `${merged.join("\n")}
+` : "", { mode: 384, fsync: true });
+    fs11.unlinkSync(aside);
+    const before = new Set(own);
+    return { ok: true, added: merged.filter((line) => !before.has(line)).length };
+  } finally {
+    lock.release();
+  }
+}
+
+// src/link/stub.ts
+import fs12 from "node:fs";
+import path8 from "node:path";
+var STUB_TEXT = "Shared instructions live in ~/.claude/CLAUDE.md, so edit that file.\n@~/.claude/CLAUDE.md\n";
+function stubState(A, S, enabled, detail) {
+  const storeHas = enabled && Boolean(statOrNull(path8.join(S, STUB))?.isFile());
+  const a = lstatOrNull(path8.join(A, STUB));
+  if (!a) return storeHas ? "create" : "none";
+  if (storeHas && !detail) return "ok";
+  const isStub = a.isFile() && readFileOrNull(path8.join(A, STUB)) === STUB_TEXT;
+  if (storeHas) return isStub ? "ok" : "differs";
+  return isStub ? "remove" : "differs";
+}
+function applyStub(A, state) {
+  const file = path8.join(A, STUB);
+  if (state === "create") {
+    try {
+      fs12.writeFileSync(file, STUB_TEXT, { flag: "wx", mode: 384 });
+      return "created";
+    } catch (e) {
+      if (errCode(e) === "EEXIST") return null;
+      throw e;
+    }
+  }
+  if (state === "remove" && readFileOrNull(file) === STUB_TEXT) {
+    fs12.unlinkSync(file);
+    return "removed";
+  }
+  return null;
+}
+
+// src/link/repair.ts
+function problemLine(account, p) {
+  return `${account}${p.entry ? `/${p.entry}` : "'s folder"} ${p.message}`;
+}
+var LAUNCH_LOCK_WAIT_MS = 2e3;
+function storeKind(p) {
+  if (!lstatOrNull(p)) return "missing";
+  const st = statOrNull(p);
+  if (!st) return "other";
+  return st.isDirectory() ? "dir" : st.isFile() ? "file" : "other";
+}
+function classifyEntry(A, S, name, kind) {
+  const a = path9.join(A, name);
+  const s = path9.join(S, name);
+  const lst = lstatOrNull(a);
+  const optional = OPTIONAL_DIRS.has(name);
+  const sk = storeKind(s);
+  const storeOk = sk === "missing" || sk === kind;
+  if (!lst) {
+    if (optional && sk === "missing") return { name, kind, state: "optional-absent" };
+    return { name, kind, state: storeOk ? "missing" : "store-wrong-type" };
+  }
+  if (lst.isSymbolicLink()) {
+    const target = readlinkOrNull(a);
+    if (target === null) return { name, kind, state: "missing" };
+    if (target === s || target === realpathOrNull(s)) {
+      if (sk === kind) return { name, kind, state: "ok", target };
+      if (sk === "missing") return { name, kind, state: optional ? "unshare" : "store-missing", target };
+      return { name, kind, state: "store-wrong-type", target };
+    }
+    return { name, kind, state: "link-elsewhere", target };
+  }
+  if (kind === "dir" && lst.isDirectory()) {
+    if (optional && sk === "missing") return { name, kind, state: "optional-absent" };
+    return { name, kind, state: storeOk ? "real-dir" : "store-wrong-type" };
+  }
+  if (kind === "file" && lst.isFile()) return { name, kind, state: storeOk ? "real-file" : "store-wrong-type" };
+  return { name, kind, state: "wrong-type" };
+}
+function inspectAccount(paths, account, table, detail = false) {
+  const A = accountDir(paths, account);
+  const S = paths.store;
+  let dirents;
+  try {
+    dirents = fs13.readdirSync(A, { withFileTypes: true });
+  } catch (e) {
+    if (errCode(e) !== "ENOENT") throw e;
+    return { dir: A, exists: false, entries: [], leftovers: [], stub: "none", names: [] };
+  }
+  const entries = table.dirs.map((name) => classifyEntry(A, S, name, "dir"));
+  if (table.history) entries.push(classifyEntry(A, S, HISTORY, "file"));
+  const shared = new Set(entries.map((e) => e.name));
+  for (const d of dirents) {
+    const name = d.name;
+    if (!d.isSymbolicLink() || shared.has(name) || name === STUB || NEVER_SHARED.includes(name) || isIgnored(name)) continue;
+    const target = readlinkOrNull(path9.join(A, name));
+    const s = path9.join(S, name);
+    if (target === null || target !== s && target !== realpathOrNull(s)) continue;
+    const kind = name === HISTORY || storeKind(s) === "file" ? "file" : "dir";
+    entries.push({ name, kind, state: "unshare", target });
+  }
+  return {
+    dir: A,
+    exists: true,
+    entries,
+    leftovers: dirents.map((d) => d.name).filter((n) => n.startsWith(".xclaude-")),
+    stub: stubState(A, S, table.stub, detail),
+    names: dirents.map((d) => d.name)
+  };
+}
+function needsWork(insp, opts) {
+  if (!insp.exists || insp.leftovers.length > 0 || insp.stub === "create" || insp.stub === "remove") return true;
+  return insp.entries.some((e) => {
+    switch (e.state) {
+      case "missing":
+      case "store-missing":
+      case "real-dir":
+      case "real-file":
+      case "unshare":
+        return true;
+      case "link-elsewhere":
+        return opts.replaceWrongLinks;
+      default:
+        return false;
+    }
+  });
+}
+function describeProblems(insp, paths) {
+  const S = tildify(paths.store, paths.home);
+  const problems = [];
+  for (const e of insp.entries) {
+    const where = `${S}/${e.name}`;
+    let message = null;
+    switch (e.state) {
+      case "link-elsewhere":
+        message = `links to ${e.target}, not ${where}; \`xclaude doctor --fix\` replaces the link`;
+        break;
+      case "wrong-type":
+        message = `is a ${e.kind === "dir" ? "file" : "directory"} where a ${e.kind === "dir" ? "directory" : "file"} link belongs; move it away, then run \`xclaude doctor --fix\``;
+        break;
+      case "store-wrong-type":
+        message = `${where} isn't a ${e.kind === "dir" ? "directory" : "file"} (or doesn't resolve), so it can't be shared`;
+        break;
+      case "missing":
+      case "store-missing":
+      case "real-dir":
+      case "real-file":
+      case "unshare":
+        message = "not repaired yet; run `xclaude doctor --fix`";
+        break;
+      default:
+        break;
+    }
+    if (message) problems.push({ entry: e.name, message });
+  }
+  for (const name of insp.leftovers) {
+    problems.push({ entry: name, message: "left by an interrupted repair; `xclaude doctor --fix` resumes it" });
+  }
+  return problems;
+}
+function ensureStoreEntry(S, name, kind) {
+  fs13.mkdirSync(S, { recursive: true, mode: 448 });
+  const p = path9.join(S, name);
+  try {
+    if (kind === "dir") fs13.mkdirSync(p, { mode: 448 });
+    else fs13.closeSync(fs13.openSync(p, "wx", 384));
+  } catch (e) {
+    if (errCode(e) !== "EEXIST") throw e;
+  }
+}
+var Repairer = class {
+  A;
+  S;
+  opts;
+  lock;
+  problems = [];
+  /** The store lock was taken over: stop, and leave the rest to the next run. */
+  lost = false;
+  constructor(opts, lock) {
+    this.opts = opts;
+    this.lock = lock;
+    this.A = accountDir(opts.paths, opts.account);
+    this.S = opts.paths.store;
+  }
+  get label() {
+    return this.opts.account;
+  }
+  storePath(name) {
+    return `${tildify(this.S, this.opts.paths.home)}/${name}`;
+  }
+  problem(entry, message) {
+    this.problems.push({ entry, message });
+  }
+  run(insp) {
+    for (const info of insp.entries) this.guard(info.name, () => this.act(info, 0));
+    for (const name of insp.leftovers) this.guard(name, () => this.resumeLeftover(name));
+    this.guard(STUB, () => applyStub(this.A, insp.stub));
+  }
+  /** Runs one step; an unexpected error becomes a problem instead of stopping the launch. */
+  guard(entry, step2) {
+    if (this.lost || !this.lock.refresh()) {
+      this.lost = true;
+      this.problem(entry, "skipped: another xclaude took over the repair lock; the next run finishes it");
+      return;
+    }
+    try {
+      step2();
+    } catch (e) {
+      if (e instanceof LockLost) {
+        this.lost = true;
+        this.problem(entry, "stopped: another xclaude took over the repair lock; the next run finishes it");
+      } else {
+        this.problem(entry, `repair failed: ${e.message}`);
+      }
+    }
+  }
+  act(info, depth) {
+    switch (info.state) {
+      case "missing":
+        this.createLink(info, depth);
+        return;
+      case "store-missing":
+        ensureStoreEntry(this.S, info.name, info.kind);
+        return;
+      case "link-elsewhere":
+        if (this.opts.replaceWrongLinks) this.replaceLink(info);
+        return;
+      case "unshare":
+        this.unshare(info);
+        return;
+      case "real-dir":
+        this.mergeDir(info);
+        return;
+      case "real-file":
+        this.mergeHistory();
+        return;
+      default:
+        return;
+    }
+  }
+  /** realpath(S/E), created first if missing. Never a path inside an account dir. */
+  linkTarget(info) {
+    ensureStoreEntry(this.S, info.name, info.kind);
+    const target = realpathOrNull(path9.join(this.S, info.name));
+    if (!target) throw new Error(`${this.storePath(info.name)} doesn't resolve`);
+    const accounts = realpathOrNull(this.opts.paths.accounts) ?? this.opts.paths.accounts;
+    if (target === accounts || target.startsWith(`${accounts}${path9.sep}`)) {
+      throw new Error(`${this.storePath(info.name)} resolves into ${tildify(target, this.opts.paths.home)}, inside an account dir; make it a real ${info.kind === "dir" ? "directory" : "file"} again`);
+    }
+    return target;
+  }
+  createLink(info, depth) {
+    const target = this.linkTarget(info);
+    try {
+      fs13.symlinkSync(target, path9.join(this.A, info.name));
+    } catch (e) {
+      if (errCode(e) !== "EEXIST" || depth > 0) throw e;
+      this.act(classifyEntry(this.A, this.S, info.name, info.kind), depth + 1);
+    }
+  }
+  replaceLink(info) {
+    const target = this.linkTarget(info);
+    const a = path9.join(this.A, info.name);
+    const tmp = siblingName(a, "link");
+    fs13.symlinkSync(target, tmp);
+    fs13.renameSync(tmp, a);
+    this.opts.log(`xclaude: ${this.label}/${info.name} pointed to ${info.target}; relinked to ${this.storePath(info.name)}`);
+  }
+  unshare(info) {
+    const a = path9.join(this.A, info.name);
+    if (info.kind === "file") {
+      const tmp = siblingName(a, "unshare");
+      fs13.closeSync(fs13.openSync(tmp, "wx", 384));
+      fs13.renameSync(tmp, a);
+    } else {
+      fs13.unlinkSync(a);
+      try {
+        fs13.mkdirSync(a, { mode: 448 });
+      } catch (e) {
+        if (errCode(e) !== "EEXIST") throw e;
+      }
+    }
+    this.opts.log(
+      `xclaude: ${this.label}/${info.name} is no longer shared and is now per account; the shared copy stays in ${this.storePath(info.name)}`
+    );
+  }
+  moveContext() {
+    return {
+      account: this.label,
+      stamp: stamp(),
+      refresh: () => {
+        if (!this.lock.refresh()) throw new LockLost();
+      }
+    };
+  }
+  /**
+   * Directory merge, link first: every file gets its store link while
+   * the real directory is still in place (passes repeat until nothing new
+   * appears), then the directory is swapped for the link, then the aside is
+   * emptied. A failure before the swap is undone completely, unless the lock
+   * was lost: then another process may already rely on those links.
+   */
+  mergeDir(info) {
+    const a = path9.join(this.A, info.name);
+    const target = this.linkTarget(info);
+    const ctx = this.moveContext();
+    const stats = emptyStats();
+    const rec = newRecord();
+    let start;
+    try {
+      start = requireRealDir(a);
+      for (let pass = 0; pass < 5; pass++) {
+        if (linkTree(a, target, ctx, stats, rec) === 0) break;
+      }
+      ctx.refresh();
+      const now = lstatOrNull(a);
+      if (!now?.isDirectory() || now.ino !== start.ino || now.dev !== start.dev) {
+        this.problem(info.name, "changed while being merged; the next run finishes the job");
+        return;
+      }
+    } catch (e) {
+      if (e instanceof LockLost) throw e;
+      undoLinks(rec);
+      this.cannotMerge(info.name, e);
+      return;
+    }
+    const asides = [];
+    for (let attempt = 0; ; attempt++) {
+      const aside = path9.join(this.A, asideName(info.name));
+      fs13.renameSync(a, aside);
+      asides.push(aside);
+      try {
+        fs13.symlinkSync(target, a);
+        break;
+      } catch (e) {
+        if (errCode(e) !== "EEXIST") {
+          fs13.renameSync(asides[0], a);
+          if (asides.length === 1) undoLinks(rec);
+          throw e;
+        }
+        const now = classifyEntry(this.A, this.S, info.name, "dir");
+        if (now.state === "ok") break;
+        if (now.state !== "real-dir" || attempt >= 3) throw new Error(`${info.name} kept changing while being merged`);
+      }
+    }
+    asides.forEach((aside, i) => {
+      moveTree(aside, target, ctx, stats, i === 0 ? rec : null);
+      fs13.rmdirSync(aside);
+    });
+    const line = summarize(this.label, info.name, this.storePath(info.name), stats);
+    if (line) this.opts.log(line);
+  }
+  cannotMerge(entry, e) {
+    const code = errCode(e);
+    if (code === "EXDEV") {
+      this.problem(
+        entry,
+        `can't be merged: ${tildify(this.S, this.opts.paths.home)} and ${tildify(this.A, this.opts.paths.home)} are on different filesystems (see \`xclaude doctor\`)`
+      );
+    } else {
+      this.problem(
+        entry,
+        `can't be merged, left as it was: ${e.message}${code === "EACCES" || code === "EPERM" || code === "EROFS" ? `; fix the permissions, or stop sharing ${entry} with share.remove` : ""}`
+      );
+    }
+  }
+  historyContext() {
+    const lockWaitMs = this.opts.lockWaitMs === Infinity ? HISTORY_LOCK.staleMs + 2e3 : LAUNCH_LOCK_WAIT_MS;
+    return { A: this.A, S: this.S, lockWaitMs, refreshStoreLock: () => this.lock.refresh() };
+  }
+  /** History merge. */
+  mergeHistory() {
+    this.linkTarget({ name: HISTORY, kind: "file", state: "real-file" });
+    const res = mergeHistory(this.historyContext());
+    if (!res.ok) {
+      this.problem(HISTORY, `not merged yet (${res.reason}); the next launch retries`);
+      return;
+    }
+    if (res.added) {
+      this.opts.log(`xclaude: merged ${this.label}'s prompt history into ${this.storePath(HISTORY)}: ${res.added} entries added`);
+    }
+  }
+  resumeLeftover(name) {
+    const p = path9.join(this.A, name);
+    if (name.startsWith(".xclaude-link-") || name.startsWith(".xclaude-unshare-") || name.startsWith(".xclaude-tmp-")) {
+      const st2 = lstatOrNull(p);
+      if (st2?.isDirectory()) fs13.rmdirSync(p);
+      else if (st2) fs13.unlinkSync(p);
+      return;
+    }
+    const entry = parseAside(name);
+    if (entry === null) {
+      this.problem(name, "left by an interrupted repair; remove it by hand if it's empty");
+      return;
+    }
+    const st = lstatOrNull(p);
+    if (!st) return;
+    if (st.isSymbolicLink()) {
+      fs13.unlinkSync(p);
+      return;
+    }
+    if (entry === HISTORY ? !st.isFile() : !st.isDirectory()) {
+      this.problem(name, "left by an interrupted repair, but of an unexpected type; look at it by hand");
+      return;
+    }
+    if (entry === HISTORY) {
+      const res = resumeHistoryAside(this.historyContext(), p, this.opts.table.history);
+      if (!res.ok) this.problem(name, `interrupted history merge not finished (${res.reason})`);
+      else if (res.added) this.opts.log(`xclaude: finished merging ${this.label}'s prompt history: ${res.added} entries added`);
+      return;
+    }
+    if (!this.opts.table.dirs.includes(entry)) {
+      const own = path9.join(this.A, entry);
+      if (!lstatOrNull(own)) fs13.mkdirSync(own, { mode: 448 });
+      const st2 = fs13.lstatSync(own);
+      if (!st2.isDirectory() || st2.isSymbolicLink()) {
+        this.problem(name, `left by an interrupted merge of ${entry}; ${entry} isn't a directory, so move the contents back by hand`);
+        return;
+      }
+      moveTree(p, own, this.moveContext(), emptyStats());
+      fs13.rmdirSync(p);
+      return;
+    }
+    const target = this.linkTarget({ name: entry, kind: "dir", state: "ok" });
+    const stats = emptyStats();
+    try {
+      moveTree(p, target, this.moveContext(), stats);
+      fs13.rmdirSync(p);
+    } catch (e) {
+      this.cannotMerge(entry, e);
+      return;
+    }
+    const line = summarize(this.label, entry, this.storePath(entry), stats);
+    if (line) this.opts.log(line);
+  }
+};
+function unmanageable(A, store) {
+  if (lstatOrNull(A)?.isSymbolicLink()) return "is a symlink; xclaude only manages real folders there, so it leaves this one alone";
+  const realA = realpathOrNull(A);
+  const realS = realpathOrNull(store);
+  if (realA && realS && (realA === realS || realS.startsWith(`${realA}${path9.sep}`))) {
+    return "is the shared store or holds it; xclaude leaves it alone";
+  }
+  return null;
+}
+function repairAccount(opts) {
+  const A = accountDir(opts.paths, opts.account);
+  const refusal = unmanageable(A, opts.paths.store);
+  if (refusal) return { clean: false, busy: false, problems: [{ entry: "", message: refusal }], names: [] };
+  let insp = inspectAccount(opts.paths, opts.account, opts.table);
+  if (!needsWork(insp, opts)) {
+    const problems = describeProblems(insp, opts.paths);
+    return { clean: problems.length === 0, busy: false, problems, names: insp.names };
+  }
+  const lock = DirLock.acquire(path9.join(opts.paths.locks, "store"), STORE_LOCK, { waitMs: opts.lockWaitMs });
+  if (!lock) {
+    const problems = describeProblems(insp, opts.paths);
+    return { clean: false, busy: true, problems, names: insp.names };
+  }
+  try {
+    if (!insp.exists) {
+      mkdirPrivate(A);
+      opts.log(`xclaude: ${opts.account}'s config dir was missing and has been recreated; log in again with /login`);
+    }
+    insp = inspectAccount(opts.paths, opts.account, opts.table);
+    const repairer = new Repairer(opts, lock);
+    repairer.run(insp);
+    insp = inspectAccount(opts.paths, opts.account, opts.table);
+    const failed = new Set(repairer.problems.map((p) => p.entry));
+    const problems = [...repairer.problems, ...describeProblems(insp, opts.paths).filter((p) => !failed.has(p.entry))];
+    return { clean: problems.length === 0, busy: false, problems, names: insp.names };
+  } finally {
+    lock.release();
+  }
+}
+
+// src/core/shellwords.ts
+function splitShellWords(input, home) {
+  const words2 = [];
+  let word = "";
+  let inWord = false;
+  let i = 0;
+  const atWordStart = () => !inWord;
+  while (i < input.length) {
+    const c = input[i];
+    if (/\s/.test(c)) {
+      if (inWord) words2.push(word);
+      word = "";
+      inWord = false;
+      i++;
+      continue;
+    }
+    if (c === "~" && atWordStart() && (i + 1 === input.length || input[i + 1] === "/" || /\s/.test(input[i + 1]))) {
+      word += home;
+      inWord = true;
+      i++;
+      continue;
+    }
+    inWord = true;
+    if (c === "'") {
+      const end = input.indexOf("'", i + 1);
+      if (end < 0) throw new UsageError("unterminated ' in --args");
+      word += input.slice(i + 1, end);
+      i = end + 1;
+    } else if (c === '"') {
+      i++;
+      for (; ; ) {
+        if (i >= input.length) throw new UsageError('unterminated " in --args');
+        const d = input[i];
+        if (d === '"') {
+          i++;
+          break;
+        }
+        if (d === "\\" && i + 1 < input.length && '"\\$`\n'.includes(input[i + 1])) {
+          word += input[i + 1];
+          i += 2;
+        } else {
+          word += d;
+          i++;
+        }
+      }
+    } else if (c === "\\") {
+      if (i + 1 < input.length) word += input[i + 1];
+      i += 2;
+    } else {
+      word += c;
+      i++;
+    }
+  }
+  if (inWord) words2.push(word);
+  return words2;
+}
+function quoteShellWord(word) {
+  if (word !== "" && !word.startsWith("=") && /^[A-Za-z0-9_\-+=.,/:@%^]+$/.test(word)) return word;
+  return `'${word.replace(/'/g, `'\\''`)}'`;
+}
+function quoteShellWords(words2) {
+  return words2.map(quoteShellWord).join(" ");
+}
+
+// src/core/format.ts
+function formatTable(headers, rows) {
+  const all = [headers, ...rows];
+  const widths = headers.map((_, col) => Math.max(...all.map((r) => (r[col] ?? "").length)));
+  return all.map(
+    (r) => r.map((cell2, col) => col === r.length - 1 ? cell2 : cell2.padEnd(widths[col])).join("  ").trimEnd()
+  ).map((line) => `${line}
+`).join("");
+}
+var DASH = "\u2013";
+
+// src/commands/defaults.ts
+var DEFAULT_OPTIONS = { model: { value: true }, effort: { value: true }, args: { value: true } };
+function applyDefaultOptions(p, home, into) {
+  const model = stringOption(p, "model");
+  if (model !== void 0) {
+    if (!model.trim()) throw new UsageError("--model needs a model name, e.g. opus");
+    into.model = model;
+  }
+  const effort = stringOption(p, "effort");
+  if (effort !== void 0) {
+    if (!isEffort(effort)) throw new UsageError(`--effort must be one of ${EFFORTS.join(", ")}`);
+    into.effort = effort;
+  }
+  const args = stringOption(p, "args");
+  if (args !== void 0) into.args = splitShellWords(args, home);
+}
+function formatDefaults(d) {
+  return [
+    `  model   ${d.model ?? DASH}`,
+    `  effort  ${d.effort ?? DASH}`,
+    `  args    ${d.args.length ? quoteShellWords(d.args) : DASH}`
+  ].map((l) => `${l}
+`).join("");
+}
+
+// src/commands/add.ts
+var USAGE = 'usage: xclaude add <name> [--model M] [--effort E] [--args "\u2026"]';
+async function addCommand(ctx, config, args) {
+  const p = parseOptions(args, DEFAULT_OPTIONS, "add");
+  const [name, ...extra] = p.positionals;
+  if (!name || extra.length) throw new UsageError(USAGE);
+  const problem2 = accountNameProblem(name);
+  if (problem2) throw new UsageError(problem2);
+  if (Object.hasOwn(config.accounts, name)) throw new XError(`account "${name}" already exists; change its defaults with: xclaude set ${name}`);
+  const defaults = { model: null, effort: null, args: [] };
+  applyDefaultOptions(p, ctx.paths.home, defaults);
+  const claude = findClaude(ctx.env, config, ctx.paths.home, ctx.selfPath);
+  const log = (line) => ctx.io.err(`${line}
+`);
+  const dir = accountDir(ctx.paths, name);
+  const refusal = unmanageable(dir, ctx.paths.store);
+  if (refusal) throw new XError(`not adding ${name}: ${tildify(dir, ctx.paths.home)} ${refusal}. Replace it with a real folder, or remove it, then add ${name} again.`);
+  if (fs14.existsSync(dir)) log(`xclaude: ${tildify(dir, ctx.paths.home)} already exists; reusing it`);
+  mkdirPrivate(dir);
+  const res = repairAccount({
+    paths: ctx.paths,
+    account: name,
+    table: shareTable(config, ctx.switches),
+    lockWaitMs: Infinity,
+    replaceWrongLinks: false,
+    log
+  });
+  for (const pr of res.problems) log(`xclaude: ${problemLine(name, pr)}`);
+  config = loadConfig(ctx.paths, { create: false }).config;
+  config.accounts[name] = defaults;
+  saveConfig(ctx.paths, config);
+  log(`xclaude: added ${name}. Starting Claude Code in it: go through the first-run screens, log in with /login, then quit.`);
+  const env = identityEnv(ctx, name);
+  await runChild(claude, [], env);
+  const status = await authStatus(claude, env);
+  if (!status.loggedIn) {
+    log(`xclaude: ${name} isn't logged in yet. Log in later with \`xclaude ${name} auth login\`, or /login inside \`xclaude ${name}\`.`);
+    return EXIT_OK;
+  }
+  log(`xclaude: ${name} is logged in as ${describeLogin(status)}. Launch it with: xclaude ${name}`);
+  const others = identities(config).filter((n) => n !== name);
+  const theirs = await Promise.all(others.map((n) => authStatus(claude, identityEnv(ctx, n))));
+  others.forEach((other, i) => {
+    const s = theirs[i];
+    if (s.loggedIn && s.email === status.email && s.orgId === status.orgId) {
+      log(`xclaude: warning: ${name} and ${other} use the same login (${describeLogin(status)})`);
+    }
+  });
+  return EXIT_OK;
+}
+
+// src/commands/doctor.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import fs19 from "node:fs";
+import path14 from "node:path";
+
+// src/link/normalize.ts
+import fs15 from "node:fs";
+import path10 from "node:path";
+var REGISTRY_FILES = ["plugins/installed_plugins.json", "plugins/known_marketplaces.json"];
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rewrite(value, re, to, onChange) {
+  if (typeof value === "string") {
+    const next = value.replace(re, (_m, _name, sep) => `${to}${sep}`);
+    if (next !== value) onChange();
+    return next;
+  }
+  if (Array.isArray(value)) return value.map((v) => rewrite(v, re, to, onChange));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = rewrite(v, re, to, onChange);
+    return out;
+  }
+  return value;
+}
+function planNormalization(paths, account) {
+  const accountsDir = path10.join(paths.xhome, "accounts");
+  const to = path10.join(paths.home, ".claude");
+  const name = account ? escapeRe(account) : "[a-z][a-z0-9-]{0,31}";
+  const re = new RegExp(`^${escapeRe(accountsDir)}/(${name})(/|$)`);
+  const plans = [];
+  for (const rel of REGISTRY_FILES) {
+    const file = realpathOrNull(path10.join(paths.store, rel));
+    if (!file) continue;
+    const st = lstatOrNull(file);
+    if (!st?.isFile()) continue;
+    const original = fs15.readFileSync(file, "utf8");
+    if (!original.includes(accountsDir)) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(original);
+    } catch {
+      continue;
+    }
+    let count = 0;
+    const next = rewrite(parsed, re, to, () => count++);
+    if (!count) continue;
+    const text = `${JSON.stringify(next, null, 2)}${original.endsWith("\n") ? "\n" : ""}`;
+    plans.push({ file, text, mtimeMs: st.mtimeMs, size: st.size, ino: st.ino, count });
+  }
+  return plans;
+}
+function applyNormalization(plans) {
+  const changed = [];
+  const skipped = [];
+  for (const plan of plans) {
+    const st = lstatOrNull(plan.file);
+    if (!st || st.mtimeMs !== plan.mtimeMs || st.size !== plan.size || st.ino !== plan.ino) {
+      skipped.push(plan.file);
+      continue;
+    }
+    writeFileAtomic(plan.file, plan.text);
+    changed.push(plan.file);
+  }
+  return { changed, skipped };
+}
+function normalizePaths(paths, opts) {
+  const plans = planNormalization(paths, opts.account);
+  if (!plans.length) return { changed: [], skipped: [], busy: false };
+  const lock = DirLock.acquire(path10.join(paths.locks, "store"), STORE_LOCK, { waitMs: opts.lockWaitMs });
+  if (!lock) return { changed: [], skipped: plans.map((p) => p.file), busy: true };
+  try {
+    const result = applyNormalization(plans);
+    for (const plan of plans.filter((p) => result.changed.includes(p.file))) {
+      opts.log(`xclaude: rewrote ${plan.count} account-dir path${plan.count > 1 ? "s" : ""} in ${tildify(plan.file, paths.home)} to ~/.claude/\u2026`);
+    }
+    return { ...result, busy: false };
+  } finally {
+    lock.release();
+  }
+}
+
+// src/link/leftover.ts
+import fs16 from "node:fs";
+import path11 from "node:path";
+function strayFolders(paths, config) {
+  let names;
+  try {
+    names = fs16.readdirSync(paths.accounts);
+  } catch {
+    return [];
+  }
+  const accounts = Object.keys(config.accounts).map((n) => lstatOrNull(accountDir(paths, n))).filter((st) => st !== null);
+  const out = [];
+  for (const name of names.sort()) {
+    if (name.endsWith(".lock") || name === ".DS_Store" || Object.hasOwn(config.accounts, name)) continue;
+    const dir = path11.join(paths.accounts, name);
+    const st = lstatOrNull(dir);
+    if (!st) continue;
+    if (st.isSymbolicLink()) out.push({ name, dir, kind: "link", entries: [] });
+    else if (!st.isDirectory() || accounts.some((a) => a.dev === st.dev && a.ino === st.ino)) continue;
+    else if (accountNameProblem(name)) out.push({ name, dir, kind: "stray", entries: [] });
+    else {
+      const entries = fs16.readdirSync(dir).filter((e) => e !== ".DS_Store" && !lstatOrNull(path11.join(dir, e))?.isSymbolicLink());
+      out.push({ name, dir, kind: entries.length ? "content" : "leftover", entries });
+    }
+  }
+  return out;
+}
+function leftoverNames(paths, config) {
+  return strayFolders(paths, config).filter((f) => f.kind === "leftover").map((f) => f.name);
+}
+function linkNames(table) {
+  return /* @__PURE__ */ new Set([...SHARED_DIRS, ...table.dirs, HISTORY]);
+}
+function hasContent(p) {
+  const st = lstatOrNull(p);
+  if (!st) return false;
+  if (st.isDirectory()) return fs16.readdirSync(p).some((e) => e !== ".DS_Store");
+  return st.size > 0;
+}
+function keepOnlyLinks(dir, table) {
+  if (lstatOrNull(dir)?.isSymbolicLink()) throw new Error(`${dir} is a symlink`);
+  const shared = linkNames(table);
+  const content = [];
+  let links = 0;
+  for (const name of fs16.readdirSync(dir)) {
+    const p = path11.join(dir, name);
+    if (shared.has(name) && lstatOrNull(p)?.isSymbolicLink()) links++;
+    else if (shared.has(name) && hasContent(p)) content.push(name);
+    else removeTree(p);
+  }
+  if (links || content.length) return { kept: true, content };
+  fs16.rmdirSync(dir);
+  return { kept: false, content };
+}
+
+// src/link/unknown.ts
+import fs17 from "node:fs";
+function unknownEntries(names, table) {
+  return names.filter((n) => !isIgnored(n) && !isKnown(n, table)).sort();
+}
+function takeNewUnknown(state, account, unknown) {
+  const seen = new Set(state.seenUnknownEntries[account] ?? []);
+  const fresh = unknown.filter((n) => !seen.has(n));
+  if (fresh.length) state.seenUnknownEntries[account] = [...seen, ...fresh].sort();
+  return fresh;
+}
+function unknownNotice(account, entry, configLabel) {
+  return `xclaude: new Claude Code entry "${entry}" in ${account} stays per-account; to share it, add "${entry}" to share.add in ${configLabel}`;
+}
+function storeUnknownEntries(store, table) {
+  let names;
+  try {
+    names = fs17.readdirSync(store);
+  } catch (e) {
+    if (errCode(e) === "ENOENT") return [];
+    throw e;
+  }
+  return unknownEntries(names, table);
+}
+
+// src/shell/rc.ts
+import fs18 from "node:fs";
+import path12 from "node:path";
+var START = "# >>> xclaude >>>";
+var END = "# <<< xclaude <<<";
+function dquote(s) {
+  return `"${s.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function blockFor(initFile2) {
+  const q = dquote(initFile2);
+  return `${START}
+# Managed by \`xclaude shell install\`. Remove with \`xclaude shell uninstall\`.
+[ -f ${q} ] && . ${q}
+${END}
+`;
+}
+function findBlock(lines, file) {
+  const start = lines.findIndex((l) => l.trim() === START);
+  if (start < 0) return null;
+  const end = lines.findIndex((l, i) => i > start && l.trim() === END);
+  if (end < 0) {
+    throw new XError(`${file} has "${START}" without "${END}"; fix or remove that block by hand, then run this again`);
+  }
+  return [start, end];
+}
+function upsertBlock(text, block, file) {
+  const lines = text.split("\n");
+  const range = findBlock(lines, file);
+  const blockLines = block.replace(/\n$/, "").split("\n");
+  if (range) {
+    lines.splice(range[0], range[1] - range[0] + 1, ...blockLines);
+    return lines.join("\n");
+  }
+  if (text === "") return block;
+  return `${text}${text.endsWith("\n") ? "" : "\n"}
+${block}`;
+}
+function removeBlock(text, file) {
+  const lines = text.split("\n");
+  const range = findBlock(lines, file);
+  if (!range) return { text, found: false };
+  let [start] = range;
+  const end = range[1];
+  if (start > 0 && lines[start - 1] === "" && (lines[end + 1] === void 0 || lines[end + 1] === "")) start--;
+  lines.splice(start, end - start + 1);
+  return { text: lines.join("\n"), found: true };
+}
+function sourcesBashrc(text) {
+  return text.split("\n").some((l) => !/^\s*#/.test(l) && /\.bashrc\b/.test(l) && /(^|[\s;&|({])(\.|source)\s/.test(l));
+}
+function rcTargets(env, home, platform, want) {
+  const zshrc = path12.join(env.ZDOTDIR || home, ".zshrc");
+  const bashrc = path12.join(home, ".bashrc");
+  const explicit = want.bash || want.zsh;
+  const targets = [];
+  if (explicit ? want.zsh : fs18.existsSync(zshrc)) targets.push({ shell: "zsh", file: zshrc });
+  if (explicit ? want.bash : fs18.existsSync(bashrc)) {
+    targets.push({ shell: "bash", file: bashrc });
+    const profile = path12.join(home, ".bash_profile");
+    const text = platform === "darwin" ? readFileOrNull(profile) : null;
+    if (text !== null && !sourcesBashrc(text)) targets.push({ shell: "bash", file: profile });
+  }
+  return targets;
+}
+function writeRc(file, text, previous) {
+  if (text === previous) return { file, status: "unchanged" };
+  const real = realpathOrNull(file);
+  if (real === null && fs18.lstatSync(file, { throwIfNoEntry: false })?.isSymbolicLink()) return { file, status: "manual", text };
+  try {
+    const target = real ?? file;
+    fs18.accessSync(path12.dirname(target), fs18.constants.W_OK);
+    if (previous !== null) fs18.accessSync(target, fs18.constants.W_OK);
+    writeFileAtomic(target, text, { mode: 420 });
+    return { file, status: "written" };
+  } catch (e) {
+    if (errCode(e) === "EACCES" || errCode(e) === "EPERM" || errCode(e) === "EROFS") return { file, status: "manual", text };
+    throw e;
+  }
+}
+function knownRcFiles(env, home) {
+  return [
+    { shell: "zsh", file: path12.join(env.ZDOTDIR || home, ".zshrc") },
+    { shell: "bash", file: path12.join(home, ".bashrc") },
+    { shell: "bash", file: path12.join(home, ".bash_profile") }
+  ];
+}
+function installedIn(env, home) {
+  return knownRcFiles(env, home).filter((t) => (readFileOrNull(t.file) ?? "").split("\n").some((l) => l.trim() === START)).map((t) => t.file);
+}
+
+// src/tmux/client.ts
+import { spawnSync } from "node:child_process";
+import path13 from "node:path";
+var STRIPPED_ENV = [
+  "CLAUDE_CONFIG_DIR",
+  "XCLAUDE_ACCOUNT",
+  "CLAUDE_CODE_CHILD_SESSION",
+  "CLAUDE_SECURESTORAGE_CONFIG_DIR",
+  "CLAUDECODE",
+  "CLAUDE_CODE_SESSION_ID",
+  "CLAUDE_CODE_SESSION_ATTENDED",
+  "CLAUDE_PID",
+  "CLAUDE_CODE_ENTRYPOINT",
+  "CLAUDE_CODE_EXECPATH",
+  "CLAUDE_CODE_MESSAGING_SOCKET",
+  "CLAUDE_CODE_MESSAGING_TOKEN",
+  "CLAUDE_CODE_BRIDGE_SESSION_ID",
+  "CLAUDE_CODE_INVOKED_SKILLS",
+  "CLAUDE_CODE_TMPDIR",
+  "CLAUDE_EFFORT",
+  "AI_AGENT"
+];
+function tmuxEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env)) if (v !== void 0 && !STRIPPED_ENV.includes(k)) out[k] = v;
+  return out;
+}
+function escapeArg(arg) {
+  return arg.endsWith(";") ? `${arg.slice(0, -1)}\\;` : arg;
+}
+var TMUX_INSTALL_HINT = process.platform === "darwin" ? "install it with: brew install tmux" : "install it with your package manager, e.g. sudo apt install tmux";
+function findTmux(env) {
+  for (const dir of (env.PATH ?? "").split(path13.delimiter)) {
+    if (!dir || !path13.isAbsolute(dir)) continue;
+    const candidate = path13.join(dir, "tmux");
+    if (isExecutableFile(candidate)) return candidate;
+  }
+  return null;
+}
+var Tmux = class {
+  bin;
+  env;
+  constructor(env) {
+    const bin = findTmux(env);
+    if (!bin) throw new XError(`tmux isn't installed (xclaude tmux needs tmux 3.0 or later); ${TMUX_INSTALL_HINT}`);
+    this.bin = bin;
+    this.env = tmuxEnv(env);
+  }
+  run(args) {
+    const res = spawnSync(this.bin, args.map(escapeArg), { env: this.env, encoding: "utf8", timeout: 15e3 });
+    if (res.error) throw new XError(`running tmux failed: ${res.error.message}`);
+    return { code: res.status, stdout: res.stdout, stderr: res.stderr };
+  }
+  /** Runs a command that must succeed. */
+  must(args) {
+    const res = this.run(args);
+    if (res.code !== 0) throw new XError(`tmux ${args[0]} failed: ${res.stderr.trim() || `exit code ${res.code}`}`);
+    return res.stdout;
+  }
+  /** [major, minor], or null when `tmux -V` can't be read. */
+  version() {
+    const m = /(\d+)\.(\d+)/.exec(this.run(["-V"]).stdout);
+    return m ? [Number(m[1]), Number(m[2])] : null;
+  }
+  requireVersion() {
+    const v = this.version();
+    if (v && (v[0] < 3 || v[0] === 3 && v[1] < 0)) throw new XError(`tmux ${v.join(".")} is too old; xclaude tmux needs 3.0 or later`);
+  }
+  /** Whether a session named exactly `name` exists (the = prefix turns off tmux's prefix matching). */
+  hasSession(name) {
+    return this.run(["has-session", "-t", `=${name}`]).code === 0;
+  }
+};
+function isNoServer(stderr) {
+  return /no server running|\(No such file or directory\)|server exited unexpectedly/i.test(stderr);
+}
+
+// src/commands/doctor.ts
+var MARK = { ok: "\u2713", info: "\xB7", warn: "!", error: "\u2717" };
+var Report = class {
+  lines = [];
+  errors = 0;
+  warnings = 0;
+  section(title) {
+    this.lines.push(this.lines.length ? `
+${title}` : title);
+  }
+  add(level, text, indent = 1) {
+    if (level === "error") this.errors++;
+    if (level === "warn") this.warnings++;
+    this.lines.push(`${"  ".repeat(indent)}${MARK[level]} ${text}`);
+  }
+};
+function managedDirs(ctx) {
+  if (ctx.env.XCLAUDE_MANAGED_SETTINGS_DIR) return { dirs: [ctx.env.XCLAUDE_MANAGED_SETTINGS_DIR], macDefaults: false };
+  if (process.platform === "darwin") return { dirs: ["/Library/Application Support/ClaudeCode"], macDefaults: true };
+  return { dirs: ["/etc/claude-code"], macDefaults: false };
+}
+function readForcedOrgs(ctx) {
+  const { dirs, macDefaults } = managedDirs(ctx);
+  if (macDefaults) {
+    const res = spawnSync2("defaults", ["read", "com.anthropic.claudecode", "forceLoginOrgUUID"], { encoding: "utf8", timeout: 5e3 });
+    const orgs2 = res.status === 0 ? [...(res.stdout ?? "").matchAll(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi)].map((m) => m[0]) : [];
+    if (orgs2.length) return { source: "the com.anthropic.claudecode preferences", orgs: orgs2 };
+  }
+  const files = [];
+  for (const dir of dirs) {
+    files.push(path14.join(dir, "managed-settings.json"));
+    try {
+      for (const name of fs19.readdirSync(path14.join(dir, "managed-settings.d")).sort()) {
+        if (name.endsWith(".json")) files.push(path14.join(dir, "managed-settings.d", name));
+      }
+    } catch {
+    }
+  }
+  let orgs = null;
+  let isList = false;
+  let sources = [];
+  for (const file of files) {
+    const text = readFileOrNull(file);
+    if (text === null) continue;
+    let value;
+    try {
+      value = JSON.parse(text).forceLoginOrgUUID;
+    } catch {
+      continue;
+    }
+    if (typeof value === "string") {
+      orgs = [value];
+      isList = false;
+      sources = [file];
+    } else if (Array.isArray(value)) {
+      const list = value.filter((v) => typeof v === "string");
+      if (isList && orgs) {
+        orgs = [...orgs, ...list];
+        sources.push(file);
+      } else {
+        orgs = list;
+        sources = [file];
+      }
+      isList = true;
+    }
+  }
+  return orgs && orgs.length ? { source: sources.join(" and "), orgs } : null;
+}
+function remoteCleanupDays(dir) {
+  try {
+    const json = JSON.parse(readFileOrNull(path14.join(dir, "remote-settings.json")) ?? "null");
+    const value = json?.cleanupPeriodDays ?? json?.settings?.cleanupPeriodDays;
+    return typeof value === "number" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function versionOf(bin, args) {
+  const res = spawnSync2(bin, args, { encoding: "utf8", timeout: 15e3 });
+  return res.status === 0 ? (res.stdout ?? "").trim().split("\n")[0] || null : null;
+}
+async function doctorCommand(ctx, args) {
+  const p = parseOptions(args, { fix: {} }, "doctor");
+  if (p.positionals.length) throw new UsageError("usage: xclaude doctor [--fix]");
+  const home = ctx.paths.home;
+  const t = (p2) => tildify(p2, home);
+  const report = new Report();
+  let config = defaultConfig();
+  let configProblem = null;
+  try {
+    config = loadConfig(ctx.paths, { create: false }).config;
+  } catch (e) {
+    if (!(e instanceof XError)) throw e;
+    configProblem = e.message;
+  }
+  const table = shareTable(config, ctx.switches);
+  if (p.values.fix && !configProblem) {
+    const log = (line) => ctx.io.err(`${line}
+`);
+    for (const name of Object.keys(config.accounts)) {
+      repairAccount({ paths: ctx.paths, account: name, table, lockWaitMs: Infinity, replaceWrongLinks: true, log });
+    }
+    if (ctx.switches.normalizePaths && table.dirs.includes("plugins")) normalizePaths(ctx.paths, { lockWaitMs: Infinity, log });
+  }
+  report.section("Tools");
+  let claude = null;
+  try {
+    claude = findClaude(ctx.env, config, home, ctx.selfPath);
+    report.add("ok", `claude ${versionOf(claude, ["--version"]) ?? "(version unknown)"} at ${t(claude)}`);
+  } catch (e) {
+    if (!(e instanceof XError)) throw e;
+    report.add("error", e.message.includes("isn't installed") ? `Claude Code isn't installed; ${INSTALL_HINT}` : e.message);
+  }
+  const tmuxBin = findTmux(ctx.env);
+  if (!tmuxBin) report.add("warn", `tmux isn't installed, so xclaude tmux won't work (it needs 3.0 or later); ${TMUX_INSTALL_HINT}`);
+  else {
+    const v = new Tmux(ctx.env).version();
+    if (v && v[0] < 3) report.add("warn", `tmux ${v.join(".")} is too old for xclaude tmux (it needs 3.0 or later)`);
+    else report.add("ok", `tmux ${v ? v.join(".") : "(version unknown)"}`);
+  }
+  report.add("ok", `Node ${process.versions.node}`);
+  report.section("Config");
+  if (configProblem) report.add("error", configProblem);
+  else report.add("ok", `${t(ctx.paths.config)}${fs19.existsSync(ctx.paths.config) ? "" : " (not created yet)"}`);
+  for (const name of table.refused) report.add("warn", `share.add "${name}" is ignored: never-shared entries and file names can't be shared`);
+  const names = identities(config);
+  const logins = /* @__PURE__ */ new Map();
+  if (claude) {
+    const statuses = await Promise.all(names.map((n) => authStatus(claude, identityEnv(ctx, n))));
+    names.forEach((n, i) => logins.set(n, statuses[i]));
+  }
+  const forced = readForcedOrgs(ctx);
+  report.section("Accounts");
+  if (configProblem) report.add("info", "not checked: fix the config first (account dirs are left alone)");
+  else if (!names.length) report.add("info", "no accounts yet; add one with: xclaude add <name>");
+  const storeDev = statOrNull(ctx.paths.store)?.dev;
+  for (const name of names) {
+    const login = logins.get(name);
+    report.lines.push(`  ${name}${login ? `  ${describeLogin(login)}` : ""}`);
+    if (name === MAIN) {
+      report.add("info", "the main identity: the login in ~/.claude, never linked", 2);
+    } else {
+      const dir = accountDir(ctx.paths, name);
+      const insp = lstatOrNull(dir)?.isSymbolicLink() ? null : inspectAccount(ctx.paths, name, table, true);
+      if (!insp) {
+        report.add("error", `${t(dir)} is a symlink; xclaude only manages real folders there, so it leaves this one alone`, 2);
+      } else if (!insp.exists) {
+        report.add("error", `${t(dir)} is missing; the next launch (or --fix) recreates it, then log in again`, 2);
+      } else {
+        const problems = describeProblems(insp, ctx.paths);
+        if (problems.length) {
+          for (const pr of problems) report.add("error", `${pr.entry} ${pr.message}`, 2);
+        } else report.add("ok", `links into ${t(ctx.paths.store)}`, 2);
+        if (insp.stub === "differs") {
+          report.add("warn", "CLAUDE.md isn't the import stub, so it's left alone; move what it says into ~/.claude/CLAUDE.md to share it", 2);
+        } else if (insp.stub === "create" || insp.stub === "remove") {
+          report.add("error", `the CLAUDE.md stub needs ${insp.stub === "create" ? "creating" : "removing"}; run xclaude doctor --fix`, 2);
+        }
+        const unknown = unknownEntries(insp.names, table);
+        if (unknown.length) report.add("info", `per-account entries xclaude doesn't know: ${unknown.join(", ")}`, 2);
+        const dev = statOrNull(dir)?.dev;
+        if (storeDev !== void 0 && dev !== void 0 && dev !== storeDev) {
+          report.add(
+            "warn",
+            `${t(ctx.paths.store)} and ${t(dir)} are on different filesystems, so left-behind directories can't be merged (hard links don't cross filesystems); keep ~/.claude and ~/.xclaude on one filesystem`,
+            2
+          );
+        }
+        const days = remoteCleanupDays(dir);
+        if (days !== null && days < 30) {
+          report.add("warn", `its organization sets cleanupPeriodDays to ${days}: its sessions delete everyone's shared transcripts older than ${days} days`, 2);
+        }
+      }
+    }
+    if (login) {
+      if (login.error) report.add("warn", `login status unknown: ${login.error}`, 2);
+      else if (!login.loggedIn) report.add("warn", `not logged in; run: xclaude ${name} auth login`, 2);
+      if (forced && login.loggedIn && login.orgId && !forced.orgs.includes(login.orgId)) {
+        report.add("error", `forceLoginOrgUUID (from ${t(forced.source)}) excludes this login's organization (${login.orgName ?? login.orgId}), so it will be refused`, 2);
+      }
+    }
+  }
+  const byLogin = /* @__PURE__ */ new Map();
+  for (const [n, s] of logins) {
+    if (s.loggedIn && s.email) byLogin.set(`${s.email}
+${s.orgId}`, [...byLogin.get(`${s.email}
+${s.orgId}`) ?? [], n]);
+  }
+  for (const [key, same] of byLogin) {
+    if (same.length > 1) report.add("warn", `${same.join(" and ")} use the same login (${key.split("\n")[0]})`);
+  }
+  for (const f of configProblem ? [] : strayFolders(ctx.paths, config)) {
+    const where = t(f.dir);
+    if (f.kind === "leftover") {
+      report.add("info", `${where}: links kept from the removed account ${f.name}, for its old conversations; delete with: xclaude rm ${f.name}`);
+    } else if (f.kind === "content") {
+      report.add("warn", `${where} isn't an account but holds more than links (${f.entries.join(", ")}): \`xclaude add ${f.name}\` takes it back, or check it and delete it by hand`);
+    } else if (f.kind === "stray") {
+      report.add("info", `${where} isn't an account folder (that name couldn't be one); check it by hand`);
+    } else {
+      report.add("warn", `${where} is a symlink; xclaude only manages real folders there`);
+    }
+  }
+  report.section("Store");
+  const storeUnknown = storeUnknownEntries(ctx.paths.store, table);
+  if (!fs19.existsSync(ctx.paths.store)) report.add("info", `${t(ctx.paths.store)} doesn't exist yet`);
+  else if (storeUnknown.length) report.add("info", `entries in ${t(ctx.paths.store)} that no account links to: ${storeUnknown.join(", ")}`);
+  else report.add("ok", t(ctx.paths.store));
+  const mainDays = remoteCleanupDays(ctx.paths.store);
+  if (mainDays !== null && mainDays < 30) {
+    report.add("warn", `the ~/.claude login's organization sets cleanupPeriodDays to ${mainDays}: plain claude deletes everyone's shared transcripts older than ${mainDays} days`);
+  }
+  for (const entry of SHARED_DIRS) {
+    const p2 = path14.join(ctx.paths.store, entry);
+    if (!fs19.existsSync(p2)) continue;
+    try {
+      fs19.accessSync(p2, fs19.constants.W_OK);
+    } catch {
+      report.add("warn", `${t(p2)} isn't writable, so sessions can't save ${entry} there`);
+    }
+  }
+  report.section("Shell");
+  const rcFiles = installedIn(ctx.env, home);
+  if (rcFiles.length) report.add("ok", `completion loaded from ${rcFiles.map(t).join(", ")}`);
+  else report.add("info", "completion isn't installed (xclaude shell install)");
+  report.add("info", `guard: ${config.guard ? "on" : "off"}`);
+  report.section("Environment");
+  let envFindings = 0;
+  if (ctx.env.CLAUDE_CONFIG_DIR) {
+    report.add("warn", `CLAUDE_CONFIG_DIR is set (${ctx.env.CLAUDE_CONFIG_DIR}), so plain \`claude\` doesn't use ~/.claude`);
+    envFindings++;
+  }
+  if (ctx.env.CLAUDE_CODE_EFFORT_LEVEL) {
+    report.add("warn", `CLAUDE_CODE_EFFORT_LEVEL is set (${ctx.env.CLAUDE_CODE_EFFORT_LEVEL}); it overrides the effort level saved in every account's settings`);
+    envFindings++;
+  }
+  if (!envFindings) report.add("ok", "nothing that overrides accounts");
+  report.lines.push("");
+  const summary = report.errors || report.warnings ? `${report.errors} problem${report.errors === 1 ? "" : "s"}, ${report.warnings} warning${report.warnings === 1 ? "" : "s"}${report.errors && !p.values.fix ? ". Run `xclaude doctor --fix` to repair what can be repaired." : "."}` : "All good.";
+  report.lines.push(summary);
+  ctx.io.out(`${report.lines.join("\n")}
+`);
+  return report.errors ? EXIT_ERROR : EXIT_OK;
+}
+
+// src/shell/init.ts
+import fs20 from "node:fs";
+import path15 from "node:path";
+function header(shell, version) {
+  return `# xclaude ${version}: ${shell} integration. Written by \`xclaude shell install\`, \`xclaude guard on|off\`
+# and after xclaude updates; don't edit, changes are overwritten.
+`;
+}
+var GUARD = `unalias claude 2>/dev/null
+claude() {
+  if [ -n "$XCLAUDE_ACCOUNT" ] || [ -n "$CLAUDE_CODE_CHILD_SESSION" ] || ! command -v xclaude >/dev/null 2>&1; then
+    command claude "$@"
+  else
+    echo "claude is disabled \u2014 use: xclaude <account>   (accounts: $(xclaude __names 2>/dev/null))" >&2
+    return 1
+  fi
+}
+`;
+function initBash(version, guard) {
+  return `${header("bash", version)}command -v xclaude >/dev/null 2>&1 || return 0
+
+_xclaude_complete() {
+  local cur out directive rest line q p
+  cur=\${COMP_WORDS[COMP_CWORD]}
+  [ "$cur" = "=" ] && cur=
+  # bash 3.2 keeps --flag=value in one word; readline completes the part after =.
+  case $cur in -*=*) cur=\${cur#*=} ;; esac
+  out=$(xclaude __complete bash "$COMP_CWORD" "\${COMP_WORDS[@]}" 2>/dev/null) || return 0
+  directive=\${out%%$'\\n'*}
+  case $out in
+    *$'\\n'*) rest=\${out#*$'\\n'} ;;
+    *) rest= ;;
+  esac
+  COMPREPLY=()
+  case $directive in
+    files|dirs)
+      if [ "$directive" = dirs ]; then rest=$(compgen -d -- "$cur"); else rest=$(compgen -f -- "$cur"); fi
+      while IFS= read -r line; do
+        [ -n "$line" ] || continue
+        printf -v q '%q' "$line"
+        case $q in '\\~'*) q=\${q#\\\\} ;; esac
+        p=$line
+        case $p in '~/'*) p=$HOME/\${p#'~/'} ;; esac
+        if [ -d "$p" ]; then COMPREPLY[\${#COMPREPLY[@]}]="$q/"; else COMPREPLY[\${#COMPREPLY[@]}]="$q "; fi
+      done <<XCLAUDE_EOF
+$rest
+XCLAUDE_EOF
+      ;;
+    *)
+      while IFS= read -r line; do
+        [ -n "$line" ] || continue
+        if [ "$directive" = nospace ]; then COMPREPLY[\${#COMPREPLY[@]}]="$line"; else COMPREPLY[\${#COMPREPLY[@]}]="$line "; fi
+      done <<XCLAUDE_EOF
+$rest
+XCLAUDE_EOF
+      ;;
+  esac
+  return 0
+}
+complete -o nospace -F _xclaude_complete xclaude
+${guard ? `
+${GUARD}` : ""}`;
+}
+function initZsh(version, guard) {
+  return `${header("zsh", version)}command -v xclaude >/dev/null 2>&1 || return 0
+
+_xclaude_complete() {
+  local out directive line
+  local -a lines vals descs
+  out=$(xclaude __complete zsh $(( CURRENT - 1 )) "\${words[@]}" 2>/dev/null) || return 1
+  lines=("\${(@f)out}")
+  directive=\${lines[1]}
+  shift lines
+  case $directive in
+    files) compset -P '*='; _files ;;
+    dirs) compset -P '*='; _files -/ ;;
+    *)
+      for line in "\${lines[@]}"; do
+        [[ -n $line ]] || continue
+        vals+=("\${line%%$'\\t'*}")
+        if [[ $line == *$'\\t'* ]]; then
+          descs+=("\${line%%$'\\t'*}  -- \${line#*$'\\t'}")
+        else
+          descs+=("$line")
+        fi
+      done
+      (( \${#vals} )) || return 1
+      if [[ $directive == nospace ]]; then
+        compadd -S '' -l -d descs -a vals
+      else
+        compadd -l -d descs -a vals
+      fi
+      ;;
+  esac
+}
+
+_xclaude_register() {
+  add-zsh-hook -d precmd _xclaude_register
+  (( $+functions[compdef] )) || { autoload -Uz compinit && compinit -i; }
+  compdef _xclaude_complete xclaude
+}
+autoload -Uz add-zsh-hook
+add-zsh-hook precmd _xclaude_register
+${guard ? `
+${GUARD}` : ""}`;
+}
+function initFile(paths, shell) {
+  return path15.join(paths.shell, `init.${shell}`);
+}
+function writeInitFiles(paths, config, version) {
+  mkdirPrivate(paths.shell);
+  writeFileAtomic(initFile(paths, "bash"), initBash(version, config.guard), { mode: 420 });
+  writeFileAtomic(initFile(paths, "zsh"), initZsh(version, config.guard), { mode: 420 });
+}
+function refreshInitFiles(paths, config, version) {
+  if (fs20.existsSync(paths.shell)) writeInitFiles(paths, config, version);
+}
+
+// package.json
+var package_default = { version: "0.1.2" };
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/commands/guard.ts
+function guardCommand(ctx, config, args) {
+  const [sub = "status", ...rest] = args;
+  if (rest.length || !["on", "off", "status"].includes(sub)) throw new UsageError("usage: xclaude guard on|off|status");
+  const rcFiles = installedIn(ctx.env, ctx.paths.home).map((f) => tildify(f, ctx.paths.home));
+  if (sub === "status") {
+    ctx.io.out(`guard: ${config.guard ? "on" : "off"}
+`);
+    ctx.io.out(`shell integration: ${rcFiles.length ? `installed in ${rcFiles.join(", ")}` : "not installed (xclaude shell install)"}
+`);
+    return EXIT_OK;
+  }
+  config.guard = sub === "on";
+  saveConfig(ctx.paths, config);
+  writeInitFiles(ctx.paths, config, VERSION);
+  ctx.io.err(
+    `xclaude: guard ${sub}: bare \`claude\` ${config.guard ? "refuses to run" : "works again"} in new shells (or after: exec $SHELL)
+`
+  );
+  if (!rcFiles.length) ctx.io.err("xclaude: the shell block isn't installed yet, so this has no effect until you run: xclaude shell install\n");
+  return EXIT_OK;
+}
+
+// src/commands/help.ts
+var MAIN_HELP = `xclaude \u2014 run Claude Code under several claude.ai logins at once
+
+Usage:
+  xclaude <account> [claude args\u2026]   Claude Code as that account
+  xclaude [claude flags\u2026]            the same, after picking the account
+  xclaude <command> [args\u2026]          one of the commands below
+
+Everything after the account goes to claude, flags and subcommands alike, as in
+xclaude acme -c --chrome or xclaude acme auth status.
+
+Commands:
+  add <name>                  add an account, then log in with /login
+  ls                          list accounts: login, defaults, config dir
+  set <name>                  change an account's defaults
+  set main --enable|--disable use the login in ~/.claude as the account "main"
+  rm <name>                   remove an account and log it out
+  rm --leftovers              delete the folders removed accounts left behind
+  tmux new|attach|ls|kill     run Claude Code in tmux sessions, by label
+  shell install|uninstall     completion (and the guard) in ~/.zshrc, ~/.bashrc
+  shell completion bash|zsh   print the completion script to load elsewhere
+  guard on|off|status         make bare \`claude\` refuse to run in your shells
+  doctor [--fix]              check links, logins and setup; --fix repairs
+  help [command]              a command's options; -v prints the version
+
+Conversations, prompt history, memory and personal content (skills, agents,
+commands, plugins\u2026) are shared by every account, so \`xclaude other -c\`
+continues the last conversation in this folder, whichever account it ran on.
+`;
+var COMMAND_HELP = {
+  add: `Usage: xclaude add <name> [--model M] [--effort E] [--args "\u2026"]
+
+Creates the account, links it to the shared ~/.claude, then starts Claude Code
+in it so you can go through the first-run screens and log in with /login.
+
+  --model M     default model, e.g. opus or sonnet
+  --effort E    default effort: low, medium, high, xhigh, max or ultracode
+  --args "\u2026"    extra Claude Code arguments for every launch, split like a
+                shell line
+
+Names use lowercase letters, digits and dashes, and start with a letter.
+`,
+  rm: `Usage: xclaude rm <name> [--keep-login] [-y]
+       xclaude rm --leftovers [-y]
+
+Removes an account: stops its background sessions, logs it out, and deletes its
+login, settings and caches. Shared conversations and content stay in ~/.claude.
+
+Its folder keeps only its links into ~/.claude, so its old conversations can
+still open their saved long outputs. Run rm on the name again to delete that
+leftover folder, or --leftovers to delete every one, after a confirmation.
+
+  --keep-login  don't log the account out
+  --leftovers   delete the leftover folders of all removed accounts
+  -y            don't ask for confirmation
+`,
+  ls: `Usage: xclaude ls
+
+Lists the accounts with their email, organization and login status, their
+defaults, and each one's config dir (the CLAUDE_CONFIG_DIR to use elsewhere,
+e.g. in an editor's environment settings).
+`,
+  set: `Usage: xclaude set <name> [--model M] [--effort E] [--args "\u2026"]
+                   [--unset model|effort|args]
+       xclaude set main --enable|--disable
+
+Changes an account's launch defaults; with no options, prints them.
+Arguments typed at launch always win over these defaults.
+
+  --model M      default model
+  --effort E     default effort: low, medium, high, xhigh, max or ultracode
+  --args "\u2026"     extra Claude Code arguments, split like a shell line
+  --unset KEY    clear model, effort or args
+  --enable       (main only) use the login in ~/.claude as the account "main"
+  --disable      (main only) turn it off again
+`,
+  tmux: `Usage: xclaude tmux new <label> [--dir <path>] [--detach] [--empty]
+                        [<account> [claude args\u2026]]
+       xclaude tmux attach [<label>]
+       xclaude tmux ls
+       xclaude tmux kill <label>
+
+  new       create session <label> running Claude Code on <account> (the picker
+            opens without one), then attach to it
+              --dir <path>  working directory (default: the current one)
+              --detach      don't attach
+              --empty       just a shell, no Claude Code
+  attach    attach to a session; without a label, pick one
+  ls        list sessions with their account, directory and Claude's state
+  kill      end a session
+
+Bare \`xclaude tmux\` is \`xclaude tmux ls\`. Needs tmux 3.0 or later.
+`,
+  shell: `Usage: xclaude shell install|uninstall [--bash] [--zsh]
+       xclaude shell completion bash|zsh
+
+  install      add a small block to ~/.zshrc (under $ZDOTDIR when set) and/or
+               ~/.bashrc, whichever exist, that loads completion and, when on,
+               the guard; on macOS also to a ~/.bash_profile that doesn't load
+               ~/.bashrc
+  uninstall    remove that block
+  completion   print the completion script for a shell
+
+Open a new shell (or run \`exec $SHELL\`) afterwards.
+`,
+  guard: `Usage: xclaude guard on|off|status
+
+When on, bare \`claude\` refuses to run in interactive shells and points to
+xclaude. It still works inside Claude Code sessions, in anything xclaude
+started, and whenever xclaude isn't installed. Needs \`xclaude shell install\`.
+`,
+  doctor: `Usage: xclaude doctor [--fix]
+
+Checks tools, config, every account's links and login, the shell setup,
+machine-managed settings and the environment. Exits non-zero if something is
+wrong.
+
+  --fix    repair links, merge left-behind directories, fix CLAUDE.md stubs
+`,
+  help: `Usage: xclaude help [command]
+`
+};
+function helpText(topic) {
+  if (topic === void 0) return MAIN_HELP;
+  const text = COMMAND_HELP[topic];
+  if (!text) throw new UsageError(`no help for "${topic}"; commands: ${Object.keys(COMMAND_HELP).join(", ")}`);
+  return text;
+}
+function wantsHelp(args) {
+  return args[0] === "-h" || args[0] === "--help";
+}
+
+// src/shell/complete.ts
+import fs22 from "node:fs";
+import path17 from "node:path";
+
+// src/claude/help.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import fs21 from "node:fs";
+import path16 from "node:path";
+var FALLBACK_SUBCOMMANDS = ["auth", "mcp", "plugin", "agents", "daemon", "doctor", "update", "install", "setup-token"];
+var opt = (names, value, placeholder, choices) => ({
+  names,
+  value,
+  ...placeholder ? { placeholder } : {},
+  ...choices ? { choices } : {},
+  description: ""
+});
+var FALLBACK_HELP = {
+  subcommands: [...FALLBACK_SUBCOMMANDS],
+  options: [
+    opt(["--add-dir"], "variadic", "directories"),
+    opt(["--agent"], "required", "agent"),
+    opt(["--agents"], "required", "json-or-file"),
+    opt(["--allowedTools", "--allowed-tools"], "variadic", "tools"),
+    opt(["--append-system-prompt"], "required", "prompt"),
+    opt(["--chrome"], "none"),
+    opt(["-c", "--continue"], "none"),
+    opt(["--dangerously-skip-permissions"], "none"),
+    opt(["-d", "--debug"], "optional", "filter"),
+    opt(["--debug-file"], "required", "path"),
+    opt(["--disallowedTools", "--disallowed-tools"], "variadic", "tools"),
+    opt(["--effort"], "required", "level"),
+    opt(["--fallback-model"], "required", "model"),
+    opt(["--fork-session"], "none"),
+    opt(["-h", "--help"], "none"),
+    opt(["--ide"], "none"),
+    opt(["--input-format"], "required", "format", ["text", "stream-json"]),
+    opt(["--mcp-config"], "variadic", "configs"),
+    opt(["--model"], "required", "model"),
+    opt(["-n", "--name"], "required", "name"),
+    opt(["--no-chrome"], "none"),
+    opt(["--output-format"], "required", "format", ["text", "json", "stream-json"]),
+    opt(["--permission-mode"], "required", "mode", ["acceptEdits", "auto", "bypassPermissions", "manual", "dontAsk", "plan"]),
+    opt(["--plugin-dir"], "required", "path"),
+    opt(["-p", "--print"], "none"),
+    opt(["-r", "--resume"], "optional", "value"),
+    opt(["--session-id"], "required", "uuid"),
+    opt(["--settings"], "required", "file-or-json"),
+    opt(["--strict-mcp-config"], "none"),
+    opt(["--system-prompt"], "required", "prompt"),
+    opt(["--tools"], "variadic", "tools"),
+    opt(["--verbose"], "none"),
+    opt(["-v", "--version"], "none"),
+    opt(["-w", "--worktree"], "optional", "name")
+  ]
+};
+function valueKind(placeholder) {
+  if (!placeholder) return "none";
+  const variadic = placeholder.includes("...");
+  if (placeholder.startsWith("<")) return variadic ? "variadic" : "required";
+  return "optional";
+}
+function parseChoices(description) {
+  const m = /\(choices: ([^)]*)\)/.exec(description);
+  if (!m) return void 0;
+  const choices = [...m[1].matchAll(/"([^"]*)"/g)].map((x) => x[1]);
+  return choices.length ? choices : void 0;
+}
+function parseHelp(text) {
+  const options = [];
+  const subcommands = [];
+  let section = "";
+  let current = null;
+  const finish = () => {
+    if (!current) return;
+    current.description = current.description.replace(/\s+/g, " ").trim();
+    const choices = parseChoices(current.description);
+    if (choices) current.choices = choices;
+    options.push(current);
+    current = null;
+  };
+  for (const line of text.split("\n")) {
+    const header2 = /^([A-Z][A-Za-z ]*):\s*$/.exec(line);
+    if (header2) {
+      finish();
+      section = header2[1];
+      continue;
+    }
+    if (section === "Options") {
+      const m = /^ {2}(-\S.*)$/.exec(line);
+      if (m) {
+        finish();
+        const [spec = "", ...rest] = m[1].split(/\s{2,}/);
+        const tokens = spec.split(/,?\s+/).filter(Boolean);
+        const names = tokens.filter((t) => t.startsWith("-")).map((t) => t.replace(/,$/, ""));
+        const placeholder = tokens.find((t) => t.startsWith("<") || t.startsWith("["));
+        current = {
+          names,
+          value: valueKind(placeholder),
+          ...placeholder ? { placeholder: placeholder.replace(/^[<[]|\.{3}|[>\]]$/g, "") } : {},
+          description: rest.join(" ")
+        };
+      } else if (current && /^\s{3,}\S/.test(line)) {
+        current.description += ` ${line.trim()}`;
+      } else if (line.trim() === "") {
+        finish();
+      }
+    } else if (section === "Commands") {
+      const m = /^ {2}([a-z][\w|-]*)/.exec(line);
+      if (m) subcommands.push(...m[1].split("|"));
+    }
+  }
+  finish();
+  return { options, subcommands };
+}
+function findOption(help, arg) {
+  const flag = arg.startsWith("--") ? arg.split("=")[0] : arg;
+  return help.options.find((o) => o.names.includes(flag));
+}
+function longName(o) {
+  return o.names.find((n) => n.startsWith("--")) ?? o.names[0];
+}
+function isSubcommand(word, help) {
+  if (!word || word.startsWith("-")) return false;
+  return FALLBACK_SUBCOMMANDS.includes(word) || Boolean(help?.subcommands.includes(word));
+}
+function loadHelp(claude, cacheDir, env) {
+  const real = realpathOrNull(claude) ?? claude;
+  let st;
+  try {
+    st = fs21.statSync(real);
+  } catch {
+    return FALLBACK_HELP;
+  }
+  const key = { path: real, mtimeMs: st.mtimeMs, size: st.size };
+  const file = path16.join(cacheDir, "claude-help.json");
+  try {
+    const cached = JSON.parse(readFileOrNull(file) ?? "null");
+    if (cached && cached.key.path === key.path && cached.key.mtimeMs === key.mtimeMs && cached.key.size === key.size) {
+      return cached.help;
+    }
+  } catch {
+  }
+  const res = spawnSync3(...shellWay(claude, ["--help"]), {
+    env,
+    encoding: "utf8",
+    timeout: 15e3,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  let help = res.status === 0 && res.stdout ? parseHelp(res.stdout) : FALLBACK_HELP;
+  if (help.options.length < 5) help = FALLBACK_HELP;
+  try {
+    mkdirPrivate(cacheDir);
+    writeFileAtomic(file, `${JSON.stringify({ key, help })}
+`, { mode: 384 });
+  } catch {
+  }
+  return help;
+}
+
+// src/tmux/sessions.ts
+var LABEL = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+var SEP = "|";
+var FORMAT = ["#{session_id}", "#{@xclaude}", "#{session_attached}", "#{session_created}", "#{@xclaude_label}", "#{@xclaude_account}", "#{@xclaude_dir}"].join(SEP);
+function sessionName(account, label) {
+  return account ? `xclaude-${account}_${label}` : `xclaude--${label}`;
+}
+function listSessions(tmux) {
+  const res = tmux.run(["list-sessions", "-F", FORMAT]);
+  if (res.code !== 0) {
+    if (isNoServer(res.stderr)) return [];
+    throw new XError(`tmux list-sessions failed: ${res.stderr.trim()}`);
+  }
+  const sessions = [];
+  for (const line of res.stdout.split("\n")) {
+    const parts = line.split(SEP);
+    if (parts.length < 7 || parts[1] !== "1") continue;
+    const [id = "", , attached = "0", created = "0", label = "", account = "", ...dir] = parts;
+    sessions.push({ id, label, account: account || null, dir: dir.join(SEP), attached: Number(attached), created: Number(created) });
+  }
+  return sessions.sort((a, b) => a.label.localeCompare(b.label));
+}
+function findByLabel(sessions, label) {
+  return sessions.find((s) => s.label === label);
+}
+
+// src/shell/complete.ts
+var MODEL_ALIASES = ["default", "best", "fable", "opus", "sonnet", "haiku", "opus[1m]", "sonnet[1m]", "opusplan"];
+var COMMAND_DESCRIPTIONS = {
+  add: "add an account and log in",
+  rm: "remove an account",
+  ls: "list accounts and logins",
+  set: "change an account's defaults",
+  tmux: "Claude Code in tmux sessions",
+  doctor: "check and repair",
+  shell: "shell integration",
+  guard: "disable bare claude",
+  help: "help for a command"
+};
+var none = () => ({ directive: "default", items: [] });
+var words = (values, describe) => ({
+  directive: "default",
+  items: values.map((value) => ({ value, ...describe?.(value) ? { description: describe(value) } : {} }))
+});
+function logicalWords(shell, words2, cword) {
+  let end = cword;
+  let cur = words2[cword] ?? "";
+  if (shell === "bash") {
+    if (cur === "=" && cword > 0) {
+      cur = `${words2[cword - 1]}=`;
+      end = cword - 1;
+    } else if (words2[cword - 1] === "=" && cword > 1) {
+      cur = `${words2[cword - 2]}=${cur}`;
+      end = cword - 2;
+    }
+  }
+  const prior = [];
+  const before = words2.slice(0, end);
+  for (let i = 0; i < before.length; i++) {
+    if (shell === "bash" && before[i] === "=" && prior.length && i + 1 < before.length) {
+      prior[prior.length - 1] += `=${before[++i]}`;
+    } else {
+      prior.push(before[i]);
+    }
+  }
+  return { prior, cur };
+}
+function suggestLabel(cwd) {
+  const label = path17.basename(cwd).replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "").slice(0, 64);
+  return label || null;
+}
+function resumeCandidates(store, cwd) {
+  const dir = path17.join(store, "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+  let files;
+  try {
+    files = fs22.readdirSync(dir).filter((n) => n.endsWith(".jsonl")).map((n) => ({ id: n.slice(0, -".jsonl".length), file: path17.join(dir, n), mtime: fs22.statSync(path17.join(dir, n)).mtimeMs }));
+  } catch {
+    return [];
+  }
+  return files.sort((a, b) => b.mtime - a.mtime).slice(0, 30).map((f) => {
+    const title = sessionTitle(f.file);
+    return title ? { value: f.id, description: title } : { value: f.id };
+  });
+}
+function sessionTitle(file) {
+  let head;
+  try {
+    const fd = fs22.openSync(file, "r");
+    try {
+      const buf = Buffer.alloc(16384);
+      head = buf.subarray(0, fs22.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
+    } finally {
+      fs22.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+  let prompt = null;
+  for (const line of head.split("\n")) {
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof e.customTitle === "string" && e.customTitle) return clip(e.customTitle);
+    if (e.type === "summary" && typeof e.summary === "string") return clip(e.summary);
+    if (!prompt && e.type === "user") {
+      const content = e.message?.content;
+      if (typeof content === "string") prompt = content;
+      else if (Array.isArray(content)) {
+        const text = content.find((c) => c?.type === "text")?.text;
+        if (typeof text === "string") prompt = text;
+      }
+    }
+  }
+  return prompt ? clip(prompt) : null;
+}
+function clip(s) {
+  const one = s.replace(/\s+/g, " ").trim();
+  return one.length > 60 ? `${one.slice(0, 59)}\u2026` : one;
+}
+var Completer = class {
+  ctx;
+  config;
+  help = null;
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+  }
+  /** Claude Code's parsed --help: the cache, or a one-time parse; the built-in lists without ~/.xclaude. */
+  claudeHelp() {
+    if (this.help) return this.help;
+    this.help = FALLBACK_HELP;
+    if (fs22.existsSync(this.ctx.paths.xhome)) {
+      try {
+        const claude = findClaude(this.ctx.env, this.config, this.ctx.paths.home, this.ctx.selfPath);
+        this.help = loadHelp(claude, this.ctx.paths.cache, this.ctx.env);
+      } catch {
+      }
+    }
+    return this.help;
+  }
+  describeIdentity(name) {
+    const d = defaultsOf(this.config, name);
+    const parts = [name === MAIN ? "the ~/.claude login" : "account", d ? describeDefaults(d) : ""].filter(Boolean);
+    return parts.join(" \xB7 ");
+  }
+  complete(args, cur) {
+    const ids = identities(this.config);
+    if (args.length === 0) {
+      if (cur.startsWith("-")) return { directive: "default", items: [...this.claudeFlags(), { value: "--help" }, { value: "--version" }] };
+      return {
+        directive: "default",
+        items: [
+          ...COMMANDS.map((c) => ({ value: c, description: COMMAND_DESCRIPTIONS[c] })),
+          ...ids.map((n) => ({ value: n, description: this.describeIdentity(n) }))
+        ]
+      };
+    }
+    const [first = "", ...rest] = args;
+    if (ids.includes(first)) return this.claudeArgs(rest, cur);
+    if (first.startsWith("-")) return this.claudeArgs(args, cur);
+    switch (first) {
+      case "add":
+        return this.own(rest, cur, { "--model": "model", "--effort": "effort", "--args": "text" }, 1, () => []);
+      case "rm":
+        if (rest.includes("--leftovers")) return this.own(rest, cur, { "-y": null }, 0, () => []);
+        return this.own(
+          rest,
+          cur,
+          { "--keep-login": null, "--leftovers": null, "-y": null },
+          1,
+          () => [...Object.keys(this.config.accounts), ...leftoverNames(this.ctx.paths, this.config)],
+          (n) => this.config.accounts[n] ? this.describeIdentity(n) : "leftover folder of a removed account"
+        );
+      case "set":
+        return this.own(
+          rest,
+          cur,
+          { "--model": "model", "--effort": "effort", "--args": "text", "--unset": "unset", "--enable": null, "--disable": null },
+          1,
+          () => [...Object.keys(this.config.accounts), MAIN]
+        );
+      case "tmux":
+        return this.tmux(rest, cur);
+      case "shell":
+        if (rest.length === 0) return words(["install", "uninstall", "completion"]);
+        if (rest[0] === "completion") return rest.length === 1 ? words(["bash", "zsh"]) : none();
+        return rest[0] === "install" || rest[0] === "uninstall" ? words(["--bash", "--zsh"]) : none();
+      case "guard":
+        return rest.length === 0 ? words(["on", "off", "status"]) : none();
+      case "doctor":
+        return words(["--fix"]);
+      case "help":
+        return rest.length === 0 ? words(COMMANDS, (c) => COMMAND_DESCRIPTIONS[c]) : none();
+      default:
+        return none();
+    }
+  }
+  /** xclaude's own options: flags, their values, and up to `max` positionals. */
+  own(rest, cur, flags, max, positional, describe = (n) => n === MAIN || this.config.accounts[n] ? this.describeIdentity(n) : void 0) {
+    const eq = cur.startsWith("--") ? cur.indexOf("=") : -1;
+    if (eq > 0) return this.ownValues(flags[cur.slice(0, eq)] ?? null, cur.slice(0, eq + 1));
+    const prev = rest[rest.length - 1];
+    if (prev !== void 0 && flags[prev]) return this.ownValues(flags[prev], "");
+    if (cur.startsWith("-")) return words(Object.keys(flags));
+    let positionals = 0;
+    for (let i = 0; i < rest.length; i++) {
+      const a = rest[i];
+      if (a.startsWith("-")) {
+        if (flags[a] && !a.includes("=")) i++;
+      } else positionals++;
+    }
+    if (positionals >= max) return none();
+    return words(positional(), describe);
+  }
+  ownValues(kind, prefix) {
+    const values = kind === "model" ? MODEL_ALIASES : kind === "effort" ? EFFORTS : kind === "unset" ? ["model", "effort", "args"] : [];
+    return words(values.map((v) => `${prefix}${v}`));
+  }
+  claudeFlags() {
+    const items = [];
+    for (const o of this.claudeHelp().options) {
+      const description = o.description ? clip(o.description.split(/(?<=\.)\s/)[0]) : void 0;
+      for (const n of o.names) items.push(description ? { value: n, description } : { value: n });
+    }
+    return items;
+  }
+  /** The option waiting for a value: the previous word, or a variadic list still going on. */
+  pendingValue(args) {
+    const help = this.claudeHelp();
+    const last = args[args.length - 1];
+    if (last?.startsWith("-") && !last.includes("=")) {
+      const spec = findOption(help, last);
+      return spec && spec.value !== "none" ? spec : null;
+    }
+    for (let i = args.length - 1; i >= 0; i--) {
+      const a = args[i];
+      if (a.startsWith("-")) {
+        const spec = a.includes("=") ? void 0 : findOption(help, a);
+        return spec?.value === "variadic" ? spec : null;
+      }
+    }
+    return null;
+  }
+  claudeArgs(args, cur) {
+    const help = this.claudeHelp();
+    if (args.length && isSubcommand(args[0], help)) return { directive: "files", items: [] };
+    const eq = cur.startsWith("--") ? cur.indexOf("=") : -1;
+    if (eq > 0) {
+      const spec = findOption(help, cur.slice(0, eq));
+      return spec && spec.value !== "none" ? this.claudeValues(spec, cur.slice(0, eq + 1)) : none();
+    }
+    if (!cur.startsWith("-")) {
+      const pending = this.pendingValue(args);
+      if (pending) return this.claudeValues(pending, "");
+      if (args.length === 0) return words([.../* @__PURE__ */ new Set([...help.subcommands, ...FALLBACK_SUBCOMMANDS])].sort());
+      return none();
+    }
+    return { directive: "default", items: this.claudeFlags() };
+  }
+  claudeValues(spec, prefix) {
+    const name = longName(spec);
+    let values = null;
+    if (name === "--model" || name === "--fallback-model") values = MODEL_ALIASES.map((value) => ({ value }));
+    else if (name === "--effort") values = EFFORTS.map((value) => ({ value }));
+    else if (spec.choices) values = spec.choices.map((value) => ({ value }));
+    else if (name === "--resume") values = resumeCandidates(this.ctx.paths.store, this.ctx.cwd);
+    else if (/dir/i.test(name) || /dir/i.test(spec.placeholder ?? "")) return { directive: "dirs", items: [] };
+    else if (/path|file|config/i.test(spec.placeholder ?? "")) return { directive: "files", items: [] };
+    if (!values) return none();
+    return { directive: "default", items: values.map((v) => ({ ...v, value: `${prefix}${v.value}` })) };
+  }
+  labels() {
+    try {
+      return listSessions(new Tmux(this.ctx.env)).map((s) => s.label);
+    } catch {
+      return [];
+    }
+  }
+  tmux(rest, cur) {
+    if (rest.length === 0) return words(["new", "attach", "ls", "kill"]);
+    const [sub, ...more] = rest;
+    if (sub === "attach" || sub === "kill") return more.length === 0 ? words(this.labels()) : none();
+    if (sub !== "new") return none();
+    if (more.length === 0) {
+      const label = suggestLabel(this.ctx.cwd);
+      return !cur.startsWith("-") && label ? words([label]) : none();
+    }
+    const after = more.slice(1);
+    if (after[after.length - 1] === "--dir" || cur.startsWith("--dir=")) return { directive: "dirs", items: [] };
+    let i = 0;
+    for (; i < after.length; i++) {
+      if (after[i] === "--dir") i++;
+      else if (!after[i].startsWith("--")) break;
+    }
+    if (i < after.length) return this.claudeArgs(after.slice(i + 1), cur);
+    if (cur.startsWith("-")) return words(["--dir", "--detach", "--empty"]);
+    return words(identities(this.config), (n) => this.describeIdentity(n));
+  }
+};
+function complete(ctx, config, shell, cword, allWords) {
+  const { prior, cur } = logicalWords(shell, allWords, cword);
+  const raw = new Completer(ctx, config).complete(prior.slice(1), cur);
+  const items = raw.items.filter((i) => i.value.startsWith(cur));
+  return { completion: { directive: raw.directive, items }, cur };
+}
+function formatCompletion(c, shell, cur) {
+  const eq = cur.startsWith("-") ? cur.indexOf("=") : -1;
+  const lines = [c.directive];
+  for (const item of c.items) {
+    const value = shell === "bash" && eq > 0 ? item.value.slice(eq + 1) : item.value;
+    lines.push(shell === "zsh" && item.description ? `${value}	${item.description.replace(/[\t\n]/g, " ")}` : value);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/commands/hidden.ts
+function quietConfig(ctx) {
+  try {
+    return loadConfig(ctx.paths, { create: false }).config;
+  } catch {
+    return null;
+  }
+}
+function completeCommand(ctx, args) {
+  const [shell, cwordArg, ...words2] = args;
+  const cword = Number(cwordArg);
+  if (shell !== "bash" && shell !== "zsh" || !Number.isInteger(cword) || cword < 0) return EXIT_OK;
+  const config = quietConfig(ctx);
+  if (!config) return EXIT_OK;
+  try {
+    const { completion, cur } = complete(ctx, config, shell, cword, words2);
+    ctx.io.out(formatCompletion(completion, shell, cur));
+  } catch {
+  }
+  return EXIT_OK;
+}
+function namesCommand(ctx) {
+  const config = quietConfig(ctx);
+  const names = config ? identities(config) : [];
+  if (names.length) ctx.io.out(`${names.join(" ")}
+`);
+  return EXIT_OK;
+}
+
+// src/commands/ls.ts
+async function lsCommand(ctx, config, args) {
+  if (args.length) throw new UsageError("usage: xclaude ls");
+  const names = identities(config);
+  if (!names.length) {
+    ctx.io.out("No accounts yet. Add one with: xclaude add <name>\n");
+    return EXIT_OK;
+  }
+  let claude = null;
+  try {
+    claude = findClaude(ctx.env, config, ctx.paths.home, ctx.selfPath);
+  } catch (e) {
+    if (!(e instanceof XError)) throw e;
+    ctx.io.err(`xclaude: ${e.message}
+`);
+  }
+  const logins = await Promise.all(names.map((n) => claude ? authStatus(claude, identityEnv(ctx, n)).then(describeLogin) : "?"));
+  const rows = names.map((n, i) => {
+    const d = defaultsOf(config, n);
+    const dir = n === MAIN ? `${ctx.paths.store} (no CLAUDE_CONFIG_DIR)` : accountDir(ctx.paths, n);
+    return [n, logins[i], d.model ?? DASH, d.effort ?? DASH, d.args.length ? quoteShellWords(d.args) : DASH, dir];
+  });
+  ctx.io.out(formatTable(["NAME", "LOGIN", "MODEL", "EFFORT", "ARGS", "CONFIG DIR"], rows));
+  return EXIT_OK;
+}
+
+// src/core/prompt.ts
+import fs23 from "node:fs";
+function confirm(question) {
+  fs23.writeSync(2, `${question} [y/N] `);
+  let fd;
+  try {
+    fd = fs23.openSync("/dev/tty", "r");
+  } catch {
+    return false;
+  }
+  try {
+    const buf = Buffer.alloc(256);
+    const n = fs23.readSync(fd, buf, 0, buf.length, null);
+    const answer = buf.subarray(0, n).toString("utf8").trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } catch {
+    return false;
+  } finally {
+    fs23.closeSync(fd);
+  }
+}
+
+// src/core/state.ts
+var MAX_DIRS = 500;
+function emptyState() {
+  return { installedVersion: null, lastAccountByDir: {}, lastUsedAccount: null, seenUnknownEntries: {} };
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function loadState(paths) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileOrNull(paths.state) ?? "{}");
+  } catch {
+    return emptyState();
+  }
+  const state = emptyState();
+  if (!isRecord(raw)) return state;
+  if (typeof raw.installedVersion === "string") state.installedVersion = raw.installedVersion;
+  if (typeof raw.lastUsedAccount === "string") state.lastUsedAccount = raw.lastUsedAccount;
+  if (isRecord(raw.lastAccountByDir)) {
+    for (const [dir, name] of Object.entries(raw.lastAccountByDir)) {
+      if (typeof name === "string") state.lastAccountByDir[dir] = name;
+    }
+  }
+  if (isRecord(raw.seenUnknownEntries)) {
+    for (const [name, entries] of Object.entries(raw.seenUnknownEntries)) {
+      if (Array.isArray(entries)) state.seenUnknownEntries[name] = entries.filter((e) => typeof e === "string");
+    }
+  }
+  return state;
+}
+function saveState(paths, state) {
+  ensureXHome(paths);
+  writeFileAtomic(paths.state, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+}
+function updateState(paths, change) {
+  const state = loadState(paths);
+  change(state);
+  saveState(paths, state);
+  return state;
+}
+function recordUse(state, dir, account) {
+  delete state.lastAccountByDir[dir];
+  state.lastAccountByDir[dir] = account;
+  const dirs = Object.keys(state.lastAccountByDir);
+  for (const old of dirs.slice(0, Math.max(0, dirs.length - MAX_DIRS))) delete state.lastAccountByDir[old];
+  state.lastUsedAccount = account;
+}
+function forgetAccount(state, account) {
+  for (const [dir, name] of Object.entries(state.lastAccountByDir)) {
+    if (name === account) delete state.lastAccountByDir[dir];
+  }
+  if (state.lastUsedAccount === account) state.lastUsedAccount = null;
+  delete state.seenUnknownEntries[account];
+}
+
+// src/grammar.ts
+var HIDDEN = ["__complete", "__names"];
+function isCommand(word) {
+  return COMMANDS.includes(word);
+}
+function isHidden(word) {
+  return HIDDEN.includes(word);
+}
+function classify(argv, config) {
+  const [first, ...rest] = argv;
+  if (first === void 0) return { kind: "launch", account: null, args: [] };
+  if (first === "-v" || first === "--version") return { kind: "version" };
+  if (first === "-h" || first === "--help") return { kind: "help" };
+  if (first.startsWith("-")) return { kind: "launch", account: null, args: argv };
+  if (isCommand(first)) return { kind: "command", name: first, args: rest };
+  if (isHidden(first)) return { kind: "hidden", name: first, args: rest };
+  if (first === MAIN) {
+    if (!config.main.enabled) throw new XError(`the main identity is disabled; enable it with: xclaude set main --enable`);
+    return { kind: "launch", account: MAIN, args: rest };
+  }
+  if (Object.hasOwn(config.accounts, first)) return { kind: "launch", account: first, args: rest };
+  throw unknownAccount(first, config);
+}
+function unknownAccount(word, config) {
+  const names = identities(config);
+  const list = names.length ? `accounts: ${names.join(", ")}` : "no accounts yet; add one with: xclaude add <name>";
+  return new UsageError(`unknown account or command "${word}" (${list})`);
+}
+
+// src/commands/rm.ts
+var USAGE2 = "usage: xclaude rm <name> [--keep-login] [-y], or xclaude rm --leftovers [-y]";
+async function rmCommand(ctx, config, args, listSessions2 = () => []) {
+  const p = parseOptions(args, { "keep-login": {}, leftovers: {}, yes: { short: "y" } }, "rm");
+  const [name, ...extra] = p.positionals;
+  const yes = Boolean(p.values.yes);
+  if (p.values.leftovers) {
+    if (name) throw new UsageError(USAGE2);
+    return removeLeftovers(ctx, config, null, yes, listSessions2);
+  }
+  if (!name || extra.length) throw new UsageError(USAGE2);
+  if (name === MAIN) throw new UsageError("the main identity isn't removable; turn it off with: xclaude set main --disable");
+  if (!Object.hasOwn(config.accounts, name)) {
+    if (strayFolders(ctx.paths, config).some((f) => f.name === name)) return removeLeftovers(ctx, config, name, yes, listSessions2);
+    throw unknownAccount(name, config);
+  }
+  const log = (line) => ctx.io.err(`${line}
+`);
+  const dir = accountDir(ctx.paths, name);
+  const st = lstatOrNull(dir);
+  if (st?.isSymbolicLink()) {
+    throw new XError(`not removing ${name}: ${tildify(dir, ctx.paths.home)} is a symlink, and xclaude only manages real folders there. Replace it with a real folder, or remove it by hand.`);
+  }
+  if (!yes) {
+    if (!ctx.tty.stdin) throw new UsageError(`removing ${name} needs a confirmation: run it in a terminal, or pass -y`);
+    const ok = confirm(`Remove account ${name}? Its login and settings go; shared conversations and content stay in ~/.claude.`);
+    if (!ok) {
+      log("xclaude: nothing removed");
+      throw new Cancelled();
+    }
+  }
+  if (!st) {
+    forget(ctx, name);
+    log(`xclaude: removed ${name}; its folder was already gone, so it wasn't logged out (on macOS its Keychain login may remain)`);
+    return EXIT_OK;
+  }
+  const table = shareTable(config, ctx.switches);
+  const res = repairAccount({ paths: ctx.paths, account: name, table, lockWaitMs: Infinity, replaceWrongLinks: false, log });
+  if (!res.clean) {
+    for (const pr of res.problems) log(`xclaude: ${problemLine(name, pr)}`);
+    throw new XError(`not removing ${name}: its links aren't all in place, and deleting now could delete shared data. Run \`xclaude doctor --fix\` first.`);
+  }
+  if (ctx.switches.normalizePaths && table.dirs.includes("plugins")) {
+    normalizePaths(ctx.paths, { account: name, lockWaitMs: Infinity, log });
+  }
+  let claude = null;
+  try {
+    claude = findClaude(ctx.env, config, ctx.paths.home, ctx.selfPath);
+  } catch (e) {
+    if (!(e instanceof XError)) throw e;
+    log(`xclaude: ${e.message}; skipping the supervisor stop and the logout`);
+  }
+  if (claude) {
+    const env = identityEnv(ctx, name);
+    await runClaude(claude, ["daemon", "stop", "--any"], env);
+    await logout(ctx, config, claude, name, Boolean(p.values["keep-login"]), log);
+  }
+  const sessions = listSessions2(name);
+  if (sessions.length) log(`xclaude: tmux sessions still running on ${name} (left alone): ${sessions.join(", ")}`);
+  const { kept, content } = keepOnlyLinks(dir, table);
+  removeTree(`${dir}.lock`);
+  forget(ctx, name);
+  log(`xclaude: removed ${name}`);
+  const where = tildify(dir, ctx.paths.home);
+  if (content.length) {
+    log(
+      `xclaude: ${where} keeps its links into ~/.claude, so ${name}'s old conversations can still open their saved long outputs, and ${name}'s own ${content.join(", ")} (not shared). Move what you want to keep; then \`xclaude rm ${name}\` deletes the rest.`
+    );
+  } else if (kept) {
+    log(`xclaude: ${where} keeps only its links into ~/.claude, so ${name}'s old conversations can still open their saved long outputs; delete it with: xclaude rm ${name}`);
+  }
+  return EXIT_OK;
+}
+function forget(ctx, name) {
+  const fresh = loadConfig(ctx.paths, { create: false }).config;
+  delete fresh.accounts[name];
+  saveConfig(ctx.paths, fresh);
+  updateState(ctx.paths, (s) => forgetAccount(s, name));
+}
+function whyNot(f, where) {
+  switch (f.kind) {
+    case "content":
+      return `not deleting ${where}: it holds more than links (${f.entries.join(", ")}). \`xclaude add ${f.name}\` takes it back as an account, merging shared content into ~/.claude; or check it and delete it by hand.`;
+    case "stray":
+      return `not deleting ${where}: that name couldn't be an account's, so xclaude didn't make this folder; check it by hand.`;
+    case "link":
+      return `not deleting ${where}: it's a symlink, and xclaude only manages real folders there.`;
+    default:
+      return "";
+  }
+}
+function removeLeftovers(ctx, config, only, yes, listSessions2) {
+  const log = (line) => ctx.io.err(`${line}
+`);
+  const where = (name) => tildify(accountDir(ctx.paths, name), ctx.paths.home);
+  const folders = strayFolders(ctx.paths, config).filter((f) => only === null || f.name === only);
+  if (!folders.length) {
+    log("xclaude: no leftover folders");
+    return EXIT_OK;
+  }
+  const names = [];
+  for (const f of folders) {
+    const sessions = f.kind === "leftover" ? listSessions2(f.name) : [];
+    if (f.kind !== "leftover") log(`xclaude: ${whyNot(f, where(f.name))}`);
+    else if (sessions.length) log(`xclaude: not deleting ${where(f.name)}: tmux sessions of ${f.name} still run (${sessions.join(", ")}); end them first`);
+    else names.push(f.name);
+  }
+  if (!names.length) return EXIT_ERROR;
+  if (!yes) {
+    if (!ctx.tty.stdin) throw new UsageError("deleting leftover folders needs a confirmation: run it in a terminal, or pass -y");
+    const which = names.length === 1 ? `${names[0]}'s leftover folder` : `the leftover folders of ${names.join(", ")}`;
+    const ok = confirm(`Delete ${which}? Old conversations from ${names.length === 1 ? "it" : "them"} can then no longer open their saved long outputs.`);
+    if (!ok) {
+      log("xclaude: nothing deleted");
+      throw new Cancelled();
+    }
+  }
+  const still = new Set(leftoverNames(ctx.paths, loadConfig(ctx.paths, { create: false }).config));
+  let deleted = 0;
+  for (const name of names) {
+    if (!still.has(name)) {
+      log(`xclaude: left ${where(name)} alone: it changed meanwhile`);
+      continue;
+    }
+    const dir = accountDir(ctx.paths, name);
+    removeTree(dir);
+    removeTree(`${dir}.lock`);
+    log(`xclaude: deleted ${where(name)}`);
+    deleted++;
+  }
+  return deleted === folders.length ? EXIT_OK : EXIT_ERROR;
+}
+async function logout(ctx, config, claude, name, keep, log) {
+  if (keep) {
+    log(`xclaude: keeping ${name}'s login (--keep-login)`);
+    return;
+  }
+  const others = ctx.switches.keepSameEmailLogin ? identities(config).filter((n) => n !== name).map((n) => ({ label: n, env: identityEnv(ctx, n) })) : [];
+  if (ctx.switches.keepSameEmailLogin && !config.main.enabled) others.push({ label: "the ~/.claude login", env: identityEnv(ctx, MAIN) });
+  const [mine, ...theirs] = await Promise.all([identityEnv(ctx, name), ...others.map((o) => o.env)].map((env) => authStatus(claude, env)));
+  if (mine.error) {
+    log(`xclaude: couldn't read ${name}'s login (${mine.error}), so it isn't logged out; its login may remain (on macOS, in the Keychain)`);
+    return;
+  }
+  if (!mine.loggedIn) return;
+  if (ctx.switches.keepSameEmailLogin) {
+    const unknown = others.filter((_, i) => theirs[i].error);
+    if (unknown.length) {
+      log(`xclaude: not logging ${name} out: couldn't read the login of ${unknown.map((o) => o.label).join(", ")}, which may use the same email`);
+      return;
+    }
+    const same = others.filter((_, i) => theirs[i].loggedIn && theirs[i].email === mine.email);
+    if (same.length) {
+      log(`xclaude: not logging ${name} out: ${same.map((o) => o.label).join(", ")} ${same.length > 1 ? "are" : "is"} logged in with the same email (${mine.email}), and a logout could affect ${same.length > 1 ? "them" : "it"}`);
+      return;
+    }
+  }
+  const res = await runClaude(claude, ["auth", "logout"], identityEnv(ctx, name));
+  if (res.code !== 0) log(`xclaude: logging ${name} out failed: ${(res.stderr || res.stdout).trim().split("\n")[0]}`);
+}
+
+// src/commands/set.ts
+var USAGE3 = 'usage: xclaude set <name> [--model M] [--effort E] [--args "\u2026"] [--unset model|effort|args], or xclaude set main --enable|--disable';
+var KEYS = ["model", "effort", "args"];
+function setCommand(ctx, config, args) {
+  const p = parseOptions(args, { ...DEFAULT_OPTIONS, unset: { value: true, repeat: true }, enable: {}, disable: {} }, "set");
+  const [name, ...extra] = p.positionals;
+  if (!name || extra.length) throw new UsageError(USAGE3);
+  const isMain = name === MAIN;
+  if (!isMain && !Object.hasOwn(config.accounts, name)) throw unknownAccount(name, config);
+  const target = isMain ? config.main : config.accounts[name];
+  if ((p.values.enable || p.values.disable) && !isMain) {
+    throw new UsageError("--enable and --disable are for the main identity: xclaude set main --enable");
+  }
+  if (p.values.enable && p.values.disable) throw new UsageError("choose --enable or --disable");
+  const unset = p.values.unset ?? [];
+  for (const key of unset) {
+    if (!KEYS.includes(key)) throw new UsageError(`--unset takes model, effort or args, not "${key}"`);
+    if (p.values[key] !== void 0) throw new UsageError(`--${key} and --unset ${key} contradict each other`);
+  }
+  if (Object.keys(p.values).length) {
+    applyDefaultOptions(p, ctx.paths.home, target);
+    for (const key of unset) {
+      if (key === "args") target.args = [];
+      else if (key === "model") target.model = null;
+      else target.effort = null;
+    }
+    if (p.values.enable) config.main.enabled = true;
+    if (p.values.disable) config.main.enabled = false;
+    saveConfig(ctx.paths, config);
+  }
+  let head = name;
+  if (isMain) head += config.main.enabled ? " (enabled: the login in ~/.claude)" : " (disabled; enable with: xclaude set main --enable)";
+  ctx.io.out(`${head}
+${formatDefaults(target)}`);
+  return EXIT_OK;
+}
+
+// src/commands/shell.ts
+function install(ctx, config, args) {
+  const p = parseOptions(args, { bash: {}, zsh: {} }, "shell install");
+  if (p.positionals.length) throw new UsageError("usage: xclaude shell install [--bash] [--zsh]");
+  const targets = rcTargets(ctx.env, ctx.paths.home, process.platform, { bash: Boolean(p.values.bash), zsh: Boolean(p.values.zsh) });
+  if (!targets.length) throw new XError("neither ~/.zshrc nor ~/.bashrc exists; pick one with --zsh or --bash (it gets created)");
+  writeInitFiles(ctx.paths, config, VERSION);
+  for (const t of targets) {
+    const label = tildify(t.file, ctx.paths.home);
+    const previous = readFileOrNull(t.file);
+    const text = upsertBlock(previous ?? "", blockFor(initFile(ctx.paths, t.shell)), label);
+    const res = writeRc(t.file, text, previous);
+    if (res.status === "written") ctx.io.err(`xclaude: ${previous === null ? "created" : "updated"} ${label}
+`);
+    else if (res.status === "unchanged") ctx.io.err(`xclaude: ${label} is already set up
+`);
+    else {
+      ctx.io.err(`xclaude: ${label} isn't writable (read-only, or managed elsewhere); add this block to it by hand:
+`);
+      ctx.io.out(blockFor(initFile(ctx.paths, t.shell)));
+    }
+  }
+  ctx.io.err("Open a new shell (or run: exec $SHELL) to use it.\n");
+  return EXIT_OK;
+}
+function uninstall(ctx, args) {
+  const p = parseOptions(args, { bash: {}, zsh: {} }, "shell uninstall");
+  if (p.positionals.length) throw new UsageError("usage: xclaude shell uninstall [--bash] [--zsh]");
+  const only = p.values.bash || p.values.zsh ? { bash: Boolean(p.values.bash), zsh: Boolean(p.values.zsh) } : null;
+  const targets = knownRcFiles(ctx.env, ctx.paths.home).filter((t) => !only || only[t.shell]);
+  let count = 0;
+  for (const t of targets) {
+    const label = tildify(t.file, ctx.paths.home);
+    const previous = readFileOrNull(t.file);
+    if (previous === null) continue;
+    const { text, found } = removeBlock(previous, label);
+    if (!found) continue;
+    count++;
+    const res = writeRc(t.file, text, previous);
+    if (res.status === "manual") ctx.io.err(`xclaude: ${label} isn't writable; remove the xclaude block from it by hand
+`);
+    else ctx.io.err(`xclaude: removed the block from ${label}
+`);
+  }
+  if (!only) removeTree(ctx.paths.shell);
+  if (!count) ctx.io.err("xclaude: no shell block was installed\n");
+  return EXIT_OK;
+}
+function shellCommand(ctx, config, args) {
+  const [sub, ...rest] = args;
+  switch (sub) {
+    case "install":
+      return install(ctx, config, rest);
+    case "uninstall":
+      return uninstall(ctx, rest);
+    case "completion": {
+      if (rest.length !== 1 || rest[0] !== "bash" && rest[0] !== "zsh") throw new UsageError("usage: xclaude shell completion bash|zsh");
+      ctx.io.out(rest[0] === "bash" ? initBash(VERSION, false) : initZsh(VERSION, false));
+      return EXIT_OK;
+    }
+    default:
+      throw new UsageError("usage: xclaude shell install|uninstall [--bash] [--zsh], or xclaude shell completion bash|zsh");
+  }
+}
+
+// src/commands/tmux.ts
+import fs26 from "node:fs";
+import path18 from "node:path";
+
+// src/launch/args.ts
+function hasFlag(args, flag) {
+  for (const a of args) {
+    if (a === "--") return false;
+    if (a === flag || a.startsWith(`${flag}=`)) return true;
+  }
+  return false;
+}
+function splitAccountArgs(args, help) {
+  const out = [];
+  const bare = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--") {
+      out.push(...args.slice(i));
+      break;
+    }
+    const spec = a.startsWith("-") && a !== "-" && !a.includes("=") ? findOption(help, a) : void 0;
+    if (!spec) {
+      out.push(a);
+      continue;
+    }
+    const flag = longName(spec);
+    const next = args[i + 1];
+    switch (spec.value) {
+      case "none":
+        out.push(a);
+        break;
+      case "required":
+        if (next === void 0) out.push(a);
+        else {
+          out.push(`${flag}=${next}`);
+          i++;
+        }
+        break;
+      case "optional":
+        if (next === void 0 || next.startsWith("-")) bare.push({ flag, names: spec.names });
+        else {
+          out.push(`${flag}=${next}`);
+          i++;
+        }
+        break;
+      case "variadic": {
+        let n = 0;
+        while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          out.push(`${flag}=${args[++i]}`);
+          n++;
+        }
+        if (!n) out.push(a);
+        break;
+      }
+    }
+  }
+  return { args: out, bare };
+}
+function buildArgs(defaults, userArgs, help) {
+  if (isSubcommand(userArgs[0], help)) return [...userArgs];
+  const { args: out, bare } = defaults.args.length && help ? splitAccountArgs(defaults.args, help) : { args: [...defaults.args], bare: [] };
+  if (defaults.model && !hasFlag(userArgs, "--model")) out.push("--model", defaults.model);
+  if (defaults.effort && !hasFlag(userArgs, "--effort")) out.push("--effort", defaults.effort);
+  const user = [...userArgs];
+  const extra = bare.filter((b) => !b.names.some((n) => hasFlag(userArgs, n))).map((b) => b.flag);
+  const dashdash = user.indexOf("--");
+  if (dashdash >= 0) user.splice(dashdash, 0, ...extra);
+  else user.push(...extra);
+  return [...out, ...user];
+}
+function needsHelp(defaults, userArgs) {
+  const first = userArgs[0];
+  return defaults.args.length > 0 || first !== void 0 && !first.startsWith("-");
+}
+
+// src/launch/picker.ts
+import fs24 from "node:fs";
+import tty2 from "node:tty";
+function parseKeys(chunk) {
+  const keys = [];
+  let i = 0;
+  while (i < chunk.length) {
+    const rest = chunk.slice(i);
+    if (rest.startsWith("\x1B[A") || rest.startsWith("\x1BOA")) {
+      keys.push("up");
+      i += 3;
+    } else if (rest.startsWith("\x1B[B") || rest.startsWith("\x1BOB")) {
+      keys.push("down");
+      i += 3;
+    } else if (rest.startsWith("\x1B[")) {
+      let j = 2;
+      while (j < rest.length && !/[@-~]/.test(rest[j])) j++;
+      keys.push(null);
+      i += j + 1;
+    } else {
+      const c = rest[0];
+      if (c === "\x1B") keys.push(rest.length === 1 ? "cancel" : null);
+      else if (c === "") keys.push("cancel");
+      else if (c === "\r" || c === "\n") keys.push("enter");
+      else if (c === "k") keys.push("up");
+      else if (c === "j") keys.push("down");
+      else if (c >= "1" && c <= "9") keys.push({ jump: Number(c) - 1 });
+      else keys.push(null);
+      i++;
+    }
+  }
+  return keys;
+}
+function step(index, count, key) {
+  if (key === "up") return { index: (index - 1 + count) % count };
+  if (key === "down") return { index: (index + 1) % count };
+  if (key === "enter") return { index, done: "chosen" };
+  if (key === "cancel") return { index, done: "cancelled" };
+  if (key && typeof key === "object" && key.jump < count) return { index: key.jump };
+  return { index };
+}
+var dim = (s) => `\x1B[2m${s}\x1B[22m`;
+var bold = (s) => `\x1B[1m${s}\x1B[22m`;
+function fit(text, width) {
+  return width > 0 && text.length > width ? `${text.slice(0, Math.max(0, width - 1))}\u2026` : text;
+}
+function render(title, items, index, width = 0) {
+  const labelWidth = Math.max(...items.map((it) => it.label.length));
+  const lines = [bold(fit(title, width))];
+  items.forEach((it, i) => {
+    const marker = i === index ? "\u276F" : " ";
+    const num = i < 9 ? String(i + 1) : " ";
+    const label = it.label.padEnd(labelWidth);
+    const text = fit(`${marker} ${num}  ${label}${it.detail ? `  ${it.detail}` : ""}`, width);
+    const head = text.slice(0, 5 + labelWidth);
+    const tail = text.slice(5 + labelWidth);
+    lines.push(i === index ? `${bold(head)}${dim(tail)}` : `${head}${dim(tail)}`);
+  });
+  lines.push(dim(fit("\u2191/\u2193 or j/k to move \xB7 1\u20139 to jump \xB7 Enter to choose \xB7 Esc to cancel", width)));
+  return lines;
+}
+function preselect(names, state, cwd) {
+  for (const candidate of [state.lastAccountByDir[cwd], state.lastUsedAccount]) {
+    if (candidate && names.includes(candidate)) return names.indexOf(candidate);
+  }
+  return 0;
+}
+function openKeyboard() {
+  let fd;
+  try {
+    fd = fs24.openSync("/dev/tty", "r");
+  } catch {
+    throw new UsageError("account required: there's no terminal to show the picker on (xclaude <account> [claude args\u2026])");
+  }
+  const input = new tty2.ReadStream(fd);
+  let columns = 0;
+  try {
+    const size = [];
+    const handle = input._handle;
+    if (handle?.getWindowSize?.(size) === 0) columns = size[0] ?? 0;
+  } catch {
+  }
+  return {
+    input,
+    columns,
+    close: () => {
+      input.pause();
+      input.unref();
+    }
+  };
+}
+function pick(title, items, initial) {
+  const keyboard = openKeyboard();
+  const { input } = keyboard;
+  const write = (s) => fs24.writeSync(2, s);
+  let index = Math.min(Math.max(initial, 0), items.length - 1);
+  let drawn = 0;
+  const draw = () => {
+    const lines = render(title, items, index, keyboard.columns);
+    write(`${drawn ? `\r\x1B[${drawn}A` : ""}\x1B[J${lines.join("\n")}
+`);
+    drawn = lines.length;
+  };
+  return new Promise((resolve, reject) => {
+    const finish = (result) => {
+      input.off("data", onData);
+      try {
+        input.setRawMode(false);
+      } finally {
+        keyboard.close();
+        write(`\r\x1B[${drawn}A\x1B[J\x1B[?25h`);
+      }
+      if (result === "chosen") resolve(index);
+      else reject(new Cancelled());
+    };
+    const onData = (chunk) => {
+      for (const key of parseKeys(chunk)) {
+        const next = step(index, items.length, key);
+        index = next.index;
+        if (next.done) {
+          finish(next.done);
+          return;
+        }
+      }
+      draw();
+    };
+    input.setRawMode(true);
+    input.setEncoding("utf8");
+    input.on("data", onData);
+    input.resume();
+    write("\x1B[?25l");
+    draw();
+  });
+}
+
+// src/launch/launch.ts
+function identityItems(config) {
+  return identities(config).map((name) => {
+    const d = defaultsOf(config, name);
+    const detail = describeDefaults(d);
+    return { label: name, detail: name === MAIN ? ["~/.claude login", detail].filter(Boolean).join(" \xB7 ") : detail };
+  });
+}
+async function chooseAccount(ctx, config, title = "Launch Claude Code as") {
+  const names = identities(config);
+  if (!names.length) throw new XError("no accounts yet; add one with: xclaude add <name>");
+  if (!ctx.tty.stdin || !ctx.tty.stderr) throw new UsageError(`account required: xclaude <account> [claude args\u2026] (accounts: ${names.join(", ")})`);
+  const index = await pick(title, identityItems(config), preselect(names, loadState(ctx.paths), ctx.cwd));
+  return names[index];
+}
+function prepareAccount(ctx, config, account) {
+  const log = (line) => ctx.io.err(`${line}
+`);
+  try {
+    return repairForLaunch(ctx, config, account, log);
+  } catch (e) {
+    log(`xclaude: couldn't check ${account}'s links (${e.message}); launching anyway`);
+    return [];
+  }
+}
+function repairForLaunch(ctx, config, account, log) {
+  const table = shareTable(config, ctx.switches);
+  const res = repairAccount({
+    paths: ctx.paths,
+    account,
+    table,
+    lockWaitMs: LAUNCH_LOCK_WAIT_MS,
+    replaceWrongLinks: false,
+    log
+  });
+  if (res.busy) log("xclaude: links not checked this time: another xclaude is repairing; the next launch retries");
+  for (const p of res.problems) log(`xclaude: ${problemLine(account, p)}`);
+  if (ctx.switches.normalizePaths && table.dirs.includes("plugins")) {
+    normalizePaths(ctx.paths, { lockWaitMs: LAUNCH_LOCK_WAIT_MS, log });
+  }
+  return unknownEntries(res.names, table);
+}
+async function launch(ctx, config, account, userArgs) {
+  const defaults = defaultsOf(config, account);
+  if (!defaults) throw unknownAccount(account, config);
+  const isMain = account === MAIN;
+  const unknown = isMain ? [] : prepareAccount(ctx, config, account);
+  const claude = findClaude(ctx.env, config, ctx.paths.home, ctx.selfPath);
+  const help = needsHelp(defaults, userArgs) ? loadHelp(claude, ctx.paths.cache, ctx.env) : null;
+  const args = buildArgs(defaults, userArgs, help);
+  const env = buildEnv(ctx.env, { name: account, configDir: isMain ? null : accountDir(ctx.paths, account) });
+  try {
+    updateState(ctx.paths, (state) => {
+      recordUse(state, ctx.cwd, account);
+      const configLabel = tildify(ctx.paths.config, ctx.paths.home);
+      for (const entry of takeNewUnknown(state, account, unknown)) ctx.io.err(`${unknownNotice(account, entry, configLabel)}
+`);
+    });
+  } catch {
+  }
+  return ctx.exec(claude, [claude, ...args], env);
+}
+
+// src/tmux/claude-state.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import fs25 from "node:fs";
+function describeAgent(e) {
+  if (e.status === "waiting") return { text: e.waitingFor ? `needs input (${e.waitingFor})` : "needs input", rank: 3 };
+  if (e.status === "busy") return { text: "working", rank: 2 };
+  if (e.status === "idle") return { text: "idle", rank: 1 };
+  return null;
+}
+function parentLookup() {
+  if (process.platform === "linux" && fs25.existsSync("/proc/self/stat")) {
+    return (pid) => {
+      try {
+        const stat = fs25.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+        return Number.isFinite(ppid) ? ppid : null;
+      } catch {
+        return null;
+      }
+    };
+  }
+  const map = /* @__PURE__ */ new Map();
+  const res = spawnSync4("ps", ["-axo", "pid=,ppid="], { encoding: "utf8", timeout: 1e4 });
+  for (const line of (res.stdout ?? "").split("\n")) {
+    const [pid, ppid] = line.trim().split(/\s+/).map(Number);
+    if (pid && ppid !== void 0 && Number.isFinite(ppid)) map.set(pid, ppid);
+  }
+  return (pid) => map.get(pid) ?? null;
+}
+function sessionOfPid(pid, panes, parentOf) {
+  let current = pid;
+  for (let i = 0; current !== null && current > 1 && i < 64; i++) {
+    const session = panes.get(current);
+    if (session) return session;
+    current = parentOf(current);
+  }
+  return null;
+}
+function statesBySession(entries, panes, parentOf) {
+  const best = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (typeof e.pid !== "number") continue;
+    const state = describeAgent(e);
+    if (!state) continue;
+    const session = sessionOfPid(e.pid, panes, parentOf);
+    if (!session) continue;
+    const prev = best.get(session);
+    if (!prev || state.rank > prev.rank) best.set(session, state);
+  }
+  return new Map([...best].map(([k, v]) => [k, v.text]));
+}
+function panePids(tmux) {
+  const panes = /* @__PURE__ */ new Map();
+  const res = tmux.run(["list-panes", "-a", "-F", "#{session_id} #{pane_pid}"]);
+  for (const line of res.stdout.split("\n")) {
+    const [session, pid] = line.trim().split(" ");
+    if (session && pid) panes.set(Number(pid), session);
+  }
+  return panes;
+}
+async function agents(claude, env) {
+  const res = await runClaude(claude, ["agents", "--json"], env, 15e3);
+  try {
+    const parsed = JSON.parse(res.stdout);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+async function claudeStates(ctx, config, tmux, sessions) {
+  const names = identities(config);
+  if (!sessions.length || !names.length) return /* @__PURE__ */ new Map();
+  let claude;
+  try {
+    claude = findClaude(ctx.env, config, ctx.paths.home, ctx.selfPath);
+  } catch (e) {
+    if (e instanceof XError) return /* @__PURE__ */ new Map();
+    throw e;
+  }
+  const first = sessions.find((s) => s.account && names.includes(s.account))?.account ?? names[0];
+  const who = ctx.switches.agentsPerAccount ? names : [first];
+  const lists = await Promise.all(who.map((n) => agents(claude, identityEnv(ctx, n))));
+  const seen = /* @__PURE__ */ new Set();
+  const entries = lists.flat().filter((e) => typeof e.pid !== "number" || !seen.has(e.pid) && seen.add(e.pid));
+  return statesBySession(entries, panePids(tmux), parentLookup());
+}
+
+// src/commands/tmux.ts
+var NEW_USAGE = "usage: xclaude tmux new <label> [--dir <path>] [--detach] [--empty] [<account> [claude args\u2026]]";
+function parseNew(args) {
+  const [label, ...rest] = args;
+  if (!label || label.startsWith("-")) throw new UsageError(NEW_USAGE);
+  if (!LABEL.test(label)) {
+    throw new UsageError(`"${label}" isn't a valid label: letters, digits, _ and -, starting with a letter or digit, at most 64 characters`);
+  }
+  const req = { label, dir: null, detach: false, empty: false, account: null, claudeArgs: [] };
+  let i = 0;
+  for (; i < rest.length && rest[i].startsWith("--"); i++) {
+    const a = rest[i];
+    if (a === "--detach") req.detach = true;
+    else if (a === "--empty") req.empty = true;
+    else if (a === "--dir") {
+      const v = rest[++i];
+      if (v === void 0) throw new UsageError("tmux new: --dir needs a path");
+      req.dir = v;
+    } else if (a.startsWith("--dir=")) req.dir = a.slice("--dir=".length);
+    else throw new UsageError(`tmux new: unknown option ${a} (xclaude's options come right after the label, Claude Code's after the account)`);
+  }
+  req.account = rest[i] ?? null;
+  req.claudeArgs = rest.slice(i + 1);
+  if (req.empty && req.account) throw new UsageError("tmux new: --empty and an account don't go together");
+  return req;
+}
+function describeSession(s, home) {
+  return `${s.account ?? "empty"}, ${tildify(s.dir, home)}`;
+}
+async function attachTo(ctx, tmux, id) {
+  if (ctx.env.TMUX) {
+    tmux.must(["switch-client", "-t", id]);
+    return EXIT_OK;
+  }
+  return ctx.exec(tmux.bin, [tmux.bin, "attach-session", "-t", id], tmux.env);
+}
+function showAccount(tmux, id, account) {
+  const prefix = `[${account}] `;
+  const right = tmux.must(["show-options", "-gv", "status-right"]).replace(/\n$/, "");
+  const length = Number(tmux.must(["show-options", "-gv", "status-right-length"]).trim()) || 40;
+  tmux.must(["set-option", "-t", id, "status-right", `${prefix}${right}`]);
+  tmux.must(["set-option", "-t", id, "status-right-length", String(length + prefix.length)]);
+}
+async function tmuxNew(ctx, config, args) {
+  const req = parseNew(args);
+  const tmux = new Tmux(ctx.env);
+  tmux.requireVersion();
+  let account = req.account;
+  if (!req.empty) {
+    account ??= await chooseAccount(ctx, config, `Run Claude Code in tmux session "${req.label}" as`);
+    if (!defaultsOf(config, account)) throw unknownAccount(account, config);
+  }
+  const dir = path18.resolve(ctx.cwd, req.dir ?? ".");
+  if (!fs26.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new XError(`--dir ${req.dir}: not a directory`);
+  const existing = findByLabel(listSessions(tmux), req.label);
+  if (existing) {
+    throw new XError(`"${req.label}" is running (${describeSession(existing, ctx.paths.home)}): xclaude tmux attach ${req.label}, or kill it first`);
+  }
+  const name = sessionName(account, req.label);
+  if (tmux.hasSession(name)) throw new XError(`a tmux session named "${name}" exists but isn't xclaude's; rename or end it first`);
+  const id = tmux.must(["new-session", "-d", "-P", "-F", "#{session_id}", "-s", name, "-c", dir]).trim();
+  const options = [
+    ["@xclaude", "1"],
+    ["@xclaude_label", req.label],
+    ["@xclaude_account", account ?? ""],
+    ["@xclaude_dir", dir]
+  ];
+  for (const [key, value] of options) tmux.must(["set-option", "-t", id, key, value]);
+  if (account && config.tmux.statusRight) showAccount(tmux, id, account);
+  if (account) {
+    tmux.must(["send-keys", "-t", id, "-l", "--", quoteShellWords(["xclaude", account, ...req.claudeArgs])]);
+    tmux.must(["send-keys", "-t", id, "Enter"]);
+  }
+  if (req.detach) {
+    ctx.io.err(`xclaude: started tmux session "${req.label}"; attach with: xclaude tmux attach ${req.label}
+`);
+    return EXIT_OK;
+  }
+  return attachTo(ctx, tmux, id);
+}
+function noSessions() {
+  return new XError("no xclaude tmux sessions; start one with: xclaude tmux new <label> [<account>]");
+}
+function requireSession(sessions, label) {
+  const s = findByLabel(sessions, label);
+  if (s) return s;
+  const labels = sessions.map((x) => x.label);
+  throw new XError(`no xclaude tmux session "${label}"${labels.length ? ` (sessions: ${labels.join(", ")})` : ""}`);
+}
+async function tmuxAttach(ctx, args) {
+  if (args.length > 1) throw new UsageError("usage: xclaude tmux attach [<label>]");
+  const tmux = new Tmux(ctx.env);
+  const sessions = listSessions(tmux);
+  const [label] = args;
+  if (label !== void 0) return attachTo(ctx, tmux, requireSession(sessions, label).id);
+  if (!sessions.length) throw noSessions();
+  if (!ctx.tty.stdin || !ctx.tty.stderr) throw new UsageError(`label required: xclaude tmux attach <label> (sessions: ${sessions.map((s) => s.label).join(", ")})`);
+  const items = sessions.map((s) => ({
+    label: s.label,
+    detail: [s.account ?? "empty", tildify(s.dir, ctx.paths.home), s.attached ? "attached" : ""].filter(Boolean).join(" \xB7 ")
+  }));
+  const index = await pick("Attach to tmux session", items, 0);
+  return attachTo(ctx, tmux, sessions[index].id);
+}
+function formatCreated(unixSeconds, now = /* @__PURE__ */ new Date()) {
+  const d = new Date(unixSeconds * 1e3);
+  const pad = (n) => String(n).padStart(2, "0");
+  const time = `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  const sameDay = d.getFullYear() === now.getFullYear() && d.getMonth() === now.getMonth() && d.getDate() === now.getDate();
+  return sameDay ? time : `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${time}`;
+}
+async function tmuxLs(ctx, config, args) {
+  if (args.length) throw new UsageError("usage: xclaude tmux ls");
+  const tmux = new Tmux(ctx.env);
+  const sessions = listSessions(tmux);
+  if (!sessions.length) {
+    ctx.io.out("No xclaude tmux sessions. Start one with: xclaude tmux new <label> [<account>]\n");
+    return EXIT_OK;
+  }
+  const claude = await claudeStates(ctx, config, tmux, sessions);
+  const rows = sessions.map((s) => [
+    s.label,
+    s.account ?? DASH,
+    tildify(s.dir, ctx.paths.home),
+    s.attached ? "yes" : "no",
+    formatCreated(s.created),
+    claude.get(s.id) ?? DASH
+  ]);
+  ctx.io.out(formatTable(["LABEL", "ACCOUNT", "WORKDIR", "ATTACHED", "CREATED", "CLAUDE"], rows));
+  return EXIT_OK;
+}
+function tmuxKill(ctx, args) {
+  if (args.length !== 1) throw new UsageError("usage: xclaude tmux kill <label>");
+  const tmux = new Tmux(ctx.env);
+  const s = requireSession(listSessions(tmux), args[0]);
+  tmux.must(["kill-session", "-t", s.id]);
+  ctx.io.err(`xclaude: ended tmux session "${s.label}"
+`);
+  return EXIT_OK;
+}
+async function tmuxCommand(ctx, config, args) {
+  const [sub = "ls", ...rest] = args;
+  switch (sub) {
+    case "new":
+      return tmuxNew(ctx, config, rest);
+    case "attach":
+      return tmuxAttach(ctx, rest);
+    case "ls":
+      return tmuxLs(ctx, config, rest);
+    case "kill":
+      return tmuxKill(ctx, rest);
+    default:
+      throw new UsageError(`tmux: unknown subcommand "${sub}" (new, attach, ls, kill)`);
+  }
+}
+function accountSessionLabels(ctx, account) {
+  try {
+    return listSessions(new Tmux(ctx.env)).filter((s) => s.account === account).map((s) => s.label);
+  } catch {
+    return [];
+  }
+}
+
+// src/main.ts
+async function main(argv, ctx) {
+  const [first] = argv;
+  if (first === "-v" || first === "--version") {
+    ctx.io.out(`${VERSION}
+`);
+    return EXIT_OK;
+  }
+  if (first === "-h" || first === "--help") {
+    ctx.io.out(helpText());
+    return EXIT_OK;
+  }
+  if (first === "help") {
+    ctx.io.out(helpText(wantsHelp(argv.slice(1)) ? "help" : argv[1]));
+    return EXIT_OK;
+  }
+  const tmuxSub = first === "tmux" && ["new", "attach", "ls", "kill"].includes(argv[1] ?? "");
+  if (first !== void 0 && COMMANDS.includes(first) && (wantsHelp(argv.slice(1)) || tmuxSub && wantsHelp(argv.slice(2)))) {
+    ctx.io.out(helpText(first));
+    return EXIT_OK;
+  }
+  if (first === "__complete") return completeCommand(ctx, argv.slice(1));
+  if (first === "__names") return namesCommand(ctx);
+  if (first === "doctor") return doctorCommand(ctx, argv.slice(1));
+  const { config, created } = loadConfig(ctx.paths, { create: true });
+  if (created && first !== "add" && first !== "shell") {
+    const where = tildify(ctx.paths.xhome, ctx.paths.home);
+    ctx.io.err(
+      `xclaude: created ${where}. Next: \`xclaude add <name>\` to add an account, then \`xclaude shell install\` for completion.
+`
+    );
+  }
+  try {
+    if (loadState(ctx.paths).installedVersion !== VERSION) {
+      refreshInitFiles(ctx.paths, config, VERSION);
+      updateState(ctx.paths, (s) => {
+        s.installedVersion = VERSION;
+      });
+    }
+  } catch {
+  }
+  const action = classify(argv, config);
+  switch (action.kind) {
+    case "version":
+    case "help":
+      return EXIT_OK;
+    // handled above
+    case "command":
+      switch (action.name) {
+        case "add":
+          return addCommand(ctx, config, action.args);
+        case "set":
+          return setCommand(ctx, config, action.args);
+        case "ls":
+          return lsCommand(ctx, config, action.args);
+        case "rm":
+          return rmCommand(ctx, config, action.args, (account) => accountSessionLabels(ctx, account));
+        case "tmux":
+          return tmuxCommand(ctx, config, action.args);
+        case "shell":
+          return shellCommand(ctx, config, action.args);
+        case "guard":
+          return guardCommand(ctx, config, action.args);
+        default:
+          throw new XError(`${action.name}: unexpected here`);
+      }
+    case "hidden":
+      return EXIT_OK;
+    // handled above
+    case "launch":
+      return launch(ctx, config, action.account ?? await chooseAccount(ctx, config), action.args);
+  }
+}
+
+// src/cli.ts
+main(process.argv.slice(2), processCtx(stdio)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (e) => {
+    if (e instanceof Cancelled) {
+      process.exitCode = e.exitCode;
+    } else if (e instanceof XError) {
+      stdio.err(`xclaude: ${e.message}
+`);
+      process.exitCode = e.exitCode;
+    } else {
+      stdio.err(`xclaude: unexpected error: ${e instanceof Error ? e.stack ?? e.message : String(e)}
+`);
+      process.exitCode = EXIT_ERROR;
+    }
+  }
+);