dsh-gitbash-shell 0.24.3 → 0.25.0

package/src/index.js

@@ -95,6 +95,36 @@ const MARKER_FILE = '.plugin-managed.json'
 /** Default preset ids this plugin materializes, in roster order (configurable). */
 export const PRESET_IDS = ['standard-gitbash', 'minimal-gitbash', 'code-gitbash', 'cordis-gitbash']
 
+/**
+ * The variant dsh-ptc-cordis-preset already covers while cooperating: its
+ * `PTC 创造模式` is materialized against Git Bash too, so our own
+ * `创造模式 · Git Bash` describes the same mode (their issue #7).
+ */
+export const PEER_COVERED_PRESET_ID = 'cordis-gitbash'
+
+/** Service dsh-ptc-cordis-preset publishes: `{ id, gitBashActive }`. */
+export const PEER_CAPABILITY = 'ptcCordisPreset'
+
+/**
+ * The roster this plugin serves: the configured list, minus the variant a peer
+ * already covers. Two independent facts must BOTH hold before anything is
+ * dropped — the user's `suppressPeerCordis` switch (row Config, default OFF)
+ * and the peer actually reporting a Git Bash-materialized preset. A peer that
+ * is absent, inactive, or mounted later than this row therefore never costs
+ * the user a variant, and the default keeps the historical four-variant roster
+ * byte for byte.
+ * @param {string[]} configured - the row's `presets` list (empty/absent = default).
+ * @param {object} [options] - live decision inputs.
+ * @param {boolean} [options.suppress] - the live `suppressPeerCordis` switch.
+ * @param {boolean} [options.peerGitBash] - the peer capability's `gitBashActive`.
+ * @returns {string[]} the ids to register (or materialize), in configured order.
+ */
+export function effectivePresetIds(configured, { suppress, peerGitBash } = {}) {
+  const list = Array.isArray(configured) && configured.length > 0 ? [...configured] : [...PRESET_IDS]
+  if (suppress !== true || peerGitBash !== true) return list
+  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'
 
@@ -721,6 +751,16 @@ export const Config = Schema === null ? undefined : Schema.object({
   gitAutocrlf: live(Schema.boolean().default(true)),
   bashPath: live(Schema.string().default('')),
   adoptSidebar: live(Schema.boolean().default(true)),
+  /**
+   * Dedupe switch against dsh-ptc-cordis-preset (their issue #7, v0.25.0):
+   * ON while that plugin is installed AND materializing its `PTC 创造模式`
+   * against Git Bash drops OUR `创造模式 · Git Bash` from the roster, because
+   * the two describe the same mode. Default OFF — the historical four-variant
+   * roster is unchanged until asked for. The same state is rendered on their
+   * settings card too (their card binds this row through configForms), so
+   * changing it on either side changes it here.
+   */
+  suppressPeerCordis: live(Schema.boolean().default(false)),
 })
 
 /** Read one Config value across eras: Volatile ref (>= 0.1.7) or plain value. */
@@ -735,7 +775,7 @@ export function valueOf(value) {
  * reading the registered namespace through the settings service.
  * @param {object} ctx - the plugin's mounting context.
  * @param {object|undefined} config - apply()'s resolved Config.
- * @returns {{ dialect: () => object, posix: () => boolean, adoptSidebar: () => boolean }}
+ * @returns {{ dialect: () => object, posix: () => boolean, adoptSidebar: () => boolean, suppressPeerCordis: () => boolean }}
  */
 function makeLiveReader(ctx, config) {
   let legacy = false
@@ -762,6 +802,8 @@ function makeLiveReader(ctx, config) {
     dialect,
     posix: () => dialect().posixPaths === true,
     adoptSidebar: () => dialect().adoptSidebar !== false,
+    // Default OFF on both eras: only an explicit true asks for deduplication.
+    suppressPeerCordis: () => (legacy || !hasConfig ? readSuppressPeerCordis(ctx) : valueOf(config.suppressPeerCordis) === true),
   }
 }
 
@@ -859,6 +901,52 @@ export function readAdoptSidebar(ctxLike) {
   }
 }
 
+/**
+ * Read the peer-dedupe switch (v0.25.0, default OFF) from the OLD era's
+ * registered namespace — on dsh >= 0.1.7 the row Config is the surface and
+ * `makeLiveReader` reads it directly. Never throws.
+ */
+export function readSuppressPeerCordis(ctxLike) {
+  try {
+    const settings = ctxLike && typeof ctxLike.get === 'function' ? ctxLike.get('settings') : undefined
+    const value = settings && typeof settings.get === 'function' ? settings.get(SETTINGS_NAMESPACE) : undefined
+    return !!(value && value.suppressPeerCordis === true)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Bounded probe for dsh-ptc-cordis-preset's coverage capability. The OLD era
+ * has no registration registry to watch, and rows mount concurrently, so poll
+ * briefly when the service is not there yet; a short absence means the peer is
+ * not installed (or is older than 0.14.0) and every configured variant stays.
+ * @param {object} ctx - the plugin's mounting context.
+ * @param {number} [timeoutMs] - total wait before giving up.
+ * @param {number} [intervalMs] - poll interval.
+ * @returns {Promise<boolean>} the peer's `gitBashActive`, false when unknown.
+ */
+export async function detectPeerCoverage(ctx, timeoutMs = 1000, intervalMs = 25) {
+  try {
+    const probe = () => {
+      const capability = ctx.get(PEER_CAPABILITY)
+      return capability === null || capability === undefined ? undefined : capability
+    }
+    let capability = probe()
+    if (capability === undefined) {
+      const deadline = Date.now() + timeoutMs
+      while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, intervalMs))
+        capability = probe()
+        if (capability !== undefined) break
+      }
+    }
+    return capability?.gitBashActive === true
+  } catch {
+    return false
+  }
+}
+
 // Windows absolute path -> MSYS drive-root form, for rewriting PROSE in place
 // (v0.10.0). Quoted spaced paths ("C:\Program Files\Git") are matched whole; a bare
 // path stops at a closing punctuation and crosses a space ONLY into a token that
