gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

package/src/resources/extensions/gsd/tests/uok-loop-adapter-writer.test.ts

@@ -0,0 +1,65 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createTurnObserver } from "../uok/loop-adapter.ts";
+import { hasActiveWriterToken, resetWriterTokensForTests } from "../uok/writer.ts";
+
+function readAuditPayloads(basePath: string): Array<Record<string, unknown>> {
+  const path = join(basePath, ".gsd", "audit", "events.jsonl");
+  if (!existsSync(path)) return [];
+  return readFileSync(path, "utf-8")
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as { payload?: Record<string, unknown> })
+    .map((event) => event.payload ?? {});
+}
+
+test("uok turn observer adds writer sequence metadata to audit events", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-loop-writer-"));
+  resetWriterTokensForTests();
+  t.after(() => {
+    resetWriterTokensForTests();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const observer = createTurnObserver({
+    basePath,
+    gitAction: "status-only",
+    gitPush: false,
+    enableAudit: true,
+    enableGitops: false,
+  });
+
+  observer.onTurnStart({
+    basePath,
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 1,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    startedAt: new Date().toISOString(),
+  });
+  assert.equal(hasActiveWriterToken(basePath, "turn-1"), true);
+
+  observer.onTurnResult({
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 1,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    status: "completed",
+    failureClass: "none",
+    phaseResults: [],
+    startedAt: new Date().toISOString(),
+    finishedAt: new Date().toISOString(),
+  });
+
+  assert.equal(hasActiveWriterToken(basePath, "turn-1"), false);
+  const payloads = readAuditPayloads(basePath);
+  assert.equal(payloads[0]?.writeSequence, 1);
+  assert.equal(payloads[1]?.writeSequence, 2);
+  assert.equal(typeof payloads[0]?.writerTokenId, "string");
+});

package/src/resources/extensions/gsd/tests/uok-parity-report.test.ts

@@ -0,0 +1,42 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, appendFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { buildParityReport, parseParityEvents, writeParityReport } from "../uok/parity-report.ts";
+
+test("uok parity report summarizes paths, statuses, and fallback use", () => {
+  const events = parseParityEvents([
+    JSON.stringify({ path: "uok-kernel", phase: "enter" }),
+    JSON.stringify({ path: "uok-kernel", phase: "exit", status: "ok" }),
+    JSON.stringify({ path: "legacy-fallback", phase: "enter" }),
+    JSON.stringify({ path: "legacy-fallback", phase: "exit", status: "error", error: "boom" }),
+  ].join("\n"));
+
+  const report = buildParityReport(events, "/tmp/uok-parity.jsonl");
+  assert.equal(report.totalEvents, 4);
+  assert.equal(report.paths["uok-kernel"], 2);
+  assert.equal(report.fallbackInvocations, 2);
+  assert.deepEqual(report.criticalMismatches, ["boom"]);
+});
+
+test("uok parity report writes runtime report artifact", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-parity-"));
+  t.after(() => {
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const runtime = join(basePath, ".gsd", "runtime");
+  mkdirSync(runtime, { recursive: true });
+  appendFileSync(
+    join(runtime, "uok-parity.jsonl"),
+    `${JSON.stringify({ path: "uok-kernel", phase: "exit", status: "ok" })}\n`,
+    "utf-8",
+  );
+
+  const report = writeParityReport(basePath);
+  assert.equal(report.totalEvents, 1);
+  const saved = JSON.parse(readFileSync(join(runtime, "uok-parity-report.json"), "utf-8"));
+  assert.equal(saved.statuses.ok, 1);
+});

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -13,7 +13,11 @@ import {
   openDatabase,
 } from "../gsd-db.ts";
 import type { GSDState, Phase } from "../types.ts";
-import { ensurePlanV2Graph } from "../uok/plan-v2.ts";
+import {
+  ensurePlanV2Graph,
+  hasFinalizedMilestoneContext,
+  isMissingFinalizedContextResult,
+} from "../uok/plan-v2.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const gsdDir = join(__dirname, "..");
@@ -88,7 +92,7 @@ test.afterEach(() => {
   tempDirs.clear();
 });
 
-test("guided flow enforces plan-v2 gate before execution-oriented dispatch", () => {
+test("guided flow keeps plan-v2 fail-closed handling for non-recoverable failures", () => {
   const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
   assert.ok(
     source.includes("needsPlanV2Gate") &&
@@ -98,6 +102,17 @@ test("guided flow enforces plan-v2 gate before execution-oriented dispatch", ()
   );
 });
 
+test("guided flow routes recoverable missing finalized context to discuss-milestone", () => {
+  const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
+  assert.ok(
+    source.includes('PlanV2GateDecision = "pass" | "recover-missing-context" | "block"') &&
+    source.includes("isMissingFinalizedContextResult(compiled)") &&
+    source.includes('planV2GateDecision === "recover-missing-context"') &&
+    source.includes("buildDiscussMilestonePrompt"),
+    "guided flow should redispatch missing finalized context to discuss-milestone instead of fail-closing",
+  );
+});
+
 test("plan-v2 gate fails closed for execution phase when finalized context is missing", () => {
   const basePath = createBasePath();
   seedGraphRows();
@@ -107,6 +122,7 @@ test("plan-v2 gate fails closed for execution phase when finalized context is mi
   const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
   assert.equal(compiled.ok, false);
   assert.match(compiled.reason ?? "", /CONTEXT\.md/i);
+  assert.equal(isMissingFinalizedContextResult(compiled), true);
 });
 
 test("plan-v2 gate accepts finalized context from project-root fallback", () => {
@@ -123,6 +139,7 @@ test("plan-v2 gate accepts finalized context from project-root fallback", () =>
     const compiled = ensurePlanV2Graph(worktreeBase, buildState("executing"));
     assert.equal(compiled.ok, true);
     assert.equal(compiled.finalizedContextIncluded, true);
+    assert.equal(hasFinalizedMilestoneContext(worktreeBase, MILESTONE_ID), true);
   } finally {
     if (prevProjectRoot === undefined) {
       delete process.env.GSD_PROJECT_ROOT;

package/src/resources/extensions/gsd/tests/uok-writer.test.ts

@@ -0,0 +1,75 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  acquireWriterToken,
+  hasActiveWriterToken,
+  nextWriteRecord,
+  releaseWriterToken,
+  resetWriterTokensForTests,
+} from "../uok/writer.ts";
+
+test("uok writer enforces one active token per turn", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-writer-"));
+  resetWriterTokensForTests();
+  t.after(() => {
+    resetWriterTokensForTests();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const token = acquireWriterToken({
+    basePath,
+    traceId: "trace-1",
+    turnId: "turn-1",
+  });
+  assert.equal(hasActiveWriterToken(basePath, "turn-1"), true);
+  assert.throws(
+    () => acquireWriterToken({ basePath, traceId: "trace-1", turnId: "turn-1" }),
+    /already active/,
+  );
+
+  releaseWriterToken(basePath, token);
+  assert.equal(hasActiveWriterToken(basePath, "turn-1"), false);
+});
+
+test("uok writer produces monotonic sequence records across turns", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-writer-seq-"));
+  resetWriterTokensForTests();
+  t.after(() => {
+    resetWriterTokensForTests();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const token1 = acquireWriterToken({
+    basePath,
+    traceId: "trace-1",
+    turnId: "turn-1",
+  });
+  const first = nextWriteRecord({
+    basePath,
+    token: token1,
+    category: "audit",
+    operation: "append",
+    path: ".gsd/audit/events.jsonl",
+  });
+  releaseWriterToken(basePath, token1);
+
+  const token2 = acquireWriterToken({
+    basePath,
+    traceId: "trace-2",
+    turnId: "turn-2",
+  });
+  const second = nextWriteRecord({
+    basePath,
+    token: token2,
+    category: "gitops",
+    operation: "insert",
+  });
+
+  assert.equal(first.sequence.sequence, 1);
+  assert.equal(second.sequence.sequence, 2);
+  assert.equal(second.sequence.turnId, "turn-2");
+});

package/src/resources/extensions/gsd/tests/validate-extension-package.test.ts

@@ -0,0 +1,168 @@
+// GSD-2 — Tests for validateExtensionPackage (EXTR-02, PKG-05)
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { validateExtensionPackage } from "../commands-extensions.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeTempDir(): string {
+  const dir = join(tmpdir(), `validate-ext-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function writePackageJson(dir: string, content: Record<string, unknown>): void {
+  writeFileSync(join(dir, "package.json"), JSON.stringify(content, null, 2));
+}
+
+function writeIndexTs(dir: string, content = "export default function() {}"): void {
+  writeFileSync(join(dir, "index.ts"), content);
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+test("validateExtensionPackage: valid package returns { valid: true }", (t) => {
+  // EXTR-02: gsd.extension: true, peerDependencies, pi.extensions
+  const dir = makeTempDir();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  writeIndexTs(dir);
+  writePackageJson(dir, {
+    name: "@gsd-extensions/test",
+    version: "1.0.0",
+    gsd: { extension: true },
+    pi: { extensions: ["./index.ts"] },
+    peerDependencies: { "@gsd/pi-coding-agent": "*" },
+    dependencies: { "some-lib": "^1.0.0" },
+  });
+
+  const result = validateExtensionPackage(dir);
+  assert.equal(result.valid, true);
+  assert.deepEqual(result.errors, []);
+});
+
+test("validateExtensionPackage: missing gsd.extension marker returns error", (t) => {
+  const dir = makeTempDir();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  writeIndexTs(dir);
+  writePackageJson(dir, {
+    name: "@gsd-extensions/test",
+    version: "1.0.0",
+    pi: { extensions: ["./index.ts"] },
+    peerDependencies: { "@gsd/pi-coding-agent": "*" },
+  });
+
+  const result = validateExtensionPackage(dir);
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.some(e => e.includes("gsd")), `Expected error about gsd, got: ${JSON.stringify(result.errors)}`);
+});
+
+test("validateExtensionPackage: missing pi.extensions returns error", (t) => {
+  const dir = makeTempDir();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  writeIndexTs(dir);
+  writePackageJson(dir, {
+    name: "@gsd-extensions/test",
+    version: "1.0.0",
+    gsd: { extension: true },
+    peerDependencies: { "@gsd/pi-coding-agent": "*" },
+  });
+
+  const result = validateExtensionPackage(dir);
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.some(e => e.includes("pi")), `Expected error about pi.extensions, got: ${JSON.stringify(result.errors)}`);
+});
+
+test("validateExtensionPackage: pi.extensions entry path not found returns error", (t) => {
+  const dir = makeTempDir();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Do NOT create index.ts
+  writePackageJson(dir, {
+    name: "@gsd-extensions/test",
+    version: "1.0.0",
+    gsd: { extension: true },
+    pi: { extensions: ["./index.ts"] },
+    peerDependencies: { "@gsd/pi-coding-agent": "*" },
+  });
+
+  const result = validateExtensionPackage(dir);
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.some(e => e.includes("index.ts")), `Expected error about index.ts, got: ${JSON.stringify(result.errors)}`);
+});
+
+test("validateExtensionPackage: @gsd/* in dependencies (not peerDependencies) returns error", (t) => {
+  const dir = makeTempDir();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  writeIndexTs(dir);
+  writePackageJson(dir, {
+    name: "@gsd-extensions/test",
+    version: "1.0.0",
+    gsd: { extension: true },
+    pi: { extensions: ["./index.ts"] },
+    dependencies: { "@gsd/pi-coding-agent": "^2.0.0" },
+  });
+
+  const result = validateExtensionPackage(dir);
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.some(e => e.includes("@gsd/pi-coding-agent")), `Expected error about @gsd/ dep, got: ${JSON.stringify(result.errors)}`);
+});
+
+test("validateExtensionPackage: @gsd/* in devDependencies returns error", (t) => {
+  const dir = makeTempDir();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  writeIndexTs(dir);
+  writePackageJson(dir, {
+    name: "@gsd-extensions/test",
+    version: "1.0.0",
+    gsd: { extension: true },
+    pi: { extensions: ["./index.ts"] },
+    peerDependencies: { "@gsd/pi-coding-agent": "*" },
+    devDependencies: { "@gsd/pi-tui": "^2.0.0" },
+  });
+
+  const result = validateExtensionPackage(dir);
+  assert.equal(result.valid, false);
+  assert.ok(
+    result.errors.some(e => e.includes("@gsd/pi-tui") && e.includes("devDependencies")),
+    `Expected error about @gsd/ in devDependencies, got: ${JSON.stringify(result.errors)}`,
+  );
+});
+
+test("validateExtensionPackage: missing package.json returns error", (t) => {
+  const dir = makeTempDir();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // No package.json written
+  const result = validateExtensionPackage(dir);
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.some(e => e.includes("package.json")), `Expected error about package.json, got: ${JSON.stringify(result.errors)}`);
+});
+
+test("validateExtensionPackage: invalid JSON in package.json returns error", (t) => {
+  const dir = makeTempDir();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  writeFileSync(join(dir, "package.json"), "{ invalid json :::}");
+
+  const result = validateExtensionPackage(dir);
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.some(e => e.toLowerCase().includes("json")), `Expected JSON error, got: ${JSON.stringify(result.errors)}`);
+});
+
+test("validateExtensionPackage: extracted google-search package passes validation (PKG-05)", (_t) => {
+  // This test runs against the actual extensions/google-search/ directory.
+  // Use process.cwd() (project root) since relative path from import.meta.url
+  // breaks when tests run from dist-test/.
+  const googleSearchDir = join(process.cwd(), "extensions", "google-search");
+
+  const result = validateExtensionPackage(googleSearchDir);
+  assert.equal(result.valid, true, `extensions/google-search/ should be valid, errors: ${JSON.stringify(result.errors)}`);
+});

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -41,6 +41,12 @@ function writeRoadmap(base: string, mid: string, content: string): void {
   writeFileSync(join(dir, `${mid}-ROADMAP.md`), content);
 }
 
+function writeContext(base: string, mid: string, content = "# M001 Context\n\nValidated context."): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-CONTEXT.md`), content);
+}
+
 function writeMilestoneSummary(base: string, mid: string, content: string): void {
   const dir = join(base, ".gsd", "milestones", mid);
   mkdirSync(dir, { recursive: true });
@@ -328,6 +334,7 @@ test("dispatch rule matches validating-milestone phase", async () => {
   const base = makeTmpBase();
   try {
     // Set up minimal milestone structure for the prompt builder
+    writeContext(base, "M001");
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
@@ -364,6 +371,7 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
 
   const base = makeTmpBase();
   try {
+    writeContext(base, "M001");
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
@@ -402,6 +410,7 @@ test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is n
   try {
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
     writeMilestoneSummary(base, "M001", "# Milestone Summary\nverification FAILED — not complete.");
 
     const ctx: DispatchContext = {
@@ -439,6 +448,7 @@ test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async (
   try {
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
     writeMilestoneSummary(
       base,
       "M001",
@@ -487,6 +497,7 @@ test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async ()
   try {
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
     writeMilestoneSummary(base, "M001", "# M001 Summary\nSome notes without completion metadata.");
 
     const ctx: DispatchContext = {

package/src/resources/extensions/gsd/tests/verify-artifact-tightened.test.ts

@@ -15,6 +15,7 @@ import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const src = readFileSync(
   resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'auto-recovery.ts'),
@@ -28,7 +29,7 @@ describe('verifyExpectedArtifact legacy branch tightened (#3607)', () => {
     assert.ok(legacyIdx !== -1, 'LEGACY comment must exist')
 
     // Check the code within a reasonable window after the LEGACY comment
-    const legacyBlock = src.slice(legacyIdx, legacyIdx + 600)
+    const legacyBlock = extractSourceRegion(src, 'LEGACY: Pre-migration fallback')
 
     assert.ok(
       !legacyBlock.includes('hdRe'),
@@ -40,7 +41,7 @@ describe('verifyExpectedArtifact legacy branch tightened (#3607)', () => {
     const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
     assert.ok(legacyIdx !== -1)
 
-    const legacyBlock = src.slice(legacyIdx, legacyIdx + 600)
+    const legacyBlock = extractSourceRegion(src, 'LEGACY: Pre-migration fallback')
 
     assert.ok(
       legacyBlock.includes('cbRe'),
@@ -58,7 +59,7 @@ describe('verifyExpectedArtifact legacy branch tightened (#3607)', () => {
     const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
     assert.ok(legacyIdx !== -1)
 
-    const legacyBlock = src.slice(legacyIdx, legacyIdx + 1000)
+    const legacyBlock = extractSourceRegion(src, 'LEGACY: Pre-migration fallback')
 
     // The else branch: no plan file means cannot verify
     assert.ok(
@@ -71,7 +72,7 @@ describe('verifyExpectedArtifact legacy branch tightened (#3607)', () => {
     const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
     assert.ok(legacyIdx !== -1)
 
-    const legacyBlock = src.slice(legacyIdx, legacyIdx + 1000)
+    const legacyBlock = extractSourceRegion(src, 'LEGACY: Pre-migration fallback')
 
     assert.ok(
       legacyBlock.includes('DB available but task row not found'),
@@ -80,7 +81,7 @@ describe('verifyExpectedArtifact legacy branch tightened (#3607)', () => {
 
     // The comment should be followed by a return false
     const commentIdx = legacyBlock.indexOf('DB available but task row not found')
-    const afterComment = legacyBlock.slice(commentIdx, commentIdx + 200)
+    const afterComment = extractSourceRegion(legacyBlock, 'DB available but task row not found')
     assert.ok(
       afterComment.includes('return false'),
       'missing task row when DB available must return false',

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -180,6 +180,11 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the
 test("workflow MCP launch config reaches mutation tools over stdio", async () => {
   const projectRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-transport-"));
   mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  // Isolate the spawned MCP server from the developer's real ~/.gsd so it
+  // can't pick up a configured Discord/Slack/Telegram channel from global
+  // PREFERENCES.md and route ask_user_questions through a remote adapter
+  // instead of MCP elicitation.
+  const isolatedGsdHome = mkdtempSync(join(tmpdir(), "gsd-workflow-home-"));
 
   const launch = detectWorkflowMcpLaunchConfig(projectRoot, {});
   assert.ok(launch, "expected a workflow MCP launch config");
@@ -219,7 +224,14 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
   const transport = new StdioClientTransport({
     command: launch.command,
     args: launch.args,
-    env: { ...process.env, ...launch.env } as Record<string, string>,
+    env: {
+      ...process.env,
+      ...launch.env,
+      GSD_HOME: isolatedGsdHome,
+      DISCORD_BOT_TOKEN: "",
+      SLACK_BOT_TOKEN: "",
+      TELEGRAM_BOT_TOKEN: "",
+    } as Record<string, string>,
     cwd: launch.cwd,
     stderr: "pipe",
   });
@@ -345,12 +357,14 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
   } finally {
     await client.close().catch(() => {});
     rmSync(projectRoot, { recursive: true, force: true });
+    rmSync(isolatedGsdHome, { recursive: true, force: true });
   }
 });
 
 test("workflow MCP ask_user_questions uses stdio elicitation round-trip", async () => {
   const projectRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-elicit-"));
   mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  const isolatedGsdHome = mkdtempSync(join(tmpdir(), "gsd-workflow-home-"));
 
   const launch = detectWorkflowMcpLaunchConfig(projectRoot, {});
   assert.ok(launch, "expected a workflow MCP launch config");
@@ -381,7 +395,14 @@ test("workflow MCP ask_user_questions uses stdio elicitation round-trip", async
   const transport = new StdioClientTransport({
     command: launch.command,
     args: launch.args,
-    env: { ...process.env, ...launch.env } as Record<string, string>,
+    env: {
+      ...process.env,
+      ...launch.env,
+      GSD_HOME: isolatedGsdHome,
+      DISCORD_BOT_TOKEN: "",
+      SLACK_BOT_TOKEN: "",
+      TELEGRAM_BOT_TOKEN: "",
+    } as Record<string, string>,
     cwd: launch.cwd,
     stderr: "pipe",
   });
@@ -432,6 +453,8 @@ test("workflow MCP ask_user_questions uses stdio elicitation round-trip", async
     );
   } finally {
     await client.close();
+    rmSync(projectRoot, { recursive: true, force: true });
+    rmSync(isolatedGsdHome, { recursive: true, force: true });
   }
 });
 

package/src/resources/extensions/gsd/tests/worktree-health-monorepo.test.ts

@@ -8,7 +8,7 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
+import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
 
 const { assertTrue, report } = createTestContext();
 
@@ -22,7 +22,7 @@ console.log("\n=== #2347: Worktree health check supports monorepos ===");
 const healthCheckIdx = src.indexOf("Worktree health check");
 assertTrue(healthCheckIdx > 0, "auto/phases.ts has worktree health check section");
 
-const healthCheckRegion = src.slice(healthCheckIdx, healthCheckIdx + 2000);
+const healthCheckRegion = extractSourceRegion(src, "Worktree health check");
 
 // ── Test 2: The check walks parent directories for project markers ──────
 

package/src/resources/extensions/gsd/tests/worktree-nested-git-safety.test.ts

@@ -13,7 +13,7 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
+import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
 
 const { assertTrue, report } = createTestContext();
 
@@ -27,7 +27,7 @@ console.log("\n=== #2616: Worktree cleanup detects nested .git directories ===")
 const removeWorktreeIdx = src.indexOf("export function removeWorktree");
 assertTrue(removeWorktreeIdx > 0, "worktree-manager.ts exports removeWorktree");
 
-const fnBody = src.slice(removeWorktreeIdx, removeWorktreeIdx + 5000);
+const fnBody = extractSourceRegion(src, "export function removeWorktree");
 
 const detectsNestedGit =
   fnBody.includes("nested") && fnBody.includes(".git") ||

package/src/resources/extensions/gsd/tests/worktree-submodule-safety.test.ts

@@ -8,7 +8,7 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
+import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
 
 const { assertTrue, report } = createTestContext();
 
@@ -22,7 +22,7 @@ console.log("\n=== #2337: Worktree teardown preserves submodule state ===");
 const removeWorktreeIdx = src.indexOf("export function removeWorktree");
 assertTrue(removeWorktreeIdx > 0, "worktree-manager.ts exports removeWorktree");
 
-const fnBody = src.slice(removeWorktreeIdx, removeWorktreeIdx + 6000);
+const fnBody = extractSourceRegion(src, "export function removeWorktree");
 
 // ── Test 2: The function checks for submodules before force removal ─────