@livx.cc/agentx 0.94.38 → 0.95.1

package/dist/cli.js

@@ -1420,6 +1420,172 @@ var init_JailedFilesystem = __esm({
   }
 });
 
+// src/worktree.ts
+var worktree_exports = {};
+__export(worktree_exports, {
+  cleanupWorktree: () => cleanupWorktree,
+  enterWorktree: () => enterWorktree,
+  exitWorktree: () => exitWorktree,
+  findGitRoot: () => findGitRoot,
+  getOrCreateWorktree: () => getOrCreateWorktree,
+  getWorktreeSession: () => getWorktreeSession,
+  validateWorktreeSlug: () => validateWorktreeSlug,
+  worktreeBranchName: () => worktreeBranchName
+});
+import { spawnSync } from "child_process";
+import { symlinkSync, mkdirSync, statSync as statSync2, readFileSync, rmSync } from "fs";
+import { join as join3 } from "path";
+function validateWorktreeSlug(slug2) {
+  if (!slug2) throw new Error("worktree slug must not be empty");
+  if (slug2.length > MAX_SLUG_LENGTH) throw new Error(`worktree slug must be \u2264${MAX_SLUG_LENGTH} chars (got ${slug2.length})`);
+  for (const seg of slug2.split("/")) {
+    if (seg === "." || seg === "..") throw new Error(`worktree slug must not contain "." or ".." segments`);
+    if (!VALID_SEGMENT.test(seg)) throw new Error(`worktree slug segment "${seg}" contains invalid characters (allowed: a-z A-Z 0-9 . _ -)`);
+  }
+}
+function flattenSlug(slug2) {
+  return slug2.replaceAll("/", "+");
+}
+function worktreeBranchName(slug2) {
+  return `worktree-${flattenSlug(slug2)}`;
+}
+function worktreesDir(repoRoot) {
+  return join3(repoRoot, ".claude", "worktrees");
+}
+function worktreePathFor(repoRoot, slug2) {
+  return join3(worktreesDir(repoRoot), flattenSlug(slug2));
+}
+function git(args, cwd) {
+  const r = spawnSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...GIT_NO_PROMPT_ENV }
+  });
+  return { ok: r.status === 0, stdout: (r.stdout ?? "").toString().trim(), stderr: (r.stderr ?? "").toString().trim() };
+}
+function findGitRoot(from) {
+  const r = git(["rev-parse", "--show-toplevel"], from);
+  return r.ok ? r.stdout : null;
+}
+function readWorktreeHead(worktreePath) {
+  try {
+    const gitFile = readFileSync(join3(worktreePath, ".git"), "utf-8").trim();
+    const m = gitFile.match(/^gitdir:\s*(.+)$/);
+    if (!m) return null;
+    const headPath = join3(m[1], "HEAD");
+    const head = readFileSync(headPath, "utf-8").trim();
+    const refMatch = head.match(/^ref:\s*(.+)$/);
+    if (!refMatch) return head.length === 40 ? head : null;
+    const refPath = join3(m[1], "..", refMatch[1]);
+    try {
+      return readFileSync(refPath, "utf-8").trim();
+    } catch {
+    }
+    const r = git(["rev-parse", "HEAD"], worktreePath);
+    return r.ok ? r.stdout : null;
+  } catch {
+    return null;
+  }
+}
+function getOrCreateWorktree(repoRoot, slug2) {
+  validateWorktreeSlug(slug2);
+  const worktreePath = worktreePathFor(repoRoot, slug2);
+  const branch = worktreeBranchName(slug2);
+  const existingHead = readWorktreeHead(worktreePath);
+  if (existingHead) return { worktreePath, branch, headCommit: existingHead, existed: true };
+  mkdirSync(worktreesDir(repoRoot), { recursive: true });
+  const defaultBranch = git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], repoRoot);
+  let baseBranch = defaultBranch.ok ? defaultBranch.stdout.replace(/^origin\//, "") : "HEAD";
+  const originRef = `origin/${baseBranch}`;
+  const hasOrigin = git(["rev-parse", "--verify", originRef], repoRoot);
+  if (!hasOrigin.ok) {
+    const fetched = git(["fetch", "origin", baseBranch], repoRoot);
+    if (!fetched.ok) baseBranch = "HEAD";
+  }
+  const base = baseBranch === "HEAD" ? "HEAD" : originRef;
+  const r = git(["worktree", "add", "-B", branch, worktreePath, base], repoRoot);
+  if (!r.ok) throw new Error(`failed to create worktree: ${r.stderr}`);
+  const headSha = git(["rev-parse", "HEAD"], worktreePath);
+  symlinkDirs(repoRoot, worktreePath, ["node_modules", ".bun"]);
+  return { worktreePath, branch, headCommit: headSha.stdout, existed: false, baseBranch };
+}
+function symlinkDirs(repoRoot, worktreePath, dirs) {
+  for (const dir of dirs) {
+    const src = join3(repoRoot, dir);
+    const dst = join3(worktreePath, dir);
+    try {
+      statSync2(src);
+    } catch {
+      continue;
+    }
+    try {
+      symlinkSync(src, dst, "dir");
+    } catch (e) {
+      if (e?.code !== "EEXIST") console.error(`[worktree] symlink ${dir}: ${e?.message ?? e}`);
+    }
+  }
+}
+function cleanupWorktree(repoRoot, slug2, opts) {
+  validateWorktreeSlug(slug2);
+  const worktreePath = worktreePathFor(repoRoot, slug2);
+  const branch = worktreeBranchName(slug2);
+  try {
+    statSync2(worktreePath);
+  } catch {
+    return { removed: false, reason: "not found" };
+  }
+  if (!opts?.force) {
+    const status = git(["status", "--porcelain", "-uno"], worktreePath);
+    if (status.ok && status.stdout) return { removed: false, reason: "uncommitted changes" };
+  }
+  for (const dir of ["node_modules", ".bun"]) {
+    try {
+      rmSync(join3(worktreePath, dir));
+    } catch {
+    }
+  }
+  const rm = git(["worktree", "remove", "--force", worktreePath], repoRoot);
+  if (!rm.ok) return { removed: false, reason: rm.stderr };
+  git(["branch", "-D", branch], repoRoot);
+  return { removed: true };
+}
+function getWorktreeSession() {
+  return _session;
+}
+function enterWorktree(slug2, cwd) {
+  const repoRoot = findGitRoot(cwd);
+  if (!repoRoot) throw new Error("--worktree requires a git repository");
+  const info = getOrCreateWorktree(repoRoot, slug2);
+  process.chdir(info.worktreePath);
+  _session = {
+    originalCwd: cwd,
+    worktreePath: info.worktreePath,
+    slug: slug2,
+    branch: info.branch,
+    headCommit: info.headCommit
+  };
+  return _session;
+}
+function exitWorktree() {
+  if (!_session) return null;
+  const repoRoot = findGitRoot(_session.originalCwd);
+  if (!repoRoot) return null;
+  process.chdir(_session.originalCwd);
+  const result = cleanupWorktree(repoRoot, _session.slug);
+  _session = null;
+  return result;
+}
+var VALID_SEGMENT, MAX_SLUG_LENGTH, GIT_NO_PROMPT_ENV, _session;
+var init_worktree = __esm({
+  "src/worktree.ts"() {
+    "use strict";
+    VALID_SEGMENT = /^[a-zA-Z0-9._-]+$/;
+    MAX_SLUG_LENGTH = 64;
+    GIT_NO_PROMPT_ENV = { GIT_TERMINAL_PROMPT: "0", GIT_ASKPASS: "" };
+    _session = null;
+  }
+});
+
 // src/shell.sandbox.ts
 function writable(cwd, o, tmpDir) {
   const set = /* @__PURE__ */ new Set([cwd, "/tmp", "/private/tmp", "/private/var/folders", "/dev", ...tmpDir ? [tmpDir] : [], ...o.writePaths]);
@@ -1741,7 +1907,7 @@ var init_tools_shell = __esm({
 
 // cli/cli.ts
 import { createInterface } from "readline/promises";
-import { existsSync as existsSync10, readFileSync as readFileSync6, appendFileSync, mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, readdirSync as readdirSync4, statSync as statSync3, unlinkSync as unlinkSync5 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7, appendFileSync, mkdirSync as mkdirSync10, writeFileSync as writeFileSync8, readdirSync as readdirSync4, statSync as statSync4, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir9, tmpdir as tmpdir3 } from "os";
 
 // cli/clipboard.ts
@@ -1809,7 +1975,7 @@ function copyTextToClipboard(text, platform2 = process.platform) {
 }
 
 // cli/cli.ts
-import { join as join12, resolve as resolve3, basename as basename2, extname, dirname as dirname4 } from "path";
+import { join as join13, resolve as resolve3, basename as basename2, extname, dirname as dirname4 } from "path";
 import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions } from "ai.libx.js";
 
 // src/llm.ts
@@ -5736,6 +5902,7 @@ function base64ToBytes(b64) {
 }
 
 // src/index.ts
+init_worktree();
 import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor as CommandExecutor2, registerHeadlessCommands as registerHeadlessCommands2 } from "@livx.cc/wcli/core";
 
 // src/mcp.client.ts
@@ -6064,7 +6231,7 @@ var defaultPool = new McpPool();
 // cli/mcpOAuth.ts
 import { createServer } from "http";
 import { randomBytes, createHash as createHash2 } from "crypto";
-import { readFileSync, writeFileSync as writeFileSync2, mkdirSync, existsSync } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync } from "fs";
 import { dirname as dirname2 } from "path";
 var McpOAuthOptions = class {
   /** Where to persist tokens. Mode 0600. */
@@ -6092,13 +6259,13 @@ var McpOAuth = class {
   // -- store I/O ----------------------------------------------------------------
   load() {
     try {
-      return existsSync(this.options.storePath) ? JSON.parse(readFileSync(this.options.storePath, "utf8")) : {};
+      return existsSync(this.options.storePath) ? JSON.parse(readFileSync2(this.options.storePath, "utf8")) : {};
     } catch {
       return {};
     }
   }
   save(store) {
-    mkdirSync(dirname2(this.options.storePath), { recursive: true });
+    mkdirSync2(dirname2(this.options.storePath), { recursive: true });
     writeFileSync2(this.options.storePath, JSON.stringify(store, null, 2), { mode: 384 });
   }
   // -- ATTENDED: one-time authorization ----------------------------------------
@@ -6257,8 +6424,8 @@ function defaultOpenBrowser(url) {
 // cli/core.ts
 import { randomUUID } from "crypto";
 import { execFile as execFile2 } from "child_process";
-import { resolve, basename, join as join3 } from "path";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { resolve, basename, join as join4 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
 import { platform, arch, release, userInfo, homedir as homedir2, tmpdir } from "os";
 init_tools_shell();
 
@@ -6303,7 +6470,7 @@ import { BodDB as BodDB2 } from "@bod.ee/db";
 
 // cli/util.ts
 init_logging();
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { homedir } from "os";
 var log14 = forComponent("cli-util");
 function dotDirs(base, sub, opts = {}) {
@@ -6330,7 +6497,7 @@ function readJsonFile(path, fallback) {
   if (!existsSync2(path)) return fallback;
   let text;
   try {
-    text = readFileSync2(path, "utf8");
+    text = readFileSync3(path, "utf8");
   } catch (e) {
     log14.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
     return fallback;
@@ -6416,8 +6583,8 @@ async function buildAgent(o) {
     fs = mem;
   } else if (o.boddb) {
     const root = resolve(o.boddb);
-    mkdirSync2(root, { recursive: true });
-    const db = new BodDB2({ path: join3(root, "meta.db"), sweepInterval: 0, vfs: { storageRoot: join3(root, "files") } });
+    mkdirSync3(root, { recursive: true });
+    const db = new BodDB2({ path: join4(root, "meta.db"), sweepInterval: 0, vfs: { storageRoot: join4(root, "files") } });
     const bod = new BodDbFilesystem(db);
     const firstRun = (await bod.readDir("/").catch(() => [])).length === 0;
     await mkdirp(bod, cwd);
@@ -6576,10 +6743,10 @@ var trunc = (s, n) => (s == null ? "" : String(s).length > n ? String(s).slice(0
 
 // cli/voice.ts
 init_logging();
-import { spawn as spawn2, spawnSync } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, statSync as statSync2 } from "fs";
+import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 import { fileURLToPath } from "url";
 var log15 = forComponent("VoiceIO");
 var now4 = () => performance.now();
@@ -6622,10 +6789,10 @@ var Player = class {
     this.proc = null;
   }
 };
-var nativeDir = () => join4(dirname3(fileURLToPath(import.meta.url)), "native");
+var nativeDir = () => join5(dirname3(fileURLToPath(import.meta.url)), "native");
 function detectFfmpegMic() {
   if (process.env.MIC_DEVICE) return process.env.MIC_DEVICE;
-  const out = spawnSync("ffmpeg", ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { encoding: "utf8" }).stderr;
+  const out = spawnSync2("ffmpeg", ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { encoding: "utf8" }).stderr;
   const audio = out.slice(out.indexOf("audio devices"));
   const devices = [...audio.matchAll(/\[(\d+)\] (.+)/g)].map(([, idx, name]) => ({ idx, name: name.trim() }));
   const mic = devices.find((d) => /microphone|built-in/i.test(d.name) && !/teams|blackhole|loopback/i.test(d.name)) ?? devices[0];
@@ -6636,10 +6803,10 @@ function detectFfmpegMic() {
 function detectedInputDevice() {
   if (process.platform !== "darwin") return null;
   let name = "";
-  if (spawnSync("which", ["SwitchAudioSource"]).status === 0) {
-    name = (spawnSync("SwitchAudioSource", ["-c", "-t", "input"], { encoding: "utf8" }).stdout || "").trim();
+  if (spawnSync2("which", ["SwitchAudioSource"]).status === 0) {
+    name = (spawnSync2("SwitchAudioSource", ["-c", "-t", "input"], { encoding: "utf8" }).stdout || "").trim();
   } else {
-    const out = spawnSync("system_profiler", ["SPAudioDataType"], { encoding: "utf8" }).stdout || "";
+    const out = spawnSync2("system_profiler", ["SPAudioDataType"], { encoding: "utf8" }).stdout || "";
     let last = "";
     for (const ln of out.split("\n")) {
       const hdr = ln.match(/^\s{6,}(\S.*?):\s*$/);
@@ -6658,21 +6825,21 @@ function detectedInputDevice() {
 }
 function resolveAecBinary() {
   if (process.env.MIC_AEC === "0" || process.platform !== "darwin") return null;
-  const src = join4(nativeDir(), "mic-aec.swift");
-  const plist = join4(nativeDir(), "Info.plist");
+  const src = join5(nativeDir(), "mic-aec.swift");
+  const plist = join5(nativeDir(), "Info.plist");
   if (!existsSync4(src)) return null;
-  const cacheDir = join4(homedir3(), ".agent", "cache");
-  const bin = join4(cacheDir, "mic-aec");
-  if (existsSync4(bin) && statSync2(bin).mtimeMs >= statSync2(src).mtimeMs) return bin;
-  if (spawnSync("which", ["swiftc"]).status !== 0) return null;
-  mkdirSync3(cacheDir, { recursive: true });
+  const cacheDir = join5(homedir3(), ".agent", "cache");
+  const bin = join5(cacheDir, "mic-aec");
+  if (existsSync4(bin) && statSync3(bin).mtimeMs >= statSync3(src).mtimeMs) return bin;
+  if (spawnSync2("which", ["swiftc"]).status !== 0) return null;
+  mkdirSync4(cacheDir, { recursive: true });
   log15.info("compiling AEC mic helper (first run)\u2026");
-  const build = spawnSync("swiftc", ["-O", "-o", bin, src, "-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist", "-Xlinker", plist], { encoding: "utf8" });
+  const build = spawnSync2("swiftc", ["-O", "-o", bin, src, "-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist", "-Xlinker", plist], { encoding: "utf8" });
   if (build.status !== 0) {
     log15.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
     return null;
   }
-  const sign = spawnSync("codesign", ["-fs", "-", bin], { encoding: "utf8" });
+  const sign = spawnSync2("codesign", ["-fs", "-", bin], { encoding: "utf8" });
   if (sign.status !== 0) {
     log15.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
     return null;
@@ -6692,7 +6859,7 @@ var NodeMicSource = class {
     if (this.bin) {
       this.proc = spawn2(this.bin, [], { stdio: ["ignore", "pipe", "ignore"] });
     } else {
-      if (spawnSync("which", ["ffmpeg"]).status !== 0) throw new Error("voice I/O unavailable: no AEC helper and no ffmpeg on PATH");
+      if (spawnSync2("which", ["ffmpeg"]).status !== 0) throw new Error("voice I/O unavailable: no AEC helper and no ffmpeg on PATH");
       log15.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
       this.proc = spawn2(
         "ffmpeg",
@@ -6861,13 +7028,13 @@ var VoiceIO = class extends VoiceEngine {
 
 // cli/config.ts
 import { homedir as homedir4 } from "os";
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
 import { pathToFileURL } from "url";
 var FILES = ["config.ts", "config.js", "config.mjs", "config.json"];
 async function loadFrom(dir) {
   for (const f of FILES) {
-    const p = join5(dir, ".agent", f);
+    const p = join6(dir, ".agent", f);
     if (!existsSync5(p)) continue;
     try {
       const mod = await import(pathToFileURL(p).href, f.endsWith(".json") ? { with: { type: "json" } } : void 0);
@@ -6880,10 +7047,10 @@ async function loadFrom(dir) {
   return {};
 }
 function loadSettings(dir) {
-  const p = join5(dir, ".agent", "settings.json");
+  const p = join6(dir, ".agent", "settings.json");
   if (!existsSync5(p)) return {};
   try {
-    const raw = JSON.parse(readFileSync3(p, "utf8"));
+    const raw = JSON.parse(readFileSync4(p, "utf8"));
     const cfg = {};
     if (raw.mcpServers && typeof raw.mcpServers === "object") cfg.mcpServers = raw.mcpServers;
     if (raw.permissions && typeof raw.permissions === "object") cfg.permissions = raw.permissions;
@@ -6916,7 +7083,7 @@ async function loadConfig(cwd) {
 }
 
 // cli/hooks-config.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 var log16 = forComponent("hooks");
 var escapeRegex = (s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
 function ruleMatches(rule, toolName) {
@@ -6926,7 +7093,7 @@ function ruleMatches(rule, toolName) {
 }
 function runCmd(rule, env) {
   try {
-    const r = spawnSync2(rule.command, {
+    const r = spawnSync3(rule.command, {
       shell: true,
       encoding: "utf8",
       timeout: rule.timeoutMs ?? 1e4,
@@ -7038,15 +7205,15 @@ function formatDiff(ops, opts = {}) {
 }
 
 // cli/session.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3, readdirSync, renameSync, symlinkSync, unlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, readdirSync, renameSync, symlinkSync as symlinkSync2, unlinkSync, readlinkSync } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var log17 = forComponent("session");
-var globalDir = () => join6(homedir5(), ".agent", "sessions");
+var globalDir = () => join7(homedir5(), ".agent", "sessions");
 var SessionStore = class {
   dir;
   constructor(cwd) {
-    this.dir = join6(cwd, ".agent", "sessions");
+    this.dir = join7(cwd, ".agent", "sessions");
   }
   /** Sortable, human-readable id: `YYYYMMDD-HHMMSS-<folder>`. */
   newId(now5 = Date.now(), cwd) {
@@ -7054,10 +7221,10 @@ var SessionStore = class {
     const p = (n, w = 2) => String(n).padStart(w, "0");
     const slug2 = (cwd ?? process.cwd()).split("/").pop()?.replace(/[^A-Za-z0-9_-]/g, "") || "session";
     let id = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${slug2}`;
-    if (existsSync6(this.dir) && existsSync6(join6(this.dir, `${id}.json`))) {
+    if (existsSync6(this.dir) && existsSync6(join7(this.dir, `${id}.json`))) {
       for (let i = 2; i <= 99; i++) {
         const c = `${id}-${i}`;
-        if (!existsSync6(join6(this.dir, `${c}.json`))) {
+        if (!existsSync6(join7(this.dir, `${c}.json`))) {
           id = c;
           break;
         }
@@ -7071,16 +7238,16 @@ var SessionStore = class {
   }
   save(data) {
     if (!this.safeId(data.meta.id)) throw new Error(`unsafe session id: ${data.meta.id}`);
-    if (!existsSync6(this.dir)) mkdirSync4(this.dir, { recursive: true });
-    const path = join6(this.dir, `${data.meta.id}.json`);
+    if (!existsSync6(this.dir)) mkdirSync5(this.dir, { recursive: true });
+    const path = join7(this.dir, `${data.meta.id}.json`);
     const tmp = `${path}.${process.pid}.tmp`;
     writeFileSync3(tmp, JSON.stringify(data));
     renameSync(tmp, path);
     try {
       const gd = globalDir();
-      if (!existsSync6(gd)) mkdirSync4(gd, { recursive: true });
-      const link2 = join6(gd, `${data.meta.id}.json`);
-      if (!existsSync6(link2)) symlinkSync(path, link2);
+      if (!existsSync6(gd)) mkdirSync5(gd, { recursive: true });
+      const link2 = join7(gd, `${data.meta.id}.json`);
+      if (!existsSync6(link2)) symlinkSync2(path, link2);
     } catch {
     }
   }
@@ -7089,10 +7256,10 @@ var SessionStore = class {
       log17.debug(`rejecting unsafe session id: ${id}`);
       return void 0;
     }
-    const path = join6(this.dir, `${id}.json`);
+    const path = join7(this.dir, `${id}.json`);
     if (!existsSync6(path)) return void 0;
     try {
-      return JSON.parse(readFileSync4(path, "utf8"));
+      return JSON.parse(readFileSync5(path, "utf8"));
     } catch (e) {
       log17.debug(`unreadable session ${id} \u2014 ignoring`, e);
       return void 0;
@@ -7105,7 +7272,7 @@ var SessionStore = class {
     for (const f of readdirSync(this.dir)) {
       if (!f.endsWith(".json")) continue;
       try {
-        metas.push(JSON.parse(readFileSync4(join6(this.dir, f), "utf8")).meta);
+        metas.push(JSON.parse(readFileSync5(join7(this.dir, f), "utf8")).meta);
       } catch (e) {
         log17.debug(`skipping unreadable session file ${f}`, e);
       }
@@ -7124,11 +7291,11 @@ var SessionStore = class {
 function globalSessionLoad(idOrPrefix) {
   const gd = globalDir();
   if (!existsSync6(gd)) return void 0;
-  const exact = join6(gd, `${idOrPrefix}.json`);
+  const exact = join7(gd, `${idOrPrefix}.json`);
   if (existsSync6(exact)) {
     try {
       const target = readlinkSync(exact);
-      return JSON.parse(readFileSync4(target, "utf8"));
+      return JSON.parse(readFileSync5(target, "utf8"));
     } catch {
       return void 0;
     }
@@ -7138,8 +7305,8 @@ function globalSessionLoad(idOrPrefix) {
       if (!f.endsWith(".json")) continue;
       const base = f.slice(0, -5);
       if (base.includes(idOrPrefix) || base.endsWith(idOrPrefix)) {
-        const target = readlinkSync(join6(gd, f));
-        return JSON.parse(readFileSync4(target, "utf8"));
+        const target = readlinkSync(join7(gd, f));
+        return JSON.parse(readFileSync5(target, "utf8"));
       }
     }
   } catch {
@@ -7153,15 +7320,15 @@ function globalSessionList() {
   for (const f of readdirSync(gd)) {
     if (!f.endsWith(".json")) continue;
     try {
-      const target = readlinkSync(join6(gd, f));
+      const target = readlinkSync(join7(gd, f));
       if (!existsSync6(target)) {
         try {
-          unlinkSync(join6(gd, f));
+          unlinkSync(join7(gd, f));
         } catch {
         }
         continue;
       }
-      metas.push(JSON.parse(readFileSync4(target, "utf8")).meta);
+      metas.push(JSON.parse(readFileSync5(target, "utf8")).meta);
     } catch {
     }
   }
@@ -7273,18 +7440,18 @@ ${formatDiff(ops)}`);
 // cli/gitCheckpoints.ts
 import { execFile as execFile3 } from "child_process";
 import { promisify } from "util";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync7 } from "fs";
-import { join as join7, resolve as resolve2, sep as sep2 } from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, existsSync as existsSync7 } from "fs";
+import { join as join8, resolve as resolve2, sep as sep2 } from "path";
 var log18 = forComponent("checkpoints");
 var exec = promisify(execFile3);
 var DEFAULT_EXCLUDE = [".agent/", ".git/", "node_modules/", "dist/", "build/", ".next/", "target/", ".venv/", "__pycache__/", "*.log"];
 var ShadowRepo = class {
   // undefined = unprobed; false = git/this root unusable
-  constructor(workTree, gitDir, exclude, git) {
+  constructor(workTree, gitDir, exclude, git2) {
     this.workTree = workTree;
     this.gitDir = gitDir;
     this.exclude = exclude;
-    this.git = git;
+    this.git = git2;
   }
   workTree;
   gitDir;
@@ -7307,10 +7474,10 @@ var ShadowRepo = class {
     try {
       await exec(this.git, ["--version"]);
       if (!existsSync7(this.gitDir)) {
-        mkdirSync5(this.gitDir, { recursive: true });
+        mkdirSync6(this.gitDir, { recursive: true });
         await this.run("init", "-q");
       }
-      writeFileSync4(join7(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
+      writeFileSync4(join8(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
       this.ready = true;
     } catch (e) {
       log18.debug(`git checkpoints unavailable for ${this.workTree}`, e);
@@ -7425,7 +7592,7 @@ var GitCheckpoints = class {
       const abs = resolve2(d);
       if (abs === cwd || abs.startsWith(cwd + sep2)) continue;
       if (cwd.startsWith(abs + sep2)) continue;
-      out.push({ workTree: abs, gitDir: join7(abs, ".agent", "checkpoints.git") });
+      out.push({ workTree: abs, gitDir: join8(abs, ".agent", "checkpoints.git") });
     }
     return out;
   }
@@ -7546,7 +7713,7 @@ var GitCheckpointsOptions = class {
   /** Real working tree to snapshot (the launch cwd). */
   workTree = process.cwd();
   /** Isolated git dir for the cwd shadow repo (kept out of the user's real .git). */
-  gitDir = join7(process.cwd(), ".agent", "checkpoints.git");
+  gitDir = join8(process.cwd(), ".agent", "checkpoints.git");
   /** Extra mounted dirs (`--add-dir`); those outside cwd each get their own shadow repo. */
   addDirs = [];
   /** Conversation id → per-session restore-point ref. */
@@ -7560,9 +7727,9 @@ var GitCheckpointsOptions = class {
 };
 
 // cli/permissions.ts
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var RULE_RE = /^(\w+)(?:\((.+)\))?$/;
 function parseOne(raw, decision) {
   const m = RULE_RE.exec(raw.trim());
@@ -7584,13 +7751,13 @@ function parsePermRules(perms) {
 function describeRule(r) {
   return `${r.decision.padEnd(5)} ${r.tool ?? "*"}${r.pathGlob ? `(${r.pathGlob})` : ""}`;
 }
-var PERM_FILE = (cwd) => join8(cwd, ".agent", "permissions.json");
+var PERM_FILE = (cwd) => join9(cwd, ".agent", "permissions.json");
 function loadPersistedRules(cwd) {
   const j = readJsonFile(PERM_FILE(cwd), null);
   return j ? { allow: j.allow ?? [], ask: j.ask ?? [], deny: j.deny ?? [] } : {};
 }
 function loadClaudeSettings(cwd, home = homedir6()) {
-  const files = [join8(home, ".claude", "settings.json"), join8(cwd, ".claude", "settings.json"), join8(cwd, ".claude", "settings.local.json")];
+  const files = [join9(home, ".claude", "settings.json"), join9(cwd, ".claude", "settings.json"), join9(cwd, ".claude", "settings.local.json")];
   let out = {};
   for (const p of files) {
     const perms = readJsonFile(p, null)?.permissions;
@@ -7603,7 +7770,7 @@ function persistRule(cwd, decision, ruleStr) {
   const list = cur[decision] ??= [];
   if (!list.includes(ruleStr)) list.push(ruleStr);
   try {
-    mkdirSync6(join8(cwd, ".agent"), { recursive: true });
+    mkdirSync7(join9(cwd, ".agent"), { recursive: true });
     writeFileSync5(PERM_FILE(cwd), JSON.stringify(cur, null, 2) + "\n");
   } catch {
   }
@@ -7617,7 +7784,7 @@ function mergePerms(a, b) {
   }
   return Object.keys(out).length ? out : void 0;
 }
-var TRUST_FILE = join8(homedir6(), ".agent", "trusted.json");
+var TRUST_FILE = join9(homedir6(), ".agent", "trusted.json");
 function isTrusted(cwd, file = TRUST_FILE) {
   const list = readJsonFile(file, []);
   return Array.isArray(list) && list.includes(cwd);
@@ -7627,7 +7794,7 @@ function trustDir(cwd, file = TRUST_FILE) {
   if (!Array.isArray(list)) list = [];
   if (!list.includes(cwd)) list.push(cwd);
   try {
-    mkdirSync6(join8(file, ".."), { recursive: true });
+    mkdirSync7(join9(file, ".."), { recursive: true });
     writeFileSync5(file, JSON.stringify(list, null, 2) + "\n");
   } catch {
   }
@@ -7687,10 +7854,10 @@ function completePath(listDir, ref) {
 
 // cli/lineEditor.ts
 import { emitKeypressEvents } from "readline";
-import { spawnSync as spawnSync3 } from "child_process";
-import { writeFileSync as writeFileSync6, readFileSync as readFileSync5, unlinkSync as unlinkSync2 } from "fs";
+import { spawnSync as spawnSync4 } from "child_process";
+import { writeFileSync as writeFileSync6, readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // cli/bidi.ts
 var RTL_RE = /[\u0590-\u05ff\u0600-\u06ff\u0750-\u077f\u08a0-\u08ff\ufb1d-\ufdff\ufe70-\ufeff]/;
@@ -8767,14 +8934,14 @@ function createLineEditor(out) {
   function externalEdit(s) {
     const spec = process.env.VISUAL || process.env.EDITOR || "vi";
     const [cmd, ...cargs] = spec.split(" ").filter(Boolean);
-    const file = join9(tmpdir2(), `agentx-edit-${process.pid}-${Date.now()}.md`);
+    const file = join10(tmpdir2(), `agentx-edit-${process.pid}-${Date.now()}.md`);
     try {
       writeFileSync6(file, s.buf);
       process.stdin.setRawMode(false);
       out.write("\x1B[?2004l");
-      const r = spawnSync3(cmd, [...cargs, file], { stdio: "inherit" });
+      const r = spawnSync4(cmd, [...cargs, file], { stdio: "inherit" });
       if (r.status === 0) {
-        const text = readFileSync5(file, "utf8").replace(/\n$/, "");
+        const text = readFileSync6(file, "utf8").replace(/\n$/, "");
         s.reset();
         if (text) s.insert(text);
       }
@@ -9196,10 +9363,10 @@ function readPlainLine() {
 }
 
 // cli/osScheduler.ts
-import { spawnSync as spawnSync4 } from "child_process";
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync2, unlinkSync as unlinkSync3, chmodSync, existsSync as existsSync8 } from "fs";
+import { spawnSync as spawnSync5 } from "child_process";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, readdirSync as readdirSync2, unlinkSync as unlinkSync3, chmodSync, existsSync as existsSync8 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var log19 = forComponent("os-sched");
 var OsScheduler = class {
   options;
@@ -9207,13 +9374,13 @@ var OsScheduler = class {
     this.options = { ...new OsSchedulerOptions(), ...options };
   }
   get dir() {
-    return join10(this.options.home, ".agent", "sched");
+    return join11(this.options.home, ".agent", "sched");
   }
   label(id) {
     return `cc.livx.agentx.sched-${id}`;
   }
   plistPath(id) {
-    return join10(this.options.home, "Library", "LaunchAgents", `${this.label(id)}.plist`);
+    return join11(this.options.home, "Library", "LaunchAgents", `${this.label(id)}.plist`);
   }
   run(cmd, args, input) {
     return this.options.exec(cmd, args, input);
@@ -9224,16 +9391,16 @@ var OsScheduler = class {
   /** Register the job with the OS. Returns a human description of the mechanism used. Throws on failure. */
   schedule(spec) {
     if (!this.available()) throw new Error(`no OS scheduler on ${this.options.platform}`);
-    mkdirSync7(this.dir, { recursive: true });
+    mkdirSync8(this.dir, { recursive: true });
     const oneOff = "at" in spec.trigger;
     const script = this.writeScript(spec, oneOff);
     const mechanism = this.options.platform === "darwin" ? this.scheduleDarwin(spec, script) : this.scheduleLinux(spec, script, oneOff);
     const meta = { ...spec, created: Date.now(), mechanism };
-    writeFileSync7(join10(this.dir, `${spec.id}.json`), JSON.stringify(meta, null, 2));
+    writeFileSync7(join11(this.dir, `${spec.id}.json`), JSON.stringify(meta, null, 2));
     return mechanism;
   }
   cancel(id) {
-    const meta = readJsonFile(join10(this.dir, `${id}.json`), null);
+    const meta = readJsonFile(join11(this.dir, `${id}.json`), null);
     if (!meta) return false;
     try {
       if (this.options.platform === "darwin") {
@@ -9266,7 +9433,7 @@ var OsScheduler = class {
     }
     for (const f of [`${id}.json`, `${id}.sh`]) {
       try {
-        unlinkSync3(join10(this.dir, f));
+        unlinkSync3(join11(this.dir, f));
       } catch {
       }
     }
@@ -9274,19 +9441,19 @@ var OsScheduler = class {
   }
   list() {
     if (!existsSync8(this.dir)) return [];
-    return readdirSync2(this.dir).filter((f) => f.endsWith(".json")).map((f) => readJsonFile(join10(this.dir, f), null)).filter(Boolean);
+    return readdirSync2(this.dir).filter((f) => f.endsWith(".json")).map((f) => readJsonFile(join11(this.dir, f), null)).filter(Boolean);
   }
   /** The per-job runner script: cd to the project, headless-resume the session, log, notify. */
   writeScript(spec, oneOff) {
-    const p = join10(this.dir, `${spec.id}.sh`);
+    const p = join11(this.dir, `${spec.id}.sh`);
     const q2 = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-    const cleanup = oneOff ? this.options.platform === "darwin" ? `launchctl remove ${this.label(spec.id)} 2>/dev/null; rm -f ${q2(this.plistPath(spec.id))} ${q2(join10(this.dir, `${spec.id}.json`))} ${q2(p)}
-` : `rm -f ${q2(join10(this.dir, `${spec.id}.json`))} ${q2(p)}
+    const cleanup = oneOff ? this.options.platform === "darwin" ? `launchctl remove ${this.label(spec.id)} 2>/dev/null; rm -f ${q2(this.plistPath(spec.id))} ${q2(join11(this.dir, `${spec.id}.json`))} ${q2(p)}
+` : `rm -f ${q2(join11(this.dir, `${spec.id}.json`))} ${q2(p)}
 ` : "";
     writeFileSync7(p, `#!/bin/sh
 # agentx scheduled job ${spec.id}${spec.label ? ` \u2014 ${spec.label}` : ""}
 cd ${q2(spec.cwd)} || exit 1
-${this.options.agentx} -p ${q2(spec.prompt)} --resume ${q2(spec.sessionId)} --yes >> ${q2(join10(this.dir, `${spec.id}.log`))} 2>&1
+${this.options.agentx} -p ${q2(spec.prompt)} --resume ${q2(spec.sessionId)} --yes >> ${q2(join11(this.dir, `${spec.id}.log`))} 2>&1
 ${cleanup}`);
     chmodSync(p, 493);
     return p;
@@ -9323,7 +9490,7 @@ ${trigger}
 <key>RunAtLoad</key><false/>
 </dict></plist>
 `;
-    mkdirSync7(join10(this.options.home, "Library", "LaunchAgents"), { recursive: true });
+    mkdirSync8(join11(this.options.home, "Library", "LaunchAgents"), { recursive: true });
     writeFileSync7(this.plistPath(spec.id), plist);
     this.run("launchctl", ["load", this.plistPath(spec.id)]);
     return `launchd:${this.label(spec.id)}`;
@@ -9361,7 +9528,7 @@ var OsSchedulerOptions = class {
   /** Injectable executor for tests. Returns stdout+stderr merged — `at` reports "job N" on STDERR,
    *  and the job id is what atrm needs for cancel. Throws on non-zero exit. */
   exec = (cmd, args, input) => {
-    const r = spawnSync4(cmd, args, { input, encoding: "utf8" });
+    const r = spawnSync5(cmd, args, { input, encoding: "utf8" });
     if (r.error) throw r.error;
     if (r.status !== 0) throw new Error(`${cmd} exited ${r.status}: ${r.stderr || r.stdout}`);
     return `${r.stdout ?? ""}${r.stderr ?? ""}`;
@@ -9376,12 +9543,12 @@ function routeTrigger(trigger, backendHint, now5 = Date.now()) {
 // cli/remoteTrigger.ts
 import { createServer as createServer2, createConnection } from "net";
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 var log20 = forComponent("remote-trigger");
-var TRIGGER_DIR = () => join11(homedir8(), ".agent", "triggers");
-var sockPath = (sessionId, dir = TRIGGER_DIR()) => join11(dir, `${sessionId}.sock`);
+var TRIGGER_DIR = () => join12(homedir8(), ".agent", "triggers");
+var sockPath = (sessionId, dir = TRIGGER_DIR()) => join12(dir, `${sessionId}.sock`);
 var TriggerServer = class {
   constructor(onTrigger) {
     this.onTrigger = onTrigger;
@@ -9393,7 +9560,7 @@ var TriggerServer = class {
   start(sessionId, dir = TRIGGER_DIR()) {
     this.stop();
     try {
-      mkdirSync8(dir, { recursive: true, mode: 448 });
+      mkdirSync9(dir, { recursive: true, mode: 448 });
       const p = sockPath(sessionId, dir);
       try {
         unlinkSync4(p);
@@ -9547,7 +9714,7 @@ var err = (s) => process.stderr.write(s);
 var log21 = forComponent("cli");
 var VERSION = (() => {
   try {
-    return JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
+    return JSON.parse(readFileSync7(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
   } catch {
     return "?";
   }
@@ -9659,6 +9826,7 @@ function parseArgs(argv) {
     else if (x === "--reasoning") a.reasoning = parseReasoning(val(++i, x));
     else if (x === "--session-id") a.sessionId = val(++i, x);
     else if (x === "--fork-session") a.fork = true;
+    else if (x === "--worktree" || x === "-w") a.worktree = val(++i, x);
     else if (x === "--max-steps") a.maxSteps = numFlag(argv[++i], "--max-steps");
     else if (x === "--max-tokens") a.maxTokens = numFlag(argv[++i], "--max-tokens");
     else if (x === "--timeout") a.timeoutMs = numFlag(argv[++i], "--timeout") * 1e3;
@@ -9671,6 +9839,7 @@ function parseArgs(argv) {
   if (!a.task && rest.length) a.task = rest.join(" ");
   if (a.boddb && a.vfs) throw new Error("--boddb and --sandbox are mutually exclusive (both are non-disk filesystems; pick one)");
   if (a.seed && !a.boddb) throw new Error("--seed only applies with --boddb (it seeds the database from cwd on first run)");
+  if (a.worktree && (a.vfs || a.boddb)) throw new Error("--worktree is a real-disk concept \u2014 incompatible with --vfs/--boddb");
   if (a.duplex && (a.task || a.print)) throw new Error("--duplex is interactive-only (a conversational mode) \u2014 drop the task/-p");
   if (a.duplex && a.plan) throw new Error("--plan is not supported in --duplex (workers are non-interactive; a plan could never be approved)");
   if (a.voiceModel && !a.duplex) throw new Error("--voice-model only applies with --duplex");
@@ -9722,6 +9891,7 @@ Flags:
   --reasoning <e>      extended thinking: off|low|medium|high or a token budget (anthropic/openai)
   --session-id <id>    use this id for the session (instead of an auto-generated one)
   --fork-session       with -r/-c: branch the resumed session into a new id (source left untouched)
+  -w, --worktree <slug>  run in an isolated git worktree (.claude/worktrees/<slug>); auto-cleaned on exit if no changes
   --max-steps <n>      step budget (default 30)
   --max-tokens <n>     token budget kill-switch (default 200000)
   --timeout <sec>      wall-clock kill-switch (default 120)
@@ -9769,11 +9939,11 @@ function resolveModelOrNewest(model) {
 var ENV_KEY_ALIASES = { google: ["GEMINI_API_KEY"] };
 function loadInstallEnv() {
   let dir = dirname4(import.meta.path);
-  for (let i = 0; i < 5 && !existsSync10(join12(dir, "package.json")); i++) dir = dirname4(dir);
+  for (let i = 0; i < 5 && !existsSync10(join13(dir, "package.json")); i++) dir = dirname4(dir);
   for (const name of [".env", ".env.local"]) {
-    const file = join12(dir, name);
+    const file = join13(dir, name);
     if (!existsSync10(file)) continue;
-    for (const line of readFileSync6(file, "utf8").split("\n")) {
+    for (const line of readFileSync7(file, "utf8").split("\n")) {
       const m = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
       if (!m || m[1] in process.env) continue;
       let val = m[2].trim();
@@ -10365,7 +10535,7 @@ var IMG_EXT = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg"
 function mentionRefs(line) {
   return [...line.matchAll(/(?:^|\s)@(?:"([^"]+)"|(\S+))/g)].map((m) => m[1] ?? m[2].replace(/[?!.,;:)\]}'">]+$/, "")).filter(Boolean);
 }
-var untilde = (p) => p.startsWith("~/") ? join12(homedir9(), p.slice(2)) : p;
+var untilde = (p) => p.startsWith("~/") ? join13(homedir9(), p.slice(2)) : p;
 function readImageParts(cwd, line) {
   const refs = mentionRefs(line);
   const parts = [];
@@ -10374,7 +10544,7 @@ function readImageParts(cwd, line) {
     if (!mime) continue;
     const abs = ref.startsWith("~/") ? untilde(ref) : resolve3(cwd, ref);
     try {
-      parts.push(imagePart(`data:${mime};base64,${readFileSync6(abs).toString("base64")}`));
+      parts.push(imagePart(`data:${mime};base64,${readFileSync7(abs).toString("base64")}`));
     } catch {
     }
   }
@@ -10388,7 +10558,7 @@ function pastePathClassifier(cwd) {
     if (!/^(\/|~\/|\.\/|\.\.\/)/.test(t)) return null;
     const abs = t.startsWith("~/") ? untilde(t) : resolve3(cwd, t);
     try {
-      if (!statSync3(abs).isFile()) return null;
+      if (!statSync4(abs).isFile()) return null;
     } catch {
       return null;
     }
@@ -10605,24 +10775,24 @@ var AGENTS_MD_TEMPLATE = `# ${"${name}"}
 `;
 function initInstructions(cwd) {
   for (const f of ["AGENTS.md", "CLAUDE.md"]) {
-    if (existsSync10(join12(cwd, f))) {
+    if (existsSync10(join13(cwd, f))) {
       err(yellow(`  ${f} already exists \u2014 leaving it as-is
 `));
       return;
     }
   }
-  const path = join12(cwd, "AGENTS.md");
+  const path = join13(cwd, "AGENTS.md");
   writeFileSync8(path, AGENTS_MD_TEMPLATE.replace("${name}", basename2(cwd)));
   err(green(`  created ${path}
 `) + dim("  edit it, then it auto-loads into every run.\n"));
 }
 function persistSetting(cwd, key, value) {
-  const path = join12(cwd, ".agent", "settings.json");
+  const path = join13(cwd, ".agent", "settings.json");
   try {
-    const obj = existsSync10(path) ? JSON.parse(readFileSync6(path, "utf8")) : {};
+    const obj = existsSync10(path) ? JSON.parse(readFileSync7(path, "utf8")) : {};
     if (obj[key] === value) return;
     obj[key] = value;
-    mkdirSync9(dirname4(path), { recursive: true });
+    mkdirSync10(dirname4(path), { recursive: true });
     writeFileSync8(path, JSON.stringify(obj, null, 2) + "\n");
   } catch (e) {
     err(yellow(`  \u26A0 couldn't persist ${key} to ${path} \u2014 ${e?.message ?? e}
@@ -10655,7 +10825,7 @@ function installCancelGuards(mounted) {
   });
 }
 async function repl(args, ai, cfg, cwd) {
-  const oauth = new McpOAuth({ storePath: join12(cwd, ".agent", "mcp-auth.json") });
+  const oauth = new McpOAuth({ storePath: join13(cwd, ".agent", "mcp-auth.json") });
   const mounted = await mountMcp(cfg, oauth);
   let mcpToolNames = [];
   const initialMcpTools = mcpAgentTools(mounted);
@@ -10863,7 +11033,7 @@ async function repl(args, ai, cfg, cwd) {
       quickLook: {
         branch: () => {
           try {
-            const head = readFileSync6(join12(cwd, ".git", "HEAD"), "utf8").trim();
+            const head = readFileSync7(join13(cwd, ".git", "HEAD"), "utf8").trim();
             return head.startsWith("ref: refs/heads/") ? `branch: ${head.slice("ref: refs/heads/".length)}` : `detached HEAD at ${head.slice(0, 12)}`;
           } catch {
             return "not a git repository";
@@ -10992,9 +11162,9 @@ async function repl(args, ai, cfg, cwd) {
   const pendingImages = [];
   const bangContext = [];
   const grabClipboardAttachment = () => {
-    const dir = join12(tmpdir3(), "agentx-pasted");
+    const dir = join13(tmpdir3(), "agentx-pasted");
     try {
-      mkdirSync9(dir, { recursive: true });
+      mkdirSync10(dir, { recursive: true });
     } catch {
     }
     const img = grabClipboardImage(dir, String(Date.now()));
@@ -11045,7 +11215,7 @@ async function repl(args, ai, cfg, cwd) {
     err(dim(`  \u23F0 ${scheduler.size} scheduled job(s) re-armed
 `));
   }
-  const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join12(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
+  const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join13(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
   const cpHooks = checkpoints.hooks?.();
   if (cpHooks) {
     agent.options.hooks = composeHooks(agent.options.hooks, cpHooks);
@@ -11097,11 +11267,11 @@ ${lines.join("\n")}
 Added entries are loadable now via the Skill/SlashCommand tools; removed ones are gone even if still listed in the system prompt.
 </system-reminder>`;
   };
-  const histPath = join12(cwd, ".agent", "history");
-  const history = existsSync10(histPath) ? readFileSync6(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
+  const histPath = join13(cwd, ".agent", "history");
+  const history = existsSync10(histPath) ? readFileSync7(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
   const remember = (line) => {
     try {
-      mkdirSync9(join12(cwd, ".agent"), { recursive: true });
+      mkdirSync10(join13(cwd, ".agent"), { recursive: true });
       appendFileSync(histPath, line + "\n");
     } catch (e) {
       log21.debug("history write failed", e);
@@ -11401,8 +11571,8 @@ ${task}`;
           const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
           if (wasRaw) process.stdin.setRawMode(false);
           try {
-            const { spawnSync: spawnSync5 } = await import("child_process");
-            const r = spawnSync5("less", ["-R"], { input: text, stdio: ["pipe", "inherit", "inherit"] });
+            const { spawnSync: spawnSync6 } = await import("child_process");
+            const r = spawnSync6("less", ["-R"], { input: text, stdio: ["pipe", "inherit", "inherit"] });
             if (r.error) err(text);
           } finally {
             if (wasRaw) process.stdin.setRawMode(true);
@@ -11426,7 +11596,7 @@ ${task}`;
         cfgFiles.length ? ok(`config: ${cfgFiles.join(", ")}`) : warn("no .agent/config.* found (project or ~) \u2014 running on defaults");
         try {
           const probe = `${cwd}/.agent/sessions/.doctor-probe`;
-          mkdirSync9(`${cwd}/.agent/sessions`, { recursive: true });
+          mkdirSync10(`${cwd}/.agent/sessions`, { recursive: true });
           writeFileSync8(probe, "ok");
           unlinkSync5(probe);
           ok(`session store writable (${cwd}/.agent/sessions)`);
@@ -11792,8 +11962,8 @@ ${task}`;
         const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
         if (wasRaw) process.stdin.setRawMode(false);
         try {
-          const { spawnSync: spawnSync5 } = await import("child_process");
-          spawnSync5(ed, [idx], { stdio: "inherit" });
+          const { spawnSync: spawnSync6 } = await import("child_process");
+          spawnSync6(ed, [idx], { stdio: "inherit" });
         } finally {
           if (wasRaw) process.stdin.setRawMode(true);
         }
@@ -12160,10 +12330,10 @@ ${task}`;
           return;
         }
         const md = exportMarkdown(session.meta, shown);
-        const name = a[0] ? extname(a[0]) ? a[0] : a[0] + ".md" : join12(".agent", "exports", `${session.meta.id}.md`);
+        const name = a[0] ? extname(a[0]) ? a[0] : a[0] + ".md" : join13(".agent", "exports", `${session.meta.id}.md`);
         const path = resolve3(cwd, name);
         try {
-          mkdirSync9(dirname4(path), { recursive: true });
+          mkdirSync10(dirname4(path), { recursive: true });
           writeFileSync8(path, md);
           err(green(`  \u2713 exported \u2192 ${path}
 `) + dim(`  ${shown.length} message(s) \xB7 ${md.length} chars
@@ -12226,7 +12396,7 @@ ${task}`;
   if (dx) banner(dim(`\u25D1 duplex \u2014 reflex: ${dx.options.reflexModel} \xB7 act: ${work.model}${dx.options.thinkModel !== false ? ` \xB7 think: ${dx.options.thinkModel}` : ""} (real work runs in background tasks, re-voiced when done)`));
   const listDir = (absDir) => {
     try {
-      return readdirSync4(join12(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
+      return readdirSync4(join13(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
     } catch (e) {
       log21.debug("completion readdir failed", absDir, e);
       return null;
@@ -12697,6 +12867,19 @@ async function main() {
   }
   if (args.debug) process.env.DEBUG ||= "*";
   if (args.print && !args.task && !process.stdin.isTTY) args.task = (await readAllStdin()).trim();
+  let worktreeCleanup;
+  if (args.worktree) {
+    const { enterWorktree: enterWorktree2, exitWorktree: exitWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
+    const session = enterWorktree2(args.worktree, resolve3(args.cwd ?? process.cwd()));
+    err(dim(`  \u2295 worktree: ${session.worktreePath} (branch ${session.branch})
+`));
+    worktreeCleanup = () => {
+      const r = exitWorktree2();
+      if (r?.removed) err(dim("  \u2296 worktree cleaned up (no changes)\n"));
+      else if (r && !r.removed) err(dim(`  \u2295 worktree kept: ${r.reason}
+`));
+    };
+  }
   const cwd = resolve3(args.cwd ?? process.cwd());
   const cfg = await loadConfig(cwd);
   cfg.permissions = mergePerms(loadClaudeSettings(cwd), mergePerms(loadPersistedRules(cwd), cfg.permissions));
@@ -12742,7 +12925,7 @@ async function main() {
     }
   });
   if (args.task) {
-    const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join12(cwd, ".agent", "mcp-auth.json") }));
+    const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join13(cwd, ".agent", "mcp-auth.json") }));
     const agent = await makeAgent(args, ai, cfg, mcpAgentTools(mounted));
     const store = new SessionStore(cwd);
     const session = startSession(args, store, agent, cwd);
@@ -12759,9 +12942,11 @@ async function main() {
       const obj = res ? jsonResult(res, session) : { ok: false, finishReason: "error", sessionId: session.meta.id };
       process.stdout.write(JSON.stringify(args.outputFormat === "stream-json" ? { type: "result", ...obj } : obj) + "\n");
     }
+    worktreeCleanup?.();
     process.exit(ok ? 0 : 1);
   }
   await repl(args, ai, cfg, cwd);
+  worktreeCleanup?.();
 }
 if (import.meta.main) main().catch((e) => {
   console.error(e?.message ?? e);