gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/dist/resources/extensions/gsd/dev-workflow-engine.js

@@ -0,0 +1,82 @@
+/**
+ * dev-workflow-engine.ts — DevWorkflowEngine implementation.
+ *
+ * Implements WorkflowEngine by delegating to existing GSD state derivation
+ * and dispatch logic. This is the "dev" engine — it wraps the current GSD
+ * auto-mode behavior behind the engine-polymorphic interface.
+ */
+import { deriveState } from "./state.js";
+import { resolveDispatch } from "./auto-dispatch.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+// ─── Bridge: DispatchAction → EngineDispatchAction ────────────────────────
+/**
+ * Map a GSD-specific DispatchAction (which carries `matchedRule`, `unitType`,
+ * etc.) to the engine-generic EngineDispatchAction discriminated union.
+ *
+ * Exported for unit testing.
+ */
+export function bridgeDispatchAction(da) {
+    switch (da.action) {
+        case "dispatch":
+            return {
+                action: "dispatch",
+                step: {
+                    unitType: da.unitType,
+                    unitId: da.unitId,
+                    prompt: da.prompt,
+                },
+            };
+        case "stop":
+            return {
+                action: "stop",
+                reason: da.reason,
+                level: da.level,
+            };
+        case "skip":
+            return { action: "skip" };
+    }
+}
+// ─── DevWorkflowEngine ───────────────────────────────────────────────────
+export class DevWorkflowEngine {
+    engineId = "dev";
+    async deriveState(basePath) {
+        const gsd = await deriveState(basePath);
+        return {
+            phase: gsd.phase,
+            currentMilestoneId: gsd.activeMilestone?.id ?? null,
+            activeSliceId: gsd.activeSlice?.id ?? null,
+            activeTaskId: gsd.activeTask?.id ?? null,
+            isComplete: gsd.phase === "complete",
+            raw: gsd,
+        };
+    }
+    async resolveDispatch(state, context) {
+        const gsd = state.raw;
+        const mid = gsd.activeMilestone?.id ?? "";
+        const midTitle = gsd.activeMilestone?.title ?? "";
+        const loaded = loadEffectiveGSDPreferences();
+        const prefs = loaded?.preferences ?? undefined;
+        const dispatchCtx = {
+            basePath: context.basePath,
+            mid,
+            midTitle,
+            state: gsd,
+            prefs,
+        };
+        const result = await resolveDispatch(dispatchCtx);
+        return bridgeDispatchAction(result);
+    }
+    async reconcile(state, _completedStep) {
+        return {
+            outcome: state.isComplete ? "milestone-complete" : "continue",
+        };
+    }
+    getDisplayMetadata(state) {
+        return {
+            engineLabel: "GSD Dev",
+            currentPhase: state.phase,
+            progressSummary: `${state.currentMilestoneId ?? "no milestone"} / ${state.activeSliceId ?? "—"} / ${state.activeTaskId ?? "—"}`,
+            stepCount: null,
+        };
+    }
+}

package/dist/resources/extensions/gsd/doctor-checks.js

@@ -1,6 +1,6 @@
 import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
 import { basename, dirname, join, sep } from "node:path";
