gsd-pi 2.17.0 → 2.19.0

package/src/resources/extensions/gsd/tests/remote-questions.test.ts

@@ -1,9 +1,15 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { parseSlackReply, parseDiscordResponse } from "../../remote-questions/format.ts";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseSlackReply, parseDiscordResponse, formatForDiscord } from "../../remote-questions/format.ts";
 import { resolveRemoteConfig, isValidChannelId } from "../../remote-questions/config.ts";
 import { sanitizeError } from "../../remote-questions/manager.ts";
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
 test("parseSlackReply handles single-number single-question answers", () => {
   const result = parseSlackReply("2", [{
     id: "choice",
@@ -153,3 +159,223 @@ test("sanitizeError preserves short safe messages", () => {
   assert.equal(sanitizeError("Connection refused"), "Connection refused");
 });
 
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Discord Parity Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("formatForDiscord includes context source in footer when present", () => {
+  const prompt = {
+    id: "test-1",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    context: { source: "auto-mode-dispatch" },
+    questions: [{
+      id: "q1",
+      header: "Confirm",
+      question: "Proceed?",
+      options: [
+        { label: "Yes", description: "Continue" },
+        { label: "No", description: "Stop" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.equal(embeds.length, 1);
+  assert.ok(embeds[0].footer?.text.includes("auto-mode-dispatch"), "footer should include context source");
+});
+
+test("formatForDiscord omits source from footer when context is absent", () => {
+  const prompt = {
+    id: "test-2",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Choice",
+      question: "Pick one",
+      options: [
+        { label: "A", description: "Alpha" },
+        { label: "B", description: "Beta" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.ok(!embeds[0].footer?.text.includes("Source:"), "footer should not include Source when context absent");
+});
+
+test("formatForDiscord multi-question footer includes question position", () => {
+  const prompt = {
+    id: "test-3",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick",
+        options: [{ label: "A", description: "a" }],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Pick",
+        options: [{ label: "B", description: "b" }],
+        allowMultiple: false,
+      },
+    ],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.equal(embeds.length, 2);
+  assert.ok(embeds[0].footer?.text.includes("1/2"), "first embed footer should show 1/2");
+  assert.ok(embeds[1].footer?.text.includes("2/2"), "second embed footer should show 2/2");
+});
+
+test("formatForDiscord single-question generates reaction emojis", () => {
+  const prompt = {
+    id: "test-4",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Pick",
+      question: "Choose",
+      options: [
+        { label: "A", description: "a" },
+        { label: "B", description: "b" },
+        { label: "C", description: "c" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { reactionEmojis } = formatForDiscord(prompt);
+  assert.equal(reactionEmojis.length, 3, "should generate 3 reaction emojis for 3 options");
+  assert.equal(reactionEmojis[0], "1️⃣");
+  assert.equal(reactionEmojis[1], "2️⃣");
+  assert.equal(reactionEmojis[2], "3️⃣");
+});
+
+test("formatForDiscord multi-question generates no reaction emojis", () => {
+  const prompt = {
+    id: "test-5",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick",
+        options: [{ label: "A", description: "a" }],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Pick",
+        options: [{ label: "B", description: "b" }],
+        allowMultiple: false,
+      },
+    ],
+  };
+
+  const { reactionEmojis } = formatForDiscord(prompt);
+  assert.equal(reactionEmojis.length, 0, "multi-question should not generate reaction emojis");
+});
+
+test("parseDiscordResponse handles multi-question text reply via semicolons", () => {
+  const result = parseDiscordResponse([], "1;2", [
+    {
+      id: "first",
+      header: "First",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+      ],
+    },
+    {
+      id: "second",
+      header: "Second",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [
+        { label: "Gamma", description: "G" },
+        { label: "Delta", description: "D" },
+      ],
+    },
+  ]);
+
+  assert.deepEqual(result.answers.first.answers, ["Alpha"]);
+  assert.deepEqual(result.answers.second.answers, ["Delta"]);
+});
+
+test("parseDiscordResponse handles multiple reactions for allowMultiple question", () => {
+  const result = parseDiscordResponse(
+    [{ emoji: "1️⃣", count: 1 }, { emoji: "3️⃣", count: 1 }],
+    null,
+    [{
+      id: "choice",
+      header: "Choice",
+      question: "Pick any",
+      allowMultiple: true,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+        { label: "Gamma", description: "G" },
+      ],
+    }],
+  );
+
+  assert.deepEqual(result.answers.choice.answers, ["Alpha", "Gamma"]);
+});
+
+test("DiscordAdapter source-level: acknowledgeAnswer method exists", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(adapterSrc.includes("async acknowledgeAnswer"), "should have acknowledgeAnswer method");
+  assert.ok(adapterSrc.includes("✅"), "should use checkmark emoji for acknowledgement");
+});
+
+test("DiscordAdapter source-level: resolves guild ID for message URLs", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(adapterSrc.includes("guildId"), "should track guild ID");
+  assert.ok(adapterSrc.includes("guild_id"), "should read guild_id from channel info");
+  assert.ok(
+    adapterSrc.includes("discord.com/channels/"),
+    "should construct message URL with guild/channel/message format",
+  );
+});
+
+test("DiscordAdapter source-level: sendPrompt sets threadUrl in ref", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    adapterSrc.includes("threadUrl: messageUrl"),
+    "sendPrompt should set threadUrl to the constructed message URL",
+  );
+});

package/src/resources/extensions/gsd/tests/routing-history.test.ts

@@ -1,87 +1,240 @@
-/**
- * Routing History — structural tests for adaptive learning module.
- *
- * Verifies routing-history.ts exports and structure from #579.
- * Uses source-level checks to avoid @gsd/pi-coding-agent import chain.
- */
-
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const historySrc = readFileSync(join(__dirname, "..", "routing-history.ts"), "utf-8");
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Module Exports
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("routing-history: exports initRoutingHistory", () => {
-  assert.ok(historySrc.includes("export function initRoutingHistory"), "should export initRoutingHistory");
+import { mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  initRoutingHistory,
+  resetRoutingHistory,
+  recordOutcome,
+  recordFeedback,
+  getAdaptiveTierAdjustment,
+  clearRoutingHistory,
+  getRoutingHistory,
+} from "../routing-history.js";
+
+// ─── Test Setup ──────────────────────────────────────────────────────────────
+
+function makeTmpDir(): string {
+  const dir = join(tmpdir(), `gsd-routing-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch {}
+  resetRoutingHistory();
+}
+
+// ─── recordOutcome ───────────────────────────────────────────────────────────
+
+test("recordOutcome tracks success and failure counts", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "standard", true);
+    recordOutcome("execute-task", "standard", true);
+    recordOutcome("execute-task", "standard", false);
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    const pattern = history.patterns["execute-task"];
+    assert.ok(pattern);
+    assert.equal(pattern.standard.success, 2);
+    assert.equal(pattern.standard.fail, 1);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: exports recordOutcome", () => {
-  assert.ok(historySrc.includes("export function recordOutcome"), "should export recordOutcome");
+test("recordOutcome tracks tag-specific patterns", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "light", true, ["docs"]);
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    assert.ok(history.patterns["execute-task:docs"]);
+    assert.equal(history.patterns["execute-task:docs"].light.success, 1);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: exports recordFeedback", () => {
-  assert.ok(historySrc.includes("export function recordFeedback"), "should export recordFeedback");
+test("recordOutcome applies rolling window", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    // Record 60 successes — should be capped to 50
+    for (let i = 0; i < 60; i++) {
+      recordOutcome("execute-task", "standard", true);
+    }
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    const total = history.patterns["execute-task"].standard.success +
+                  history.patterns["execute-task"].standard.fail;
+    assert.ok(total <= 50, `total ${total} should be <= 50`);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: exports getAdaptiveTierAdjustment", () => {
-  assert.ok(historySrc.includes("export function getAdaptiveTierAdjustment"), "should export getAdaptiveTierAdjustment");
+// ─── getAdaptiveTierAdjustment ───────────────────────────────────────────────
+
+test("no adjustment when insufficient data", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "light", false);
+    // Only 1 data point — not enough
+    const adj = getAdaptiveTierAdjustment("execute-task", "light");
+    assert.equal(adj, null);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: exports resetRoutingHistory", () => {
-  assert.ok(historySrc.includes("export function resetRoutingHistory"), "should export resetRoutingHistory");
+test("bumps tier when failure rate exceeds threshold", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    // Record high failure rate at light tier
+    recordOutcome("execute-task", "light", false);
+    recordOutcome("execute-task", "light", false);
+    recordOutcome("execute-task", "light", true);
+    // 2/3 = 66% failure rate > 20% threshold
+
+    const adj = getAdaptiveTierAdjustment("execute-task", "light");
+    assert.equal(adj, "standard");
+  } finally {
+    cleanup(dir);
+  }
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Design Constants
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("routing-history: uses rolling window of 50 entries", () => {
-  assert.ok(historySrc.includes("ROLLING_WINDOW = 50"), "should use 50-entry rolling window");
+test("no adjustment when success rate is high", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    for (let i = 0; i < 10; i++) {
+      recordOutcome("execute-task", "light", true);
+    }
+    const adj = getAdaptiveTierAdjustment("execute-task", "light");
+    assert.equal(adj, null);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: failure threshold is 20%", () => {
-  assert.ok(historySrc.includes("FAILURE_THRESHOLD = 0.20"), "should use 20% failure threshold");
+test("tag-specific patterns take precedence", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    // Base pattern has high success rate (tagged calls also count toward base)
+    for (let i = 0; i < 15; i++) {
+      recordOutcome("execute-task", "light", true);
+    }
+    // But docs-tagged tasks fail at light
+    recordOutcome("execute-task", "light", false, ["docs"]);
+    recordOutcome("execute-task", "light", false, ["docs"]);
+    recordOutcome("execute-task", "light", true, ["docs"]);
+
+    // With tags, should bump (docs pattern: 1/3 success = 66% failure)
+    const adj = getAdaptiveTierAdjustment("execute-task", "light", ["docs"]);
+    assert.equal(adj, "standard");
+
+    // Without tags, should not bump (base: 16/18 success = 11% failure)
+    const adjBase = getAdaptiveTierAdjustment("execute-task", "light");
+    assert.equal(adjBase, null);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: feedback weight is 2x", () => {
-  assert.ok(historySrc.includes("FEEDBACK_WEIGHT = 2"), "feedback should count 2x");
+// ─── recordFeedback ──────────────────────────────────────────────────────────
+
+test("recordFeedback stores feedback entries", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordFeedback("execute-task", "M001/S01/T01", "standard", "over");
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    assert.equal(history.feedback.length, 1);
+    assert.equal(history.feedback[0].rating, "over");
+    assert.equal(history.feedback[0].tier, "standard");
+  } finally {
+    cleanup(dir);
+  }
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Type Structure
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("routing-history: imports ComplexityTier from types.ts", () => {
-  assert.ok(
-    historySrc.includes('from "./types.js"') && historySrc.includes("ComplexityTier"),
-    "should import ComplexityTier from types.ts",
-  );
-});
-
-test("routing-history: defines RoutingHistoryData interface", () => {
-  assert.ok(historySrc.includes("interface RoutingHistoryData"), "should define RoutingHistoryData");
+test("recordFeedback 'under' increases failure count at tier", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordFeedback("execute-task", "M001/S01/T01", "light", "under");
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    // "under" adds 2 (FEEDBACK_WEIGHT) failures
+    assert.equal(history.patterns["execute-task"].light.fail, 2);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: defines FeedbackEntry interface", () => {
-  assert.ok(historySrc.includes("interface FeedbackEntry"), "should define FeedbackEntry");
+test("recordFeedback 'over' increases success count at lower tier", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordFeedback("execute-task", "M001/S01/T01", "standard", "over");
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    // "over" at standard → adds 2 successes at light
+    assert.equal(history.patterns["execute-task"].light.success, 2);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Persistence
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("routing-history: persists to routing-history.json", () => {
-  assert.ok(historySrc.includes("routing-history.json"), "should persist to routing-history.json");
+// ─── clearRoutingHistory ─────────────────────────────────────────────────────
+
+test("clearRoutingHistory resets all data", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "light", true);
+    clearRoutingHistory(dir);
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    assert.deepEqual(history.patterns, {});
+    assert.deepEqual(history.feedback, []);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: has save and load functions", () => {
-  assert.ok(historySrc.includes("saveHistory") || historySrc.includes("function save"), "should have save");
-  assert.ok(historySrc.includes("loadHistory") || historySrc.includes("function load"), "should have load");
+// ─── Persistence ─────────────────────────────────────────────────────────────
+
+test("routing history persists to disk and reloads", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "standard", true);
+    recordOutcome("execute-task", "standard", true);
+    resetRoutingHistory();
+
+    // Reload from disk
+    initRoutingHistory(dir);
+    const history = getRoutingHistory();
+    assert.ok(history);
+    assert.equal(history.patterns["execute-task"].standard.success, 2);
+  } finally {
+    cleanup(dir);
+  }
 });

package/src/resources/extensions/gsd/tests/stale-worktree-cwd.test.ts

@@ -0,0 +1,139 @@
+/**
+ * stale-worktree-cwd.test.ts — Tests for #608 fix.
+ *
+ * Verifies that when process.cwd() is inside a stale .gsd/worktrees/ path,
+ * startAuto escapes back to the project root before proceeding.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, existsSync, realpathSync, writeFileSync } from "node:fs";
+import { join, sep } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createAutoWorktree,
+  teardownAutoWorktree,
+  mergeMilestoneToMain,
+} from "../auto-worktree.ts";
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "stale-wt-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+// ─── escapeStaleWorktree is called by startAuto, test the detection logic ────
+
+test("detects stale worktree path and extracts project root", () => {
+  // Simulate the path pattern: /project/.gsd/worktrees/M004/...
+  const projectRoot = "/Users/test/myproject";
+  const stalePath = `${projectRoot}${sep}.gsd${sep}worktrees${sep}M004`;
+
+  const marker = `${sep}.gsd${sep}worktrees${sep}`;
+  const idx = stalePath.indexOf(marker);
+
+  assert.ok(idx !== -1, "marker found in stale path");
+  assert.equal(stalePath.slice(0, idx), projectRoot, "project root extracted correctly");
+});
+
+test("does not trigger on normal project path", () => {
+  const normalPath = "/Users/test/myproject";
+  const marker = `${sep}.gsd${sep}worktrees${sep}`;
+  const idx = normalPath.indexOf(marker);
+
+  assert.equal(idx, -1, "marker not found in normal path");
+});
+
+// ─── Integration: mergeMilestoneToMain restores cwd ─────────────────────────
+
+test("mergeMilestoneToMain restores cwd to project root", () => {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Create milestone planning artifacts
+    const msDir = join(tempDir, ".gsd", "milestones", "M050");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M050 Context\n");
+    const roadmap = [
+      "# M050: Test Milestone",
+      "**Vision**: testing",
+      "## Success Criteria",
+      "- It works",
+      "## Slices",
+      "- [x] S01 — First slice",
+    ].join("\n");
+    writeFileSync(join(msDir, "ROADMAP.md"), roadmap);
+    run("git add .", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
+
+    // Create auto-worktree (enters the worktree dir)
+    const wtPath = createAutoWorktree(tempDir, "M050");
+    assert.equal(process.cwd(), wtPath, "cwd is in worktree after create");
+
+    // Add a change in the worktree
+    writeFileSync(join(wtPath, "feature.txt"), "new feature\n");
+    run("git add .", wtPath);
+    run("git commit -m \"feat: add feature\"", wtPath);
+
+    // Merge back — should restore cwd to tempDir
+    mergeMilestoneToMain(tempDir, "M050", roadmap);
+
+    assert.equal(process.cwd(), tempDir, "cwd restored to project root after merge");
+    assert.ok(!existsSync(wtPath), "worktree directory removed after merge");
+  } finally {
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+});
+
+// ─── Integration: stale worktree directory is detectable ────────────────────
+
+test("process.cwd() inside removed worktree is recoverable", () => {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Create a .gsd/worktrees/M099 directory to simulate stale state
+    const staleWtDir = join(tempDir, ".gsd", "worktrees", "M099");
+    mkdirSync(staleWtDir, { recursive: true });
+
+    // Enter the stale directory
+    process.chdir(staleWtDir);
+    const cwdBefore = process.cwd();
+    assert.ok(cwdBefore.includes(`${sep}.gsd${sep}worktrees${sep}`), "cwd is inside worktree dir");
+
+    // Simulate escapeStaleWorktree logic
+    const marker = `${sep}.gsd${sep}worktrees${sep}`;
+    const idx = cwdBefore.indexOf(marker);
+    assert.ok(idx !== -1, "marker found");
+
+    const projectRoot = cwdBefore.slice(0, idx);
+    process.chdir(projectRoot);
+
+    assert.equal(process.cwd(), tempDir, "successfully escaped to project root");
+  } finally {
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+});