gsd-pi 2.78.0 → 2.78.1-dev.2ff77b0ce

package/dist/resource-loader.js

@@ -1,4 +1,3 @@
-import { DefaultResourceLoader, sortExtensionPaths } from '@gsd/pi-coding-agent';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, openSync, closeSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
@@ -7,6 +6,11 @@ import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';
 import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled, ensureRegistryEntries } from './extension-registry.js';
+import { resolveBundledResourcesDirFromPackageRoot } from './bundled-resource-path.js';
+let piCodingAgentModulePromise;
+function loadPiCodingAgentModule() {
+    return (piCodingAgentModulePromise ??= import('@gsd/pi-coding-agent'));
+}
 // Resolve resources directory — prefer dist/resources/ (stable, set at build time)
 // over src/resources/ (live working tree, changes with git branch).
 //
@@ -16,16 +20,10 @@ import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled, ensureRegi
 // dist/resources/ is populated by the build step (`npm run copy-resources`) and
 // reflects the built state, not the currently checked-out branch.
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const distResources = join(packageRoot, 'dist', 'resources');
-const srcResources = join(packageRoot, 'src', 'resources');
-// Use dist/resources only if it has the full expected structure.
-// A partial build (tsc without copy-resources) creates dist/resources/extensions/
-// but not agents/ or skills/, causing initResources to sync from an incomplete source.
-const resourcesDir = (existsSync(distResources) && existsSync(join(distResources, 'agents')))
-    ? distResources
-    : srcResources;
+const resourcesDir = resolveBundledResourcesDirFromPackageRoot(packageRoot);
 const bundledExtensionsDir = join(resourcesDir, 'extensions');
 const resourceVersionManifestName = 'managed-resources.json';
