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

package/dist/cli.js

@@ -327,10 +327,7 @@ if (isPrintMode) {
     markStartup('createAgentSession');
     if (extensionsResult.errors.length > 0) {
         for (const err of extensionsResult.errors) {
-            // Downgrade conflicts with built-in tools to warnings (#1347)
-            const isSuperseded = err.error.includes("supersedes");
-            const prefix = isSuperseded ? "Extension conflict" : "Extension load error";
-            process.stderr.write(`[gsd] ${prefix}: ${err.error}\n`);
+            process.stderr.write(`[gsd] Extension load error: ${err.error}\n`);
         }
     }
     // Apply --model override if specified
@@ -459,9 +456,7 @@ const { session, extensionsResult } = await createAgentSession({
 markStartup('createAgentSession');
 if (extensionsResult.errors.length > 0) {
     for (const err of extensionsResult.errors) {
-        const isSuperseded = err.error.includes("supersedes");
-        const prefix = isSuperseded ? "Extension conflict" : "Extension load error";
-        process.stderr.write(`[gsd] ${prefix}: ${err.error}\n`);
+        process.stderr.write(`[gsd] Extension load error: ${err.error}\n`);
     }
 }
 // Restore scoped models from settings on startup.

package/dist/resource-loader.d.ts

@@ -9,7 +9,7 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  * - extensions/ → ~/.gsd/agent/extensions/   (overwrite when version changes)
  * - agents/     → ~/.gsd/agent/agents/        (overwrite when version changes)
  * - skills/     → ~/.gsd/agent/skills/        (overwrite when version changes)
- * - GSD-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
+ * - GSD-WORKFLOW.md is read directly from bundled path via GSD_WORKFLOW_PATH env var
  *
  * Skips the copy when the managed-resources.json version matches the current
  * GSD version, avoiding ~128ms of synchronous cpSync on every startup.

package/dist/resource-loader.js

@@ -18,9 +18,6 @@ import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled, ensureRegi
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const distResources = join(packageRoot, 'dist', 'resources');
 const srcResources = join(packageRoot, 'src', 'resources');
-// Use dist/resources only if it has the full expected structure.
-// A partial build (tsc without copy-resources) creates dist/resources/extensions/
-// but not agents/ or skills/, causing initResources to sync from an incomplete source.
 const resourcesDir = (existsSync(distResources) && existsSync(join(distResources, 'agents')))
     ? distResources
     : srcResources;
@@ -223,7 +220,7 @@ function copyDirRecursive(src, dest) {
  * - extensions/ → ~/.gsd/agent/extensions/   (overwrite when version changes)
  * - agents/     → ~/.gsd/agent/agents/        (overwrite when version changes)
  * - skills/     → ~/.gsd/agent/skills/        (overwrite when version changes)
- * - GSD-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
+ * - GSD-WORKFLOW.md is read directly from bundled path via GSD_WORKFLOW_PATH env var
  *
  * Skips the copy when the managed-resources.json version matches the current
  * GSD version, avoiding ~128ms of synchronous cpSync on every startup.
@@ -250,15 +247,6 @@ export function initResources(agentDir) {
     syncResourceDir(bundledExtensionsDir, join(agentDir, 'extensions'));
     syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
     syncResourceDir(join(resourcesDir, 'skills'), join(agentDir, 'skills'));
-    // Sync GSD-WORKFLOW.md to agentDir as a fallback for when GSD_WORKFLOW_PATH
-    // env var is not set (e.g. fork/dev builds, alternative entry points).
-    const workflowSrc = join(resourcesDir, 'GSD-WORKFLOW.md');
-    if (existsSync(workflowSrc)) {
-        try {
-            copyFileSync(workflowSrc, join(agentDir, 'GSD-WORKFLOW.md'));
-        }
-        catch { /* non-fatal */ }
-    }
     // Ensure all newly copied files are owner-writable so the next run can
     // overwrite them (covers extensions, agents, and skills in one walk).
     makeTreeWritable(agentDir);

package/dist/resources/extensions/async-jobs/await-tool.js

@@ -52,12 +52,14 @@ export function createAwaitTool(getManager) {
             const running = watched.filter((j) => j.status === "running");
             if (running.length === 0) {
                 const result = formatResults(watched);
+                manager.acknowledgeDeliveries(watched.map((j) => j.id));
                 return { content: [{ type: "text", text: result }], details: undefined };
             }
             // Wait for at least one to complete
             await Promise.race(running.map((j) => j.promise));
             // Collect all completed results (more may have finished while waiting)
             const completed = watched.filter((j) => j.status !== "running");
+            manager.acknowledgeDeliveries(completed.map((j) => j.id));
             const stillRunning = watched.filter((j) => j.status === "running");
             let result = formatResults(completed);
             if (stillRunning.length > 0) {

package/dist/resources/extensions/async-jobs/job-manager.js

@@ -101,6 +101,12 @@ export class AsyncJobManager {
     getAllJobs() {
         return [...this.jobs.values()];
     }
+    /**
+     * No-op. Retained for API compatibility with await_job tool.
+     */
+    acknowledgeDeliveries(_jobIds) {
+        // Delivery is fire-once; no retries to cancel.
+    }
     /**
      * Cleanup all timers and resources.
      */

package/dist/resources/extensions/bg-shell/output-formatter.js

@@ -2,7 +2,7 @@
  * Output analysis, digest generation, highlights extraction, and output retrieval.
  */
 import { truncateHead, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, } from "@gsd/pi-coding-agent";
-import { ERROR_PATTERN_UNION, WARNING_PATTERN_UNION, READINESS_PATTERN_UNION, BUILD_COMPLETE_PATTERN_UNION, TEST_RESULT_PATTERN_UNION, URL_PATTERN, PORT_PATTERN_SOURCE, } from "./types.js";
+import { ERROR_PATTERN_UNION, WARNING_PATTERN_UNION, READINESS_PATTERN_UNION, BUILD_COMPLETE_PATTERN_UNION, TEST_RESULT_PATTERN_UNION, URL_PATTERN, PORT_PATTERN_SOURCE, LINE_DEDUP_MAX, } from "./types.js";
 import { addEvent, pushAlert } from "./process-manager.js";
 import { transitionToReady } from "./readiness-detector.js";
 import { formatUptime, formatTimeAgo } from "./utilities.js";
@@ -78,6 +78,24 @@ export function analyzeLine(bg, line, stream) {
             pushAlert(bg, "recovered — errors cleared");
         }
     }
+    // Dedup tracking — evict oldest entry when map exceeds LINE_DEDUP_MAX (LRU via Map insertion order)
+    bg.totalRawLines++;
+    const lineHash = line.trim().slice(0, 100);
+    const existing = bg.lineDedup.get(lineHash);
+    if (existing !== undefined) {
+        // Re-insert to update insertion order (move to tail = most recent)
+        bg.lineDedup.delete(lineHash);
+        bg.lineDedup.set(lineHash, existing + 1);
+    }
+    else {
+        if (bg.lineDedup.size >= LINE_DEDUP_MAX) {
+            // Evict oldest entry (Map iteration order = insertion order = LRU at head)
+            const oldest = bg.lineDedup.keys().next().value;
+            if (oldest !== undefined)
+                bg.lineDedup.delete(oldest);
+        }
+        bg.lineDedup.set(lineHash, 1);
+    }
 }
 // ── Digest Generation ──────────────────────────────────────────────────────
 export function generateDigest(bg, mutate = false) {

package/dist/resources/extensions/bg-shell/process-manager.js

@@ -135,8 +135,12 @@ export function startProcess(opts) {
         group: opts.group || null,
         lastErrorCount: 0,
         lastWarningCount: 0,
+        commandHistory: [],
+        lineDedup: new Map(),
+        totalRawLines: 0,
         stdoutLineCount: 0,
         stderrLineCount: 0,
+        envKeys: Object.keys(opts.env || {}),
         restartCount: 0,
         startConfig: {
             command,

package/dist/resources/extensions/bg-shell/types.js

@@ -5,6 +5,8 @@
 export const MAX_BUFFER_LINES = 5000;
 export const MAX_EVENTS = 200;
 export const DEAD_PROCESS_TTL = 10 * 60 * 1000;
+/** Maximum unique entries in the per-process lineDedup Map before LRU eviction. */
+export const LINE_DEDUP_MAX = 500;
 export const PORT_PROBE_TIMEOUT = 500;
 export const READY_POLL_INTERVAL = 250;
 export const DEFAULT_READY_TIMEOUT = 30000;

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

@@ -327,11 +327,6 @@ export default function (pi) {
             return new Text(text, 0, 0);
         },
     });
-    // ── Session cleanup ─────────────────────────────────────────────────────
-    pi.on("session_shutdown", async () => {
-        searchCache.clear();
-        docCache.clear();
-    });
     // ── Startup notification ─────────────────────────────────────────────────
     pi.on("session_start", async (_event, ctx) => {
         if (!getApiKey()) {

package/dist/resources/extensions/get-secrets-from-user.js

@@ -8,9 +8,9 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
-import { Editor, Key, matchesKey, Text, truncateToWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+import { CURSOR_MARKER, Editor, Key, matchesKey, Text, truncateToWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { makeUI, maskEditorLine } from "./shared/mod.js";
+import { makeUI } from "./shared/mod.js";
 import { parseSecretsManifest, formatSecretsManifest } from "./gsd/files.js";
 import { resolveMilestoneFile } from "./gsd/paths.js";
 // ─── Helpers ──────────────────────────────────────────────────────────────────
@@ -21,6 +21,34 @@ function maskPreview(value) {
         return "*".repeat(value.length);
     return `${value.slice(0, 4)}${"*".repeat(Math.max(4, value.length - 8))}${value.slice(-4)}`;
 }
+/**
+ * Replace editor visible text with masked characters while preserving ANSI cursor/sequencer codes.
+ */
+function maskEditorLine(line) {
+    // Keep border / metadata lines readable.
+    if (line.startsWith("─")) {
+        return line;
+    }
+    let output = "";
+    let i = 0;
+    while (i < line.length) {
+        if (line.startsWith(CURSOR_MARKER, i)) {
+            output += CURSOR_MARKER;
+            i += CURSOR_MARKER.length;
+            continue;
+        }
+        const ansiMatch = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
+        if (ansiMatch) {
+            output += ansiMatch[0];
+            i += ansiMatch[0].length;
+            continue;
+        }
+        const ch = line[i];
+        output += ch === " " ? " " : "*";
+        i += 1;
+    }
+    return output;
+}
 function shellEscapeSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }

package/dist/resources/extensions/google-search/index.js

@@ -326,11 +326,6 @@ export default function (pi) {
             return new Text(text, 0, 0);
         },
     });
-    // ── Session cleanup ─────────────────────────────────────────────────────
-    pi.on("session_shutdown", async () => {
-        resultCache.clear();
-        client = null;
-    });
     // ── Startup notification ─────────────────────────────────────────────────
     pi.on("session_start", async (_event, ctx) => {
         if (process.env.GEMINI_API_KEY)

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

@@ -8,7 +8,7 @@
  * data structure that is inspectable, testable per-rule, and extensible
  * without modifying orchestration code.
  */
-import { loadFile, loadActiveOverrides, parseRoadmap } from "./files.js";
+import { loadFile, loadActiveOverrides } from "./files.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -274,28 +274,6 @@ const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
             if (state.phase !== "validating-milestone")
                 return null;
-            // Safety guard (#1368): verify all roadmap slices have SUMMARY files before
-            // allowing milestone validation. If any slice lacks a summary, the milestone
-            // is not genuinely complete — something skipped earlier slices.
-            const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (roadmapContent) {
-                const roadmap = parseRoadmap(roadmapContent);
-                const missingSlices = [];
-                for (const slice of roadmap.slices) {
-                    const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
-                    if (!summaryPath || !existsSync(summaryPath)) {
-                        missingSlices.push(slice.id);
-                    }
-                }
-                if (missingSlices.length > 0) {
-                    return {
-                        action: "stop",
-                        reason: `Cannot validate milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. These slices may have been skipped.`,
-                        level: "error",
-                    };
-                }
-            }
             // Skip preference: write a minimal pass-through VALIDATION file
             if (prefs?.phases?.skip_milestone_validation) {
                 const mDir = resolveMilestonePath(basePath, mid);
@@ -330,26 +308,6 @@ const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             if (state.phase !== "completing-milestone")
                 return null;
-            // Safety guard (#1368): verify all roadmap slices have SUMMARY files.
-            const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (roadmapContent) {
-                const roadmap = parseRoadmap(roadmapContent);
-                const missingSlices = [];
-                for (const slice of roadmap.slices) {
-                    const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
-                    if (!summaryPath || !existsSync(summaryPath)) {
-                        missingSlices.push(slice.id);
-                    }
-                }
-                if (missingSlices.length > 0) {
-                    return {
-                        action: "stop",
-                        reason: `Cannot complete milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. Run /gsd doctor to diagnose.`,
-                        level: "error",
-                    };
-                }
-            }
             return {
                 action: "dispatch",
                 unitType: "complete-milestone",

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

@@ -161,15 +161,6 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
     const unitPromise = new Promise((resolve) => {
         s.pendingResolve = resolve;
     });
-    // Ensure cwd matches basePath before dispatch (#1389).
-    // async_bash and background jobs can drift cwd away from the worktree.
-    // Realigning here prevents commits from landing on the wrong branch.
-    try {
-        if (process.cwd() !== s.basePath) {
-            process.chdir(s.basePath);
-        }
-    }
-    catch { /* non-fatal — chdir may fail if dir was removed */ }
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
@@ -507,7 +498,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             }
             // Secrets re-check gate
             try {
-                const manifestStatus = await deps.getManifestStatus(s.basePath, mid, s.originalBasePath);
+                const manifestStatus = await deps.getManifestStatus(s.basePath, mid);
                 if (manifestStatus && manifestStatus.pending.length > 0) {
                     const result = await deps.collectSecretsFromManifest(s.basePath, mid, ctx);
                     if (result &&

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

@@ -6,13 +6,11 @@
  * Pure functions that receive all needed state as parameters — no module-level
  * globals or AutoContext dependency.
  */
-import { parseUnitId } from "./unit-id.js";
 import { clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { clearParseCache, parseRoadmap, parsePlan } from "./files.js";
 import { isValidationTerminal } from "./state.js";
 import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
 import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, relMilestoneFile, relSliceFile, relSlicePath, relTaskFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
-import { markSliceDoneInRoadmap } from "./roadmap-mutations.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
 import { dirname, join } from "node:path";
 // ─── Artifact Resolution & Verification ───────────────────────────────────────
@@ -434,39 +432,6 @@ export async function selfHealRuntimeRecords(base, ctx) {
         const now = Date.now();
         for (const record of records) {
             const { unitType, unitId } = record;
-            // Case 0: complete-slice with SUMMARY + UAT but unchecked roadmap (#1350).
-            // If a complete-slice was interrupted after writing artifacts but before
-            // flipping the roadmap checkbox, the verification fails and the dispatch
-            // loop relaunches the same unit forever. Auto-fix the checkbox.
-            if (unitType === "complete-slice") {
-                const { milestone: mid, slice: sid } = parseUnitId(unitId);
-                if (mid && sid) {
-                    const dir = resolveSlicePath(base, mid, sid);
-                    if (dir) {
-                        const summaryPath = join(dir, buildSliceFileName(sid, "SUMMARY"));
-                        const uatPath = join(dir, buildSliceFileName(sid, "UAT"));
-                        if (existsSync(summaryPath) && existsSync(uatPath)) {
-                            const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-                            if (roadmapFile && existsSync(roadmapFile)) {
-                                try {
-                                    const roadmapContent = readFileSync(roadmapFile, "utf-8");
-                                    const roadmap = parseRoadmap(roadmapContent);
-                                    const slice = (roadmap.slices ?? []).find(s => s.id === sid);
-                                    if (slice && !slice.done) {
-                                        // Auto-fix: flip the checkbox using shared utility
-                                        if (markSliceDoneInRoadmap(base, mid, sid)) {
-                                            ctx.ui.notify(`Self-heal: marked ${sid} done in roadmap (SUMMARY + UAT exist but checkbox was stale).`, "info");
-                                        }
-                                    }
-                                }
-                                catch {
-                                    // Roadmap parse failure — don't block self-heal
-                                }
-                            }
-                        }
-                    }
-                }
-            }
             // Clear stale dispatched records (dispatched > 1h ago, process crashed)
             const age = now - (record.startedAt ?? 0);
             if (record.phase === "dispatched" && age > STALE_THRESHOLD_MS) {

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

@@ -11,8 +11,6 @@
 import { deriveState } from "./state.js";
 import { loadFile, getManifestStatus } from "./files.js";
 import { loadEffectiveGSDPreferences, resolveSkillDiscoveryMode, getIsolationMode, } from "./preferences.js";
-import { ensureGsdSymlink } from "./repo-identity.js";
-import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import { gsdRoot, resolveMilestoneFile } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
@@ -44,12 +42,6 @@ import { sep as pathSep } from "node:path";
  * Returns false if the bootstrap aborted (e.g., guided flow returned,
  * concurrent session detected). Returns true when ready to dispatch.
  */
-/** Guard: tracks consecutive bootstrap attempts that found phase === "complete".
- *  Prevents the recursive dialog loop described in #1348 where
- *  bootstrapAutoSession → showSmartEntry → checkAutoStartAfterDiscuss → startAuto
- *  cycles indefinitely when the discuss workflow doesn't produce a milestone. */
-let _consecutiveCompleteBootstraps = 0;
-const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
 export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps) {
     const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase, buildResolver, } = deps;
     const lockResult = acquireSessionLock(base);
@@ -68,19 +60,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
             nativeInit(base, mainBranch);
         }
-        // Migrate legacy in-project .gsd/ to external state directory.
-        // Migration MUST run before ensureGitignore to avoid adding ".gsd" to
-        // .gitignore when .gsd/ is git-tracked (data-loss bug #1364).
-        recoverFailedMigration(base);
-        const migration = migrateToExternalState(base);
-        if (migration.error) {
-            ctx.ui.notify(`External state migration warning: ${migration.error}`, "warning");
-        }
-        // Ensure symlink exists (handles fresh projects and post-migration)
-        ensureGsdSymlink(base);
-        // Ensure .gitignore has baseline patterns.
-        // ensureGitignore checks for git-tracked .gsd/ files and skips the
-        // ".gsd" pattern if the project intentionally tracks .gsd/ in git.
+        // Ensure .gitignore has baseline patterns
         const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
         const commitDocs = gitPrefs?.commit_docs;
         const manageGitignore = gitPrefs?.manage_gitignore;
@@ -206,16 +186,6 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         if (!hasSurvivorBranch) {
             // No active work — start a new milestone via discuss flow
             if (!state.activeMilestone || state.phase === "complete") {
-                // Guard against recursive dialog loop (#1348):
-                // If we've entered this branch multiple times in quick succession,
-                // the discuss workflow isn't producing a milestone. Break the cycle.
-                _consecutiveCompleteBootstraps++;
-                if (_consecutiveCompleteBootstraps > MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS) {
-                    _consecutiveCompleteBootstraps = 0;
-                    ctx.ui.notify("All milestones are complete and the discussion didn't produce a new one. " +
-                        "Run /gsd to start a new milestone manually.", "warning");
-                    return releaseLockAndReturn();
-                }
                 const { showSmartEntry } = await import("./guided-flow.js");
                 await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
                 invalidateAllCaches();
@@ -223,7 +193,6 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 if (postState.activeMilestone &&
                     postState.phase !== "complete" &&
                     postState.phase !== "pre-planning") {
-                    _consecutiveCompleteBootstraps = 0; // Successfully advanced past "complete"
                     state = postState;
                 }
                 else if (postState.activeMilestone &&
@@ -268,8 +237,6 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
             return releaseLockAndReturn();
         }
-        // Successfully resolved an active milestone — reset the re-entry guard
-        _consecutiveCompleteBootstraps = 0;
         // ── Initialize session state ──
         s.active = true;
         s.stepMode = requestedStepMode;
@@ -378,7 +345,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Secrets collection gate
         const mid = state.activeMilestone.id;
         try {
-            const manifestStatus = await getManifestStatus(base, mid, s.originalBasePath || base);
+            const manifestStatus = await getManifestStatus(base, mid);
             if (manifestStatus && manifestStatus.pending.length > 0) {
                 const result = await collectSecretsFromManifest(base, mid, ctx);
                 if (result &&

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

@@ -36,7 +36,7 @@ import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
 import { join } from "node:path";
-import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
@@ -325,13 +325,6 @@ export async function stopAuto(ctx, pi, reason) {
     resetHookState();
     if (s.basePath)
         clearPersistedHookState(s.basePath);
-    // Remove paused-session metadata if present (#1383)
-    try {
-        const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
-        if (existsSync(pausedPath))
-            unlinkSync(pausedPath);
-    }
-    catch { /* non-fatal */ }
     s.active = false;
     s.paused = false;
     s.stepMode = false;
@@ -376,28 +369,10 @@ export async function pauseAuto(ctx, _pi) {
         return;
     clearUnitTimeout();
     s.pausedSessionFile = ctx?.sessionManager?.getSessionFile() ?? null;
-    // Persist paused-session metadata so resume survives /exit (#1383).
-    // The fresh-start bootstrap checks for this file and restores worktree context.
-    try {
-        const pausedMeta = {
-            milestoneId: s.currentMilestoneId,
-            worktreePath: isInAutoWorktree(s.basePath) ? s.basePath : null,
-            originalBasePath: s.originalBasePath,
-            stepMode: s.stepMode,
-            pausedAt: new Date().toISOString(),
-            sessionFile: s.pausedSessionFile,
-        };
-        const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
-        mkdirSync(runtimeDir, { recursive: true });
-        writeFileSync(join(runtimeDir, "paused-session.json"), JSON.stringify(pausedMeta, null, 2), "utf-8");
-    }
-    catch {
-        // Non-fatal — resume will still work via full bootstrap, just without worktree context
-    }
-    if (lockBase()) {
-        releaseSessionLock(lockBase());
+    if (lockBase())
         clearLock(lockBase());
-    }
+    if (lockBase())
+        releaseSessionLock(lockBase());
     deregisterSigtermHandler();
     s.active = false;
     s.paused = true;
@@ -545,30 +520,6 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     // Escape stale worktree cwd from a previous milestone (#608).
     base = escapeStaleWorktree(base);
     // If resuming from paused state, just re-activate and dispatch next unit.
-    // Check persisted paused-session first (#1383) — survives /exit.
-    if (!s.paused) {
-        try {
-            const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
-            if (existsSync(pausedPath)) {
-                const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
-                if (meta.milestoneId) {
-                    s.currentMilestoneId = meta.milestoneId;
-                    s.originalBasePath = meta.originalBasePath || base;
-                    s.stepMode = meta.stepMode ?? requestedStepMode;
-                    s.paused = true;
-                    // Clean up the persisted file — we're consuming it
-                    try {
-                        unlinkSync(pausedPath);
-                    }
-                    catch { /* non-fatal */ }
-                    ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath ? ` (worktree)` : ""}.`, "info");
-                }
-            }
-        }
-        catch {
-            // Malformed or missing — proceed with fresh bootstrap
-        }
-    }
     if (s.paused) {
         const resumeLock = acquireSessionLock(base);
         if (!resumeLock.acquired) {
@@ -803,12 +754,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
     }, hookHardTimeoutMs);
     ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
     ctx.ui.notify(`Running post-unit hook: ${hookName}`, "info");
-    // Ensure cwd matches basePath before hook dispatch (#1389)
-    try {
-        if (process.cwd() !== s.basePath)
-            process.chdir(s.basePath);
-    }
-    catch { }
     debugLog("dispatchHookUnit", {
         phase: "send-message",
         promptLength: hookPrompt.length,

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -15,7 +15,7 @@ import { isAutoActive } from "./auto.js";
 import { projectRoot } from "./commands.js";
 import { loadPrompt } from "./prompt-loader.js";
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
-    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");
     const prompt = loadPrompt("doctor-heal", {
         doctorSummary: reportText,
@@ -144,7 +144,7 @@ export async function handleTriage(ctx, pi, basePath) {
         currentPlan: currentPlan || "(no active slice plan)",
         roadmapContext: roadmapContext || "(no active roadmap)",
     });
-    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: "gsd-triage",

package/dist/resources/extensions/gsd/doctor-environment.js

@@ -148,36 +148,27 @@ function checkPortConflicts(basePath) {
     // Try to detect ports from package.json scripts
     const portsToCheck = new Set();
     const pkgPath = join(basePath, "package.json");
-    if (!existsSync(pkgPath)) {
-        // No package.json — this isn't a Node.js project. Skip port checks
-        // entirely to avoid false positives from system services (e.g., macOS
-        // AirPlay Receiver on port 5000). (#1381)
-        return [];
-    }
-    try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const scripts = pkg.scripts ?? {};
-        const scriptText = Object.values(scripts).join(" ");
-        // Look for --port NNNN, -p NNNN, PORT=NNNN, :NNNN patterns
-        const portMatches = scriptText.matchAll(/(?:--port\s+|(?:^|[^a-z])PORT[=:]\s*|-p\s+|:)(\d{4,5})\b/gi);
-        for (const m of portMatches) {
-            const port = parseInt(m[1], 10);
-            if (port >= 1024 && port <= 65535)
-                portsToCheck.add(port);
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const scripts = pkg.scripts ?? {};
+            const scriptText = Object.values(scripts).join(" ");
+            // Look for --port NNNN, -p NNNN, PORT=NNNN, :NNNN patterns
+            const portMatches = scriptText.matchAll(/(?:--port\s+|(?:^|[^a-z])PORT[=:]\s*|-p\s+|:)(\d{4,5})\b/gi);
+            for (const m of portMatches) {
+                const port = parseInt(m[1], 10);
+                if (port >= 1024 && port <= 65535)
+                    portsToCheck.add(port);
+            }
+        }
+        catch {
+            // parse failed — use defaults
         }
     }
-    catch {
-        // parse failed — skip port checks rather than using defaults
-        return [];
-    }
-    // If no ports found in scripts, check common defaults.
-    // Filter out port 5000 on macOS — AirPlay Receiver uses it by default (#1381).
+    // If no ports found in scripts, check common defaults
     if (portsToCheck.size === 0) {
-        for (const p of DEFAULT_DEV_PORTS) {
-            if (p === 5000 && process.platform === "darwin")
-                continue;
+        for (const p of DEFAULT_DEV_PORTS)
             portsToCheck.add(p);
-        }
     }
     for (const port of portsToCheck) {
         const result = tryExec(`lsof -i :${port} -sTCP:LISTEN -t`, basePath);