-import { readRepoMeta, externalProjectsRoot } from "./repo-identity.js";
+import { readRepoMeta, externalProjectsRoot, cleanNumberedGsdVariants } from "./repo-identity.js";
 import { loadFile, parseRoadmap } from "./files.js";
 import { resolveMilestoneFile, milestonesDir, gsdRoot, resolveGsdRootFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
@@ -733,6 +733,36 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
     catch {
         // Non-fatal — external state check failed
     }
+    // ── Numbered .gsd collision variants (#2205) ───────────────────────────
+    // macOS APFS can create ".gsd 2", ".gsd 3" etc. when a directory blocks
+    // symlink creation. These must be removed so the canonical .gsd is used.
+    try {
+        const variantPattern = /^\.gsd \d+$/;
+        const entries = readdirSync(basePath);
+        const variants = entries.filter(e => variantPattern.test(e));
+        if (variants.length > 0) {
+            for (const v of variants) {
+                issues.push({
+                    severity: "warning",
+                    code: "numbered_gsd_variant",
+                    scope: "project",
+                    unitId: "project",
+                    message: `Found macOS collision variant "${v}" — this can cause GSD state to appear deleted.`,
+                    file: v,
+                    fixable: true,
+                });
+            }
+            if (shouldFix("numbered_gsd_variant")) {
+                const removed = cleanNumberedGsdVariants(basePath);
+                for (const name of removed) {
+                    fixesApplied.push(`removed numbered .gsd variant: ${name}`);
+                }
+            }
+        }
+    }
+    catch {
+        // Non-fatal — variant check failed
+    }
     // ── Metrics ledger integrity ───────────────────────────────────────────
     try {
         const metricsPath = join(root, "metrics.json");

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -260,11 +260,21 @@ function checkRemoteQuestionsProvider() {
 function checkOptionalProviders() {
     const optional = ["brave", "tavily", "jina", "context7"];
     const results = [];
+    // Determine which search providers are configured so we can suppress
+    // "not configured" noise for alternative search providers when at least
+    // one is already active (e.g. don't warn about missing BRAVE_API_KEY
+    // when Tavily is configured).
+    const searchProviderIds = ["brave", "tavily"];
+    const hasAnySearchProvider = searchProviderIds.some(id => resolveKey(id).found);
     for (const providerId of optional) {
         const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
         if (!info)
             continue;
         const lookup = resolveKey(providerId);
+        // Skip unconfigured search providers when another search provider is active
+        if (!lookup.found && hasAnySearchProvider && info.category === "search") {
+            continue;
+        }
         results.push({
             name: providerId,
             label: info.label,

package/dist/resources/extensions/gsd/doctor.js

@@ -745,6 +745,7 @@ export async function runGSDDoctor(basePath, options) {
             }
             catch { /* non-fatal */ }
             let allTasksDone = plan.tasks.length > 0;
+            let taskUncheckedByDoctor = false;
             for (const task of plan.tasks) {
                 const taskUnitId = `${unitId}/${task.id}`;
                 const summaryPath = resolveTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY");
@@ -762,6 +763,7 @@ export async function runGSDDoctor(basePath, options) {
                     dryRunCanFix("task_done_missing_summary", `uncheck ${task.id} in plan for ${taskUnitId}`);
                     if (shouldFix("task_done_missing_summary")) {
                         await markTaskUndoneInPlan(basePath, milestoneId, slice.id, task.id, fixesApplied);
+                        taskUncheckedByDoctor = true;
                     }
                 }
                 if (!task.done && hasSummary) {
@@ -822,6 +824,14 @@ export async function runGSDDoctor(basePath, options) {
                 }
                 allTasksDone = allTasksDone && task.done;
             }
+            // ── #1850: cascade slice uncheck when task_done_missing_summary fires ──
+            // When doctor unchecks tasks inside a done slice, the slice must also be
+            // unchecked so the state machine re-enters the executing phase. Without
+            // this, state.ts skips done slices and the unchecked tasks never run,
+            // causing doctor to fire again on every start (infinite loop).
+            if (taskUncheckedByDoctor && slice.done) {
+                await markSliceUndoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
+            }
             // Blocker-without-replan detection
             const replanPath = resolveSliceFile(basePath, milestoneId, slice.id, "REPLAN");
             if (!replanPath) {
@@ -898,7 +908,7 @@ export async function runGSDDoctor(basePath, options) {
                     fixable: true,
                 });
                 dryRunCanFix("all_tasks_done_roadmap_not_checked", `mark ${slice.id} done in roadmap`);
-                if (shouldFix("all_tasks_done_roadmap_not_checked") && (hasSliceSummary || issues.some(issue => issue.code === "all_tasks_done_missing_slice_summary" && issue.unitId === unitId))) {
+                if (shouldFix("all_tasks_done_roadmap_not_checked") && (hasSliceSummary || existsSync(join(slicePath, `${slice.id}-SUMMARY.md`)))) {
                     await markSliceDoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
                 }
             }

package/dist/resources/extensions/gsd/engine-resolver.js

@@ -0,0 +1,40 @@
+/**
+ * engine-resolver.ts — Route sessions to engine/policy pairs.
+ *
+ * Routes `null` and `"dev"` engine IDs to the DevWorkflowEngine/DevExecutionPolicy
+ * pair. Any other non-null engine ID is treated as a custom workflow engine that
+ * reads its state from an `activeRunDir`. Respects `GSD_ENGINE_BYPASS=1` kill
+ * switch to skip the engine layer entirely.
+ */
+import { DevWorkflowEngine } from "./dev-workflow-engine.js";
+import { DevExecutionPolicy } from "./dev-execution-policy.js";
+import { CustomWorkflowEngine } from "./custom-workflow-engine.js";
+import { CustomExecutionPolicy } from "./custom-execution-policy.js";
+/**
+ * Resolve an engine/policy pair for the given session.
+ *
+ * - `null` or `"dev"` → DevWorkflowEngine + DevExecutionPolicy
+ * - any other non-null ID → CustomWorkflowEngine(activeRunDir) + CustomExecutionPolicy()
+ *   (requires activeRunDir to be a non-empty string)
+ *
+ * Note: `GSD_ENGINE_BYPASS=1` is checked in autoLoop before calling this function.
+ */
+export function resolveEngine(session) {
+    const { activeEngineId, activeRunDir } = session;
+    if (activeEngineId === null || activeEngineId === "dev") {
+        return {
+            engine: new DevWorkflowEngine(),
+            policy: new DevExecutionPolicy(),
+        };
+    }
+    // Any non-null, non-"dev" engine ID is a custom workflow engine.
+    // activeRunDir is required — the engine reads GRAPH.yaml from it.
+    if (!activeRunDir || typeof activeRunDir !== "string") {
+        throw new Error(`Custom engine "${activeEngineId}" requires activeRunDir to be a non-empty string, ` +
+            `got: ${JSON.stringify(activeRunDir)}`);
+    }
+    return {
+        engine: new CustomWorkflowEngine(activeRunDir),
+        policy: new CustomExecutionPolicy(activeRunDir),
+    };
+}

package/dist/resources/extensions/gsd/engine-types.js

@@ -0,0 +1,8 @@
+/**
+ * engine-types.ts — Engine-polymorphic type contracts.
+ *
+ * LEAF NODE: This file must have ZERO imports from any GSD module.
+ * Only `node:` imports are permitted. All engine/policy interfaces
+ * depend on these types; nothing here depends on GSD internals.
+ */
+export {};

package/dist/resources/extensions/gsd/execution-policy.js

@@ -0,0 +1,8 @@
+/**
+ * execution-policy.ts — ExecutionPolicy interface.
+ *
+ * Defines the policy layer that governs model selection, verification,
+ * recovery, and closeout for each execution step. Imports only from
+ * the leaf-node engine-types.
+ */
+export {};

package/dist/resources/extensions/gsd/exit-command.js

@@ -4,8 +4,18 @@ export function registerExitCommand(pi, deps = {}) {
         description: "Exit GSD gracefully",
         handler: async (_args, ctx) => {
             // Stop auto-mode first so locks and activity state are cleaned up before shutdown.
-            const stopAuto = deps.stopAuto ?? (await importExtensionModule(import.meta.url, "./auto.js")).stopAuto;
-            await stopAuto(ctx, pi, "Graceful exit");
+            // Wrapped in try/catch: if gsd-pi was updated on disk mid-session, the dynamic
+            // import may resolve a new auto-worktree.js whose static imports reference
+            // exports absent from the process-cached native-git-bridge.js (ESM cache is
+            // immutable). The user's work is already saved — this is cleanup only.
+            try {
+                const stopAuto = deps.stopAuto ?? (await importExtensionModule(import.meta.url, "./auto.js")).stopAuto;
+                await stopAuto(ctx, pi, "Graceful exit");
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                ctx.ui?.notify?.(`Auto-mode cleanup skipped (module version mismatch): ${msg}`, "warning");
+            }
             ctx.shutdown();
         },
     });

package/dist/resources/extensions/gsd/export.js

@@ -2,7 +2,7 @@
 // Generate shareable reports of milestone work in JSON or markdown format.
 import { writeFileSync, mkdirSync } from "node:fs";
 import { join, basename } from "node:path";
-import { exec } from "node:child_process";
+import { execFile } from "node:child_process";
 import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk, } from "./metrics.js";
 import { gsdRoot } from "./paths.js";
 import { formatDuration, fileLink } from "../shared/format-utils.js";
@@ -13,18 +13,14 @@ import { getErrorMessage } from "./error-utils.js";
  * Non-blocking, non-fatal — failures are silently ignored.
  */
 export function openInBrowser(filePath) {
-    const cmd = process.platform === "darwin" ? "open" :
-        process.platform === "win32" ? "start" :
-            "xdg-open";
-    // On Windows, `start` needs an empty title argument when the path has spaces
-    const args = process.platform === "win32"
-        ? `"" "${filePath}"`
-        : `"${filePath}"`;
-    exec(`${cmd} ${args}`, (err) => {
-        // Non-fatal — if the browser can't be opened, the file path is still shown
-        if (err)
-            void err;
-    });
+    if (process.platform === "win32") {
+        // PowerShell's Start-Process handles paths with '&' and spaces safely.
+        execFile("powershell", ["-c", `Start-Process '${filePath.replace(/'/g, "''")}'`], () => { });
+    }
+    else {
+        const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+        execFile(cmd, [filePath], () => { });
+    }
 }
 /**
  * Write an export file directly, without requiring an ExtensionCommandContext.

package/dist/resources/extensions/gsd/extension-manifest.json

@@ -8,8 +8,8 @@
   "provides": {
     "tools": [
       "bash", "write", "read", "edit",
-      "gsd_save_decision", "gsd_save_summary",
-      "gsd_update_requirement", "gsd_generate_milestone_id"
+      "gsd_decision_save", "gsd_summary_save",
+      "gsd_requirement_update", "gsd_milestone_generate_id"
     ],
     "commands": ["gsd", "kill", "worktree", "exit"],
     "hooks": ["session_start"],

package/dist/resources/extensions/gsd/files.js

@@ -309,19 +309,36 @@ function _parsePlanImpl(content) {
         let currentTask = null;
         for (const line of taskLines) {
             const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
-            if (cbMatch) {
+            // Heading-style: ### T01 -- Title, ### T01: Title, ### T01 — Title
+            const hdMatch = !cbMatch ? line.match(/^#{2,4}\s+([\w.]+)\s*(?:--|—|:)\s*(.+)/) : null;
+            if (cbMatch || hdMatch) {
                 if (currentTask)
                     tasks.push(currentTask);
-                const rest = cbMatch[4] || '';
-                const estMatch = rest.match(/`est:([^`]+)`/);
-                const estimate = estMatch ? estMatch[1] : '';
-                currentTask = {
-                    id: cbMatch[2],
-                    title: cbMatch[3],
-                    description: '',
-                    done: cbMatch[1].toLowerCase() === 'x',
-                    estimate,
-                };
+                if (cbMatch) {
+                    const rest = cbMatch[4] || '';
+                    const estMatch = rest.match(/`est:([^`]+)`/);
+                    const estimate = estMatch ? estMatch[1] : '';
+                    currentTask = {
+                        id: cbMatch[2],
+                        title: cbMatch[3],
+                        description: '',
+                        done: cbMatch[1].toLowerCase() === 'x',
+                        estimate,
+                    };
+                }
+                else {
+                    const rest = hdMatch[2] || '';
+                    const titleEstMatch = rest.match(/^(.+?)\s*`est:([^`]+)`\s*$/);
+                    const title = titleEstMatch ? titleEstMatch[1].trim() : rest.trim();
+                    const estimate = titleEstMatch ? titleEstMatch[2] : '';
+                    currentTask = {
+                        id: hdMatch[1],
+                        title,
+                        description: '',
+                        done: false,
+                        estimate,
+                    };
+                }
             }
             else if (currentTask && line.match(/^\s*-\s+Files:\s*(.*)/)) {
                 const filesMatch = line.match(/^\s*-\s+Files:\s*(.*)/);

package/dist/resources/extensions/gsd/forensics.js

@@ -10,6 +10,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join, dirname, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 import { extractTrace } from "./session-forensics.js";
 import { nativeParseJsonlTail } from "./native-parser-bridge.js";
 import { MAX_JSONL_BYTES, parseJSONL } from "./jsonl-utils.js";
@@ -23,6 +24,70 @@ import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
 import { formatDuration } from "../shared/format-utils.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
+import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import { showNextAction } from "../shared/tui.js";
+import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
+// ─── Duplicate Detection ──────────────────────────────────────────────────────
+const DEDUP_PROMPT_SECTION = `
+## Duplicate Detection (REQUIRED before issue creation)
+
+Before offering to create a GitHub issue, you MUST search for existing issues and PRs that may already address this bug. This step uses the user's AI tokens for analysis.
+
+### Search Steps
+
+1. **Search closed issues** for similar keywords from your diagnosis:
+   \`\`\`
+   gh issue list --repo gsd-build/gsd-2 --state closed --search "<keywords from root cause>" --limit 20
+   \`\`\`
+
+2. **Search open PRs** that might contain the fix:
+   \`\`\`
+   gh pr list --repo gsd-build/gsd-2 --state open --search "<keywords>" --limit 10
+   \`\`\`
+
+3. **Search merged PRs** that may have already fixed this:
+   \`\`\`
+   gh pr list --repo gsd-build/gsd-2 --state merged --search "<keywords>" --limit 10
+   \`\`\`
+
+### Analysis
+
+For each result, compare it against your root-cause diagnosis:
+- Does the issue describe the same code path or file?
+- Does the PR modify the same file:line you identified?
+- Is the symptom description semantically similar even if keywords differ?
+
+### Present Findings
+
+If you find potential matches, present them to the user:
+
+1. **"Already fixed by PR #X — skip issue creation"** — when a merged PR or closed issue clearly addresses the same root cause. Explain why you believe it matches.
+2. **"Add my findings to existing issue #Y"** — when an open issue exists for the same bug. Use \`gh issue comment #Y --repo gsd-build/gsd-2\` to add forensic evidence.
+3. **"Create new issue anyway"** — when existing results do not cover this specific failure.
+
+Only proceed to issue creation if no matches were found OR the user explicitly chooses "Create new issue anyway".
+`;
+async function writeForensicsDedupPref(ctx, enabled) {
+    const prefsPath = getGlobalGSDPreferencesPath();
+    await ensurePreferencesFile(prefsPath, ctx, "global");
+    const existing = loadGlobalGSDPreferences();
+    const prefs = existing?.preferences ? { ...existing.preferences } : {};
+    prefs.version = prefs.version || 1;
+    prefs.forensics_dedup = enabled;
+    const frontmatter = serializePreferencesToFrontmatter(prefs);
+    const raw = existsSync(prefsPath) ? readFileSync(prefsPath, "utf-8") : "";
+    let body = "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
+    const start = raw.startsWith("---\n") ? 4 : raw.startsWith("---\r\n") ? 5 : -1;
+    if (start !== -1) {
+        const closingIdx = raw.indexOf("\n---", start);
+        if (closingIdx !== -1) {
+            const after = raw.slice(closingIdx + 4);
+            if (after.trim())
+                body = after;
+        }
+    }
+    writeFileSync(prefsPath, `---\n${frontmatter}---${body}`, "utf-8");
+}
 // ─── Entry Point ──────────────────────────────────────────────────────────────
 export async function handleForensics(args, ctx, pi) {
     if (isAutoActive()) {
@@ -43,17 +108,43 @@ export async function handleForensics(args, ctx, pi) {
         ctx.ui.notify("Problem description required for forensic analysis.", "warning");
         return;
     }
+    // ─── Duplicate detection opt-in ─────────────────────────────────────────────
+    const effectivePrefs = loadEffectiveGSDPreferences()?.preferences;
+    let dedupEnabled = effectivePrefs?.forensics_dedup === true;
+    if (effectivePrefs?.forensics_dedup === undefined) {
+        const choice = await showNextAction(ctx, {
+            title: "Duplicate detection available",
+            summary: ["Before filing a GitHub issue, forensics can search existing issues and PRs to avoid duplicates.", "This uses additional AI tokens for analysis."],
+            actions: [
+                { id: "enable", label: "Enable duplicate detection", description: "Search issues/PRs before filing (recommended)", recommended: true },
+                { id: "skip", label: "Skip for now", description: "File without checking for duplicates" },
+            ],
+            notYetMessage: "You can enable this later via preferences (forensics_dedup: true).",
+        });
+        if (choice === "enable") {
+            await writeForensicsDedupPref(ctx, true);
+            dedupEnabled = true;
+        }
+    }
+    const dedupSection = dedupEnabled ? DEDUP_PROMPT_SECTION : "";
     ctx.ui.notify("Building forensic report...", "info");
     const report = await buildForensicReport(basePath);
     const savedPath = saveForensicReport(basePath, report, problemDescription);
-    // Derive GSD source dir for prompt
-    const __extensionDir = dirname(fileURLToPath(import.meta.url));
-    const gsdSourceDir = __extensionDir;
+    // Derive GSD source dir for prompt — fall back to ~/.gsd/agent/extensions/gsd/
+    // when import.meta.url resolves to the npm-global install path (Windows).
+    let gsdSourceDir = dirname(fileURLToPath(import.meta.url));
+    if (!existsSync(join(gsdSourceDir, "prompts"))) {
+        const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+        const fallback = join(gsdHome, "agent", "extensions", "gsd");
+        if (existsSync(join(fallback, "prompts")))
+            gsdSourceDir = fallback;
+    }
     const forensicData = formatReportForPrompt(report);
     const content = loadPrompt("forensics", {
         problemDescription,
         forensicData,
         gsdSourceDir,
+        dedupSection,
     });
     ctx.ui.notify(`Forensic report saved: ${relative(basePath, savedPath)}`, "info");
     pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });

package/dist/resources/extensions/gsd/git-constants.js

@@ -7,4 +7,5 @@ export const GIT_NO_PROMPT_ENV = {
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: "",
     GIT_SVN_ID: "",
+    LC_ALL: "C", // force English git output so stderr string checks work on all locales (#1997)
 };

package/dist/resources/extensions/gsd/git-service.js

@@ -130,7 +130,7 @@ export function readIntegrationBranch(basePath, milestoneId) {
  */
 /** Regex matching GSD quick-task branches: gsd/quick/<num>-<slug> */
 export const QUICK_BRANCH_RE = /^gsd\/quick\//;
-export function writeIntegrationBranch(basePath, milestoneId, branch, _options) {
+export function writeIntegrationBranch(basePath, milestoneId, branch) {
     // Don't record slice branches as the integration target
     if (SLICE_BRANCH_RE.test(branch))
         return;
@@ -508,7 +508,11 @@ export class GitServiceImpl {
  */
 export function createDraftPR(basePath, milestoneId, title, body) {
     try {
-        const result = execSync(`gh pr create --draft --title ${JSON.stringify(title)} --body ${JSON.stringify(body)}`, { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
+        const result = execFileSync("gh", [
+            "pr", "create", "--draft",
+            "--title", title,
+            "--body", body,
+        ], { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
         return result.trim();
     }
     catch {