@wrongstack/core 0.313.0 → 0.313.1

package/dist/worktree/index.js

@@ -1,890 +1,9 @@
-// src/worktree/worktree-manager.ts
-import { mkdir, readFile } from "node:fs/promises";
-import { join, resolve as resolve3, sep as sep3 } from "node:path";
-
-// src/utils/error.ts
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
-// src/worktree/worktree-git.ts
-import { spawn } from "node:child_process";
-import { resolve, sep } from "node:path";
-
-// src/utils/child-env.ts
-var ALLOWED_KEYS = /* @__PURE__ */ new Set([
-  "PATH",
-  "HOME",
-  "USER",
-  "USERNAME",
-  "LOGNAME",
-  "SHELL",
-  "LANG",
-  "LC_ALL",
-  "LC_CTYPE",
-  "TERM",
-  "TZ",
-  "TMPDIR",
-  "TEMP",
-  "TMP",
-  "PWD",
-  "OLDPWD",
-  "COMSPEC",
-  "SYSTEMROOT",
-  "SYSTEMDRIVE",
-  "WINDIR",
-  "PROGRAMFILES",
-  "PROGRAMFILES(X86)",
-  "PROGRAMDATA",
-  "APPDATA",
-  "LOCALAPPDATA",
-  "USERPROFILE",
-  "PUBLIC",
-  "PATHEXT"
-]);
-var SECRET_NAME_PARTS = [
-  "TOKEN",
-  "SECRET",
-  "PASSWORD",
-  "PASSWD",
-  // WRONGSTACK_VAULT_PASSPHRASE is the vault KEK. Without this entry it matched
-  // no rule here and fell through to the `WRONGSTACK_` prefix allow-rule, so the
-  // key that protects the credential vault was forwarded to every child process
-  // — including the agent's own exec/bash tools and MCP stdio servers (WS-033).
-  "PASSPHRASE",
-  "AUTH",
-  "CRED",
-  "BEARER",
-  "COOKIE",
-  "PRIVATE"
-];
-function looksSecret(name) {
-  const upper = name.toUpperCase();
-  for (const p of SECRET_NAME_PARTS) {
-    if (upper.includes(p)) return true;
-  }
-  if (/(?:^|_)KEY(?:$|_|S$)/i.test(upper)) return true;
-  if (/API[_-]?KEY/i.test(upper)) return true;
-  if (/ACCESS[_-]?KEY/i.test(upper)) return true;
-  if (/SESSION[_-]?ID/i.test(upper) === false && /SESSION/i.test(upper)) {
-    return true;
-  }
-  return false;
-}
-function valueHasEmbeddedCredential(value) {
-  return /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]*:[^/\s@]+@/i.test(value);
-}
-var NODE_OPTIONS_INJECTION_FLAG = /^(?:--require|-r|--import|--loader|--experimental-loader)$/;
-var NODE_OPTIONS_INJECTION_FLAG_EQ = /^(?:--require|-r|--import|--loader|--experimental-loader)=/;
-function sanitizeNodeOptions(value) {
-  const tokens = value.split(/\s+/).filter(Boolean);
-  const kept = [];
-  for (let i = 0; i < tokens.length; i++) {
-    const tok = tokens[i];
-    if (NODE_OPTIONS_INJECTION_FLAG_EQ.test(tok)) continue;
-    if (NODE_OPTIONS_INJECTION_FLAG.test(tok)) {
-      i++;
-      continue;
-    }
-    kept.push(tok);
-  }
-  return kept.join(" ");
-}
-var gitIdentity = null;
-function buildChildEnv(optsOrSessionId) {
-  const opts = typeof optsOrSessionId === "string" ? { sessionId: optsOrSessionId } : optsOrSessionId ?? {};
-  const hasOwn = Object.hasOwn(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
-  const legacyHasOwn = Object.hasOwn(process.env, "WRONGSTACK_BASH_ENV_PASSTHROUGH");
-  const passthrough = hasOwn && process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || legacyHasOwn && process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
-  if (passthrough && !process.env["CI"]) {
-    console.warn(
-      "[agent] WARNING: WRONGSTACK_*_ENV_PASSTHROUGH=1 is active \u2014\n  all parent env vars (including API keys) forwarded to child processes.\n  Do not use on shared or multi-tenant systems."
-    );
-  }
-  const out = {};
-  const nodeEnvDefaulted = process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] === "1";
-  for (const [k, v] of Object.entries(process.env)) {
-    if (v === void 0) continue;
-    if (nodeEnvDefaulted && (k === "NODE_ENV" || k === "WRONGSTACK_NODE_ENV_DEFAULTED")) continue;
-    if (passthrough) {
-      out[k] = v;
-      continue;
-    }
-    const upper = k.toUpperCase();
-    if (valueHasEmbeddedCredential(v)) continue;
-    if (ALLOWED_KEYS.has(upper)) {
-      out[k] = v;
-      continue;
-    }
-    if (looksSecret(upper)) continue;
-    if (upper === "NODE_OPTIONS") {
-      const sanitized = sanitizeNodeOptions(v);
-      if (sanitized) out[k] = sanitized;
-      continue;
-    }
-    if (upper.startsWith("NODE_") || upper.startsWith("NPM_") || upper.startsWith("PNPM_") || upper.startsWith("YARN_") || upper.startsWith("GIT_") || upper.startsWith("CI") || upper.startsWith("XDG_") || // Our own non-secret knobs (WRONGSTACK_HOME, WRONGSTACK_SESSION_ID, …).
-    // Secrets never live in WRONGSTACK_* env vars (they're in the encrypted
-    // vault). Forwarding keeps child wstack processes — e.g. ones spawned
-    // by the test suite — inside the same redirected global root.
-    upper.startsWith("WRONGSTACK_") || upper === "EDITOR" || upper === "VISUAL" || upper === "PAGER") {
-      out[k] = v;
-    }
-  }
-  if (gitIdentity) {
-    if (gitIdentity.name) {
-      out["GIT_AUTHOR_NAME"] = gitIdentity.name;
-      out["GIT_COMMITTER_NAME"] = gitIdentity.name;
-    }
-    if (gitIdentity.email) {
-      out["GIT_AUTHOR_EMAIL"] = gitIdentity.email;
-      out["GIT_COMMITTER_EMAIL"] = gitIdentity.email;
-    }
-  }
-  if (opts.extra) {
-    Object.assign(out, opts.extra);
-  }
-  if (opts.sessionId) out["WRONGSTACK_SESSION_ID"] = opts.sessionId;
-  return out;
-}
-
-// src/worktree/worktree-git.ts
-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)
-    };
-  }
-};
+import {
+  WorktreeManager,
+  assertSafePath
+} from "../chunk-RCQYT2I4.js";
+import "../chunk-VB3H5WWB.js";
+import "../chunk-TBRL2RCC.js";
 export {
   WorktreeManager,
   assertSafePath