@opengsd/gsd-pi 1.5.0 → 1.6.0-dev.aa7f94e8

package/dist/resources/extensions/gsd/auto-start.js

@@ -27,18 +27,19 @@ import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchList, nativeBranchExists, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, nativeHasChanges, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
-import { getAutoWorktreePath } from "./auto-worktree.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, openWorkflowDatabase, resolveProjectRootDbPath, } from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
@@ -118,36 +119,42 @@ export function reconcileProjectMilestonesFromDisk(basePath) {
 export function reconcileMergedMilestonesFromJournal(basePath) {
     if (!isDbAvailable())
         return 0;
-    const mergedAtByMilestone = new Map();
-    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;
-        }
-        if (!isClosedStatus(existing.status)) {
-            updateMilestoneStatus(milestoneId, "complete", completedAt);
-            closed++;
+    try {
+        const mergedAtByMilestone = new Map();
+        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;
+            }
+            if (!isClosedStatus(existing.status)) {
+                updateMilestoneStatus(milestoneId, "complete", completedAt);
+                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;
     }
-    if (closed > 0)
-        invalidateAllCaches();
-    return closed;
 }
 export function decideSurvivorAction(hasSurvivorBranch, phase) {
     if (!hasSurvivorBranch)
@@ -1253,6 +1260,10 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         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) => {
@@ -1376,6 +1387,19 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             ctx.ui.notify(`SQLite database exists but failed to open: ${gsdDbPath}. ${phaseHint}${errorDetail}.${providerHint}`, "error");
             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);
         // Initialize routing history
@@ -1409,7 +1433,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
         // Snapshot installed skills
         if (resolveSkillDiscoveryMode(base) !== "off") {
-            snapshotSkills();
+            snapshotSkills({ cwd: s.basePath });
         }
         setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);

package/dist/resources/extensions/gsd/auto-timeout-recovery.js

@@ -8,6 +8,8 @@ import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, verifyExpectedAr
 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 async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rctx) {
     // Note on turn epoch: the bump is intentionally NOT unconditional at
     // function entry. Two branches below (the "steering retry" paths) keep
@@ -79,11 +81,15 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
                     "Immediately finish the required durable output for this unit.",
                     "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}).`, "warning");
             return "recovered";
         }
@@ -176,11 +182,15 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
                 "Write the required artifact now.",
                 "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}).`, "warning");
         return "recovered";
     }

package/dist/resources/extensions/gsd/auto-timers.js

@@ -11,6 +11,7 @@ import { resolveAutoSupervisorConfig } from "./preferences.js";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
 import { getInFlightToolCount, getOldestInFlightToolStart, clearInFlightTools, hasInteractiveToolInFlight, } from "./auto-tool-tracking.js";
 import { detectWorkingTreeActivity } from "./auto-supervisor.js";
+import { applySupervisorModelIfConfigured } from "./auto-model-selection.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { saveActivityLog } from "./activity-log.js";
 import { recoverTimedOutUnit } from "./auto-timeout-recovery.js";
@@ -113,7 +114,7 @@ export function startUnitSupervision(sctx) {
         ? supervisor.stalled_tool_timeout_minutes * 60 * 1000
         : idleTimeoutMs;
     // ── 1. Soft timeout warning ──
-    s.wrapupWarningHandle = setTimeout(() => {
+    s.wrapupWarningHandle = setTimeout(async () => {
         s.wrapupWarningHandle = null;
         if (!s.active || !s.currentUnit)
             return;
@@ -125,6 +126,9 @@ export function startUnitSupervision(sctx) {
         // 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",
             display: s.verbose,
@@ -291,7 +295,7 @@ export function startUnitSupervision(sctx) {
     }
     const executorContextWindow = resolveExecutorContextWindow(ctx.modelRegistry, prefs, ctx.model?.contextWindow, 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);
@@ -316,6 +320,9 @@ export function startUnitSupervision(sctx) {
         }
         // 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",
             display: s.verbose,

package/dist/resources/extensions/gsd/auto-worktree-branch-lifecycle.js

@@ -0,0 +1,189 @@
+// 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) {
+    return `milestone/${milestoneId}`;
+}
+export function _resolveAutoWorktreeStartPoint(integrationBranch, gitMainBranch, branchExists) {
+    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, milestoneId) {
+    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, branch) {
+    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, milestoneId) {
+    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, milestoneId, branch) {
+    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/dist/resources/extensions/gsd/auto-worktree-cleanup.js

@@ -0,0 +1,133 @@
+// 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, b) {
+    try {
+        return realpathSync(a) === realpathSync(b);
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return false;
+        logWarning("worktree", `isSamePath failed: ${e.message}`);
+        return false;
+    }
+}
+export function _isSamePath(a, b) {
+    return isSamePath(a, b);
+}
+export function _shouldReconcileWorktreeDb(worktreeDbPath, mainDbPath, pathExists = existsSync, samePath = isSamePath) {
+    return pathExists(worktreeDbPath) && !samePath(worktreeDbPath, mainDbPath);
+}
+export function _isExpectedWorktreeUnlinkError(code) {
+    return code === "ENOENT" || code === "EISDIR";
+}
+function gitPathspecForWorktreePath(basePath, targetPath) {
+    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, targetPath) {
+    return gitPathspecForWorktreePath(basePath, targetPath);
+}
+export function clearProjectRootStateFiles(basePath, milestoneId) {
+    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.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.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/dist/resources/extensions/gsd/auto-worktree-conflict-auto-resolve.js

@@ -0,0 +1,35 @@
+// 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 = [
+    /\.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) {
+    return filePath.startsWith(".gsd/")
+        || SAFE_AUTO_RESOLVE_PATTERNS.some((re) => re.test(filePath));
+}