@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-RCQYT2I4.js

@@ -0,0 +1,757 @@
+import {
+  buildChildEnv
+} from "./chunk-VB3H5WWB.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/worktree/worktree-manager.ts
+import { mkdir, readFile } from "node:fs/promises";
+import { join, resolve as resolve3, sep as sep3 } from "node:path";
+
+// src/worktree/worktree-git.ts
+import { spawn } from "node:child_process";
+import { resolve, sep } from "node:path";
+var MAX_SLUG = 40;
+function makeSlug(hint, usedSlugs) {
+  let base = hint.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+/, "").replace(/[-.]+$/, "").slice(0, MAX_SLUG).replace(/[-.]+$/, "");
+  if (!base) base = "wt";
+  let slug = `${base}-${crypto.randomUUID().slice(0, 6)}`;
+  while (usedSlugs.has(slug)) slug = `${base}-${crypto.randomUUID().slice(0, 6)}`;
+  usedSlugs.add(slug);
+  return slug;
+}
+async function collectStats(runGit, dir) {
+  const sha = (await runGit(["rev-parse", "HEAD"], dir)).stdout.trim();
+  const numstat = await runGit(["show", "--numstat", "--format=", "HEAD"], dir);
+  let insertions = 0;
+  let deletions = 0;
+  let files = 0;
+  for (const line of numstat.stdout.split("\n")) {
+    const m = line.trim().match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+    if (!m) continue;
+    files++;
+    if (m[1] !== "-") insertions += Number(m[1]);
+    if (m[2] !== "-") deletions += Number(m[2]);
+  }
+  return { insertions, deletions, files, sha };
+}
+async function identityArgs(runGit, cwd) {
+  const name = (await runGit(["config", "user.name"], cwd)).stdout.trim();
+  const email = (await runGit(["config", "user.email"], cwd)).stdout.trim();
+  if (name && email) return [];
+  return ["-c", `user.name=${name || "Goal"}`, "-c", `user.email=${email || "goal@agent.local"}`];
+}
+function defaultRun(gitBin, args, cwd) {
+  return new Promise((res) => {
+    let stdout = "";
+    let stderr = "";
+    const MAX_GIT_OUTPUT = 1e6;
+    const child = spawn(gitBin, args, {
+      cwd,
+      env: buildChildEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: AbortSignal.timeout(3e4),
+      windowsHide: true
+    });
+    child.stdout?.on("data", (c) => {
+      if (stdout.length < MAX_GIT_OUTPUT) stdout += c.toString();
+    });
+    child.stderr?.on("data", (c) => {
+      if (stderr.length < MAX_GIT_OUTPUT) stderr += c.toString();
+    });
+    child.on("error", (err) => res({ code: 1, stdout, stderr: err.message }));
+    child.on("close", (code) => res({ code: code ?? 1, stdout, stderr }));
+  });
+}
+function parseConflictPaths(output) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of output.split("\n")) {
+    const m = line.match(/^CONFLICT \([^)]*\): Merge conflict in (.+?)\s*$/);
+    if (m?.[1]) paths.add(m[1]);
+  }
+  return [...paths];
+}
+function assertSafePath(dir, projectRoot) {
+  const root = resolve(projectRoot);
+  const abs = resolve(dir);
+  if (abs !== root && !abs.startsWith(root + sep)) {
+    throw new Error(`worktree path escapes project root: ${dir}`);
+  }
+}
+
+// src/worktree/worktree-managed-ops.ts
+import { resolve as resolve2, sep as sep2 } from "node:path";
+async function cleanupAllManaged(ctx) {
+  const root = resolve2(ctx.worktreesRoot);
+  let removed = 0;
+  try {
+    const listed = await ctx.runGit(["worktree", "list", "--porcelain"], ctx.projectRoot);
+    for (const line of listed.stdout.split("\n")) {
+      const m = line.match(/^worktree\s+(.+?)\s*$/);
+      if (!m?.[1]) continue;
+      const dir = resolve2(m[1]);
+      if (dir !== root && (dir === root || dir.startsWith(root + sep2))) {
+        const rm = await ctx.runGit(["worktree", "remove", "--force", dir], ctx.projectRoot);
+        if (rm.code === 0) removed++;
+      }
+    }
+  } catch {
+  }
+  try {
+    const branches = await ctx.runGit(
+      ["branch", "--list", "--format=%(refname:short)", "wstack/ap/*"],
+      ctx.projectRoot
+    );
+    for (const b of branches.stdout.split("\n").map((s) => s.trim()).filter(Boolean)) {
+      await ctx.runGit(["branch", "-D", b], ctx.projectRoot);
+    }
+  } catch {
+  }
+  await ctx.runGit(["worktree", "prune"], ctx.projectRoot).catch(() => void 0);
+  ctx.handles.clear();
+  ctx.usedSlugs.clear();
+  ctx.emit("worktree.released", {
+    handleId: "cleanup-all",
+    ownerId: "cleanup-all",
+    branch: "wstack/ap/*",
+    kept: false
+  });
+  return { removed };
+}
+async function listManaged(ctx) {
+  const root = resolve2(ctx.worktreesRoot);
+  const worktrees = [];
+  try {
+    const listed = await ctx.runGit(["worktree", "list", "--porcelain"], ctx.projectRoot);
+    let curDir = null;
+    let curBranch;
+    const flush = () => {
+      if (curDir) {
+        const d = resolve2(curDir);
+        if (d !== root && d.startsWith(root + sep2)) {
+          worktrees.push({ dir: curDir, branch: curBranch });
+        }
+      }
+      curDir = null;
+      curBranch = void 0;
+    };
+    for (const line of listed.stdout.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        flush();
+        curDir = line.slice("worktree ".length).trim();
+      } else if (line.startsWith("branch ")) {
+        curBranch = line.slice("branch ".length).trim().replace(/^refs\/heads\//, "");
+      } else if (line.trim() === "") {
+        flush();
+      }
+    }
+    flush();
+  } catch {
+  }
+  let branches = [];
+  try {
+    const b = await ctx.runGit(
+      ["branch", "--list", "--format=%(refname:short)", "wstack/ap/*"],
+      ctx.projectRoot
+    );
+    branches = b.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch {
+  }
+  return { worktrees, branches };
+}
+async function removeOne(ctx, dir, branch) {
+  const root = resolve2(ctx.worktreesRoot);
+  const abs = resolve2(dir);
+  if (abs === root || !abs.startsWith(root + sep2)) {
+    return { removed: false };
+  }
+  let removed = false;
+  try {
+    const rm = await ctx.runGit(["worktree", "remove", "--force", abs], ctx.projectRoot);
+    removed = rm.code === 0;
+  } catch {
+  }
+  if (branch && !branch.startsWith("-")) {
+    await ctx.runGit(["branch", "-D", "--", branch], ctx.projectRoot).catch(() => void 0);
+  }
+  await ctx.runGit(["worktree", "prune"], ctx.projectRoot).catch(() => void 0);
+  for (const [ownerId, h] of [...ctx.handles]) {
+    if (resolve2(h.dir) === abs) ctx.handles.delete(ownerId);
+  }
+  return { removed };
+}
+async function cleanupStale(ctx) {
+  const root = resolve2(ctx.worktreesRoot);
+  let detected = 0;
+  try {
+    const listed = await ctx.runGit(["worktree", "list", "--porcelain"], ctx.projectRoot);
+    for (const line of listed.stdout.split("\n")) {
+      const m = line.match(/^worktree\s+(.+?)\s*$/);
+      if (!m?.[1]) continue;
+      const dir = resolve2(m[1]);
+      if (dir !== root && (dir === root || dir.startsWith(root + sep2))) {
+        detected++;
+      }
+    }
+  } catch {
+    return { removed: 0, detected: 0 };
+  }
+  if (detected === 0) {
+    try {
+      const branches = await ctx.runGit(
+        ["branch", "--list", "--format=%(refname:short)", "wstack/ap/*"],
+        ctx.projectRoot
+      );
+      detected += branches.stdout.split("\n").map((s) => s.trim()).filter(Boolean).length;
+    } catch {
+    }
+  }
+  if (detected === 0) {
+    return { removed: 0, detected: 0 };
+  }
+  const { removed } = await cleanupAllManaged(ctx);
+  return { removed, detected };
+}
+
+// src/worktree/worktree-manager.ts
+var WorktreeManager = class {
+  projectRoot;
+  events;
+  sessionIdSource;
+  gitBin;
+  runGit;
+  /** Keyed by ownerId. */
+  handles = /* @__PURE__ */ new Map();
+  usedSlugs = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.projectRoot = resolve3(opts.projectRoot);
+    this.events = opts.events;
+    this.sessionIdSource = opts.sessionId;
+    this.gitBin = opts.gitBin ?? "git";
+    this.runGit = opts.run ?? ((args, cwd) => this.defaultRun(args, cwd));
+  }
+  /** Create a fresh worktree + branch forked from the current base branch. */
+  async allocate(ownerId, opts = {}) {
+    const existing = this.handles.get(ownerId);
+    if (existing && (existing.status === "allocating" || existing.status === "active")) {
+      return existing;
+    }
+    const slug = this.makeSlug(opts.slugHint ?? ownerId);
+    const branch = `wstack/ap/${slug}`;
+    const dir = join(this.worktreesRoot(), slug);
+    const absDir = resolve3(dir);
+    const absRoot = resolve3(this.projectRoot);
+    if (!absDir.startsWith(absRoot + sep3)) {
+      throw new Error(`Worktree dir "${absDir}" resolves outside project root`);
+    }
+    const baseBranch = opts.baseBranch ?? await this.detectBaseBranch();
+    const handle = {
+      id: slug,
+      ownerId,
+      ownerLabel: opts.ownerLabel ?? opts.slugHint ?? ownerId,
+      slug,
+      dir,
+      branch,
+      baseBranch,
+      status: "allocating",
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      insertions: 0,
+      deletions: 0,
+      files: 0
+    };
+    this.handles.set(ownerId, handle);
+    try {
+      await mkdir(this.worktreesRoot(), { recursive: true });
+      const res = await this.runGit(
+        ["worktree", "add", "-b", branch, dir, baseBranch],
+        this.projectRoot
+      );
+      if (res.code !== 0) {
+        return this.fail(handle, res.stderr || "git worktree add failed");
+      }
+    } catch (err) {
+      return this.fail(handle, toErrorMessage(err));
+    }
+    this.setStatus(handle, "active");
+    this.emit("worktree.allocated", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      ownerLabel: handle.ownerLabel,
+      slug: handle.slug,
+      dir: handle.dir,
+      branch: handle.branch,
+      baseBranch: handle.baseBranch
+    });
+    return handle;
+  }
+  /** Stage everything and commit inside the worktree. */
+  async commitAll(handle, message) {
+    this.setStatus(handle, "committing");
+    await this.runGit(["add", "-A"], handle.dir);
+    const staged = await this.runGit(["diff", "--cached", "--quiet"], handle.dir);
+    if (staged.code === 0) {
+      this.emitCommitted(handle, false);
+      return { committed: false };
+    }
+    const idArgs = await this.identityArgs(handle.dir);
+    const committed = await this.runGit([...idArgs, "commit", "-m", message], handle.dir);
+    if (committed.code !== 0) {
+      this.fail(handle, committed.stderr || "git commit failed");
+      return { committed: false };
+    }
+    const stats = await this.collectStats(handle.dir);
+    handle.insertions = stats.insertions;
+    handle.deletions = stats.deletions;
+    handle.files = stats.files;
+    handle.sha = stats.sha;
+    handle.updatedAt = Date.now();
+    this.emitCommitted(handle, true);
+    return { committed: true };
+  }
+  /** Merge the worktree branch back into the base branch (squash by default). */
+  async merge(handle, opts = {}) {
+    const squash = opts.squash ?? true;
+    this.setStatus(handle, "merging");
+    const status = await this.runGit(
+      ["status", "--porcelain", "--untracked-files=no"],
+      this.projectRoot
+    );
+    if (status.stdout.trim().length > 0) {
+      const reason = "working tree has uncommitted changes \u2014 commit or stash first";
+      this.fail(handle, reason);
+      return { ok: false, stderr: reason };
+    }
+    const checkout = await this.runGit(["checkout", handle.baseBranch], this.projectRoot);
+    if (checkout.code !== 0) {
+      this.fail(handle, checkout.stderr || `checkout ${handle.baseBranch} failed`);
+      return { ok: false, stderr: checkout.stderr };
+    }
+    const mergeArgs = squash ? ["merge", "--squash", handle.branch] : ["merge", "--no-ff", handle.branch];
+    const merged = await this.runGit(mergeArgs, this.projectRoot);
+    const fromOutput = parseConflictPaths(`${merged.stdout}
+${merged.stderr}`);
+    const fromIndex = await this.unmergedFiles();
+    const conflictFiles = [.../* @__PURE__ */ new Set([...fromOutput, ...fromIndex])];
+    if (merged.code !== 0 || conflictFiles.length > 0) {
+      if (opts.resolve) {
+        const finalized = await this.tryResolveConflict(handle, conflictFiles, opts);
+        if (finalized) return finalized;
+      }
+      await this.runGit(["reset", "--hard", "HEAD"], this.projectRoot);
+      handle.conflictFiles = conflictFiles;
+      this.setStatus(handle, "needs-review", { lastError: merged.stderr });
+      this.emit("worktree.conflict", {
+        handleId: handle.id,
+        ownerId: handle.ownerId,
+        branch: handle.branch,
+        conflictFiles
+      });
+      return { ok: false, conflict: true, conflictFiles, stderr: merged.stderr };
+    }
+    if (squash) {
+      const msg = opts.message ?? `merge ${handle.branch} (squash)`;
+      const idArgs = await this.identityArgs(this.projectRoot);
+      const commit = await this.runGit([...idArgs, "commit", "-m", msg], this.projectRoot);
+      if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
+        this.fail(handle, commit.stderr || "squash commit failed");
+        return { ok: false, stderr: commit.stderr };
+      }
+    }
+    this.setStatus(handle, "merged");
+    this.emit("worktree.merged", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      baseBranch: handle.baseBranch,
+      squash
+    });
+    return { ok: true };
+  }
+  /**
+   * Current tip SHA of a handle's base branch (without checking it out). Capture
+   * this before a merge so a regressed merge can be reverted to exactly this
+   * commit — unambiguous even when a squash produced no diff. Returns null on
+   * failure (caller then skips the revert).
+   */
+  async baseHead(handle) {
+    const res = await this.runGit(["rev-parse", handle.baseBranch], this.projectRoot);
+    const sha = res.stdout.trim();
+    return res.code === 0 && sha ? sha : null;
+  }
+  /**
+   * Hard-reset the base branch back to `sha` (a value previously returned by
+   * {@link baseHead}). Used to undo a squash-merge whose integrated result failed
+   * re-verification, so an auto-resolved-but-broken merge never sticks on base.
+   * Safe because SDD merges are serialized — no other commit lands in between.
+   */
+  async revertBaseTo(handle, sha) {
+    const status = await this.runGit(["status", "--porcelain"], this.projectRoot);
+    if (status.code !== 0) return false;
+    const hasTrackedDirt = status.stdout.split("\n").some((line) => line.trim().length > 0 && !line.startsWith("??"));
+    if (hasTrackedDirt) return false;
+    const co = await this.runGit(["checkout", handle.baseBranch], this.projectRoot);
+    if (co.code !== 0) return false;
+    const reset = await this.runGit(["reset", "--hard", sha], this.projectRoot);
+    return reset.code === 0;
+  }
+  /**
+   * Current base branch + tip SHA, captured WITHOUT a handle. The SDD run calls
+   * this once at start so a later rollback knows which branch the run's squash
+   * commits landed on. Returns null when not in a usable git state.
+   */
+  async currentBase() {
+    const branch = await this.detectBaseBranch();
+    const head = await this.runGit(["rev-parse", "HEAD"], this.projectRoot);
+    const sha = head.stdout.trim();
+    return head.code === 0 && sha ? { branch, sha } : null;
+  }
+  /**
+   * Force-remove EVERY managed worktree + branch this project owns, without
+   * relying on the in-memory `handles` map — so it works post-run (a fresh
+   * manager can clean up a previous run's leftovers). Enumerates
+   * `git worktree list --porcelain`, removes every checkout living under the
+   * `.wrongstack/worktrees` root, deletes every `wstack/ap/*` branch, then prunes.
+   * Returns the number of worktrees removed. Never throws — best-effort cleanup.
+   */
+  async cleanupAllManaged() {
+    return cleanupAllManaged(this.managedOpsContext());
+  }
+  /**
+   * Read-only inventory of this project's managed git artifacts: every worktree
+   * checkout under the `.wrongstack/worktrees` root (with its branch, when the
+   * checkout has one) plus every `wstack/ap/*` branch. Unlike `cleanupStale` /
+   * `cleanupAllManaged` this removes nothing — it powers the WebUI worktree panel
+   * so the user can SEE orphans before deciding to clean them. Never throws.
+   */
+  async listManaged() {
+    return listManaged(this.managedOpsContext());
+  }
+  /**
+   * Force-remove ONE managed worktree + (optionally) its branch — the targeted
+   * counterpart to `cleanupAllManaged`. Used by the WebUI worktree panel's
+   * per-row Remove/Discard. Path-guarded so only checkouts under the project's
+   * worktrees root can be removed. Best-effort; never throws.
+   */
+  async removeOne(dir, branch) {
+    return removeOne(this.managedOpsContext(), dir, branch);
+  }
+  /**
+   * Squash-merge an arbitrary `wstack/ap/*` branch into the base branch from the
+   * main checkout — the handle-free counterpart to {@link merge}, used by the
+   * WebUI worktree panel's per-row "Merge to base". On conflict it hard-resets
+   * the base tree (never leaves it dirty) and reports the conflicted paths.
+   * Refuses on a dirty base tree so uncommitted work is never clobbered.
+   */
+  async mergeBranch(branch, baseBranch) {
+    const base = baseBranch ?? await this.detectBaseBranch();
+    if (branch.startsWith("-") || base.startsWith("-")) {
+      return { ok: false, reason: "invalid ref" };
+    }
+    const status = await this.runGit(["status", "--porcelain"], this.projectRoot);
+    if (status.stdout.trim().length > 0) {
+      return { ok: false, reason: "working tree has uncommitted changes \u2014 commit or stash first" };
+    }
+    const co = await this.runGit(["checkout", base], this.projectRoot);
+    if (co.code !== 0) {
+      return { ok: false, reason: co.stderr || `checkout ${base} failed` };
+    }
+    const merged = await this.runGit(["merge", "--squash", branch], this.projectRoot);
+    if (merged.code !== 0) {
+      const fromOutput = parseConflictPaths(`${merged.stdout}
+${merged.stderr}`);
+      const fromIndex = await this.unmergedFiles();
+      const conflictFiles = [.../* @__PURE__ */ new Set([...fromOutput, ...fromIndex])];
+      await this.runGit(["reset", "--hard", "HEAD"], this.projectRoot).catch(() => void 0);
+      return {
+        ok: false,
+        conflict: true,
+        conflictFiles,
+        reason: merged.stderr || "merge conflict"
+      };
+    }
+    const idArgs = await this.identityArgs(this.projectRoot);
+    const commit = await this.runGit(
+      [...idArgs, "commit", "-m", `merge ${branch} (squash)`],
+      this.projectRoot
+    );
+    if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
+      return { ok: false, reason: commit.stderr || "squash commit failed" };
+    }
+    return { ok: true };
+  }
+  /**
+   * Compact change summary for a worktree checkout: working-tree edits
+   * (numstat vs HEAD) + commit count ahead of `baseBranch`. Powers the panel's
+   * "View changes" without streaming a full diff. Never throws.
+   */
+  async diffSummary(dir, baseBranch) {
+    const files = [];
+    let insertions = 0;
+    let deletions = 0;
+    let commits = 0;
+    try {
+      const numstat = await this.runGit(["diff", "--numstat", "HEAD"], dir);
+      for (const line of numstat.stdout.split("\n")) {
+        const m = line.trim().match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+        if (!m) continue;
+        const ins = m[1] === "-" ? 0 : Number(m[1]);
+        const del = m[2] === "-" ? 0 : Number(m[2]);
+        files.push({ path: m[3], insertions: ins, deletions: del });
+        insertions += ins;
+        deletions += del;
+      }
+    } catch {
+    }
+    try {
+      const base = baseBranch ?? await this.detectBaseBranch();
+      const count = await this.runGit(["rev-list", "--count", `${base}..HEAD`], dir);
+      commits = Number(count.stdout.trim()) || 0;
+    } catch {
+    }
+    return { files, insertions, deletions, commits };
+  }
+  /**
+   * Detect and clean up stale worktrees left behind by crashed subagents.
+   *
+   * P2 #B6 (sprint2 audit): when a subagent crashes (OOM, SIGKILL), its
+   * worktree checkout and branch remain on disk. `cleanupAllManaged()`
+   * sweeps everything, but is never called automatically — only via
+   * `/worktree clean`. This method runs on Director boot (or any other
+   * entry point) to clean up leftovers from a previous crashed run.
+   *
+   * Unlike `cleanupAllManaged()`, this method is a no-op when no stale
+   * worktrees are detected — it doesn't clear in-memory handles or emit
+   * events unnecessarily. When stale worktrees ARE found, it delegates
+   * to `cleanupAllManaged()` for the actual removal.
+   *
+   * Returns the number of stale worktrees removed (0 = clean).
+   */
+  async cleanupStale() {
+    return cleanupStale(this.managedOpsContext());
+  }
+  /**
+   * Undo a run's squash commits by reverting each (newest → oldest) on the base
+   * branch — history-preserving, never a destructive reset. Refuses on a dirty
+   * working tree (so uncommitted work is never clobbered) and aborts cleanly if a
+   * revert conflicts, reporting which SHA. `shas` are the run commit SHAs in the
+   * order they landed; this reverses them. Returns the count reverted.
+   */
+  async revertCommits(baseBranch, shas) {
+    if (shas.length === 0) return { ok: true, reverted: 0, reason: "nothing to revert" };
+    const status = await this.runGit(["status", "--porcelain"], this.projectRoot);
+    if (status.stdout.trim().length > 0) {
+      return {
+        ok: false,
+        reverted: 0,
+        reason: "working tree has uncommitted changes \u2014 commit or stash first"
+      };
+    }
+    const co = await this.runGit(["checkout", baseBranch], this.projectRoot);
+    if (co.code !== 0) {
+      return { ok: false, reverted: 0, reason: co.stderr || `checkout ${baseBranch} failed` };
+    }
+    const idArgs = await this.identityArgs(this.projectRoot);
+    let reverted = 0;
+    for (const sha of [...shas].reverse()) {
+      const res = await this.runGit([...idArgs, "revert", "--no-edit", sha], this.projectRoot);
+      if (res.code !== 0) {
+        await this.runGit(["revert", "--abort"], this.projectRoot).catch(() => void 0);
+        return {
+          ok: false,
+          reverted,
+          reason: `revert of ${sha.slice(0, 8)} failed: ${(res.stderr || res.stdout).trim().split("\n")[0] ?? "conflict"}`
+        };
+      }
+      reverted++;
+    }
+    return { ok: true, reverted };
+  }
+  /**
+   * Run the caller-supplied resolver against a conflicted squash-merge, then
+   * commit if it cleared every marker. Returns a successful `MergeResult` on a
+   * clean resolution, or `null` to signal the caller should fall back to the
+   * abort path. Never leaves the base tree committed-but-dirty: a partial or
+   * failed resolution returns `null` and the caller hard-resets.
+   */
+  async tryResolveConflict(handle, conflictFiles, opts) {
+    let resolved = false;
+    try {
+      resolved = opts.resolve ? await opts.resolve({ conflictFiles, cwd: this.projectRoot }) : false;
+    } catch {
+      resolved = false;
+    }
+    if (!resolved) return null;
+    await this.runGit(["add", "-A"], this.projectRoot);
+    if (await this.hasConflictMarkers(conflictFiles)) return null;
+    const idArgs = await this.identityArgs(this.projectRoot);
+    const msg = opts.message ?? `merge ${handle.branch} (squash, conflict resolved)`;
+    const commit = await this.runGit([...idArgs, "commit", "-m", msg], this.projectRoot);
+    if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
+      return null;
+    }
+    handle.conflictFiles = conflictFiles;
+    this.setStatus(handle, "merged");
+    this.emit("worktree.merged", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      baseBranch: handle.baseBranch,
+      squash: true
+    });
+    return { ok: true, resolved: true, conflictFiles };
+  }
+  /**
+   * True when staged content still carries conflict markers.
+   *
+   * Reads the working-tree files directly and matches a full marker line
+   * (`<<<<<<< `, `=======`, `>>>>>>> `, `||||||| `) with a lenient regex
+   * (`{7,}`) that stays platform- and config-independent — unlike the old
+   * `git diff --check` (only fires when `core.whitespace` opts in) and
+   * `git grep` (assumes the default 7-char markers).
+   *
+   * Scan set: when the caller supplies the conflicted paths (the normal
+   * path from {@link tryResolveConflict}), ONLY those files are scanned so
+   * an unrelated `=======` setext-heading underline in a staged document
+   * can't false-positive and discard valid resolution work. The staged-file
+   * listing (`git diff --cached --name-only`) is used only as a fallback
+   * when no paths are given.
+   *
+   * CRLF caveat: conflicted files checked out with CRLF (`core.autocrlf=true`,
+   * `.gitattributes eol=crlf`) carry bare markers as `=======\r\n`. Because
+   * `$` in multiline mode matches only before `\n`, carriage returns are
+   * stripped before matching so `\r` never defeats the end-of-line anchor.
+   */
+  async hasConflictMarkers(files) {
+    const listed = files ?? [];
+    const paths = listed.length > 0 ? listed : (await this.runGit(["diff", "--cached", "--name-only", "-z"], this.projectRoot)).stdout.split("\0").filter(Boolean);
+    const marker = /^(?:<{7,}(?: |$)|={7,}$|>{7,}(?: |$)|\|{7,}(?: |$))/m;
+    const startMarker = /^(?:<{7,}(?: |$)|\|{7,}(?: |$))/m;
+    for (const rel of paths) {
+      try {
+        const content = (await readFile(join(this.projectRoot, rel), "utf8")).replace(/\r/g, "");
+        const lines = content.split("\n");
+        let seenStart = false;
+        for (const line of lines) {
+          if (!marker.test(line)) continue;
+          if (line.startsWith("=====")) {
+            if (!seenStart) continue;
+          } else if (startMarker.test(line)) {
+            seenStart = true;
+          }
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Remove the worktree + branch. Conflicted/failed handles (or `keep:true`)
+   * are left on disk for inspection.
+   */
+  async release(handle, opts = {}) {
+    const keep = opts.keep || handle.status === "needs-review" || handle.status === "failed";
+    if (!keep) {
+      await this.runGit(["worktree", "remove", "--force", handle.dir], this.projectRoot);
+      await this.runGit(["branch", "-D", handle.branch], this.projectRoot);
+      await this.runGit(["worktree", "prune"], this.projectRoot);
+      this.handles.delete(handle.ownerId);
+    }
+    this.emit("worktree.released", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      kept: keep
+    });
+  }
+  get(ownerId) {
+    return this.handles.get(ownerId);
+  }
+  list() {
+    return [...this.handles.values()];
+  }
+  // ── internals ────────────────────────────────────────────────────────────
+  worktreesRoot() {
+    return join(this.projectRoot, ".wrongstack", "worktrees");
+  }
+  async detectBaseBranch() {
+    const head = await this.runGit(["rev-parse", "--abbrev-ref", "HEAD"], this.projectRoot);
+    const name = head.stdout.trim();
+    if (name && name !== "HEAD") return name;
+    const sha = await this.runGit(["rev-parse", "HEAD"], this.projectRoot);
+    return sha.stdout.trim() || "HEAD";
+  }
+  makeSlug(hint) {
+    return makeSlug(hint, this.usedSlugs);
+  }
+  async collectStats(dir) {
+    return collectStats(this.runGit, dir);
+  }
+  async identityArgs(cwd) {
+    return identityArgs(this.runGit, cwd);
+  }
+  async unmergedFiles() {
+    const res = await this.runGit(["diff", "--name-only", "--diff-filter=U"], this.projectRoot);
+    return res.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  emitCommitted(handle, committed) {
+    this.emit("worktree.committed", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      committed,
+      insertions: handle.insertions,
+      deletions: handle.deletions,
+      files: handle.files,
+      sha: handle.sha
+    });
+  }
+  fail(handle, error) {
+    this.setStatus(handle, "failed", { lastError: error });
+    this.emit("worktree.failed", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      error
+    });
+    return handle;
+  }
+  setStatus(handle, status, patch) {
+    handle.status = status;
+    handle.updatedAt = Date.now();
+    if (patch) Object.assign(handle, patch);
+  }
+  emit(event, payload) {
+    const sessionId = this.currentSessionId();
+    this.events?.emit(
+      event,
+      sessionId && payload && typeof payload === "object" ? { ...payload, sessionId } : payload
+    );
+  }
+  currentSessionId() {
+    const value = typeof this.sessionIdSource === "function" ? this.sessionIdSource() : this.sessionIdSource;
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }
+  defaultRun(args, cwd) {
+    return defaultRun(this.gitBin, args, cwd);
+  }
+  /** Bundle of manager state the handle-free managed-artifact ops operate on. */
+  managedOpsContext() {
+    return {
+      runGit: this.runGit,
+      projectRoot: this.projectRoot,
+      worktreesRoot: this.worktreesRoot(),
+      handles: this.handles,
+      usedSlugs: this.usedSlugs,
+      emit: (event, payload) => this.emit(event, payload)
+    };
+  }
+};
+
+export {
+  assertSafePath,
+  WorktreeManager
+};
+//# sourceMappingURL=chunk-RCQYT2I4.js.map