@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-BYFHHCFV.js

@@ -0,0 +1,601 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/worktree-root.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstatSync, mkdirSync, readFileSync, statfsSync } from "node:fs";
+import { userInfo } from "node:os";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+var WORKTREE_FREE_SPACE_MARGIN_BYTES = 256 * 1024 * 1024;
+function unescapeMountField(field) {
+  return field.replace(/\\([0-7]{3})/gu, (_match, octal) => String.fromCharCode(Number.parseInt(octal, 8)));
+}
+function procMountsType(path) {
+  let text;
+  try {
+    text = readFileSync("/proc/mounts", "utf8");
+  } catch {
+    return null;
+  }
+  const target = resolve(path);
+  let best = null;
+  for (const line of text.split("\n")) {
+    const fields = line.split(" ");
+    const point = unescapeMountField(fields[1] ?? "");
+    const type = fields[2];
+    if (point.length === 0 || type === void 0) continue;
+    const covers = target === point || target.startsWith(point === "/" ? "/" : `${point}/`);
+    if (covers && (best === null || point.length >= best.point.length)) best = { point, type };
+  }
+  return best?.type ?? null;
+}
+var HOST_WORKTREE_ROOT_FACTS = {
+  tmpfsCandidates() {
+    const runtime = process.env.XDG_RUNTIME_DIR;
+    return [...runtime !== void 0 && isAbsolute(runtime) ? [runtime] : [], "/dev/shm"];
+  },
+  filesystemType: procMountsType,
+  freeBytes(path) {
+    try {
+      const stats = statfsSync(path);
+      return stats.bavail * stats.bsize;
+    } catch {
+      return null;
+    }
+  },
+  workingTreeBytes(projectRoot) {
+    try {
+      const listing = execFileSync("git", ["-C", projectRoot, "ls-tree", "-r", "-l", "-z", "HEAD"], {
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 3e4,
+        maxBuffer: 256 * 1024 * 1024
+      }).toString("utf8");
+      let total = 0;
+      for (const entry of listing.split("\0")) {
+        const size = Number.parseInt(entry.slice(0, entry.indexOf("	")).trim().split(/\s+/u)[3] ?? "", 10);
+        if (Number.isSafeInteger(size)) total += size;
+      }
+      return total;
+    } catch {
+      return null;
+    }
+  },
+  userSegment() {
+    try {
+      return `clio-coder-${userInfo().uid}`;
+    } catch {
+      return "clio-coder";
+    }
+  }
+};
+function diskWorktreeParent(projectRoot) {
+  return join(projectRoot, ".clio-coder", "worktrees");
+}
+function repositoryKey(projectRoot) {
+  return createHash("sha256").update(projectRoot).digest("hex").slice(0, 16);
+}
+function tmpfsParent(base, projectRoot, facts) {
+  return join(base, facts.userSegment(), "worktrees", repositoryKey(projectRoot));
+}
+function customParent(base, projectRoot) {
+  return join(resolve(base), repositoryKey(projectRoot));
+}
+function allowedWorktreeParents(setting, projectRoot, facts = HOST_WORKTREE_ROOT_FACTS) {
+  const parents = [diskWorktreeParent(projectRoot)];
+  for (const base of facts.tmpfsCandidates()) parents.push(tmpfsParent(base, projectRoot, facts));
+  if (isAbsolute(setting)) parents.push(customParent(setting, projectRoot));
+  return parents;
+}
+function formatMiB(bytes) {
+  return `${Math.ceil(bytes / (1024 * 1024))} MiB`;
+}
+function shortOfSpace(base, projectRoot, facts) {
+  const tree = facts.workingTreeBytes(projectRoot);
+  const free = facts.freeBytes(base);
+  if (tree === null) return "the working tree could not be sized";
+  if (free === null) return `free space on ${base} could not be read`;
+  const needed = tree * 2 + WORKTREE_FREE_SPACE_MARGIN_BYTES;
+  return free >= needed ? null : `${base} has ${formatMiB(free)} free and a worktree needs ${formatMiB(needed)}`;
+}
+function resolveWorktreeRoot(input) {
+  const facts = input.facts ?? HOST_WORKTREE_ROOT_FACTS;
+  const disk = { parent: diskWorktreeParent(input.projectRoot), kind: "disk" };
+  const { setting } = input;
+  if (setting === "disk") return disk;
+  if (input.remoteEligible) {
+    return { ...disk, notice: "fleet nodes are configured, so task worktrees stay under the project root" };
+  }
+  if (isAbsolute(setting)) {
+    const short = shortOfSpace(setting, input.projectRoot, facts);
+    if (short !== null) return { ...disk, notice: `${short}; using the project root` };
+    return { parent: customParent(setting, input.projectRoot), kind: "path", base: resolve(setting) };
+  }
+  const reasons = [];
+  let sawTmpfs = false;
+  for (const base of facts.tmpfsCandidates()) {
+    const type = facts.filesystemType(base);
+    if (type !== "tmpfs") {
+      reasons.push(`${base} is ${type ?? "not a readable mount"}, not tmpfs`);
+      continue;
+    }
+    sawTmpfs = true;
+    const short = shortOfSpace(base, input.projectRoot, facts);
+    if (short !== null) {
+      reasons.push(short);
+      continue;
+    }
+    return { parent: tmpfsParent(base, input.projectRoot, facts), kind: "tmpfs", base };
+  }
+  if (setting === "auto" && !sawTmpfs) return disk;
+  return { ...disk, notice: `no usable tmpfs (${reasons.join("; ") || "no candidates"}); using the project root` };
+}
+function prepareWorktreeParent(resolved) {
+  if (resolved.kind === "disk" || resolved.base === void 0) return null;
+  const rel = relative(resolved.base, resolved.parent);
+  if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel))
+    return `${resolved.parent} is not under ${resolved.base}`;
+  const uid = typeof process.getuid === "function" ? process.getuid() : null;
+  let cursor = resolved.base;
+  for (const segment of rel.split(sep)) {
+    cursor = join(cursor, segment);
+    try {
+      mkdirSync(cursor, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        return `${cursor} could not be created: ${error.message}`;
+      }
+    }
+    let stats;
+    try {
+      stats = lstatSync(cursor);
+    } catch (error) {
+      return `${cursor} could not be inspected: ${error.message}`;
+    }
+    if (!stats.isDirectory()) return `${cursor} is not a plain directory`;
+    if (uid !== null && stats.uid !== uid) return `${cursor} belongs to another user`;
+    if ((stats.mode & 18) !== 0) return `${cursor} is writable by other users`;
+  }
+  return null;
+}
+
+// src/tools/task-worktree.ts
+init_esm_shims();
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync3,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { basename, dirname, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+
+// src/tools/process-lease.ts
+init_esm_shims();
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { hostname } from "node:os";
+function processSnapshot(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return { alive: false, birthToken: null };
+  try {
+    process.kill(pid, 0);
+  } catch (err) {
+    if (err.code !== "EPERM") return { alive: false, birthToken: null };
+  }
+  try {
+    const stat = readFileSync2(`/proc/${pid}/stat`, "utf8").trim();
+    const close = stat.lastIndexOf(")");
+    if (close > 0) {
+      const fields = stat.slice(close + 1).trim().split(/\s+/u);
+      if (fields[0] === "Z") return { alive: false, birthToken: fields[19] ?? null };
+      const startTicks = fields[19];
+      if (startTicks !== void 0 && /^\d+$/u.test(startTicks)) {
+        return { alive: true, birthToken: `linux:${startTicks}` };
+      }
+    }
+  } catch {
+  }
+  try {
+    const started = execFileSync2("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    }).trim();
+    if (started.length > 0) return { alive: true, birthToken: `ps:${started}` };
+  } catch {
+  }
+  return { alive: true, birthToken: null };
+}
+function currentProcessLease() {
+  return {
+    host: hostname(),
+    pid: process.pid,
+    birthToken: processSnapshot(process.pid).birthToken
+  };
+}
+function validProcessLease(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const lease = value;
+  return typeof lease.host === "string" && lease.host.length > 0 && typeof lease.pid === "number" && Number.isSafeInteger(lease.pid) && lease.pid > 0 && (lease.birthToken === null || typeof lease.birthToken === "string");
+}
+function ownerIsAlive(owner) {
+  if (owner.host !== hostname()) return true;
+  const snapshot = processSnapshot(owner.pid);
+  if (!snapshot.alive) return false;
+  if (owner.birthToken === null || snapshot.birthToken === null) return true;
+  return owner.birthToken === snapshot.birthToken;
+}
+
+// src/tools/task-worktree.ts
+var SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+var OWNER_FILE_SUFFIX = ".task-owner.json";
+var TASK_WORKTREE_KIND = "clio-coder-task-worktree";
+var LEGACY_TASK_WORKTREE_KIND = "clio-task-worktree";
+var COMMIT_IDENTITY = "clio-coder-task";
+function gitBytes(root, args) {
+  return execFileSync3("git", ["-C", root, ...args], {
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3e4
+  });
+}
+function git(root, args) {
+  return gitBytes(root, args).toString("utf8").trim();
+}
+function isCanonicalWorktreePathInside(parent, candidate) {
+  let canonicalParent;
+  let canonicalCandidate;
+  try {
+    canonicalParent = realpathSync(parent);
+  } catch {
+    canonicalParent = resolve2(parent);
+  }
+  try {
+    canonicalCandidate = realpathSync(candidate);
+  } catch {
+    canonicalCandidate = resolve2(candidate);
+  }
+  const rel = relative2(canonicalParent, canonicalCandidate);
+  return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute2(rel);
+}
+function commitWorktreePath(path, identity, message, excludedPaths = []) {
+  if (excludedPaths.length > 0) {
+    git(path, ["reset", "-q", "HEAD", "--", ...excludedPaths.map((entry) => `:(top,literal)${entry}`)]);
+  }
+  git(path, ["add", "-A", "--", ".", ...excludedPaths.map((entry) => `:(top,exclude,literal)${entry}`)]);
+  if (git(path, ["diff", "--cached", "--name-only", "-z"]).length === 0) return false;
+  git(path, [
+    "-c",
+    `user.name=${identity}`,
+    "-c",
+    `user.email=${identity}@local`,
+    "commit",
+    "-m",
+    message,
+    "--no-verify"
+  ]);
+  return true;
+}
+function worktreeBranchDiffStat(root, branch) {
+  try {
+    return git(root, ["diff", "--shortstat", `HEAD...${branch}`]) || "no changes";
+  } catch {
+    return "diff unavailable";
+  }
+}
+function protectedPathsChangedByWorktreeBranch(root, branch, protectedPaths) {
+  const canonical = realpathSync(root);
+  const protectedInside = protectedPaths.map((path) => resolve2(path)).filter((path) => {
+    const rel = relative2(canonical, path);
+    return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute2(rel);
+  });
+  if (protectedInside.length === 0) return [];
+  const changed = git(canonical, ["diff", "--name-only", "-z", "--no-renames", `HEAD...${branch}`]).split("\0").filter((path) => path.length > 0).map((path) => resolve2(canonical, path));
+  const blocked = /* @__PURE__ */ new Set();
+  for (const candidate of changed) {
+    for (const protectedPath of protectedInside) {
+      const rel = relative2(protectedPath, candidate);
+      if (candidate === protectedPath || rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute2(rel)) {
+        blocked.add(protectedPath);
+      }
+    }
+  }
+  return [...blocked].sort();
+}
+function mergeWorktreeBranch(root, branch, identity) {
+  try {
+    git(root, [
+      "-c",
+      `user.name=${identity}`,
+      "-c",
+      `user.email=${identity}@local`,
+      "merge",
+      "--no-edit",
+      "--no-verify",
+      branch
+    ]);
+    return { ok: true };
+  } catch (error) {
+    try {
+      git(root, ["merge", "--abort"]);
+    } catch {
+    }
+    return {
+      ok: false,
+      reason: error instanceof Error ? error.message.split("\n")[0] ?? "merge failed" : String(error)
+    };
+  }
+}
+function validateRunId(runId) {
+  if (!SAFE_RUN_ID.test(runId) || runId === "." || runId === "..")
+    throw new Error(`invalid task worktree run id '${runId}'`);
+}
+function gitCheckoutRoot(cwd) {
+  try {
+    return realpathSync(git(cwd, ["rev-parse", "--show-toplevel"]));
+  } catch {
+    return null;
+  }
+}
+function claimPathFor(root, runId) {
+  return join2(diskWorktreeParent(root), `${runId}${OWNER_FILE_SUFFIX}`);
+}
+function createTaskWorktree(root, runId, base, apply = "merge", worktreeParent) {
+  validateRunId(runId);
+  const canonical = realpathSync(root);
+  const resolvedBase = base ?? git(canonical, ["rev-parse", "HEAD"]);
+  const claimParent = diskWorktreeParent(canonical);
+  const parent = worktreeParent ?? claimParent;
+  const path = join2(parent, runId);
+  const branch = `clio-coder/task/${runId}`;
+  mkdirSync2(claimParent, { recursive: true });
+  mkdirSync2(parent, { recursive: true, mode: 448 });
+  if (!isCanonicalWorktreePathInside(parent, path))
+    throw new Error(`task worktree path escapes its parent for run ${runId}`);
+  git(canonical, ["worktree", "add", "-b", branch, path, resolvedBase]);
+  const ownerToken = randomBytes(16).toString("hex");
+  writeFileSync(
+    claimPathFor(canonical, runId),
+    `${JSON.stringify(
+      {
+        version: 2,
+        kind: TASK_WORKTREE_KIND,
+        root: canonical,
+        runId,
+        branch,
+        base: resolvedBase,
+        ownerToken,
+        // What restart recovery needs to tell a crashed run from a live one.
+        state: "active",
+        apply,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        owner: currentProcessLease(),
+        path
+      },
+      null,
+      2
+    )}
+`,
+    { encoding: "utf8", flag: "wx" }
+  );
+  return { root: canonical, runId, path, parent, branch, base: resolvedBase, ownerToken };
+}
+function assertOwnership(worktree) {
+  const parent = worktree.parent ?? diskWorktreeParent(worktree.root);
+  const expected = join2(parent, worktree.runId);
+  if (resolve2(worktree.path) !== resolve2(expected) || !isCanonicalWorktreePathInside(parent, worktree.path)) {
+    throw new Error(`task worktree ${worktree.runId} has an invalid ownership path`);
+  }
+  const ownerPath = claimPathFor(worktree.root, worktree.runId);
+  if (!existsSync(ownerPath)) throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+  let marker;
+  try {
+    const value = JSON.parse(readFileSync3(ownerPath, "utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("not an object");
+    marker = value;
+  } catch {
+    throw new Error(`task worktree ${worktree.runId} has an invalid ownership file`);
+  }
+  if (marker.version !== 1 && marker.version !== 2 || marker.kind !== TASK_WORKTREE_KIND && marker.kind !== LEGACY_TASK_WORKTREE_KIND || marker.root !== worktree.root || marker.runId !== worktree.runId || marker.branch !== worktree.branch || marker.base !== worktree.base || marker.ownerToken !== worktree.ownerToken || // A claim that names a path names this one; an older claim names none.
+  marker.path !== void 0 && marker.path !== worktree.path) {
+    throw new Error(`task worktree ${worktree.runId} ownership facts do not match`);
+  }
+}
+function commitTaskWorktree(worktree, message = `Clio Coder task ${worktree.runId}`) {
+  assertOwnership(worktree);
+  return commitWorktreePath(worktree.path, COMMIT_IDENTITY, message);
+}
+function taskWorktreeDiffHash(worktree) {
+  const bytes = gitBytes(worktree.root, ["diff", `${worktree.base}..${worktree.branch}`]);
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+function protectedPathsChangedByTaskBranch(worktree, protectedPaths) {
+  return protectedPathsChangedByWorktreeBranch(worktree.root, worktree.branch, protectedPaths);
+}
+function applyTaskWorktree(input) {
+  assertOwnership(input.worktree);
+  commitTaskWorktree(input.worktree);
+  const receipt = {
+    path: input.worktree.path,
+    branch: input.worktree.branch,
+    diffHash: taskWorktreeDiffHash(input.worktree),
+    apply: input.apply,
+    applied: false
+  };
+  if (input.apply === "preserve") return receipt;
+  const protectedChanges = protectedPathsChangedByTaskBranch(input.worktree, input.protectedPaths ?? []);
+  if (protectedChanges.length > 0) return { ...receipt, reason: "protected_artifact_changed" };
+  const merged = mergeWorktreeBranch(input.worktree.root, input.worktree.branch, COMMIT_IDENTITY);
+  if (!merged.ok) return { ...receipt, reason: "worktree_merge_conflict" };
+  return { ...receipt, applied: true };
+}
+function cleanupTaskWorktree(worktree, deleteBranch) {
+  assertOwnership(worktree);
+  try {
+    git(worktree.root, ["worktree", "remove", "--force", worktree.path]);
+  } catch {
+    if (existsSync(worktree.path)) rmSync(worktree.path, { recursive: true, force: true });
+    git(worktree.root, ["worktree", "prune"]);
+  }
+  if (deleteBranch) git(worktree.root, ["branch", "-D", worktree.branch]);
+  rmSync(claimPathFor(worktree.root, worktree.runId), { force: true });
+}
+function replaceMarker(ownerPath, marker) {
+  const temporary = `${ownerPath}.${randomBytes(6).toString("hex")}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(marker, null, 2)}
+`, { encoding: "utf8", flag: "wx" });
+  renameSync(temporary, ownerPath);
+}
+function settleTaskWorktree(worktree) {
+  assertOwnership(worktree);
+  const ownerPath = claimPathFor(worktree.root, worktree.runId);
+  const marker = JSON.parse(readFileSync3(ownerPath, "utf8"));
+  if (marker.version !== 2) return;
+  replaceMarker(ownerPath, { ...marker, state: "settled" });
+}
+function readTaskClaims(canonical, allowedParents) {
+  const parent = diskWorktreeParent(canonical);
+  let names;
+  try {
+    names = readdirSync(parent);
+  } catch {
+    return [];
+  }
+  const claims = [];
+  for (const name of names.sort()) {
+    if (!name.endsWith(OWNER_FILE_SUFFIX)) continue;
+    const runId = name.slice(0, -OWNER_FILE_SUFFIX.length);
+    if (!SAFE_RUN_ID.test(runId)) continue;
+    const ownerPath = join2(parent, name);
+    let marker;
+    try {
+      const value = JSON.parse(readFileSync3(ownerPath, "utf8"));
+      if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+      marker = value;
+    } catch {
+      continue;
+    }
+    const path = typeof marker.path === "string" ? marker.path : join2(parent, runId);
+    const pathParent = allowedParents.find((allowed) => resolve2(allowed) === resolve2(dirname(path)));
+    if (pathParent === void 0 || basename(path) !== runId) continue;
+    if (marker.version !== 1 && marker.version !== 2 || marker.kind !== TASK_WORKTREE_KIND && marker.kind !== LEGACY_TASK_WORKTREE_KIND || marker.root !== canonical || marker.runId !== runId || marker.branch !== `clio-coder/task/${runId}` && marker.branch !== `clio/task/${runId}` || typeof marker.base !== "string" || !/^[0-9a-f]{40,64}$/u.test(marker.base) || existsSync(path) && !isCanonicalWorktreePathInside(pathParent, path)) {
+      continue;
+    }
+    const state = marker.state === "settled" || marker.state === "abandoned" ? marker.state : "active";
+    claims.push({
+      runId,
+      path,
+      ownerPath,
+      marker,
+      branch: marker.branch,
+      base: marker.base,
+      state,
+      createdAt: typeof marker.createdAt === "string" ? marker.createdAt : null,
+      owner: marker.version === 2 && validProcessLease(marker.owner) ? marker.owner : null
+    });
+  }
+  return claims;
+}
+function workHeldBy(canonical, claim) {
+  try {
+    const commits = Number.parseInt(git(canonical, ["rev-list", "--count", `${claim.base}..${claim.branch}`]), 10);
+    if (!Number.isSafeInteger(commits)) return "its commits could not be counted";
+    if (commits > 0) {
+      return existsSync(claim.path) ? `${commits} commit(s) beyond its base` : `${commits} commit(s) beyond its base (its working tree is gone)`;
+    }
+    if (!existsSync(claim.path)) return null;
+    const dirty = git(claim.path, ["status", "--porcelain", "--untracked-files=all"]);
+    return dirty.length > 0 ? `${dirty.split("\n").length} uncommitted path(s)` : null;
+  } catch (error) {
+    return `git could not inspect it: ${error instanceof Error ? error.message.split("\n")[0] ?? "error" : String(error)}`;
+  }
+}
+function preservedView(claim, state, reason) {
+  return {
+    runId: claim.runId,
+    path: claim.path,
+    claimPath: claim.ownerPath,
+    branch: claim.branch,
+    base: claim.base,
+    state,
+    createdAt: claim.createdAt,
+    reason
+  };
+}
+function recoverTaskWorktrees(root, allowedParents) {
+  const result = { removed: [], preserved: [], failed: [] };
+  let canonical;
+  try {
+    canonical = realpathSync(root);
+  } catch {
+    return result;
+  }
+  for (const claim of readTaskClaims(canonical, allowedParents ?? [diskWorktreeParent(canonical)])) {
+    if (claim.state !== "active" || claim.owner === null || ownerIsAlive(claim.owner)) continue;
+    try {
+      const held = workHeldBy(canonical, claim);
+      if (held !== null) {
+        replaceMarker(claim.ownerPath, { ...claim.marker, state: "abandoned" });
+        result.preserved.push(preservedView(claim, "abandoned", held));
+        continue;
+      }
+      if (existsSync(claim.path)) git(canonical, ["worktree", "remove", "--force", claim.path]);
+      else git(canonical, ["worktree", "prune"]);
+      git(canonical, ["branch", "-D", claim.branch]);
+      rmSync(claim.ownerPath, { force: true });
+      result.removed.push(claim.runId);
+    } catch (error) {
+      result.failed.push({ runId: claim.runId, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return result;
+}
+function listPreservedTaskWorktrees(root, allowedParents) {
+  let canonical;
+  try {
+    canonical = realpathSync(root);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const claim of readTaskClaims(canonical, allowedParents ?? [diskWorktreeParent(canonical)])) {
+    if (claim.state === "settled") out.push(preservedView(claim, "settled", "kept by its run"));
+    else if (claim.state === "abandoned") out.push(preservedView(claim, "abandoned", "its owner died holding work"));
+    else if (claim.owner === null) out.push(preservedView(claim, "active", "its claim predates restart recovery"));
+    else if (!ownerIsAlive(claim.owner))
+      out.push(preservedView(claim, "active", "its owner is gone; the next start recovers it"));
+  }
+  return out;
+}
+
+export {
+  processSnapshot,
+  currentProcessLease,
+  validProcessLease,
+  ownerIsAlive,
+  HOST_WORKTREE_ROOT_FACTS,
+  diskWorktreeParent,
+  allowedWorktreeParents,
+  resolveWorktreeRoot,
+  prepareWorktreeParent,
+  isCanonicalWorktreePathInside,
+  commitWorktreePath,
+  worktreeBranchDiffStat,
+  protectedPathsChangedByWorktreeBranch,
+  mergeWorktreeBranch,
+  gitCheckoutRoot,
+  createTaskWorktree,
+  applyTaskWorktree,
+  cleanupTaskWorktree,
+  settleTaskWorktree,
+  recoverTaskWorktrees,
+  listPreservedTaskWorktrees
+};
+//# sourceMappingURL=chunk-BYFHHCFV.js.map

package/dist/chunk-C2CPOIH2.js

@@ -0,0 +1,83 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  canonicalizeRawPath
+} from "./chunk-MGLRTOCK.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/path-utils.ts
+init_esm_shims();
+import { accessSync, constants } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, sep } from "node:path";
+function toPosixPath(value) {
+  return value.split(sep).join("/");
+}
+var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+var NARROW_NO_BREAK_SPACE = "\u202F";
+function normalizeUnicodeSpaces(value) {
+  return value.replace(UNICODE_SPACES, " ");
+}
+function fileExists(filePath) {
+  try {
+    accessSync(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeAtPrefix(filePath) {
+  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+}
+function tryMacOSScreenshotPath(filePath) {
+  return filePath.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`);
+}
+function tryNfdVariant(filePath) {
+  return filePath.normalize("NFD");
+}
+function tryCurlyQuoteVariant(filePath) {
+  return filePath.replace(/'/g, "\u2019");
+}
+function normalizeToolPath(filePath) {
+  return normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
+}
+function expandPath(filePath) {
+  const normalized = normalizeToolPath(filePath);
+  if (normalized === "~") return homedir();
+  if (normalized.startsWith("~/")) return homedir() + normalized.slice(1);
+  return normalized;
+}
+function resolveToCwd(filePath, cwd = process.cwd()) {
+  return resolveMutationTarget(filePath, cwd).path;
+}
+function resolveMutationTarget(filePath, cwd = process.cwd()) {
+  const expanded = expandPath(filePath);
+  const physical = canonicalizeRawPath(expanded, cwd);
+  if (physical !== null) return { path: physical, physical };
+  return { path: isAbsolute(expanded) ? expanded : `${cwd}${sep}${expanded}`, physical: void 0 };
+}
+function readPathVariants(resolved) {
+  const nfd = tryNfdVariant(resolved);
+  const variants = [tryMacOSScreenshotPath(resolved), nfd, tryCurlyQuoteVariant(resolved), tryCurlyQuoteVariant(nfd)];
+  return [...new Set(variants)].filter((variant) => variant !== resolved);
+}
+function resolveReadPath(filePath, cwd = process.cwd()) {
+  const resolved = resolveToCwd(filePath, cwd);
+  if (fileExists(resolved)) return resolved;
+  for (const variant of readPathVariants(resolved)) {
+    if (fileExists(variant)) return variant;
+  }
+  return resolved;
+}
+
+export {
+  toPosixPath,
+  normalizeToolPath,
+  expandPath,
+  resolveToCwd,
+  resolveMutationTarget,
+  readPathVariants,
+  resolveReadPath
+};
+//# sourceMappingURL=chunk-C2CPOIH2.js.map