gsd-pi 2.54.0 → 2.55.0-dev.9ec7cdf

package/src/resources/extensions/bg-shell/bg-shell-lifecycle.ts

@@ -22,7 +22,7 @@ import {
 	loadManifest,
 	pruneDeadProcesses,
 } from "./process-manager.js";
-import { formatUptime, resolveBgShellPersistenceCwd } from "./utilities.js";
+import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { formatTokenCount } from "../shared/format-utils.js";
 
 import type { BgShellSharedState } from "./index.js";
@@ -213,7 +213,7 @@ export function registerBgShellLifecycle(pi: ExtensionAPI, state: BgShellSharedS
 			return {
 				render(width: number): string[] {
 					// ── Line 1: pwd (branch) [session]  ...  bg status ──
-					let pwd = process.cwd();
+					let pwd = getBgShellLiveCwd(state.latestCtx?.cwd);
 					const home = process.env.HOME || process.env.USERPROFILE;
 					if (home && pwd.startsWith(home)) {
 						pwd = `~${pwd.slice(home.length)}`;

package/src/resources/extensions/bg-shell/utilities.ts

@@ -42,16 +42,51 @@ export function formatTimeAgo(timestamp: number): string {
 	return formatDuration(Date.now() - timestamp) + " ago";
 }
 
+function deriveProjectRootFromAutoWorktree(cachedCwd?: string): string | undefined {
+	if (!cachedCwd) return undefined;
+	const match = cachedCwd.match(/^(.*?)[\\/]\.gsd[\\/]worktrees[\\/][^\\/]+(?:[\\/].*)?$/);
+	return match?.[1];
+}
+
+export function getBgShellLiveCwd(
+	cachedCwd?: string,
+	pathExists: (path: string) => boolean = existsSync,
+	getCwd: () => string = () => process.cwd(),
+	chdir: (path: string) => void = (path) => process.chdir(path),
+): string {
+	try {
+		return getCwd();
+	} catch {
+		const projectRoot = deriveProjectRootFromAutoWorktree(cachedCwd);
+		const home = process.env.HOME || process.env.USERPROFILE;
+		const fallbacks = [projectRoot, cachedCwd, home, "/"].filter(
+			(candidate): candidate is string => Boolean(candidate),
+		);
+
+		for (const candidate of fallbacks) {
+			if (candidate !== "/" && !pathExists(candidate)) continue;
+			try {
+				chdir(candidate);
+			} catch {
+				// Best-effort only. Returning a known-good fallback is enough to avoid crashes.
+			}
+			return candidate;
+		}
+
+		return "/";
+	}
+}
 
 export function resolveBgShellPersistenceCwd(
 	cachedCwd: string,
-	liveCwd = process.cwd(),
+	liveCwd: string | undefined = undefined,
 	pathExists: (path: string) => boolean = existsSync,
 ): string {
+	const resolvedLiveCwd = liveCwd ?? getBgShellLiveCwd(cachedCwd, pathExists);
 	const cachedIsAutoWorktree = /(?:^|[\\/])\.gsd[\\/]worktrees[\\/]/.test(cachedCwd);
 	if (!cachedIsAutoWorktree) return cachedCwd;
-	if (cachedCwd === liveCwd && pathExists(cachedCwd)) return cachedCwd;
-	if (!pathExists(cachedCwd)) return liveCwd;
-	if (liveCwd !== cachedCwd) return liveCwd;
+	if (cachedCwd === resolvedLiveCwd && pathExists(cachedCwd)) return cachedCwd;
+	if (!pathExists(cachedCwd)) return resolvedLiveCwd;
+	if (resolvedLiveCwd !== cachedCwd) return resolvedLiveCwd;
 	return cachedCwd;
 }

package/src/resources/extensions/gsd/auto/phases.ts

@@ -45,6 +45,17 @@ export function _resolveReportBasePath(s: Pick<AutoSession, "originalBasePath" |
   return s.originalBasePath || s.basePath;
 }
 
+/**
+ * Resolve the authoritative project base for dispatch guards.
+ * Prior-milestone completion lives at the project root, even when the active
+ * unit is running inside an auto worktree.
+ */
+export function _resolveDispatchGuardBasePath(
+  s: Pick<AutoSession, "originalBasePath" | "basePath">,
+): string {
+  return s.originalBasePath || s.basePath;
+}
+
 /**
  * Generate and write an HTML milestone report snapshot.
  * Extracted from the milestone-transition block in autoLoop.
@@ -667,9 +678,10 @@ export async function runDispatch(
     prompt = preDispatchResult.prompt;
   }
 
+  const guardBasePath = _resolveDispatchGuardBasePath(s);
   const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(
-    s.basePath,
-    deps.getMainBranch(s.basePath),
+    guardBasePath,
+    deps.getMainBranch(guardBasePath),
     unitType,
     unitId,
   );
@@ -707,8 +719,17 @@ export async function runGuards(
   const budgetCeiling = prefs?.budget_ceiling;
   if (budgetCeiling !== undefined && budgetCeiling > 0) {
     const currentLedger = deps.getLedger() as { units: unknown } | null;
-    const totalCost = currentLedger
-      ? deps.getProjectTotals(currentLedger.units).cost
+    // In parallel worker mode, only count cost from the current auto-mode session
+    // to avoid hitting the ceiling due to historical project-wide spend (#2184).
+    let costUnits = currentLedger?.units;
+    if (process.env.GSD_PARALLEL_WORKER && s.autoStartTime && Array.isArray(costUnits)) {
+      const sessionStartISO = new Date(s.autoStartTime).toISOString();
+      costUnits = costUnits.filter(
+        (u: { startedAt?: string }) => u.startedAt != null && u.startedAt >= sessionStartISO,
+      );
+    }
+    const totalCost = costUnits
+      ? deps.getProjectTotals(costUnits).cost
       : 0;
     const budgetPct = totalCost / budgetCeiling;
     const budgetAlertLevel = deps.getBudgetAlertLevel(budgetPct);

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

@@ -200,7 +200,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           uatContent ?? "",
           basePath,
         ),
-        pauseAfterDispatch: uatType !== "artifact-driven" && uatType !== "browser-executable" && uatType !== "runtime-executable",
+        pauseAfterDispatch: !process.env.GSD_HEADLESS && uatType !== "artifact-driven" && uatType !== "browser-executable" && uatType !== "runtime-executable",
       };
     },
   },

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -18,6 +18,26 @@ export interface ModelSelectionResult {
   routing: { tier: string; modelDowngraded: boolean } | null;
 }
 
+export function resolvePreferredModelConfig(
+  unitType: string,
+  autoModeStartModel: { provider: string; id: string } | null,
+) {
+  const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
+  if (explicitConfig) return explicitConfig;
+
+  const routingConfig = resolveDynamicRoutingConfig();
+  if (!routingConfig.enabled || !routingConfig.tier_models) return undefined;
+
+  const ceilingModel = routingConfig.tier_models.heavy
+    ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
+  if (!ceilingModel) return undefined;
+
+  return {
+    primary: ceilingModel,
+    fallbacks: [],
+  };
+}
+
 /**
  * Select and apply the appropriate model for a unit dispatch.
  * Handles: per-unit-type model preferences, dynamic complexity routing,
@@ -36,7 +56,7 @@ export async function selectAndApplyModel(
   autoModeStartModel: { provider: string; id: string } | null,
   retryContext?: { isRetry: boolean; previousTier?: string },
 ): Promise<ModelSelectionResult> {
-  const modelConfig = resolveModelWithFallbacksForUnit(unitType);
+  const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel);
   let routing: { tier: string; modelDowngraded: boolean } | null = null;
 
   if (modelConfig) {

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

@@ -87,6 +87,11 @@ function buildSourceFilePaths(
     paths.push(`- **Decisions**: \`${relGsdRootFile("DECISIONS")}\``);
   }
 
+  const queuePath = resolveGsdRootFile(base, "QUEUE");
+  if (existsSync(queuePath)) {
+    paths.push(`- **Queue**: \`${relGsdRootFile("QUEUE")}\``);
+  }
+
   const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
   if (contextPath) {
     paths.push(`- **Milestone Context**: \`${relMilestoneFile(base, mid, "CONTEXT")}\``);
@@ -915,6 +920,16 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
     const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
     if (decisionsInline) inlined.push(decisionsInline);
   }
+  const queuePath = resolveGsdRootFile(base, "QUEUE");
+  if (existsSync(queuePath)) {
+    const queueInline = await inlineFileSmart(
+      queuePath,
+      relGsdRootFile("QUEUE"),
+      "Project Queue",
+      `${mid} ${midTitle}`,
+    );
+    inlined.push(queueInline);
+  }
   const knowledgeInlinePM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
   if (knowledgeInlinePM) inlined.push(knowledgeInlinePM);
   inlined.push(inlineTemplate("roadmap", "Roadmap"));

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

@@ -131,6 +131,15 @@ export async function bootstrapAutoSession(
     return false;
   }
 
+  // Capture the user's session model before guided-flow dispatch can apply a
+  // phase-specific planning model for a discuss turn (#2829).
+  const startModelSnapshot = ctx.model
+    ? {
+        provider: ctx.model.provider,
+        id: ctx.model.id,
+      }
+    : null;
+
   try {
     // Validate GSD_PROJECT_ID early so the user gets immediate feedback
     const customProjectId = process.env.GSD_PROJECT_ID;
@@ -576,12 +585,11 @@ export async function bootstrapAutoSession(
     // Initialize routing history
     initRoutingHistory(s.basePath);
 
-    // Capture session's model at auto-mode start (#650)
-    const currentModel = ctx.model;
-    if (currentModel) {
+    // Restore the model that was active when auto bootstrap began (#650, #2829).
+    if (startModelSnapshot) {
       s.autoModeStartModel = {
-        provider: currentModel.provider,
-        id: currentModel.id,
+        provider: startModelSnapshot.provider,
+        id: startModelSnapshot.id,
       };
     }
 

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

@@ -65,6 +65,8 @@ import {
 } from "./native-git-bridge.js";
 
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
+const LEGACY_PROJECT_PREFERENCES_FILE = "preferences.md";
 
 // ─── Shared Constants & Helpers ─────────────────────────────────────────────
 
@@ -82,7 +84,7 @@ const ROOT_STATE_FILES = [
   "QUEUE.md",
   "completed-units.json",
   "metrics.json",
-  // NOTE: preferences.md is intentionally NOT in ROOT_STATE_FILES.
+  // NOTE: project preferences are intentionally NOT in ROOT_STATE_FILES.
   // Forward-sync (main → worktree) is handled explicitly in syncGsdStateToWorktree().
   // Back-sync (worktree → main) must NEVER overwrite the project root's copy
   // because the project root is authoritative for preferences (#2684).
@@ -196,6 +198,11 @@ export function syncProjectRootToWorktree(
   const prGsd = join(projectRoot, ".gsd");
   const wtGsd = join(worktreePath_, ".gsd");
 
+  // When .gsd is a symlink to the same external directory in both locations,
+  // cpSync rejects the copy because source === destination (ERR_FS_CP_EINVAL).
+  // Compare realpaths and skip when they resolve to the same physical path (#2184).
+  if (isSamePath(prGsd, wtGsd)) return;
+
   // Copy milestone directory from project root to worktree — additive only.
   // force:false prevents cpSync from overwriting existing worktree files.
   // Without this, worktree-authoritative files (e.g. VALIDATION.md written
@@ -245,6 +252,11 @@ export function syncStateToProjectRoot(
   const wtGsd = join(worktreePath_, ".gsd");
   const prGsd = join(projectRoot, ".gsd");
 
+  // When .gsd is a symlink to the same external directory in both locations,
+  // cpSync rejects the copy because source === destination (ERR_FS_CP_EINVAL).
+  // Compare realpaths and skip when they resolve to the same physical path (#2184).
+  if (isSamePath(wtGsd, prGsd)) return;
+
   // 1. STATE.md — the quick-glance status used by initial deriveState()
   safeCopy(join(wtGsd, "STATE.md"), join(prGsd, "STATE.md"), { force: true });
 
@@ -439,18 +451,25 @@ export function syncGsdStateToWorktree(
     }
   }
 
-  // Forward-sync preferences.md from project root to worktree (additive only).
-  // NOT in ROOT_STATE_FILES because syncWorktreeStateBack() must never overwrite
-  // the project root's preferences — the project root is authoritative (#2684).
+  // Forward-sync project preferences from project root to worktree (additive only).
+  // Prefer the canonical uppercase file name, but keep the legacy lowercase
+  // fallback so older repos still work on case-sensitive filesystems.
   {
-    const src = join(mainGsd, "preferences.md");
-    const dst = join(wtGsd, "preferences.md");
-    if (existsSync(src) && !existsSync(dst)) {
-      try {
-        cpSync(src, dst);
-        synced.push("preferences.md");
-      } catch {
-        /* non-fatal */
+    const worktreeHasPreferences = existsSync(join(wtGsd, PROJECT_PREFERENCES_FILE))
+      || existsSync(join(wtGsd, LEGACY_PROJECT_PREFERENCES_FILE));
+    if (!worktreeHasPreferences) {
+      for (const file of [PROJECT_PREFERENCES_FILE, LEGACY_PROJECT_PREFERENCES_FILE] as const) {
+        const src = join(mainGsd, file);
+        const dst = join(wtGsd, file);
+        if (existsSync(src)) {
+          try {
+            cpSync(src, dst);
+            synced.push(file);
+          } catch {
+            /* non-fatal */
+          }
+          break;
+        }
       }
     }
   }
@@ -985,11 +1004,25 @@ function copyPlanningArtifacts(srcBase: string, wtPath: string): void {
     "STATE.md",
     "KNOWLEDGE.md",
     "OVERRIDES.md",
-    "preferences.md",
   ]) {
     safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
   }
 
+  // Seed canonical PREFERENCES.md when available; fall back to legacy lowercase.
+  if (existsSync(join(srcGsd, PROJECT_PREFERENCES_FILE))) {
+    safeCopy(
+      join(srcGsd, PROJECT_PREFERENCES_FILE),
+      join(dstGsd, PROJECT_PREFERENCES_FILE),
+      { force: true },
+    );
+  } else if (existsSync(join(srcGsd, LEGACY_PROJECT_PREFERENCES_FILE))) {
+    safeCopy(
+      join(srcGsd, LEGACY_PROJECT_PREFERENCES_FILE),
+      join(dstGsd, LEGACY_PROJECT_PREFERENCES_FILE),
+      { force: true },
+    );
+  }
+
   // Shared WAL (R012): worktrees use the project root's DB directly.
   // No longer copy gsd.db into the worktree — the DB path resolver in
   // ensureDbOpen() detects the worktree location and opens the root DB.

package/src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts

@@ -7,6 +7,7 @@ import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto-loop.js";
 import { resolveModelId } from "../auto-model-selection.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
+import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import {
   classifyError,
   createRetryState,
@@ -44,10 +45,10 @@ async function pauseTransientWithBackoff(
     retryAfterMs,
     resume: allowAutoResume
       ? () => {
-        pi.sendMessage(
-          { customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false },
-          { triggerTurn: true },
-        );
+        void resumeAutoAfterProviderDelay(pi, ctx).catch((err) => {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(`Provider error recovery delay elapsed, but auto-mode failed to resume: ${message}`, "error");
+        });
       }
       : undefined,
   });

package/src/resources/extensions/gsd/bootstrap/provider-error-resume.ts

@@ -0,0 +1,53 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+} from "@gsd/pi-coding-agent";
+
+import { getAutoDashboardData, startAuto, type AutoDashboardData } from "../auto.js";
+
+type AutoResumeSnapshot = Pick<AutoDashboardData, "active" | "paused" | "stepMode" | "basePath">;
+
+export interface ProviderErrorResumeDeps {
+  getSnapshot(): AutoResumeSnapshot;
+  startAuto(
+    ctx: ExtensionCommandContext,
+    pi: ExtensionAPI,
+    base: string,
+    verboseMode: boolean,
+    options?: { step?: boolean },
+  ): Promise<void>;
+}
+
+const defaultDeps: ProviderErrorResumeDeps = {
+  getSnapshot: () => getAutoDashboardData(),
+  startAuto,
+};
+
+export async function resumeAutoAfterProviderDelay(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  deps: ProviderErrorResumeDeps = defaultDeps,
+): Promise<"resumed" | "already-active" | "not-paused" | "missing-base"> {
+  const snapshot = deps.getSnapshot();
+
+  if (snapshot.active) return "already-active";
+  if (!snapshot.paused) return "not-paused";
+
+  if (!snapshot.basePath) {
+    ctx.ui.notify(
+      "Provider error recovery delay elapsed, but no paused auto-mode base path was available. Leaving auto-mode paused.",
+      "warning",
+    );
+    return "missing-base";
+  }
+
+  await deps.startAuto(
+    ctx as ExtensionCommandContext,
+    pi,
+    snapshot.basePath,
+    false,
+    { step: snapshot.stepMode },
+  );
+  return "resumed";
+}

package/src/resources/extensions/gsd/bootstrap/register-extension.ts

@@ -9,14 +9,28 @@ import { registerJournalTools } from "./journal-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 
+export function handleRecoverableExtensionProcessError(err: Error): boolean {
+  if ((err as NodeJS.ErrnoException).code === "EPIPE") {
+    process.exit(0);
+  }
+  if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+    const syscall = (err as NodeJS.ErrnoException).syscall;
+    if (syscall?.startsWith("spawn")) {
+      process.stderr.write(`[gsd] spawn ENOENT: ${(err as any).path ?? "unknown"} — command not found\n`);
+      return true;
+    }
+    if (syscall === "uv_cwd") {
+      process.stderr.write(`[gsd] ENOENT (${syscall}): ${err.message}\n`);
+      return true;
+    }
+  }
+  return false;
+}
+
 function installEpipeGuard(): void {
   if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
     const _gsdEpipeGuard = (err: Error): void => {
-      if ((err as NodeJS.ErrnoException).code === "EPIPE") {
-        process.exit(0);
-      }
-      if ((err as NodeJS.ErrnoException).code === "ENOENT" && (err as any).syscall?.startsWith("spawn")) {
-        process.stderr.write(`[gsd] spawn ENOENT: ${(err as any).path ?? "unknown"} — command not found\n`);
+      if (handleRecoverableExtensionProcessError(err)) {
         return;
       }
       throw err;
@@ -45,4 +59,3 @@ export function registerGsdExtension(pi: ExtensionAPI): void {
   registerShortcuts(pi);
   registerHooks(pi);
 }
-

package/src/resources/extensions/gsd/bootstrap/register-shortcuts.ts

@@ -5,6 +5,7 @@ import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 import { Key } from "@gsd/pi-tui";
 
 import { GSDDashboardOverlay } from "../dashboard-overlay.js";
+import { ParallelMonitorOverlay } from "../parallel-monitor-overlay.js";
 import { shortcutDesc } from "../../shared/mod.js";
 
 export function registerShortcuts(pi: ExtensionAPI): void {
@@ -29,4 +30,27 @@ export function registerShortcuts(pi: ExtensionAPI): void {
       );
     },
   });
+
+  pi.registerShortcut(Key.ctrlAlt("p"), {
+    description: shortcutDesc("Open parallel worker monitor", "/gsd parallel watch"),
+    handler: async (ctx) => {
+      const parallelDir = join(process.cwd(), ".gsd", "parallel");
+      if (!existsSync(parallelDir)) {
+        ctx.ui.notify("No parallel workers found. Run /gsd parallel start first.", "info");
+        return;
+      }
+      await ctx.ui.custom<void>(
+        (tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done()),
+        {
+          overlay: true,
+          overlayOptions: {
+            width: "90%",
+            minWidth: 80,
+            maxHeight: "92%",
+            anchor: "center",
+          },
+        },
+      );
+    },
+  });
 }

