@opengsd/gsd-pi 1.5.0 → 1.6.0

package/src/resources/extensions/gsd/auto-start.ts

@@ -63,18 +63,20 @@ import {
   detectWorktreeName,
   setActiveMilestoneId,
 } from "./worktree.js";
-import { getAutoWorktreePath, isInAutoWorktree } from "./auto-worktree.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { checkoutBranchWithStashGuard } from "./worktree-git-recovery.js";
-import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
+import { cleanStaleRuntimeUnits } from "./auto-worktree-runtime-cleanup.js";
+import { readResourceVersion } from "./auto-worktree-resource-version.js";
 import { worktreePath as getWorktreeDir, isInsideWorktreesDir } from "./worktree-manager.js";
 import { emitWorktreeOrphaned } from "./worktree-telemetry.js";
 import { queryJournal } from "./journal.js";
 import { initMetrics } from "./metrics.js";
 import { initRoutingHistory } from "./routing-history.js";
-import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
+import { restoreHookState, resetHookState, reconcileRestoredHookDispatch } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, updateMilestoneStatus } from "./gsd-db.js";
+import { isDbAvailable, probeDbWritable, getMilestone, getAllMilestones, insertMilestone, updateMilestoneStatus } from "./gsd-db.js";
 import {
   getWorkflowDatabaseStatus,
   openExistingWorkflowDatabase,
@@ -203,35 +205,43 @@ export function reconcileProjectMilestonesFromDisk(basePath: string): number {
 export function reconcileMergedMilestonesFromJournal(basePath: string): number {
   if (!isDbAvailable()) return 0;
 
-  const mergedAtByMilestone = new Map<string, string>();
-  for (const entry of queryJournal(basePath, { eventType: "worktree-merged" })) {
-    const data = entry.data ?? {};
-    const milestoneId = typeof data.milestoneId === "string" ? data.milestoneId : null;
-    if (!milestoneId) continue;
-    if (data.conflict === true) continue;
-
-    const endedAt = typeof data.endedAt === "string" ? data.endedAt : entry.ts;
-    const previous = mergedAtByMilestone.get(milestoneId);
-    if (!previous || endedAt > previous) mergedAtByMilestone.set(milestoneId, endedAt);
-  }
-
-  let closed = 0;
-  for (const [milestoneId, completedAt] of mergedAtByMilestone) {
-    const existing = getMilestone(milestoneId);
-    if (!existing) {
-      insertMilestone({ id: milestoneId, title: milestoneId, status: "complete" });
-      updateMilestoneStatus(milestoneId, "complete", completedAt);
-      closed++;
-      continue;
+  try {
+    const mergedAtByMilestone = new Map<string, string>();
+    for (const entry of queryJournal(basePath, { eventType: "worktree-merged" })) {
+      const data = entry.data ?? {};
+      const milestoneId = typeof data.milestoneId === "string" ? data.milestoneId : null;
+      if (!milestoneId) continue;
+      if (data.conflict === true) continue;
+
+      const endedAt = typeof data.endedAt === "string" ? data.endedAt : entry.ts;
+      const previous = mergedAtByMilestone.get(milestoneId);
+      if (!previous || endedAt > previous) mergedAtByMilestone.set(milestoneId, endedAt);
     }
-    if (!isClosedStatus(existing.status)) {
-      updateMilestoneStatus(milestoneId, "complete", completedAt);
-      closed++;
+
+    let closed = 0;
+    for (const [milestoneId, completedAt] of mergedAtByMilestone) {
+      const existing = getMilestone(milestoneId);
+      if (!existing) {
+        insertMilestone({ id: milestoneId, title: milestoneId, status: "complete" });
+        updateMilestoneStatus(milestoneId, "complete", completedAt);
+        closed++;
+        continue;
+      }
+      if (!isClosedStatus(existing.status)) {
+        updateMilestoneStatus(milestoneId, "complete", completedAt);
+        closed++;
+      }
     }
-  }
 
-  if (closed > 0) invalidateAllCaches();
-  return closed;
+    if (closed > 0) invalidateAllCaches();
+    return closed;
+  } catch (err) {
+    logWarning(
+      "bootstrap",
+      `merged-milestone journal reconciliation failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return 0;
+  }
 }
 
 /**
@@ -1622,6 +1632,10 @@ export async function bootstrapAutoSession(
     s.unitLifetimeDispatches.clear();
     resetHookState();
     restoreHookState(base);
+    // A restored activeHook has no live dispatch (the sidecar queue is not
+    // persisted); re-enqueue it so the hook runs instead of blocking the next
+    // unrelated unit's close-out (#1246).
+    reconcileRestoredHookDispatch(base, s.sidecarQueue);
     resetProactiveHealing();
     // Notify user on health level transitions (green→yellow→red and back)
     setLevelChangeCallback((_from, to, summary) => {
@@ -1776,6 +1790,23 @@ export async function bootstrapAutoSession(
       return releaseLockAndReturn();
     }
 
+    // Gate: confirm the handle is actually writable, not just open. A
+    // schema-current DB does zero writes during open, so a read-only /
+    // DBMOVED handle otherwise passes the check above and only fails much
+    // later at the first authoritative write (the uok-kernel-enter audit)
+    // with an opaque "readonly database" error (#1234).
+    if (existsSync(gsdDbPath) && isDbAvailable()) {
+      const writable = probeDbWritable();
+      if (!writable.ok) {
+        const detail = writable.detail ? ` (${writable.detail})` : "";
+        ctx.ui.notify(
+          `SQLite database is not writable: ${gsdDbPath}.${detail} Check file/WAL permissions or reopen a stale handle before running auto-mode.`,
+          "error",
+        );
+        return releaseLockAndReturn();
+      }
+    }
+
     // Initialize metrics
     initMetrics(s.basePath);
 
@@ -1813,7 +1844,7 @@ export async function bootstrapAutoSession(
 
     // Snapshot installed skills
     if (resolveSkillDiscoveryMode(base) !== "off") {
-      snapshotSkills();
+      snapshotSkills({ cwd: s.basePath });
     }
 
     setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");

package/src/resources/extensions/gsd/auto-timeout-recovery.ts

@@ -21,6 +21,8 @@ import { existsSync } from "node:fs";
 
 import { bumpAndResolveSynthetic } from "./auto/resolve.js";
 import { finalizeProjectResearchTimeout } from "./project-research-policy.js";
+import { applySupervisorModelIfConfigured } from "./auto-model-selection.js";
+import { getInFlightToolCount } from "./auto-tool-tracking.js";
 
 export interface RecoveryContext {
   basePath: string;
@@ -122,13 +124,17 @@ export async function recoverTimedOutUnit(
             "If full completion is impossible, write the partial artifact/state needed for recovery and make the blocker explicit.",
           ];
 
+      const recoveryTrigger = getInFlightToolCount() === 0;
+      if (recoveryTrigger) {
+        await applySupervisorModelIfConfigured(ctx, pi, basePath);
+      }
       pi.sendMessage(
         {
           customType: "gsd-auto-timeout-recovery",
           display: verbose,
           content: steeringLines.join("\n"),
         },
-        { triggerTurn: true, deliverAs: "steer" },
+        { triggerTurn: recoveryTrigger, deliverAs: "steer" },
       );
       ctx.ui.notify(
         `${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to finish durable output (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`,
@@ -249,13 +255,17 @@ export async function recoverTimedOutUnit(
           "If blocked, write the partial artifact and explicitly record the blocker instead of going silent.",
         ];
 
+    const recoveryTrigger = getInFlightToolCount() === 0;
+    if (recoveryTrigger) {
+      await applySupervisorModelIfConfigured(ctx, pi, basePath);
+    }
     pi.sendMessage(
       {
         customType: "gsd-auto-timeout-recovery",
         display: verbose,
         content: steeringLines.join("\n"),
       },
-      { triggerTurn: true, deliverAs: "steer" },
+      { triggerTurn: recoveryTrigger, deliverAs: "steer" },
     );
     ctx.ui.notify(
       `${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to produce ${expected} (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`,

package/src/resources/extensions/gsd/auto-timers.ts

@@ -19,6 +19,7 @@ import {
   hasInteractiveToolInFlight,
 } from "./auto-tool-tracking.js";
 import { detectWorkingTreeActivity } from "./auto-supervisor.js";
+import { applySupervisorModelIfConfigured } from "./auto-model-selection.js";
 import { closeoutUnit, type CloseoutOptions } from "./auto-unit-closeout.js";
 import { saveActivityLog } from "./activity-log.js";
 import { recoverTimedOutUnit, type RecoveryContext } from "./auto-timeout-recovery.js";
@@ -158,7 +159,7 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
       : idleTimeoutMs;
 
   // ── 1. Soft timeout warning ──
-  s.wrapupWarningHandle = setTimeout(() => {
+  s.wrapupWarningHandle = setTimeout(async () => {
     s.wrapupWarningHandle = null;
     if (!s.active || !s.currentUnit) return;
     writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
@@ -169,6 +170,9 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
     // Triggering during active tool calls causes tool results to be skipped
     // with "Skipped due to queued user message", leading to provider errors (#3512).
     const softTrigger = getInFlightToolCount() === 0;
+    if (softTrigger) {
+      await applySupervisorModelIfConfigured(ctx, pi, s.basePath);
+    }
     pi.sendMessage(
       {
         customType: "gsd-auto-wrapup",
@@ -351,7 +355,7 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
     ctx.model?.provider,
   );
   const continueHereThreshold = computeBudgets(executorContextWindow).continueThresholdPercent;
-  s.continueHereHandle = setInterval(() => {
+  s.continueHereHandle = setInterval(async () => {
     if (!s.active || !s.currentUnit || !s.cmdCtx) return;
     const runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
     if (runtime?.continueHereFired) return;
@@ -382,6 +386,9 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
 
     // Only trigger a new turn if no tools are currently in flight (#3512).
     const contextTrigger = getInFlightToolCount() === 0;
+    if (contextTrigger) {
+      await applySupervisorModelIfConfigured(ctx, pi, s.basePath);
+    }
     pi.sendMessage(
       {
         customType: "gsd-auto-wrapup",

package/src/resources/extensions/gsd/auto-worktree-branch-lifecycle.ts

@@ -0,0 +1,237 @@
+// gsd-pi — Auto-worktree branch lifecycle module.
+//
+// Owns milestone branch naming, branch-mode entry, and safe fast-forward of
+// reused milestone branches. Worktree creation/merge code imports this module
+// instead of keeping branch policy inside the legacy auto-worktree barrel.
+
+import { GSDError, GSD_GIT_ERROR } from "./errors.js";
+import { readIntegrationBranch } from "./git-service.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { debugLog } from "./debug-logger.js";
+import { checkoutBranchWithStashGuard } from "./worktree-git-recovery.js";
+import {
+  nativeBranchExists,
+  nativeBranchForceReset,
+  nativeDetectMainBranch,
+  nativeIsAncestor,
+  nativeUpdateRef,
+  nativeWorktreeList,
+} from "./native-git-bridge.js";
+
+/** Returns the git branch name for a milestone worktree (`milestone/<MID>`). */
+export function autoWorktreeBranch(milestoneId: string): string {
+  return `milestone/${milestoneId}`;
+}
+
+export function _resolveAutoWorktreeStartPoint(
+  integrationBranch: string | null | undefined,
+  gitMainBranch: string | null | undefined,
+  branchExists: (branch: string) => boolean,
+): string | undefined {
+  if (integrationBranch) return integrationBranch;
+  return gitMainBranch &&
+    typeof gitMainBranch === "string" &&
+    gitMainBranch.length > 0 &&
+    branchExists(gitMainBranch)
+    ? gitMainBranch
+    : undefined;
+}
+
+/**
+ * Enter branch isolation mode for a milestone.
+ *
+ * Creates `milestone/<MID>` from the integration branch (if it doesn't
+ * exist yet) and checks out to it. No worktree directory is created — the
+ * project root is the working copy; only HEAD changes.
+ *
+ * Uses the same 3-tier integration-branch fallback as createAutoWorktree:
+ *   1. META.json recorded integration branch
+ *   2. git.main_branch preference
+ *   3. nativeDetectMainBranch (origin/HEAD auto-detection)
+ */
+export function enterBranchModeForMilestone(
+  basePath: string,
+  milestoneId: string,
+): void {
+  const branch = autoWorktreeBranch(milestoneId);
+  const branchExists = nativeBranchExists(basePath, branch);
+
+  if (!branchExists) {
+    // Create the milestone branch from the integration branch start-point.
+    const integrationBranch =
+      readIntegrationBranch(basePath, milestoneId) ?? undefined;
+    const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
+    const startPoint =
+      _resolveAutoWorktreeStartPoint(
+        integrationBranch,
+        gitPrefs?.main_branch,
+        (branchName) => nativeBranchExists(basePath, branchName),
+      ) ??
+      nativeDetectMainBranch(basePath);
+
+    // TOCTOU ancestry guard (Issue #4980 HIGH-3).
+    //
+    // The outer `branchExists` check is racy: a concurrent process
+    // (parallel-orchestrator worker, side-by-side `gsd` instance, or manual
+    // `git branch` invocation) may have created the branch with real commits
+    // between that check and this point. `nativeBranchForceReset` does
+    // `git branch -f`, which silently overwrites the branch ref — orphaning
+    // any commits not reachable from `startPoint`. Re-check immediately
+    // before the destructive call and refuse if the branch suddenly exists
+    // with non-ancestor commits.
+    const concurrentlyCreated = nativeBranchExists(basePath, branch);
+    if (
+      concurrentlyCreated &&
+      !nativeIsAncestor(basePath, branch, startPoint)
+    ) {
+      throw new GSDError(
+        GSD_GIT_ERROR,
+        `Branch "${branch}" was created concurrently with commits not reachable from "${startPoint}". ` +
+        `Refusing to force-reset — would orphan prior work. ` +
+        `Resume the existing milestone or run \`git branch -D ${branch}\` to discard.`,
+      );
+    }
+    // nativeBranchForceReset creates (or resets) branch at startPoint,
+    // then checkout switches HEAD to it.
+    nativeBranchForceReset(basePath, branch, startPoint);
+    debugLog("auto-worktree", {
+      action: "enterBranchMode",
+      milestoneId,
+      branch,
+      startPoint,
+      created: true,
+    });
+  } else {
+    debugLog("auto-worktree", {
+      action: "enterBranchMode",
+      milestoneId,
+      branch,
+      reused: true,
+    });
+  }
+
+  checkoutBranchWithStashGuard(
+    basePath,
+    branch,
+    `enter-branch-mode:${milestoneId}`,
+  );
+}
+
+/**
+ * True when `branch` is checked out in any worktree listed by
+ * `git worktree list --porcelain`. Used to gate ref updates that would
+ * otherwise leave a concurrent worktree's HEAD inconsistent with its
+ * index/working tree (Codex peer-review of #5538-followup).
+ *
+ * Best-effort: a `nativeWorktreeList` failure returns true so we err on
+ * the side of NOT moving the ref. Better to skip a fast-forward than to
+ * silently corrupt another worktree.
+ */
+export function _isBranchCheckedOutElsewhere(
+  basePath: string,
+  branch: string,
+): boolean {
+  try {
+    const entries = nativeWorktreeList(basePath);
+    return entries.some((entry) => entry.branch === branch);
+  } catch {
+    return true;
+  }
+}
+
+/**
+ * Resolve the integration branch using the same 3-tier fallback as the
+ * fresh-create path: META.json → git.main_branch preference → detected
+ * main branch. Returns null when no usable target exists.
+ */
+function resolveIntegrationBranchForReuse(
+  basePath: string,
+  milestoneId: string,
+): string | null {
+  const fromMeta = readIntegrationBranch(basePath, milestoneId);
+  if (fromMeta) return fromMeta;
+
+  const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
+  const fromPref = gitPrefs?.main_branch &&
+    typeof gitPrefs.main_branch === "string" &&
+    gitPrefs.main_branch.length > 0 &&
+    nativeBranchExists(basePath, gitPrefs.main_branch)
+    ? gitPrefs.main_branch
+    : null;
+  if (fromPref) return fromPref;
+
+  try {
+    return nativeDetectMainBranch(basePath);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * When reusing an existing milestone branch, fast-forward it onto the
+ * integration branch when that's safe (branch is a strict ancestor of
+ * integration — no commits would be lost). Skips when the branch has its
+ * own commits ahead of integration, when the integration branch can't be
+ * resolved, or when any git operation fails — the merge gate at milestone
+ * completion will surface real divergence as a conflict.
+ *
+ * The previous behavior re-attached the worktree to whatever stale tip
+ * the branch held, which caused new milestone work to fork from a base
+ * missing prior milestones' merges (#5538-followup).
+ */
+export function fastForwardReusedMilestoneBranchIfSafe(
+  basePath: string,
+  milestoneId: string,
+  branch: string,
+): void {
+  try {
+    const integrationBranch = resolveIntegrationBranchForReuse(
+      basePath,
+      milestoneId,
+    );
+    if (!integrationBranch || integrationBranch === branch) return;
+    if (!nativeBranchExists(basePath, integrationBranch)) return;
+
+    // Pure fast-forward only: branch must be a strict ancestor of integration.
+    // If the branch has its own commits ahead, leave it alone.
+    if (!nativeIsAncestor(basePath, branch, integrationBranch)) {
+      debugLog("createAutoWorktree", {
+        phase: "skip-ff-branch-not-ancestor",
+        milestoneId,
+        branch,
+        integration: integrationBranch,
+      });
+      return;
+    }
+
+    // Codex peer-review: `nativeUpdateRef` succeeds even when the branch is
+    // currently checked out in another worktree, leaving that worktree's HEAD
+    // inconsistent with its index/work tree. Skip the fast-forward if any
+    // listed worktree has this branch checked out — the merge gate at
+    // milestone-completion will surface stale-base divergence as a conflict
+    // instead of silently corrupting the other worktree's state.
+    if (_isBranchCheckedOutElsewhere(basePath, branch)) {
+      debugLog("createAutoWorktree", {
+        phase: "skip-ff-branch-checked-out-elsewhere",
+        milestoneId,
+        branch,
+      });
+      return;
+    }
+
+    nativeUpdateRef(basePath, `refs/heads/${branch}`, integrationBranch);
+    debugLog("createAutoWorktree", {
+      phase: "fast-forward-reused-branch",
+      milestoneId,
+      branch,
+      integration: integrationBranch,
+    });
+  } catch (err) {
+    debugLog("createAutoWorktree", {
+      phase: "fast-forward-reused-branch-failed",
+      milestoneId,
+      branch,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  }
+}

package/src/resources/extensions/gsd/auto-worktree-cleanup.ts

@@ -0,0 +1,166 @@
+// gsd-pi — Auto-worktree cleanup helpers.
+//
+// Owns shared cleanup primitives used by teardown and merge cleanup paths:
+// same-file DB reconciliation checks, transient project-root state removal,
+// git pathspec conversion for externally-rooted .gsd paths, and expected
+// unlink error classification.
+
+import { execFileSync } from "node:child_process";
+import { existsSync, realpathSync, unlinkSync } from "node:fs";
+import { isAbsolute, join, relative } from "node:path";
+
+import { gsdRoot } from "./paths.js";
+import { logWarning } from "./workflow-logger.js";
+
+function isSamePath(a: string, b: string): boolean {
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") return false;
+    logWarning("worktree", `isSamePath failed: ${(e as Error).message}`);
+    return false;
+  }
+}
+
+export function _isSamePath(a: string, b: string): boolean {
+  return isSamePath(a, b);
+}
+
+export function _shouldReconcileWorktreeDb(
+  worktreeDbPath: string,
+  mainDbPath: string,
+  pathExists: (path: string) => boolean = existsSync,
+  samePath: (a: string, b: string) => boolean = isSamePath,
+): boolean {
+  return pathExists(worktreeDbPath) && !samePath(worktreeDbPath, mainDbPath);
+}
+
+export function _isExpectedWorktreeUnlinkError(
+  code: string | undefined,
+): boolean {
+  return code === "ENOENT" || code === "EISDIR";
+}
+
+function gitPathspecForWorktreePath(
+  basePath: string,
+  targetPath: string,
+): string | null {
+  let base = basePath;
+  let target = targetPath;
+  try {
+    base = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8",
+    }).trim() || basePath;
+  } catch {
+    /* keep original */
+    void base;
+  }
+  try {
+    base = realpathSync.native(base);
+  } catch {
+    /* keep original */
+    void base;
+  }
+  try {
+    target = realpathSync.native(targetPath);
+  } catch {
+    /* keep original */
+    void target;
+  }
+
+  const rel = relative(base, target);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+  return rel.replaceAll("\\", "/");
+}
+
+export function _gitPathspecForWorktreePath(
+  basePath: string,
+  targetPath: string,
+): string | null {
+  return gitPathspecForWorktreePath(basePath, targetPath);
+}
+
+export function clearProjectRootStateFiles(
+  basePath: string,
+  milestoneId: string,
+): void {
+  const gsdDir = gsdRoot(basePath);
+  // Phase C pt 2: auto.lock removed from this list — the file is gone
+  // (migrated to the workers + unit_dispatches + runtime_kv tables). The
+  // remaining transient files (STATE.md, {MID}-META.json) are still
+  // worth removing on teardown.
+  const transientFiles = [
+    join(gsdDir, "STATE.md"),
+    join(gsdDir, "milestones", milestoneId, `${milestoneId}-META.json`),
+  ];
+
+  for (const file of transientFiles) {
+    try {
+      unlinkSync(file);
+    } catch (err) {
+      // ENOENT is expected — file may not exist (#3597)
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        logWarning(
+          "worktree",
+          `file unlink failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+  }
+
+  // Clean up legacy synced milestone directories and runtime/units.
+  // Older versions copied these into the project root during execution.
+  // If they remain as untracked files when we attempt
+  // `git merge --squash`, git rejects the merge with "local changes would
+  // be overwritten", causing silent data loss (#1738).
+  const syncedDirs = [
+    join(gsdDir, "milestones", milestoneId),
+    join(gsdDir, "runtime", "units"),
+  ];
+
+  for (const dir of syncedDirs) {
+    try {
+      if (!existsSync(dir)) continue;
+
+      const pathspec = gitPathspecForWorktreePath(basePath, dir);
+      if (!pathspec) continue;
+
+      // Only remove files that are untracked by git — tracked files are
+      // managed by the branch checkout and should not be deleted.
+      const untrackedOutput = execFileSync(
+        "git",
+        ["ls-files", "--others", "--exclude-standard", pathspec],
+        {
+          cwd: basePath,
+          stdio: ["ignore", "pipe", "pipe"],
+          encoding: "utf-8",
+        },
+      ).trim();
+      if (!untrackedOutput) continue;
+
+      for (const f of untrackedOutput.split("\n").filter(Boolean)) {
+        try {
+          unlinkSync(join(basePath, f));
+        } catch (err) {
+          // ENOENT/EISDIR are expected for already-removed or
+          // directory entries (#3597).
+          const code = (err as NodeJS.ErrnoException).code;
+          if (!_isExpectedWorktreeUnlinkError(code)) {
+            logWarning(
+              "worktree",
+              `untracked file unlink failed: ${err instanceof Error ? err.message : String(err)}`,
+            );
+          }
+        }
+      }
+    } catch (err) {
+      /* non-fatal — git command may fail if not in repo */
+      logWarning(
+        "worktree",
+        `untracked file cleanup failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+}

package/src/resources/extensions/gsd/auto-worktree-conflict-auto-resolve.ts

@@ -0,0 +1,37 @@
+// gsd-pi — Conflict auto-resolve policy for auto-worktree merges.
+//
+// Owns the pure path policy for conflict paths that are safe to resolve
+// mechanically. Git mutation stays in git-conflict-resolve.ts.
+
+/** Patterns for machine-generated build artifacts that can be safely
+ * auto-resolved by accepting --theirs during merge. These files are
+ * regenerable and never contain meaningful manual edits. */
+export const SAFE_AUTO_RESOLVE_PATTERNS: RegExp[] = [
+  /\.tsbuildinfo$/,
+  /\.pyc$/,
+  /\/__pycache__\//,
+  /\.DS_Store$/,
+  /\.map$/,
+  // Regenerable dependency lockfiles. These are fully derivable from their
+  // manifests by the package manager, so accepting the merge side during
+  // auto-resolve clears the conflict markers without losing meaningful edits —
+  // and stops auto-mode from hard-pausing on a lockfile conflict (issue #828).
+  /(?:^|\/)pnpm-lock\.yaml$/,
+  /(?:^|\/)package-lock\.json$/,
+  /(?:^|\/)npm-shrinkwrap\.json$/,
+  /(?:^|\/)yarn\.lock$/,
+  /(?:^|\/)bun\.lockb?$/,
+  /(?:^|\/)Cargo\.lock$/,
+  /(?:^|\/)composer\.lock$/,
+  /(?:^|\/)Gemfile\.lock$/,
+  /(?:^|\/)Pipfile\.lock$/,
+  /(?:^|\/)poetry\.lock$/,
+];
+
+/** Returns true if the file path is safe to auto-resolve during merge.
+ * Covers `.gsd/` state files, common build artifacts, and regenerable
+ * dependency lockfiles. */
+export function isSafeToAutoResolve(filePath: string): boolean {
+  return filePath.startsWith(".gsd/")
+    || SAFE_AUTO_RESOLVE_PATTERNS.some((re) => re.test(filePath));
+}