very-happy-cli 0.2.166 → 0.2.167

package/dist/mirrorProtocol-BdcN6QlN.cjs

@@ -0,0 +1,1270 @@
+'use strict';
+
+var node_child_process = require('node:child_process');
+var node_crypto = require('node:crypto');
+var node_fs = require('node:fs');
+var path = require('node:path');
+var promises = require('node:fs/promises');
+var configuration = require('./configuration-C3piBtxY.cjs');
+var index = require('./index-C9hI8a10.cjs');
+var _package = require('./package-C9ZP9bpX.cjs');
+
+function summarizeSpawnSessionForLog(value) {
+  const input = value && typeof value === "object" ? value : {};
+  const environmentVariables = input.environmentVariables && typeof input.environmentVariables === "object" ? input.environmentVariables : {};
+  return {
+    ...typeof input.agent === "string" ? { agent: input.agent } : {},
+    ...typeof input.variant === "string" ? { variant: input.variant } : {},
+    ...typeof input.sessionId === "string" ? { sessionId: input.sessionId } : {},
+    hasDirectory: typeof input.directory === "string" && input.directory.length > 0,
+    hasToken: typeof input.token === "string" && input.token.length > 0,
+    environmentVariableNames: Object.keys(environmentVariables).sort(),
+    resumesClaude: typeof input.resumeClaudeSessionId === "string" && input.resumeClaudeSessionId.length > 0,
+    resumesCodex: typeof input.resumeCodexThreadId === "string" && input.resumeCodexThreadId.length > 0,
+    importsClaude: typeof input.importedFromClaudeSessionId === "string" && input.importedFromClaudeSessionId.length > 0,
+    forceNew: input.forceNew === true,
+    ...typeof input.permissionMode === "string" ? { permissionMode: input.permissionMode } : {}
+  };
+}
+
+const WORKTREE_CAPABILITY_VERSION = 1;
+const obj = (value) => value && typeof value === "object" ? value : {};
+function registerWorktreeHandlers(rpc, service) {
+  rpc.registerHandler("worktree-info", async (params) => service.info(obj(params).path));
+  rpc.registerHandler("worktree-create", async (params) => {
+    const p = obj(params);
+    return service.create({ path: p.path, branch: p.branch, baseRef: p.baseRef, location: p.location });
+  });
+  rpc.registerHandler("worktree-setup-status", async (params) => service.status(obj(params).path));
+  rpc.registerHandler("worktree-setup-approve", async (params) => service.approve(obj(params).path, obj(params).hash));
+  rpc.registerHandler("worktree-setup-decline", async (params) => service.decline(obj(params).path));
+  rpc.registerHandler("worktree-setup-log", async (params) => service.log(obj(params).path, obj(params).offset));
+  rpc.registerHandler("worktree-inspect", async (params) => service.inspect(obj(params).path));
+  rpc.registerHandler("worktree-remove", async (params) => service.remove(obj(params).path, obj(params).discardChanges, obj(params).expectedFingerprint));
+}
+
+const CONFIG_RELATIVE_PATH = ".veryhappy/worktree.json";
+const CONFIG_MAX_BYTES = 64 * 1024;
+const SCRIPT_MAX_BYTES = 32 * 1024;
+const MAX_COPY_PATTERNS = 64;
+const MAX_LINK_ENTRIES = 16;
+const DEFAULT_SETUP_TIMEOUT_MINUTES = 10;
+const DEFAULT_WEB_COPY = [".env*"];
+const EMPTY_CONFIG = { copy: [], link: [], setup: null, setupWindows: null, setupTimeoutMinutes: DEFAULT_SETUP_TIMEOUT_MINUTES };
+function isSafeRelativePattern(pattern) {
+  if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > 512) return false;
+  if (pattern.includes("\0") || pattern.includes("\\")) return false;
+  if (pattern.startsWith("/") || /^[a-zA-Z]:/.test(pattern) || pattern.startsWith("~")) return false;
+  const segments = pattern.split("/");
+  return segments.every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+function globSegmentToRegExp(segment) {
+  let source = "^";
+  for (const ch of segment) {
+    if (ch === "*") source += "[^/]*";
+    else if (ch === "?") source += "[^/]";
+    else source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`${source}$`);
+}
+function hasGlob(segment) {
+  return segment.includes("*") || segment.includes("?");
+}
+function clampTimeout(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_SETUP_TIMEOUT_MINUTES;
+  return Math.min(60, Math.max(1, Math.round(value)));
+}
+function readScript(value, field, errors) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value !== "string") {
+    errors.push(`${field} must be a string`);
+    return null;
+  }
+  if (Buffer.byteLength(value, "utf8") > SCRIPT_MAX_BYTES) {
+    errors.push(`${field} exceeds ${SCRIPT_MAX_BYTES} bytes`);
+    return null;
+  }
+  return value.trim() ? value : null;
+}
+function readPatterns(value, field, max, errors) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    errors.push(`${field} must be an array`);
+    return [];
+  }
+  const out = [];
+  for (const entry of value.slice(0, max)) {
+    if (typeof entry === "string" && isSafeRelativePattern(entry)) out.push(entry);
+    else errors.push(`${field}: rejected ${JSON.stringify(entry).slice(0, 80)}`);
+  }
+  if (value.length > max) errors.push(`${field}: only the first ${max} entries are used`);
+  return out;
+}
+function parseWorktreeConfig(text, origin) {
+  if (text === null) {
+    return origin === "web" ? { source: "default", config: { ...EMPTY_CONFIG, copy: [...DEFAULT_WEB_COPY] }, errors: [] } : { source: "none", config: { ...EMPTY_CONFIG }, errors: [] };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { source: "invalid", config: { ...EMPTY_CONFIG }, errors: [`${CONFIG_RELATIVE_PATH} is not valid JSON`] };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { source: "invalid", config: { ...EMPTY_CONFIG }, errors: [`${CONFIG_RELATIVE_PATH} must be a JSON object`] };
+  }
+  const obj = raw;
+  const errors = [];
+  const config = {
+    copy: readPatterns(obj.copy, "copy", MAX_COPY_PATTERNS, errors),
+    link: readPatterns(obj.link, "link", MAX_LINK_ENTRIES, errors).filter((entry) => {
+      if (hasGlob(entry)) {
+        errors.push(`link: globs are not allowed (${entry})`);
+        return false;
+      }
+      return true;
+    }),
+    setup: readScript(obj.setup, "setup", errors),
+    setupWindows: readScript(obj.setupWindows, "setupWindows", errors),
+    setupTimeoutMinutes: clampTimeout(obj.setupTimeoutMinutes)
+  };
+  return { source: "file", config, errors };
+}
+function isShebangScript(script) {
+  return script.trimStart().startsWith("#!");
+}
+function selectSetupScript(config, platform) {
+  if (platform === "win32") {
+    const script2 = config.setupWindows ?? config.setup;
+    if (!script2) return { kind: "none" };
+    if (isShebangScript(script2)) {
+      return { kind: "unsupported", script: script2, message: 'A "#!" setup script needs a POSIX shell; native Windows runs setup through cmd.exe. Add "setupWindows" with cmd syntax.' };
+    }
+    return { kind: "script", script: script2, runner: "cmd" };
+  }
+  const script = config.setup;
+  if (!script) return { kind: "none" };
+  return { kind: "script", script, runner: isShebangScript(script) ? "shebang" : "posix-sh" };
+}
+function setupScriptHash(runner, script) {
+  return node_crypto.createHash("sha256").update(`${runner}\0${script}`, "utf8").digest("hex");
+}
+function describeRunner(runner) {
+  if (runner === "cmd") return "cmd.exe /d /c setup.cmd";
+  if (runner === "shebang") return "./setup (its own #! interpreter)";
+  return "/bin/sh -e setup.sh";
+}
+
+const COPY_MAX_FILE_BYTES = 10 * 1024 * 1024;
+const COPY_MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+const COPY_MAX_FILES = 200;
+const GLOB_MAX_MATCHES = 1e3;
+function isInside(parent, child) {
+  const rel = path.relative(parent, child);
+  return rel === "" || !!rel && !rel.startsWith("..") && !path.isAbsolute(rel) && rel.split(path.sep)[0] !== "..";
+}
+async function expandPattern(root, pattern) {
+  if (!isSafeRelativePattern(pattern)) return [];
+  let current = [""];
+  for (const segment of pattern.split("/")) {
+    const next = [];
+    for (const base of current) {
+      if (!hasGlob(segment)) {
+        next.push(base ? `${base}/${segment}` : segment);
+        continue;
+      }
+      const regex = globSegmentToRegExp(segment);
+      let names = [];
+      try {
+        names = await promises.readdir(path.join(root, ...base.split("/").filter(Boolean)));
+      } catch {
+        continue;
+      }
+      for (const name of names.sort()) {
+        if (name.startsWith(".") && !segment.startsWith(".")) continue;
+        if (name === ".git") continue;
+        if (regex.test(name)) next.push(base ? `${base}/${name}` : name);
+        if (next.length >= GLOB_MAX_MATCHES) break;
+      }
+    }
+    current = next;
+    if (current.length === 0) break;
+  }
+  return current.filter(Boolean);
+}
+async function realOrNull(path) {
+  try {
+    return await promises.realpath(path);
+  } catch {
+    return null;
+  }
+}
+async function realExistingAncestor(path$1) {
+  let current = path$1;
+  for (let i = 0; i < 64; i++) {
+    const real = await realOrNull(current);
+    if (real) return real;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+  return null;
+}
+async function copyIntoWorktree(sourceRoot, worktree, patterns) {
+  const copied = [];
+  const skipped = [];
+  const realSource = await promises.realpath(sourceRoot);
+  const realWorktree = await promises.realpath(worktree);
+  let total = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    if (!isSafeRelativePattern(pattern)) {
+      skipped.push({ path: pattern, reason: "unsafe-pattern" });
+      continue;
+    }
+    for (const rel of await expandPattern(realSource, pattern)) {
+      if (seen.has(rel)) continue;
+      seen.add(rel);
+      if (rel.split("/").includes(".git")) {
+        skipped.push({ path: rel, reason: "git-internal" });
+        continue;
+      }
+      const source = path.join(realSource, ...rel.split("/"));
+      let info;
+      try {
+        info = await promises.lstat(source);
+      } catch {
+        continue;
+      }
+      const resolved = await realOrNull(source);
+      if (!resolved || !isInside(realSource, resolved)) {
+        skipped.push({ path: rel, reason: "outside-repo" });
+        continue;
+      }
+      const target = info.isSymbolicLink() ? await promises.stat(resolved).catch(() => null) : info;
+      if (!target || !target.isFile()) {
+        skipped.push({ path: rel, reason: "not-a-file" });
+        continue;
+      }
+      if (target.size > COPY_MAX_FILE_BYTES) {
+        skipped.push({ path: rel, reason: "too-large" });
+        continue;
+      }
+      if (copied.length >= COPY_MAX_FILES) {
+        skipped.push({ path: rel, reason: "file-limit" });
+        continue;
+      }
+      if (total + target.size > COPY_MAX_TOTAL_BYTES) {
+        skipped.push({ path: rel, reason: "total-limit" });
+        continue;
+      }
+      const destination = path.join(realWorktree, ...rel.split("/"));
+      if (await promises.lstat(destination).then(() => true, () => false)) {
+        skipped.push({ path: rel, reason: "exists" });
+        continue;
+      }
+      const parentReal = await realExistingAncestor(path.dirname(destination));
+      if (!parentReal || !isInside(realWorktree, parentReal)) {
+        skipped.push({ path: rel, reason: "outside-worktree" });
+        continue;
+      }
+      try {
+        await promises.mkdir(path.dirname(destination), { recursive: true });
+        const madeReal = await promises.realpath(path.dirname(destination));
+        if (!isInside(realWorktree, madeReal)) {
+          skipped.push({ path: rel, reason: "outside-worktree" });
+          continue;
+        }
+        await promises.copyFile(resolved, destination, node_fs.constants.COPYFILE_EXCL);
+        copied.push(rel);
+        total += target.size;
+      } catch (error) {
+        skipped.push({ path: rel, reason: `copy-failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 200) });
+      }
+    }
+  }
+  return { copied, skipped };
+}
+function linkTypeCandidates(platform) {
+  return platform === "win32" ? ["junction", "dir"] : ["dir"];
+}
+async function linkIntoWorktree(sourceRoot, worktree, entries, platform = process.platform) {
+  const linked = [];
+  const skipped = [];
+  const realSource = await promises.realpath(sourceRoot);
+  const realWorktree = await promises.realpath(worktree);
+  for (const rel of entries) {
+    if (!isSafeRelativePattern(rel) || hasGlob(rel)) {
+      skipped.push({ path: rel, reason: "unsafe-pattern" });
+      continue;
+    }
+    if (rel.split("/").includes(".git")) {
+      skipped.push({ path: rel, reason: "git-internal" });
+      continue;
+    }
+    try {
+      const source = path.join(realSource, ...rel.split("/"));
+      let info;
+      try {
+        info = await promises.lstat(source);
+      } catch {
+        skipped.push({ path: rel, reason: "missing" });
+        continue;
+      }
+      if (info.isSymbolicLink() || !info.isDirectory()) {
+        skipped.push({ path: rel, reason: "not-a-directory" });
+        continue;
+      }
+      const resolved = await realOrNull(source);
+      if (!resolved || !isInside(realSource, resolved) || resolved === realSource) {
+        skipped.push({ path: rel, reason: "outside-repo" });
+        continue;
+      }
+      const destination = path.join(realWorktree, ...rel.split("/"));
+      if (await promises.lstat(destination).then(() => true, () => false)) {
+        skipped.push({ path: rel, reason: "exists" });
+        continue;
+      }
+      const parentReal = await realExistingAncestor(path.dirname(destination));
+      if (!parentReal || !isInside(realWorktree, parentReal)) {
+        skipped.push({ path: rel, reason: "outside-worktree" });
+        continue;
+      }
+      await promises.mkdir(path.dirname(destination), { recursive: true });
+      const madeReal = await promises.realpath(path.dirname(destination));
+      if (!isInside(realWorktree, madeReal)) {
+        skipped.push({ path: rel, reason: "outside-worktree" });
+        continue;
+      }
+      let done = false;
+      let lastError = "";
+      for (const type of linkTypeCandidates(platform)) {
+        try {
+          await promises.symlink(resolved, destination, type);
+          done = true;
+          break;
+        } catch (error) {
+          lastError = error instanceof Error ? error.message : String(error);
+        }
+      }
+      if (done) linked.push(rel);
+      else skipped.push({ path: rel, reason: `link-failed: ${lastError}`.slice(0, 200) });
+    } catch (error) {
+      skipped.push({ path: rel, reason: `link-failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 200) });
+    }
+  }
+  return { linked, skipped };
+}
+
+const SETUP_KILL_GRACE_MS = 1e4;
+const SETUP_LOG_MAX_BYTES = 20 * 1024 * 1024;
+const LOG_CHECK_MS = 500;
+function buildWindowsRunnerScript(script) {
+  const header = "@echo off\r\nsetlocal EnableExtensions DisableDelayedExpansion\r\n";
+  let out = header;
+  for (const raw of script.split("\n")) {
+    const line = raw.replace(/\r$/, "").trim();
+    if (!line) {
+      out += "\r\n";
+      continue;
+    }
+    out += `call ${line}\r
+if errorlevel 1 exit /b %errorlevel%\r
+`;
+  }
+  return out;
+}
+function sanitizeSetupEnv(base, paths) {
+  const env = {};
+  for (const [key, value] of Object.entries(base)) {
+    if (value === void 0) continue;
+    if (/^(HAPPY|VH)_/i.test(key)) continue;
+    env[key] = value;
+  }
+  env.VERY_HAPPY_WORKTREE_PATH = paths.worktree;
+  env.VERY_HAPPY_ROOT_PATH = paths.root;
+  return env;
+}
+function prepareRunner(runDir, runner, script) {
+  if (runner === "cmd") {
+    const scriptPath2 = path.join(runDir, "setup.cmd");
+    node_fs.writeFileSync(scriptPath2, buildWindowsRunnerScript(script), { mode: 384 });
+    return { command: process.env.ComSpec || "cmd.exe", args: ["/d", "/c", scriptPath2], scriptPath: scriptPath2 };
+  }
+  const scriptPath = path.join(runDir, runner === "shebang" ? "setup" : "setup.sh");
+  node_fs.writeFileSync(scriptPath, script, { mode: 448 });
+  if (runner === "shebang") {
+    node_fs.chmodSync(scriptPath, 448);
+    return { command: scriptPath, args: [], scriptPath };
+  }
+  return { command: "/bin/sh", args: ["-e", scriptPath], scriptPath };
+}
+function killSetupTree(child, signal, platform = process.platform) {
+  if (!child.pid || child.exitCode !== null || child.signalCode !== null) return;
+  try {
+    if (platform === "win32") {
+      node_child_process.spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }).on("error", () => void 0);
+    } else {
+      process.kill(-child.pid, signal);
+    }
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
+}
+function startSetupRun(opts) {
+  const maxLogBytes = opts.maxLogBytes ?? SETUP_LOG_MAX_BYTES;
+  const logFd = node_fs.openSync(opts.logPath, "a", 384);
+  let child;
+  let interrupted = false;
+  let timedOut = false;
+  let truncated = false;
+  let settle = () => void 0;
+  const done = new Promise((resolve) => {
+    settle = resolve;
+  });
+  let settled = false;
+  const finish = (outcome) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    clearInterval(sizeWatch);
+    try {
+      node_fs.closeSync(logFd);
+    } catch {
+    }
+    settle(outcome);
+  };
+  const terminate = () => {
+    killSetupTree(child, "SIGTERM");
+    const hard = setTimeout(() => killSetupTree(child, "SIGKILL"), SETUP_KILL_GRACE_MS);
+    hard.unref();
+    child.once("exit", () => clearTimeout(hard));
+  };
+  const timer = setTimeout(() => {
+    timedOut = true;
+    terminate();
+  }, opts.timeoutMs);
+  timer.unref();
+  const sizeWatch = setInterval(() => {
+    if (truncated) return;
+    let size = 0;
+    try {
+      size = node_fs.fstatSync(logFd).size;
+    } catch {
+      return;
+    }
+    if (size > maxLogBytes) {
+      truncated = true;
+      terminate();
+    }
+  }, LOG_CHECK_MS);
+  sizeWatch.unref();
+  try {
+    child = (opts.spawnImpl ?? node_child_process.spawn)(opts.launch.command, opts.launch.args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      shell: false,
+      windowsHide: true,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", logFd, logFd]
+    });
+  } catch (error) {
+    finish({ state: "failed", exitCode: null, message: error instanceof Error ? error.message : String(error) });
+    return { pid: void 0, done, stop: () => void 0 };
+  }
+  child.on("error", (error) => finish({ state: "failed", exitCode: null, message: error.message }));
+  child.on("exit", (code, signal) => {
+    if (process.platform !== "win32" && child.pid) {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+      }
+    }
+    if (truncated) finish({ state: "failed", exitCode: code, truncated: true, message: `Output exceeded ${Math.round(maxLogBytes / 1024 / 1024)} MB; stopped` });
+    else if (timedOut) finish({ state: "timed-out", exitCode: code, message: `Timed out after ${Math.round(opts.timeoutMs / 6e4)} min` });
+    else if (interrupted) finish({ state: "interrupted", exitCode: code, message: "Stopped" });
+    else if (code === 0) finish({ state: "succeeded", exitCode: 0 });
+    else finish({ state: "failed", exitCode: code, ...signal ? { message: `Killed by ${signal}` } : {} });
+  });
+  return {
+    pid: child.pid,
+    done,
+    stop: () => {
+      if (settled) return;
+      interrupted = true;
+      terminate();
+    }
+  };
+}
+
+const MAX_WORKTREES = 500;
+const MAX_RUN_DIRS = 100;
+class WorktreeStore {
+  dir;
+  constructor(home) {
+    this.dir = path.join(home, "worktree-setup");
+  }
+  file(name) {
+    return path.join(this.dir, name);
+  }
+  read(name, fallback) {
+    const path = this.file(name);
+    if (!node_fs.existsSync(path)) return fallback;
+    try {
+      return JSON.parse(node_fs.readFileSync(path, "utf8"));
+    } catch {
+      return fallback;
+    }
+  }
+  write(name, value) {
+    configuration.ensurePrivateDirectorySync(this.dir);
+    const path = this.file(name);
+    const tmp = `${path}.${process.pid}.tmp`;
+    configuration.writePrivateFileSync(tmp, JSON.stringify(value, null, 2));
+    node_fs.renameSync(tmp, path);
+  }
+  runDir(runId) {
+    const dir = path.join(this.dir, "runs", runId);
+    configuration.ensurePrivateDirectorySync(dir);
+    return dir;
+  }
+  logPath(runId) {
+    return path.join(this.dir, "runs", runId, "output.log");
+  }
+  /** Keep the newest MAX_RUN_DIRS runs (run ids start with a base36 timestamp, so names sort by age). */
+  pruneRuns(keep = /* @__PURE__ */ new Set(), max = MAX_RUN_DIRS) {
+    const root = path.join(this.dir, "runs");
+    let names;
+    try {
+      names = node_fs.readdirSync(root).sort();
+    } catch {
+      return 0;
+    }
+    let removed = 0;
+    for (const name of names.slice(0, Math.max(0, names.length - max))) {
+      if (keep.has(name)) continue;
+      try {
+        node_fs.rmSync(path.join(root, name), { recursive: true, force: true });
+        removed++;
+      } catch {
+      }
+    }
+    return removed;
+  }
+  // ── approvals ──
+  approvals() {
+    const data = this.read("approvals.json", {});
+    return Array.isArray(data.approvals) ? data.approvals : [];
+  }
+  isApproved(machineId, repoRoot, hash) {
+    return this.approvals().some((a) => a.machineId === machineId && a.repoRoot === repoRoot && a.hash === hash);
+  }
+  /** True when this repo has SOME approval but not for `hash` (the script changed). */
+  hasOtherApproval(machineId, repoRoot, hash) {
+    return this.approvals().some((a) => a.machineId === machineId && a.repoRoot === repoRoot && a.hash !== hash);
+  }
+  approve(entry) {
+    const rest = this.approvals().filter((a) => !(a.machineId === entry.machineId && a.repoRoot === entry.repoRoot && a.hash === entry.hash));
+    const next = [...rest, entry].sort((a, b) => a.approvedAt - b.approvedAt).slice(-500);
+    this.write("approvals.json", { version: 1, approvals: next });
+  }
+  // ── worktree registry ──
+  worktrees() {
+    const data = this.read("worktrees.json", {});
+    return data.worktrees && typeof data.worktrees === "object" ? data.worktrees : {};
+  }
+  get(worktree) {
+    return this.worktrees()[worktree];
+  }
+  put(worktree, record) {
+    const all = { ...this.worktrees(), [worktree]: record };
+    const keys = Object.keys(all).sort((a, b) => all[a].createdAt - all[b].createdAt);
+    for (const key of keys.slice(0, Math.max(0, keys.length - MAX_WORKTREES))) delete all[key];
+    this.write("worktrees.json", { version: 1, worktrees: all });
+  }
+  updateSetup(worktree, patch) {
+    const record = this.get(worktree);
+    if (!record) return void 0;
+    const next = { ...record, setup: { ...record.setup, ...patch } };
+    this.put(worktree, next);
+    return next;
+  }
+  remove(worktree) {
+    const all = this.worktrees();
+    if (!(worktree in all)) return;
+    delete all[worktree];
+    this.write("worktrees.json", { version: 1, worktrees: all });
+  }
+  /**
+   * Daemon start: any `running` record belongs to a previous daemon process
+   * (this one has not started anything yet) — it was cut off. Never re-run.
+   */
+  markStaleRunsInterrupted(now = Date.now()) {
+    const all = this.worktrees();
+    const cut = [];
+    for (const [worktree, record] of Object.entries(all)) {
+      if (record.setup.state === "running") {
+        cut.push({ worktree, pid: record.setup.pid, runId: record.setup.runId });
+        record.setup = { ...record.setup, state: "interrupted", endedAt: now, message: "Daemon stopped during setup" };
+      }
+    }
+    if (cut.length) this.write("worktrees.json", { version: 1, worktrees: all });
+    return cut;
+  }
+}
+
+const GIT_CREATE_TIMEOUT_MS = 25e3;
+const LOG_CHUNK_BYTES = 64 * 1024;
+const MAX_BRANCHES = 200;
+const MAX_DIRTY_LISTED = 50;
+class WorktreeError extends Error {
+  constructor(code, message) {
+    super(message ? `${code}: ${message}` : code);
+    this.code = code;
+  }
+}
+function runGit(cwd, args, timeoutMs = 15e3) {
+  return new Promise((resolvePromise) => {
+    node_child_process.execFile("git", ["-C", cwd, ...args], { timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } }, (error, stdout, stderr) => {
+      const code = error ? typeof error.code === "number" ? error.code : 1 : 0;
+      resolvePromise({ code, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") || (error && code !== 0 ? error.message : "") });
+    });
+  });
+}
+function defaultWorktreeLocation(repoRoot, branch) {
+  const slug = branch.replace(/[\\/]+/g, "-").replace(/[^A-Za-z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "worktree";
+  return path.join(path.dirname(repoRoot), `${path.basename(repoRoot)}.worktrees`, slug);
+}
+function parsePorcelainZ(output) {
+  const parts = output.split("\0");
+  const paths = [];
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4) continue;
+    const status = entry.slice(0, 2);
+    paths.push(entry.slice(3).replace(/\/$/, ""));
+    if (status[0] === "R" || status[0] === "C") i++;
+  }
+  return paths;
+}
+function userDirtyPaths(dirty, managed) {
+  const own = /* @__PURE__ */ new Set([...managed.copied, ...managed.linked]);
+  return dirty.filter((path) => !own.has(path));
+}
+function real(path$1) {
+  try {
+    return node_fs.realpathSync(path$1);
+  } catch {
+    return path.resolve(path$1);
+  }
+}
+function requireAbsolute(path$1, field = "path") {
+  if (typeof path$1 !== "string" || !path$1 || !path.isAbsolute(path$1) || path$1.includes("\0")) throw new WorktreeError("invalid-path", `${field} must be an absolute path`);
+  return path$1;
+}
+class WorktreeService {
+  constructor(opts) {
+    this.opts = opts;
+    this.store = new WorktreeStore(opts.home);
+    this.platform = opts.platform ?? process.platform;
+    this.debug = opts.log ?? (() => void 0);
+    try {
+      this.killOrphanedRuns(this.store.markStaleRunsInterrupted());
+    } catch (error) {
+      this.debug("[worktree] could not reconcile stale setup runs", error);
+    }
+  }
+  store;
+  runs = /* @__PURE__ */ new Map();
+  platform;
+  debug;
+  /**
+   * A daemon that died hard (SIGKILL/crash) left its setup process groups
+   * running. Kill a group ONLY when its leader's command line still names
+   * that run's own script path (a reused pid belongs to something else).
+   * A group whose leader already exited cannot be verified and is left alone.
+   */
+  killOrphanedRuns(cut) {
+    if (this.platform === "win32") return;
+    const probe = this.opts.processCommand ?? defaultProcessCommand;
+    for (const run of cut) {
+      if (!run.pid || !run.runId) continue;
+      const command = probe(run.pid);
+      if (!command || !command.includes(path.join(this.store.dir, "runs", run.runId))) continue;
+      try {
+        process.kill(-run.pid, "SIGKILL");
+        this.debug(`[worktree] killed orphaned setup group ${run.pid}`);
+      } catch (error) {
+        this.debug("[worktree] orphan kill failed", error);
+      }
+    }
+  }
+  async toplevel(path) {
+    const result = await runGit(path, ["rev-parse", "--show-toplevel"]);
+    if (result.code !== 0) throw new WorktreeError("not-a-git-repo", path);
+    return real(result.stdout.trim());
+  }
+  /** Read `.veryhappy/worktree.json` from the source checkout (never followed outside it). */
+  readConfig(root, origin) {
+    const path$1 = path.join(root, ...CONFIG_RELATIVE_PATH.split("/"));
+    let info;
+    try {
+      info = node_fs.lstatSync(path$1);
+    } catch {
+      return parseWorktreeConfig(null, origin);
+    }
+    try {
+      const resolved = node_fs.realpathSync(path$1);
+      if (!isInside(real(root), resolved)) return { ...parseWorktreeConfig("{}", origin), source: "invalid", errors: [`${CONFIG_RELATIVE_PATH} points outside the repository`] };
+      const size = info.isSymbolicLink() ? node_fs.statSync(resolved).size : info.size;
+      if (size > CONFIG_MAX_BYTES) return { ...parseWorktreeConfig("{}", origin), source: "invalid", errors: [`${CONFIG_RELATIVE_PATH} exceeds ${CONFIG_MAX_BYTES} bytes`] };
+      return parseWorktreeConfig(node_fs.readFileSync(resolved, "utf8"), origin);
+    } catch (error) {
+      return { ...parseWorktreeConfig("{}", origin), source: "invalid", errors: [`${CONFIG_RELATIVE_PATH}: ${error instanceof Error ? error.message : String(error)}`] };
+    }
+  }
+  setupFor(root, origin) {
+    const resolved = this.readConfig(root, origin);
+    const selection = selectSetupScript(resolved.config, this.platform);
+    const hash = selection.kind === "script" ? setupScriptHash(selection.runner, selection.script) : null;
+    return { resolved, selection, hash };
+  }
+  async info(path$1) {
+    const root = await this.toplevel(requireAbsolute(path$1));
+    const [head, refs] = await Promise.all([
+      runGit(root, ["symbolic-ref", "--short", "-q", "HEAD"]),
+      runGit(root, ["for-each-ref", "--sort=-committerdate", `--count=${MAX_BRANCHES}`, "--format=%(refname:short)", "refs/heads"])
+    ]);
+    const { resolved, selection, hash } = this.setupFor(root, "web");
+    return {
+      repoRoot: root,
+      currentBranch: head.code === 0 ? head.stdout.trim() || null : null,
+      branches: refs.stdout.split("\n").map((line) => line.trim()).filter(Boolean),
+      defaultParent: path.join(path.dirname(root), `${path.basename(root)}.worktrees`),
+      config: {
+        source: resolved.source,
+        copy: resolved.config.copy,
+        link: resolved.config.link,
+        hasSetup: selection.kind !== "none",
+        setupApproved: hash ? this.store.isApproved(this.opts.machineId, root, hash) : false,
+        ...resolved.errors.length ? { error: resolved.errors.join("; ") } : {}
+      }
+    };
+  }
+  async create(params) {
+    const root = await this.toplevel(requireAbsolute(params.path));
+    const branch = typeof params.branch === "string" ? params.branch.trim() : "";
+    if (!branch || branch.length > 200 || branch.startsWith("-")) throw new WorktreeError("invalid-branch");
+    const refCheck = await runGit(root, ["check-ref-format", "--branch", branch]);
+    if (refCheck.code !== 0 || refCheck.stdout.trim() !== branch) throw new WorktreeError("invalid-branch", branch);
+    const baseRef = typeof params.baseRef === "string" && params.baseRef.trim() ? params.baseRef.trim() : "HEAD";
+    if (baseRef.startsWith("-")) throw new WorktreeError("invalid-base", baseRef);
+    const location = typeof params.location === "string" && params.location.trim() ? requireAbsolute(params.location.trim(), "location") : defaultWorktreeLocation(root, branch);
+    const existing = node_fs.existsSync(location) ? this.store.get(real(location)) : void 0;
+    if (existing && existing.origin === "web" && existing.repoRoot === root && existing.branch === branch) {
+      return { worktreePath: real(location), branch, baseRef: existing.baseRef ?? baseRef, init: summarize(existing), reused: true };
+    }
+    if ((await runGit(root, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])).code === 0) throw new WorktreeError("branch-exists", branch);
+    const base = await runGit(root, ["rev-parse", "--verify", "--quiet", `${baseRef}^{commit}`]);
+    if (base.code !== 0) throw new WorktreeError("invalid-base", baseRef);
+    if (node_fs.existsSync(location)) throw new WorktreeError("location-exists", location);
+    let ancestor = path.dirname(location);
+    while (!node_fs.existsSync(ancestor) && path.dirname(ancestor) !== ancestor) ancestor = path.dirname(ancestor);
+    if (isInside(root, real(ancestor)) || isInside(root, path.resolve(location))) throw new WorktreeError("location-inside-repo", location);
+    node_fs.mkdirSync(path.dirname(location), { recursive: true });
+    const added = await runGit(root, ["worktree", "add", "-b", branch, location, base.stdout.trim()], GIT_CREATE_TIMEOUT_MS);
+    if (added.code !== 0) {
+      await this.cleanupFailedAdd(root, location, branch);
+      throw new WorktreeError("git-worktree-add-failed", added.stderr.trim().slice(0, 500));
+    }
+    const worktreePath = real(location);
+    const record = await this.initialize({ source: root, worktree: worktreePath, branch, baseRef, origin: "web" });
+    return { worktreePath, branch, baseRef, init: summarize(record) };
+  }
+  /** Remove a half-made worktree + the branch this call created (it did not exist before). */
+  async cleanupFailedAdd(root, location, branch) {
+    if (node_fs.existsSync(location)) await runGit(root, ["worktree", "remove", "--force", location]);
+    await runGit(root, ["worktree", "prune"]);
+    if ((await runGit(root, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])).code === 0) {
+      await runGit(root, ["branch", "-D", branch]);
+    }
+  }
+  /**
+   * Copy → link → setup decision. Returns after materialization; an approved
+   * script keeps running in the background. Never throws for config problems.
+   */
+  async initialize(input) {
+    const source = real(input.source);
+    const worktree = real(input.worktree);
+    const record = {
+      repoRoot: source,
+      branch: input.branch,
+      baseRef: input.baseRef,
+      origin: input.origin,
+      createdAt: Date.now(),
+      copied: [],
+      linked: [],
+      skipped: [],
+      setup: { state: "none" }
+    };
+    this.store.put(worktree, record);
+    const { resolved, selection, hash } = this.setupFor(source, input.origin);
+    const errors = [];
+    const step = async (label, run, fallback) => {
+      try {
+        return await run();
+      } catch (error) {
+        errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`.slice(0, 300));
+        return fallback;
+      }
+    };
+    const copy = resolved.config.copy.length ? await step("copy", () => copyIntoWorktree(source, worktree, resolved.config.copy), { copied: [], skipped: [] }) : { copied: [], skipped: [] };
+    const link = resolved.config.link.length ? await step("link", () => linkIntoWorktree(source, worktree, resolved.config.link, this.platform), { linked: [], skipped: [] }) : { linked: [], skipped: [] };
+    Object.assign(record, {
+      copied: copy.copied,
+      linked: link.linked,
+      skipped: [...copy.skipped, ...link.skipped],
+      ...resolved.errors.length ? { configError: resolved.errors.join("; ") } : {},
+      ...errors.length ? { initError: errors.join("; ") } : {},
+      setup: selection.kind === "none" ? { state: "none" } : selection.kind === "unsupported" ? { state: "unsupported", message: selection.message } : { state: "needs-approval", hash, runner: selection.runner }
+    });
+    this.store.put(worktree, record);
+    if (selection.kind === "script" && hash && this.store.isApproved(this.opts.machineId, source, hash)) {
+      try {
+        return this.startRun(worktree, record, selection.script, selection.runner, hash, resolved.config.setupTimeoutMinutes);
+      } catch (error) {
+        return this.store.updateSetup(worktree, { state: "failed", message: error instanceof Error ? error.message : String(error) }) ?? record;
+      }
+    }
+    return record;
+  }
+  startRun(worktree, record, script, runner, hash, timeoutMinutes) {
+    const runId = `${Date.now().toString(36)}-${node_crypto.randomUUID().slice(0, 8)}`;
+    const active = new Set(Object.values(this.store.worktrees()).filter((r) => r.setup.state === "running" && r.setup.runId).map((r) => r.setup.runId));
+    try {
+      this.store.pruneRuns(active);
+    } catch (error) {
+      this.debug("[worktree] run pruning failed", error);
+    }
+    const runDir = this.store.runDir(runId);
+    const launch = prepareRunner(runDir, runner, script);
+    const handle = startSetupRun({
+      launch,
+      cwd: worktree,
+      env: sanitizeSetupEnv(this.opts.env ?? process.env, { worktree, root: record.repoRoot }),
+      logPath: this.store.logPath(runId),
+      timeoutMs: timeoutMinutes * 6e4
+    });
+    this.runs.set(worktree, handle);
+    const next = this.store.updateSetup(worktree, { state: "running", hash, runner, runId, pid: handle.pid, startedAt: Date.now(), endedAt: void 0, exitCode: void 0, message: void 0 });
+    void handle.done.then((outcome) => {
+      this.runs.delete(worktree);
+      this.store.updateSetup(worktree, { state: outcome.state, exitCode: outcome.exitCode, endedAt: Date.now(), message: outcome.message, ...outcome.truncated ? { truncated: true } : {} });
+    }).catch((error) => this.debug("[worktree] setup outcome not recorded", error));
+    return next;
+  }
+  status(path$1) {
+    const worktree = real(requireAbsolute(path$1));
+    const record = this.store.get(worktree);
+    if (!record) return { tracked: false };
+    const base = { tracked: true, worktreePath: worktree, origin: record.origin, branch: record.branch, repoRoot: record.repoRoot, copied: record.copied, linked: record.linked, skipped: record.skipped, ...record.configError ? { configError: record.configError } : {}, ...record.initError ? { initError: record.initError } : {}, setup: record.setup };
+    if (record.setup.state !== "needs-approval" && record.setup.state !== "declined") return base;
+    const { resolved, selection, hash } = this.setupFor(record.repoRoot, record.origin);
+    if (selection.kind !== "script" || !hash) return base;
+    return {
+      ...base,
+      pending: {
+        script: selection.script,
+        hash,
+        runner: selection.runner,
+        runnerLabel: describeRunner(selection.runner),
+        cwd: worktree,
+        repoRoot: record.repoRoot,
+        configPath: path.join(record.repoRoot, ...CONFIG_RELATIVE_PATH.split("/")),
+        timeoutMinutes: resolved.config.setupTimeoutMinutes,
+        changedSinceApproval: this.store.hasOtherApproval(this.opts.machineId, record.repoRoot, hash)
+      }
+    };
+  }
+  approve(path, hash) {
+    const worktree = real(requireAbsolute(path));
+    const record = this.store.get(worktree);
+    if (!record) throw new WorktreeError("not-tracked");
+    if (record.setup.state !== "needs-approval" && record.setup.state !== "declined") throw new WorktreeError("not-awaiting-approval", record.setup.state);
+    const { resolved, selection, hash: current2 } = this.setupFor(record.repoRoot, record.origin);
+    if (selection.kind !== "script" || !current2) throw new WorktreeError("no-setup-script");
+    if (typeof hash !== "string" || hash !== current2) throw new WorktreeError("script-changed");
+    this.store.approve({ machineId: this.opts.machineId, repoRoot: record.repoRoot, hash: current2, runner: selection.runner, approvedAt: Date.now() });
+    this.startRun(worktree, record, selection.script, selection.runner, current2, resolved.config.setupTimeoutMinutes);
+    return this.status(worktree);
+  }
+  decline(path) {
+    const worktree = real(requireAbsolute(path));
+    const record = this.store.get(worktree);
+    if (!record) throw new WorktreeError("not-tracked");
+    if (record.setup.state === "needs-approval") this.store.updateSetup(worktree, { state: "declined", endedAt: Date.now() });
+    return this.status(worktree);
+  }
+  log(path, offset) {
+    const worktree = real(requireAbsolute(path));
+    const record = this.store.get(worktree);
+    const runId = record?.setup.runId;
+    if (!record || !runId) return { text: "", offset: 0, size: 0, done: true };
+    const logPath = this.store.logPath(runId);
+    if (!node_fs.existsSync(logPath)) return { text: "", offset: 0, size: 0, done: record.setup.state !== "running" };
+    const size = node_fs.statSync(logPath).size;
+    const start = typeof offset === "number" && offset >= 0 && offset <= size ? Math.floor(offset) : 0;
+    const length = Math.min(LOG_CHUNK_BYTES, size - start);
+    const buffer = Buffer.alloc(length);
+    if (length > 0) {
+      const fd = node_fs.openSync(logPath, "r");
+      try {
+        node_fs.readSync(fd, buffer, 0, length, start);
+      } finally {
+        node_fs.closeSync(fd);
+      }
+    }
+    return { text: buffer.toString("utf8"), offset: start + length, size, done: record.setup.state !== "running" && start + length >= size };
+  }
+  async inspect(path$1) {
+    const worktree = real(requireAbsolute(path$1));
+    const record = this.store.get(worktree);
+    if (!record) return { removable: false, reason: "not-tracked", dirty: [], dirtyCount: 0, branch: null };
+    if (record.origin !== "web") return { removable: false, reason: `owned-by-${record.origin}`, dirty: [], dirtyCount: 0, branch: record.branch };
+    const gitFile = path.join(worktree, ".git");
+    if (!node_fs.existsSync(gitFile) || !node_fs.lstatSync(gitFile).isFile()) return { removable: false, reason: "not-a-linked-worktree", dirty: [], dirtyCount: 0, branch: record.branch };
+    const status = await runGit(worktree, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+    if (status.code !== 0) return { removable: false, reason: "git-status-failed", dirty: [], dirtyCount: 0, branch: record.branch };
+    const dirty = userDirtyPaths(parsePorcelainZ(status.stdout), record);
+    const head = await runGit(worktree, ["symbolic-ref", "--short", "-q", "HEAD"]);
+    return { removable: true, dirty: dirty.slice(0, MAX_DIRTY_LISTED), dirtyCount: dirty.length, dirtyFingerprint: dirtyFingerprint(worktree, dirty), branch: head.stdout.trim() || record.branch };
+  }
+  /**
+   * `expectedFingerprint` is what the user confirmed (inspect's
+   * `dirtyFingerprint`). If the changes moved since — new files, or an edit
+   * to a listed one — refuse with `changes-changed` and make them re-confirm.
+   * Residual window: between this final check and `git worktree remove`
+   * (milliseconds) an edit can still be lost; spec §5 accepts it.
+   */
+  async remove(path$1, discardChanges, expectedFingerprint) {
+    const worktree = real(requireAbsolute(path$1));
+    const inspection = await this.inspect(worktree);
+    if (!inspection.removable) throw new WorktreeError("not-removable", inspection.reason);
+    if (inspection.dirtyCount > 0 && discardChanges !== true) throw new WorktreeError("dirty", String(inspection.dirtyCount));
+    if (typeof expectedFingerprint === "string" && "dirtyFingerprint" in inspection && expectedFingerprint !== inspection.dirtyFingerprint) {
+      throw new WorktreeError("changes-changed", String(inspection.dirtyCount));
+    }
+    const record = this.store.get(worktree);
+    this.runs.get(worktree)?.stop();
+    for (const rel of record.linked) {
+      const target = path.join(worktree, ...rel.split("/"));
+      try {
+        const info = node_fs.lstatSync(target);
+        if (info.isSymbolicLink()) node_fs.unlinkSync(target);
+        else if (this.platform === "win32") node_fs.rmdirSync(target);
+      } catch {
+      }
+    }
+    const removed = await runGit(record.repoRoot, ["worktree", "remove", "--force", worktree], GIT_CREATE_TIMEOUT_MS);
+    if (removed.code !== 0) throw new WorktreeError("git-worktree-remove-failed", removed.stderr.trim().slice(0, 500));
+    this.store.remove(worktree);
+    return { removed: true, branch: inspection.branch };
+  }
+  /** Daemon shutdown: kill every running setup tree (recorded as interrupted). */
+  stopAll() {
+    for (const handle of this.runs.values()) handle.stop();
+  }
+}
+function dirtyFingerprint(worktree, dirty) {
+  const hash = node_crypto.createHash("sha256");
+  for (const rel of [...dirty].sort()) {
+    let meta = "missing";
+    try {
+      const info = node_fs.lstatSync(path.join(worktree, ...rel.split("/")));
+      meta = `${info.size}:${info.mtimeMs}`;
+    } catch {
+    }
+    hash.update(`${rel}\0${meta}
+`);
+  }
+  return hash.digest("hex").slice(0, 32);
+}
+function defaultProcessCommand(pid) {
+  try {
+    return node_child_process.execFileSync("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf8", timeout: 2e3 }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function summarize(record) {
+  return { copied: record.copied, linked: record.linked, skipped: record.skipped, ...record.configError ? { configError: record.configError } : {}, ...record.initError ? { initError: record.initError } : {}, setup: { state: record.setup.state, ...record.setup.message ? { message: record.setup.message } : {} } };
+}
+let current = null;
+function configureWorktreeService(opts) {
+  if (!current || current.store.dir !== new WorktreeStore(opts.home).dir) current = new WorktreeService(opts);
+  return current;
+}
+function currentWorktreeService() {
+  return current;
+}
+async function initializeOwnedWorktree(input) {
+  const service = currentWorktreeService();
+  if (!service) return;
+  try {
+    const source = await service.toplevel(input.source);
+    await service.initialize({ ...input, source, baseRef: null });
+  } catch (error) {
+    service.debug(`[worktree] ${input.origin} worktree initialization failed`, error);
+  }
+}
+
+function sanitizeGeometry(cols, rows) {
+  const ok = (v) => typeof v === "number" && Number.isInteger(v) && v >= 2 && v <= 1e4;
+  return ok(cols) && ok(rows) ? { cols, rows } : void 0;
+}
+function sanitizeTagList(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const tag of value) {
+    if (typeof tag !== "string") continue;
+    const clean = tag.trim();
+    if (clean && !out.includes(clean)) out.push(clean);
+    if (out.length >= 64) break;
+  }
+  return out;
+}
+const LIVE_SNAPSHOT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+const LIVE_SNAPSHOT_MAX = 100;
+function sanitizeLiveSnapshot(raw, now, ttlMs = LIVE_SNAPSHOT_TTL_MS, max = LIVE_SNAPSHOT_MAX) {
+  const out = /* @__PURE__ */ new Map();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return out;
+  const rows = [];
+  for (const [id, value] of Object.entries(raw)) {
+    if (!id || !value || typeof value !== "object") continue;
+    const { title, cwd, seenAt, tags, manual, attachTmux, cols: rawCols, rows: rawRows } = value;
+    if (typeof seenAt !== "number" || !Number.isFinite(seenAt)) continue;
+    if (now - seenAt >= ttlMs) continue;
+    const tagList = sanitizeTagList(tags);
+    rows.push([id, {
+      title: typeof title === "string" && title.trim() ? title : void 0,
+      cwd: typeof cwd === "string" && cwd ? cwd : void 0,
+      ...tagList !== void 0 ? { tags: tagList } : {},
+      ...manual === true ? { manual: true } : {},
+      ...typeof attachTmux === "string" && attachTmux ? { attachTmux } : {},
+      ...sanitizeGeometry(rawCols, rawRows) ?? {},
+      seenAt
+    }]);
+  }
+  rows.sort((a, b) => b[1].seenAt - a[1].seenAt);
+  for (const [id, info] of rows.slice(0, max)) out.set(id, info);
+  return out;
+}
+function serializeLiveSnapshot(map, max = LIVE_SNAPSHOT_MAX) {
+  const rows = [...map.entries()].sort((a, b) => b[1].seenAt - a[1].seenAt).slice(0, max);
+  const out = {};
+  for (const [id, info] of rows) out[id] = info;
+  return out;
+}
+function liveSnapshotChanged(prev, next) {
+  if (prev.size !== next.size) return true;
+  for (const [id, info] of next) {
+    const before = prev.get(id);
+    if (!before) return true;
+    if (before.title !== info.title || before.cwd !== info.cwd) return true;
+    if (!!before.manual !== !!info.manual) return true;
+    if ((before.attachTmux ?? "") !== (info.attachTmux ?? "")) return true;
+    if ((before.tags ?? []).join("\0") !== (info.tags ?? []).join("\0")) return true;
+    if (before.cols !== info.cols || before.rows !== info.rows) return true;
+  }
+  return false;
+}
+const CLAUDE_SESSION_ID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+function isClaudeSessionId(value) {
+  return typeof value === "string" && CLAUDE_SESSION_ID_RE.test(value);
+}
+function pickMirrorForTerminal(sessions, terminalId) {
+  if (!terminalId) return null;
+  let best = null;
+  for (const [id, session] of Object.entries(sessions || {})) {
+    const meta = session?.metadata;
+    if (!meta || meta.terminalId !== terminalId) continue;
+    const savedAt = typeof session.savedAt === "number" ? session.savedAt : 0;
+    if (best && savedAt <= best.savedAt) continue;
+    best = {
+      id,
+      savedAt,
+      claude: isClaudeSessionId(meta.claudeSessionId) ? meta.claudeSessionId : void 0
+    };
+  }
+  return best ? { sessionId: best.id, claudeSessionId: best.claude } : null;
+}
+
+const AGENT_CHECK_INTERVAL = 6 * 60 * 60 * 1e3;
+function stableVersion(value) {
+  const match = value.trim().match(/(?:^|\s|v)(\d+\.\d+\.\d+)([-+][\w.-]+)?(?=\s|$)/);
+  return match && !match[2] ? match[1] : null;
+}
+function newerVersion(current, latest) {
+  const a = current.split(".").map(Number), b = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (b[i] !== a[i]) return b[i] > a[i];
+  }
+  return false;
+}
+const runVersionCommand = (command, args, shell) => new Promise((resolve, reject) => {
+  node_child_process.execFile(
+    command,
+    args,
+    { timeout: 5e3, maxBuffer: 32 * 1024, windowsHide: true, shell },
+    (error, stdout) => error ? reject(error) : resolve(stdout)
+  );
+});
+async function probeAgentVersion(command, platform = process.platform, run = runVersionCommand) {
+  if (platform === "win32") {
+    try {
+      await run("where.exe", [command], false);
+    } catch (error) {
+      return { version: null, missing: error.code === 1 };
+    }
+  }
+  try {
+    return { version: stableVersion(await run(command, ["--version"], platform === "win32")), missing: false };
+  } catch (error) {
+    return { version: null, missing: error.code === "ENOENT" };
+  }
+}
+async function registryVersion(name) {
+  const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`, { signal: AbortSignal.timeout(5e3) });
+  if (!response.ok) throw new Error("Registry unavailable");
+  const data = await response.json();
+  return typeof data.version === "string" ? stableVersion(data.version) : null;
+}
+async function detectAgentVersions(deps = { probe: probeAgentVersion, registryVersion }, now = Date.now()) {
+  const agents = await Promise.all(index.AGENT_VERSION_SOURCES.map(async (source) => {
+    const local = source.command ? await deps.probe(source.command).catch(() => ({ version: null, missing: false })) : { version: stableVersion(_package.packageJson.dependencies["@anthropic-ai/claude-agent-sdk"]), missing: false };
+    if (local.missing) return { id: source.id, installed: null, latest: null, status: "not-installed" };
+    const latest = await deps.registryVersion(source.package).catch(() => null);
+    const installed = local.version;
+    const status = !installed || !latest ? "unknown" : newerVersion(installed, latest) ? "update-available" : "current";
+    return { id: source.id, installed, latest, status };
+  }));
+  return { checkedAt: now, daemonPid: process.pid, agents };
+}
+function startAgentVersionChecks(publish, onError, detect = detectAgentVersions) {
+  let stopped = false, pending = false;
+  async function refresh() {
+    if (stopped || pending) return;
+    pending = true;
+    try {
+      const snapshot = await detect();
+      if (!stopped) await publish(snapshot);
+    } catch (error) {
+      onError(error);
+    } finally {
+      pending = false;
+    }
+  }
+  void refresh();
+  const timer = setInterval(() => void refresh(), AGENT_CHECK_INTERVAL);
+  timer.unref();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+
+function parseTerminalHookPayload(body) {
+  if (!body || typeof body !== "object") return null;
+  const raw = body;
+  const eventName = raw.hook_event_name;
+  if (eventName !== "SessionStart" && eventName !== "SessionEnd") return null;
+  const claudeSessionId = typeof raw.session_id === "string" && raw.session_id.length > 0 ? raw.session_id : typeof raw.sessionId === "string" && raw.sessionId.length > 0 ? raw.sessionId : null;
+  if (!claudeSessionId) return null;
+  const terminalId = typeof raw.terminalId === "string" && raw.terminalId.length > 0 ? raw.terminalId : null;
+  if (!terminalId) return null;
+  return {
+    event: eventName,
+    claudeSessionId,
+    terminalId,
+    transcriptPath: typeof raw.transcript_path === "string" && raw.transcript_path.length > 0 ? raw.transcript_path : void 0,
+    cwd: typeof raw.cwd === "string" && raw.cwd.length > 0 ? raw.cwd : void 0,
+    source: typeof raw.source === "string" && raw.source.length > 0 ? raw.source : void 0
+  };
+}
+const FRESH_CONVERSATION_SOURCES = /* @__PURE__ */ new Set(["startup", "clear"]);
+function decideMirrorBinding(event, binding) {
+  if (event.event === "SessionEnd") {
+    if (!binding) return { action: "ignore", reason: "no binding for terminal" };
+    if (binding.claudeSessionId !== event.claudeSessionId) {
+      return { action: "ignore", reason: "stale SessionEnd for a superseded claude session" };
+    }
+    if (binding.status === "ended") return { action: "ignore", reason: "already ended" };
+    return { action: "end" };
+  }
+  if (!binding) return { action: "create" };
+  if (binding.status === "active" && binding.claudeSessionId === event.claudeSessionId) {
+    return { action: "ignore", reason: "duplicate SessionStart for the bound session" };
+  }
+  if (FRESH_CONVERSATION_SOURCES.has(event.source ?? "startup")) {
+    return { action: "create", replaces: binding };
+  }
+  return { action: "continue" };
+}
+function mirrorLineKey(message) {
+  if (message.type === "summary") return `summary-${message.leafUuid}`;
+  if (message.type === "user" || message.type === "assistant" || message.type === "system") {
+    return message.uuid;
+  }
+  return null;
+}
+function mirrorLocalId(lineKey, envelopeIndex) {
+  return `mirror:${lineKey}:${envelopeIndex}`;
+}
+function extractCompleteLines(buf) {
+  const lastNl = buf.lastIndexOf(10);
+  if (lastNl === -1) return { lines: [], consumedBytes: 0 };
+  const text = buf.subarray(0, lastNl).toString("utf-8");
+  const lines = text.split("\n").filter((l) => l.trim().length > 0);
+  return { lines, consumedBytes: lastNl + 1 };
+}
+const MIRROR_SEND_MAX_CHARS = 16384;
+function parseMirrorSendParams(params, isValidTerminalId) {
+  if (!params || typeof params !== "object") return { error: "invalid params" };
+  const { terminalId, text, submit } = params;
+  if (!isValidTerminalId(terminalId)) return { error: "invalid terminalId" };
+  if (typeof text !== "string" || text.length === 0) return { error: "text is required" };
+  if (text.length > MIRROR_SEND_MAX_CHARS) return { error: `text too long (max ${MIRROR_SEND_MAX_CHARS} chars)` };
+  return { terminalId, text, submit: submit !== false };
+}
+const MIRROR_BACKFILL_LINES_DEFAULT = 500;
+function decideBackfill(messages, maxLines) {
+  const cap = Math.max(0, Math.floor(maxLines));
+  if (messages.length <= cap) return { replay: messages, truncated: false };
+  return { replay: messages.slice(messages.length - cap), truncated: true };
+}
+
+exports.MIRROR_BACKFILL_LINES_DEFAULT = MIRROR_BACKFILL_LINES_DEFAULT;
+exports.WORKTREE_CAPABILITY_VERSION = WORKTREE_CAPABILITY_VERSION;
+exports.configureWorktreeService = configureWorktreeService;
+exports.currentWorktreeService = currentWorktreeService;
+exports.decideBackfill = decideBackfill;
+exports.decideMirrorBinding = decideMirrorBinding;
+exports.extractCompleteLines = extractCompleteLines;
+exports.initializeOwnedWorktree = initializeOwnedWorktree;
+exports.isClaudeSessionId = isClaudeSessionId;
+exports.liveSnapshotChanged = liveSnapshotChanged;
+exports.mirrorLineKey = mirrorLineKey;
+exports.mirrorLocalId = mirrorLocalId;
+exports.parseMirrorSendParams = parseMirrorSendParams;
+exports.parseTerminalHookPayload = parseTerminalHookPayload;
+exports.pickMirrorForTerminal = pickMirrorForTerminal;
+exports.registerWorktreeHandlers = registerWorktreeHandlers;
+exports.sanitizeLiveSnapshot = sanitizeLiveSnapshot;
+exports.sanitizeTagList = sanitizeTagList;
+exports.serializeLiveSnapshot = serializeLiveSnapshot;
+exports.stableVersion = stableVersion;
+exports.startAgentVersionChecks = startAgentVersionChecks;
+exports.summarizeSpawnSessionForLog = summarizeSpawnSessionForLog;