gsd-pi 2.35.0-dev.30eec3f → 2.35.0-dev.640d5c7

package/dist/resources/extensions/gsd/files.js

@@ -705,7 +705,7 @@ export async function inlinePriorMilestoneSummary(mid, base) {
  * Returns `null` when no manifest file exists (path resolution failure or
  * file not on disk) - callers can distinguish "no manifest" from "empty manifest".
  */
-export async function getManifestStatus(base, milestoneId, projectRoot) {
+export async function getManifestStatus(base, milestoneId) {
     const resolvedPath = resolveMilestoneFile(base, milestoneId, 'SECRETS');
     if (!resolvedPath)
         return null;
@@ -714,16 +714,8 @@ export async function getManifestStatus(base, milestoneId, projectRoot) {
         return null;
     const manifest = parseSecretsManifest(content);
     const keys = manifest.entries.map(e => e.key);
-    // Check both the base path .env AND the project root .env (#1387).
-    // In worktree mode, base is the worktree path which may not have .env.
-    // The project root's .env is where the user actually defined their keys.
     const existingKeys = await checkExistingEnvKeys(keys, resolve(base, '.env'));
     const existingSet = new Set(existingKeys);
-    if (projectRoot && projectRoot !== base) {
-        const rootKeys = await checkExistingEnvKeys(keys, resolve(projectRoot, '.env'));
-        for (const k of rootKeys)
-            existingSet.add(k);
-    }
     const result = {
         pending: [],
         collected: [],

package/dist/resources/extensions/gsd/gitignore.js

@@ -6,8 +6,8 @@
  * Both idempotent — non-destructive if already present.
  */
 import { join } from "node:path";
-import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
-import { nativeRmCached, nativeLsFiles } from "./native-git-bridge.js";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { nativeRmCached } from "./native-git-bridge.js";
 import { gsdRoot } from "./paths.js";
 /**
  * GSD runtime patterns for git index cleanup.
@@ -67,48 +67,12 @@ const BASELINE_PATTERNS = [
     "tmp/",
 ];
 /**
- * Check whether `.gsd/` contains files tracked by git.
- * If so, the project intentionally keeps `.gsd/` in version control
- * and we must NOT add `.gsd` to `.gitignore` or attempt migration.
- *
- * Returns true if git tracks at least one file under `.gsd/`.
- * Returns false (safe to ignore) if:
- *   - Not a git repo
- *   - `.gsd/` is a symlink (external state, should be ignored)
- *   - `.gsd/` doesn't exist
- *   - No tracked files found under `.gsd/`
- */
-export function hasGitTrackedGsdFiles(basePath) {
-    const localGsd = join(basePath, ".gsd");
-    // If .gsd doesn't exist or is already a symlink, no tracked files concern
-    if (!existsSync(localGsd))
-        return false;
-    try {
-        if (lstatSync(localGsd).isSymbolicLink())
-            return false;
-    }
-    catch {
-        return false;
-    }
-    // Check if git tracks any files under .gsd/
-    try {
-        const tracked = nativeLsFiles(basePath, ".gsd");
-        return tracked.length > 0;
-    }
-    catch {
-        // Not a git repo or git not available — safe to proceed
-        return false;
-    }
-}
-/**
- * Ensure basePath/.gitignore contains baseline ignore patterns.
- * Creates the file if missing; appends missing patterns.
+ * Ensure basePath/.gitignore contains a blanket `.gsd/` ignore.
+ * Creates the file if missing; appends `.gsd/` if not present.
  * Returns true if the file was created or modified, false if already complete.
  *
- * **Safety check:** If `.gsd/` contains git-tracked files (i.e., the project
- * intentionally keeps `.gsd/` in version control), the `.gsd` ignore pattern
- * is excluded to prevent data loss. Only the `.gsd` pattern is affected —
- * all other baseline patterns are still applied normally.
+ * `.gsd/` state is managed externally (symlinked to `~/.gsd/projects/<hash>/`),
+ * so the entire directory is always gitignored.
  */
 export function ensureGitignore(basePath, options) {
     // If manage_gitignore is explicitly false, do not touch .gitignore at all
@@ -124,14 +88,8 @@ export function ensureGitignore(basePath, options) {
         .split("\n")
         .map((l) => l.trim())
         .filter((l) => l && !l.startsWith("#")));
-    // Determine which patterns to apply. If .gsd/ has tracked files,
-    // exclude the ".gsd" pattern to prevent deleting tracked state.
-    const gsdIsTracked = hasGitTrackedGsdFiles(basePath);
-    const patternsToApply = gsdIsTracked
-        ? BASELINE_PATTERNS.filter((p) => p !== ".gsd")
-        : BASELINE_PATTERNS;
     // Find patterns not yet present
-    const missing = patternsToApply.filter((p) => !existingLines.has(p));
+    const missing = BASELINE_PATTERNS.filter((p) => !existingLines.has(p));
     if (missing.length === 0)
         return false;
     // Build the block to append
@@ -153,11 +111,6 @@ export function ensureGitignore(basePath, options) {
  * already in the index even after .gitignore is updated.
  *
  * Only removes from the index (`--cached`), never from disk. Idempotent.
- *
- * Note: These are strictly runtime/ephemeral paths (activity logs, lock files,
- * metrics, STATE.md). They are always safe to untrack, even when the project
- * intentionally keeps other `.gsd/` files (like PROJECT.md, milestones/) in
- * version control.
  */
 export function untrackRuntimeFiles(basePath) {
     const runtimePaths = GSD_RUNTIME_PATTERNS;

package/dist/resources/extensions/gsd/guided-flow.js

@@ -154,7 +154,7 @@ function parseMilestoneSequenceFromProject(content) {
  * This is the only way the wizard triggers work — everything else is the LLM's job.
  */
 function dispatchWorkflow(pi, note, customType = "gsd-run") {
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({
         customType,

package/dist/resources/extensions/gsd/health-widget.js

@@ -11,23 +11,21 @@ import { runProviderChecks, summariseProviderIssues } from "./doctor-providers.j
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { loadLedgerFromDisk, getProjectTotals } from "./metrics.js";
-import { describeNextUnit, estimateTimeRemaining, updateSliceProgressCache } from "./auto-dashboard.js";
 import { projectRoot } from "./commands.js";
-import { deriveState, invalidateStateCache } from "./state.js";
-import { buildHealthLines, detectHealthWidgetProjectState, } from "./health-widget-core.js";
 // ── Data loader ────────────────────────────────────────────────────────────────
-function loadBaseHealthWidgetData(basePath) {
+function loadHealthWidgetData(basePath) {
+    let hasProject = false;
     let budgetCeiling;
     let budgetSpent = 0;
     let providerIssue = null;
     let environmentErrorCount = 0;
     let environmentWarningCount = 0;
-    const projectState = detectHealthWidgetProjectState(basePath);
     try {
         const prefs = loadEffectiveGSDPreferences();
         budgetCeiling = prefs?.preferences?.budget_ceiling;
         const ledger = loadLedgerFromDisk(basePath);
         if (ledger) {
+            hasProject = true;
             const totals = getProjectTotals(ledger.units ?? []);
             budgetSpent = totals.cost;
         }
@@ -49,7 +47,7 @@ function loadBaseHealthWidgetData(basePath) {
     }
     catch { /* non-fatal */ }
     return {
-        projectState,
+        hasProject,
         budgetCeiling,
         budgetSpent,
         providerIssue,
@@ -58,85 +56,50 @@ function loadBaseHealthWidgetData(basePath) {
         lastRefreshed: Date.now(),
     };
 }
-function compactText(text, max = 64) {
-    const trimmed = text.replace(/\s+/g, " ").trim();
-    if (trimmed.length <= max)
-        return trimmed;
-    return `${trimmed.slice(0, max - 1).trimEnd()}…`;
+// ── Rendering ──────────────────────────────────────────────────────────────────
+function formatCost(n) {
+    return n >= 1 ? `$${n.toFixed(2)}` : `${(n * 100).toFixed(1)}¢`;
 }
-function summarizeExecutionStatus(state) {
-    switch (state.phase) {
-        case "blocked": return "Blocked";
-        case "paused": return "Paused";
-        case "complete": return "Complete";
-        case "executing": return "Executing";
-        case "planning": return "Planning";
-        case "pre-planning": return "Pre-planning";
-        case "summarizing": return "Summarizing";
-        case "validating-milestone": return "Validating";
-        case "completing-milestone": return "Completing";
-        case "needs-discussion": return "Needs discussion";
-        case "replanning-slice": return "Replanning";
-        default: return "Active";
+/**
+ * Build compact health lines for the widget.
+ * Returns a string array suitable for setWidget().
+ */
+export function buildHealthLines(data) {
+    if (!data.hasProject) {
+        return ["  GSD  No project loaded — run /gsd to start"];
     }
-}
-function summarizeExecutionTarget(state) {
-    switch (state.phase) {
-        case "needs-discussion":
-            return state.activeMilestone ? `Discuss ${state.activeMilestone.id}` : "Discuss milestone draft";
-        case "pre-planning":
-            return state.activeMilestone ? `Plan ${state.activeMilestone.id}` : "Research & plan milestone";
-        case "planning":
-            return state.activeSlice ? `Plan ${state.activeSlice.id}` : "Plan next slice";
-        case "executing":
-            return state.activeTask ? `Execute ${state.activeTask.id}` : "Execute next task";
-        case "summarizing":
-            return state.activeSlice ? `Complete ${state.activeSlice.id}` : "Complete current slice";
-        case "validating-milestone":
-            return state.activeMilestone ? `Validate ${state.activeMilestone.id}` : "Validate milestone";
-        case "completing-milestone":
-            return state.activeMilestone ? `Complete ${state.activeMilestone.id}` : "Complete milestone";
-        case "replanning-slice":
-            return state.activeSlice ? `Replan ${state.activeSlice.id}` : "Replan current slice";
-        case "blocked":
-            return `waiting on ${compactText(state.blockers[0] ?? state.nextAction, 56)}`;
-        case "paused":
-            return compactText(state.nextAction || "waiting to resume", 56);
-        case "complete":
-            return "All milestones complete";
-        default:
-            return compactText(describeNextUnit(state).label, 56);
+    const parts = [];
+    // System status signal
+    const totalIssues = data.environmentErrorCount + data.environmentWarningCount + (data.providerIssue ? 1 : 0);
+    if (totalIssues === 0) {
+        parts.push("● System OK");
     }
-}
-async function enrichHealthWidgetData(basePath, baseData) {
-    if (baseData.projectState !== "active")
-        return baseData;
-    try {
-        invalidateStateCache();
-        const state = await deriveState(basePath);
-        if (state.activeMilestone) {
-            // Warm the slice-progress cache so estimateTimeRemaining() has data
-            updateSliceProgressCache(basePath, state.activeMilestone.id, state.activeSlice?.id);
-        }
-        return {
-            ...baseData,
-            executionPhase: state.phase,
-            executionStatus: summarizeExecutionStatus(state),
-            executionTarget: summarizeExecutionTarget(state),
-            nextAction: state.nextAction,
-            blocker: state.blockers[0] ?? null,
-            activeMilestoneId: state.activeMilestone?.id,
-            activeSliceId: state.activeSlice?.id,
-            activeTaskId: state.activeTask?.id,
-            progress: state.progress,
-            eta: state.phase === "blocked" || state.phase === "paused" || state.phase === "complete"
-                ? null
-                : estimateTimeRemaining(),
-        };
+    else if (data.environmentErrorCount > 0 || data.providerIssue?.includes("✗")) {
+        parts.push(`✗ ${totalIssues} issue${totalIssues > 1 ? "s" : ""}`);
+    }
+    else {
+        parts.push(`⚠ ${totalIssues} warning${totalIssues > 1 ? "s" : ""}`);
     }
-    catch {
-        return baseData;
+    // Budget
+    if (data.budgetCeiling !== undefined && data.budgetCeiling > 0) {
+        const pct = Math.min(100, (data.budgetSpent / data.budgetCeiling) * 100);
+        parts.push(`Budget: ${formatCost(data.budgetSpent)}/${formatCost(data.budgetCeiling)} (${pct.toFixed(0)}%)`);
     }
+    else if (data.budgetSpent > 0) {
+        parts.push(`Spent: ${formatCost(data.budgetSpent)}`);
+    }
+    // Provider issue (if any)
+    if (data.providerIssue) {
+        parts.push(data.providerIssue);
+    }
+    // Environment issues
+    if (data.environmentErrorCount > 0) {
+        parts.push(`Env: ${data.environmentErrorCount} error${data.environmentErrorCount > 1 ? "s" : ""}`);
+    }
+    else if (data.environmentWarningCount > 0) {
+        parts.push(`Env: ${data.environmentWarningCount} warning${data.environmentWarningCount > 1 ? "s" : ""}`);
+    }
+    return [`  ${parts.join("  │  ")}`];
 }
 // ── Widget init ────────────────────────────────────────────────────────────────
 const REFRESH_INTERVAL_MS = 60_000;
@@ -149,33 +112,19 @@ export function initHealthWidget(ctx) {
         return;
     const basePath = projectRoot();
     // String-array fallback — used in RPC mode (factory is a no-op there)
-    const initialData = loadBaseHealthWidgetData(basePath);
+    const initialData = loadHealthWidgetData(basePath);
     ctx.ui.setWidget("gsd-health", buildHealthLines(initialData), { placement: "belowEditor" });
     // Factory-based widget for TUI mode — replaces the string-array above
     ctx.ui.setWidget("gsd-health", (_tui, _theme) => {
         let data = initialData;
         let cachedLines;
-        let refreshInFlight = false;
-        const refresh = async () => {
-            if (refreshInFlight)
-                return;
-            refreshInFlight = true;
+        const refreshTimer = setInterval(() => {
             try {
-                const baseData = loadBaseHealthWidgetData(basePath);
-                data = await enrichHealthWidgetData(basePath, baseData);
+                data = loadHealthWidgetData(basePath);
                 cachedLines = undefined;
                 _tui.requestRender();
             }
             catch { /* non-fatal */ }
-            finally {
-                refreshInFlight = false;
-            }
-        };
-        // Fire first enrichment immediately. requestRender() inside is a no-op
-        // if the widget has not yet rendered, so this is safe before factory return.
-        void refresh();
-        const refreshTimer = setInterval(() => {
-            void refresh();
         }, REFRESH_INTERVAL_MS);
         return {
             render(_width) {

package/dist/resources/extensions/gsd/index.js

@@ -140,16 +140,7 @@ export default function (pi) {
                 // Pipe closed — nothing we can write; just exit cleanly
                 process.exit(0);
             }
-            if (err.code === "ENOENT" &&
-                err.syscall?.startsWith("spawn")) {
-                // spawn ENOENT — command not found (e.g., npx on Windows).
-                // This surfaces as an uncaught exception from child_process but
-                // is not a fatal process error. Log and continue instead of
-                // crashing auto-mode (#1384).
-                process.stderr.write(`[gsd] spawn ENOENT: ${err.path ?? "unknown"} — command not found\n`);
-                return;
-            }
-            // Re-throw anything that isn't EPIPE/ENOENT so real crashes still surface
+            // Re-throw anything that isn't EPIPE so real crashes still surface
             throw err;
         };
         process.on("uncaughtException", _gsdEpipeGuard);

package/dist/resources/extensions/gsd/migrate-external.js

@@ -5,11 +5,10 @@
  * `~/.gsd/projects/<hash>/` state directory. After migration, a
  * symlink replaces the original directory so all paths remain valid.
  */
-import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, symlinkSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, renameSync, cpSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { externalGsdRoot } from "./repo-identity.js";
 import { getErrorMessage } from "./error-utils.js";
-import { hasGitTrackedGsdFiles } from "./gitignore.js";
 /**
  * Migrate a legacy in-project `.gsd/` directory to external storage.
  *
@@ -43,27 +42,6 @@ export function migrateToExternalState(basePath) {
     catch (err) {
         return { migrated: false, error: `Cannot stat .gsd: ${getErrorMessage(err)}` };
     }
-    // Skip if .gsd/ contains git-tracked files — the project intentionally
-    // keeps .gsd/ in version control and migration would destroy that.
-    if (hasGitTrackedGsdFiles(basePath)) {
-        return { migrated: false };
-    }
-    // Skip if .gsd/worktrees/ has active worktree directories (#1337).
-    // On Windows, active git worktrees hold OS-level directory handles that
-    // prevent rename/delete. Attempting migration causes EBUSY and data loss.
-    const worktreesDir = join(localGsd, "worktrees");
-    if (existsSync(worktreesDir)) {
-        try {
-            const entries = readdirSync(worktreesDir, { withFileTypes: true });
-            if (entries.some(e => e.isDirectory())) {
-                return { migrated: false };
-            }
-        }
-        catch {
-            // Can't read worktrees dir — skip migration to be safe
-            return { migrated: false };
-        }
-    }
     const externalPath = externalGsdRoot(basePath);
     const migratingPath = join(basePath, ".gsd.migrating");
     try {
@@ -111,38 +89,7 @@ export function migrateToExternalState(basePath) {
         }
         // Create symlink .gsd -> external path
         symlinkSync(externalPath, localGsd, "junction");
-        // Verify the symlink resolves correctly before removing the backup (#1377).
-        // On Windows, junction creation can silently succeed but resolve to the wrong
-        // target, or the external dir may not be accessible. If verification fails,
-        // restore from the backup.
-        try {
-            const resolved = realpathSync(localGsd);
-            const resolvedExternal = realpathSync(externalPath);
-            if (resolved !== resolvedExternal) {
-                // Symlink points to wrong target — restore backup
-                try {
-                    rmSync(localGsd, { force: true });
-                }
-                catch { /* may not exist */ }
-                renameSync(migratingPath, localGsd);
-                return { migrated: false, error: `Migration verification failed: symlink resolves to ${resolved}, expected ${resolvedExternal}` };
-            }
-            // Verify we can read through the symlink
-            readdirSync(localGsd);
-        }
-        catch (verifyErr) {
-            // Symlink broken or unreadable — restore backup
-            try {
-                rmSync(localGsd, { force: true });
-            }
-            catch { /* may not exist */ }
-            try {
-                renameSync(migratingPath, localGsd);
-            }
-            catch { /* best-effort restore */ }
-            return { migrated: false, error: `Migration verification failed: ${getErrorMessage(verifyErr)}` };
-        }
-        // Remove .gsd.migrating only after symlink is verified
+        // Remove .gsd.migrating
         rmSync(migratingPath, { recursive: true, force: true });
         return { migrated: true };
     }

package/dist/resources/extensions/gsd/paths.js

@@ -9,8 +9,7 @@
  * via prefix matching, so existing projects work without migration.
  */
 import { readdirSync, existsSync, realpathSync, Dirent } from "node:fs";
-import { join, dirname, normalize } from "node:path";
-import { spawnSync } from "node:child_process";
+import { join } from "node:path";
 import { nativeScanGsdTree } from "./native-parser-bridge.js";
 import { DIR_CACHE_MAX } from "./constants.js";
 // ─── Directory Listing Cache ──────────────────────────────────────────────────
@@ -264,81 +263,15 @@ const LEGACY_GSD_ROOT_FILES = {
     OVERRIDES: "overrides.md",
     KNOWLEDGE: "knowledge.md",
 };
-// ─── GSD Root Discovery ───────────────────────────────────────────────────────
-const gsdRootCache = new Map();
-/** Exported for tests only — do not call in production code. */
-export function _clearGsdRootCache() {
-    gsdRootCache.clear();
-}
-/**
- * Resolve the `.gsd` directory for a given project base path.
- *
- * Probe order:
- *   1. basePath/.gsd         — fast path (common case)
- *   2. git rev-parse root    — handles cwd-is-a-subdirectory
- *   3. Walk up from basePath — handles moved .gsd in an ancestor (bounded by git root)
- *   4. basePath/.gsd         — creation fallback (init scenario)
- *
- * Result is cached per basePath for the process lifetime.
- */
 export function gsdRoot(basePath) {
-    const cached = gsdRootCache.get(basePath);
-    if (cached)
-        return cached;
-    const result = probeGsdRoot(basePath);
-    gsdRootCache.set(basePath, result);
-    return result;
-}
-function probeGsdRoot(rawBasePath) {
-    // 1. Fast path — check the input path directly
-    const local = join(rawBasePath, ".gsd");
-    if (existsSync(local))
-        return local;
-    // Resolve symlinks so path comparisons work correctly across platforms
-    // (e.g. macOS /var → /private/var). Use rawBasePath as fallback if not resolvable.
-    let basePath;
+    const local = join(basePath, ".gsd");
     try {
-        basePath = realpathSync.native(rawBasePath);
-    }
-    catch {
-        basePath = rawBasePath;
-    }
-    // 2. Git root anchor — used as both probe target and walk-up boundary
-    //    Only walk if we're inside a git project — prevents escaping into
-    //    unrelated filesystem territory when running outside any repo.
-    let gitRoot = null;
-    try {
-        const out = spawnSync("git", ["rev-parse", "--show-toplevel"], {
-            cwd: basePath,
-            encoding: "utf-8",
-        });
-        if (out.status === 0) {
-            const r = out.stdout.trim();
-            if (r)
-                gitRoot = normalize(r);
-        }
-    }
-    catch { /* git not available */ }
-    if (gitRoot) {
-        const candidate = join(gitRoot, ".gsd");
-        if (existsSync(candidate))
-            return candidate;
-    }
-    // 3. Walk up from basePath to the git root (only if we are in a subdirectory)
-    if (gitRoot && basePath !== gitRoot) {
-        let cur = dirname(basePath);
-        while (cur !== basePath) {
-            const candidate = join(cur, ".gsd");
-            if (existsSync(candidate))
-                return candidate;
-            if (cur === gitRoot)
-                break;
-            basePath = cur;
-            cur = dirname(cur);
-        }
+        const resolved = realpathSync(local);
+        if (resolved !== local)
+            return resolved; // symlink resolved
     }
-    // 4. Fallback for init/creation
-    return local;
+    catch { /* doesn't exist yet — fall through */ }
+    return local; // backwards compat: unmigrated projects
 }
 export function milestonesDir(basePath) {
     return join(gsdRoot(basePath), "milestones");

package/dist/resources/extensions/gsd/post-unit-hooks.js

@@ -111,13 +111,10 @@ function dequeueNextHook(basePath) {
         };
         // Build the prompt with variable substitution
         const [mid, sid, tid] = triggerUnitId.split("/");
-        let prompt = config.prompt
+        const prompt = config.prompt
             .replace(/\{milestoneId\}/g, mid ?? "")
             .replace(/\{sliceId\}/g, sid ?? "")
             .replace(/\{taskId\}/g, tid ?? "");
-        // Inject browser safety instruction for hooks that may use browser tools (#1345).
-        // Vite HMR and other persistent connections prevent networkidle from resolving.
-        prompt += "\n\n**Browser tool safety:** Do NOT use `browser_wait_for` with `condition: \"network_idle\"` — it hangs indefinitely when dev servers keep persistent connections (Vite HMR, WebSocket). Use `selector_visible`, `text_visible`, or `delay` instead.";
         return {
             hookName: config.name,
             prompt,

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -14,24 +14,9 @@ export function validatePreferences(preferences) {
     const warnings = [];
     const validated = {};
     // ─── Unknown Key Detection ──────────────────────────────────────────
-    // Common key migration hints for pi-level settings that don't map to GSD prefs
-    const KEY_MIGRATION_HINTS = {
-        taskIsolation: 'use "git.isolation" instead (values: worktree, branch, none)',
-        task_isolation: 'use "git.isolation" instead (values: worktree, branch, none)',
-        isolation: 'use "git.isolation" instead (values: worktree, branch, none)',
-        manage_gitignore: 'use "git.manage_gitignore" instead',
-        auto_push: 'use "git.auto_push" instead',
-        main_branch: 'use "git.main_branch" instead',
-    };
     for (const key of Object.keys(preferences)) {
         if (!KNOWN_PREFERENCE_KEYS.has(key)) {
-            const hint = KEY_MIGRATION_HINTS[key];
-            if (hint) {
-                warnings.push(`unknown preference key "${key}" — ${hint}`);
-            }
-            else {
-                warnings.push(`unknown preference key "${key}" — ignored`);
-            }
+            warnings.push(`unknown preference key "${key}" — ignored`);
         }
     }
     if (preferences.version !== undefined) {

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -28,8 +28,6 @@ Then:
 
 **Important:** Do NOT skip the success criteria and definition of done verification (steps 3-4). The milestone summary must reflect actual verified outcomes, not assumed success. If any criterion was not met, document it clearly in the summary and do not mark the milestone as passing verification.
 
-**File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
-
 **You MUST write `{{milestoneSummaryPath}}` AND update PROJECT.md before finishing.**
 
 When done, say: "Milestone {{milestoneId}} complete."

package/dist/resources/extensions/gsd/prompts/validate-milestone.md

@@ -67,6 +67,4 @@ If verdict is `needs-remediation`:
 
 **You MUST write `{{validationPath}}` before finishing.**
 
-**File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
-
 When done, say: "Milestone {{milestoneId}} validation complete — verdict: <verdict>."

package/dist/resources/extensions/gsd/session-lock.js

@@ -32,17 +32,8 @@ let _lockPid = 0;
 let _lockCompromised = false;
 /** Whether we've already registered a process.on('exit') handler. */
 let _exitHandlerRegistered = false;
-/** Snapshotted lock file path — captured at acquireSessionLock time to avoid
- *  gsdRoot() resolving differently in worktree vs project root contexts (#1363). */
-let _snapshotLockPath = null;
-/** Timestamp when the session lock was acquired — used to detect false-positive
- *  onCompromised events from event loop stalls within the stale window (#1362). */
-let _lockAcquiredAt = 0;
 const LOCK_FILE = "auto.lock";
 function lockPath(basePath) {
-    // If we have a snapshotted path from acquisition, use it for consistency
-    if (_snapshotLockPath)
-        return _snapshotLockPath;
     return join(gsdRoot(basePath), LOCK_FILE);
 }
 // ─── Stray Lock Cleanup ─────────────────────────────────────────────────────
@@ -184,17 +175,8 @@ export function acquireSessionLock(basePath) {
             onCompromised: () => {
                 // proper-lockfile detected mtime drift (system sleep, event loop stall, etc.).
                 // Default handler throws inside setTimeout — an uncaught exception that crashes
-                // or corrupts process state.
-                //
-                // False-positive suppression (#1362): If we're still within the stale window
-                // (30 min since acquisition), the mtime mismatch is from an event loop stall
-                // during a long LLM call — not a real takeover. Log and continue.
-                const elapsed = Date.now() - _lockAcquiredAt;
-                if (elapsed < 1_800_000) {
-                    process.stderr.write(`[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — event loop stall, continuing.\n`);
-                    return; // Suppress false positive
-                }
-                // Past the stale window — this is a real compromise
+                // or corrupts process state. Instead, set a flag so validateSessionLock() can
+                // detect the compromise gracefully on the next dispatch cycle.
                 _lockCompromised = true;
                 _releaseFunction = null;
             },
@@ -203,8 +185,6 @@ export function acquireSessionLock(basePath) {
         _lockedPath = basePath;
         _lockPid = process.pid;
         _lockCompromised = false;
-        _lockAcquiredAt = Date.now();
-        _snapshotLockPath = lp; // Snapshot the resolved path for consistent access (#1363)
         // Safety net: clean up lock dir on process exit if _releaseFunction
         // wasn't called (e.g., normal exit after clean completion) (#1245).
         ensureExitHandler(gsdDir);
@@ -239,8 +219,6 @@ export function acquireSessionLock(basePath) {
                 _lockedPath = basePath;
                 _lockPid = process.pid;
                 _lockCompromised = false;
-                _lockAcquiredAt = Date.now();
-                _snapshotLockPath = lp; // Snapshot for retry path too (#1363)
                 // Safety net — uses centralized handler to avoid double-registration
                 ensureExitHandler(gsdDir);
                 atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
@@ -370,8 +348,6 @@ export function releaseSessionLock(basePath) {
     _lockedPath = null;
     _lockPid = 0;
     _lockCompromised = false;
-    _lockAcquiredAt = 0;
-    _snapshotLockPath = null;
 }
 /**
  * Check if a session lock exists and return its data (for crash recovery).