gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.9bafd68

package/dist/resources/extensions/gsd/worktree-manager.ts

@@ -1,449 +0,0 @@
-/**
- * GSD Worktree Manager
- *
- * Creates and manages git worktrees under .gsd/worktrees/<name>/.
- * Each worktree gets its own branch (worktree/<name>) and a full
- * working copy of the project, enabling parallel work streams.
- *
- * The merge helper compares .gsd/ artifacts between a worktree and
- * the main branch, then dispatches an LLM-guided merge flow.
- *
- * Flow:
- *   1. create()  — git worktree add .gsd/worktrees/<name> -b worktree/<name>
- *   2. user works in the worktree (new plans, milestones, etc.)
- *   3. merge()   — LLM-guided reconciliation of .gsd/ artifacts back to main
- *   4. remove()  — git worktree remove + branch cleanup
- */
-
-import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-import { gsdRoot } from "./paths.js";
-import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
-import {
-  nativeBranchDelete,
-  nativeBranchExists,
-  nativeBranchForceReset,
-  nativeCommit,
-  nativeDetectMainBranch,
-  nativeDiffContent,
-  nativeDiffNameStatus,
-  nativeDiffNumstat,
-  nativeGetCurrentBranch,
-  nativeLogOneline,
-  nativeMergeSquash,
-  nativeWorktreeAdd,
-  nativeWorktreeList,
-  nativeWorktreePrune,
-  nativeWorktreeRemove,
-} from "./native-git-bridge.js";
-
-// ─── Types ─────────────────────────────────────────────────────────────────
-
-export interface WorktreeInfo {
-  name: string;
-  path: string;
-  branch: string;
-  exists: boolean;
-}
-
-/** Per-file line change stats from git diff --numstat. */
-export interface FileLineStat {
-  file: string;
-  added: number;
-  removed: number;
-}
-
-export interface WorktreeDiffSummary {
-  /** Files only in the worktree .gsd/ (new artifacts) */
-  added: string[];
-  /** Files in both but with different content */
-  modified: string[];
-  /** Files only in main .gsd/ (deleted in worktree) */
-  removed: string[];
-}
-
-// ─── Path Helpers ──────────────────────────────────────────────────────────
-
-function normalizePathForComparison(path: string): string {
-  const normalized = path
-    .replaceAll("\\", "/")
-    .replace(/^\/\/\?\//, "")
-    .replace(/\/+$/, "");
-  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
-
-// ─── resolveGitDir ─────────────────────────────────────────────────────────
-
-/**
- * Resolve the actual git directory for a given repository path.
- *
- * In a normal repo, .git is a directory → returns `<basePath>/.git`.
- * In a worktree, .git is a file containing `gitdir: <path>` → resolves
- * and returns that path.
- *
- * This is critical for operations that reference git metadata files like
- * MERGE_HEAD, SQUASH_MSG, etc. — these live in the git directory, not
- * in the working tree root. Without this, worktree merges fail because
- * they look for MERGE_HEAD in the wrong location.
- */
-export function resolveGitDir(basePath: string): string {
-  const gitPath = join(basePath, ".git");
-  if (!existsSync(gitPath)) return join(basePath, ".git");
-  try {
-    const content = readFileSync(gitPath, "utf-8").trim();
-    if (content.startsWith("gitdir: ")) {
-      return resolve(basePath, content.slice(8));
-    }
-  } catch {
-    // Not a file or unreadable — fall through to default
-  }
-  return join(basePath, ".git");
-}
-
-export function worktreesDir(basePath: string): string {
-  return join(gsdRoot(basePath), "worktrees");
-}
-
-export function worktreePath(basePath: string, name: string): string {
-  return join(worktreesDir(basePath), name);
-}
-
-export function worktreeBranchName(name: string): string {
-  return `worktree/${name}`;
-}
-
-// ─── Core Operations ───────────────────────────────────────────────────────
-
-/**
- * Create a new git worktree under .gsd/worktrees/<name>/ with branch worktree/<name>.
- * The branch is created from the current HEAD of the main branch.
- *
- * @param opts.branch — override the default `worktree/<name>` branch name
- */
-export function createWorktree(basePath: string, name: string, opts: { branch?: string; startPoint?: string; reuseExistingBranch?: boolean } = {}): WorktreeInfo {
-  // Validate name: alphanumeric, hyphens, underscores only
-  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
-    throw new GSDError(GSD_PARSE_ERROR, `Invalid worktree name "${name}". Use only letters, numbers, hyphens, and underscores.`);
-  }
-
-  const wtPath = worktreePath(basePath, name);
-  const branch = opts.branch ?? worktreeBranchName(name);
-
-  if (existsSync(wtPath)) {
-    throw new GSDError(GSD_STALE_STATE, `Worktree "${name}" already exists at ${wtPath}`);
-  }
-
-  // Ensure the .gsd/worktrees/ directory exists
-  const wtDir = worktreesDir(basePath);
-  mkdirSync(wtDir, { recursive: true });
-
-  // Prune any stale worktree entries from a previous removal
-  nativeWorktreePrune(basePath);
-
-  // Use the explicit start point (e.g. integration branch) if provided,
-  // otherwise fall back to the repo's detected main branch.
-  const startPoint = opts.startPoint ?? nativeDetectMainBranch(basePath);
-
-  // Check if the branch already exists (leftover from a previous worktree)
-  const branchAlreadyExists = nativeBranchExists(basePath, branch);
-
-  if (branchAlreadyExists) {
-    // Check if the branch is actively used by an existing worktree.
-    const worktreeEntries = nativeWorktreeList(basePath);
-    const branchInUse = worktreeEntries.some(entry => entry.branch === branch);
-
-    if (branchInUse) {
-      throw new GSDError(
-        GSD_LOCK_HELD,
-        `Branch "${branch}" is already in use by another worktree. ` +
-        `Remove the existing worktree first with /worktree remove ${name}.`,
-      );
-    }
-
-    if (opts.reuseExistingBranch) {
-      // Attach worktree to the existing branch as-is (preserving commits).
-      // Used when resuming auto-mode: the milestone branch has valid work
-      // from prior sessions that must not be reset.
-      nativeWorktreeAdd(basePath, wtPath, branch);
-    } else {
-      // Reset the stale branch to the start point, then attach worktree to it
-      nativeBranchForceReset(basePath, branch, startPoint);
-      nativeWorktreeAdd(basePath, wtPath, branch);
-    }
-  } else {
-    nativeWorktreeAdd(basePath, wtPath, branch, true, startPoint);
-  }
-
-  return {
-    name,
-    path: wtPath,
-    branch,
-    exists: true,
-  };
-}
-
-/**
- * List all GSD-managed worktrees.
- * Uses native worktree list and filters to those under .gsd/worktrees/.
- */
-export function listWorktrees(basePath: string): WorktreeInfo[] {
-  const baseVariants = [resolve(basePath)];
-  if (existsSync(basePath)) {
-    baseVariants.push(realpathSync(basePath));
-  }
-  const seenRoots = new Set<string>();
-  const worktreeRoots = baseVariants
-    .map(baseVariant => {
-      const path = join(gsdRoot(baseVariant), "worktrees");
-      return {
-        normalized: normalizePathForComparison(path),
-      };
-    })
-    .filter(root => {
-      if (seenRoots.has(root.normalized)) return false;
-      seenRoots.add(root.normalized);
-      return true;
-    });
-
-  const entries = nativeWorktreeList(basePath);
-
-  if (!entries.length) return [];
-
-  const worktrees: WorktreeInfo[] = [];
-
-  for (const entry of entries) {
-    if (entry.isBare) continue;
-
-    const entryPath = entry.path;
-    const branch = entry.branch;
-
-    if (!branch) continue;
-
-    const branchWorktreeName = branch.startsWith("worktree/")
-      ? branch.slice("worktree/".length)
-      : branch.startsWith("milestone/")
-        ? branch.slice("milestone/".length)
-        : null;
-
-    const entryVariants = [resolve(entryPath)];
-    if (existsSync(entryPath)) {
-      entryVariants.push(realpathSync(entryPath));
-    }
-    const normalizedEntryVariants = [...new Set(entryVariants.map(normalizePathForComparison))];
-    const matchedRoot = worktreeRoots.find(root =>
-      normalizedEntryVariants.some(entryVariant => entryVariant.startsWith(`${root.normalized}/`)),
-    );
-    const matchesBranchLeaf = branchWorktreeName
-      ? normalizedEntryVariants.some(entryVariant => entryVariant.split("/").pop() === branchWorktreeName)
-      : false;
-
-    // Only include worktrees under .gsd/worktrees/
-    if (!matchedRoot && !matchesBranchLeaf) continue;
-
-    const matchedEntryPath = normalizedEntryVariants.find(entryVariant =>
-      matchedRoot ? entryVariant.startsWith(`${matchedRoot.normalized}/`) : false,
-    );
-    let name = matchedRoot ? matchedEntryPath?.slice(matchedRoot.normalized.length + 1) ?? "" : "";
-
-    // Git on Windows can report a path form that does not map cleanly back to the
-    // repo root even when the branch naming is still authoritative.
-    if ((!name || name.includes("/")) && branchWorktreeName && matchesBranchLeaf) {
-      name = branchWorktreeName;
-    }
-
-    if (!name || name.includes("/")) continue;
-
-    const resolvedEntryPath = existsSync(entryPath) ? realpathSync(entryPath) : resolve(entryPath);
-
-    worktrees.push({
-      name,
-      path: resolvedEntryPath,
-      branch,
-      exists: existsSync(resolvedEntryPath),
-    });
-  }
-
-  return worktrees;
-}
-
-/**
- * Remove a worktree and optionally delete its branch.
- * If the process is currently inside the worktree, chdir out first.
- */
-export function removeWorktree(
-  basePath: string,
-  name: string,
-  opts: { deleteBranch?: boolean; force?: boolean; branch?: string } = {},
-): void {
-  const wtPath = worktreePath(basePath, name);
-  const resolvedWtPath = existsSync(wtPath) ? realpathSync(wtPath) : wtPath;
-  const branch = opts.branch ?? worktreeBranchName(name);
-  const { deleteBranch = true, force = true } = opts;
-
-  // If we're inside the worktree, move out first — git can't remove an in-use directory
-  const cwd = process.cwd();
-  const resolvedCwd = existsSync(cwd) ? realpathSync(cwd) : cwd;
-  if (resolvedCwd === resolvedWtPath || resolvedCwd.startsWith(resolvedWtPath + sep)) {
-    process.chdir(basePath);
-  }
-
-  if (!existsSync(wtPath)) {
-    nativeWorktreePrune(basePath);
-    if (deleteBranch) {
-      try { nativeBranchDelete(basePath, branch, true); } catch { /* branch may not exist */ }
-    }
-    return;
-  }
-
-  // Remove worktree (force if requested, to handle dirty worktrees)
-  try { nativeWorktreeRemove(basePath, wtPath, force); } catch { /* may fail */ }
-
-  // If the directory is still there (e.g. locked), try harder with force
-  if (existsSync(wtPath)) {
-    try { nativeWorktreeRemove(basePath, wtPath, true); } catch { /* may fail */ }
-  }
-
-  // Prune stale entries so git knows the worktree is gone
-  nativeWorktreePrune(basePath);
-
-  if (deleteBranch) {
-    try { nativeBranchDelete(basePath, branch, true); } catch { /* branch may not exist */ }
-  }
-}
-
-/** Paths to skip in all worktree diffs (internal/runtime artifacts). */
-const SKIP_PATHS = [".gsd/worktrees/", ".gsd/runtime/", ".gsd/activity/"];
-const SKIP_EXACT = [".gsd/STATE.md", ".gsd/auto.lock", ".gsd/metrics.json"];
-
-function shouldSkipPath(filePath: string): boolean {
-  if (SKIP_PATHS.some(p => filePath.startsWith(p))) return true;
-  if (SKIP_EXACT.includes(filePath)) return true;
-  return false;
-}
-
-function parseDiffNameStatus(entries: { status: string; path: string }[]): WorktreeDiffSummary {
-  const added: string[] = [];
-  const modified: string[] = [];
-  const removed: string[] = [];
-
-  for (const { status, path } of entries) {
-    if (shouldSkipPath(path)) continue;
-
-    switch (status) {
-      case "A": added.push(path); break;
-      case "M": modified.push(path); break;
-      case "D": removed.push(path); break;
-      default:
-        // Renames, copies — treat as modified
-        if (status?.startsWith("R") || status?.startsWith("C")) {
-          modified.push(path);
-        }
-    }
-  }
-
-  return { added, modified, removed };
-}
-
-/**
- * Diff the .gsd/ directory between the worktree branch and main branch.
- * Returns a summary of added, modified, and removed GSD artifacts.
- */
-export function diffWorktreeGSD(basePath: string, name: string): WorktreeDiffSummary {
-  const branch = worktreeBranchName(name);
-  const mainBranch = nativeDetectMainBranch(basePath);
-
-  const entries = nativeDiffNameStatus(basePath, mainBranch, branch, ".gsd/", true);
-
-  return parseDiffNameStatus(entries);
-}
-
-/**
- * Diff ALL files between the worktree branch and main branch.
- * Uses direct diff (no merge-base) to show what will actually change
- * on main when the merge is applied. If both branches have identical
- * content, this correctly returns an empty diff.
- */
-export function diffWorktreeAll(basePath: string, name: string): WorktreeDiffSummary {
-  const branch = worktreeBranchName(name);
-  const mainBranch = nativeDetectMainBranch(basePath);
-
-  const entries = nativeDiffNameStatus(basePath, mainBranch, branch);
-
-  return parseDiffNameStatus(entries);
-}
-
-/**
- * Get per-file line addition/deletion stats for what will change on main.
- * Uses direct diff (not merge-base) so the preview matches the actual merge outcome.
- */
-export function diffWorktreeNumstat(basePath: string, name: string): FileLineStat[] {
-  const branch = worktreeBranchName(name);
-  const mainBranch = nativeDetectMainBranch(basePath);
-
-  const rawStats = nativeDiffNumstat(basePath, mainBranch, branch);
-
-  const stats: FileLineStat[] = [];
-  for (const entry of rawStats) {
-    if (shouldSkipPath(entry.path)) continue;
-    stats.push({ file: entry.path, added: entry.added, removed: entry.removed });
-  }
-  return stats;
-}
-
-/**
- * Get the full diff content for .gsd/ between the worktree branch and main.
- * Returns the raw unified diff for LLM consumption.
- */
-export function getWorktreeGSDDiff(basePath: string, name: string): string {
-  const branch = worktreeBranchName(name);
-  const mainBranch = nativeDetectMainBranch(basePath);
-
-  return nativeDiffContent(basePath, mainBranch, branch, ".gsd/", undefined, true);
-}
-
-/**
- * Get the full diff content for non-.gsd/ files between the worktree branch and main.
- * Returns the raw unified diff for LLM consumption.
- */
-export function getWorktreeCodeDiff(basePath: string, name: string): string {
-  const branch = worktreeBranchName(name);
-  const mainBranch = nativeDetectMainBranch(basePath);
-
-  return nativeDiffContent(basePath, mainBranch, branch, undefined, ".gsd/", true);
-}
-
-/**
- * Get commit log for the worktree branch since it diverged from main.
- */
-export function getWorktreeLog(basePath: string, name: string): string {
-  const branch = worktreeBranchName(name);
-  const mainBranch = nativeDetectMainBranch(basePath);
-
-  const entries = nativeLogOneline(basePath, mainBranch, branch);
-
-  return entries.map(e => `${e.sha} ${e.message}`).join("\n");
-}
-
-/**
- * Merge the worktree branch into main using squash merge.
- * Must be called from the main working tree (not the worktree itself).
- * Returns the merge commit message.
- */
-export function mergeWorktreeToMain(basePath: string, name: string, commitMessage: string): string {
-  const branch = worktreeBranchName(name);
-  const mainBranch = nativeDetectMainBranch(basePath);
-  const current = nativeGetCurrentBranch(basePath);
-
-  if (current !== mainBranch) {
-    throw new GSDError(GSD_GIT_ERROR, `Must be on ${mainBranch} to merge. Currently on ${current}.`);
-  }
-
-  const result = nativeMergeSquash(basePath, branch);
-  if (!result.success) {
-    throw new GSDError(GSD_MERGE_CONFLICT, `Merge conflicts detected in: ${result.conflicts.join(", ")}`);
-  }
-
-  nativeCommit(basePath, commitMessage);
-
-  return commitMessage;
-}

package/dist/resources/extensions/gsd/worktree.ts

@@ -1,257 +0,0 @@
-/**
- * GSD Worktree Utilities
- *
- * Pure utility functions for worktree name detection, legacy branch name
- * parsing, and integration branch capture.
- *
- * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
- * SLICE_BRANCH_RE) remain standalone for backwards compatibility.
- *
- * Branchless architecture: all work commits sequentially on the milestone branch.
- * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
- * SLICE_BRANCH_RE) remain for backwards compatibility with legacy branches.
- */
-
-import { existsSync, lstatSync, readFileSync, utimesSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-
-import { GitServiceImpl, writeIntegrationBranch, type TaskCommitContext } from "./git-service.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
-
-export { MergeConflictError } from "./git-service.js";
-export type { TaskCommitContext } from "./git-service.js";
-
-// ─── Lazy GitServiceImpl Cache ─────────────────────────────────────────────
-
-let cachedService: GitServiceImpl | null = null;
-let cachedBasePath: string | null = null;
-
-/**
- * Get or create a GitServiceImpl for the given basePath.
- * Resets the cache if basePath changes between calls.
- * Lazy construction: only instantiated at call-time, never at module-evaluation.
- */
-function getService(basePath: string): GitServiceImpl {
-  if (cachedService === null || cachedBasePath !== basePath) {
-    const loaded = loadEffectiveGSDPreferences();
-    const gitPrefs = loaded?.preferences?.git ?? {};
-    cachedService = new GitServiceImpl(basePath, gitPrefs);
-    cachedBasePath = basePath;
-  }
-  return cachedService;
-}
-
-/**
- * Set the active milestone ID on the cached GitServiceImpl.
- * This enables integration branch resolution in getMainBranch().
- */
-export function setActiveMilestoneId(basePath: string, milestoneId: string | null): void {
-  getService(basePath).setMilestoneId(milestoneId);
-}
-
-/**
- * Record the current branch as the integration branch for a milestone.
- * Called once when auto-mode starts — captures where slice branches should
- * merge back to. No-op if the same branch is already recorded. Updates the
- * record when the user starts from a different branch (#300). Always a no-op
- * if on a GSD slice branch.
- */
-export function captureIntegrationBranch(basePath: string, milestoneId: string): void {
-  // In a worktree, the base branch is implicit (worktree/<name>).
-  // Writing it to META.json would leave stale metadata after merge back to main.
-  if (detectWorktreeName(basePath)) return;
-  const svc = getService(basePath);
-  const current = svc.getCurrentBranch();
-  writeIntegrationBranch(basePath, milestoneId, current);
-}
-
-// ─── Pure Utility Functions (unchanged) ────────────────────────────────────
-
-/**
- * Detect the active worktree name from the current working directory.
- * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
- */
-export function detectWorktreeName(basePath: string): string | null {
-  // Primary: use git metadata — .git file with gitdir: pointer
-  const gitPath = join(basePath, ".git");
-  try {
-    const stat = lstatSync(gitPath);
-    if (stat.isFile()) {
-      const content = readFileSync(gitPath, "utf-8").trim();
-      if (content.startsWith("gitdir:")) {
-        const gitdir = content.slice(7).trim();
-        // Git worktree gitdir format: <repo>/.git/worktrees/<name>
-        const parts = gitdir.replace(/\\/g, "/").split("/");
-        const wtIdx = parts.lastIndexOf("worktrees");
-        if (wtIdx !== -1 && wtIdx < parts.length - 1) {
-          return parts[wtIdx + 1] || null;
-        }
-      }
-    }
-  } catch { /* fall through */ }
-
-  // Fallback: path-based detection for legacy setups
-  const normalizedPath = basePath.replaceAll("\\", "/");
-  const marker = "/.gsd/worktrees/";
-  const idx = normalizedPath.indexOf(marker);
-  if (idx === -1) return null;
-  const afterMarker = normalizedPath.slice(idx + marker.length);
-  const name = afterMarker.split("/")[0];
-  return name || null;
-}
-
-/**
- * Resolve the project root from a path that may be inside a worktree.
- * If the path contains `/.gsd/worktrees/<name>/`, returns the portion
- * before `/.gsd/`. Otherwise returns the input unchanged.
- *
- * Use this in commands that call `process.cwd()` to ensure they always
- * operate against the real project root, not a worktree subdirectory.
- */
-export function resolveProjectRoot(basePath: string): string {
-  // Primary: use git metadata to resolve the main worktree root
-  const gitPath = join(basePath, ".git");
-  try {
-    const stat = lstatSync(gitPath);
-    if (stat.isFile()) {
-      const content = readFileSync(gitPath, "utf-8").trim();
-      if (content.startsWith("gitdir:")) {
-        const gitdir = resolve(basePath, content.slice(7).trim());
-        // Git worktree gitdir: <repo>/.git/worktrees/<name>
-        // Walk up to <repo>
-        const parts = gitdir.replace(/\\/g, "/").split("/");
-        const wtIdx = parts.lastIndexOf("worktrees");
-        if (wtIdx >= 2 && parts[wtIdx - 1] === ".git") {
-          return parts.slice(0, wtIdx - 1).join("/");
-        }
-      }
-    }
-  } catch { /* fall through */ }
-
-  // Fallback: legacy path-based detection
-  const normalizedPath = basePath.replaceAll("\\", "/");
-  const marker = "/.gsd/worktrees/";
-  const idx = normalizedPath.indexOf(marker);
-  if (idx === -1) return basePath;
-  const osSep = basePath.includes("\\") ? "\\" : "/";
-  const markerOs = `${osSep}.gsd${osSep}worktrees${osSep}`;
-  const idxOs = basePath.indexOf(markerOs);
-  if (idxOs !== -1) return basePath.slice(0, idxOs);
-  return basePath.slice(0, idx);
-}
-
-/**
- * Get the slice branch name, namespaced by worktree when inside one.
- *
- * In the main tree:     gsd/<milestoneId>/<sliceId>
- * In a worktree:        gsd/<worktreeName>/<milestoneId>/<sliceId>
- *
- * This prevents branch conflicts when multiple worktrees work on the
- * same milestone/slice IDs — git doesn't allow a branch to be checked
- * out in more than one worktree simultaneously.
- */
-export function getSliceBranchName(milestoneId: string, sliceId: string, worktreeName?: string | null): string {
-  if (worktreeName) {
-    return `gsd/${worktreeName}/${milestoneId}/${sliceId}`;
-  }
-  return `gsd/${milestoneId}/${sliceId}`;
-}
-
-/** Regex that matches both plain and worktree-namespaced slice branches. */
-export const SLICE_BRANCH_RE = /^gsd\/(?:([a-zA-Z0-9_-]+)\/)?(M\d+(?:-[a-z0-9]{6})?)\/(S\d+)$/;
-
-/**
- * Parse a slice branch name into its components.
- * Handles both `gsd/M001/S01` and `gsd/myworktree/M001/S01`.
- */
-export function parseSliceBranch(branchName: string): {
-  worktreeName: string | null;
-  milestoneId: string;
-  sliceId: string;
-} | null {
-  const match = branchName.match(SLICE_BRANCH_RE);
-  if (!match) return null;
-  return {
-    worktreeName: match[1] ?? null,
-    milestoneId: match[2]!,
-    sliceId: match[3]!,
-  };
-}
-
-// ─── Git-Mutation Functions (delegate to GitServiceImpl) ───────────────────
-
-/**
- * Get the "main" branch for GSD slice operations.
- *
- * In the main working tree: returns main/master (the repo's default branch).
- * In a worktree: returns worktree/<name> — the worktree's own base branch.
- *
- * This is critical because git doesn't allow a branch to be checked out
- * in more than one worktree. Slice branches merge into the worktree's base
- * branch, and the worktree branch later merges into the real main via
- * /worktree merge.
- */
-export function getMainBranch(basePath: string): string {
-  return getService(basePath).getMainBranch();
-}
-
-export function getCurrentBranch(basePath: string): string {
-  return getService(basePath).getCurrentBranch();
-}
-
-/**
- * Auto-commit any dirty files in the current working tree.
- *
- * When `taskContext` is provided, generates a meaningful conventional commit
- * message from the task summary (one-liner, inferred type, key files).
- * Falls back to a generic `chore()` message for non-task commits.
- *
- * Returns the commit message used, or null if already clean.
- */
-export function autoCommitCurrentBranch(
-  basePath: string, unitType: string, unitId: string,
-  taskContext?: TaskCommitContext,
-): string | null {
-  return getService(basePath).autoCommit(unitType, unitId, [], taskContext);
-}
-
-// ─── Git HEAD Resolution ────────────────────────────────────────────────────
-
-/**
- * Resolve the git HEAD file path for a given directory.
- * Handles both normal repos (.git is a directory) and worktrees (.git is a file
- * containing a `gitdir:` pointer to the real gitdir).
- */
-export function resolveGitHeadPath(dir: string): string | null {
-  const gitPath = join(dir, ".git");
-  if (!existsSync(gitPath)) return null;
-
-  try {
-    const content = readFileSync(gitPath, "utf8").trim();
-    if (content.startsWith("gitdir: ")) {
-      const gitDir = resolve(dir, content.slice(8));
-      const headPath = join(gitDir, "HEAD");
-      return existsSync(headPath) ? headPath : null;
-    }
-    const headPath = join(dir, ".git", "HEAD");
-    return existsSync(headPath) ? headPath : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Nudge pi's FooterDataProvider to re-read the git branch after chdir.
- * Touches HEAD in both old and new cwd to fire the fs watcher.
- */
-export function nudgeGitBranchCache(previousCwd: string): void {
-  const now = new Date();
-  for (const dir of [previousCwd, process.cwd()]) {
-    try {
-      const headPath = resolveGitHeadPath(dir);
-      if (headPath) utimesSync(headPath, now, now);
-    } catch {
-      // Best-effort
-    }
-  }
-}