dsh-gitbash-shell 0.26.1 → 0.28.0

package/src/index.js

@@ -180,6 +180,51 @@ export function pythonBackendActive(capability) {
   return intent && reported === 'python'
 }
 
+/**
+ * Is this agent a DELEGATED one — a subagent, a team member, or a nested child
+ * of either? The canonical in-tree signal is the session header pair dsh's own
+ * workspace-changes plugin uses
+ * (`packages/deliverables/workspace-changes/src/index.ts:59-60`), stamped when
+ * the subagent driver creates a child
+ * (`packages/subagent/subagent/src/child-agent.ts:139-155`):
+ * `origin === 'subagent'` or a non-zero `delegationDepth`.
+ *
+ * Unknown shapes read as NOT delegated: applying the dialect is the helpful
+ * direction, and a diagnostic assembly without an agent must keep it.
+ * @param {object|undefined} agent - the assembling/executing agent, when known.
+ * @returns {boolean} true only when the agent is provably delegated.
+ */
+export function isDelegatedAgent(agent) {
+  try {
+    const header = agent && agent.session ? agent.session.header : undefined
+    if (header === null || typeof header !== 'object') return false
+    if (header.origin === 'subagent') return true
+    return typeof header.delegationDepth === 'number' && header.delegationDepth > 0
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Does the Git Bash dialect apply to THIS agent (v0.27.0)? The row switch
+ * `subagentDialect` (default ON) decides whether delegated agents — subagents,
+ * team members, nested children — participate in the dialect at all; the main
+ * agent always does. A closed function so every consumer (prompt assembly,
+ * dispatch translation, result echo, failure text, the shell-env fact) answers
+ * the same way.
+ *
+ * Note the honest bound: dsh has exactly ONE shell provider per process, so
+ * the executor binary stays Git Bash for every agent; this gate governs the
+ * dialect/translation layers that this plugin owns.
+ * @param {object} dialect - the live dialect switches.
+ * @param {object|undefined} agent - the agent that owns this assembly/execution.
+ * @returns {boolean} true when the dialect applies to this agent.
+ */
+export function dialectApplies(dialect, agent) {
+  if (!dialect || dialect.subagentDialect !== false) return true
+  return !isDelegatedAgent(agent)
+}
+
 /**
  * The roster this plugin serves: the configured list, minus the variant a peer
  * already covers. Two independent facts must BOTH hold before anything is
@@ -200,8 +245,15 @@ export function effectivePresetIds(configured, { suppress, peerGitBash } = {}) {
   return list.filter((id) => id !== PEER_COVERED_PRESET_ID)
 }
 
-/** Git Bash binary default — must match src/shell.js. */
-const DEFAULT_GIT_BASH = 'C:/Program Files/Git/bin/bash.exe'
+/**
+ * The ONE bash resolver (v0.28.0, issue #11): the executor (src/shell.js) and
+ * this translation layer read the same memoized result, so "dialect translated
+ * to Q:/Git but the executor still spawns C:/Program Files/Git" cannot happen.
+ */
+import {
+  DEFAULT_GIT_BASH, GIT_BASH_DOWNLOAD_URL, bashResolutionReport,
+  effectiveConfiguredBashPath, executorConfiguredBashPath, resolveGitBashCached, settingsBashPath,
+} from './bash-path.js'
 
 /** The shipped preset whose skills/ dir seeds cordis-gitbash. */
 const SKILLS_SOURCE_PRESET = 'cordis'
@@ -823,6 +875,15 @@ export const Config = Schema === null ? undefined : Schema.object({
   globSplit: live(Schema.boolean().default(true)),
   errorDialect: live(Schema.boolean().default(true)),
   codePaths: live(Schema.boolean().default(true)),
+  /**
+   * Whether DELEGATED agents (subagents, team members, nested children) also
+   * use the Git Bash dialect (v0.27.0). Default ON — the historical behavior;
+   * OFF keeps the dialect to the main agent, so a delegated request carries the
+   * official shell semantics (no prompt rewrite, no path-argument translation,
+   * no echo rewrite, no DSH_PATH_DIALECT fact). The executor itself is one
+   * per-process provider, so Git Bash stays the binary either way.
+   */
+  subagentDialect: live(Schema.boolean().default(true)),
   gitAutocrlf: live(Schema.boolean().default(true)),
   bashPath: live(Schema.string().default('')),
   adoptSidebar: live(Schema.boolean().default(true)),
@@ -869,6 +930,8 @@ function makeLiveReader(ctx, config) {
       errorDialect: valueOf(config.errorDialect) === true,
       codePaths: valueOf(config.codePaths) === true,
       gitAutocrlf: valueOf(config.gitAutocrlf) === true,
+      // Default ON: delegated agents keep the dialect unless the user opts out.
+      subagentDialect: valueOf(config.subagentDialect) !== false,
       bashPath: typeof bash === 'string' ? bash : '',
       adoptSidebar: valueOf(config.adoptSidebar) !== false,
     }
@@ -943,7 +1006,7 @@ export function readPosixPaths(ctxLike) {
  * first. All default ON (schema defaults); never throws.
  */
 export function readDialectSettings(ctxLike) {
-  const fallback = { posixPaths: false, virtualMounts: false, globSplit: false, errorDialect: false, codePaths: false, gitAutocrlf: false, bashPath: '' }
+  const fallback = { posixPaths: false, virtualMounts: false, globSplit: false, errorDialect: false, codePaths: false, gitAutocrlf: false, bashPath: '', subagentDialect: true }
   try {
     const settings = ctxLike && typeof ctxLike.get === 'function' ? ctxLike.get('settings') : undefined
     const value = settings && typeof settings.get === 'function' ? settings.get(SETTINGS_NAMESPACE) : undefined
@@ -954,6 +1017,8 @@ export function readDialectSettings(ctxLike) {
       globSplit: v.globSplit === true,
       errorDialect: v.errorDialect === true,
       codePaths: v.codePaths === true,
+      // An old host without the key keeps the default (delegated agents covered).
+      subagentDialect: v.subagentDialect !== false,
       gitAutocrlf: v.gitAutocrlf === true,
       bashPath: typeof v.bashPath === 'string' ? v.bashPath : '',
     }
@@ -1390,23 +1455,12 @@ export function buildTranslateEnv(configuredBashPath) {
     if (h && existsSync(h)) env.home = h.replace(/\\/g, '/')
   } catch { /* keep undefined */ }
   try {
-    const candidates = []
-    if (cacheKey !== '') candidates.push(cacheKey.replace(/\\/g, '/'))
-    candidates.push(DEFAULT_GIT_BASH)
-    for (const dir of String(process.env.PATH ?? '').split(';')) {
-      const clean = dir && dir.trim()
-      if (clean) candidates.push(clean.replace(/\\/g, '/') + '/bash.exe')
-    }
-    for (const candidate of candidates) {
-      try {
-        if (!existsSync(candidate)) continue
-        const root = dirname(dirname(candidate))
-        if (existsSync(join(root, 'usr', 'bin'))) {
-          env.gitRoot = root.replace(/\\/g, '/')
-          break
-        }
-      } catch { /* try the next candidate */ }
-    }
+    // v0.28.0 (issue #11): ONE resolver for the executor and this layer. Its
+    // chain is setting > default install paths > PATH > registry PATH and it
+    // refuses WSL/MSYS2/Cygwin outright; `cacheKey` is the settings bashPath,
+    // i.e. the same explicit tier the executor reads.
+    const resolution = resolveGitBashCached({ configured: cacheKey })
+    if (resolution.ok) env.gitRoot = resolution.root.replace(/\\/g, '/')
   } catch { /* keep undefined */ }
   translateEnvCache.set(cacheKey, env)
   return env
@@ -2293,7 +2347,28 @@ export async function apply(ctx, config = {}) {
   // plugins (e.g. dsh-ptc-cordis-preset) can adopt it in the presets they
   // materialize: service present, 'active: true' on Windows, 'active: false'
   // where the bundle is installed but the platform stack stayed native.
-  const gitBashCapability = { active: process.platform === 'win32', bashPath: DEFAULT_GIT_BASH }
+  /* The explicit tier of the resolution chain, in its documented priority:
+     the `gitbash-executor` row's own config > the `gitbash-shell` row/settings
+     field > empty (= run the automatic chain). Both this layer and the
+     executor resolve from this same value, so an explicit answer is never
+     substituted and never silently ignored.
+     (issue #11: the row config is where the reporter's workaround landed.) */
+  const configuredBashPath = effectiveConfiguredBashPath(executorConfiguredBashPath(ctx), settingsBashPath(ctx))
+  const bashResolution = resolveGitBashCached({ configured: configuredBashPath })
+  const gitBashCapability = {
+    active: process.platform === 'win32',
+    // Kept for existing consumers (peer plugins read `bashPath`): the resolved
+    // interpreter. When resolution failed we report the explicit value (or the
+    // historical default) so the ENOENT a consumer may hit names a real path —
+    // never a substitute shell.
+    bashPath: bashResolution.ok ? bashResolution.path : (configuredBashPath || DEFAULT_GIT_BASH),
+    // Additive (v0.28.0): the full verdict, for the guided popup and peers.
+    ok: bashResolution.ok,
+    source: bashResolution.source,
+    configured: configuredBashPath,
+    tried: bashResolution.tried,
+    downloadUrl: GIT_BASH_DOWNLOAD_URL,
+  }
   const disposeGitBash = ctx.provide('gitBash', gitBashCapability)
   ctx.effect(() => disposeGitBash, 'dsh-gitbash-shell: gitBash capability')
 
@@ -2336,6 +2411,7 @@ export async function apply(ctx, config = {}) {
             globSplit: Schema.boolean().default(true),
             errorDialect: Schema.boolean().default(true),
             codePaths: Schema.boolean().default(true),
+            subagentDialect: Schema.boolean().default(true),
             gitAutocrlf: Schema.boolean().default(true),
             bashPath: Schema.string().default(''),
             adoptSidebar: Schema.boolean().default(true),
@@ -2391,8 +2467,17 @@ export async function apply(ctx, config = {}) {
             // git line endings and anything else non-DSH_* ride the executor's
             // own env layer (src/shell.js), not this registry.
             variables: { [PATH_DIALECT_KEY]: { description: PATH_DIALECT_DESCRIPTION } },
-            resolve() {
-              return liveSettings.posix() ? { [PATH_DIALECT_KEY]: PATH_DIALECT_VALUE } : {}
+            resolve(execution) {
+              try {
+                const dialect = liveSettings.dialect()
+                if (dialect.posixPaths !== true) return {}
+                // The environment fact is per execution, so a delegated agent
+                // the user excluded sees no DSH_PATH_DIALECT at all.
+                if (!dialectApplies(dialect, execution && execution.agent)) return {}
+                return { [PATH_DIALECT_KEY]: PATH_DIALECT_VALUE }
+              } catch {
+                return {}
+              }
             },
           })
           envCtx.effect(() => unregister, 'dsh-gitbash-shell: shellEnv path-dialect fact')
@@ -2418,9 +2503,16 @@ export async function apply(ctx, config = {}) {
   // could corrupt pattern/default fields).
   if (process.platform === 'win32') {
     try {
-      ctx.on('system-prompt/assemble', (assembly, _assembleContext, next) => {
+      ctx.on('system-prompt/assemble', (assembly, assembleContext, next) => {
         try {
-          if (liveSettings.posix() && assembly && typeof assembly === 'object') {
+          /* v0.27.0: the main agent always participates; a DELEGATED agent
+             (subagent / team member / nested child) only while the
+             `subagentDialect` switch is on. Turning it off leaves the official
+             prompt text untouched for those agents — no source replacement and
+             no run_code hint — so they meet the shell they were composed for. */
+          const dialect = liveSettings.dialect()
+          const applies = dialectApplies(dialect, assembleContext && assembleContext.agent)
+          if (applies && dialect.posixPaths === true && assembly && typeof assembly === 'object') {
             for (const section of Array.isArray(assembly.sections) ? assembly.sections : []) {
               if (section && typeof section.text === 'string') section.text = windowsToMsys(section.text)
             }
@@ -2491,9 +2583,12 @@ export async function apply(ctx, config = {}) {
           // `bash.workdir` went through raw, and an in-workspace `/c/...` write
           // fell outside the sandbox. One missed call site, five symptoms.
           const dialect = liveSettings.dialect()
-          if (dialect.posixPaths) {
+          // v0.27.0: a delegated agent the user excluded keeps the official
+          // semantics for BOTH faces of its calls — arguments go through
+          // untouched and the result metadata is not echoed back in MSYS form.
+          if (dialect.posixPaths && dialectApplies(dialect, exec && exec.agent)) {
             echo = true
-            const env = dialect.virtualMounts ? buildTranslateEnv(dialect.bashPath) : null
+            const env = dialect.virtualMounts ? buildTranslateEnv(configuredBashPath) : null
             echoEnv = env
             if (exec && exec.arguments && typeof exec.arguments === 'object') {
               const translated = translateDispatch(exec, dialect, env)
@@ -2542,9 +2637,13 @@ export async function apply(ctx, config = {}) {
         let contentPatch
         try {
           const dialect = liveSettings.dialect()
+          // Same agent gate as the dispatch wrapper: one call, one dialect.
+          // RETURN the downstream promise: a waterfall listener that swallows
+          // it would hand the caller `undefined` instead of the decision.
+          if (!dialectApplies(dialect, exec && exec.agent)) return next()
           if (dialect.posixPaths && dialect.errorDialect && exec && result && typeof result === 'object'
             && result.isError === true && Array.isArray(result.content)) {
-            const env = dialect.virtualMounts ? buildTranslateEnv(dialect.bashPath) : null
+            const env = dialect.virtualMounts ? buildTranslateEnv(configuredBashPath) : null
             if (exec.name === 'run_code') {
               // paths only — the /dev/null hint is for file tools
               const content = rewriteErrorContent(result.content, { nulHint: false, env })
@@ -2588,10 +2687,14 @@ export async function apply(ctx, config = {}) {
           pctx.effect(() => pctx.systemPrompt.context({
             name: 'gitbash-shell:posix-paths',
             order: 126,
-            text: () => {
+            text: (assembleContext) => {
               try {
                 const dialect = liveSettings.dialect()
                 if (dialect.posixPaths !== true) return ''
+                // A delegated agent whose dialect the user turned off meets the
+                // official shell semantics: no directive, the same way no
+                // translation happens for its calls.
+                if (!dialectApplies(dialect, assembleContext && assembleContext.agent)) return ''
                 return dialect.virtualMounts === false ? POSIX_DIRECTIVE_TEXT_STRICT : POSIX_DIRECTIVE_TEXT
               } catch {
                 return ''
@@ -2608,12 +2711,56 @@ export async function apply(ctx, config = {}) {
     }
   }
 
+  // ── fail-loud bash report + the client-visible status route (v0.28.0) ──
+  // issue #11: the old failure mode was "every command dies with
+  // `spawn C:/Program Files/Git/bin/bash.exe ENOENT` and nothing explains it".
+  // Now the boot log names the value, the whole probe chain and where to fix
+  // it, and the client half reads the same verdict over HTTP to raise the
+  // guided popup. Nothing here substitutes another shell — by design.
+  console.log(TAG + ' bash resolution: ' + bashResolutionReport(bashResolution).split('\n').join('\n' + TAG + ' '))
+  if (process.platform === 'win32') {
+    try {
+      ctx.inject(['webServer'], (wctx) => {
+        try {
+          const route = '/dsh-gitbash-shell/api/status'
+          const read = () => {
+            const resolution = resolveGitBashCached({ configured: configuredBashPath, fresh: true })
+            return {
+              ok: resolution.ok,
+              platform: process.platform,
+              resolved: resolution.path,
+              root: resolution.root,
+              source: resolution.source,
+              configured: resolution.configured,
+              tried: resolution.tried,
+              downloadUrl: GIT_BASH_DOWNLOAD_URL,
+              settingsHint: 'Settings -> Plugins -> dsh-gitbash-shell -> "Git Bash path"',
+            }
+          }
+          const handler = (req, res) => {
+            const text = JSON.stringify(read())
+            res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', 'content-length': Buffer.byteLength(text) })
+            res.end(text)
+          }
+          const dispose = wctx.webServer.register({ kind: 'prefix', path: route, handler })
+          wctx.effect(() => dispose, 'dsh-gitbash-shell: bash status route')
+          console.log(TAG + ' bash status route active at ' + route + ' (read by the guided popup)')
+        } catch (error) {
+          console.log(TAG + ' bash status route failed: ' + (error?.message ?? error))
+        }
+      })
+    } catch (error) {
+      console.log(TAG + ' bash status route wiring failed: ' + (error?.message ?? error))
+    }
+  }
+
   // ── dsh-better-sidebar terminal adoption (Windows only) ────────────────
   // The sidebar resolves its terminal shell through the settings seam per
   // open; adopt it through that seam (see adoptSidebarShell for rationale).
   // Disable with `betterSidebarShell: false` in the plugin row config.
   if (config.betterSidebarShell !== false && process.platform === 'win32') {
-    adoptSidebarShell(ctx, gitBashCapability.bashPath, () => liveSettings.adoptSidebar())
+    if (bashResolution.ok) adoptSidebarShell(ctx, bashResolution.path, () => liveSettings.adoptSidebar())
+    else console.log(TAG + ' sidebar terminal adoption skipped: no Git Bash resolved (nothing is substituted)')
   }
 
   // ── era split: declarative registration on dsh >= 0.1.7 ──────────────────
@@ -2717,4 +2864,4 @@ export async function apply(ctx, config = {}) {
 }
 
 // Test surface: pure helpers, no Cordis context required.
-export const _internal = { PRESET_IDS, PEER_COVERED_PRESET_ID, PEER_CAPABILITY, PEER_PYTHON_FIELD, PEER_PYTHON_BACKEND_FIELD, peerFact, peerBackend, pythonBackendActive, effectivePresetIds, detectPeerCoverage, readSuppressPeerCordis, translateDispatch, translateMsysPath, translatePathArguments, rewriteCodePaths, scanCodeLiterals, programPrelude, translateGlobArguments, buildTranslateEnv, rewriteErrorContent, rewriteErrorMessage, rewriteFailureMessage, msysEcho, driveToMsys, pathEcho, ERROR_CONTENT_TOOLS, readPosixPaths, readAdoptSidebar, readDialectSettings, windowsToMsys, rewriteResultPaths, adoptSidebarShell, MARKER_FILE, classify, materialize, cleanupOnDispose, firstUserRoot, hashTree, skillsHashes, syncDecision, installRegisterShim, baseForRoster, detectBase, pickComposition, personaEraForText, detectPersonaEra, injectPresentRow, hostHasToolPresent, detectPresentSupport, injectPluginManagerRow, hostHasPluginManagerTools, rowFormOf, rowFormsOf, alignEngineRow, alignRalphRow, ROW_SOURCE }
+export const _internal = { PRESET_IDS, PEER_COVERED_PRESET_ID, PEER_CAPABILITY, isDelegatedAgent, dialectApplies, PEER_PYTHON_FIELD, PEER_PYTHON_BACKEND_FIELD, peerFact, peerBackend, pythonBackendActive, effectivePresetIds, detectPeerCoverage, readSuppressPeerCordis, translateDispatch, translateMsysPath, translatePathArguments, rewriteCodePaths, scanCodeLiterals, programPrelude, translateGlobArguments, buildTranslateEnv, rewriteErrorContent, rewriteErrorMessage, rewriteFailureMessage, msysEcho, driveToMsys, pathEcho, ERROR_CONTENT_TOOLS, readPosixPaths, readAdoptSidebar, readDialectSettings, windowsToMsys, rewriteResultPaths, adoptSidebarShell, MARKER_FILE, classify, materialize, cleanupOnDispose, firstUserRoot, hashTree, skillsHashes, syncDecision, installRegisterShim, baseForRoster, detectBase, pickComposition, personaEraForText, detectPersonaEra, injectPresentRow, hostHasToolPresent, detectPresentSupport, injectPluginManagerRow, hostHasPluginManagerTools, rowFormOf, rowFormsOf, alignEngineRow, alignRalphRow, ROW_SOURCE }

package/src/shell.js

@@ -38,10 +38,13 @@
  */
 
 import { SandboxBashExecutor } from '@deepseek-ai/dsh-bash-sandbox'
+
+import { DEFAULT_GIT_BASH, bashResolutionReport, effectiveConfiguredBashPath, resolveGitBashCached, settingsBashPath } from './bash-path.js'
+
+/** Re-exported for callers that historically read it here (the value now lives in bash-path.js). */
+export { DEFAULT_GIT_BASH }
 import z from '@deepseek-ai/schemastery'
 
-/** Default Git for Windows bash (forward slashes work on Windows too). */
-export const DEFAULT_GIT_BASH = 'C:/Program Files/Git/bin/bash.exe'
 
 /** Log prefix, matching src/index.js. */
 const TAG = '[gitbash-shell]'
@@ -95,7 +98,12 @@ export function gitBashShellConfig(z) {
     graceMs: live(z.number().default(3000)),
     // Our own knob: the base class neither declares nor `.get()`s it, and
     // `get bashPath()` below reads it as a plain value, so it stays plain.
-    bashPath: z.string().default(DEFAULT_GIT_BASH),
+    //
+    // EMPTY means AUTO (v0.28.0, issue #11): the shared resolver walks
+    // setting > default install paths > PATH > registry PATH and refuses WSL /
+    // MSYS2 / Cygwin. A hard-coded default here is what made a Git installed
+    // outside C:/Program Files look like "dsh is broken".
+    bashPath: z.string().default(''),
   })
 }
 
@@ -107,9 +115,49 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
   static inject = ['subprocess', 'sandbox', 'sandboxPolicy']
   static Config = Config
 
-  /** Effective Git Bash path: composition/config value with the default fallback. */
+  /**
+   * Effective Git Bash path. The configured value wins when it is non-empty
+   * (the user's explicit answer is never substituted); otherwise the SHARED
+   * resolver decides — the very same result the path-dialect translation layer
+   * uses, so "dialect works, executor cannot find bash" (issue #11) is
+   * structurally impossible.
+   *
+   * A failed resolution returns '' — deliberately NOT a substitute shell. Every
+   * argv built from it then fails loudly on spawn; `apply()` has already
+   * printed the full report, and the client half shows the guided popup.
+   */
   get bashPath() {
-    return this.config.bashPath ?? DEFAULT_GIT_BASH
+    return this.bashResolution().path
+  }
+
+  /**
+   * Resolve the interpreter with the SAME merged explicit tier the main plugin
+   * uses (executor row config > `gitbash-shell` settings row > empty = auto),
+   * so both halves of the plugin always agree on which bash this process runs.
+   * @returns {object} the memoized resolution verdict.
+   */
+  bashResolution() {
+    const configured = effectiveConfiguredBashPath(this.config.bashPath, settingsBashPath(this.ctx))
+    return resolveGitBashCached({ configured })
+  }
+
+  /**
+   * The resolved Git Bash path, or a THROW that says exactly what is wrong.
+   *
+   * The throw is the design (AGENTS.md §4h): with no Git Bash there is no
+   * command execution at all — we do not substitute pwsh, cmd, WSL or MSYS2,
+   * and we do not let a bare `spawn ENOENT` be the only thing the user sees.
+   * The boot log carries the same report (src/index.js) and the client half
+   * shows the guided popup with the probed list.
+   * @returns {string} the resolved interpreter path.
+   */
+  requireBashPath() {
+    const resolution = this.bashResolution()
+    if (!resolution.ok) {
+      throw new Error('dsh-gitbash-shell: no Git for Windows bash found, so this command cannot run. '
+        + bashResolutionReport(resolution).split('\n').slice(1).join(' | '))
+    }
+    return resolution.path
   }
 
   /**
@@ -129,7 +177,7 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
    * @returns the provider's exact argv and settlement-classification facts (a promise on dsh >= 0.1.6).
    */
   confine(command, policy, signal) {
-    return this.ctx.sandbox.confine([this.bashPath, '-c', command], policy, signal)
+    return this.ctx.sandbox.confine([this.requireBashPath(), '-c', command], policy, signal)
   }
 
   /**
@@ -219,7 +267,7 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
     const routed = this.withParityEnv(spec)
     const route = this.gitBashRoute(routed)
     if (route === undefined) return super.execute(routed)
-    const argv = [this.bashPath, '-c', routed.command]
+    const argv = [this.requireBashPath(), '-c', routed.command]
     if (route.unconfined) this.warnConfinedUnconfined(route.mode)
     const sandbox = route.unconfined
       ? { mode: route.mode, denied: false, enforcement: 'unconfined' }
@@ -304,13 +352,13 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
     const { mode } = policy
     if (mode === 'danger-full-access') {
       const { result } = GitBashSandboxExecutor.unwrapRunArgv(
-        await this.runArgv(spec, [this.bashPath, '-c', spec.command]))
+        await this.runArgv(spec, [this.requireBashPath(), '-c', spec.command]))
       return { ...result, sandbox: { mode, denied: false } }
     }
     if (process.platform === 'win32') {
       this.warnConfinedUnconfined(mode)
       const { result, spawnRequested } = GitBashSandboxExecutor.unwrapRunArgv(
-        await this.runArgv(spec, [this.bashPath, '-c', spec.command]))
+        await this.runArgv(spec, [this.requireBashPath(), '-c', spec.command]))
       // No spawn means no argv ran, so there is nothing to label as
       // unconfined; the parent reports the same bare sandbox facts there.
       return { ...result, sandbox: spawnRequested ? { mode, denied: false, enforcement: 'unconfined' } : { mode, denied: false } }
@@ -326,7 +374,7 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
     const fullAccess = mode === 'danger-full-access'
     if (fullAccess || process.platform === 'win32') {
       if (!fullAccess) this.warnConfinedUnconfined(mode)
-      const proc = this.startArgv(spec, [this.bashPath, '-c', spec.command])
+      const proc = this.startArgv(spec, [this.requireBashPath(), '-c', spec.command])
       proc.sandbox = fullAccess ? { mode, denied: false } : { mode, denied: false, enforcement: 'unconfined' }
       // Match the loaded base contract: the async one (dsh >= 0.1.6) is
       // awaited by its callers, the synchronous one is consumed directly.