package/src/resources/extensions/gsd/commands/catalog.ts

@@ -59,7 +59,7 @@ export const TOP_LEVEL_SUBCOMMANDS: readonly GsdCommandDefinition[] = [
   { cmd: "inspect", desc: "Show SQLite DB diagnostics" },
   { cmd: "knowledge", desc: "Add persistent project knowledge (rule, pattern, or lesson)" },
   { cmd: "new-milestone", desc: "Create a milestone from a specification document (headless)" },
-  { cmd: "parallel", desc: "Parallel milestone orchestration (start, status, stop, merge)" },
+  { cmd: "parallel", desc: "Parallel milestone orchestration (start, status, stop, merge, watch)" },
   { cmd: "cmux", desc: "Manage cmux integration (status, sidebar, notifications, splits)" },
   { cmd: "park", desc: "Park a milestone — skip without deleting" },
   { cmd: "unpark", desc: "Reactivate a parked milestone" },
@@ -100,6 +100,7 @@ const NESTED_COMPLETIONS: CompletionMap = {
     { cmd: "pause", desc: "Pause a specific worker" },
     { cmd: "resume", desc: "Resume a paused worker" },
     { cmd: "merge", desc: "Merge completed milestone branches" },
+    { cmd: "watch", desc: "Live TUI dashboard monitoring all workers" },
   ],
   setup: [
     { cmd: "llm", desc: "Configure LLM provider settings" },

package/src/resources/extensions/gsd/commands/handlers/parallel.ts

@@ -111,7 +111,25 @@ export async function handleParallelCommand(trimmed: string, _ctx: ExtensionComm
     return true;
   }
 
-  emitParallelMessage(pi, `Unknown parallel subcommand "${subcommand}". Usage: /gsd parallel [start|status|stop|pause|resume|merge]`);
+  if (subcommand === "watch") {
+    const root = projectRoot();
+    const { ParallelMonitorOverlay } = await import("../../parallel-monitor-overlay.js");
+    await _ctx.ui.custom<void>(
+      (tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(), root),
+      {
+        overlay: true,
+        overlayOptions: {
+          width: "90%",
+          minWidth: 80,
+          maxHeight: "92%",
+          anchor: "center",
+        },
+      },
+    );
+    return true;
+  }
+
+  emitParallelMessage(pi, `Unknown parallel subcommand "${subcommand}". Usage: /gsd parallel [start|status|stop|pause|resume|merge|watch]`);
   return true;
 }
 

package/src/resources/extensions/gsd/crash-recovery.ts

@@ -14,8 +14,7 @@ import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
-
-const LOCK_FILE = "auto.lock";
+import { effectiveLockFile } from "./session-lock.js";
 
 export interface LockData {
   pid: number;
@@ -28,7 +27,7 @@ export interface LockData {
 }
 
 function lockPath(basePath: string): string {
-  return join(gsdRoot(basePath), LOCK_FILE);
+  return join(gsdRoot(basePath), effectiveLockFile());
 }
 
 /** Write or update the lock file with current auto-mode state. */