gsd-pi 2.20.0 → 2.22.0

package/src/resources/extensions/gsd/preferences.ts

@@ -525,6 +525,17 @@ export function resolveSkillStalenessDays(): number {
   return prefs?.preferences.skill_staleness_days ?? 60;
 }
 
+/**
+ * Resolve the effective git isolation mode from preferences.
+ * Returns "worktree" (default), "branch", or "none".
+ */
+export function getIsolationMode(): "none" | "worktree" | "branch" {
+  const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
+  if (prefs?.isolation === "none") return "none";
+  if (prefs?.isolation === "branch") return "branch";
+  return "worktree"; // default
+}
+
 /**
  * Resolve which model ID to use for a given auto-mode unit type.
  * Returns undefined if no model preference is set for this unit type.
@@ -1197,11 +1208,11 @@ export function validatePreferences(preferences: GSDPreferences): {
       }
     }
     if (g.isolation !== undefined) {
-      const validIsolation = new Set(["worktree", "branch"]);
+      const validIsolation = new Set(["worktree", "branch", "none"]);
       if (typeof g.isolation === "string" && validIsolation.has(g.isolation)) {
-        git.isolation = g.isolation as "worktree" | "branch";
+        git.isolation = g.isolation as "worktree" | "branch" | "none";
       } else {
-        errors.push("git.isolation must be one of: worktree, branch");
+        errors.push("git.isolation must be one of: worktree, branch, none");
       }
     }
     if (g.commit_docs !== undefined) {

package/src/resources/extensions/gsd/prompts/execute-task.md

@@ -26,7 +26,7 @@ A researcher explored the codebase and a planner decomposed the work — you are
 
 Then:
 0. Narrate step transitions, key implementation decisions, and verification outcomes as you work. Keep it terse — one line between tool-call clusters, not between every call.
-1. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during execution, without relaxing required verification or artifact rules
+1. **Load relevant skills before writing code.** Check the `GSD Skill Preferences` block in system context and the `<available_skills>` catalog in your system prompt. For each skill that matches this task's technology stack (e.g., React, Next.js, accessibility, component design), `read` its SKILL.md file now. Skills contain implementation rules and patterns that should guide your code. If no skills match this task, skip this step.
 2. Execute the steps in the inlined task plan
 3. Build the real thing. If the task plan says "create login endpoint", build an endpoint that actually authenticates against a real store, not one that returns a hardcoded success response. If the task plan says "create dashboard page", build a page that renders real data from the API, not a component with hardcoded props. Stubs and mocks are for tests, not for the shipped feature.
 4. Write or update tests as part of execution — tests are verification, not an afterthought. If the slice plan defines test files in its Verification section and this is the first task, create them (they should initially fail).

package/src/resources/extensions/gsd/prompts/forensics.md

@@ -0,0 +1,71 @@
+You are investigating a GSD auto-mode failure. The user has described their problem and a structured forensic report has been gathered automatically.
+
+## User's Problem
+
+{{problemDescription}}
+
+## Forensic Report
+
+{{forensicData}}
+
+## GSD Source Location
+
+GSD extension source code is at: {{gsdSourceDir}}
+Key files for understanding failures:
+- auto.ts — unit dispatch loop, stuck detection, timeout recovery
+- session-forensics.ts — trace extraction from activity logs
+- auto-recovery.ts — artifact verification, skip logic
+- crash-recovery.ts — crash lock lifecycle
+- doctor.ts — state integrity checks
+
+You may read these files to identify the specific code path that caused the failure.
+
+## Your Task
+
+1. **Analyze** the forensic report. Identify the root cause of the user's problem.
+
+2. **Clarify** if needed. Use ask_user_questions (max 2 questions) to narrow down ambiguity. Only ask if the report is genuinely insufficient — do not ask questions you can answer from the data.
+
+3. **Explain** your findings clearly:
+   - What happened (the failure sequence)
+   - Why it happened (root cause in GSD's logic)
+   - What the user can do to recover (immediate fix)
+
+4. **Offer GitHub issue creation.** Ask the user:
+   "Would you like me to create a GitHub issue for this on gsd-build/gsd-2?"
+
+   If yes, create the issue using bash with `gh issue create`:
+   - Repository: gsd-build/gsd-2
+   - Labels: bug, auto-generated
+   - Title: concise description of the failure
+   - Body format:
+     ```
+     ## Problem
+     [1-2 sentence summary]
+
+     ## Environment
+     - GSD version: [from report]
+     - Model: [from report]
+     - Unit: [type/id that failed]
+
+     ## Reproduction Context
+     [What was happening when it failed — phase, milestone, slice]
+
+     ## Forensic Findings
+     [Key anomalies detected, error traces, relevant tool call sequences]
+
+     ## Suggested Fix Area
+     [File:line references in GSD source if identified]
+
+     ---
+     *Auto-generated by `/gsd forensics`*
+     ```
+
+   **CRITICAL REDACTION RULES** before creating the issue:
+   - Replace all absolute paths with relative paths
+   - Remove any API keys, tokens, or credentials
+   - Remove any environment variable values
+   - Do not include file content (code written by the user)
+   - Only include GSD structural information (tool names, file names, error messages)
+
+5. **Report saved.** Remind the user that the full forensic report was saved locally (the path will be in the notification).

package/src/resources/extensions/gsd/prompts/plan-slice.md

@@ -33,7 +33,7 @@ Then:
 1. Read the templates:
    - `~/.gsd/agent/extensions/gsd/templates/plan.md`
    - `~/.gsd/agent/extensions/gsd/templates/task-plan.md`
-2. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during planning, without overriding required plan formatting
+2. **Load relevant skills.** Check the `GSD Skill Preferences` block in system context and the `<available_skills>` catalog in your system prompt. `read` any skill files relevant to this slice's technology stack before decomposing. When writing task plans, note which installed skills are relevant in the task description so executors know which to load.
 3. Define slice-level verification — the objective stopping condition for this slice:
    - For non-trivial slices: plan actual test files with real assertions. Name the files.
    - For simple slices: executable commands or script assertions are fine.

package/src/resources/extensions/gsd/prompts/research-slice.md

@@ -42,7 +42,7 @@ An honest "this is straightforward, here's the pattern to follow" is more valuab
 
 Research what this slice needs. Narrate key findings and surprises as you go — what exists, what's missing, what constrains the approach.
 0. If `REQUIREMENTS.md` was preloaded above, identify which Active requirements this slice owns or supports. Research should target these requirements — surfacing risks, unknowns, and implementation constraints that could affect whether the slice actually delivers them.
-1. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during research, without relaxing required verification or artifact rules
+1. **Load relevant skills.** Check the `GSD Skill Preferences` block in system context and the `<available_skills>` catalog in your system prompt. `read` any skill files relevant to this slice's technology stack before exploring code. Reference specific rules from loaded skills in your findings where they inform the implementation approach.
 2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
 3. Explore relevant code for this slice's scope. For targeted exploration, use `rg`, `find`, and reads. For broad or unfamiliar subsystems, use `scout` to map the relevant area first.
 4. Use `resolve_library` / `get_library_docs` for unfamiliar libraries — skip this for libraries already used in the codebase

package/src/resources/extensions/gsd/prompts/system.md

@@ -90,11 +90,17 @@ Titles live inside file content (headings, frontmatter), not in file or director
             T01-SUMMARY.md
 ```
 
-### Worktree Model
+### Isolation Model
 
-All auto-mode work happens inside a worktree at `.gsd/worktrees/<MID>/`. This is a full git worktree on the `milestone/<MID>` branch — it has its own working copy of the project and its own `.gsd/` directory. Slices commit sequentially on this branch; there are no per-slice branches. When a milestone completes, the worktree is merged back to the integration branch.
+Auto-mode supports three isolation modes (configured in `.gsd/preferences.md` under `taskIsolation.mode`):
 
-**If you are executing in auto-mode, your working directory is already set to the worktree.** Use relative paths or the path shown in the Working Directory section of your prompt. Do not navigate to any other copy of the project.
+- **worktree** (default): Work happens in `.gsd/worktrees/<MID>/`, a full git worktree on the `milestone/<MID>` branch. Each worktree has its own working copy and `.gsd/` directory. Squash-merged back to the integration branch on milestone completion.
+- **branch**: Work happens in the project root on a `milestone/<MID>` branch. No worktree directory — files are checked out in-place.
+- **none**: Work happens directly on the current branch. No worktree, no milestone branch. Commits land in-place.
+
+In all modes, slices commit sequentially on the active branch; there are no per-slice branches.
+
+**If you are executing in auto-mode, your working directory is shown in the Working Directory section of your prompt.** Use relative paths. Do not navigate to any other copy of the project.
 
 ### Conventions
 
@@ -152,6 +158,8 @@ Templates showing the expected format for each artifact type are in:
 
 **One-shot commands:** Use `async_bash` for builds, tests, and installs. The result is pushed to you when the command exits — no polling needed. Use `await_job` to block on a specific job.
 
+**Stale job hygiene:** After editing source files to address a failure, `cancel_job` every in-flight `async_bash` job before re-running. If the inputs changed, in-flight outputs are untrusted.
+
 **Secrets:** Use `secure_env_collect`. Never ask the user to edit `.env` files or paste secrets.
 
 **Browser verification:** Verify frontend work against a running app. Discovery: `browser_find`/`browser_snapshot_refs`. Action: refs/selectors → `browser_batch` for obvious sequences. Verification: `browser_assert` for explicit pass/fail. Diagnostics: `browser_diff` for ambiguous outcomes → console/network logs when assertions fail → full page inspection as last resort. Debug in order: failing assertion → diff → diagnostics → element state → broader inspection. Retry only with a new hypothesis.
@@ -165,6 +173,7 @@ Templates showing the expected format for each artifact type are in:
 - Never read files one-by-one to understand a subsystem — use `rg` or `scout` first.
 - Never guess at library APIs from training data — use `get_library_docs`.
 - Never ask the user to run a command, set a variable, or check something you can check yourself.
+- Never await stale async jobs after editing source — `cancel_job` them first, then re-run.
 
 ### Ask vs infer
 

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -19,7 +19,7 @@ export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
   let currentSlice: RoadmapSliceEntry | null = null;
 
   for (const line of checkboxItems) {
-    const cbMatch = line.match(/^\s*-\s+\[([ xX])\]\s+\*\*(\w+):\s+(.+?)\*\*\s*(.*)/);
+    const cbMatch = line.match(/^\s*-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
     if (cbMatch) {
       if (currentSlice) slices.push(currentSlice);
 

package/src/resources/extensions/gsd/session-forensics.ts

@@ -313,10 +313,10 @@ function formatRecoveryPrompt(
   const sections: string[] = [];
 
   sections.push(
-    "## Crash Recovery Briefing",
+    "## Recovery Briefing",
     "",
-    `You are resuming \`${unitType}\` for \`${unitId}\` after a crash.`,
-    `The previous session completed **${trace.toolCallCount} tool calls** before dying.`,
+    `You are resuming \`${unitType}\` for \`${unitId}\` after an interruption.`,
+    `The previous session completed **${trace.toolCallCount} tool calls** before stopping.`,
     "Use this briefing to pick up exactly where it left off. Do NOT redo completed work.",
   );
 
@@ -352,7 +352,7 @@ function formatRecoveryPrompt(
   // Errors
   if (trace.errors.length > 0) {
     sections.push(
-      "", "### Errors Before Crash",
+      "", "### Errors Before Interruption",
       ...trace.errors.slice(-3).map(e => `- ${truncate(e, 200)}`),
     );
   }
@@ -368,7 +368,7 @@ function formatRecoveryPrompt(
   // Last reasoning
   if (trace.lastReasoning) {
     sections.push(
-      "", "### Last Agent Reasoning Before Crash",
+      "", "### Last Agent Reasoning Before Interruption",
       `> ${trace.lastReasoning.replace(/\n/g, "\n> ")}`,
     );
   }

package/src/resources/extensions/gsd/tests/claude-import-tui.test.ts

@@ -0,0 +1,351 @@
+/**
+ * TUI Command Flow Tests for import-claude
+ *
+ * Tests R015: validates the TUI command flow for /gsd prefs import-claude.
+ * These tests currently use mock UI, and marketplace availability is still
+ * derived from real/local marketplace roots. Follow-up work should route these
+ * through portable marketplace fixtures that mirror Claude Code's
+ * `/plugin marketplace add ...` source model.
+ */
+
+
+import { describe, it, before, after, mock } from 'node:test';
+import assert from 'node:assert';
+import { existsSync, mkdtempSync, rmSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { ExtensionCommandContext } from '@gsd/pi-coding-agent';
+import { runClaudeImportFlow, getClaudeSearchRoots, discoverClaudeSkills, discoverClaudePlugins } from '../claude-import.js';
+import { getMarketplaceFixtures } from './marketplace-test-fixtures.js';
+
+// ============================================================================
+// Test Configuration
+// ============================================================================
+
+const fixtureSetup = getMarketplaceFixtures(import.meta.dirname);
+const fixtures = fixtureSetup.fixtures;
+const CLAUDE_SKILLS_PATH = fixtures?.claudeSkillsPath;
+const CLAUDE_PLUGINS_OFFICIAL_PATH = fixtures?.claudePluginsOfficialPath;
+
+function marketplacesAvailable(): boolean {
+	return Boolean(fixtures);
+}
+
+// ============================================================================
+// Mock UI Context
+// ============================================================================
+
+interface MockUISelectCall {
+	prompt: string;
+	options: string[];
+}
+
+function createMockContext(selections: string[]): {
+	ctx: ExtensionCommandContext;
+	selectCalls: MockUISelectCall[];
+} {
+	const selectCalls: MockUISelectCall[] = [];
+
+	const selectMock = mock.fn(async (prompt: string, options: string[]) => {
+		selectCalls.push({ prompt, options });
+		const next = selections.shift();
+		if (next && options.includes(next)) {
+			return next;
+		}
+		// Default: cancel or first option
+		return options.find(o => o.toLowerCase().includes('cancel')) || options[0];
+	});
+
+	const notifyMock = mock.fn();
+
+	// Create a mock that satisfies ExtensionCommandContext
+	// Using type assertion since we only use select, notify, waitForIdle, reload in the tests
+	const ctx = {
+		ui: {
+			select: selectMock,
+			notify: notifyMock,
+			confirm: async () => false,
+			input: async () => undefined,
+			onTerminalInput: () => () => {},
+			setStatus: () => {},
+			setWorkingMessage: () => {},
+			setWidget: () => {},
+			setFooter: () => {},
+			setHeader: () => {},
+			setTitle: () => {},
+			custom: async () => { throw new Error('Not implemented'); },
+			pasteToEditor: () => {},
+			setEditorText: () => {},
+			getEditorText: () => '',
+			editor: async () => undefined,
+			setEditorComponent: () => {},
+			theme: {},
+			getAllThemes: () => [],
+			getTheme: () => undefined,
+			setTheme: () => ({ success: false }),
+			getToolsExpanded: () => true,
+			setToolsExpanded: () => {},
+		},
+		hasUI: true,
+		cwd: process.cwd(),
+		sessionManager: {} as unknown,
+		modelRegistry: {} as unknown,
+		model: undefined,
+		isIdle: () => true,
+		abort: () => {},
+		hasPendingMessages: () => false,
+		shutdown: () => {},
+		getContextUsage: () => undefined,
+		compact: () => {},
+		getSystemPrompt: () => '',
+		waitForIdle: mock.fn(async () => {}),
+		newSession: async () => ({ cancelled: false }),
+		fork: async () => ({ cancelled: false }),
+		navigateTree: async () => ({ cancelled: false }),
+		switchSession: async () => ({ cancelled: false }),
+		reload: mock.fn(async () => {}),
+	} as unknown as ExtensionCommandContext;
+
+	return { ctx, selectCalls };
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+const skipReason = !marketplacesAvailable()
+	? fixtureSetup.skipReason ?? 'Marketplace repos not found for TUI testing'
+	: undefined;
+
+describe(
+	'TUI Command Flow Tests',
+	{ skip: skipReason },
+	() => {
+		let tempDir: string;
+		let prefsPath: string;
+		let prefs: Record<string, unknown>;
+
+		before(() => {
+			tempDir = mkdtempSync(join(tmpdir(), 'gsd-tui-test-'));
+			prefsPath = join(tempDir, 'preferences.md');
+			prefs = { version: 1 };
+		});
+
+		after(() => {
+			fixtures?.cleanup();
+			if (existsSync(tempDir)) {
+				rmSync(tempDir, { recursive: true, force: true });
+			}
+		});
+
+		describe('getClaudeSearchRoots()', () => {
+			it('should return existing skill and plugin roots', () => {
+				const cwd = process.cwd();
+				const { skillRoots, pluginRoots } = getClaudeSearchRoots(cwd);
+
+				// At least one root should exist in our test environment
+				assert.ok(
+					skillRoots.length > 0 || pluginRoots.length > 0,
+					'Should find at least one search root'
+				);
+
+				// All returned roots should exist
+				for (const root of [...skillRoots, ...pluginRoots]) {
+					assert.ok(existsSync(root), `Root should exist: ${root}`);
+				}
+			});
+		});
+
+		describe('discoverClaudeSkills()', () => {
+			it('should discover skills without crashing', () => {
+				const cwd = process.cwd();
+				const skills = discoverClaudeSkills(cwd);
+
+				assert.ok(Array.isArray(skills), 'Should return an array');
+
+				// Log for observability
+				console.log(`\nDiscovered ${skills.length} skills`);
+
+				if (skills.length > 0) {
+					console.log('Sample skills:');
+					skills.slice(0, 3).forEach(s => {
+						console.log(`  - ${s.name} (${s.sourceLabel})`);
+					});
+
+					// Verify structure
+					const sample = skills[0]!;
+					assert.ok(sample.name, 'Skill should have name');
+					assert.ok(sample.path, 'Skill should have path');
+					assert.ok(sample.root, 'Skill should have root');
+					assert.strictEqual(sample.type, 'skill');
+				}
+			});
+		});
+
+		describe('discoverClaudePlugins()', () => {
+			it('should discover plugins without crashing', () => {
+				const cwd = process.cwd();
+				const plugins = discoverClaudePlugins(cwd);
+
+				assert.ok(Array.isArray(plugins), 'Should return an array');
+
+				// Log for observability
+				console.log(`\nDiscovered ${plugins.length} plugins`);
+
+				if (plugins.length > 0) {
+					console.log('Sample plugins:');
+					plugins.slice(0, 3).forEach(p => {
+						console.log(`  - ${p.name} (${p.sourceLabel})`);
+					});
+
+					// Verify structure
+					const sample = plugins[0]!;
+					assert.ok(sample.name, 'Plugin should have name');
+					assert.ok(sample.path, 'Plugin should have path');
+					assert.strictEqual(sample.type, 'plugin');
+				}
+			});
+		});
+
+		describe('runClaudeImportFlow()', () => {
+			it('should not crash when user cancels at first prompt', async () => {
+				const { ctx, selectCalls } = createMockContext(['Cancel']);
+
+				const readPrefs = () => ({ ...prefs });
+				const writePrefs = async (p: Record<string, unknown>) => {
+					Object.assign(prefs, p);
+				};
+
+				// Should complete without throwing
+				await runClaudeImportFlow(ctx, 'global', readPrefs, writePrefs);
+
+				// Should have asked about asset type
+				assert.ok(selectCalls.length >= 1, 'Should have at least one select call');
+				assert.ok(
+					selectCalls[0]!.prompt.includes('Import Claude assets'),
+					'First prompt should be about asset selection'
+				);
+			});
+
+			it('should not crash when selecting skills only with cancel at next step', async () => {
+				const { ctx, selectCalls } = createMockContext([
+					'Skills only',    // Select skills only
+					'Cancel',         // Cancel at skill selection
+				]);
+
+				const readPrefs = () => ({ ...prefs });
+				const writePrefs = async (p: Record<string, unknown>) => {
+					Object.assign(prefs, p);
+				};
+
+				// Should complete without throwing
+				await runClaudeImportFlow(ctx, 'global', readPrefs, writePrefs);
+
+				// Log interaction flow
+				console.log('\nSelect calls made:');
+				selectCalls.forEach((call, i) => {
+					console.log(`  ${i + 1}. "${call.prompt}"`);
+				});
+			});
+
+			it('should handle marketplace flow when user selects plugins', async () => {
+				const { ctx, selectCalls } = createMockContext([
+					'Plugins only',                     // Select plugins only
+					'Yes - discover plugins and select components',  // Marketplace prompt
+					'Cancel',                           // Cancel at component selection
+				]);
+
+				const readPrefs = () => ({ ...prefs });
+				const writePrefs = async (p: Record<string, unknown>) => {
+					Object.assign(prefs, p);
+				};
+
+				// Should complete without throwing
+				await runClaudeImportFlow(ctx, 'global', readPrefs, writePrefs);
+
+				// Log interaction flow
+				console.log('\nMarketplace flow select calls:');
+				selectCalls.forEach((call, i) => {
+					console.log(`  ${i + 1}. "${call.prompt}"`);
+				});
+			});
+
+			it('should complete import-all flow with mock UI', async () => {
+				// This tests the happy path where user selects "Import all"
+				const { ctx, selectCalls } = createMockContext([
+					'Skills + plugins',                 // Select both
+					'Cancel',                           // Cancel at skill selection (no skills to import)
+					'Yes - discover plugins and select components',  // Marketplace prompt
+					'Import all components',            // Import all
+					'Yes, continue',                    // Continue with warnings (if any)
+				]);
+
+				const readPrefs = () => ({ ...prefs });
+				const writePrefs = async (p: Record<string, unknown>) => {
+					Object.assign(prefs, p);
+				};
+
+				// Should complete without throwing
+				await runClaudeImportFlow(ctx, 'global', readPrefs, writePrefs);
+
+				// Log interaction flow
+				console.log('\nImport-all flow select calls:');
+				selectCalls.forEach((call, i) => {
+					console.log(`  ${i + 1}. "${call.prompt}"`);
+				});
+
+				// Verify notification was called
+				const notifyCalls = (ctx.ui.notify as unknown as ReturnType<typeof mock.fn>).mock.calls;
+				assert.ok(notifyCalls.length > 0, 'Should have shown notification');
+
+				console.log('\nNotifications shown:');
+				notifyCalls.forEach((call, i) => {
+					const msg = call.arguments[0];
+					const level = call.arguments[1];
+					console.log(`  ${i + 1}. [${level}]: ${String(msg).split('\n')[0]}`);
+				});
+			});
+
+			it('should not persist marketplace agent directories into package sources', async () => {
+				const isolatedAgentDir = join(tempDir, '.gsd', 'agent');
+				const settingsPath = join(isolatedAgentDir, 'settings.json');
+				rmSync(isolatedAgentDir, { recursive: true, force: true });
+				process.env.GSD_CODING_AGENT_DIR = isolatedAgentDir;
+
+				try {
+					mkdirSync(isolatedAgentDir, { recursive: true });
+					const tempSettings: Record<string, unknown> = { packages: [] };
+					writeFileSync(settingsPath, JSON.stringify(tempSettings, null, 2));
+
+					const { ctx } = createMockContext([
+						'Plugins only',
+						'Yes - discover plugins and select components',
+						'Import all components',
+						'Yes, continue',
+					]);
+
+					const readPrefs = () => ({ ...prefs });
+					const writePrefs = async (p: Record<string, unknown>) => {
+						Object.assign(prefs, p);
+					};
+
+					await runClaudeImportFlow(ctx, 'global', readPrefs, writePrefs);
+
+					const settings = JSON.parse(readFileSync(settingsPath, 'utf8')) as { packages?: unknown[] };
+					const packageEntries = Array.isArray(settings.packages) ? settings.packages : [];
+					const hasAgentsDirPackage = packageEntries.some((entry) => {
+						const source = typeof entry === 'string'
+							? entry
+							: (entry && typeof entry === 'object' ? (entry as { source?: unknown }).source : undefined);
+						return typeof source === 'string' && source.endsWith('/agents');
+					});
+
+					assert.strictEqual(hasAgentsDirPackage, false, 'Marketplace agent directories should not be persisted as package sources');
+				} finally {
+					delete process.env.GSD_CODING_AGENT_DIR;
+					rmSync(isolatedAgentDir, { recursive: true, force: true });
+				}
+			});
+		});
+	}
+);