@@ -1692,10 +1780,22 @@ function adoptSidebarShell(ctx, bashPath, readAdopt) {
 
   const readShell = () => {
     const settings = ctx.get('settings')
-    if (!settings || typeof settings.get !== 'function' || typeof settings.update !== 'function') return null
+    if (!settings || typeof settings.update !== 'function') return null
     try {
-      const value = settings.get(SIDEBAR_NS)
-      return value && typeof value === 'object' && typeof value.terminalShell === 'string' ? value.terminalShell : ''
+      // <=0.1.6: the sidebar registers a settings namespace and `get(ns)` reads
+      // it. >=0.1.7: that API is gone (the service exposes describe/update
+      // only), so the value comes from the row Config's projected form —
+      // without this branch the adoption was silently skipped on the new host.
+      if (typeof settings.get === 'function') {
+        const value = settings.get(SIDEBAR_NS)
+        return value && typeof value === 'object' && typeof value.terminalShell === 'string' ? value.terminalShell : ''
+      }
+      if (typeof settings.describe === 'function') {
+        const entry = settings.describe().find((row) => row !== null && typeof row === 'object' && row.ns === SIDEBAR_NS)
+        const value = entry === undefined ? undefined : entry.value
+        return value && typeof value === 'object' && typeof value.terminalShell === 'string' ? value.terminalShell : ''
+      }
+      return null
     } catch {
       return null // namespace not registered yet / sidebar absent
     }
@@ -1908,26 +2008,107 @@ async function registerVariant(ctx, presetId, { gitBashActive, skillsDir }) {
 }
 
 /**
- * Declarative-era wiring: register every configured variant once at startup
- * and keep exactly one registration per variant for the plugin's lifetime.
- * The roster picks the entries up immediately; sessions already pinned to a
- * variant keep their revision until recomposed.
+ * Declarative-era wiring: keep exactly one registration per VARIANT THIS HOST
+ * SHOULD SERVE for the plugin's lifetime, and re-reconcile whenever that set
+ * changes. Two inputs drive it — the live `suppressPeerCordis` switch and the
+ * peer capability appearing (or leaving) via `ctx.inject`, which fires
+ * independent of row activation order — and the peer's own coverage only
+ * counts while it reports a Git Bash-materialized preset.
+ *
+ * The roster picks entries up immediately; sessions already pinned to a
+ * variant keep their revision until recomposed, so suppressing a variant never
+ * rewrites a running session.
+ * @param {object} ctx - the plugin's mounting context.
+ * @param {string[]} presetIds - the row's configured variants.
+ * @param {() => boolean} readSuppress - live dedupe switch reader.
+ * @returns {Promise<void>} resolves once the first reconcile finished.
  */
-async function runDeclarativeEra(ctx, presetIds) {
+async function runDeclarativeEra(ctx, presetIds, readSuppress) {
   cleanupLegacyTrees(presetIds)
   const gitBashActive = process.platform === 'win32'
   const skillsDir = await resolveSkillsDir()
-  const unregisters = []
-  for (const presetId of presetIds) {
-    try {
-      const unregister = await registerVariant(ctx, presetId, { gitBashActive, skillsDir })
-      if (unregister) unregisters.push(unregister)
-    } catch (error) {
-      console.log(TAG + " preset '" + presetId + "' registration failed: " + (error && error.message ? error.message : error))
-    }
+  /** presetId -> unregister, i.e. exactly what is live right now. */
+  const live = new Map()
+  let peerGitBash = false
+  let serial = Promise.resolve()
+
+  const desired = () => effectivePresetIds(presetIds, { suppress: readSuppress(), peerGitBash })
+
+  const reconcile = () => {
+    serial = serial.then(async () => {
+      const want = desired()
+      for (const [presetId, off] of [...live]) {
+        if (want.includes(presetId)) continue
+        live.delete(presetId)
+        try {
+          await off()
+          console.log(TAG + " preset '" + presetId + "' retired (dsh-ptc-cordis-preset covers Creation mode on Git Bash)")
+        } catch (error) {
+          console.log(TAG + " preset '" + presetId + "' retirement failed: " + (error && error.message ? error.message : error))
+        }
+      }
+      for (const presetId of want) {
+        if (live.has(presetId)) continue
+        try {
+          const unregister = await registerVariant(ctx, presetId, { gitBashActive, skillsDir })
+          if (unregister) {
+            live.set(presetId, unregister)
+            console.log(TAG + " preset '" + presetId + "' registered declaratively")
+          }
+        } catch (error) {
+          console.log(TAG + " preset '" + presetId + "' registration failed: " + (error && error.message ? error.message : error))
+        }
+      }
+    }).catch((error) => {
+      console.log(TAG + ' preset reconcile failed: ' + (error && error.message ? error.message : error))
+    })
+    return serial
+  }
+
+  await reconcile()
+  console.log(TAG + ' registered ' + live.size + ' preset(s) declaratively (' + [...live.keys()].join(', ') + ')')
+
+  // The peer's capability: `ctx.inject` makes this independent of row order,
+  // and the child scope's disposer runs when the peer unmounts (or its row is
+  // disabled), which restores the variant.
+  try {
+    ctx.inject([PEER_CAPABILITY], (peerCtx) => {
+      try {
+        const coverage = peerCtx[PEER_CAPABILITY] ?? peerCtx.get(PEER_CAPABILITY)
+        const next = coverage?.gitBashActive === true
+        if (next !== peerGitBash) {
+          peerGitBash = next
+          void reconcile()
+        }
+      } catch (error) {
+        console.log(TAG + ' peer coverage read failed: ' + (error && error.message ? error.message : error))
+      }
+      peerCtx.effect(() => () => {
+        if (!peerGitBash) return
+        peerGitBash = false
+        void reconcile()
+      }, 'dsh-gitbash-shell: peer coverage release')
+    })
+  } catch (error) {
+    console.log(TAG + ' peer capability wiring failed: ' + (error && error.message ? error.message : error))
   }
-  console.log(TAG + ' registered ' + unregisters.length + ' preset(s) declaratively (' + presetIds.join(', ') + ')')
-  ctx.effect(() => () => { for (const off of unregisters) void off() }, 'dsh-gitbash-shell: declarative preset registrations')
+
+  // The switch itself: a volatile Config edit on this row lands as a
+  // loader/volatile-update event on this fiber.
+  try {
+    ctx.on('loader/volatile-update', (paths) => {
+      try {
+        if (!Array.isArray(paths) || !paths.some((path) => Array.isArray(path) && path[0] === 'suppressPeerCordis')) return
+        void reconcile()
+      } catch (error) {
+        console.log(TAG + ' dedupe switch handling failed: ' + (error && error.message ? error.message : error))
+      }
+    })
+  } catch (error) {
+    console.log(TAG + ' dedupe switch wiring failed: ' + (error && error.message ? error.message : error))
+  }
+
+  ctx.effect(() => () => { for (const off of live.values()) void off() }, 'dsh-gitbash-shell: declarative preset registrations')
 }
 
 export async function apply(ctx, config = {}) {
@@ -2007,6 +2188,10 @@ export async function apply(ctx, config = {}) {
             gitAutocrlf: Schema.boolean().default(true),
             bashPath: Schema.string().default(''),
             adoptSidebar: Schema.boolean().default(true),
+            // v0.25.0: same switch as the row Config carries on dsh >= 0.1.7
+            // (the OLD era has no cross-namespace edits, so this namespace is
+            // the only side that can change it here).
+            suppressPeerCordis: Schema.boolean().default(false),
           }))
           sidebarScope = scope
           console.log(`${TAG} settings namespace registered: ${SETTINGS_NAMESPACE} (posixPaths default on, adoptSidebar default on)`)
@@ -2292,7 +2477,7 @@ export async function apply(ctx, config = {}) {
   // more), so this branch serves the variants and returns.
   if (ctx.agentPresets && typeof ctx.agentPresets.register === 'function') {
     try {
-      await runDeclarativeEra(ctx, presetIds)
+      await runDeclarativeEra(ctx, presetIds, () => liveSettings.suppressPeerCordis())
     } catch (error) {
       console.log(TAG + ' declarative registration failed: ' + (error && error.message ? error.message : error))
     }
@@ -2331,9 +2516,21 @@ export async function apply(ctx, config = {}) {
   // 0.1.6-alpha.1, so the materializer copies whatever the host itself ships.
   const rows = await detectRowForms(ctx.agentPresets)
   const userRootPath = userRoot.path
-  purgeOrphans(userRootPath, presetIds)
-
-  for (const presetId of presetIds) {
+  // Same dedupe decision as the declarative era, taken once at startup here:
+  // this host has no roster registry to watch and no live Config writes, so the
+  // switch is read per boot (documented in the README). `purgeOrphans` retires
+  // a copy an earlier boot materialized, and flipping the switch back
+  // re-materializes it on the next start.
+  const suppressPeer = liveSettings.suppressPeerCordis()
+  const peerGitBash = suppressPeer ? await detectPeerCoverage(ctx) : false
+  const effectiveIds = effectivePresetIds(presetIds, { suppress: suppressPeer, peerGitBash })
+  if (effectiveIds.length !== presetIds.length) {
+    const skipped = presetIds.filter((presetId) => !effectiveIds.includes(presetId))
+    console.log(`${TAG} dsh-ptc-cordis-preset covers Creation mode on Git Bash — not materializing: ${skipped.join(', ')}`)
+  }
+  purgeOrphans(userRootPath, effectiveIds)
+
+  for (const presetId of effectiveIds) {
     const target = join(userRootPath, presetId)
     const state = classify(target)
     if (state === 'foreign') {
@@ -2375,4 +2572,4 @@ export async function apply(ctx, config = {}) {
 }
 
 // Test surface: pure helpers, no Cordis context required.
-export const _internal = { PRESET_IDS, translateMsysPath, translatePathArguments, rewriteCodePaths, scanCodeLiterals, programPrelude, translateGlobArguments, buildTranslateEnv, rewriteErrorContent, rewriteErrorMessage, rewriteFailureMessage, msysEcho, driveToMsys, pathEcho, ERROR_CONTENT_TOOLS, readPosixPaths, readAdoptSidebar, readDialectSettings, windowsToMsys, rewriteResultPaths, 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, effectivePresetIds, detectPeerCoverage, readSuppressPeerCordis, 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

@@ -46,16 +46,61 @@ export const DEFAULT_GIT_BASH = 'C:/Program Files/Git/bin/bash.exe'
 /** Log prefix, matching src/index.js. */
 const TAG = '[gitbash-shell]'
 
+/**
+ * The plugin row's id, which doubles as the settings namespace on <= 0.1.6 and
+ * as the row-config namespace on 0.1.7+ (same string by design).
+ */
+const SETTINGS_NAMESPACE = 'gitbash-shell'
+
+/**
+ * Mark one schema field live-editable when the HOST's schemastery supports it.
+ *
+ * dsh 0.1.7-alpha.1 (`feat(settings): project volatile Config through
+ * profile-backed forms`, #4587) made `LocalBashExecutor.Config` declare
+ * `cwd`/`timeoutMs`/`maxTimeoutMs`/`maxOutputBytes`/`maxSpillBytes`/`graceMs`
+ * with `.volatile()` and read every one of them through `.get()`
+ * (`packages/shell/bash-local/src/index.ts:100-107` and its
+ * `assertServiceableBashConfig`/`resolve`). A subclass that REDECLARES those
+ * fields as plain values therefore throws
+ * `TypeError: config.timeoutMs.get is not a function` on the first shell call
+ * and takes the whole `ctx.shell` down with it (issue #6, 0.24.2).
+ * `SandboxBashExecutor` — our parent — declares no Config of its own: it
+ * inherits `LocalBashExecutor`'s verbatim, so this redeclaration IS the
+ * executor's contract.
+ *
+ * The probe keeps one build serving both eras: hosts whose schemastery has
+ * `volatile()` (0.1.7+) get the Volatile refs their base class calls `.get()`
+ * on, while older hosts — whose base class reads plain values — keep plain
+ * ones. Published schemastery 3.18.2 has no `volatile()`, which is exactly why
+ * the probe (not an unconditional call) is required.
+ */
+function live(schema) {
+  return typeof schema.volatile === 'function' ? schema.volatile() : schema
+}
+
+/**
+ * Build the executor's Config against a given schemastery module. Exported so
+ * the smoke test can drive BOTH eras with a recording stand-in instead of
+ * depending on which schemastery happens to be installed here.
+ * @param z schemastery module (real one, or the test's recorder).
+ * @returns the object schema for the `gitbash-executor` row.
+ */
+export function gitBashShellConfig(z) {
+  return z.object({
+    cwd: live(z.string()),
+    timeoutMs: live(z.number().default(120000)),
+    maxTimeoutMs: live(z.number().default(600000)),
+    maxOutputBytes: live(z.number().default(64000)),
+    maxSpillBytes: live(z.number().default(64 * 1024 * 1024)),
+    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),
+  })
+}
+
 /** Resolved configuration: the local executor's knobs, plus the Git Bash path. */
-export const Config = z.object({
-  cwd: z.string(),
-  timeoutMs: z.number().default(120000),
-  maxTimeoutMs: z.number().default(600000),
-  maxOutputBytes: z.number().default(64000),
-  maxSpillBytes: z.number().default(64 * 1024 * 1024),
-  graceMs: z.number().default(3000),
-  bashPath: z.string().default(DEFAULT_GIT_BASH),
-})
+export const Config = gitBashShellConfig(z)
 
 /** Git Bash executor — mirrors the shipped bash/pwsh sandbox executors. */
 export class GitBashSandboxExecutor extends SandboxBashExecutor {
@@ -119,15 +164,72 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
   }
 
   /**
-   * Full-access path with Git Bash argv: the parent's full-access branch
-   * delegates to LocalBashExecutor.run, which hardcodes the bare `bash`
-   * name, so override that branch here and keep everything else inherited.
+   * Decide whether one spec takes the Git Bash argv path, and how to label it
+   * (pure). Full access always does — the shipped executor hardcodes the bare
+   * `bash` name there. A Windows confined call does too (issue #1: MSYS2 cannot
+   * start under the restricted-token runner). Everything else inherits the
+   * parent's sandbox path, which already runs Git Bash because `confine` below
+   * substitutes the argv.
+   * @param spec the shell request.
+   * @returns `{ mode, unconfined }`, or undefined to inherit the parent path.
    */
+  gitBashRoute(spec) {
+    const policy = spec.sandboxPolicy
+    const mode = policy === undefined ? undefined : policy.mode
+    if (mode === undefined) return undefined
+    if (mode === 'danger-full-access') return { mode, unconfined: false }
+    if (process.platform === 'win32') return { mode, unconfined: true }
+    return undefined
+  }
+
   /**
-   * Confined Windows calls cannot use the restricted-token runner (issue
-   * #1, see the file header): route them through the unconfined argv path
-   * and label the result honestly so callers can tell.
+   * Label one execution handle's foreground result without changing its
+   * identity (the parent's `decorateResult` is private to the shipped class, so
+   * the same memoized in-place wrapper lives here).
+   * @param ex the handle returned by `executeArgv`.
+   * @param sandbox sandbox facts to stamp onto the result.
+   * @returns the same handle, with `result()` mapped.
    */
+  static decorateExecution(ex, sandbox) {
+    const base = ex.result.bind(ex)
+    let decorated
+    ex.result = () => {
+      decorated ??= base().then((result) => ({ ...result, sandbox }))
+      return decorated
+    }
+    return ex
+  }
+
+  /**
+   * dsh 0.1.7 execution entry point (the shipped `ShellExecutor` now declares
+   * `execute(spec): Promise<ShellExecution>`; `run`/`start` were removed and
+   * background work is an `onExpiry: 'none'` execution the caller stops
+   * waiting on). Overriding it is what keeps the two Git Bash substitutions
+   * alive on the new host: without it the full-access branch spawns the bare
+   * `bash` name hardcoded in `LocalBashExecutor.execute`, and a Windows
+   * confined call goes back through the restricted-token runner MSYS2 cannot
+   * survive.
+   * On hosts without `execute` (<= 0.1.6) this method is never called by the
+   * runtime; it delegates to `run` so the class still behaves if it is.
+   * @param spec resolved execution settings and caller-owned command metadata.
+   * @returns the live execution handle.
+   */
+  execute(spec) {
+    if (typeof super.execute !== 'function') return this.run(spec)
+    const routed = this.withParityEnv(spec)
+    const route = this.gitBashRoute(routed)
+    if (route === undefined) return super.execute(routed)
+    const argv = [this.bashPath, '-c', routed.command]
+    if (route.unconfined) this.warnConfinedUnconfined(route.mode)
+    const sandbox = route.unconfined
+      ? { mode: route.mode, denied: false, enforcement: 'unconfined' }
+      : { mode: route.mode, denied: false }
+    // `executeArgv` is the shipped helper for exactly this: run an explicit
+    // argv with the executor's own lifecycle, output and deadline semantics.
+    return Promise.resolve(this.executeArgv(routed, argv))
+      .then((ex) => GitBashSandboxExecutor.decorateExecution(ex, sandbox))
+  }
+
   /**
    * Linux-parity environment for the MODEL's shell (v0.21.1). The official
    * shell-env registry accepts DSH_* facts only — registering anything else
@@ -146,10 +248,33 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
    * @param {object} spec the shell request
    * @returns {object} the request with the parity facts merged in
    */
-  withParityEnv(spec) {
+  /**
+   * The plugin row's live dialect settings, across eras. dsh 0.1.7 replaced the
+   * settings namespace API: the service still exists but exposes only
+   * `describe()` / `update()` — `get(ns)` is gone — so the old read silently
+   * returned undefined on the new host and the Linux-parity env below never
+   * applied. The new era reads the row Config's projected values from the form
+   * descriptors (the same read dsh-agent-lang uses for the `locale` namespace).
+   * @returns the row's settings object, or undefined when unavailable.
+   */
+  dialectSettings() {
     try {
       const settings = this.ctx && typeof this.ctx.get === 'function' ? this.ctx.get('settings') : undefined
-      const value = settings && typeof settings.get === 'function' ? settings.get('gitbash-shell') : undefined
+      if (settings === undefined || settings === null) return undefined
+      if (typeof settings.get === 'function') return settings.get(SETTINGS_NAMESPACE)
+      if (typeof settings.describe === 'function') {
+        const entry = settings.describe().find((row) => row !== null && typeof row === 'object' && row.ns === SETTINGS_NAMESPACE)
+        return entry === undefined ? undefined : entry.value
+      }
+      return undefined
+    } catch {
+      return undefined
+    }
+  }
+
+  withParityEnv(spec) {
+    try {
+      const value = this.dialectSettings()
       if (!value || value.posixPaths !== true || value.gitAutocrlf === false) return spec
       const dshEnv = {
         ...(spec.dshEnv === undefined ? {} : spec.dshEnv),
@@ -165,6 +290,13 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
     }
   }
 
+  /**
+   * 0.1.6-era full-access path with Git Bash argv: the parent's full-access
+   * branch delegates to LocalBashExecutor.run, which hardcodes the bare `bash`
+   * name, so override that branch here and keep everything else inherited.
+   * On 0.1.7+ the runtime calls `execute` above instead; this stays as the
+   * old-era entry point.
+   */
   async run(spec) {
     spec = this.withParityEnv(spec)
     const policy = spec.sandboxPolicy