+const resourceFingerprintFileName = '.managed-resources-content-hash';
 export { discoverExtensionEntryPaths } from './extension-discovery.js';
 export function getExtensionKey(entryPath, extensionsDir) {
     const relPath = relative(extensionsDir, entryPath);
@@ -77,7 +75,7 @@ function writeManagedResourceManifest(agentDir) {
     const manifest = {
         gsdVersion: getBundledGsdVersion(),
         syncedAt: Date.now(),
-        contentHash: computeResourceFingerprint(),
+        contentHash: getCurrentResourceFingerprint(),
         installedExtensionRootFiles,
         installedExtensionDirs,
     };
@@ -125,10 +123,24 @@ export function computeResourceFingerprint(rootDir = resourcesDir) {
     entries.sort();
     return createHash('sha256').update(entries.join('\n')).digest('hex').slice(0, 16);
 }
+function getCurrentResourceFingerprint() {
+    try {
+        const precomputed = readFileSync(join(resourcesDir, resourceFingerprintFileName), 'utf-8').trim();
+        if (/^[a-f0-9]{16}$/i.test(precomputed)) {
+            return precomputed;
+        }
+    }
+    catch {
+        // Source-tree and partial-build workflows may not have a precomputed hash.
+    }
+    return computeResourceFingerprint();
+}
 function collectFileEntries(dir, root, out) {
     if (!existsSync(dir))
         return;
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === resourceFingerprintFileName)
+            continue;
         const fullPath = join(dir, entry.name);
         if (entry.isDirectory()) {
             collectFileEntries(fullPath, root, out);
@@ -548,7 +560,7 @@ export function initResources(agentDir, skillsDir = join(homedir(), '.agents', '
     // hotfixes within a release). The content hash catches those at ~1ms cost.
     if (manifest && manifest.gsdVersion === currentVersion) {
         // Version matches — check content fingerprint for same-version staleness.
-        const currentHash = computeResourceFingerprint();
+        const currentHash = getCurrentResourceFingerprint();
         const hasStaleExtensionFiles = hasStaleCompiledExtensionSiblings(extensionsDir, bundledExtensionsDir);
         if (manifest.contentHash && manifest.contentHash === currentHash && !hasStaleExtensionFiles) {
             return;
@@ -699,29 +711,38 @@ function migrateSkillsToEcosystemDir(agentDir) {
 export function hasStaleCompiledExtensionSiblings(extensionsDir, sourceDir = bundledExtensionsDir) {
     if (!existsSync(extensionsDir))
         return false;
-    const sourceFiles = existsSync(sourceDir)
-        ? new Set(readdirSync(sourceDir, { withFileTypes: true })
-            .filter((entry) => entry.isFile())
-            .map((entry) => entry.name))
-        : new Set();
-    for (const entry of readdirSync(extensionsDir, { withFileTypes: true })) {
-        if (!entry.isFile())
+    const sourceFiles = collectRelativeFiles(sourceDir);
+    const installedFiles = collectRelativeFiles(extensionsDir);
+    for (const relPath of installedFiles) {
+        if (!relPath.endsWith('.ts') && !relPath.endsWith('.js'))
             continue;
-        if (!entry.name.endsWith('.ts') && !entry.name.endsWith('.js'))
+        if (sourceFiles.has(relPath))
             continue;
-        const siblingName = entry.name.endsWith('.ts')
-            ? entry.name.replace(/\.ts$/, '.js')
-            : entry.name.replace(/\.js$/, '.ts');
-        if (!existsSync(join(extensionsDir, siblingName)))
-            continue;
-        if (sourceFiles.has(entry.name) && sourceFiles.has(siblingName))
-            continue;
-        if (sourceFiles.has(entry.name) || sourceFiles.has(siblingName)) {
+        const bundledSibling = relPath.endsWith('.ts')
+            ? relPath.replace(/\.ts$/, '.js')
+            : relPath.replace(/\.js$/, '.ts');
+        if (sourceFiles.has(bundledSibling))
             return true;
-        }
     }
     return false;
 }
+function collectRelativeFiles(rootDir) {
+    const files = new Set();
+    if (!existsSync(rootDir))
+        return files;
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const entryPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                visit(entryPath);
+                continue;
+            }
+            files.add(relative(rootDir, entryPath).replaceAll('\\', '/'));
+        }
+    };
+    visit(rootDir);
+    return files;
+}
 /**
  * Constructs a DefaultResourceLoader that loads extensions from both
  * ~/.gsd/agent/extensions/ (GSD's default) and ~/.pi/agent/extensions/ (pi's default).
@@ -736,7 +757,8 @@ function getBundledExtensionKeys() {
     }
     return _bundledExtensionKeys;
 }
-export function buildResourceLoader(agentDir) {
+export async function buildResourceLoader(agentDir, options = {}) {
+    const { DefaultResourceLoader, sortExtensionPaths } = await loadPiCodingAgentModule();
     const registry = loadRegistry();
     const piAgentDir = join(homedir(), '.pi', 'agent');
     const piExtensionsDir = join(piAgentDir, 'extensions');
@@ -749,9 +771,13 @@ export function buildResourceLoader(agentDir) {
             return true;
         return isExtensionEnabled(registry, manifest.id);
     });
+    const additionalExtensionPaths = [
+        ...piExtensionPaths,
+        ...(options.additionalExtensionPaths ?? []),
+    ];
     return new DefaultResourceLoader({
         agentDir,
-        additionalExtensionPaths: piExtensionPaths,
+        additionalExtensionPaths,
         bundledExtensionKeys: bundledKeys,
         extensionPathsTransform: (paths) => {
             // 1. Filter community extensions through the GSD registry

package/dist/resources/.managed-resources-content-hash

@@ -0,0 +1 @@
+cc8431019a2c8873

package/dist/resources/GSD-WORKFLOW.md

@@ -542,74 +542,61 @@ If files disagree, **pause and surface to the user**:
 
 ---
 
-## Git Strategy: Branch-Per-Slice with Squash Merge
+## Git Strategy: Sequential Commits with Optional Milestone Isolation
 
-**Principle:** Main is always clean and working. Each slice gets an isolated branch. The user never runs a git command — the agent handles everything.
+**Principle:** GSD keeps work atomic and recoverable. By default, work happens on the current branch. If `git.isolation` is set to `worktree` or `branch`, a milestone branch is used and merged back to the recorded integration branch when the milestone completes. The user never runs a git command — the agent handles everything.
 
-### Branch Lifecycle
+### Isolation Modes
 
-1. **Slice starts** → create branch `gsd/M001/S01` from main
-2. **Per-task commits** on the branch — atomic, descriptive, bisectable
-3. **Slice completes** → squash merge to main as one clean commit
-4. **Branch deleted** — squash commit on main is the permanent record
+| Mode | Where work happens | Branch behavior |
+|------|--------------------|-----------------|
+| `none` (default) | Project root | Current branch, no isolation branch |
+| `worktree` | `.gsd/worktrees/<MID>/` | `milestone/<MID>` branch in a git worktree |
+| `branch` | Project root | `milestone/<MID>` branch checked out in place |
 
-### What Main Looks Like
+In all modes, slices and tasks commit sequentially on the active branch; there are no per-slice branches. The integration branch is captured when the milestone starts, so stale `git.main_branch` preferences do not redirect merge-back.
 
-```
-feat(M001/S03): milestone and slice discuss commands
-feat(M001/S02): extension scaffold and command routing
-feat(M001/S01): file I/O foundation
-```
+### Milestone Lifecycle
 
-One commit per slice. Individually revertable. Reads like a changelog.
+1. **Milestone starts** → capture the current integration branch.
+2. **Optional isolation** → create `milestone/M001` only when `git.isolation` is `worktree` or `branch`.
+3. **Per-task commits** — atomic, descriptive, bisectable.
+4. **Slice completes** → write slice summary, UAT script, roadmap checkbox, and milestone summary.
+5. **Milestone completes** → if isolated, squash-merge the milestone branch back to the captured integration branch and clean up the worktree/branch.
 
-### What the Branch Looks Like
+### What History Looks Like
 
 ```
-gsd/M001/S01:
-  test(S01/T03): round-trip tests passing
-  feat(S01/T03): file writer with round-trip fidelity
-  feat(S01/T02): markdown parser for plan files
-  feat(S01/T01): core types and interfaces
-  docs(S01): add slice plan
+feat: core type definitions
+feat: markdown parser for plan files
+fix: handle empty state rebuild
 ```
 
+In `none` mode these commits land directly on the current branch. In isolated modes they land on `milestone/<MID>` and are squashed back at milestone completion.
+
 ### Commit Conventions
 
 | When | Format | Example |
 |------|--------|---------|
-| Task completed | `{type}(S01/T02): <one-liner from summary>` | Type inferred from title (`feat`, `fix`, `test`, etc.) |
-| Plan/docs committed | `docs(S01): add slice plan` | Planning artifacts |
-| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title |
-| State rebuild | `chore(S01/T02): auto-commit after state-rebuild` | Bookkeeping only |
+| Task completed | `{type}: <one-liner from summary>` | Type inferred from title (`feat`, `fix`, `test`, etc.) |
+| State rebuild | `chore: auto-commit after state-rebuild` | Bookkeeping only |
+| Milestone squash | `{type}: <milestone title>` | Type inferred from title |
 
 The system reads the task summary after execution and builds a meaningful commit message:
-- **Subject**: `{type}({sliceId}/{taskId}): {one-liner}` — the one-liner from the summary frontmatter
+- **Subject**: `{type}: {one-liner}` — the one-liner from the summary frontmatter, sanitized to one line
 - **Type**: Inferred from the task title and one-liner (`feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`)
 - **Body**: Key files from the summary frontmatter (up to 8 files listed)
+- **Trailers**: `GSD-Task: S##/T##`; if GitHub sync linked an issue, `Resolves #N`
 
 Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`
 
-### Squash Merge Message
-
-```
-feat(M001/S01): file I/O foundation
-
-Agent can parse, format, load, and save all GSD file types with round-trip fidelity.
-
-Tasks completed:
-- T01: core types and interfaces
-- T02: markdown parser for plan files
-- T03: file writer with round-trip fidelity
-```
-
 ### Rollback
 
 | Problem | Fix |
 |---------|-----|
-| Bad task | `git reset --hard HEAD~1` to previous commit on the branch |
-| Bad slice | `git revert <squash commit>` on main |
-| UAT failure after merge | Fix tasks on `gsd/M001/S01-fix` branch, squash as `fix(M001/S01): <fix>` |
+| Bad task | Revert the task commit on the active branch |
+| Bad milestone squash | Revert the squash commit on the integration branch |
+| UAT failure after merge | Create follow-up fix tasks in the current or next milestone |
 
 ---
 

package/dist/resources/extensions/async-jobs/job-manager.js

@@ -159,6 +159,10 @@ export class AsyncJobManager {
             this.evictionTimers.delete(id);
             this.jobs.delete(id);
         }, this.evictionMs);
+        // Eviction is housekeeping; it should not keep short-lived test/CLI
+        // processes alive after the real work has finished.
+        if (typeof timer === "object" && "unref" in timer)
+            timer.unref();
         this.evictionTimers.set(id, timer);
     }
     evictOldest() {

package/dist/resources/extensions/bg-shell/bg-shell-lifecycle.js

@@ -6,6 +6,7 @@ import { truncateToWidth, visibleWidth, } from "@gsd/pi-tui";
 import { processes, pendingAlerts, pushAlert, cleanupAll, cleanupSessionProcesses, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
 import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { formatTokenCount } from "../shared/format-utils.js";
+import { homedir } from "node:os";
 export function registerBgShellLifecycle(pi, state) {
     function syncLatestCtxCwd() {
         if (!state.latestCtx)
@@ -177,8 +178,8 @@ export function registerBgShellLifecycle(pi, state) {
                 render(width) {
                     // ── Line 1: pwd (branch) [session]  ...  bg status ──
                     let pwd = getBgShellLiveCwd(state.latestCtx?.cwd);
-                    const home = process.env.HOME || process.env.USERPROFILE;
-                    if (home && pwd.startsWith(home)) {
+                    const home = homedir();
+                    if (pwd.startsWith(home)) {
                         pwd = `~${pwd.slice(home.length)}`;
                     }
                     const branch = footerData.getGitBranch();

package/dist/resources/extensions/bg-shell/utilities.js

@@ -32,6 +32,7 @@ export function restoreWindowsVTInput() {
 }
 // ── Time Formatting ────────────────────────────────────────────────────────
 import { formatDuration } from "../shared/mod.js";
+import { homedir } from "node:os";
 export const formatUptime = formatDuration;
 export function formatTimeAgo(timestamp) {
     return formatDuration(Date.now() - timestamp) + " ago";
@@ -48,7 +49,7 @@ export function getBgShellLiveCwd(cachedCwd, pathExists = existsSync, getCwd = (
     }
     catch {
         const projectRoot = deriveProjectRootFromAutoWorktree(cachedCwd);
-        const home = process.env.HOME || process.env.USERPROFILE;
+        const home = homedir();
         const fallbacks = [projectRoot, cachedCwd, home, "/"].filter((candidate) => Boolean(candidate));
         for (const candidate of fallbacks) {
             if (candidate !== "/" && !pathExists(candidate))

package/dist/resources/extensions/browser-tools/tools/intent.js

@@ -1,5 +1,4 @@
 import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@gsd/pi-ai";
 import { diffCompactStates } from "../core.js";
 import { setLastActionBeforeState, setLastActionAfterState, } from "../state.js";
 // ---------------------------------------------------------------------------
@@ -15,6 +14,14 @@ const INTENTS = [
     "auth_action",
     "back_navigation",
 ];
+function StringEnum(values, options) {
+    return Type.Unsafe({
+        type: "string",
+        enum: values,
+        ...(options?.description && { description: options.description }),
+        ...(options?.default && { default: options.default }),
+    });
+}
 // ---------------------------------------------------------------------------
 // Scoring evaluate script — runs entirely in-browser via page.evaluate()
 // ---------------------------------------------------------------------------

package/dist/resources/extensions/claude-code-cli/readiness.js

@@ -5,10 +5,30 @@
  * Results are cached for 30 seconds to avoid shelling out on every
  * model-availability check.
  *
- * Auth verification follows the T3 Code pattern: run `claude auth status`
- * and check the exit code + output for an authenticated session.
+ * Auth verification runs `claude auth status --json` and inspects the
+ * `loggedIn` field, falling back to plain `claude auth status` and a text
+ * heuristic when the JSON shape is unavailable (older Claude CLI builds).
+ *
+ * Set GSD_CLAUDE_DEBUG=1 to print the probe's binary selection and auth
+ * outputs to stderr — useful when diagnosing platform-specific detection
+ * failures (Issue #4997).
  */
 import { execFileSync } from "node:child_process";
+/**
+ * Spawn the Claude CLI without triggering Node's DEP0190.
+ *
+ * Passing `args` together with `shell: true` is deprecated in Node 22+
+ * because the args are concatenated into the command string without
+ * escaping. On Windows we still need a shell to resolve `.cmd` shims, so
+ * we invoke `cmd /c <command> <args...>` explicitly. On POSIX we don't
+ * need a shell at all.
+ */
+function spawnClaude(command, args, opts) {
+    if (process.platform === "win32") {
+        return execFileSync("cmd", ["/c", command, ...args], opts);
+    }
+    return execFileSync(command, args, opts);
+}
 /**
  * Candidate executable names for the Claude Code CLI.
  *
@@ -23,33 +43,114 @@ const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
  * installed" results in readiness checks.
  */
 const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
-function execClaude(args) {
-    let lastError;
+// Keep the version probe snappy — `claude --version` is a quick path.
+const VERSION_TIMEOUT_MS = 5_000;
+// Auth status can be much slower on Windows because the spawn goes through
+// cmd.exe → claude.cmd → node → Claude CLI. 15s leaves headroom on cold spawns
+// without making startup feel hung when the CLI is genuinely missing.
+const AUTH_TIMEOUT_MS = 15_000;
+function debugLog(...parts) {
+    if (process.env.GSD_CLAUDE_DEBUG) {
+        process.stderr.write(`[claude-readiness] ${parts.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ")}\n`);
+    }
+}
+/**
+ * Find the first candidate that responds to `--version`. Returns the
+ * candidate name on success, null if none worked.
+ *
+ * On Windows with `cmd /c`, a missing candidate surfaces as a
+ * non-zero exit from cmd.exe rather than ENOENT — so we cannot rely on
+ * the error code to decide "try next". Treat any failure as "try next"
+ * for the version probe; the only thing that matters for binary
+ * detection is whether *some* candidate produces a `claude --version`
+ * line.
+ */
+function findWorkingCommand() {
     for (const command of CLAUDE_COMMAND_CANDIDATES) {
         try {
-            return execFileSync(command, args, {
-                timeout: 5_000,
+            spawnClaude(command, ["--version"], {
+                timeout: VERSION_TIMEOUT_MS,
                 stdio: "pipe",
-                shell: process.platform === "win32",
             });
+            debugLog("version probe ok via", command);
+            return command;
         }
         catch (error) {
-            lastError = error;
-            const code = error?.code;
-            // Windows Git Bash can surface `.cmd` spawn failures as EINVAL instead
-            // of ENOENT. Treat both as "try next candidate".
-            if (code === "ENOENT" || code === "EINVAL") {
-                continue;
+            debugLog("version probe failed for", command, "code=", error?.code);
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Decide auth state from `claude auth status` output.
+ *
+ * Newer Claude CLI builds emit JSON by default with a `loggedIn` boolean.
+ * Older builds emit free-form text. We prefer the structured signal and fall
+ * back to a text heuristic. Note: the text heuristic only covers English
+ * phrasing — the JSON path is the durable signal.
+ */
+function parseAuthStatus(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed.loggedIn === "boolean") {
+                return parsed.loggedIn;
             }
-            throw error;
         }
+        catch {
+            // Fall through to text heuristic.
+        }
+    }
+    const lower = trimmed.toLowerCase();
+    if (/not logged in|no credentials|unauthenticated|not authenticated/.test(lower)) {
+        return false;
+    }
+    if (/logged in|authenticated|signed in|email|subscription/.test(lower)) {
+        return true;
+    }
+    return null;
+}
+function probeAuth(command) {
+    // Try --json first (newer CLIs).
+    try {
+        const out = spawnClaude(command, ["auth", "status", "--json"], {
+            timeout: AUTH_TIMEOUT_MS,
+            stdio: "pipe",
+        }).toString();
+        debugLog("auth status --json output:", out.slice(0, 200));
+        const parsed = parseAuthStatus(out);
+        if (parsed !== null)
+            return parsed;
+    }
+    catch (error) {
+        debugLog("auth status --json threw:", error.message?.slice(0, 200));
+    }
+    // Fallback: plain `auth status` (older CLIs that don't accept --json).
+    try {
+        const out = spawnClaude(command, ["auth", "status"], {
+            timeout: AUTH_TIMEOUT_MS,
+            stdio: "pipe",
+        }).toString();
+        debugLog("auth status output:", out.slice(0, 200));
+        return parseAuthStatus(out);
+    }
+    catch (error) {
+        debugLog("auth status threw:", error.message?.slice(0, 200));
+        return null;
     }
-    throw lastError ?? new Error(`Claude CLI executable not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(", ")})`);
 }
 let cachedBinaryPresent = null;
 let cachedAuthed = null;
 let lastCheckMs = 0;
 const CHECK_INTERVAL_MS = 30_000;
+/**
+ * Refresh the cached binary/auth state when the cache window has expired.
+ * Preserves a known auth state across soft-fail auth probes.
+ */
 function refreshCache() {
     const now = Date.now();
     if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS) {
@@ -57,28 +158,23 @@ function refreshCache() {
     }
     // Set timestamp first to prevent re-entrant checks during the same window
     lastCheckMs = now;
-    // Check binary presence
-    try {
-        execClaude(["--version"]);
-        cachedBinaryPresent = true;
-    }
-    catch {
+    const command = findWorkingCommand();
+    if (!command) {
         cachedBinaryPresent = false;
         cachedAuthed = false;
         return;
     }
-    // Check auth status — exit code 0 with non-error output means authenticated
-    try {
-        const output = execClaude(["auth", "status"])
-            .toString()
-            .toLowerCase();
-        // The CLI outputs "not logged in", "no credentials", or similar when unauthenticated
-        cachedAuthed = !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));
-    }
-    catch {
-        // Non-zero exit code means not authenticated
-        cachedAuthed = false;
+    cachedBinaryPresent = true;
+    const authed = probeAuth(command);
+    if (authed === null) {
+        // Couldn't determine auth state from CLI output. Don't clobber a
+        // previously known-good cache; otherwise default to false so we don't
+        // silently route requests to an unauthenticated CLI.
+        if (cachedAuthed === null)
+            cachedAuthed = false;
+        return;
     }
+    cachedAuthed = authed;
 }
 /**
  * Whether the `claude` binary is installed (regardless of auth state).

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -860,6 +860,21 @@ export function createClaudeCodeCanUseToolHandler(ui) {
                             }];
                     }
                 }
+                else if (!perms || (Array.isArray(perms) && perms.length === 0)) {
+                    // Non-Bash tool with no SDK-supplied suggestions. Without a
+                    // fallback rule the SDK would return `behavior: "allow"`
+                    // with no `updatedPermissions`, so "Always Allow" silently
+                    // fails to persist for tools whose input varies per call
+                    // (e.g. AskUserQuestion with different `questions` payloads).
+                    // A bare `{ toolName }` rule matches any input.
+                    perms = [{
+                            type: "addRules",
+                            rules: [{ toolName }],
+                            behavior: "allow",
+                            destination: "localSettings",
+                        }];
+                    notifyLabel = toolName;
+                }
                 // Notify with the resolved pattern (label already previewed it)
                 if (notifyLabel) {
                     ui.notify(`Saved: ${notifyLabel}`, "info");
@@ -1019,13 +1034,13 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
-    // Globally unblock all tools. Users reported that the `acceptEdits` default
-    // plus a narrow allowlist silently declined most Bash/Agent/WebFetch calls
-    // when `extensionUIContext` wasn't threaded through. Default to
-    // bypassPermissions and an empty disallow list so every tool — including
-    // `AskUserQuestion` and every `mcp__*` workflow tool — is auto-approved.
+    // Globally unblock the tools GSD expects Claude Code to run. When the
+    // workflow MCP server is available, prefer its `ask_user_questions` tool over
+    // Claude Code's native `AskUserQuestion`; the MCP path carries stable IDs and
+    // routes responses through the GSD elicitation bridge.
     // Opt back into gated mode with GSD_CLAUDE_CODE_PERMISSION_MODE=acceptEdits.
-    const disallowedTools = [];
+    const workflowMcpTools = mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : [];
+    const disallowedTools = workflowMcpTools.length > 0 ? ["AskUserQuestion"] : [];
     const allowedTools = [
         "Read",
         "Write",
@@ -1036,8 +1051,7 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         "Agent",
         "WebFetch",
         "WebSearch",
-        "AskUserQuestion",
-        ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
+        ...(workflowMcpTools.length > 0 ? workflowMcpTools : ["AskUserQuestion"]),
     ];
     const supportsAdaptive = modelSupportsAdaptiveThinking(modelId);
     const effort = reasoning && supportsAdaptive

package/dist/resources/extensions/github-sync/cli.js

@@ -5,6 +5,7 @@
  * Uses `execFileSync` (not `execSync`) for safety.
  */
 import { execFileSync } from "node:child_process";
+import { GIT_NO_PROMPT_ENV } from "../gsd/git-constants.js";
 function ok(data) {
     return { ok: true, data };
 }
@@ -261,6 +262,7 @@ export function ghPushBranch(cwd, branch, setUpstream = true) {
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "pipe"],
             timeout: 30_000,
+            env: GIT_NO_PROMPT_ENV,
         });
         return ok(undefined);
     }
@@ -275,6 +277,7 @@ export function ghCreateBranch(cwd, branch, from) {
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "pipe"],
             timeout: 10_000,
+            env: GIT_NO_PROMPT_ENV,
         });
         return ok(undefined);
     }