gsd-pi 2.70.0-dev.55a1c68 → 2.70.0-dev.c236ea4

package/src/resources/extensions/gsd/doctor-engine-checks.ts

@@ -13,6 +13,20 @@ export async function checkEngineHealth(
   issues: DoctorIssue[],
   fixesApplied: string[],
 ): Promise<void> {
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+
+  if (!isDbAvailable() && existsSync(dbPath)) {
+    issues.push({
+      severity: "warning",
+      code: "db_unavailable",
+      scope: "project",
+      unitId: "project",
+      message: "Database unavailable — using filesystem state derivation (degraded mode). State queries may be slower and less reliable.",
+      file: ".gsd/gsd.db",
+      fixable: false,
+    });
+  }
+
   // ── DB constraint violation detection (full doctor only, not pre-dispatch per D-10) ──
   try {
     if (isDbAvailable()) {

package/src/resources/extensions/gsd/doctor-format.ts

@@ -2,6 +2,7 @@ import type { DoctorIssue, DoctorIssueCode, DoctorReport, DoctorSummary } from "
 
 function matchesScope(unitId: string, scope?: string): boolean {
   if (!scope) return true;
+  if (unitId === "project" || unitId === "environment") return true;
   return unitId === scope || unitId.startsWith(`${scope}/`) || unitId.startsWith(`${scope}`);
 }
 

package/src/resources/extensions/gsd/doctor-types.ts

@@ -78,6 +78,7 @@ export type DoctorIssueCode =
   | "db_orphaned_slice"
   | "db_done_task_no_summary"
   | "db_duplicate_id"
+  | "db_unavailable"
   | "projection_drift";
 
 /**

package/src/resources/extensions/gsd/guided-flow.ts

@@ -48,6 +48,7 @@ import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
 import {
   getWorkflowTransportSupportError,
   getRequiredWorkflowToolsForGuidedUnit,
+  supportsStructuredQuestions,
 } from "./workflow-mcp.js";
 import {
   runPreparation,
@@ -367,6 +368,20 @@ async function dispatchWorkflow(
   }
 }
 
+function getStructuredQuestionsAvailability(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext | undefined,
+): "true" | "false" {
+  if (!ctx) return "false";
+
+  const provider = ctx.model?.provider;
+  const authMode = provider ? ctx.modelRegistry.getProviderAuthMode(provider) : undefined;
+  return supportsStructuredQuestions(pi.getActiveTools(), {
+    authMode,
+    baseUrl: ctx.model?.baseUrl,
+  }) ? "true" : "false";
+}
+
 /**
  * Resolve a model ID string to a model object from available models.
  * Handles "provider/model" and bare ID formats.
@@ -739,7 +754,7 @@ export async function showDiscuss(
 
     if (choice === "discuss_draft") {
       const discussMilestoneTemplates = inlineTemplate("context", "Context");
-      const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+      const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
       const basePrompt = loadPrompt("guided-discuss-milestone", {
         milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
         commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
@@ -752,7 +767,7 @@ export async function showDiscuss(
       await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone");
     } else if (choice === "discuss_fresh") {
       const discussMilestoneTemplates = inlineTemplate("context", "Context");
-      const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+      const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
       pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: mid, step: false, createdAt: Date.now() });
       await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
         milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
@@ -910,7 +925,7 @@ export async function showDiscuss(
       if (confirm !== "rediscuss") continue;
     }
 
-    const sqAvail = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+    const sqAvail = getStructuredQuestionsAvailability(pi, ctx);
     const prompt = await buildDiscussSlicePrompt(mid, chosen.id, chosen.title, basePath, { rediscuss: isRediscuss, structuredQuestionsAvailable: sqAvail });
     await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-slice");
 
@@ -1020,7 +1035,7 @@ async function dispatchDiscussForMilestone(
       ].join("\n")
     : "";
   const discussMilestoneTemplates = inlineTemplate("context", "Context");
-  const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+  const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
   const basePrompt = loadPrompt("guided-discuss-milestone", {
     milestoneId: mid,
     milestoneTitle,
@@ -1461,7 +1476,7 @@ export async function showSmartEntry(
 
     if (choice === "discuss_draft") {
       const discussMilestoneTemplates = inlineTemplate("context", "Context");
-      const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+      const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
       const basePrompt = loadPrompt("guided-discuss-milestone", {
         milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
         commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
@@ -1474,7 +1489,7 @@ export async function showSmartEntry(
       await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone");
     } else if (choice === "discuss_fresh") {
       const discussMilestoneTemplates = inlineTemplate("context", "Context");
-      const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+      const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
       pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId, step: stepMode, createdAt: Date.now() });
       await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
         milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
@@ -1572,7 +1587,7 @@ export async function showSmartEntry(
         }), "gsd-run", ctx, "plan-milestone");
       } else if (choice === "discuss") {
         const discussMilestoneTemplates = inlineTemplate("context", "Context");
-        const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+        const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
         await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
           milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
           commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
@@ -1712,7 +1727,7 @@ export async function showSmartEntry(
         }),
       }), "gsd-run", ctx, "plan-slice");
     } else if (choice === "discuss") {
-      const sqAvail = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+      const sqAvail = getStructuredQuestionsAvailability(pi, ctx);
       await dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext, structuredQuestionsAvailable: sqAvail }), "gsd-run", ctx, "discuss-slice");
     } else if (choice === "research") {
       const researchTemplates = inlineTemplate("research", "Research");

package/src/resources/extensions/gsd/pre-execution-checks.ts

@@ -20,6 +20,8 @@ import { resolve } from "node:path";
 import type { TaskRow } from "./gsd-db.ts";
 import type { PreExecutionCheckJSON } from "./verification-evidence.ts";
 
+const NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
+
 // ─── Result Types ────────────────────────────────────────────────────────────
 
 export interface PreExecutionResult {
@@ -126,9 +128,10 @@ async function checkPackageOnNpm(
   timeoutMs = 5000
 ): Promise<{ exists: boolean; error?: string }> {
   return new Promise((resolve) => {
-    const child = spawn("npm", ["view", packageName, "name"], {
+    const child = spawn(NPM_COMMAND, ["view", packageName, "name"], {
       stdio: ["ignore", "pipe", "pipe"],
       timeout: timeoutMs,
+      shell: process.platform === "win32",
     });
 
     let stdout = "";
@@ -263,9 +266,9 @@ function extractPathFromAnnotation(raw: string): string {
   const trimmed = raw.trim();
   if (!trimmed) return trimmed;
 
-  const backtickMatch = trimmed.match(/^`([^`]+)`(?:\s+[—–-]\s+.*)?$/);
+  const backtickMatch = trimmed.match(/^(`+)([^`]+)\1(?:(?:\s+[—–-]\s+.+)|(?:\s+\([^()]+\)))?$/);
   if (backtickMatch) {
-    return backtickMatch[1].trim();
+    return backtickMatch[2].trim();
   }
 
   const annotatedMatch = trimmed.match(/^(.+?)\s+[—–-]\s+.+$/);

package/src/resources/extensions/gsd/tests/doctor-scope-db-unavailable.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, test } from "node:test";
+import assert from "node:assert/strict";
+import { closeDatabase } from "../gsd-db.ts";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { filterDoctorIssues } from "../doctor-format.ts";
+import { checkEngineHealth } from "../doctor-engine-checks.ts";
+
+afterEach(() => {
+  closeDatabase();
+});
+
+test("filterDoctorIssues keeps project and environment issues in scoped reports", () => {
+  const issues = [
+    { severity: "error", code: "env_dependencies", scope: "project", unitId: "environment", message: "node_modules missing", fixable: false },
+    { severity: "warning", code: "db_unavailable", scope: "project", unitId: "project", message: "DB unavailable", fixable: false },
+    { severity: "warning", code: "state_file_missing", scope: "slice", unitId: "M016/S01", message: "slice warning", fixable: false },
+  ] as const;
+
+  const filtered = filterDoctorIssues([...issues], { scope: "M016", includeWarnings: true });
+  assert.deepEqual(
+    filtered.map((issue) => issue.unitId),
+    ["environment", "project", "M016/S01"],
+  );
+});
+
+test("checkEngineHealth reports db_unavailable when gsd.db exists but the DB is closed", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-db-unavailable-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, "gsd.db"), "");
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  const dbIssue = issues.find((issue) => issue.code === "db_unavailable");
+  assert.ok(dbIssue, "doctor should surface degraded DB mode when a DB file exists");
+  assert.equal(dbIssue.unitId, "project");
+  assert.equal(dbIssue.file, ".gsd/gsd.db");
+});

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -12,7 +12,7 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { normalizeFilePath, checkFilePathConsistency } from '../pre-execution-checks.ts'
-import { readFileSync } from 'node:fs'
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
 const src = readFileSync(
@@ -25,6 +25,11 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
     assert.equal(normalizeFilePath('`src/foo.ts`'), 'src/foo.ts')
   })
 
+  it('strips doubled backticks and trailing notes from file paths', () => {
+    assert.equal(normalizeFilePath('``src/foo.ts`` - current state'), 'src/foo.ts')
+    assert.equal(normalizeFilePath('``src/foo.ts`` (current state)'), 'src/foo.ts')
+  })
+
   it('strips backticks even when mixed with other normalization', () => {
     assert.equal(normalizeFilePath('`./src//bar.ts`'), 'src/bar.ts')
   })
@@ -66,3 +71,45 @@ describe('checkFilePathConsistency checks task.inputs not task.files (#3626)', (
     )
   })
 })
+
+describe('checkFilePathConsistency handles doubled-backtick annotations (#3892)', () => {
+  it('accepts existing files when task.inputs include doubled-backtick notes', () => {
+    const task = {
+      milestone_id: 'M001',
+      slice_id: 'S01',
+      id: 'T01',
+      title: 'Test Task',
+      status: 'pending',
+      one_liner: '',
+      narrative: '',
+      verification_result: '',
+      duration: '',
+      completed_at: null,
+      blocker_discovered: false,
+      deviations: '',
+      known_issues: '',
+      key_files: [],
+      key_decisions: [],
+      full_summary_md: '',
+      description: '',
+      estimate: '',
+      files: [],
+      verify: '',
+      inputs: ['``src/foo.ts`` (current state)'],
+      expected_output: [],
+      observability_impact: '',
+      full_plan_md: '',
+      sequence: 0,
+    }
+
+    const tmp = resolve(process.cwd(), '.tmp-pre-exec-3892')
+    try {
+      mkdirSync(resolve(tmp, 'src'), { recursive: true })
+      writeFileSync(resolve(tmp, 'src', 'foo.ts'), '// ok')
+      const results = checkFilePathConsistency([task as any], tmp)
+      assert.deepEqual(results, [])
+    } finally {
+      rmSync(tmp, { recursive: true, force: true })
+    }
+  })
+})

package/src/resources/extensions/gsd/tests/resource-loader-import-path.test.ts

@@ -22,16 +22,17 @@ describe("resource-loader import path", () => {
     );
   });
 
-  test("uses createRequire to resolve resource-loader from package root", () => {
-    // The fix uses createRequire to find gsd-pi/package.json, then imports
-    // dist/resource-loader.js from there — works in both source and deployed.
+  test("uses GSD_PKG_ROOT to resolve resource-loader from package root", () => {
+    // The fix uses GSD_PKG_ROOT (set by loader.ts) to construct an absolute
+    // file URL to dist/resource-loader.js — works in both source and deployed,
+    // and on Windows where raw paths fail with ERR_UNSUPPORTED_ESM_URL_SCHEME.
     assert.ok(
-      autoSrc.includes('createRequire(import.meta.url)'),
-      "auto.ts should use createRequire to resolve resource-loader",
+      autoSrc.includes('process.env.GSD_PKG_ROOT'),
+      "auto.ts should use GSD_PKG_ROOT to resolve resource-loader",
     );
     assert.ok(
-      autoSrc.includes('resolve("gsd-pi/package.json")'),
-      "auto.ts should resolve gsd-pi package root via package.json",
+      autoSrc.includes('pathToFileURL'),
+      "auto.ts should convert path to file URL for cross-platform import()",
     );
   });
 });

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

@@ -74,6 +74,27 @@ test("validateDirectory: C:\\Windows is blocked", { skip: !isWindows ? "Windows-
   assert.equal(result.severity, "blocked");
 });
 
+test("validateDirectory: D:\\Windows is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
+  const result = validateDirectory("D:\\Windows");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("system directory"));
+});
+
+test("validateDirectory: E:\\Program Files is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
+  const result = validateDirectory("E:\\Program Files");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("system directory"));
+});
+
+test("validateDirectory: any Windows drive root is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
+  const result = validateDirectory("D:\\");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("system directory"));
+});
+
 // ─── Home directory (cross-platform) ─────────────────────────────────────────────
 
 test("validateDirectory: home directory itself is blocked", () => {
@@ -104,7 +125,13 @@ test("validateDirectory: subdirectory of home is NOT blocked", () => {
 // Regression test for #1317: GSD worktree inside $HOME must not be blocked even
 // when the resolved project root equals $HOME (e.g. home dir is a git repo).
 test("validateDirectory: GSD worktree path nested under home is NOT blocked (#1317)", () => {
+  const originalHome = process.env.HOME;
+  const originalUserProfile = process.env.USERPROFILE;
+  const fakeHome = makeTempDir("fake-home");
+  process.env.HOME = fakeHome;
+  process.env.USERPROFILE = fakeHome;
   const worktreePath = join(homedir(), ".gsd", "worktrees", "M001");
+  const worktreeRoot = join(fakeHome, ".gsd", "worktrees", "M001");
   mkdirSync(worktreePath, { recursive: true });
   try {
     // The worktree CWD itself is a valid location — it must pass.
@@ -112,7 +139,12 @@ test("validateDirectory: GSD worktree path nested under home is NOT blocked (#13
     assert.equal(result.safe, true, "GSD worktree path should be safe to run in");
     assert.equal(result.severity, "ok");
   } finally {
-    rmSync(join(homedir(), ".gsd", "worktrees", "M001"), { recursive: true, force: true });
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+    rmSync(worktreeRoot, { recursive: true, force: true });
+    rmSync(fakeHome, { recursive: true, force: true });
   }
 });
 

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

@@ -9,10 +9,11 @@ import { deriveState, isValidationTerminal } from "../state.ts";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact } from "../auto-artifact-paths.ts";
 import { verifyExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
 import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
-import { buildValidateMilestonePrompt } from "../auto-prompts.ts";
+import { buildCompleteMilestonePrompt, buildValidateMilestonePrompt } from "../auto-prompts.ts";
 import type { GSDState } from "../types.ts";
 import { clearPathCache } from "../paths.ts";
 import { clearParseCache } from "../files.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
@@ -25,9 +26,15 @@ function makeTmpBase(): string {
 function cleanup(base: string): void {
   clearPathCache();
   clearParseCache();
+  closeDatabase();
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+function openTestDb(base: string): void {
+  const dbPath = join(base, ".gsd", "gsd.db");
+  assert.equal(openDatabase(dbPath), true, "test DB should open");
+}
+
 function writeRoadmap(base: string, mid: string, content: string): void {
   const dir = join(base, ".gsd", "milestones", mid);
   mkdirSync(dir, { recursive: true });
@@ -218,6 +225,85 @@ test("buildValidateMilestonePrompt inlines ASSESSMENT evidence instead of UAT sp
   }
 });
 
+test("buildCompleteMilestonePrompt skips skipped slices from DB-backed summary inlining", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", `# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- It works
+
+## Slices
+
+- [x] **S01: First slice** \`risk:low\` \`depends:[]\`
+  > Done
+- [ ] **S02: Skipped slice** \`risk:low\` \`depends:[]\`
+  > Intentionally skipped
+
+## Boundary Map
+
+| From | To | Produces | Consumes |
+|------|-----|----------|----------|
+| S01  | terminal | output | nothing |
+`);
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [], sequence: 2 });
+    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
+
+    const prompt = await buildCompleteMilestonePrompt("M001", "Test Milestone", base);
+    assert.match(prompt, /S01 Summary/i, "prompt should inline non-skipped slice summaries");
+    assert.doesNotMatch(prompt, /### S02 Summary/i, "prompt should not inline skipped slice summaries");
+    assert.doesNotMatch(prompt, /not found — file does not exist yet/i, "prompt should not emit skipped-slice missing-file placeholders");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildValidateMilestonePrompt skips skipped slices from DB-backed summary inlining", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", `# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- It works
+
+## Slices
+
+- [x] **S01: First slice** \`risk:low\` \`depends:[]\`
+  > Done
+- [ ] **S02: Skipped slice** \`risk:low\` \`depends:[]\`
+  > Intentionally skipped
+
+## Boundary Map
+
+| From | To | Produces | Consumes |
+|------|-----|----------|----------|
+| S01  | terminal | output | nothing |
+`);
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [], sequence: 2 });
+    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
+    writeSliceAssessment(base, "M001", "S01", "---\nverdict: PASS\n---\n# Assessment\nEvidence captured.");
+
+    const prompt = await buildValidateMilestonePrompt("M001", "Test Milestone", base);
+    assert.match(prompt, /S01 Summary/i, "prompt should inline non-skipped slice summaries");
+    assert.doesNotMatch(prompt, /### S02 Summary/i, "prompt should not inline skipped slice summaries");
+    assert.doesNotMatch(prompt, /not found — file does not exist yet/i, "prompt should not emit skipped-slice missing-file placeholders");
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── Dispatch rule ────────────────────────────────────────────────────────
 
 test("dispatch rule matches validating-milestone phase", async () => {

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

@@ -13,6 +13,7 @@ import {
   getWorkflowTransportSupportError,
   getRequiredWorkflowToolsForAutoUnit,
   getRequiredWorkflowToolsForGuidedUnit,
+  supportsStructuredQuestions,
   usesWorkflowMcpTransport,
 } from "../workflow-mcp.ts";
 
@@ -291,6 +292,30 @@ test("usesWorkflowMcpTransport matches local externalCli providers", () => {
   assert.equal(usesWorkflowMcpTransport("oauth", "local://custom"), false);
 });
 
+test("supportsStructuredQuestions disables structured ask flow on workflow MCP transports", () => {
+  assert.equal(
+    supportsStructuredQuestions(["ask_user_questions"], {
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    }),
+    false,
+  );
+  assert.equal(
+    supportsStructuredQuestions(["ask_user_questions"], {
+      authMode: "oauth",
+      baseUrl: "https://api.anthropic.com",
+    }),
+    true,
+  );
+  assert.equal(
+    supportsStructuredQuestions([], {
+      authMode: "oauth",
+      baseUrl: "https://api.anthropic.com",
+    }),
+    false,
+  );
+});
+
 test("transport compatibility passes when required tools fit current MCP surface", () => {
   const error = getWorkflowTransportSupportError(
     "claude-code",

package/src/resources/extensions/gsd/validate-directory.ts

@@ -61,6 +61,33 @@ const WINDOWS_BLOCKED_PATHS = new Set([
   "C:\\Program Files (x86)",
 ]);
 
+const WINDOWS_BLOCKED_SUFFIXES = new Set([
+  "\\",
+  "\\windows",
+  "\\windows\\system32",
+  "\\program files",
+  "\\program files (x86)",
+]);
+
+function normalizePathForComparison(dirPath: string): string {
+  let normalized = dirPath.replace(/[/\\]+$/, "");
+  if (normalized === "") {
+    normalized = "/";
+  } else if (/^[A-Za-z]:$/.test(normalized)) {
+    normalized += "\\";
+  }
+  return platform() === "win32" ? normalized.toLowerCase() : normalized;
+}
+
+function isBlockedWindowsPath(normalized: string): boolean {
+  if (!/^[a-z]:\\/.test(normalized)) {
+    return false;
+  }
+
+  const suffix = normalized.slice(2);
+  return WINDOWS_BLOCKED_SUFFIXES.has(suffix);
+}
+
 // ─── Core Validation ────────────────────────────────────────────────────────────
 
 /**
@@ -84,16 +111,11 @@ export function validateDirectory(dirPath: string): DirectoryValidationResult {
 
   // Normalize trailing slashes for consistent comparison.
   // Special cases: "/" → "/" (not ""), "C:\" → "C:\" (not "C:")
-  let normalized = resolved.replace(/[/\\]+$/, "");
-  if (normalized === "") {
-    normalized = "/";
-  } else if (/^[A-Za-z]:$/.test(normalized)) {
-    normalized = normalized + "\\";
-  }
+  const normalized = normalizePathForComparison(resolved);
 
   // ── Check 1: Blocked system paths ──────────────────────────────────────
   const blockedPaths = platform() === "win32" ? WINDOWS_BLOCKED_PATHS : UNIX_BLOCKED_PATHS;
-  if (blockedPaths.has(normalized)) {
+  if (platform() === "win32" ? isBlockedWindowsPath(normalized) : blockedPaths.has(normalized)) {
     return {
       safe: false,
       severity: "blocked",
@@ -104,9 +126,9 @@ export function validateDirectory(dirPath: string): DirectoryValidationResult {
   // ── Check 2: Home directory itself (not subdirs) ───────────────────────
   let resolvedHome: string;
   try {
-    resolvedHome = realpathSync(resolve(homedir())).replace(/[/\\]+$/, "");
+    resolvedHome = normalizePathForComparison(realpathSync(resolve(homedir())));
   } catch {
-    resolvedHome = resolve(homedir()).replace(/[/\\]+$/, "");
+    resolvedHome = normalizePathForComparison(resolve(homedir()));
   }
 
   if (normalized === resolvedHome) {
@@ -120,9 +142,9 @@ export function validateDirectory(dirPath: string): DirectoryValidationResult {
   // ── Check 3: Temp directory root ───────────────────────────────────────
   let resolvedTmp: string;
   try {
-    resolvedTmp = realpathSync(resolve(tmpdir())).replace(/[/\\]+$/, "");
+    resolvedTmp = normalizePathForComparison(realpathSync(resolve(tmpdir())));
   } catch {
-    resolvedTmp = resolve(tmpdir()).replace(/[/\\]+$/, "");
+    resolvedTmp = normalizePathForComparison(resolve(tmpdir()));
   }
 
   if (normalized === resolvedTmp) {

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

@@ -348,6 +348,21 @@ export function usesWorkflowMcpTransport(
   return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");
 }
 
+export function supportsStructuredQuestions(
+  activeTools: string[],
+  options: Pick<WorkflowCapabilityOptions, "authMode" | "baseUrl"> = {},
+): boolean {
+  if (!activeTools.includes("ask_user_questions")) return false;
+
+  // Workflow MCP currently exposes ask_user_questions via MCP form elicitation.
+  // Local external CLI transports such as Claude Code can invoke the tool, but
+  // do not reliably complete that elicitation round-trip yet, so guided discuss
+  // prompts must fall back to plain-text questioning.
+  if (usesWorkflowMcpTransport(options.authMode, options.baseUrl)) return false;
+
+  return true;
+}
+
 export function getWorkflowTransportSupportError(
   provider: string | undefined,
   requiredTools: string[],

package/src/resources/extensions/slash-commands/audit.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { mkdirSync } from "node:fs";
 
 export default function auditCommand(pi: ExtensionAPI) {
 	pi.registerCommand("audit", {
@@ -39,7 +40,7 @@ export default function auditCommand(pi: ExtensionAPI) {
 
 			// ── Step 3: Ensure the output directory exists ───────────────────────
 
-			await pi.exec("mkdir", ["-p", ".gsd/audits"]);
+			mkdirSync(".gsd/audits", { recursive: true });
 
 			// ── Step 4: Send the audit prompt to the agent ───────────────────────
 

package/src/resources/extensions/subagent/isolation.ts

@@ -53,8 +53,10 @@ interface Baseline {
 // Directory helpers
 // ============================================================================
 
-function encodeCwd(cwd: string): string {
-	return cwd.replace(/\//g, "--");
+export function encodeCwd(cwd: string): string {
+	// Encode the entire cwd so Windows drive letters, separators, and UNC
+	// prefixes cannot leak into the isolation path.
+	return Buffer.from(cwd, "utf8").toString("base64url");
 }
 
 const gsdHome = process.env.GSD_HOME || path.join(os.homedir(), ".gsd");
@@ -500,4 +502,3 @@ export function readIsolationMode(): IsolationMode {
 		return "none";
 	}
 }
-