gsd-pi 2.39.0 → 2.40.0-dev.4a93031

package/dist/resource-loader.js

@@ -48,10 +48,22 @@ function getBundledGsdVersion() {
     }
 }
 function writeManagedResourceManifest(agentDir) {
+    // Record root-level files currently in the bundled extensions source so that
+    // future upgrades can detect and prune any that get removed or moved.
+    let installedExtensionRootFiles = [];
+    try {
+        if (existsSync(bundledExtensionsDir)) {
+            installedExtensionRootFiles = readdirSync(bundledExtensionsDir, { withFileTypes: true })
+                .filter(e => e.isFile())
+                .map(e => e.name);
+        }
+    }
+    catch { /* non-fatal */ }
     const manifest = {
         gsdVersion: getBundledGsdVersion(),
         syncedAt: Date.now(),
         contentHash: computeResourceFingerprint(),
+        installedExtensionRootFiles,
     };
     writeFileSync(getManagedResourceManifestPath(agentDir), JSON.stringify(manifest));
 }
@@ -246,6 +258,53 @@ function ensureNodeModulesSymlink(agentDir) {
         // Non-fatal — worst case, extensions fall back to NODE_PATH via jiti
     }
 }
+/**
+ * Prune root-level extension files that were installed by a previous GSD version
+ * but have since been removed or relocated to a subdirectory.
+ *
+ * Two strategies:
+ * 1. Manifest-based (preferred): the manifest records which root files were installed
+ *    last time; any that are no longer in the current bundle are deleted.
+ * 2. Known-stale fallback: for upgrades from versions before manifest tracking,
+ *    explicitly delete files known to have been moved (e.g. env-utils.js → gsd/).
+ */
+function pruneRemovedBundledExtensions(manifest, agentDir) {
+    const extensionsDir = join(agentDir, 'extensions');
+    if (!existsSync(extensionsDir))
+        return;
+    // Current bundled root-level files (what the new version provides)
+    const currentSourceFiles = new Set();
+    try {
+        if (existsSync(bundledExtensionsDir)) {
+            for (const e of readdirSync(bundledExtensionsDir, { withFileTypes: true })) {
+                if (e.isFile())
+                    currentSourceFiles.add(e.name);
+            }
+        }
+    }
+    catch { /* non-fatal */ }
+    const removeIfStale = (fileName) => {
+        if (currentSourceFiles.has(fileName))
+            return; // still in bundle, not stale
+        const stale = join(extensionsDir, fileName);
+        try {
+            if (existsSync(stale))
+                rmSync(stale, { force: true });
+        }
+        catch { /* non-fatal */ }
+    };
+    if (manifest?.installedExtensionRootFiles) {
+        // Manifest-based: remove previously-installed root files that are no longer bundled
+        for (const prevFile of manifest.installedExtensionRootFiles) {
+            removeIfStale(prevFile);
+        }
+    }
+    else {
+        // Fallback: explicitly remove known stale files from pre-manifest-tracking versions
+        // env-utils.js was moved from extensions/ root → gsd/ in v2.39.x (#1634)
+        removeIfStale('env-utils.js');
+    }
+}
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
@@ -263,11 +322,16 @@ function ensureNodeModulesSymlink(agentDir) {
  */
 export function initResources(agentDir) {
     mkdirSync(agentDir, { recursive: true });
+    const currentVersion = getBundledGsdVersion();
+    const manifest = readManagedResourceManifest(agentDir);
+    // Always prune root-level extension files that were removed from the bundle.
+    // This is cheap (a few existence checks + at most one rmSync) and must run
+    // unconditionally so that stale files left by a previous version are cleaned
+    // up even when the version/hash match causes the full sync to be skipped.
+    pruneRemovedBundledExtensions(manifest, agentDir);
     // Skip the full copy when both version AND content fingerprint match.
     // Version-only checks miss same-version content changes (npm link dev workflow,
     // hotfixes within a release). The content hash catches those at ~1ms cost.
-    const currentVersion = getBundledGsdVersion();
-    const manifest = readManagedResourceManifest(agentDir);
     if (manifest && manifest.gsdVersion === currentVersion) {
         // Version matches — check content fingerprint for same-version staleness.
         const currentHash = computeResourceFingerprint();

package/dist/resources/extensions/async-jobs/index.js

@@ -64,6 +64,16 @@ export default function AsyncJobs(pi) {
             },
         });
     });
+    pi.on("session_before_switch", async () => {
+        if (manager) {
+            // Cancel all running background jobs — their results are no longer
+            // relevant to the new session and would produce wasteful follow-up
+            // notifications that trigger empty LLM turns (#1642).
+            for (const job of manager.getRunningJobs()) {
+                manager.cancel(job.id);
+            }
+        }
+    });
     pi.on("session_shutdown", async () => {
         if (manager) {
             manager.shutdown();

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

@@ -49,7 +49,7 @@ async function writeEnvKey(filePath, key, value) {
 // Re-export from env-utils.ts so existing consumers still work.
 // The implementation lives in env-utils.ts to avoid pulling @gsd/pi-tui
 // into modules that only need env-checking (e.g. files.ts during reports).
-import { checkExistingEnvKeys } from "./env-utils.js";
+import { checkExistingEnvKeys } from "./gsd/env-utils.js";
 export { checkExistingEnvKeys };
 /**
  * Detect the write destination based on project files in basePath.

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

@@ -371,6 +371,13 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
             render(width) {
                 if (cachedLines && cachedWidth === width)
                     return cachedLines;
+                // While newSession() is in-flight, session state is mid-mutation.
+                // Accessing cmdCtx.sessionManager or cmdCtx.getContextUsage() can
+                // block the render loop and freeze the TUI. Return the last cached
+                // frame (or an empty frame on first render) until the switch settles.
+                if (accessors.isSessionSwitching()) {
+                    return cachedLines ?? [];
+                }
                 const ui = makeUI(theme, width);
                 const lines = [];
                 const pad = INDENT.base;